Teams App Developer

import { ChatPrompt } from "@anthropic-ai/sdk"; // or teams-ai equivalent

const queryFunctions = [
  {
    name: "queryPtoRequests",
    description: "Query PTO/time-off requests. Use when the user asks about PTO, time off, vacation, leave, or days off.",
    parameters: {
      type: "object",
      properties: {
        status: {
          type: "string",
          enum: ["Pending", "Approved", "Rejected", "All"],
          description: "Filter by request status. Default: All",
        },
        requester: {
          type: "string",
          description: "Filter by requester name (partial match). Omit for all requesters.",
        },
        month: {
          type: "string",
          description: "Filter by month, e.g. '2024-03' for March 2024. Omit for all dates.",
        },
      },
    },
  },
  {
    name: "queryBreakStatus",
    description: "Query who is currently on break or break history. Use when the user asks about breaks, availability, or who is away.",
    parameters: {
      type: "object",
      properties: {
        currentOnly: {
          type: "boolean",
          description: "True to show only active breaks. False for break history.",
        },
        dateRange: {
          type: "object",
          properties: {
            start: { type: "string", description: "ISO date" },
            end: { type: "string", description: "ISO date" },
          },
        },
      },
    },
  },
  {
    name: "queryEquipmentBookings",
    description: "Query equipment reservations and availability. Use when the user asks about bookings, reservations, equipment, or availability.",
    parameters: {
      type: "object",
      properties: {
        item: { type: "string", description: "Equipment name or type to filter" },
        status: { type: "string", enum: ["Active", "Returned", "Overdue", "All"] },
        dateRange: {
          type: "object",
          properties: {
            start: { type: "string" },
            end: { type: "string" },
          },
        },
      },
    },
  },
];

async function queryPtoRequests(
  graphClient: Client,
  siteId: string,
  listId: string,
  params: { status?: string; requester?: string; month?: string }
): Promise<{ records: any[]; summary: string }> {
  const filters: string[] = [];

  if (params.status && params.status !== "All") {
    filters.push(`fields/Status eq '${params.status}'`);
  }

  if (params.month) {
    const start = `${params.month}-01`;
    const endDate = new Date(
      parseInt(params.month.split("-")[0]),
      parseInt(params.month.split("-")[1]),
      0
    );
    const end = endDate.toISOString().split("T")[0];
    filters.push(`fields/StartDate ge '${start}' and fields/StartDate le '${end}'`);
  }

  let query = graphClient
    .api(`/sites/${siteId}/lists/${listId}/items`)
    .expand("fields")
    .top(20)
    .orderby("fields/StartDate desc");

  if (filters.length > 0) {
    query = query.filter(filters.join(" and "));
  }

  const response = await query.get();
  const records = response.value.map((item: any) => ({
    id: item.id,
    requester: item.fields.Title,
    startDate: item.fields.StartDate,
    endDate: item.fields.EndDate,
    status: item.fields.Status,
    hoursRequested: item.fields.HoursRequested,
  }));

  // Filter requester client-side (OData doesn't support contains on all field types)
  const filtered = params.requester
    ? records.filter((r: any) =>
        r.requester.toLowerCase().includes(params.requester!.toLowerCase())
      )
    : records;

  // Build summary for LLM
  const summary = [
    `Found ${filtered.length} PTO request(s).`,
    params.status && params.status !== "All" ? `Status: ${params.status}.` : "",
    params.month ? `Month: ${params.month}.` : "",
    `Total hours: ${filtered.reduce((sum: number, r: any) => sum + (r.hoursRequested || 0), 0)}.`,
  ]
    .filter(Boolean)
    .join(" ");

  return { records: filtered, summary };
}

app.message(async (ctx) => {
  const userMessage = ctx.activity.text ?? "";

  // Send to LLM with function definitions
  const response = await openai.chat.completions.create({
    model: "gpt-4o",
    messages: [
      {
        role: "system",
        content:
          "You are a workflow assistant. Answer questions about PTO, breaks, equipment, and other workflow records. " +
          "Always use the provided functions to query real data. Never make up record counts or details.",
      },
      { role: "user", content: userMessage },
    ],
    tools: queryFunctions.map((f) => ({ type: "function", function: f })),
  });

  const choice = response.choices[0];

  if (choice.message.tool_calls?.length) {
    const toolCall = choice.message.tool_calls[0];
    const args = JSON.parse(toolCall.function.arguments);

    // Execute the query
    let result: { records: any[]; summary: string };
    switch (toolCall.function.name) {
      case "queryPtoRequests":
        result = await queryPtoRequests(graphClient, siteId, ptoListId, args);
        break;
      case "queryBreakStatus":
        result = await queryBreakStatus(graphClient, siteId, breakListId, args);
        break;
      case "queryEquipmentBookings":
        result = await queryEquipmentBookings(graphClient, siteId, equipListId, args);
        break;
      default:
        result = { records: [], summary: "Unknown query type." };
    }

    // Send result back to LLM for natural language response
    const followUp = await openai.chat.completions.create({
      model: "gpt-4o",
      messages: [
        { role: "system", content: "Summarize the query results naturally. Include counts and key details." },
        { role: "user", content: userMessage },
        choice.message,
        {
          role: "tool",
          tool_call_id: toolCall.id,
          content: result.summary,
        },
      ],
    });

    const textResponse = followUp.choices[0].message.content ?? "";

    // Send text summary + record cards
    await ctx.send(textResponse);

    if (result.records.length > 0 && result.records.length <= 5) {
      // Inline cards for small result sets
      for (const record of result.records) {
        await ctx.send({
          attachments: [{
            contentType: "application/vnd.microsoft.card.adaptive",
            content: buildRecordCard(record),
          }],
        });
      }
    } else if (result.records.length > 5) {
      // Summary card for large result sets
      await ctx.send({
        attachments: [{
          contentType: "application/vnd.microsoft.card.adaptive",
          content: buildRecordListCard(result.records.slice(0, 10)),
        }],
      });
    }
  } else {
    // No function call — direct response
    await ctx.send(choice.message.content ?? "I couldn't find relevant records for that query.");
  }
});

async function queryBreakStatus(
  graphClient: Client,
  siteId: string,
  listId: string,
  params: { currentOnly?: boolean; dateRange?: { start: string; end: string } }
): Promise<{ records: any[]; summary: string }> {
  const filters: string[] = [];

  if (params.currentOnly) {
    filters.push("fields/Status eq 'Active'");
  }

  if (params.dateRange) {
    filters.push(
      `fields/StartTime ge '${params.dateRange.start}' and fields/StartTime le '${params.dateRange.end}'`
    );
  }

  let query = graphClient
    .api(`/sites/${siteId}/lists/${listId}/items`)
    .expand("fields")
    .top(50);

  if (filters.length) query = query.filter(filters.join(" and "));

  const response = await query.get();
  const records = response.value.map((item: any) => item.fields);

  // Compute aggregates
  const activeBreaks = records.filter((r: any) => r.Status === "Active");
  const completedBreaks = records.filter((r: any) => r.Status === "Ended");
  const avgDuration =
    completedBreaks.length > 0
      ? completedBreaks.reduce((sum: number, r: any) => sum + (r.DurationMinutes || 0), 0) /
        completedBreaks.length
      : 0;

  const summary = [
    `Currently on break: ${activeBreaks.length} people.`,
    activeBreaks.map((r: any) => r.EmployeeName).join(", ") || "None.",
    completedBreaks.length > 0
      ? `Average break duration today: ${avgDuration.toFixed(1)} minutes.`
      : "",
  ]
    .filter(Boolean)
    .join(" ");

  return { records, summary };
}