@agenticmail/enterprise 0.5.320 → 0.5.322

package/dist/microsoft-2IIHDLJB.js

@@ -0,0 +1,4159 @@
+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";
+var GRAPH_BETA = "https://graph.microsoft.com/beta";
+async function graph(token, path, opts) {
+  const method = opts?.method || "GET";
+  const base = opts?.beta ? GRAPH_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 maxRetries = opts?.retries ?? 3;
+  let lastError = null;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      const res = await fetch(url.toString(), {
+        method,
+        headers,
+        body: opts?.rawBody || (opts?.body ? JSON.stringify(opts.body) : void 0)
+      });
+      if (res.status === 429 && attempt < maxRetries) {
+        const retryAfter = parseInt(res.headers.get("Retry-After") || "5", 10);
+        await sleep(retryAfter * 1e3);
+        continue;
+      }
+      if (res.status >= 500 && attempt < maxRetries) {
+        await sleep(Math.pow(2, attempt) * 1e3);
+        continue;
+      }
+      if (opts?.raw) return res;
+      if (!res.ok) {
+        const err = await res.text();
+        throw new Error(`Graph ${method} ${path} ${res.status}: ${err}`);
+      }
+      if (res.status === 204 || res.status === 202) return {};
+      const ct = res.headers.get("content-type") || "";
+      if (ct.includes("application/json")) return res.json();
+      return { content: await res.text() };
+    } catch (e) {
+      lastError = e;
+      if (attempt < maxRetries && e.message?.includes("fetch failed")) {
+        await sleep(Math.pow(2, attempt) * 1e3);
+        continue;
+      }
+      throw e;
+    }
+  }
+  throw lastError || new Error("Graph request failed after retries");
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/agent-tools/tools/microsoft/outlook-mail.ts
+function mapMessage(m, full = false) {
+  const result = {
+    id: m.id,
+    subject: m.subject,
+    from: m.from?.emailAddress?.address,
+    fromName: m.from?.emailAddress?.name,
+    to: m.toRecipients?.map((r) => r.emailAddress?.address),
+    date: m.receivedDateTime,
+    isRead: m.isRead,
+    hasAttachments: m.hasAttachments,
+    importance: m.importance,
+    conversationId: m.conversationId
+  };
+  if (!full) {
+    result.preview = m.bodyPreview;
+    result.flagged = m.flag?.flagStatus === "flagged";
+    result.cc = m.ccRecipients?.map((r) => r.emailAddress?.address);
+  } else {
+    result.to = m.toRecipients?.map((r) => ({ email: r.emailAddress?.address, name: r.emailAddress?.name }));
+    result.cc = m.ccRecipients?.map((r) => ({ email: r.emailAddress?.address, name: r.emailAddress?.name }));
+    result.bcc = m.bccRecipients?.map((r) => ({ email: r.emailAddress?.address, name: r.emailAddress?.name }));
+    result.replyTo = m.replyTo?.map((r) => r.emailAddress?.address);
+    result.sentDate = m.sentDateTime;
+    result.body = m.body?.content;
+    result.bodyType = m.body?.contentType;
+    result.internetMessageId = m.internetMessageId;
+    result.categories = m.categories;
+    result.flagged = m.flag?.flagStatus === "flagged";
+  }
+  return result;
+}
+var LIST_SELECT = "id,subject,from,toRecipients,ccRecipients,receivedDateTime,isRead,hasAttachments,importance,bodyPreview,flag,conversationId,categories";
+var FULL_SELECT = "id,subject,from,toRecipients,ccRecipients,bccRecipients,replyTo,receivedDateTime,sentDateTime,isRead,hasAttachments,importance,body,flag,conversationId,internetMessageId,parentFolderId,categories";
+function parseRecipients(str) {
+  return str.split(",").map((e) => ({ emailAddress: { address: e.trim() } }));
+}
+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. Supports OData filtering and search.",
+      category: "utility",
+      parameters: {
+        type: "object",
+        properties: {
+          folder: { type: "string", description: "Folder: inbox, sentitems, drafts, deleteditems, junkemail, archive, or folder ID (default: inbox)" },
+          maxResults: { type: "number", description: "Max messages to return (default: 20, max: 50)" },
+          filter: { type: "string", description: `OData $filter (e.g., "isRead eq false", "from/emailAddress/address eq 'user@example.com'", "hasAttachments eq true", "importance eq 'high'")` },
+          search: { type: "string", description: "Search query (searches subject, body, sender \u2014 natural language or KQL)" },
+          orderBy: { type: "string", description: 'Sort order (default: "receivedDateTime desc"). Options: receivedDateTime, from/emailAddress/address, subject, importance' }
+        },
+        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": params.orderBy || "receivedDateTime desc",
+            "$select": LIST_SELECT
+          };
+          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) => mapMessage(m));
+          return jsonResult({ messages, count: messages.length, folder });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "outlook_mail_read",
+      description: "Read a specific email message by ID. Returns full body, headers, attachments list, and categories.",
+      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)" },
+          preferText: { type: "boolean", description: "Request plain text body instead of HTML (default: false)" }
+        },
+        required: ["messageId"]
+      },
+      async execute(_id, params) {
+        try {
+          const token = await tp.getAccessToken();
+          const headers = {};
+          if (params.preferText) headers["Prefer"] = 'outlook.body-content-type="text"';
+          const msg = await graph(token, `/me/messages/${params.messageId}`, {
+            query: { "$select": FULL_SELECT },
+            headers
+          });
+          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
+            }));
+          }
+          const result = mapMessage(msg, true);
+          result.attachments = attachments;
+          result.attachmentCount = attachments.length;
+          return jsonResult(result);
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "outlook_mail_thread",
+      description: "Get all messages in a conversation thread. Groups related emails by conversationId for context.",
+      category: "utility",
+      parameters: {
+        type: "object",
+        properties: {
+          conversationId: { type: "string", description: "Conversation ID (from any message in the thread)" },
+          messageId: { type: "string", description: "Message ID \u2014 will auto-find its conversationId" },
+          maxResults: { type: "number", description: "Max messages in thread (default: 25)" }
+        },
+        required: []
+      },
+      async execute(_id, params) {
+        try {
+          const token = await tp.getAccessToken();
+          let convId = params.conversationId;
+          if (!convId && params.messageId) {
+            const msg = await graph(token, `/me/messages/${params.messageId}`, { query: { "$select": "conversationId" } });
+            convId = msg.conversationId;
+          }
+          if (!convId) throw new Error("Provide conversationId or messageId");
+          const data = await graph(token, "/me/messages", {
+            query: {
+              "$filter": `conversationId eq '${convId}'`,
+              "$orderby": "receivedDateTime asc",
+              "$top": String(params.maxResults || 25),
+              "$select": FULL_SELECT
+            }
+          });
+          const messages = (data.value || []).map((m) => mapMessage(m, true));
+          return jsonResult({ conversationId: convId, messages, count: messages.length });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "outlook_mail_send",
+      description: "Send an email via Outlook. Supports to, cc, bcc, HTML body, attachments (base64), 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: auto-detect)" },
+          replyTo: { type: "string", description: "Reply-to address" },
+          saveToSent: { type: "boolean", description: "Save to Sent Items (default: true)" },
+          attachments: { type: "array", description: "Array of {name, contentType, contentBytes} \u2014 contentBytes is base64" },
+          categories: { type: "array", items: { type: "string" }, description: "Category labels to apply" }
+        },
+        required: ["to", "subject", "body"]
+      },
+      async execute(_id, params) {
+        try {
+          const token = await tp.getAccessToken();
+          const isHtml = params.isHtml ?? /<[a-z][\s\S]*>/i.test(params.body);
+          const message = {
+            subject: params.subject,
+            body: { contentType: isHtml ? "HTML" : "Text", content: params.body },
+            toRecipients: parseRecipients(params.to)
+          };
+          if (params.cc) message.ccRecipients = parseRecipients(params.cc);
+          if (params.bcc) message.bccRecipients = parseRecipients(params.bcc);
+          if (params.importance) message.importance = params.importance;
+          if (params.replyTo) message.replyTo = [{ emailAddress: { address: params.replyTo } }];
+          if (params.categories) message.categories = params.categories;
+          if (params.attachments?.length) {
+            message.attachments = params.attachments.map((a) => ({
+              "@odata.type": "#microsoft.graph.fileAttachment",
+              name: a.name,
+              contentType: a.contentType || "application/octet-stream",
+              contentBytes: a.contentBytes
+            }));
+          }
+          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. Can reply to sender only or reply-all. Supports HTML and attachments.",
+      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)" },
+          attachments: { type: "array", description: "Array of {name, contentType, contentBytes}" }
+        },
+        required: ["messageId", "body"]
+      },
+      async execute(_id, params) {
+        try {
+          const token = await tp.getAccessToken();
+          const action = params.replyAll ? "replyAll" : "reply";
+          const body = { comment: params.body };
+          if (params.attachments?.length) {
+            const draft = await graph(token, `/me/messages/${params.messageId}/createReply`, { method: "POST" });
+            await graph(token, `/me/messages/${draft.id}`, {
+              method: "PATCH",
+              body: {
+                body: { contentType: params.isHtml ? "HTML" : "Text", content: params.body }
+              }
+            });
+            for (const a of params.attachments) {
+              await graph(token, `/me/messages/${draft.id}/attachments`, {
+                method: "POST",
+                body: {
+                  "@odata.type": "#microsoft.graph.fileAttachment",
+                  name: a.name,
+                  contentType: a.contentType || "application/octet-stream",
+                  contentBytes: a.contentBytes
+                }
+              });
+            }
+            await graph(token, `/me/messages/${draft.id}/send`, { method: "POST" });
+            return jsonResult({ replied: true, messageId: params.messageId, replyAll: !!params.replyAll, withAttachments: true });
+          }
+          await graph(token, `/me/messages/${params.messageId}/${action}`, { method: "POST", 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 to another recipient with an optional comment.",
+      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 above the forwarded message" }
+        },
+        required: ["messageId", "to"]
+      },
+      async execute(_id, params) {
+        try {
+          const token = await tp.getAccessToken();
+          await graph(token, `/me/messages/${params.messageId}/forward`, {
+            method: "POST",
+            body: { comment: params.comment || "", toRecipients: parseRecipients(params.to) }
+          });
+          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: inbox, archive, deleteditems, junkemail, sentitems, drafts, 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: read/unread, flag, importance, 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 set (replaces existing)" }
+        },
+        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. Supports natural language and KQL syntax.",
+      category: "utility",
+      parameters: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: 'Search query (natural language or KQL: "from:user@example.com subject:report has:attachment")' },
+          maxResults: { type: "number", description: "Max results (default: 15, max: 25)" },
+          folder: { type: "string", description: "Limit search to specific folder (default: all folders)" }
+        },
+        required: ["query"]
+      },
+      async execute(_id, params) {
+        try {
+          const token = await tp.getAccessToken();
+          const top = Math.min(params.maxResults || 15, 25);
+          const basePath = params.folder ? `/me/mailFolders/${params.folder}/messages` : "/me/messages";
+          const data = await graph(token, basePath, {
+            query: {
+              "$search": `"${params.query}"`,
+              "$top": String(top),
+              "$select": LIST_SELECT
+            }
+          });
+          const messages = (data.value || []).map((m) => mapMessage(m));
+          return jsonResult({ messages, count: messages.length, query: params.query });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "outlook_mail_draft",
+      description: "Create a draft email. Can be edited and sent later with outlook_mail_send_draft.",
+      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" },
+          importance: { type: "string", description: "low, normal, or high" }
+        },
+        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: parseRecipients(params.to)
+          };
+          if (params.cc) message.ccRecipients = parseRecipients(params.cc);
+          if (params.importance) message.importance = params.importance;
+          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 all mail folders including nested child folders.",
+      category: "utility",
+      parameters: {
+        type: "object",
+        properties: {
+          parentFolderId: { type: "string", description: "Parent folder ID to list children (omit for top-level)" },
+          includeHidden: { type: "boolean", description: "Include hidden folders (default: false)" }
+        },
+        required: []
+      },
+      async execute(_id, params) {
+        try {
+          const token = await tp.getAccessToken();
+          const path = params.parentFolderId ? `/me/mailFolders/${params.parentFolderId}/childFolders` : "/me/mailFolders";
+          const query = {
+            "$top": "100",
+            "$select": "id,displayName,totalItemCount,unreadItemCount,parentFolderId,isHidden,childFolderCount"
+          };
+          if (!params.includeHidden) query["$filter"] = "isHidden eq false";
+          const data = await graph(token, path, { query });
+          const folders = (data.value || []).map((f) => ({
+            id: f.id,
+            name: f.displayName,
+            totalItems: f.totalItemCount,
+            unreadItems: f.unreadItemCount,
+            childFolders: f.childFolderCount,
+            isHidden: f.isHidden
+          }));
+          return jsonResult({ folders, count: folders.length });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "outlook_mail_create_folder",
+      description: "Create a new mail folder.",
+      category: "utility",
+      parameters: {
+        type: "object",
+        properties: {
+          name: { type: "string", description: "Folder name" },
+          parentFolderId: { type: "string", description: "Parent folder ID (omit for top-level)" }
+        },
+        required: ["name"]
+      },
+      async execute(_id, params) {
+        try {
+          const token = await tp.getAccessToken();
+          const path = params.parentFolderId ? `/me/mailFolders/${params.parentFolderId}/childFolders` : "/me/mailFolders";
+          const folder = await graph(token, path, {
+            method: "POST",
+            body: { displayName: params.name }
+          });
+          return jsonResult({ id: folder.id, name: folder.displayName });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "outlook_mail_attachment_download",
+      description: "Download an attachment from an email. Returns 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
+          });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "outlook_mail_auto_reply",
+      description: "Configure automatic replies (out-of-office / vacation responder).",
+      category: "utility",
+      parameters: {
+        type: "object",
+        properties: {
+          status: { type: "string", description: "disabled, alwaysEnabled, or scheduled" },
+          internalMessage: { type: "string", description: "Auto-reply message for internal senders (HTML)" },
+          externalMessage: { type: "string", description: "Auto-reply message for external senders (HTML)" },
+          externalAudience: { type: "string", description: "none, contactsOnly, or all (default: all)" },
+          startDate: { type: "string", description: "Start date (ISO 8601, required if scheduled)" },
+          endDate: { type: "string", description: "End date (ISO 8601, required if scheduled)" }
+        },
+        required: ["status"]
+      },
+      async execute(_id, params) {
+        try {
+          const token = await tp.getAccessToken();
+          if (params.status === "disabled") {
+            await graph(token, "/me/mailboxSettings", {
+              method: "PATCH",
+              body: { automaticRepliesSetting: { status: "disabled" } }
+            });
+            return jsonResult({ autoReply: "disabled" });
+          }
+          const setting = { status: params.status };
+          if (params.internalMessage) setting.internalReplyMessage = params.internalMessage;
+          if (params.externalMessage) setting.externalReplyMessage = params.externalMessage;
+          if (params.externalAudience) setting.externalAudience = params.externalAudience;
+          if (params.status === "scheduled") {
+            setting.scheduledStartDateTime = { dateTime: params.startDate, timeZone: "UTC" };
+            setting.scheduledEndDateTime = { dateTime: params.endDate, timeZone: "UTC" };
+          }
+          await graph(token, "/me/mailboxSettings", {
+            method: "PATCH",
+            body: { automaticRepliesSetting: setting }
+          });
+          return jsonResult({ autoReply: params.status, configured: true });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "outlook_mail_get_auto_reply",
+      description: "Get current automatic reply (out-of-office) settings.",
+      category: "utility",
+      parameters: { type: "object", properties: {}, required: [] },
+      async execute(_id) {
+        try {
+          const token = await tp.getAccessToken();
+          const settings = await graph(token, "/me/mailboxSettings/automaticRepliesSetting");
+          return jsonResult({
+            status: settings.status,
+            internalMessage: settings.internalReplyMessage,
+            externalMessage: settings.externalReplyMessage,
+            externalAudience: settings.externalAudience,
+            startDate: settings.scheduledStartDateTime?.dateTime,
+            endDate: settings.scheduledEndDateTime?.dateTime
+          });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "outlook_mail_rules",
+      description: "List, create, or delete inbox rules (message rules). Rules auto-process incoming mail.",
+      category: "utility",
+      parameters: {
+        type: "object",
+        properties: {
+          action: { type: "string", description: "list, create, or delete" },
+          ruleId: { type: "string", description: "Rule ID (for delete)" },
+          displayName: { type: "string", description: "Rule name (for create)" },
+          conditions: { type: "object", description: 'Match conditions object \u2014 e.g., {fromAddresses:[{emailAddress:{address:"user@example.com"}}], subjectContains:["invoice"]}' },
+          actions: { type: "object", description: 'Actions when matched \u2014 e.g., {moveToFolder:"archive", markAsRead:true, stopProcessingRules:true}' },
+          isEnabled: { type: "boolean", description: "Enable/disable rule (default: true)" }
+        },
+        required: ["action"]
+      },
+      async execute(_id, params) {
+        try {
+          const token = await tp.getAccessToken();
+          if (params.action === "list") {
+            const data = await graph(token, "/me/mailFolders/inbox/messageRules");
+            const rules = (data.value || []).map((r) => ({
+              id: r.id,
+              name: r.displayName,
+              isEnabled: r.isEnabled,
+              sequence: r.sequence,
+              conditions: r.conditions,
+              actions: r.actions
+            }));
+            return jsonResult({ rules, count: rules.length });
+          }
+          if (params.action === "delete") {
+            await graph(token, `/me/mailFolders/inbox/messageRules/${params.ruleId}`, { method: "DELETE" });
+            return jsonResult({ deleted: true, ruleId: params.ruleId });
+          }
+          if (params.action === "create") {
+            const rule = await graph(token, "/me/mailFolders/inbox/messageRules", {
+              method: "POST",
+              body: {
+                displayName: params.displayName || "Agent Rule",
+                isEnabled: params.isEnabled !== false,
+                conditions: params.conditions || {},
+                actions: params.actions || {}
+              }
+            });
+            return jsonResult({ id: rule.id, name: rule.displayName, created: true });
+          }
+          throw new Error("action must be list, create, or delete");
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "outlook_mail_categories",
+      description: "Manage Outlook categories (color-coded labels). List, create, or delete.",
+      category: "utility",
+      parameters: {
+        type: "object",
+        properties: {
+          action: { type: "string", description: "list, create, or delete" },
+          name: { type: "string", description: "Category name (for create)" },
+          color: { type: "string", description: "Color preset: None, Red, Orange, Brown, Yellow, Green, Teal, Olive, Blue, Purple, Cranberry, Steel, DarkSteel, Gray, DarkGray, Black (for create)" },
+          categoryId: { type: "string", description: "Category ID (for delete)" }
+        },
+        required: ["action"]
+      },
+      async execute(_id, params) {
+        try {
+          const token = await tp.getAccessToken();
+          if (params.action === "list") {
+            const data = await graph(token, "/me/outlook/masterCategories");
+            const cats = (data.value || []).map((c) => ({
+              id: c.id,
+              name: c.displayName,
+              color: c.color
+            }));
+            return jsonResult({ categories: cats, count: cats.length });
+          }
+          if (params.action === "create") {
+            const cat = await graph(token, "/me/outlook/masterCategories", {
+              method: "POST",
+              body: { displayName: params.name, color: params.color || "None" }
+            });
+            return jsonResult({ id: cat.id, name: cat.displayName, color: cat.color });
+          }
+          if (params.action === "delete") {
+            await graph(token, `/me/outlook/masterCategories/${params.categoryId}`, { method: "DELETE" });
+            return jsonResult({ deleted: true });
+          }
+          throw new Error("action must be list, create, or delete");
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "outlook_mail_profile",
+      description: "Get the mailbox user profile \u2014 email address, display name, timezone, language, and mailbox settings.",
+      category: "utility",
+      parameters: { type: "object", properties: {}, required: [] },
+      async execute(_id) {
+        try {
+          const token = await tp.getAccessToken();
+          const [user, settings] = await Promise.all([
+            graph(token, "/me", { query: { "$select": "displayName,mail,userPrincipalName,jobTitle,department,officeLocation" } }),
+            graph(token, "/me/mailboxSettings")
+          ]);
+          return jsonResult({
+            email: user.mail || user.userPrincipalName,
+            name: user.displayName,
+            jobTitle: user.jobTitle,
+            department: user.department,
+            office: user.officeLocation,
+            timeZone: settings.timeZone,
+            language: settings.language?.locale,
+            dateFormat: settings.dateFormat,
+            timeFormat: settings.timeFormat,
+            delegateMeetingRequests: settings.delegateMeetingMessageDeliveryOptions
+          });
+        } 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)" },
+          expirationDateTime: { type: "string", description: "Link expiry (ISO 8601). Only for anonymous links." },
+          password: { type: "string", description: "Password-protect the link (only for anonymous links)." }
+        },
+        required: ["itemId"]
+      },
+      async execute(_id, params) {
+        try {
+          const token = await tp.getAccessToken();
+          const body = { type: params.type || "view", scope: params.scope || "organization" };
+          if (params.expirationDateTime) body.expirationDateTime = params.expirationDateTime;
+          if (params.password) body.password = params.password;
+          const link = await graph(token, `/me/drive/items/${params.itemId}/createLink`, {
+            method: "POST",
+            body
+          });
+          return jsonResult({ url: link.link?.webUrl, type: link.link?.type, scope: link.link?.scope, expiration: link.link?.expirationDateTime });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "onedrive_move",
+      description: "Move or rename a file/folder in OneDrive.",
+      category: "utility",
+      parameters: {
+        type: "object",
+        properties: {
+          itemId: { type: "string", description: "Item ID to move/rename" },
+          newName: { type: "string", description: "New name (optional, for rename)" },
+          destinationFolderId: { type: "string", description: "Destination folder ID (optional, for move)" },
+          destinationPath: { type: "string", description: 'Destination folder path (alternative to ID, e.g., "/Documents/Archive")' }
+        },
+        required: ["itemId"]
+      },
+      async execute(_id, params) {
+        try {
+          const token = await tp.getAccessToken();
+          const body = {};
+          if (params.newName) body.name = params.newName;
+          if (params.destinationFolderId) {
+            body.parentReference = { id: params.destinationFolderId };
+          } else if (params.destinationPath) {
+            const dest = await graph(token, `/me/drive/root:${params.destinationPath}`, {
+              query: { "$select": "id" }
+            });
+            body.parentReference = { id: dest.id };
+          }
+          if (!body.name && !body.parentReference) {
+            return errorResult("Provide newName (rename), destinationFolderId or destinationPath (move), or both.");
+          }
+          const updated = await graph(token, `/me/drive/items/${params.itemId}`, {
+            method: "PATCH",
+            body
+          });
+          return jsonResult({ id: updated.id, name: updated.name, webUrl: updated.webUrl, path: updated.parentReference?.path });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "onedrive_copy",
+      description: "Copy a file or folder to a new location in OneDrive. Returns a monitor URL for large copies.",
+      category: "utility",
+      parameters: {
+        type: "object",
+        properties: {
+          itemId: { type: "string", description: "Item ID to copy" },
+          destinationFolderId: { type: "string", description: "Destination folder ID" },
+          destinationPath: { type: "string", description: "Destination folder path (alternative to ID)" },
+          newName: { type: "string", description: "New name for the copy (optional)" }
+        },
+        required: ["itemId"]
+      },
+      async execute(_id, params) {
+        try {
+          const token = await tp.getAccessToken();
+          const body = {};
+          if (params.newName) body.name = params.newName;
+          if (params.destinationFolderId) {
+            body.parentReference = { driveId: "me", id: params.destinationFolderId };
+          } else if (params.destinationPath) {
+            const dest = await graph(token, `/me/drive/root:${params.destinationPath}`, { query: { "$select": "id,parentReference" } });
+            body.parentReference = { driveId: dest.parentReference?.driveId || "me", id: dest.id };
+          } else {
+            return errorResult("Provide destinationFolderId or destinationPath.");
+          }
+          const res = await fetch(`https://graph.microsoft.com/v1.0/me/drive/items/${params.itemId}/copy`, {
+            method: "POST",
+            headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+            body: JSON.stringify(body)
+          });
+          if (res.status === 202) {
+            return jsonResult({ status: "copying", monitorUrl: res.headers.get("Location"), message: "Copy started. Large files may take time." });
+          }
+          if (!res.ok) throw new Error(`Copy failed: ${res.status} ${await res.text()}`);
+          const data = await res.json();
+          return jsonResult({ id: data.id, name: data.name, webUrl: data.webUrl });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "onedrive_versions",
+      description: "List version history of a file in OneDrive.",
+      category: "utility",
+      parameters: {
+        type: "object",
+        properties: {
+          itemId: { type: "string", description: "File item ID" },
+          path: { type: "string", description: "File path (alternative to itemId)" }
+        },
+        required: []
+      },
+      async execute(_id, params) {
+        try {
+          const token = await tp.getAccessToken();
+          const base = params.itemId ? `/me/drive/items/${params.itemId}` : `/me/drive/root:${params.path}:`;
+          const data = await graph(token, `${base}/versions`);
+          const versions = (data.value || []).map((v) => ({
+            id: v.id,
+            size: v.size,
+            modified: v.lastModifiedDateTime,
+            modifiedBy: v.lastModifiedBy?.user?.displayName || v.lastModifiedBy?.user?.email
+          }));
+          return jsonResult({ versions, count: versions.length });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "onedrive_recent",
+      description: "List recently accessed files in OneDrive.",
+      category: "utility",
+      parameters: {
+        type: "object",
+        properties: {
+          maxResults: { type: "number", description: "Max items (default: 20)" }
+        },
+        required: []
+      },
+      async execute(_id, params) {
+        try {
+          const token = await tp.getAccessToken();
+          const data = await graph(token, "/me/drive/recent", {
+            query: { "$top": String(params.maxResults || 20), "$select": "id,name,size,webUrl,lastModifiedDateTime,file,remoteItem" }
+          });
+          const items = (data.value || []).map((i) => {
+            const item = i.remoteItem || i;
+            return {
+              id: item.id,
+              name: item.name || i.name,
+              size: item.size,
+              mimeType: item.file?.mimeType,
+              modified: item.lastModifiedDateTime || i.lastModifiedDateTime,
+              webUrl: item.webUrl || i.webUrl
+            };
+          });
+          return jsonResult({ items, count: items.length });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "onedrive_permissions",
+      description: "List or manage sharing permissions on a file/folder.",
+      category: "utility",
+      parameters: {
+        type: "object",
+        properties: {
+          itemId: { type: "string", description: "Item ID" },
+          action: { type: "string", description: "list (default), revoke, or invite" },
+          permissionId: { type: "string", description: "Permission ID to revoke (for action=revoke)" },
+          email: { type: "string", description: "Email to invite (for action=invite)" },
+          role: { type: "string", description: "read or write (for action=invite, default: read)" },
+          message: { type: "string", description: "Optional message for invite" }
+        },
+        required: ["itemId"]
+      },
+      async execute(_id, params) {
+        try {
+          const token = await tp.getAccessToken();
+          const action = params.action || "list";
+          if (action === "revoke") {
+            if (!params.permissionId) return errorResult("permissionId required for revoke");
+            await graph(token, `/me/drive/items/${params.itemId}/permissions/${params.permissionId}`, { method: "DELETE" });
+            return jsonResult({ revoked: true, permissionId: params.permissionId });
+          }
+          if (action === "invite") {
+            if (!params.email) return errorResult("email required for invite");
+            const invite = await graph(token, `/me/drive/items/${params.itemId}/invite`, {
+              method: "POST",
+              body: {
+                recipients: [{ email: params.email }],
+                roles: [params.role || "read"],
+                requireSignIn: true,
+                sendInvitation: true,
+                message: params.message || ""
+              }
+            });
+            return jsonResult({ invited: true, email: params.email, permissions: invite.value });
+          }
+          const data = await graph(token, `/me/drive/items/${params.itemId}/permissions`);
+          const perms = (data.value || []).map((p) => ({
+            id: p.id,
+            roles: p.roles,
+            grantedTo: p.grantedToV2?.user?.displayName || p.grantedTo?.user?.displayName,
+            email: p.grantedToV2?.user?.email || p.invitation?.email,
+            link: p.link ? { type: p.link.type, scope: p.link.scope, webUrl: p.link.webUrl } : void 0
+          }));
+          return jsonResult({ permissions: perms, count: perms.length });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    }
+  ];
+}
+
+// src/agent-tools/tools/microsoft/teams.ts
+function mapMessage2(m) {
+  return {
+    id: m.id,
+    from: m.from?.user?.displayName || m.from?.application?.displayName,
+    fromEmail: m.from?.user?.email,
+    fromUserId: m.from?.user?.id,
+    body: m.body?.content,
+    bodyType: m.body?.contentType,
+    date: m.createdDateTime,
+    lastModified: m.lastModifiedDateTime,
+    importance: m.importance,
+    subject: m.subject,
+    attachments: m.attachments?.map((a) => ({
+      id: a.id,
+      name: a.name,
+      contentType: a.contentType,
+      contentUrl: a.contentUrl
+    })),
+    mentions: m.mentions?.map((mt) => ({ id: mt.id, text: mt.mentionText, userId: mt.mentioned?.user?.id })),
+    reactions: m.reactions?.map((r) => ({ type: r.reactionType, user: r.user?.user?.displayName })),
+    replyCount: m.replies?.length
+  };
+}
+function createTeamsTools(config, _options) {
+  const tp = config.tokenProvider;
+  return [
+    {
+      name: "teams_list_teams",
+      description: "List all Teams the agent is a member of, with descriptions and visibility.",
+      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,visibility,isArchived" }
+          });
+          const teams = (data.value || []).map((t) => ({
+            id: t.id,
+            name: t.displayName,
+            description: t.description,
+            visibility: t.visibility,
+            isArchived: t.isArchived
+          }));
+          return jsonResult({ teams, count: teams.length });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "teams_list_channels",
+      description: "List channels in a Team with membership type and description.",
+      category: "utility",
+      parameters: {
+        type: "object",
+        properties: {
+          teamId: { type: "string", description: "Team ID" },
+          includePrivate: { type: "boolean", description: "Include private/shared channels (default: true)" }
+        },
+        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,webUrl,createdDateTime" }
+          });
+          const channels = (data.value || []).map((c) => ({
+            id: c.id,
+            name: c.displayName,
+            description: c.description,
+            membershipType: c.membershipType,
+            webUrl: c.webUrl,
+            created: c.createdDateTime
+          }));
+          return jsonResult({ channels, count: channels.length });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "teams_create_channel",
+      description: "Create a new channel in a Team.",
+      category: "utility",
+      parameters: {
+        type: "object",
+        properties: {
+          teamId: { type: "string", description: "Team ID" },
+          name: { type: "string", description: "Channel display name" },
+          description: { type: "string", description: "Channel description" },
+          membershipType: { type: "string", description: "standard or private (default: standard)" }
+        },
+        required: ["teamId", "name"]
+      },
+      async execute(_id, params) {
+        try {
+          const token = await tp.getAccessToken();
+          const channel = await graph(token, `/teams/${params.teamId}/channels`, {
+            method: "POST",
+            body: {
+              displayName: params.name,
+              description: params.description || "",
+              membershipType: params.membershipType || "standard"
+            }
+          });
+          return jsonResult({ id: channel.id, name: channel.displayName, created: true });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "teams_send_channel_message",
+      description: "Send a message to a Teams channel. Supports HTML, @mentions, and importance.",
+      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)" },
+          importance: { type: "string", description: "normal, high, or urgent" },
+          subject: { type: "string", description: "Message subject (creates a thread header)" }
+        },
+        required: ["teamId", "channelId", "message"]
+      },
+      async execute(_id, params) {
+        try {
+          const token = await tp.getAccessToken();
+          const body = {
+            body: { contentType: params.isHtml ? "html" : "text", content: params.message }
+          };
+          if (params.importance) body.importance = params.importance;
+          if (params.subject) body.subject = params.subject;
+          const msg = await graph(token, `/teams/${params.teamId}/channels/${params.channelId}/messages`, {
+            method: "POST",
+            body
+          });
+          return jsonResult({ id: msg.id, sent: true });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "teams_reply_to_message",
+      description: "Reply to a specific message in a Teams channel (threaded conversation).",
+      category: "utility",
+      parameters: {
+        type: "object",
+        properties: {
+          teamId: { type: "string", description: "Team ID" },
+          channelId: { type: "string", description: "Channel ID" },
+          messageId: { type: "string", description: "Parent message ID to reply to" },
+          message: { type: "string", description: "Reply content" },
+          isHtml: { type: "boolean", description: "Whether reply is HTML" }
+        },
+        required: ["teamId", "channelId", "messageId", "message"]
+      },
+      async execute(_id, params) {
+        try {
+          const token = await tp.getAccessToken();
+          const reply = await graph(token, `/teams/${params.teamId}/channels/${params.channelId}/messages/${params.messageId}/replies`, {
+            method: "POST",
+            body: { body: { contentType: params.isHtml ? "html" : "text", content: params.message } }
+          });
+          return jsonResult({ id: reply.id, sent: true, parentId: params.messageId });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "teams_read_channel_messages",
+      description: "Read recent messages from a Teams channel, including replies and reactions.",
+      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)" },
+          includeReplies: { type: "boolean", description: "Include thread replies (default: false \u2014 heavier API call)" }
+        },
+        required: ["teamId", "channelId"]
+      },
+      async execute(_id, params) {
+        try {
+          const token = await tp.getAccessToken();
+          const query = {
+            "$top": String(params.maxResults || 20)
+          };
+          if (params.includeReplies) query["$expand"] = "replies";
+          const data = await graph(token, `/teams/${params.teamId}/channels/${params.channelId}/messages`, { query });
+          const messages = (data.value || []).map((m) => {
+            const msg = mapMessage2(m);
+            if (params.includeReplies && m.replies?.length) {
+              msg.replies = m.replies.map((r) => mapMessage2(r));
+            }
+            return msg;
+          });
+          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)" },
+          filter: { type: "string", description: 'Filter: "oneOnOne", "group", or "meeting" (default: all)' }
+        },
+        required: []
+      },
+      async execute(_id, params) {
+        try {
+          const token = await tp.getAccessToken();
+          const query = {
+            "$top": String(params.maxResults || 20),
+            "$select": "id,topic,chatType,createdDateTime,lastUpdatedDateTime",
+            "$orderby": "lastUpdatedDateTime desc"
+          };
+          if (params.filter) query["$filter"] = `chatType eq '${params.filter}'`;
+          const data = await graph(token, "/me/chats", { query });
+          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) => mapMessage2(m));
+          return jsonResult({ messages, count: messages.length });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "teams_list_members",
+      description: "List members of a team or channel.",
+      category: "utility",
+      parameters: {
+        type: "object",
+        properties: {
+          teamId: { type: "string", description: "Team ID" },
+          channelId: { type: "string", description: "Channel ID (omit for team members)" }
+        },
+        required: ["teamId"]
+      },
+      async execute(_id, params) {
+        try {
+          const token = await tp.getAccessToken();
+          const path = params.channelId ? `/teams/${params.teamId}/channels/${params.channelId}/members` : `/teams/${params.teamId}/members`;
+          const data = await graph(token, path);
+          const members = (data.value || []).map((m) => ({
+            id: m.id,
+            userId: m.userId,
+            name: m.displayName,
+            email: m.email,
+            roles: m.roles
+            // ['owner'] or []
+          }));
+          return jsonResult({ members, count: members.length });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "teams_add_member",
+      description: "Add a member to a team.",
+      category: "utility",
+      parameters: {
+        type: "object",
+        properties: {
+          teamId: { type: "string", description: "Team ID" },
+          userId: { type: "string", description: "User ID or email to add" },
+          role: { type: "string", description: "member or owner (default: member)" }
+        },
+        required: ["teamId", "userId"]
+      },
+      async execute(_id, params) {
+        try {
+          const token = await tp.getAccessToken();
+          const body = {
+            "@odata.type": "#microsoft.graph.aadUserConversationMember",
+            "user@odata.bind": `https://graph.microsoft.com/v1.0/users('${params.userId}')`,
+            roles: params.role === "owner" ? ["owner"] : []
+          };
+          await graph(token, `/teams/${params.teamId}/members`, { method: "POST", body });
+          return jsonResult({ added: true, userId: params.userId, teamId: params.teamId });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "teams_share_file",
+      description: "Share a file in a Teams channel by uploading it to the channel's SharePoint folder.",
+      category: "utility",
+      parameters: {
+        type: "object",
+        properties: {
+          teamId: { type: "string", description: "Team ID" },
+          channelId: { type: "string", description: "Channel ID" },
+          fileName: { type: "string", description: 'File name (e.g., "report.pdf")' },
+          content: { type: "string", description: "File content (text or base64 for binary)" },
+          message: { type: "string", description: "Optional message to post with the file" }
+        },
+        required: ["teamId", "channelId", "fileName", "content"]
+      },
+      async execute(_id, params) {
+        try {
+          const token = await tp.getAccessToken();
+          const folder = await graph(token, `/teams/${params.teamId}/channels/${params.channelId}/filesFolder`);
+          const driveId = folder.parentReference?.driveId;
+          const folderId = folder.id;
+          if (!driveId) throw new Error("Could not resolve channel files folder");
+          const uploadRes = await fetch(`https://graph.microsoft.com/v1.0/drives/${driveId}/items/${folderId}:/${encodeURIComponent(params.fileName)}:/content`, {
+            method: "PUT",
+            headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/octet-stream" },
+            body: params.content
+          });
+          if (!uploadRes.ok) throw new Error(`Upload failed: ${uploadRes.status}`);
+          const file = await uploadRes.json();
+          if (params.message) {
+            await graph(token, `/teams/${params.teamId}/channels/${params.channelId}/messages`, {
+              method: "POST",
+              body: {
+                body: { contentType: "html", content: `${params.message}<br/><a href="${file.webUrl}">${params.fileName}</a>` }
+              }
+            });
+          }
+          return jsonResult({ fileId: file.id, name: file.name, webUrl: file.webUrl, uploaded: true });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    {
+      name: "teams_presence",
+      description: "Get presence/availability status for users (Available, Busy, DoNotDisturb, Away, Offline).",
+      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, statusMessage: p.statusMessage?.message?.content }] });
+          }
+          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);
+        }
+      }
+    },
+    {
+      name: "teams_set_status",
+      description: "Set the agent's presence status message in Teams.",
+      category: "utility",
+      parameters: {
+        type: "object",
+        properties: {
+          message: { type: "string", description: "Status message text" },
+          expiry: { type: "string", description: 'Expiry duration (ISO 8601 duration, e.g., "PT1H" for 1 hour, "P1D" for 1 day)' }
+        },
+        required: ["message"]
+      },
+      async execute(_id, params) {
+        try {
+          const token = await tp.getAccessToken();
+          const body = {
+            statusMessage: {
+              message: { content: params.message, contentType: "text" }
+            }
+          };
+          if (params.expiry) {
+            body.statusMessage.expiryDateTime = {
+              dateTime: new Date(Date.now() + parseDuration(params.expiry)).toISOString(),
+              timeZone: "UTC"
+            };
+          }
+          await graph(token, "/me/presence/setStatusMessage", { method: "POST", body });
+          return jsonResult({ statusSet: true, message: params.message });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    }
+  ];
+}
+function parseDuration(iso) {
+  const match = iso.match(/P(?:(\d+)D)?T?(?:(\d+)H)?(?:(\d+)M)?/);
+  if (!match) return 36e5;
+  const days = parseInt(match[1] || "0") * 864e5;
+  const hours = parseInt(match[2] || "0") * 36e5;
+  const mins = parseInt(match[3] || "0") * 6e4;
+  return days + hours + mins;
+}
+
+// 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
+};