@agenticmail/enterprise 0.5.325 → 0.5.327

package/dist/microsoft-YUT6EIGP.js

@@ -1,3400 +0,0 @@
-import {
-  errorResult,
-  jsonResult
-} from "./chunk-ZB3VC2MR.js";
-import "./chunk-KFQGP6VL.js";
-
-// src/agent-tools/tools/microsoft/graph-api.ts
-var GRAPH_BASE = "https://graph.microsoft.com/v1.0";
-async function graph(token, path, opts) {
-  const method = opts?.method || "GET";
-  const base = opts?.beta ? "https://graph.microsoft.com/beta" : GRAPH_BASE;
-  const url = new URL(base + path);
-  if (opts?.query) {
-    for (const [k, v] of Object.entries(opts.query)) {
-      if (v !== void 0 && v !== "") url.searchParams.set(k, v);
-    }
-  }
-  const headers = {
-    Authorization: `Bearer ${token}`,
-    ...opts?.headers
-  };
-  if (!opts?.rawBody && !opts?.headers?.["Content-Type"]) {
-    headers["Content-Type"] = "application/json";
-  }
-  const res = await fetch(url.toString(), {
-    method,
-    headers,
-    body: opts?.rawBody || (opts?.body ? JSON.stringify(opts.body) : void 0)
-  });
-  if (!res.ok) {
-    const err = await res.text();
-    throw new Error(`Microsoft Graph ${res.status}: ${err}`);
-  }
-  if (res.status === 204) return {};
-  const ct = res.headers.get("content-type") || "";
-  if (ct.includes("application/json")) return res.json();
-  return { content: await res.text() };
-}
-
-// src/agent-tools/tools/microsoft/outlook-mail.ts
-function createOutlookMailTools(config, _options) {
-  const tp = config.tokenProvider;
-  return [
-    {
-      name: "outlook_mail_list",
-      description: "List messages from Outlook mailbox. Returns recent emails from inbox or specified folder.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          folder: { type: "string", description: "Folder: inbox, sentitems, drafts, deleteditems, junkemail, or folder ID (default: inbox)" },
-          maxResults: { type: "number", description: "Max messages to return (default: 20, max: 50)" },
-          filter: { type: "string", description: `OData $filter expression (e.g., "isRead eq false", "from/emailAddress/address eq 'user@example.com'")` },
-          search: { type: "string", description: "Search query (searches subject, body, sender)" }
-        },
-        required: []
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const folder = params.folder || "inbox";
-          const top = Math.min(params.maxResults || 20, 50);
-          const query = {
-            "$top": String(top),
-            "$orderby": "receivedDateTime desc",
-            "$select": "id,subject,from,toRecipients,ccRecipients,receivedDateTime,isRead,hasAttachments,importance,bodyPreview,flag,conversationId"
-          };
-          if (params.filter) query["$filter"] = params.filter;
-          if (params.search) query["$search"] = `"${params.search}"`;
-          const data = await graph(token, `/me/mailFolders/${folder}/messages`, { query });
-          const messages = (data.value || []).map((m) => ({
-            id: m.id,
-            subject: m.subject,
-            from: m.from?.emailAddress?.address,
-            fromName: m.from?.emailAddress?.name,
-            to: m.toRecipients?.map((r) => r.emailAddress?.address),
-            cc: m.ccRecipients?.map((r) => r.emailAddress?.address),
-            date: m.receivedDateTime,
-            isRead: m.isRead,
-            hasAttachments: m.hasAttachments,
-            importance: m.importance,
-            preview: m.bodyPreview,
-            flagged: m.flag?.flagStatus === "flagged",
-            conversationId: m.conversationId
-          }));
-          return jsonResult({ messages, count: messages.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_mail_read",
-      description: "Read a specific email message by ID. Returns full body, headers, and attachment list.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          messageId: { type: "string", description: "Message ID to read" },
-          markAsRead: { type: "boolean", description: "Mark as read when opening (default: true)" }
-        },
-        required: ["messageId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const msg = await graph(token, `/me/messages/${params.messageId}`, {
-            query: { "$select": "id,subject,from,toRecipients,ccRecipients,bccRecipients,replyTo,receivedDateTime,sentDateTime,isRead,hasAttachments,importance,body,flag,conversationId,internetMessageId,parentFolderId" }
-          });
-          if (params.markAsRead !== false && !msg.isRead) {
-            graph(token, `/me/messages/${params.messageId}`, { method: "PATCH", body: { isRead: true } }).catch(() => {
-            });
-          }
-          let attachments = [];
-          if (msg.hasAttachments) {
-            const att = await graph(token, `/me/messages/${params.messageId}/attachments`, {
-              query: { "$select": "id,name,contentType,size,isInline" }
-            });
-            attachments = (att.value || []).map((a) => ({
-              id: a.id,
-              name: a.name,
-              contentType: a.contentType,
-              size: a.size,
-              isInline: a.isInline
-            }));
-          }
-          return jsonResult({
-            id: msg.id,
-            subject: msg.subject,
-            from: msg.from?.emailAddress?.address,
-            fromName: msg.from?.emailAddress?.name,
-            to: msg.toRecipients?.map((r) => ({ email: r.emailAddress?.address, name: r.emailAddress?.name })),
-            cc: msg.ccRecipients?.map((r) => ({ email: r.emailAddress?.address, name: r.emailAddress?.name })),
-            bcc: msg.bccRecipients?.map((r) => ({ email: r.emailAddress?.address, name: r.emailAddress?.name })),
-            replyTo: msg.replyTo?.map((r) => r.emailAddress?.address),
-            date: msg.receivedDateTime,
-            sentDate: msg.sentDateTime,
-            body: msg.body?.content,
-            bodyType: msg.body?.contentType,
-            isRead: msg.isRead,
-            importance: msg.importance,
-            attachments,
-            conversationId: msg.conversationId,
-            internetMessageId: msg.internetMessageId
-          });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_mail_send",
-      description: "Send an email via Outlook. Supports to, cc, bcc, HTML body, importance, and reply-to.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          to: { type: "string", description: "Recipient email(s), comma-separated" },
-          subject: { type: "string", description: "Email subject" },
-          body: { type: "string", description: "Email body (HTML or plain text)" },
-          cc: { type: "string", description: "CC recipients, comma-separated" },
-          bcc: { type: "string", description: "BCC recipients, comma-separated" },
-          importance: { type: "string", description: "low, normal, or high (default: normal)" },
-          isHtml: { type: "boolean", description: "Whether body is HTML (default: false)" },
-          replyTo: { type: "string", description: "Reply-to address" },
-          saveToSent: { type: "boolean", description: "Save to Sent Items (default: true)" }
-        },
-        required: ["to", "subject", "body"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const toRecipients = params.to.split(",").map((e) => ({
-            emailAddress: { address: e.trim() }
-          }));
-          const message = {
-            subject: params.subject,
-            body: { contentType: params.isHtml ? "HTML" : "Text", content: params.body },
-            toRecipients
-          };
-          if (params.cc) message.ccRecipients = params.cc.split(",").map((e) => ({ emailAddress: { address: e.trim() } }));
-          if (params.bcc) message.bccRecipients = params.bcc.split(",").map((e) => ({ emailAddress: { address: e.trim() } }));
-          if (params.importance) message.importance = params.importance;
-          if (params.replyTo) message.replyTo = [{ emailAddress: { address: params.replyTo } }];
-          await graph(token, "/me/sendMail", {
-            method: "POST",
-            body: { message, saveToSentItems: params.saveToSent !== false }
-          });
-          return jsonResult({ sent: true, to: params.to, subject: params.subject });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_mail_reply",
-      description: "Reply to an email message. Can reply to sender only or reply-all.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          messageId: { type: "string", description: "Message ID to reply to" },
-          body: { type: "string", description: "Reply body text" },
-          replyAll: { type: "boolean", description: "Reply to all recipients (default: false)" },
-          isHtml: { type: "boolean", description: "Whether body is HTML (default: false)" }
-        },
-        required: ["messageId", "body"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const action = params.replyAll ? "replyAll" : "reply";
-          await graph(token, `/me/messages/${params.messageId}/${action}`, {
-            method: "POST",
-            body: { comment: params.body }
-          });
-          return jsonResult({ replied: true, messageId: params.messageId, replyAll: !!params.replyAll });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_mail_forward",
-      description: "Forward an email message to another recipient.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          messageId: { type: "string", description: "Message ID to forward" },
-          to: { type: "string", description: "Forward recipient email(s), comma-separated" },
-          comment: { type: "string", description: "Optional comment to add above the forwarded message" }
-        },
-        required: ["messageId", "to"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const toRecipients = params.to.split(",").map((e) => ({ emailAddress: { address: e.trim() } }));
-          await graph(token, `/me/messages/${params.messageId}/forward`, {
-            method: "POST",
-            body: { comment: params.comment || "", toRecipients }
-          });
-          return jsonResult({ forwarded: true, messageId: params.messageId, to: params.to });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_mail_move",
-      description: "Move a message to another folder.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          messageId: { type: "string", description: "Message ID to move" },
-          folder: { type: "string", description: "Destination folder: inbox, archive, deleteditems, junkemail, or folder ID" }
-        },
-        required: ["messageId", "folder"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const folderMap = {
-            inbox: "inbox",
-            archive: "archive",
-            trash: "deleteditems",
-            deleteditems: "deleteditems",
-            junk: "junkemail",
-            junkemail: "junkemail",
-            sent: "sentitems",
-            sentitems: "sentitems",
-            drafts: "drafts"
-          };
-          const destId = folderMap[params.folder.toLowerCase()] || params.folder;
-          const result = await graph(token, `/me/messages/${params.messageId}/move`, {
-            method: "POST",
-            body: { destinationId: destId }
-          });
-          return jsonResult({ moved: true, newId: result.id, folder: params.folder });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_mail_delete",
-      description: "Delete an email message (moves to Deleted Items).",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          messageId: { type: "string", description: "Message ID to delete" }
-        },
-        required: ["messageId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          await graph(token, `/me/messages/${params.messageId}`, { method: "DELETE" });
-          return jsonResult({ deleted: true, messageId: params.messageId });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_mail_update",
-      description: "Update message properties: mark as read/unread, flag, change importance, add categories.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          messageId: { type: "string", description: "Message ID to update" },
-          isRead: { type: "boolean", description: "Mark as read or unread" },
-          importance: { type: "string", description: "low, normal, or high" },
-          flag: { type: "string", description: "notFlagged, flagged, or complete" },
-          categories: { type: "array", items: { type: "string" }, description: "Category labels to apply" }
-        },
-        required: ["messageId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const body = {};
-          if (params.isRead !== void 0) body.isRead = params.isRead;
-          if (params.importance) body.importance = params.importance;
-          if (params.flag) body.flag = { flagStatus: params.flag };
-          if (params.categories) body.categories = params.categories;
-          await graph(token, `/me/messages/${params.messageId}`, { method: "PATCH", body });
-          return jsonResult({ updated: true, messageId: params.messageId });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_mail_search",
-      description: "Search emails across all folders using Microsoft Search. Supports natural language queries.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          query: { type: "string", description: 'Search query (natural language or KQL: "from:user@example.com subject:report")' },
-          maxResults: { type: "number", description: "Max results (default: 10, max: 25)" }
-        },
-        required: ["query"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const top = Math.min(params.maxResults || 10, 25);
-          const data = await graph(token, "/me/messages", {
-            query: {
-              "$search": `"${params.query}"`,
-              "$top": String(top),
-              "$select": "id,subject,from,receivedDateTime,bodyPreview,isRead,hasAttachments,importance"
-            }
-          });
-          const messages = (data.value || []).map((m) => ({
-            id: m.id,
-            subject: m.subject,
-            from: m.from?.emailAddress?.address,
-            fromName: m.from?.emailAddress?.name,
-            date: m.receivedDateTime,
-            preview: m.bodyPreview,
-            isRead: m.isRead,
-            hasAttachments: m.hasAttachments
-          }));
-          return jsonResult({ messages, count: messages.length, query: params.query });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_mail_draft",
-      description: "Create a draft email in Outlook. Can be edited and sent later.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          to: { type: "string", description: "Recipient email(s), comma-separated" },
-          subject: { type: "string", description: "Email subject" },
-          body: { type: "string", description: "Email body" },
-          cc: { type: "string", description: "CC recipients" },
-          isHtml: { type: "boolean", description: "Whether body is HTML" }
-        },
-        required: ["to", "subject", "body"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const message = {
-            subject: params.subject,
-            body: { contentType: params.isHtml ? "HTML" : "Text", content: params.body },
-            toRecipients: params.to.split(",").map((e) => ({ emailAddress: { address: e.trim() } }))
-          };
-          if (params.cc) message.ccRecipients = params.cc.split(",").map((e) => ({ emailAddress: { address: e.trim() } }));
-          const draft = await graph(token, "/me/messages", { method: "POST", body: message });
-          return jsonResult({ draftId: draft.id, subject: params.subject, status: "draft_created" });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_mail_send_draft",
-      description: "Send an existing draft email.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          messageId: { type: "string", description: "Draft message ID to send" }
-        },
-        required: ["messageId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          await graph(token, `/me/messages/${params.messageId}/send`, { method: "POST" });
-          return jsonResult({ sent: true, messageId: params.messageId });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_mail_folders",
-      description: "List mail folders in the mailbox.",
-      category: "utility",
-      parameters: { type: "object", properties: {}, required: [] },
-      async execute(_id) {
-        try {
-          const token = await tp.getAccessToken();
-          const data = await graph(token, "/me/mailFolders", {
-            query: { "$top": "50", "$select": "id,displayName,totalItemCount,unreadItemCount,parentFolderId" }
-          });
-          const folders = (data.value || []).map((f) => ({
-            id: f.id,
-            name: f.displayName,
-            totalItems: f.totalItemCount,
-            unreadItems: f.unreadItemCount
-          }));
-          return jsonResult({ folders, count: folders.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_mail_attachment_download",
-      description: "Download an attachment from an email. Returns the attachment content as base64.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          messageId: { type: "string", description: "Message ID containing the attachment" },
-          attachmentId: { type: "string", description: "Attachment ID to download" }
-        },
-        required: ["messageId", "attachmentId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const att = await graph(token, `/me/messages/${params.messageId}/attachments/${params.attachmentId}`);
-          return jsonResult({
-            name: att.name,
-            contentType: att.contentType,
-            size: att.size,
-            content: att.contentBytes
-            // base64 encoded
-          });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    }
-  ];
-}
-
-// src/agent-tools/tools/microsoft/outlook-calendar.ts
-function createOutlookCalendarTools(config, _options) {
-  const tp = config.tokenProvider;
-  return [
-    {
-      name: "outlook_calendar_list",
-      description: "List all calendars the agent has access to.",
-      category: "utility",
-      parameters: { type: "object", properties: {}, required: [] },
-      async execute(_id) {
-        try {
-          const token = await tp.getAccessToken();
-          const data = await graph(token, "/me/calendars");
-          const cals = (data.value || []).map((c) => ({
-            id: c.id,
-            name: c.name,
-            color: c.color,
-            isDefaultCalendar: c.isDefaultCalendar,
-            canEdit: c.canEdit,
-            owner: c.owner?.address
-          }));
-          return jsonResult({ calendars: cals, count: cals.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_calendar_events",
-      description: "List upcoming events from a calendar. Defaults to the primary calendar.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          calendarId: { type: "string", description: "Calendar ID (omit for default calendar)" },
-          timeMin: { type: "string", description: "Start of time range (ISO 8601, default: now)" },
-          timeMax: { type: "string", description: "End of time range (ISO 8601, default: +7 days)" },
-          maxResults: { type: "number", description: "Max events (default: 20)" }
-        },
-        required: []
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const now = /* @__PURE__ */ new Date();
-          const timeMin = params.timeMin || now.toISOString();
-          const weekLater = new Date(now.getTime() + 7 * 864e5);
-          const timeMax = params.timeMax || weekLater.toISOString();
-          const top = params.maxResults || 20;
-          const basePath = params.calendarId ? `/me/calendars/${params.calendarId}/calendarView` : "/me/calendarView";
-          const data = await graph(token, basePath, {
-            query: {
-              startDateTime: timeMin,
-              endDateTime: timeMax,
-              "$top": String(top),
-              "$orderby": "start/dateTime",
-              "$select": "id,subject,start,end,location,organizer,attendees,isAllDay,isCancelled,showAs,importance,bodyPreview,onlineMeeting,webLink"
-            }
-          });
-          const events = (data.value || []).map((e) => ({
-            id: e.id,
-            subject: e.subject,
-            start: e.start?.dateTime,
-            startTimeZone: e.start?.timeZone,
-            end: e.end?.dateTime,
-            endTimeZone: e.end?.timeZone,
-            isAllDay: e.isAllDay,
-            location: e.location?.displayName,
-            organizer: e.organizer?.emailAddress?.address,
-            attendees: e.attendees?.map((a) => ({
-              email: a.emailAddress?.address,
-              name: a.emailAddress?.name,
-              status: a.status?.response,
-              type: a.type
-            })),
-            showAs: e.showAs,
-            isCancelled: e.isCancelled,
-            preview: e.bodyPreview,
-            meetingUrl: e.onlineMeeting?.joinUrl,
-            webLink: e.webLink
-          }));
-          return jsonResult({ events, count: events.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_calendar_create",
-      description: "Create a new calendar event. Supports attendees, location, online meeting (Teams), and recurrence.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          subject: { type: "string", description: "Event subject/title" },
-          start: { type: "string", description: "Start time (ISO 8601)" },
-          end: { type: "string", description: "End time (ISO 8601)" },
-          timeZone: { type: "string", description: "Time zone (default: UTC)" },
-          location: { type: "string", description: "Location name" },
-          body: { type: "string", description: "Event body/description" },
-          attendees: { type: "string", description: "Attendee emails, comma-separated" },
-          isOnlineMeeting: { type: "boolean", description: "Create a Teams meeting link (default: false)" },
-          isAllDay: { type: "boolean", description: "All-day event" },
-          importance: { type: "string", description: "low, normal, or high" },
-          reminderMinutes: { type: "number", description: "Reminder before event in minutes (default: 15)" },
-          calendarId: { type: "string", description: "Calendar ID (omit for default)" }
-        },
-        required: ["subject", "start", "end"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const tz = params.timeZone || "UTC";
-          const event = {
-            subject: params.subject,
-            start: { dateTime: params.start, timeZone: tz },
-            end: { dateTime: params.end, timeZone: tz }
-          };
-          if (params.location) event.location = { displayName: params.location };
-          if (params.body) event.body = { contentType: "HTML", content: params.body };
-          if (params.attendees) {
-            event.attendees = params.attendees.split(",").map((e) => ({
-              emailAddress: { address: e.trim() },
-              type: "required"
-            }));
-          }
-          if (params.isOnlineMeeting) {
-            event.isOnlineMeeting = true;
-            event.onlineMeetingProvider = "teamsForBusiness";
-          }
-          if (params.isAllDay) event.isAllDay = true;
-          if (params.importance) event.importance = params.importance;
-          if (params.reminderMinutes !== void 0) {
-            event.isReminderOn = true;
-            event.reminderMinutesBefore = params.reminderMinutes;
-          }
-          const basePath = params.calendarId ? `/me/calendars/${params.calendarId}/events` : "/me/events";
-          const created = await graph(token, basePath, { method: "POST", body: event });
-          return jsonResult({
-            id: created.id,
-            subject: created.subject,
-            start: created.start?.dateTime,
-            end: created.end?.dateTime,
-            meetingUrl: created.onlineMeeting?.joinUrl,
-            webLink: created.webLink
-          });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_calendar_update",
-      description: "Update an existing calendar event.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          eventId: { type: "string", description: "Event ID to update" },
-          subject: { type: "string", description: "New subject" },
-          start: { type: "string", description: "New start time (ISO 8601)" },
-          end: { type: "string", description: "New end time (ISO 8601)" },
-          timeZone: { type: "string", description: "Time zone" },
-          location: { type: "string", description: "New location" },
-          body: { type: "string", description: "New body content" }
-        },
-        required: ["eventId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const update = {};
-          if (params.subject) update.subject = params.subject;
-          if (params.start) update.start = { dateTime: params.start, timeZone: params.timeZone || "UTC" };
-          if (params.end) update.end = { dateTime: params.end, timeZone: params.timeZone || "UTC" };
-          if (params.location) update.location = { displayName: params.location };
-          if (params.body) update.body = { contentType: "HTML", content: params.body };
-          const updated = await graph(token, `/me/events/${params.eventId}`, { method: "PATCH", body: update });
-          return jsonResult({ id: updated.id, subject: updated.subject, updated: true });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_calendar_delete",
-      description: "Delete a calendar event.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          eventId: { type: "string", description: "Event ID to delete" }
-        },
-        required: ["eventId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          await graph(token, `/me/events/${params.eventId}`, { method: "DELETE" });
-          return jsonResult({ deleted: true, eventId: params.eventId });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_calendar_respond",
-      description: "Respond to a calendar event invitation (accept, tentatively accept, or decline).",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          eventId: { type: "string", description: "Event ID to respond to" },
-          response: { type: "string", description: "accept, tentativelyAccept, or decline" },
-          comment: { type: "string", description: "Optional response message" },
-          sendResponse: { type: "boolean", description: "Send response to organizer (default: true)" }
-        },
-        required: ["eventId", "response"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const body = { sendResponse: params.sendResponse !== false };
-          if (params.comment) body.comment = params.comment;
-          await graph(token, `/me/events/${params.eventId}/${params.response}`, { method: "POST", body });
-          return jsonResult({ responded: true, eventId: params.eventId, response: params.response });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_calendar_freebusy",
-      description: "Check free/busy availability for one or more users.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          emails: { type: "string", description: "Email addresses to check, comma-separated" },
-          start: { type: "string", description: "Start of range (ISO 8601)" },
-          end: { type: "string", description: "End of range (ISO 8601)" },
-          timeZone: { type: "string", description: "Time zone (default: UTC)" }
-        },
-        required: ["emails", "start", "end"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const schedules = params.emails.split(",").map((e) => e.trim());
-          const data = await graph(token, "/me/calendar/getSchedule", {
-            method: "POST",
-            body: {
-              schedules,
-              startTime: { dateTime: params.start, timeZone: params.timeZone || "UTC" },
-              endTime: { dateTime: params.end, timeZone: params.timeZone || "UTC" },
-              availabilityViewInterval: 30
-            }
-          });
-          const results = (data.value || []).map((s) => ({
-            email: s.scheduleId,
-            availability: s.availabilityView,
-            items: s.scheduleItems?.map((i) => ({
-              status: i.status,
-              subject: i.subject,
-              start: i.start?.dateTime,
-              end: i.end?.dateTime
-            }))
-          }));
-          return jsonResult({ schedules: results });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    }
-  ];
-}
-
-// src/agent-tools/tools/microsoft/onedrive.ts
-function createOneDriveTools(config, _options) {
-  const tp = config.tokenProvider;
-  return [
-    {
-      name: "onedrive_list",
-      description: "List files and folders in OneDrive. Defaults to root folder.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          path: { type: "string", description: 'Folder path (e.g., "/Documents/Reports") or item ID. Default: root' },
-          maxResults: { type: "number", description: "Max items to return (default: 50)" }
-        },
-        required: []
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const top = params.maxResults || 50;
-          const basePath = params.path ? `/me/drive/root:${params.path}:/children` : "/me/drive/root/children";
-          const data = await graph(token, basePath, {
-            query: { "$top": String(top), "$select": "id,name,size,createdDateTime,lastModifiedDateTime,webUrl,folder,file,parentReference" }
-          });
-          const items = (data.value || []).map((i) => ({
-            id: i.id,
-            name: i.name,
-            size: i.size,
-            type: i.folder ? "folder" : "file",
-            mimeType: i.file?.mimeType,
-            childCount: i.folder?.childCount,
-            created: i.createdDateTime,
-            modified: i.lastModifiedDateTime,
-            webUrl: i.webUrl,
-            path: i.parentReference?.path
-          }));
-          return jsonResult({ items, count: items.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "onedrive_search",
-      description: "Search for files in OneDrive by name or content.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          query: { type: "string", description: "Search query" },
-          maxResults: { type: "number", description: "Max results (default: 20)" }
-        },
-        required: ["query"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const top = params.maxResults || 20;
-          const data = await graph(token, `/me/drive/root/search(q='${encodeURIComponent(params.query)}')`, {
-            query: { "$top": String(top), "$select": "id,name,size,webUrl,file,folder,lastModifiedDateTime,parentReference" }
-          });
-          const items = (data.value || []).map((i) => ({
-            id: i.id,
-            name: i.name,
-            size: i.size,
-            type: i.folder ? "folder" : "file",
-            mimeType: i.file?.mimeType,
-            modified: i.lastModifiedDateTime,
-            webUrl: i.webUrl,
-            path: i.parentReference?.path
-          }));
-          return jsonResult({ items, count: items.length, query: params.query });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "onedrive_read",
-      description: "Read/download a file from OneDrive. For text files returns content; for binary returns download URL.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          itemId: { type: "string", description: "File item ID" },
-          path: { type: "string", description: 'File path (alternative to itemId, e.g., "/Documents/report.txt")' }
-        },
-        required: []
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const itemPath4 = params.itemId ? `/me/drive/items/${params.itemId}` : `/me/drive/root:${params.path}:`;
-          const meta = await graph(token, itemPath4, {
-            query: { "$select": "id,name,size,file,webUrl,@microsoft.graph.downloadUrl" }
-          });
-          const isText = meta.file?.mimeType?.startsWith("text/") || /\.(txt|md|csv|json|xml|html|css|js|ts|py|rb|go|rs|yaml|yml|toml|ini|cfg|log|sh|bat|ps1|sql)$/i.test(meta.name || "");
-          if (isText && meta.size < 1048576) {
-            const contentRes = await fetch(meta["@microsoft.graph.downloadUrl"] || `https://graph.microsoft.com/v1.0${itemPath4}/content`, {
-              headers: { Authorization: `Bearer ${token}` }
-            });
-            const content = await contentRes.text();
-            return jsonResult({ id: meta.id, name: meta.name, size: meta.size, content });
-          }
-          return jsonResult({
-            id: meta.id,
-            name: meta.name,
-            size: meta.size,
-            mimeType: meta.file?.mimeType,
-            downloadUrl: meta["@microsoft.graph.downloadUrl"],
-            webUrl: meta.webUrl
-          });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "onedrive_upload",
-      description: "Upload a text file to OneDrive. For small files (< 4MB).",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          path: { type: "string", description: 'Destination path (e.g., "/Documents/report.md")' },
-          content: { type: "string", description: "File content (text)" },
-          conflictBehavior: { type: "string", description: "rename, replace, or fail (default: replace)" }
-        },
-        required: ["path", "content"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const conflict = params.conflictBehavior || "replace";
-          const res = await fetch(`https://graph.microsoft.com/v1.0/me/drive/root:${params.path}:/content?@microsoft.graph.conflictBehavior=${conflict}`, {
-            method: "PUT",
-            headers: { Authorization: `Bearer ${token}`, "Content-Type": "text/plain" },
-            body: params.content
-          });
-          if (!res.ok) throw new Error(`Upload failed: ${res.status} ${await res.text()}`);
-          const data = await res.json();
-          return jsonResult({ id: data.id, name: data.name, size: data.size, webUrl: data.webUrl });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "onedrive_create_folder",
-      description: "Create a new folder in OneDrive.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          name: { type: "string", description: "Folder name" },
-          parentPath: { type: "string", description: "Parent folder path (default: root)" }
-        },
-        required: ["name"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const parentPath = params.parentPath ? `/me/drive/root:${params.parentPath}:/children` : "/me/drive/root/children";
-          const folder = await graph(token, parentPath, {
-            method: "POST",
-            body: { name: params.name, folder: {}, "@microsoft.graph.conflictBehavior": "rename" }
-          });
-          return jsonResult({ id: folder.id, name: folder.name, webUrl: folder.webUrl });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "onedrive_delete",
-      description: "Delete a file or folder from OneDrive.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          itemId: { type: "string", description: "Item ID to delete" }
-        },
-        required: ["itemId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          await graph(token, `/me/drive/items/${params.itemId}`, { method: "DELETE" });
-          return jsonResult({ deleted: true, itemId: params.itemId });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "onedrive_share",
-      description: "Create a sharing link for a file or folder.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          itemId: { type: "string", description: "Item ID to share" },
-          type: { type: "string", description: "view or edit (default: view)" },
-          scope: { type: "string", description: "anonymous (anyone) or organization (default: organization)" }
-        },
-        required: ["itemId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const link = await graph(token, `/me/drive/items/${params.itemId}/createLink`, {
-            method: "POST",
-            body: { type: params.type || "view", scope: params.scope || "organization" }
-          });
-          return jsonResult({ url: link.link?.webUrl, type: link.link?.type, scope: link.link?.scope });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    }
-  ];
-}
-
-// src/agent-tools/tools/microsoft/teams.ts
-function createTeamsTools(config, _options) {
-  const tp = config.tokenProvider;
-  return [
-    {
-      name: "teams_list_teams",
-      description: "List all Teams the agent is a member of.",
-      category: "utility",
-      parameters: { type: "object", properties: {}, required: [] },
-      async execute(_id) {
-        try {
-          const token = await tp.getAccessToken();
-          const data = await graph(token, "/me/joinedTeams", {
-            query: { "$select": "id,displayName,description" }
-          });
-          const teams = (data.value || []).map((t) => ({
-            id: t.id,
-            name: t.displayName,
-            description: t.description
-          }));
-          return jsonResult({ teams, count: teams.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "teams_list_channels",
-      description: "List channels in a Team.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          teamId: { type: "string", description: "Team ID" }
-        },
-        required: ["teamId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const data = await graph(token, `/teams/${params.teamId}/channels`, {
-            query: { "$select": "id,displayName,description,membershipType" }
-          });
-          const channels = (data.value || []).map((c) => ({
-            id: c.id,
-            name: c.displayName,
-            description: c.description,
-            membershipType: c.membershipType
-          }));
-          return jsonResult({ channels, count: channels.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "teams_send_channel_message",
-      description: "Send a message to a Teams channel.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          teamId: { type: "string", description: "Team ID" },
-          channelId: { type: "string", description: "Channel ID" },
-          message: { type: "string", description: "Message content (supports HTML)" },
-          isHtml: { type: "boolean", description: "Whether message is HTML (default: false)" }
-        },
-        required: ["teamId", "channelId", "message"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const msg = await graph(token, `/teams/${params.teamId}/channels/${params.channelId}/messages`, {
-            method: "POST",
-            body: {
-              body: {
-                contentType: params.isHtml ? "html" : "text",
-                content: params.message
-              }
-            }
-          });
-          return jsonResult({ id: msg.id, sent: true });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "teams_read_channel_messages",
-      description: "Read recent messages from a Teams channel.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          teamId: { type: "string", description: "Team ID" },
-          channelId: { type: "string", description: "Channel ID" },
-          maxResults: { type: "number", description: "Max messages (default: 20)" }
-        },
-        required: ["teamId", "channelId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const data = await graph(token, `/teams/${params.teamId}/channels/${params.channelId}/messages`, {
-            query: { "$top": String(params.maxResults || 20) }
-          });
-          const messages = (data.value || []).map((m) => ({
-            id: m.id,
-            from: m.from?.user?.displayName || m.from?.application?.displayName,
-            fromEmail: m.from?.user?.email,
-            body: m.body?.content,
-            bodyType: m.body?.contentType,
-            date: m.createdDateTime,
-            importance: m.importance,
-            replyCount: m.replies?.length
-          }));
-          return jsonResult({ messages, count: messages.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "teams_list_chats",
-      description: "List the agent's 1:1 and group chats in Teams.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          maxResults: { type: "number", description: "Max chats to return (default: 20)" }
-        },
-        required: []
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const data = await graph(token, "/me/chats", {
-            query: {
-              "$top": String(params.maxResults || 20),
-              "$select": "id,topic,chatType,createdDateTime,lastUpdatedDateTime",
-              "$orderby": "lastUpdatedDateTime desc"
-            }
-          });
-          const chats = (data.value || []).map((c) => ({
-            id: c.id,
-            topic: c.topic,
-            type: c.chatType,
-            created: c.createdDateTime,
-            lastUpdated: c.lastUpdatedDateTime
-          }));
-          return jsonResult({ chats, count: chats.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "teams_send_chat_message",
-      description: "Send a message in a Teams 1:1 or group chat.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          chatId: { type: "string", description: "Chat ID" },
-          message: { type: "string", description: "Message content" },
-          isHtml: { type: "boolean", description: "Whether message is HTML (default: false)" }
-        },
-        required: ["chatId", "message"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const msg = await graph(token, `/chats/${params.chatId}/messages`, {
-            method: "POST",
-            body: {
-              body: { contentType: params.isHtml ? "html" : "text", content: params.message }
-            }
-          });
-          return jsonResult({ id: msg.id, sent: true });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "teams_read_chat_messages",
-      description: "Read recent messages from a Teams chat.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          chatId: { type: "string", description: "Chat ID" },
-          maxResults: { type: "number", description: "Max messages (default: 20)" }
-        },
-        required: ["chatId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const data = await graph(token, `/chats/${params.chatId}/messages`, {
-            query: { "$top": String(params.maxResults || 20), "$orderby": "createdDateTime desc" }
-          });
-          const messages = (data.value || []).map((m) => ({
-            id: m.id,
-            from: m.from?.user?.displayName,
-            body: m.body?.content,
-            bodyType: m.body?.contentType,
-            date: m.createdDateTime
-          }));
-          return jsonResult({ messages, count: messages.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "teams_presence",
-      description: "Get presence/availability status for users.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          userIds: { type: "string", description: 'User IDs, comma-separated (use "me" for self)' }
-        },
-        required: ["userIds"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          if (params.userIds === "me") {
-            const p = await graph(token, "/me/presence");
-            return jsonResult({ presence: [{ availability: p.availability, activity: p.activity }] });
-          }
-          const ids = params.userIds.split(",").map((s) => s.trim());
-          const data = await graph(token, "/communications/getPresencesByUserId", {
-            method: "POST",
-            body: { ids }
-          });
-          const presence = (data.value || []).map((p) => ({
-            userId: p.id,
-            availability: p.availability,
-            activity: p.activity
-          }));
-          return jsonResult({ presence });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    }
-  ];
-}
-
-// src/agent-tools/tools/microsoft/todo.ts
-function createTodoTools(config, _options) {
-  const tp = config.tokenProvider;
-  return [
-    {
-      name: "todo_list_lists",
-      description: "List all To Do task lists.",
-      category: "utility",
-      parameters: { type: "object", properties: {}, required: [] },
-      async execute(_id) {
-        try {
-          const token = await tp.getAccessToken();
-          const data = await graph(token, "/me/todo/lists");
-          const lists = (data.value || []).map((l) => ({
-            id: l.id,
-            name: l.displayName,
-            isOwner: l.isOwner,
-            wellknownName: l.wellknownListName
-          }));
-          return jsonResult({ lists, count: lists.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "todo_list_tasks",
-      description: "List tasks in a To Do list.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          listId: { type: "string", description: "Task list ID" },
-          includeCompleted: { type: "boolean", description: "Include completed tasks (default: false)" },
-          maxResults: { type: "number", description: "Max tasks (default: 50)" }
-        },
-        required: ["listId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const query = {
-            "$top": String(params.maxResults || 50),
-            "$orderby": "importance desc,createdDateTime desc",
-            "$select": "id,title,body,status,importance,createdDateTime,lastModifiedDateTime,dueDateTime,completedDateTime,isReminderOn,reminderDateTime"
-          };
-          if (!params.includeCompleted) query["$filter"] = "status ne 'completed'";
-          const data = await graph(token, `/me/todo/lists/${params.listId}/tasks`, { query });
-          const tasks = (data.value || []).map((t) => ({
-            id: t.id,
-            title: t.title,
-            body: t.body?.content,
-            bodyType: t.body?.contentType,
-            status: t.status,
-            importance: t.importance,
-            created: t.createdDateTime,
-            modified: t.lastModifiedDateTime,
-            dueDate: t.dueDateTime?.dateTime,
-            dueTimeZone: t.dueDateTime?.timeZone,
-            completedDate: t.completedDateTime?.dateTime,
-            hasReminder: t.isReminderOn
-          }));
-          return jsonResult({ tasks, count: tasks.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "todo_create_task",
-      description: "Create a new task in a To Do list.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          listId: { type: "string", description: "Task list ID" },
-          title: { type: "string", description: "Task title" },
-          body: { type: "string", description: "Task notes/description" },
-          dueDate: { type: "string", description: 'Due date (ISO 8601 date, e.g., "2026-03-15")' },
-          importance: { type: "string", description: "low, normal, or high (default: normal)" },
-          reminderDateTime: { type: "string", description: "Reminder date/time (ISO 8601)" }
-        },
-        required: ["listId", "title"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const task = { title: params.title };
-          if (params.body) task.body = { contentType: "text", content: params.body };
-          if (params.dueDate) task.dueDateTime = { dateTime: params.dueDate + "T00:00:00", timeZone: "UTC" };
-          if (params.importance) task.importance = params.importance;
-          if (params.reminderDateTime) {
-            task.isReminderOn = true;
-            task.reminderDateTime = { dateTime: params.reminderDateTime, timeZone: "UTC" };
-          }
-          const created = await graph(token, `/me/todo/lists/${params.listId}/tasks`, { method: "POST", body: task });
-          return jsonResult({ id: created.id, title: created.title, status: created.status });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "todo_update_task",
-      description: "Update an existing To Do task (title, status, due date, importance).",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          listId: { type: "string", description: "Task list ID" },
-          taskId: { type: "string", description: "Task ID" },
-          title: { type: "string", description: "New title" },
-          status: { type: "string", description: "notStarted, inProgress, completed, waitingOnOthers, deferred" },
-          importance: { type: "string", description: "low, normal, or high" },
-          dueDate: { type: "string", description: "New due date (ISO 8601 date)" },
-          body: { type: "string", description: "New task notes" }
-        },
-        required: ["listId", "taskId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const update = {};
-          if (params.title) update.title = params.title;
-          if (params.status) update.status = params.status;
-          if (params.importance) update.importance = params.importance;
-          if (params.dueDate) update.dueDateTime = { dateTime: params.dueDate + "T00:00:00", timeZone: "UTC" };
-          if (params.body) update.body = { contentType: "text", content: params.body };
-          const updated = await graph(token, `/me/todo/lists/${params.listId}/tasks/${params.taskId}`, {
-            method: "PATCH",
-            body: update
-          });
-          return jsonResult({ id: updated.id, title: updated.title, status: updated.status, updated: true });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "todo_delete_task",
-      description: "Delete a To Do task.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          listId: { type: "string", description: "Task list ID" },
-          taskId: { type: "string", description: "Task ID to delete" }
-        },
-        required: ["listId", "taskId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          await graph(token, `/me/todo/lists/${params.listId}/tasks/${params.taskId}`, { method: "DELETE" });
-          return jsonResult({ deleted: true, taskId: params.taskId });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "todo_create_list",
-      description: "Create a new To Do task list.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          name: { type: "string", description: "List name" }
-        },
-        required: ["name"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const list = await graph(token, "/me/todo/lists", {
-            method: "POST",
-            body: { displayName: params.name }
-          });
-          return jsonResult({ id: list.id, name: list.displayName });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    }
-  ];
-}
-
-// src/agent-tools/tools/microsoft/contacts.ts
-function createOutlookContactsTools(config, _options) {
-  const tp = config.tokenProvider;
-  return [
-    {
-      name: "outlook_contacts_list",
-      description: "List contacts from the Outlook address book.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          maxResults: { type: "number", description: "Max contacts (default: 50)" },
-          search: { type: "string", description: "Search by name or email" }
-        },
-        required: []
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const query = {
-            "$top": String(params.maxResults || 50),
-            "$select": "id,displayName,givenName,surname,emailAddresses,mobilePhone,businessPhones,companyName,jobTitle",
-            "$orderby": "displayName"
-          };
-          if (params.search) query["$filter"] = `startswith(displayName,'${params.search}') or startswith(givenName,'${params.search}') or startswith(surname,'${params.search}')`;
-          const data = await graph(token, "/me/contacts", { query });
-          const contacts = (data.value || []).map((c) => ({
-            id: c.id,
-            name: c.displayName,
-            firstName: c.givenName,
-            lastName: c.surname,
-            emails: c.emailAddresses?.map((e) => e.address),
-            mobile: c.mobilePhone,
-            phones: c.businessPhones,
-            company: c.companyName,
-            jobTitle: c.jobTitle
-          }));
-          return jsonResult({ contacts, count: contacts.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_contacts_create",
-      description: "Create a new contact in Outlook.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          firstName: { type: "string", description: "First name" },
-          lastName: { type: "string", description: "Last name" },
-          email: { type: "string", description: "Email address" },
-          mobile: { type: "string", description: "Mobile phone number" },
-          company: { type: "string", description: "Company name" },
-          jobTitle: { type: "string", description: "Job title" },
-          notes: { type: "string", description: "Personal notes" }
-        },
-        required: ["firstName", "email"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const contact = {
-            givenName: params.firstName,
-            emailAddresses: [{ address: params.email, name: `${params.firstName} ${params.lastName || ""}`.trim() }]
-          };
-          if (params.lastName) contact.surname = params.lastName;
-          if (params.mobile) contact.mobilePhone = params.mobile;
-          if (params.company) contact.companyName = params.company;
-          if (params.jobTitle) contact.jobTitle = params.jobTitle;
-          if (params.notes) contact.personalNotes = params.notes;
-          const created = await graph(token, "/me/contacts", { method: "POST", body: contact });
-          return jsonResult({ id: created.id, name: created.displayName, email: params.email });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_contacts_update",
-      description: "Update an existing contact.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          contactId: { type: "string", description: "Contact ID" },
-          firstName: { type: "string", description: "First name" },
-          lastName: { type: "string", description: "Last name" },
-          email: { type: "string", description: "Email address" },
-          mobile: { type: "string", description: "Mobile phone" },
-          company: { type: "string", description: "Company name" },
-          jobTitle: { type: "string", description: "Job title" }
-        },
-        required: ["contactId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const update = {};
-          if (params.firstName) update.givenName = params.firstName;
-          if (params.lastName) update.surname = params.lastName;
-          if (params.email) update.emailAddresses = [{ address: params.email }];
-          if (params.mobile) update.mobilePhone = params.mobile;
-          if (params.company) update.companyName = params.company;
-          if (params.jobTitle) update.jobTitle = params.jobTitle;
-          await graph(token, `/me/contacts/${params.contactId}`, { method: "PATCH", body: update });
-          return jsonResult({ updated: true, contactId: params.contactId });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_contacts_delete",
-      description: "Delete a contact from Outlook.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          contactId: { type: "string", description: "Contact ID to delete" }
-        },
-        required: ["contactId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          await graph(token, `/me/contacts/${params.contactId}`, { method: "DELETE" });
-          return jsonResult({ deleted: true, contactId: params.contactId });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_people_search",
-      description: "Search for people relevant to the user (contacts, colleagues, recent correspondents).",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          query: { type: "string", description: "Search query (name or email)" },
-          maxResults: { type: "number", description: "Max results (default: 10)" }
-        },
-        required: ["query"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const data = await graph(token, "/me/people", {
-            query: {
-              "$search": `"${params.query}"`,
-              "$top": String(params.maxResults || 10),
-              "$select": "id,displayName,givenName,surname,emailAddresses,companyName,jobTitle,department"
-            }
-          });
-          const people = (data.value || []).map((p) => ({
-            id: p.id,
-            name: p.displayName,
-            firstName: p.givenName,
-            lastName: p.surname,
-            emails: p.emailAddresses?.map((e) => e.address),
-            company: p.companyName,
-            jobTitle: p.jobTitle,
-            department: p.department
-          }));
-          return jsonResult({ people, count: people.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    }
-  ];
-}
-
-// src/agent-tools/tools/microsoft/excel.ts
-function itemPath(p) {
-  if (p.driveId && p.itemId) return `/drives/${p.driveId}/items/${p.itemId}`;
-  if (p.itemId) return `/me/drive/items/${p.itemId}`;
-  if (p.path) return `/me/drive/root:${p.path}:`;
-  throw new Error("Provide itemId or path to the Excel file");
-}
-function createExcelTools(config, _options) {
-  const tp = config.tokenProvider;
-  return [
-    {
-      name: "excel_list_worksheets",
-      description: "List all worksheets in an Excel workbook.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          itemId: { type: "string", description: "OneDrive/SharePoint item ID of the Excel file" },
-          path: { type: "string", description: 'File path (alternative to itemId, e.g., "/Documents/Budget.xlsx")' },
-          driveId: { type: "string", description: "Drive ID (for SharePoint drives)" }
-        },
-        required: []
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const base = itemPath(params);
-          const data = await graph(token, `${base}/workbook/worksheets`);
-          const sheets = (data.value || []).map((s) => ({
-            id: s.id,
-            name: s.name,
-            position: s.position,
-            visibility: s.visibility
-          }));
-          return jsonResult({ worksheets: sheets, count: sheets.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "excel_read_range",
-      description: "Read a range of cells from an Excel worksheet. Returns values, formulas, and formatting.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          itemId: { type: "string", description: "OneDrive/SharePoint item ID" },
-          path: { type: "string", description: "File path (alternative to itemId)" },
-          driveId: { type: "string", description: "Drive ID (for SharePoint)" },
-          worksheet: { type: "string", description: "Worksheet name (default: first sheet)" },
-          range: { type: "string", description: 'Cell range (e.g., "A1:D10", "Sheet1!A1:Z100"). Omit for used range.' }
-        },
-        required: []
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const base = itemPath(params);
-          let rangePath;
-          if (params.range) {
-            const ws = params.worksheet ? `/worksheets/${encodeURIComponent(params.worksheet)}` : "/worksheets";
-            if (params.range.includes("!")) {
-              rangePath = `${base}/workbook/worksheets/${encodeURIComponent(params.range.split("!")[0])}/range(address='${params.range.split("!")[1]}')`;
-            } else if (params.worksheet) {
-              rangePath = `${base}/workbook/worksheets/${encodeURIComponent(params.worksheet)}/range(address='${params.range}')`;
-            } else {
-              rangePath = `${base}/workbook/worksheets('Sheet1')/range(address='${params.range}')`;
-            }
-          } else {
-            const ws = params.worksheet || "Sheet1";
-            rangePath = `${base}/workbook/worksheets/${encodeURIComponent(ws)}/usedRange`;
-          }
-          const data = await graph(token, rangePath, {
-            query: { "$select": "address,values,text,formulas,numberFormat,rowCount,columnCount" }
-          });
-          return jsonResult({
-            address: data.address,
-            values: data.values,
-            text: data.text,
-            formulas: data.formulas,
-            rows: data.rowCount,
-            columns: data.columnCount
-          });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "excel_write_range",
-      description: "Write values to a range of cells in an Excel worksheet.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          itemId: { type: "string", description: "OneDrive/SharePoint item ID" },
-          path: { type: "string", description: "File path (alternative to itemId)" },
-          driveId: { type: "string", description: "Drive ID (for SharePoint)" },
-          worksheet: { type: "string", description: "Worksheet name (default: Sheet1)" },
-          range: { type: "string", description: 'Cell range to write to (e.g., "A1:C3")' },
-          values: { type: "array", description: 'Array of arrays \u2014 each inner array is a row (e.g., [["Name","Age"],["Alice",30]])' }
-        },
-        required: ["range", "values"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const base = itemPath(params);
-          const ws = params.worksheet || "Sheet1";
-          await graph(token, `${base}/workbook/worksheets/${encodeURIComponent(ws)}/range(address='${params.range}')`, {
-            method: "PATCH",
-            body: { values: params.values }
-          });
-          return jsonResult({ written: true, range: params.range, worksheet: ws });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "excel_add_row",
-      description: "Add a row to an Excel table (structured table, not just a range).",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          itemId: { type: "string", description: "OneDrive/SharePoint item ID" },
-          path: { type: "string", description: "File path" },
-          driveId: { type: "string", description: "Drive ID" },
-          worksheet: { type: "string", description: "Worksheet name" },
-          tableName: { type: "string", description: "Table name (default: first table found)" },
-          values: { type: "array", description: 'Row values as array (e.g., ["Alice", 30, "alice@example.com"])' }
-        },
-        required: ["values"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const base = itemPath(params);
-          let tablePath;
-          if (params.tableName) {
-            tablePath = params.worksheet ? `${base}/workbook/worksheets/${encodeURIComponent(params.worksheet)}/tables/${encodeURIComponent(params.tableName)}` : `${base}/workbook/tables/${encodeURIComponent(params.tableName)}`;
-          } else {
-            const ws = params.worksheet || "Sheet1";
-            const tables = await graph(token, `${base}/workbook/worksheets/${encodeURIComponent(ws)}/tables`);
-            if (!tables.value?.length) throw new Error("No tables found in worksheet. Create a table first or use excel_write_range.");
-            tablePath = `${base}/workbook/tables/${tables.value[0].id}`;
-          }
-          const row = await graph(token, `${tablePath}/rows/add`, {
-            method: "POST",
-            body: { values: [params.values] }
-          });
-          return jsonResult({ added: true, index: row.index });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "excel_list_tables",
-      description: "List all tables in an Excel workbook or specific worksheet.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          itemId: { type: "string", description: "OneDrive/SharePoint item ID" },
-          path: { type: "string", description: "File path" },
-          driveId: { type: "string", description: "Drive ID" },
-          worksheet: { type: "string", description: "Worksheet name (omit for all tables in workbook)" }
-        },
-        required: []
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const base = itemPath(params);
-          const tablesPath = params.worksheet ? `${base}/workbook/worksheets/${encodeURIComponent(params.worksheet)}/tables` : `${base}/workbook/tables`;
-          const data = await graph(token, tablesPath);
-          const tables = (data.value || []).map((t) => ({
-            id: t.id,
-            name: t.name,
-            rows: t.rowCount,
-            columns: t.columns?.length,
-            showHeaders: t.showHeaders,
-            style: t.style
-          }));
-          return jsonResult({ tables, count: tables.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "excel_read_table",
-      description: "Read all data from an Excel table including headers.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          itemId: { type: "string", description: "OneDrive/SharePoint item ID" },
-          path: { type: "string", description: "File path" },
-          driveId: { type: "string", description: "Drive ID" },
-          tableName: { type: "string", description: "Table name or ID" }
-        },
-        required: ["tableName"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const base = itemPath(params);
-          const [headerData, bodyData] = await Promise.all([
-            graph(token, `${base}/workbook/tables/${encodeURIComponent(params.tableName)}/headerRowRange`),
-            graph(token, `${base}/workbook/tables/${encodeURIComponent(params.tableName)}/dataBodyRange`)
-          ]);
-          return jsonResult({
-            headers: headerData.values?.[0],
-            rows: bodyData.values,
-            rowCount: bodyData.rowCount,
-            columnCount: bodyData.columnCount
-          });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "excel_create_worksheet",
-      description: "Add a new worksheet to an Excel workbook.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          itemId: { type: "string", description: "OneDrive/SharePoint item ID" },
-          path: { type: "string", description: "File path" },
-          driveId: { type: "string", description: "Drive ID" },
-          name: { type: "string", description: "Worksheet name" }
-        },
-        required: ["name"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const base = itemPath(params);
-          const ws = await graph(token, `${base}/workbook/worksheets/add`, {
-            method: "POST",
-            body: { name: params.name }
-          });
-          return jsonResult({ id: ws.id, name: ws.name, position: ws.position });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    }
-  ];
-}
-
-// src/agent-tools/tools/microsoft/excel-vba.ts
-function itemPath2(p) {
-  if (p.driveId && p.itemId) return `/drives/${p.driveId}/items/${p.itemId}`;
-  if (p.itemId) return `/me/drive/items/${p.itemId}`;
-  if (p.path) return `/me/drive/root:${p.path}:`;
-  throw new Error("Provide itemId or path");
-}
-function createExcelAdvancedTools(config, _options) {
-  const tp = config.tokenProvider;
-  return [
-    {
-      name: "excel_create_session",
-      description: "Create a workbook session for batch operations. Returns a session ID to use in subsequent calls for atomic transactions.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          itemId: { type: "string", description: "OneDrive/SharePoint item ID" },
-          path: { type: "string", description: "File path" },
-          driveId: { type: "string", description: "Drive ID" },
-          persistChanges: { type: "boolean", description: "Persist changes after session closes (default: true)" }
-        },
-        required: []
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const base = itemPath2(params);
-          const session = await graph(token, `${base}/workbook/createSession`, {
-            method: "POST",
-            body: { persistChanges: params.persistChanges !== false }
-          });
-          return jsonResult({ sessionId: session.id, persistChanges: session.persistChanges });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "excel_close_session",
-      description: "Close a workbook session. Commits or discards changes based on session config.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          itemId: { type: "string", description: "OneDrive/SharePoint item ID" },
-          path: { type: "string", description: "File path" },
-          driveId: { type: "string", description: "Drive ID" },
-          sessionId: { type: "string", description: "Session ID to close" }
-        },
-        required: ["sessionId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const base = itemPath2(params);
-          await graph(token, `${base}/workbook/closeSession`, {
-            method: "POST",
-            headers: { "workbook-session-id": params.sessionId }
-          });
-          return jsonResult({ closed: true, sessionId: params.sessionId });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "excel_evaluate_formula",
-      description: "Evaluate an Excel formula without writing it to a cell. Supports any Excel function (SUM, VLOOKUP, IF, etc.).",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          itemId: { type: "string", description: "OneDrive/SharePoint item ID" },
-          path: { type: "string", description: "File path" },
-          driveId: { type: "string", description: "Drive ID" },
-          worksheet: { type: "string", description: "Worksheet name (default: Sheet1)" },
-          formula: { type: "string", description: 'Excel formula (e.g., "=SUM(A1:A10)", "=VLOOKUP("Alice",A:C,3,FALSE)")' },
-          sessionId: { type: "string", description: "Optional session ID for batch operations" }
-        },
-        required: ["formula"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const base = itemPath2(params);
-          const ws = params.worksheet || "Sheet1";
-          const headers = {};
-          if (params.sessionId) headers["workbook-session-id"] = params.sessionId;
-          const tempCell = "ZZ9999";
-          await graph(token, `${base}/workbook/worksheets/${encodeURIComponent(ws)}/range(address='${tempCell}')`, {
-            method: "PATCH",
-            body: { formulas: [[params.formula]] },
-            headers
-          });
-          const result = await graph(token, `${base}/workbook/worksheets/${encodeURIComponent(ws)}/range(address='${tempCell}')`, {
-            query: { "$select": "values,text,formulas" },
-            headers
-          });
-          await graph(token, `${base}/workbook/worksheets/${encodeURIComponent(ws)}/range(address='${tempCell}')/clear`, {
-            method: "POST",
-            body: { applyTo: "All" },
-            headers
-          });
-          return jsonResult({
-            formula: params.formula,
-            result: result.values?.[0]?.[0],
-            text: result.text?.[0]?.[0]
-          });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "excel_named_ranges",
-      description: "List all named ranges in a workbook.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          itemId: { type: "string", description: "OneDrive/SharePoint item ID" },
-          path: { type: "string", description: "File path" },
-          driveId: { type: "string", description: "Drive ID" }
-        },
-        required: []
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const base = itemPath2(params);
-          const data = await graph(token, `${base}/workbook/names`);
-          const names = (data.value || []).map((n) => ({
-            name: n.name,
-            value: n.value,
-            type: n.type,
-            visible: n.visible,
-            comment: n.comment
-          }));
-          return jsonResult({ namedRanges: names, count: names.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "excel_read_named_range",
-      description: "Read values from a named range.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          itemId: { type: "string", description: "OneDrive/SharePoint item ID" },
-          path: { type: "string", description: "File path" },
-          driveId: { type: "string", description: "Drive ID" },
-          name: { type: "string", description: "Named range name" }
-        },
-        required: ["name"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const base = itemPath2(params);
-          const range = await graph(token, `${base}/workbook/names/${encodeURIComponent(params.name)}/range`, {
-            query: { "$select": "address,values,text,formulas,rowCount,columnCount" }
-          });
-          return jsonResult({
-            name: params.name,
-            address: range.address,
-            values: range.values,
-            text: range.text,
-            rows: range.rowCount,
-            columns: range.columnCount
-          });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "excel_list_charts",
-      description: "List all charts in an Excel worksheet.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          itemId: { type: "string", description: "OneDrive/SharePoint item ID" },
-          path: { type: "string", description: "File path" },
-          driveId: { type: "string", description: "Drive ID" },
-          worksheet: { type: "string", description: "Worksheet name (default: Sheet1)" }
-        },
-        required: []
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const base = itemPath2(params);
-          const ws = params.worksheet || "Sheet1";
-          const data = await graph(token, `${base}/workbook/worksheets/${encodeURIComponent(ws)}/charts`);
-          const charts = (data.value || []).map((c) => ({
-            id: c.id,
-            name: c.name,
-            height: c.height,
-            width: c.width,
-            top: c.top,
-            left: c.left
-          }));
-          return jsonResult({ charts, count: charts.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "excel_chart_image",
-      description: "Get a chart as a base64 PNG image.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          itemId: { type: "string", description: "OneDrive/SharePoint item ID" },
-          path: { type: "string", description: "File path" },
-          driveId: { type: "string", description: "Drive ID" },
-          worksheet: { type: "string", description: "Worksheet name" },
-          chartName: { type: "string", description: "Chart name or ID" }
-        },
-        required: ["chartName"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const base = itemPath2(params);
-          const ws = params.worksheet || "Sheet1";
-          const img = await graph(token, `${base}/workbook/worksheets/${encodeURIComponent(ws)}/charts/${encodeURIComponent(params.chartName)}/image`);
-          return jsonResult({ chartName: params.chartName, base64Image: img.value, format: "png" });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "excel_pivot_refresh",
-      description: "Refresh all pivot tables in a workbook by recalculating the workbook.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          itemId: { type: "string", description: "OneDrive/SharePoint item ID" },
-          path: { type: "string", description: "File path" },
-          driveId: { type: "string", description: "Drive ID" },
-          sessionId: { type: "string", description: "Session ID (recommended for consistency)" }
-        },
-        required: []
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const base = itemPath2(params);
-          const headers = {};
-          if (params.sessionId) headers["workbook-session-id"] = params.sessionId;
-          await graph(token, `${base}/workbook/application/calculate`, {
-            method: "POST",
-            body: { calculationType: "Full" },
-            headers
-          });
-          return jsonResult({ refreshed: true, calculationType: "Full" });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "excel_set_cell_format",
-      description: "Set number format, font, fill, or borders on a cell range.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          itemId: { type: "string", description: "OneDrive/SharePoint item ID" },
-          path: { type: "string", description: "File path" },
-          driveId: { type: "string", description: "Drive ID" },
-          worksheet: { type: "string", description: "Worksheet name" },
-          range: { type: "string", description: 'Cell range (e.g., "A1:D10")' },
-          numberFormat: { type: "string", description: 'Number format (e.g., "$#,##0.00", "0%", "mm/dd/yyyy")' },
-          bold: { type: "boolean", description: "Set font bold" },
-          italic: { type: "boolean", description: "Set font italic" },
-          fontColor: { type: "string", description: 'Font color (e.g., "#FF0000")' },
-          fillColor: { type: "string", description: 'Cell fill color (e.g., "#FFFF00")' },
-          horizontalAlignment: { type: "string", description: "Left, Center, Right, Fill, Justify" }
-        },
-        required: ["range"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const base = itemPath2(params);
-          const ws = params.worksheet || "Sheet1";
-          const rangePath = `${base}/workbook/worksheets/${encodeURIComponent(ws)}/range(address='${params.range}')`;
-          const format = {};
-          if (params.numberFormat) {
-            await graph(token, `${rangePath}/format`, { method: "PATCH", body: { columnWidth: null } });
-          }
-          if (params.bold !== void 0 || params.italic !== void 0 || params.fontColor) {
-            const font = {};
-            if (params.bold !== void 0) font.bold = params.bold;
-            if (params.italic !== void 0) font.italic = params.italic;
-            if (params.fontColor) font.color = params.fontColor;
-            await graph(token, `${rangePath}/format/font`, { method: "PATCH", body: font });
-          }
-          if (params.fillColor) {
-            await graph(token, `${rangePath}/format/fill`, { method: "PATCH", body: { color: params.fillColor } });
-          }
-          if (params.horizontalAlignment) {
-            await graph(token, `${rangePath}/format`, { method: "PATCH", body: { horizontalAlignment: params.horizontalAlignment } });
-          }
-          if (params.numberFormat) {
-            const rangeInfo = await graph(token, rangePath, { query: { "$select": "rowCount,columnCount" } });
-            const fmt = Array(rangeInfo.rowCount).fill(null).map(() => Array(rangeInfo.columnCount).fill(params.numberFormat));
-            await graph(token, rangePath, { method: "PATCH", body: { numberFormat: fmt } });
-          }
-          return jsonResult({ formatted: true, range: params.range });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    }
-  ];
-}
-
-// src/agent-tools/tools/microsoft/sharepoint.ts
-function createSharePointTools(config, _options) {
-  const tp = config.tokenProvider;
-  return [
-    {
-      name: "sharepoint_list_sites",
-      description: "Search or list SharePoint sites the agent has access to.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          search: { type: "string", description: "Search query for site name/description" },
-          maxResults: { type: "number", description: "Max results (default: 20)" }
-        },
-        required: []
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          let path = "/sites";
-          const query = { "$top": String(params.maxResults || 20) };
-          if (params.search) {
-            query["$search"] = `"${params.search}"`;
-          }
-          const data = await graph(token, path, { query });
-          const sites = (data.value || []).map((s) => ({
-            id: s.id,
-            name: s.displayName,
-            description: s.description,
-            webUrl: s.webUrl,
-            created: s.createdDateTime
-          }));
-          return jsonResult({ sites, count: sites.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "sharepoint_get_site",
-      description: "Get details about a SharePoint site by hostname and path, or by site ID.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          siteId: { type: "string", description: "Site ID" },
-          hostname: { type: "string", description: 'Site hostname (e.g., "contoso.sharepoint.com")' },
-          path: { type: "string", description: 'Site path (e.g., "/sites/engineering")' }
-        },
-        required: []
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          let sitePath;
-          if (params.siteId) {
-            sitePath = `/sites/${params.siteId}`;
-          } else if (params.hostname) {
-            sitePath = `/sites/${params.hostname}:${params.path || "/"}`;
-          } else {
-            throw new Error("Provide siteId or hostname");
-          }
-          const site = await graph(token, sitePath);
-          return jsonResult({
-            id: site.id,
-            name: site.displayName,
-            description: site.description,
-            webUrl: site.webUrl,
-            created: site.createdDateTime
-          });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "sharepoint_list_drives",
-      description: "List document libraries (drives) on a SharePoint site.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          siteId: { type: "string", description: "SharePoint site ID" }
-        },
-        required: ["siteId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const data = await graph(token, `/sites/${params.siteId}/drives`);
-          const drives = (data.value || []).map((d) => ({
-            id: d.id,
-            name: d.name,
-            description: d.description,
-            driveType: d.driveType,
-            webUrl: d.webUrl,
-            totalSize: d.quota?.total,
-            usedSize: d.quota?.used
-          }));
-          return jsonResult({ drives, count: drives.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "sharepoint_list_files",
-      description: "List files and folders in a SharePoint document library.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          siteId: { type: "string", description: "SharePoint site ID" },
-          driveId: { type: "string", description: "Drive (document library) ID" },
-          path: { type: "string", description: "Folder path within the drive (default: root)" },
-          maxResults: { type: "number", description: "Max items (default: 50)" }
-        },
-        required: ["siteId", "driveId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const basePath = params.path ? `/drives/${params.driveId}/root:${params.path}:/children` : `/drives/${params.driveId}/root/children`;
-          const data = await graph(token, basePath, {
-            query: {
-              "$top": String(params.maxResults || 50),
-              "$select": "id,name,size,createdDateTime,lastModifiedDateTime,webUrl,folder,file"
-            }
-          });
-          const items = (data.value || []).map((i) => ({
-            id: i.id,
-            name: i.name,
-            size: i.size,
-            type: i.folder ? "folder" : "file",
-            mimeType: i.file?.mimeType,
-            childCount: i.folder?.childCount,
-            created: i.createdDateTime,
-            modified: i.lastModifiedDateTime,
-            webUrl: i.webUrl
-          }));
-          return jsonResult({ items, count: items.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "sharepoint_upload_file",
-      description: "Upload a text file to a SharePoint document library.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          driveId: { type: "string", description: "Drive (document library) ID" },
-          path: { type: "string", description: 'Destination path (e.g., "/General/report.md")' },
-          content: { type: "string", description: "File content (text)" }
-        },
-        required: ["driveId", "path", "content"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const res = await fetch(`https://graph.microsoft.com/v1.0/drives/${params.driveId}/root:${params.path}:/content`, {
-            method: "PUT",
-            headers: { Authorization: `Bearer ${token}`, "Content-Type": "text/plain" },
-            body: params.content
-          });
-          if (!res.ok) throw new Error(`Upload failed: ${res.status} ${await res.text()}`);
-          const data = await res.json();
-          return jsonResult({ id: data.id, name: data.name, size: data.size, webUrl: data.webUrl });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "sharepoint_list_lists",
-      description: "List SharePoint lists on a site.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          siteId: { type: "string", description: "SharePoint site ID" }
-        },
-        required: ["siteId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const data = await graph(token, `/sites/${params.siteId}/lists`, {
-            query: { "$select": "id,displayName,description,webUrl,list", "$top": "50" }
-          });
-          const lists = (data.value || []).map((l) => ({
-            id: l.id,
-            name: l.displayName,
-            description: l.description,
-            webUrl: l.webUrl,
-            template: l.list?.template,
-            hidden: l.list?.hidden
-          }));
-          return jsonResult({ lists: lists.filter((l) => !l.hidden), count: lists.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "sharepoint_list_items",
-      description: "Read items from a SharePoint list.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          siteId: { type: "string", description: "SharePoint site ID" },
-          listId: { type: "string", description: "List ID or name" },
-          maxResults: { type: "number", description: "Max items (default: 50)" },
-          filter: { type: "string", description: "OData $filter expression" },
-          expand: { type: "boolean", description: "Expand field values (default: true)" }
-        },
-        required: ["siteId", "listId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const query = {
-            "$top": String(params.maxResults || 50)
-          };
-          if (params.expand !== false) query["$expand"] = "fields";
-          if (params.filter) query["$filter"] = params.filter;
-          const data = await graph(token, `/sites/${params.siteId}/lists/${params.listId}/items`, { query });
-          const items = (data.value || []).map((i) => ({
-            id: i.id,
-            created: i.createdDateTime,
-            modified: i.lastModifiedDateTime,
-            webUrl: i.webUrl,
-            fields: i.fields
-          }));
-          return jsonResult({ items, count: items.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "sharepoint_create_list_item",
-      description: "Create a new item in a SharePoint list.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          siteId: { type: "string", description: "SharePoint site ID" },
-          listId: { type: "string", description: "List ID or name" },
-          fields: { type: "object", description: 'Field values as key-value pairs (e.g., {"Title": "My Item", "Status": "Active"})' }
-        },
-        required: ["siteId", "listId", "fields"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const item = await graph(token, `/sites/${params.siteId}/lists/${params.listId}/items`, {
-            method: "POST",
-            body: { fields: params.fields }
-          });
-          return jsonResult({ id: item.id, created: true, fields: item.fields });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "sharepoint_update_list_item",
-      description: "Update an existing item in a SharePoint list.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          siteId: { type: "string", description: "SharePoint site ID" },
-          listId: { type: "string", description: "List ID or name" },
-          itemId: { type: "string", description: "Item ID to update" },
-          fields: { type: "object", description: "Updated field values" }
-        },
-        required: ["siteId", "listId", "itemId", "fields"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          await graph(token, `/sites/${params.siteId}/lists/${params.listId}/items/${params.itemId}/fields`, {
-            method: "PATCH",
-            body: params.fields
-          });
-          return jsonResult({ updated: true, itemId: params.itemId });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "sharepoint_search",
-      description: "Search across SharePoint for sites, files, list items, and pages.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          query: { type: "string", description: "Search query" },
-          entityTypes: { type: "string", description: "Comma-separated: site, drive, driveItem, list, listItem, message (default: driveItem)" },
-          maxResults: { type: "number", description: "Max results (default: 10)" }
-        },
-        required: ["query"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const types = (params.entityTypes || "driveItem").split(",").map((t) => t.trim());
-          const data = await graph(token, "/search/query", {
-            method: "POST",
-            body: {
-              requests: [{
-                entityTypes: types,
-                query: { queryString: params.query },
-                from: 0,
-                size: params.maxResults || 10
-              }]
-            }
-          });
-          const hits = data.value?.[0]?.hitsContainers?.[0]?.hits || [];
-          const results = hits.map((h) => ({
-            id: h.resource?.id,
-            name: h.resource?.name || h.resource?.displayName,
-            summary: h.summary,
-            webUrl: h.resource?.webUrl,
-            type: h.resource?.["@odata.type"],
-            lastModified: h.resource?.lastModifiedDateTime
-          }));
-          return jsonResult({ results, count: results.length, query: params.query });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    }
-  ];
-}
-
-// src/agent-tools/tools/microsoft/onenote.ts
-function createOneNoteTools(config, _options) {
-  const tp = config.tokenProvider;
-  return [
-    {
-      name: "onenote_list_notebooks",
-      description: "List all OneNote notebooks.",
-      category: "utility",
-      parameters: { type: "object", properties: {}, required: [] },
-      async execute(_id) {
-        try {
-          const token = await tp.getAccessToken();
-          const data = await graph(token, "/me/onenote/notebooks", {
-            query: { "$select": "id,displayName,createdDateTime,lastModifiedDateTime,isShared,links", "$orderby": "lastModifiedDateTime desc" }
-          });
-          const notebooks = (data.value || []).map((n) => ({
-            id: n.id,
-            name: n.displayName,
-            created: n.createdDateTime,
-            modified: n.lastModifiedDateTime,
-            isShared: n.isShared,
-            webUrl: n.links?.oneNoteWebUrl?.href
-          }));
-          return jsonResult({ notebooks, count: notebooks.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "onenote_list_sections",
-      description: "List sections in a OneNote notebook.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          notebookId: { type: "string", description: "Notebook ID" }
-        },
-        required: ["notebookId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const data = await graph(token, `/me/onenote/notebooks/${params.notebookId}/sections`, {
-            query: { "$select": "id,displayName,createdDateTime,lastModifiedDateTime" }
-          });
-          const sections = (data.value || []).map((s) => ({
-            id: s.id,
-            name: s.displayName,
-            created: s.createdDateTime,
-            modified: s.lastModifiedDateTime
-          }));
-          return jsonResult({ sections, count: sections.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "onenote_list_pages",
-      description: "List pages in a OneNote section.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          sectionId: { type: "string", description: "Section ID" },
-          maxResults: { type: "number", description: "Max pages (default: 20)" }
-        },
-        required: ["sectionId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const data = await graph(token, `/me/onenote/sections/${params.sectionId}/pages`, {
-            query: {
-              "$top": String(params.maxResults || 20),
-              "$select": "id,title,createdDateTime,lastModifiedDateTime,links,level,order",
-              "$orderby": "lastModifiedDateTime desc"
-            }
-          });
-          const pages = (data.value || []).map((p) => ({
-            id: p.id,
-            title: p.title,
-            created: p.createdDateTime,
-            modified: p.lastModifiedDateTime,
-            webUrl: p.links?.oneNoteWebUrl?.href
-          }));
-          return jsonResult({ pages, count: pages.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "onenote_read_page",
-      description: "Read the HTML content of a OneNote page.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          pageId: { type: "string", description: "Page ID" }
-        },
-        required: ["pageId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const res = await fetch(`https://graph.microsoft.com/v1.0/me/onenote/pages/${params.pageId}/content`, {
-            headers: { Authorization: `Bearer ${token}` }
-          });
-          if (!res.ok) throw new Error(`OneNote API ${res.status}: ${await res.text()}`);
-          const html = await res.text();
-          const text = html.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
-          return jsonResult({ pageId: params.pageId, html, text: text.substring(0, 1e4) });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "onenote_create_page",
-      description: "Create a new page in a OneNote section. Content is HTML.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          sectionId: { type: "string", description: "Section ID to create the page in" },
-          title: { type: "string", description: "Page title" },
-          content: { type: "string", description: "Page content (HTML or plain text)" }
-        },
-        required: ["sectionId", "title", "content"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const html = `<!DOCTYPE html><html><head><title>${params.title}</title></head><body>${params.content}</body></html>`;
-          const res = await fetch(`https://graph.microsoft.com/v1.0/me/onenote/sections/${params.sectionId}/pages`, {
-            method: "POST",
-            headers: {
-              Authorization: `Bearer ${token}`,
-              "Content-Type": "application/xhtml+xml"
-            },
-            body: html
-          });
-          if (!res.ok) throw new Error(`OneNote API ${res.status}: ${await res.text()}`);
-          const page = await res.json();
-          return jsonResult({
-            id: page.id,
-            title: page.title,
-            webUrl: page.links?.oneNoteWebUrl?.href,
-            created: true
-          });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "onenote_update_page",
-      description: "Append content to an existing OneNote page.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          pageId: { type: "string", description: "Page ID" },
-          content: { type: "string", description: "HTML content to append" },
-          position: { type: "string", description: "Where to add: after (end of body) or before (start of body). Default: after" }
-        },
-        required: ["pageId", "content"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          await graph(token, `/me/onenote/pages/${params.pageId}/content`, {
-            method: "PATCH",
-            body: [{
-              target: "body",
-              action: params.position === "before" ? "prepend" : "append",
-              content: params.content
-            }]
-          });
-          return jsonResult({ updated: true, pageId: params.pageId });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    }
-  ];
-}
-
-// src/agent-tools/tools/microsoft/powerpoint.ts
-function itemPath3(p) {
-  if (p.driveId && p.itemId) return `/drives/${p.driveId}/items/${p.itemId}`;
-  if (p.itemId) return `/me/drive/items/${p.itemId}`;
-  if (p.path) return `/me/drive/root:${p.path}:`;
-  throw new Error("Provide itemId or path to the PowerPoint file");
-}
-function createPowerPointTools(config, _options) {
-  const tp = config.tokenProvider;
-  return [
-    {
-      name: "powerpoint_get_info",
-      description: "Get metadata and slide count of a PowerPoint presentation.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          itemId: { type: "string", description: "OneDrive/SharePoint item ID" },
-          path: { type: "string", description: 'File path (e.g., "/Documents/Deck.pptx")' },
-          driveId: { type: "string", description: "Drive ID (for SharePoint)" }
-        },
-        required: []
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const base = itemPath3(params);
-          const meta = await graph(token, base, {
-            query: { "$select": "id,name,size,webUrl,createdDateTime,lastModifiedDateTime,file" }
-          });
-          let slideCount = null;
-          try {
-            const preview = await graph(token, `${base}/preview`, { method: "POST", body: {} });
-            const thumbs = await graph(token, `${base}/thumbnails`);
-            if (thumbs.value?.[0]) slideCount = Object.keys(thumbs.value[0]).filter((k) => k !== "id").length;
-          } catch {
-          }
-          return jsonResult({
-            id: meta.id,
-            name: meta.name,
-            size: meta.size,
-            webUrl: meta.webUrl,
-            mimeType: meta.file?.mimeType,
-            created: meta.createdDateTime,
-            modified: meta.lastModifiedDateTime,
-            slideCount
-          });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "powerpoint_export_pdf",
-      description: "Export/convert a PowerPoint presentation to PDF.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          itemId: { type: "string", description: "OneDrive/SharePoint item ID" },
-          path: { type: "string", description: "File path" },
-          driveId: { type: "string", description: "Drive ID" }
-        },
-        required: []
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const base = itemPath3(params);
-          const res = await fetch(`https://graph.microsoft.com/v1.0${base}/content?format=pdf`, {
-            headers: { Authorization: `Bearer ${token}` },
-            redirect: "follow"
-          });
-          if (!res.ok) throw new Error(`Export failed: ${res.status}`);
-          const buf = Buffer.from(await res.arrayBuffer());
-          return jsonResult({
-            format: "pdf",
-            sizeBytes: buf.length,
-            base64: buf.toString("base64"),
-            note: "PDF content returned as base64. Save to file or send as attachment."
-          });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "powerpoint_get_thumbnails",
-      description: "Get thumbnail images of slides in a presentation.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          itemId: { type: "string", description: "OneDrive/SharePoint item ID" },
-          path: { type: "string", description: "File path" },
-          driveId: { type: "string", description: "Drive ID" },
-          size: { type: "string", description: "Thumbnail size: small, medium, large (default: medium)" }
-        },
-        required: []
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const base = itemPath3(params);
-          const data = await graph(token, `${base}/thumbnails`);
-          const size = params.size || "medium";
-          const thumbs = (data.value || []).map((set, i) => {
-            const t = set[size] || set.medium || set.large || set.small;
-            return { slide: i + 1, url: t?.url, width: t?.width, height: t?.height };
-          }).filter((t) => t.url);
-          return jsonResult({ thumbnails: thumbs, count: thumbs.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "powerpoint_create_from_template",
-      description: "Create a new PowerPoint by copying a template file. Returns the new file for editing.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          templateItemId: { type: "string", description: "Item ID of the template .pptx" },
-          templatePath: { type: "string", description: "Path of the template (alternative to itemId)" },
-          newName: { type: "string", description: 'Name for the new file (e.g., "Q1 Report.pptx")' },
-          destFolder: { type: "string", description: "Destination folder path (default: same as template)" }
-        },
-        required: ["newName"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const base = params.templateItemId ? `/me/drive/items/${params.templateItemId}` : `/me/drive/root:${params.templatePath}:`;
-          const parentRef = {};
-          if (params.destFolder) parentRef.path = `/drive/root:${params.destFolder}`;
-          const copy = await graph(token, `${base}/copy`, {
-            method: "POST",
-            body: { name: params.newName, ...params.destFolder ? { parentReference: parentRef } : {} }
-          });
-          return jsonResult({
-            status: "copy_initiated",
-            monitorUrl: copy["@odata.context"] || null,
-            name: params.newName,
-            note: "Copy is async. File will appear in OneDrive shortly."
-          });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "powerpoint_get_embed_url",
-      description: "Get an embeddable preview URL for a PowerPoint presentation.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          itemId: { type: "string", description: "OneDrive/SharePoint item ID" },
-          path: { type: "string", description: "File path" },
-          driveId: { type: "string", description: "Drive ID" }
-        },
-        required: []
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const base = itemPath3(params);
-          const preview = await graph(token, `${base}/preview`, { method: "POST", body: {} });
-          return jsonResult({
-            embedUrl: preview.getUrl,
-            editUrl: preview.postUrl
-          });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    }
-  ];
-}
-
-// src/agent-tools/tools/microsoft/planner.ts
-function createPlannerTools(config, _options) {
-  const tp = config.tokenProvider;
-  return [
-    {
-      name: "planner_list_plans",
-      description: "List all Planner plans the agent has access to (via group membership).",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          groupId: { type: "string", description: "Microsoft 365 Group/Team ID to list plans for" }
-        },
-        required: ["groupId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const data = await graph(token, `/groups/${params.groupId}/planner/plans`);
-          const plans = (data.value || []).map((p) => ({
-            id: p.id,
-            title: p.title,
-            created: p.createdDateTime,
-            owner: p.owner
-          }));
-          return jsonResult({ plans, count: plans.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "planner_list_buckets",
-      description: "List buckets (columns) in a Planner plan.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          planId: { type: "string", description: "Plan ID" }
-        },
-        required: ["planId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const data = await graph(token, `/planner/plans/${params.planId}/buckets`);
-          const buckets = (data.value || []).map((b) => ({
-            id: b.id,
-            name: b.name,
-            orderHint: b.orderHint,
-            planId: b.planId
-          }));
-          return jsonResult({ buckets, count: buckets.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "planner_list_tasks",
-      description: "List tasks in a Planner plan or bucket.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          planId: { type: "string", description: "Plan ID (lists all tasks in plan)" },
-          bucketId: { type: "string", description: "Bucket ID (lists tasks in specific bucket)" }
-        },
-        required: []
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const path = params.bucketId ? `/planner/buckets/${params.bucketId}/tasks` : `/planner/plans/${params.planId}/tasks`;
-          if (!params.planId && !params.bucketId) throw new Error("Provide planId or bucketId");
-          const data = await graph(token, path);
-          const tasks = (data.value || []).map((t) => ({
-            id: t.id,
-            title: t.title,
-            bucketId: t.bucketId,
-            percentComplete: t.percentComplete,
-            priority: t.priority,
-            // 0-10, lower = higher
-            assignees: t.assignments ? Object.keys(t.assignments) : [],
-            dueDate: t.dueDateTime,
-            created: t.createdDateTime,
-            startDate: t.startDateTime,
-            hasDescription: t.hasDescription
-          }));
-          return jsonResult({ tasks, count: tasks.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "planner_create_task",
-      description: "Create a new task in a Planner plan.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          planId: { type: "string", description: "Plan ID" },
-          title: { type: "string", description: "Task title" },
-          bucketId: { type: "string", description: "Bucket ID to place the task in" },
-          assignees: { type: "string", description: "Comma-separated user IDs to assign" },
-          dueDate: { type: "string", description: "Due date (ISO 8601)" },
-          startDate: { type: "string", description: "Start date (ISO 8601)" },
-          priority: { type: "number", description: "Priority: 1 (urgent), 3 (important), 5 (medium), 9 (low)" },
-          percentComplete: { type: "number", description: "0, 50, or 100" }
-        },
-        required: ["planId", "title"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const task = { planId: params.planId, title: params.title };
-          if (params.bucketId) task.bucketId = params.bucketId;
-          if (params.dueDate) task.dueDateTime = params.dueDate;
-          if (params.startDate) task.startDateTime = params.startDate;
-          if (params.priority !== void 0) task.priority = params.priority;
-          if (params.percentComplete !== void 0) task.percentComplete = params.percentComplete;
-          if (params.assignees) {
-            task.assignments = {};
-            params.assignees.split(",").forEach((id) => {
-              task.assignments[id.trim()] = { "@odata.type": "#microsoft.graph.plannerAssignment", orderHint: " !" };
-            });
-          }
-          const created = await graph(token, "/planner/tasks", { method: "POST", body: task });
-          return jsonResult({ id: created.id, title: created.title, created: true });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "planner_update_task",
-      description: "Update a Planner task (title, progress, bucket, priority, assignments).",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          taskId: { type: "string", description: "Task ID" },
-          title: { type: "string", description: "New title" },
-          percentComplete: { type: "number", description: "0 (not started), 50 (in progress), 100 (completed)" },
-          bucketId: { type: "string", description: "Move to different bucket" },
-          priority: { type: "number", description: "1 (urgent), 3 (important), 5 (medium), 9 (low)" },
-          dueDate: { type: "string", description: "Due date (ISO 8601)" }
-        },
-        required: ["taskId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const existing = await graph(token, `/planner/tasks/${params.taskId}`, {
-            query: { "$select": "id" }
-          });
-          const etag = existing["@odata.etag"];
-          const update = {};
-          if (params.title) update.title = params.title;
-          if (params.percentComplete !== void 0) update.percentComplete = params.percentComplete;
-          if (params.bucketId) update.bucketId = params.bucketId;
-          if (params.priority !== void 0) update.priority = params.priority;
-          if (params.dueDate) update.dueDateTime = params.dueDate;
-          await graph(token, `/planner/tasks/${params.taskId}`, {
-            method: "PATCH",
-            body: update,
-            headers: { "If-Match": etag }
-          });
-          return jsonResult({ updated: true, taskId: params.taskId });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "planner_delete_task",
-      description: "Delete a Planner task.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          taskId: { type: "string", description: "Task ID to delete" }
-        },
-        required: ["taskId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const existing = await graph(token, `/planner/tasks/${params.taskId}`, { query: { "$select": "id" } });
-          await graph(token, `/planner/tasks/${params.taskId}`, {
-            method: "DELETE",
-            headers: { "If-Match": existing["@odata.etag"] }
-          });
-          return jsonResult({ deleted: true, taskId: params.taskId });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    }
-  ];
-}
-
-// src/agent-tools/tools/microsoft/powerbi.ts
-var PBI_BASE = "https://api.powerbi.com/v1.0/myorg";
-async function pbi(token, path, opts) {
-  const method = opts?.method || "GET";
-  const url = new URL(PBI_BASE + path);
-  if (opts?.query) for (const [k, v] of Object.entries(opts.query)) {
-    if (v) url.searchParams.set(k, v);
-  }
-  const res = await fetch(url.toString(), {
-    method,
-    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
-    body: opts?.body ? JSON.stringify(opts.body) : void 0
-  });
-  if (!res.ok) {
-    const err = await res.text();
-    throw new Error(`Power BI API ${res.status}: ${err}`);
-  }
-  if (res.status === 200 || res.status === 201) return res.json().catch(() => ({}));
-  return {};
-}
-function createPowerBITools(config, _options) {
-  const tp = config.tokenProvider;
-  return [
-    {
-      name: "powerbi_list_workspaces",
-      description: "List Power BI workspaces (groups) the agent has access to.",
-      category: "utility",
-      parameters: { type: "object", properties: {}, required: [] },
-      async execute(_id) {
-        try {
-          const token = await tp.getAccessToken();
-          const data = await pbi(token, "/groups");
-          const workspaces = (data.value || []).map((w) => ({
-            id: w.id,
-            name: w.name,
-            isOnDedicatedCapacity: w.isOnDedicatedCapacity,
-            type: w.type
-          }));
-          return jsonResult({ workspaces, count: workspaces.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "powerbi_list_reports",
-      description: "List reports in a Power BI workspace.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          workspaceId: { type: "string", description: 'Workspace (group) ID. Omit for "My Workspace".' }
-        },
-        required: []
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const path = params.workspaceId ? `/groups/${params.workspaceId}/reports` : "/reports";
-          const data = await pbi(token, path);
-          const reports = (data.value || []).map((r) => ({
-            id: r.id,
-            name: r.name,
-            datasetId: r.datasetId,
-            webUrl: r.webUrl,
-            embedUrl: r.embedUrl,
-            reportType: r.reportType
-          }));
-          return jsonResult({ reports, count: reports.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "powerbi_list_dashboards",
-      description: "List dashboards in a Power BI workspace.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          workspaceId: { type: "string", description: 'Workspace ID. Omit for "My Workspace".' }
-        },
-        required: []
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const path = params.workspaceId ? `/groups/${params.workspaceId}/dashboards` : "/dashboards";
-          const data = await pbi(token, path);
-          const dashboards = (data.value || []).map((d) => ({
-            id: d.id,
-            displayName: d.displayName,
-            webUrl: d.webUrl,
-            embedUrl: d.embedUrl,
-            isReadOnly: d.isReadOnly
-          }));
-          return jsonResult({ dashboards, count: dashboards.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "powerbi_list_datasets",
-      description: "List datasets in a Power BI workspace.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          workspaceId: { type: "string", description: 'Workspace ID. Omit for "My Workspace".' }
-        },
-        required: []
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const path = params.workspaceId ? `/groups/${params.workspaceId}/datasets` : "/datasets";
-          const data = await pbi(token, path);
-          const datasets = (data.value || []).map((d) => ({
-            id: d.id,
-            name: d.name,
-            configuredBy: d.configuredBy,
-            isRefreshable: d.isRefreshable,
-            isOnPremGatewayRequired: d.isOnPremGatewayRequired,
-            webUrl: d.webUrl
-          }));
-          return jsonResult({ datasets, count: datasets.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "powerbi_refresh_dataset",
-      description: "Trigger a data refresh on a Power BI dataset.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          datasetId: { type: "string", description: "Dataset ID to refresh" },
-          workspaceId: { type: "string", description: "Workspace ID (omit for My Workspace)" },
-          notifyOption: { type: "string", description: "NoNotification, MailOnFailure, or MailOnCompletion (default: NoNotification)" }
-        },
-        required: ["datasetId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const path = params.workspaceId ? `/groups/${params.workspaceId}/datasets/${params.datasetId}/refreshes` : `/datasets/${params.datasetId}/refreshes`;
-          await pbi(token, path, {
-            method: "POST",
-            body: { notifyOption: params.notifyOption || "NoNotification" }
-          });
-          return jsonResult({ refreshTriggered: true, datasetId: params.datasetId });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "powerbi_refresh_history",
-      description: "Get refresh history for a dataset.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          datasetId: { type: "string", description: "Dataset ID" },
-          workspaceId: { type: "string", description: "Workspace ID" },
-          maxResults: { type: "number", description: "Max results (default: 10)" }
-        },
-        required: ["datasetId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const path = params.workspaceId ? `/groups/${params.workspaceId}/datasets/${params.datasetId}/refreshes` : `/datasets/${params.datasetId}/refreshes`;
-          const data = await pbi(token, path, {
-            query: { "$top": String(params.maxResults || 10) }
-          });
-          const history = (data.value || []).map((r) => ({
-            id: r.requestId,
-            refreshType: r.refreshType,
-            status: r.status,
-            startTime: r.startTime,
-            endTime: r.endTime,
-            serviceExceptionJson: r.serviceExceptionJson
-          }));
-          return jsonResult({ refreshHistory: history, count: history.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "powerbi_execute_query",
-      description: "Execute a DAX query against a Power BI dataset. Returns tabular results.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          datasetId: { type: "string", description: "Dataset ID" },
-          workspaceId: { type: "string", description: "Workspace ID" },
-          query: { type: "string", description: `DAX query (e.g., "EVALUATE TOPN(10, 'Sales', 'Sales'[Amount], DESC)")` }
-        },
-        required: ["datasetId", "query"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const path = params.workspaceId ? `/groups/${params.workspaceId}/datasets/${params.datasetId}/executeQueries` : `/datasets/${params.datasetId}/executeQueries`;
-          const data = await pbi(token, path, {
-            method: "POST",
-            body: {
-              queries: [{ query: params.query }],
-              serializerSettings: { includeNulls: true }
-            }
-          });
-          const result = data.results?.[0];
-          const tables = result?.tables?.[0];
-          return jsonResult({
-            columns: tables?.columns?.map((c) => c.name),
-            rows: tables?.rows,
-            rowCount: tables?.rows?.length || 0
-          });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "powerbi_dashboard_tiles",
-      description: "List tiles (widgets) on a Power BI dashboard.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          dashboardId: { type: "string", description: "Dashboard ID" },
-          workspaceId: { type: "string", description: "Workspace ID" }
-        },
-        required: ["dashboardId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const path = params.workspaceId ? `/groups/${params.workspaceId}/dashboards/${params.dashboardId}/tiles` : `/dashboards/${params.dashboardId}/tiles`;
-          const data = await pbi(token, path);
-          const tiles = (data.value || []).map((t) => ({
-            id: t.id,
-            title: t.title,
-            reportId: t.reportId,
-            datasetId: t.datasetId,
-            embedUrl: t.embedUrl,
-            rowSpan: t.rowSpan,
-            colSpan: t.colSpan
-          }));
-          return jsonResult({ tiles, count: tiles.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    }
-  ];
-}
-
-// src/agent-tools/tools/microsoft/index.ts
-function createAllMicrosoftTools(config, options) {
-  const enabled = options?.enabledMicrosoftServices;
-  const has = (s) => enabled ? enabled.includes(s) : false;
-  const core = !enabled;
-  const tools = [];
-  if (core || has("mail")) tools.push(...createOutlookMailTools(config, options));
-  if (core || has("calendar")) tools.push(...createOutlookCalendarTools(config, options));
-  if (core || has("onedrive")) tools.push(...createOneDriveTools(config, options));
-  if (core || has("tasks")) tools.push(...createTodoTools(config, options));
-  if (has("teams")) tools.push(...createTeamsTools(config, options));
-  if (has("contacts")) tools.push(...createOutlookContactsTools(config, options));
-  if (has("excel")) tools.push(...createExcelTools(config, options));
-  if (has("excel-advanced")) tools.push(...createExcelAdvancedTools(config, options));
-  if (has("sharepoint")) tools.push(...createSharePointTools(config, options));
-  if (has("onenote")) tools.push(...createOneNoteTools(config, options));
-  if (has("powerpoint")) tools.push(...createPowerPointTools(config, options));
-  if (has("planner")) tools.push(...createPlannerTools(config, options));
-  if (has("powerbi")) tools.push(...createPowerBITools(config, options));
-  return tools;
-}
-export {
-  createAllMicrosoftTools,
-  createExcelAdvancedTools,
-  createExcelTools,
-  createOneDriveTools,
-  createOneNoteTools,
-  createOutlookCalendarTools,
-  createOutlookContactsTools,
-  createOutlookMailTools,
-  createPlannerTools,
-  createPowerBITools,
-  createPowerPointTools,
-  createSharePointTools,
-  createTeamsTools,
-  createTodoTools
-};