@agenticmail/enterprise 0.5.324 → 0.5.326

package/dist/microsoft-UFLZBEAC.js

@@ -1,1619 +0,0 @@
-import {
-  errorResult,
-  jsonResult
-} from "./chunk-ZB3VC2MR.js";
-import "./chunk-KFQGP6VL.js";
-
-// src/agent-tools/tools/microsoft/graph-api.ts
-var GRAPH_BASE = "https://graph.microsoft.com/v1.0";
-async function graph(token, path, opts) {
-  const method = opts?.method || "GET";
-  const base = opts?.beta ? "https://graph.microsoft.com/beta" : GRAPH_BASE;
-  const url = new URL(base + path);
-  if (opts?.query) {
-    for (const [k, v] of Object.entries(opts.query)) {
-      if (v !== void 0 && v !== "") url.searchParams.set(k, v);
-    }
-  }
-  const headers = {
-    Authorization: `Bearer ${token}`,
-    ...opts?.headers
-  };
-  if (!opts?.rawBody && !opts?.headers?.["Content-Type"]) {
-    headers["Content-Type"] = "application/json";
-  }
-  const res = await fetch(url.toString(), {
-    method,
-    headers,
-    body: opts?.rawBody || (opts?.body ? JSON.stringify(opts.body) : void 0)
-  });
-  if (!res.ok) {
-    const err = await res.text();
-    throw new Error(`Microsoft Graph ${res.status}: ${err}`);
-  }
-  if (res.status === 204) return {};
-  const ct = res.headers.get("content-type") || "";
-  if (ct.includes("application/json")) return res.json();
-  return { content: await res.text() };
-}
-
-// src/agent-tools/tools/microsoft/outlook-mail.ts
-function createOutlookMailTools(config, _options) {
-  const tp = config.tokenProvider;
-  return [
-    {
-      name: "outlook_mail_list",
-      description: "List messages from Outlook mailbox. Returns recent emails from inbox or specified folder.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          folder: { type: "string", description: "Folder: inbox, sentitems, drafts, deleteditems, junkemail, or folder ID (default: inbox)" },
-          maxResults: { type: "number", description: "Max messages to return (default: 20, max: 50)" },
-          filter: { type: "string", description: `OData $filter expression (e.g., "isRead eq false", "from/emailAddress/address eq 'user@example.com'")` },
-          search: { type: "string", description: "Search query (searches subject, body, sender)" }
-        },
-        required: []
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const folder = params.folder || "inbox";
-          const top = Math.min(params.maxResults || 20, 50);
-          const query = {
-            "$top": String(top),
-            "$orderby": "receivedDateTime desc",
-            "$select": "id,subject,from,toRecipients,ccRecipients,receivedDateTime,isRead,hasAttachments,importance,bodyPreview,flag,conversationId"
-          };
-          if (params.filter) query["$filter"] = params.filter;
-          if (params.search) query["$search"] = `"${params.search}"`;
-          const data = await graph(token, `/me/mailFolders/${folder}/messages`, { query });
-          const messages = (data.value || []).map((m) => ({
-            id: m.id,
-            subject: m.subject,
-            from: m.from?.emailAddress?.address,
-            fromName: m.from?.emailAddress?.name,
-            to: m.toRecipients?.map((r) => r.emailAddress?.address),
-            cc: m.ccRecipients?.map((r) => r.emailAddress?.address),
-            date: m.receivedDateTime,
-            isRead: m.isRead,
-            hasAttachments: m.hasAttachments,
-            importance: m.importance,
-            preview: m.bodyPreview,
-            flagged: m.flag?.flagStatus === "flagged",
-            conversationId: m.conversationId
-          }));
-          return jsonResult({ messages, count: messages.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_mail_read",
-      description: "Read a specific email message by ID. Returns full body, headers, and attachment list.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          messageId: { type: "string", description: "Message ID to read" },
-          markAsRead: { type: "boolean", description: "Mark as read when opening (default: true)" }
-        },
-        required: ["messageId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const msg = await graph(token, `/me/messages/${params.messageId}`, {
-            query: { "$select": "id,subject,from,toRecipients,ccRecipients,bccRecipients,replyTo,receivedDateTime,sentDateTime,isRead,hasAttachments,importance,body,flag,conversationId,internetMessageId,parentFolderId" }
-          });
-          if (params.markAsRead !== false && !msg.isRead) {
-            graph(token, `/me/messages/${params.messageId}`, { method: "PATCH", body: { isRead: true } }).catch(() => {
-            });
-          }
-          let attachments = [];
-          if (msg.hasAttachments) {
-            const att = await graph(token, `/me/messages/${params.messageId}/attachments`, {
-              query: { "$select": "id,name,contentType,size,isInline" }
-            });
-            attachments = (att.value || []).map((a) => ({
-              id: a.id,
-              name: a.name,
-              contentType: a.contentType,
-              size: a.size,
-              isInline: a.isInline
-            }));
-          }
-          return jsonResult({
-            id: msg.id,
-            subject: msg.subject,
-            from: msg.from?.emailAddress?.address,
-            fromName: msg.from?.emailAddress?.name,
-            to: msg.toRecipients?.map((r) => ({ email: r.emailAddress?.address, name: r.emailAddress?.name })),
-            cc: msg.ccRecipients?.map((r) => ({ email: r.emailAddress?.address, name: r.emailAddress?.name })),
-            bcc: msg.bccRecipients?.map((r) => ({ email: r.emailAddress?.address, name: r.emailAddress?.name })),
-            replyTo: msg.replyTo?.map((r) => r.emailAddress?.address),
-            date: msg.receivedDateTime,
-            sentDate: msg.sentDateTime,
-            body: msg.body?.content,
-            bodyType: msg.body?.contentType,
-            isRead: msg.isRead,
-            importance: msg.importance,
-            attachments,
-            conversationId: msg.conversationId,
-            internetMessageId: msg.internetMessageId
-          });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_mail_send",
-      description: "Send an email via Outlook. Supports to, cc, bcc, HTML body, importance, and reply-to.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          to: { type: "string", description: "Recipient email(s), comma-separated" },
-          subject: { type: "string", description: "Email subject" },
-          body: { type: "string", description: "Email body (HTML or plain text)" },
-          cc: { type: "string", description: "CC recipients, comma-separated" },
-          bcc: { type: "string", description: "BCC recipients, comma-separated" },
-          importance: { type: "string", description: "low, normal, or high (default: normal)" },
-          isHtml: { type: "boolean", description: "Whether body is HTML (default: false)" },
-          replyTo: { type: "string", description: "Reply-to address" },
-          saveToSent: { type: "boolean", description: "Save to Sent Items (default: true)" }
-        },
-        required: ["to", "subject", "body"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const toRecipients = params.to.split(",").map((e) => ({
-            emailAddress: { address: e.trim() }
-          }));
-          const message = {
-            subject: params.subject,
-            body: { contentType: params.isHtml ? "HTML" : "Text", content: params.body },
-            toRecipients
-          };
-          if (params.cc) message.ccRecipients = params.cc.split(",").map((e) => ({ emailAddress: { address: e.trim() } }));
-          if (params.bcc) message.bccRecipients = params.bcc.split(",").map((e) => ({ emailAddress: { address: e.trim() } }));
-          if (params.importance) message.importance = params.importance;
-          if (params.replyTo) message.replyTo = [{ emailAddress: { address: params.replyTo } }];
-          await graph(token, "/me/sendMail", {
-            method: "POST",
-            body: { message, saveToSentItems: params.saveToSent !== false }
-          });
-          return jsonResult({ sent: true, to: params.to, subject: params.subject });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_mail_reply",
-      description: "Reply to an email message. Can reply to sender only or reply-all.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          messageId: { type: "string", description: "Message ID to reply to" },
-          body: { type: "string", description: "Reply body text" },
-          replyAll: { type: "boolean", description: "Reply to all recipients (default: false)" },
-          isHtml: { type: "boolean", description: "Whether body is HTML (default: false)" }
-        },
-        required: ["messageId", "body"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const action = params.replyAll ? "replyAll" : "reply";
-          await graph(token, `/me/messages/${params.messageId}/${action}`, {
-            method: "POST",
-            body: { comment: params.body }
-          });
-          return jsonResult({ replied: true, messageId: params.messageId, replyAll: !!params.replyAll });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_mail_forward",
-      description: "Forward an email message to another recipient.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          messageId: { type: "string", description: "Message ID to forward" },
-          to: { type: "string", description: "Forward recipient email(s), comma-separated" },
-          comment: { type: "string", description: "Optional comment to add above the forwarded message" }
-        },
-        required: ["messageId", "to"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const toRecipients = params.to.split(",").map((e) => ({ emailAddress: { address: e.trim() } }));
-          await graph(token, `/me/messages/${params.messageId}/forward`, {
-            method: "POST",
-            body: { comment: params.comment || "", toRecipients }
-          });
-          return jsonResult({ forwarded: true, messageId: params.messageId, to: params.to });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_mail_move",
-      description: "Move a message to another folder.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          messageId: { type: "string", description: "Message ID to move" },
-          folder: { type: "string", description: "Destination folder: inbox, archive, deleteditems, junkemail, or folder ID" }
-        },
-        required: ["messageId", "folder"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const folderMap = {
-            inbox: "inbox",
-            archive: "archive",
-            trash: "deleteditems",
-            deleteditems: "deleteditems",
-            junk: "junkemail",
-            junkemail: "junkemail",
-            sent: "sentitems",
-            sentitems: "sentitems",
-            drafts: "drafts"
-          };
-          const destId = folderMap[params.folder.toLowerCase()] || params.folder;
-          const result = await graph(token, `/me/messages/${params.messageId}/move`, {
-            method: "POST",
-            body: { destinationId: destId }
-          });
-          return jsonResult({ moved: true, newId: result.id, folder: params.folder });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_mail_delete",
-      description: "Delete an email message (moves to Deleted Items).",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          messageId: { type: "string", description: "Message ID to delete" }
-        },
-        required: ["messageId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          await graph(token, `/me/messages/${params.messageId}`, { method: "DELETE" });
-          return jsonResult({ deleted: true, messageId: params.messageId });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_mail_update",
-      description: "Update message properties: mark as read/unread, flag, change importance, add categories.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          messageId: { type: "string", description: "Message ID to update" },
-          isRead: { type: "boolean", description: "Mark as read or unread" },
-          importance: { type: "string", description: "low, normal, or high" },
-          flag: { type: "string", description: "notFlagged, flagged, or complete" },
-          categories: { type: "array", items: { type: "string" }, description: "Category labels to apply" }
-        },
-        required: ["messageId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const body = {};
-          if (params.isRead !== void 0) body.isRead = params.isRead;
-          if (params.importance) body.importance = params.importance;
-          if (params.flag) body.flag = { flagStatus: params.flag };
-          if (params.categories) body.categories = params.categories;
-          await graph(token, `/me/messages/${params.messageId}`, { method: "PATCH", body });
-          return jsonResult({ updated: true, messageId: params.messageId });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_mail_search",
-      description: "Search emails across all folders using Microsoft Search. Supports natural language queries.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          query: { type: "string", description: 'Search query (natural language or KQL: "from:user@example.com subject:report")' },
-          maxResults: { type: "number", description: "Max results (default: 10, max: 25)" }
-        },
-        required: ["query"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const top = Math.min(params.maxResults || 10, 25);
-          const data = await graph(token, "/me/messages", {
-            query: {
-              "$search": `"${params.query}"`,
-              "$top": String(top),
-              "$select": "id,subject,from,receivedDateTime,bodyPreview,isRead,hasAttachments,importance"
-            }
-          });
-          const messages = (data.value || []).map((m) => ({
-            id: m.id,
-            subject: m.subject,
-            from: m.from?.emailAddress?.address,
-            fromName: m.from?.emailAddress?.name,
-            date: m.receivedDateTime,
-            preview: m.bodyPreview,
-            isRead: m.isRead,
-            hasAttachments: m.hasAttachments
-          }));
-          return jsonResult({ messages, count: messages.length, query: params.query });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_mail_draft",
-      description: "Create a draft email in Outlook. Can be edited and sent later.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          to: { type: "string", description: "Recipient email(s), comma-separated" },
-          subject: { type: "string", description: "Email subject" },
-          body: { type: "string", description: "Email body" },
-          cc: { type: "string", description: "CC recipients" },
-          isHtml: { type: "boolean", description: "Whether body is HTML" }
-        },
-        required: ["to", "subject", "body"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const message = {
-            subject: params.subject,
-            body: { contentType: params.isHtml ? "HTML" : "Text", content: params.body },
-            toRecipients: params.to.split(",").map((e) => ({ emailAddress: { address: e.trim() } }))
-          };
-          if (params.cc) message.ccRecipients = params.cc.split(",").map((e) => ({ emailAddress: { address: e.trim() } }));
-          const draft = await graph(token, "/me/messages", { method: "POST", body: message });
-          return jsonResult({ draftId: draft.id, subject: params.subject, status: "draft_created" });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_mail_send_draft",
-      description: "Send an existing draft email.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          messageId: { type: "string", description: "Draft message ID to send" }
-        },
-        required: ["messageId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          await graph(token, `/me/messages/${params.messageId}/send`, { method: "POST" });
-          return jsonResult({ sent: true, messageId: params.messageId });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_mail_folders",
-      description: "List mail folders in the mailbox.",
-      category: "utility",
-      parameters: { type: "object", properties: {}, required: [] },
-      async execute(_id) {
-        try {
-          const token = await tp.getAccessToken();
-          const data = await graph(token, "/me/mailFolders", {
-            query: { "$top": "50", "$select": "id,displayName,totalItemCount,unreadItemCount,parentFolderId" }
-          });
-          const folders = (data.value || []).map((f) => ({
-            id: f.id,
-            name: f.displayName,
-            totalItems: f.totalItemCount,
-            unreadItems: f.unreadItemCount
-          }));
-          return jsonResult({ folders, count: folders.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_mail_attachment_download",
-      description: "Download an attachment from an email. Returns the attachment content as base64.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          messageId: { type: "string", description: "Message ID containing the attachment" },
-          attachmentId: { type: "string", description: "Attachment ID to download" }
-        },
-        required: ["messageId", "attachmentId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const att = await graph(token, `/me/messages/${params.messageId}/attachments/${params.attachmentId}`);
-          return jsonResult({
-            name: att.name,
-            contentType: att.contentType,
-            size: att.size,
-            content: att.contentBytes
-            // base64 encoded
-          });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    }
-  ];
-}
-
-// src/agent-tools/tools/microsoft/outlook-calendar.ts
-function createOutlookCalendarTools(config, _options) {
-  const tp = config.tokenProvider;
-  return [
-    {
-      name: "outlook_calendar_list",
-      description: "List all calendars the agent has access to.",
-      category: "utility",
-      parameters: { type: "object", properties: {}, required: [] },
-      async execute(_id) {
-        try {
-          const token = await tp.getAccessToken();
-          const data = await graph(token, "/me/calendars");
-          const cals = (data.value || []).map((c) => ({
-            id: c.id,
-            name: c.name,
-            color: c.color,
-            isDefaultCalendar: c.isDefaultCalendar,
-            canEdit: c.canEdit,
-            owner: c.owner?.address
-          }));
-          return jsonResult({ calendars: cals, count: cals.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_calendar_events",
-      description: "List upcoming events from a calendar. Defaults to the primary calendar.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          calendarId: { type: "string", description: "Calendar ID (omit for default calendar)" },
-          timeMin: { type: "string", description: "Start of time range (ISO 8601, default: now)" },
-          timeMax: { type: "string", description: "End of time range (ISO 8601, default: +7 days)" },
-          maxResults: { type: "number", description: "Max events (default: 20)" }
-        },
-        required: []
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const now = /* @__PURE__ */ new Date();
-          const timeMin = params.timeMin || now.toISOString();
-          const weekLater = new Date(now.getTime() + 7 * 864e5);
-          const timeMax = params.timeMax || weekLater.toISOString();
-          const top = params.maxResults || 20;
-          const basePath = params.calendarId ? `/me/calendars/${params.calendarId}/calendarView` : "/me/calendarView";
-          const data = await graph(token, basePath, {
-            query: {
-              startDateTime: timeMin,
-              endDateTime: timeMax,
-              "$top": String(top),
-              "$orderby": "start/dateTime",
-              "$select": "id,subject,start,end,location,organizer,attendees,isAllDay,isCancelled,showAs,importance,bodyPreview,onlineMeeting,webLink"
-            }
-          });
-          const events = (data.value || []).map((e) => ({
-            id: e.id,
-            subject: e.subject,
-            start: e.start?.dateTime,
-            startTimeZone: e.start?.timeZone,
-            end: e.end?.dateTime,
-            endTimeZone: e.end?.timeZone,
-            isAllDay: e.isAllDay,
-            location: e.location?.displayName,
-            organizer: e.organizer?.emailAddress?.address,
-            attendees: e.attendees?.map((a) => ({
-              email: a.emailAddress?.address,
-              name: a.emailAddress?.name,
-              status: a.status?.response,
-              type: a.type
-            })),
-            showAs: e.showAs,
-            isCancelled: e.isCancelled,
-            preview: e.bodyPreview,
-            meetingUrl: e.onlineMeeting?.joinUrl,
-            webLink: e.webLink
-          }));
-          return jsonResult({ events, count: events.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_calendar_create",
-      description: "Create a new calendar event. Supports attendees, location, online meeting (Teams), and recurrence.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          subject: { type: "string", description: "Event subject/title" },
-          start: { type: "string", description: "Start time (ISO 8601)" },
-          end: { type: "string", description: "End time (ISO 8601)" },
-          timeZone: { type: "string", description: "Time zone (default: UTC)" },
-          location: { type: "string", description: "Location name" },
-          body: { type: "string", description: "Event body/description" },
-          attendees: { type: "string", description: "Attendee emails, comma-separated" },
-          isOnlineMeeting: { type: "boolean", description: "Create a Teams meeting link (default: false)" },
-          isAllDay: { type: "boolean", description: "All-day event" },
-          importance: { type: "string", description: "low, normal, or high" },
-          reminderMinutes: { type: "number", description: "Reminder before event in minutes (default: 15)" },
-          calendarId: { type: "string", description: "Calendar ID (omit for default)" }
-        },
-        required: ["subject", "start", "end"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const tz = params.timeZone || "UTC";
-          const event = {
-            subject: params.subject,
-            start: { dateTime: params.start, timeZone: tz },
-            end: { dateTime: params.end, timeZone: tz }
-          };
-          if (params.location) event.location = { displayName: params.location };
-          if (params.body) event.body = { contentType: "HTML", content: params.body };
-          if (params.attendees) {
-            event.attendees = params.attendees.split(",").map((e) => ({
-              emailAddress: { address: e.trim() },
-              type: "required"
-            }));
-          }
-          if (params.isOnlineMeeting) {
-            event.isOnlineMeeting = true;
-            event.onlineMeetingProvider = "teamsForBusiness";
-          }
-          if (params.isAllDay) event.isAllDay = true;
-          if (params.importance) event.importance = params.importance;
-          if (params.reminderMinutes !== void 0) {
-            event.isReminderOn = true;
-            event.reminderMinutesBefore = params.reminderMinutes;
-          }
-          const basePath = params.calendarId ? `/me/calendars/${params.calendarId}/events` : "/me/events";
-          const created = await graph(token, basePath, { method: "POST", body: event });
-          return jsonResult({
-            id: created.id,
-            subject: created.subject,
-            start: created.start?.dateTime,
-            end: created.end?.dateTime,
-            meetingUrl: created.onlineMeeting?.joinUrl,
-            webLink: created.webLink
-          });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_calendar_update",
-      description: "Update an existing calendar event.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          eventId: { type: "string", description: "Event ID to update" },
-          subject: { type: "string", description: "New subject" },
-          start: { type: "string", description: "New start time (ISO 8601)" },
-          end: { type: "string", description: "New end time (ISO 8601)" },
-          timeZone: { type: "string", description: "Time zone" },
-          location: { type: "string", description: "New location" },
-          body: { type: "string", description: "New body content" }
-        },
-        required: ["eventId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const update = {};
-          if (params.subject) update.subject = params.subject;
-          if (params.start) update.start = { dateTime: params.start, timeZone: params.timeZone || "UTC" };
-          if (params.end) update.end = { dateTime: params.end, timeZone: params.timeZone || "UTC" };
-          if (params.location) update.location = { displayName: params.location };
-          if (params.body) update.body = { contentType: "HTML", content: params.body };
-          const updated = await graph(token, `/me/events/${params.eventId}`, { method: "PATCH", body: update });
-          return jsonResult({ id: updated.id, subject: updated.subject, updated: true });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_calendar_delete",
-      description: "Delete a calendar event.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          eventId: { type: "string", description: "Event ID to delete" }
-        },
-        required: ["eventId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          await graph(token, `/me/events/${params.eventId}`, { method: "DELETE" });
-          return jsonResult({ deleted: true, eventId: params.eventId });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_calendar_respond",
-      description: "Respond to a calendar event invitation (accept, tentatively accept, or decline).",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          eventId: { type: "string", description: "Event ID to respond to" },
-          response: { type: "string", description: "accept, tentativelyAccept, or decline" },
-          comment: { type: "string", description: "Optional response message" },
-          sendResponse: { type: "boolean", description: "Send response to organizer (default: true)" }
-        },
-        required: ["eventId", "response"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const body = { sendResponse: params.sendResponse !== false };
-          if (params.comment) body.comment = params.comment;
-          await graph(token, `/me/events/${params.eventId}/${params.response}`, { method: "POST", body });
-          return jsonResult({ responded: true, eventId: params.eventId, response: params.response });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_calendar_freebusy",
-      description: "Check free/busy availability for one or more users.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          emails: { type: "string", description: "Email addresses to check, comma-separated" },
-          start: { type: "string", description: "Start of range (ISO 8601)" },
-          end: { type: "string", description: "End of range (ISO 8601)" },
-          timeZone: { type: "string", description: "Time zone (default: UTC)" }
-        },
-        required: ["emails", "start", "end"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const schedules = params.emails.split(",").map((e) => e.trim());
-          const data = await graph(token, "/me/calendar/getSchedule", {
-            method: "POST",
-            body: {
-              schedules,
-              startTime: { dateTime: params.start, timeZone: params.timeZone || "UTC" },
-              endTime: { dateTime: params.end, timeZone: params.timeZone || "UTC" },
-              availabilityViewInterval: 30
-            }
-          });
-          const results = (data.value || []).map((s) => ({
-            email: s.scheduleId,
-            availability: s.availabilityView,
-            items: s.scheduleItems?.map((i) => ({
-              status: i.status,
-              subject: i.subject,
-              start: i.start?.dateTime,
-              end: i.end?.dateTime
-            }))
-          }));
-          return jsonResult({ schedules: results });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    }
-  ];
-}
-
-// src/agent-tools/tools/microsoft/onedrive.ts
-function createOneDriveTools(config, _options) {
-  const tp = config.tokenProvider;
-  return [
-    {
-      name: "onedrive_list",
-      description: "List files and folders in OneDrive. Defaults to root folder.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          path: { type: "string", description: 'Folder path (e.g., "/Documents/Reports") or item ID. Default: root' },
-          maxResults: { type: "number", description: "Max items to return (default: 50)" }
-        },
-        required: []
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const top = params.maxResults || 50;
-          const basePath = params.path ? `/me/drive/root:${params.path}:/children` : "/me/drive/root/children";
-          const data = await graph(token, basePath, {
-            query: { "$top": String(top), "$select": "id,name,size,createdDateTime,lastModifiedDateTime,webUrl,folder,file,parentReference" }
-          });
-          const items = (data.value || []).map((i) => ({
-            id: i.id,
-            name: i.name,
-            size: i.size,
-            type: i.folder ? "folder" : "file",
-            mimeType: i.file?.mimeType,
-            childCount: i.folder?.childCount,
-            created: i.createdDateTime,
-            modified: i.lastModifiedDateTime,
-            webUrl: i.webUrl,
-            path: i.parentReference?.path
-          }));
-          return jsonResult({ items, count: items.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "onedrive_search",
-      description: "Search for files in OneDrive by name or content.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          query: { type: "string", description: "Search query" },
-          maxResults: { type: "number", description: "Max results (default: 20)" }
-        },
-        required: ["query"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const top = params.maxResults || 20;
-          const data = await graph(token, `/me/drive/root/search(q='${encodeURIComponent(params.query)}')`, {
-            query: { "$top": String(top), "$select": "id,name,size,webUrl,file,folder,lastModifiedDateTime,parentReference" }
-          });
-          const items = (data.value || []).map((i) => ({
-            id: i.id,
-            name: i.name,
-            size: i.size,
-            type: i.folder ? "folder" : "file",
-            mimeType: i.file?.mimeType,
-            modified: i.lastModifiedDateTime,
-            webUrl: i.webUrl,
-            path: i.parentReference?.path
-          }));
-          return jsonResult({ items, count: items.length, query: params.query });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "onedrive_read",
-      description: "Read/download a file from OneDrive. For text files returns content; for binary returns download URL.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          itemId: { type: "string", description: "File item ID" },
-          path: { type: "string", description: 'File path (alternative to itemId, e.g., "/Documents/report.txt")' }
-        },
-        required: []
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const itemPath = params.itemId ? `/me/drive/items/${params.itemId}` : `/me/drive/root:${params.path}:`;
-          const meta = await graph(token, itemPath, {
-            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${itemPath}/content`, {
-              headers: { Authorization: `Bearer ${token}` }
-            });
-            const content = await contentRes.text();
-            return jsonResult({ id: meta.id, name: meta.name, size: meta.size, content });
-          }
-          return jsonResult({
-            id: meta.id,
-            name: meta.name,
-            size: meta.size,
-            mimeType: meta.file?.mimeType,
-            downloadUrl: meta["@microsoft.graph.downloadUrl"],
-            webUrl: meta.webUrl
-          });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "onedrive_upload",
-      description: "Upload a text file to OneDrive. For small files (< 4MB).",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          path: { type: "string", description: 'Destination path (e.g., "/Documents/report.md")' },
-          content: { type: "string", description: "File content (text)" },
-          conflictBehavior: { type: "string", description: "rename, replace, or fail (default: replace)" }
-        },
-        required: ["path", "content"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const conflict = params.conflictBehavior || "replace";
-          const res = await fetch(`https://graph.microsoft.com/v1.0/me/drive/root:${params.path}:/content?@microsoft.graph.conflictBehavior=${conflict}`, {
-            method: "PUT",
-            headers: { Authorization: `Bearer ${token}`, "Content-Type": "text/plain" },
-            body: params.content
-          });
-          if (!res.ok) throw new Error(`Upload failed: ${res.status} ${await res.text()}`);
-          const data = await res.json();
-          return jsonResult({ id: data.id, name: data.name, size: data.size, webUrl: data.webUrl });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "onedrive_create_folder",
-      description: "Create a new folder in OneDrive.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          name: { type: "string", description: "Folder name" },
-          parentPath: { type: "string", description: "Parent folder path (default: root)" }
-        },
-        required: ["name"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const parentPath = params.parentPath ? `/me/drive/root:${params.parentPath}:/children` : "/me/drive/root/children";
-          const folder = await graph(token, parentPath, {
-            method: "POST",
-            body: { name: params.name, folder: {}, "@microsoft.graph.conflictBehavior": "rename" }
-          });
-          return jsonResult({ id: folder.id, name: folder.name, webUrl: folder.webUrl });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "onedrive_delete",
-      description: "Delete a file or folder from OneDrive.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          itemId: { type: "string", description: "Item ID to delete" }
-        },
-        required: ["itemId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          await graph(token, `/me/drive/items/${params.itemId}`, { method: "DELETE" });
-          return jsonResult({ deleted: true, itemId: params.itemId });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "onedrive_share",
-      description: "Create a sharing link for a file or folder.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          itemId: { type: "string", description: "Item ID to share" },
-          type: { type: "string", description: "view or edit (default: view)" },
-          scope: { type: "string", description: "anonymous (anyone) or organization (default: organization)" }
-        },
-        required: ["itemId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const link = await graph(token, `/me/drive/items/${params.itemId}/createLink`, {
-            method: "POST",
-            body: { type: params.type || "view", scope: params.scope || "organization" }
-          });
-          return jsonResult({ url: link.link?.webUrl, type: link.link?.type, scope: link.link?.scope });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    }
-  ];
-}
-
-// src/agent-tools/tools/microsoft/teams.ts
-function createTeamsTools(config, _options) {
-  const tp = config.tokenProvider;
-  return [
-    {
-      name: "teams_list_teams",
-      description: "List all Teams the agent is a member of.",
-      category: "utility",
-      parameters: { type: "object", properties: {}, required: [] },
-      async execute(_id) {
-        try {
-          const token = await tp.getAccessToken();
-          const data = await graph(token, "/me/joinedTeams", {
-            query: { "$select": "id,displayName,description" }
-          });
-          const teams = (data.value || []).map((t) => ({
-            id: t.id,
-            name: t.displayName,
-            description: t.description
-          }));
-          return jsonResult({ teams, count: teams.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "teams_list_channels",
-      description: "List channels in a Team.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          teamId: { type: "string", description: "Team ID" }
-        },
-        required: ["teamId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const data = await graph(token, `/teams/${params.teamId}/channels`, {
-            query: { "$select": "id,displayName,description,membershipType" }
-          });
-          const channels = (data.value || []).map((c) => ({
-            id: c.id,
-            name: c.displayName,
-            description: c.description,
-            membershipType: c.membershipType
-          }));
-          return jsonResult({ channels, count: channels.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "teams_send_channel_message",
-      description: "Send a message to a Teams channel.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          teamId: { type: "string", description: "Team ID" },
-          channelId: { type: "string", description: "Channel ID" },
-          message: { type: "string", description: "Message content (supports HTML)" },
-          isHtml: { type: "boolean", description: "Whether message is HTML (default: false)" }
-        },
-        required: ["teamId", "channelId", "message"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const msg = await graph(token, `/teams/${params.teamId}/channels/${params.channelId}/messages`, {
-            method: "POST",
-            body: {
-              body: {
-                contentType: params.isHtml ? "html" : "text",
-                content: params.message
-              }
-            }
-          });
-          return jsonResult({ id: msg.id, sent: true });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "teams_read_channel_messages",
-      description: "Read recent messages from a Teams channel.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          teamId: { type: "string", description: "Team ID" },
-          channelId: { type: "string", description: "Channel ID" },
-          maxResults: { type: "number", description: "Max messages (default: 20)" }
-        },
-        required: ["teamId", "channelId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const data = await graph(token, `/teams/${params.teamId}/channels/${params.channelId}/messages`, {
-            query: { "$top": String(params.maxResults || 20) }
-          });
-          const messages = (data.value || []).map((m) => ({
-            id: m.id,
-            from: m.from?.user?.displayName || m.from?.application?.displayName,
-            fromEmail: m.from?.user?.email,
-            body: m.body?.content,
-            bodyType: m.body?.contentType,
-            date: m.createdDateTime,
-            importance: m.importance,
-            replyCount: m.replies?.length
-          }));
-          return jsonResult({ messages, count: messages.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "teams_list_chats",
-      description: "List the agent's 1:1 and group chats in Teams.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          maxResults: { type: "number", description: "Max chats to return (default: 20)" }
-        },
-        required: []
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const data = await graph(token, "/me/chats", {
-            query: {
-              "$top": String(params.maxResults || 20),
-              "$select": "id,topic,chatType,createdDateTime,lastUpdatedDateTime",
-              "$orderby": "lastUpdatedDateTime desc"
-            }
-          });
-          const chats = (data.value || []).map((c) => ({
-            id: c.id,
-            topic: c.topic,
-            type: c.chatType,
-            created: c.createdDateTime,
-            lastUpdated: c.lastUpdatedDateTime
-          }));
-          return jsonResult({ chats, count: chats.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "teams_send_chat_message",
-      description: "Send a message in a Teams 1:1 or group chat.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          chatId: { type: "string", description: "Chat ID" },
-          message: { type: "string", description: "Message content" },
-          isHtml: { type: "boolean", description: "Whether message is HTML (default: false)" }
-        },
-        required: ["chatId", "message"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const msg = await graph(token, `/chats/${params.chatId}/messages`, {
-            method: "POST",
-            body: {
-              body: { contentType: params.isHtml ? "html" : "text", content: params.message }
-            }
-          });
-          return jsonResult({ id: msg.id, sent: true });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "teams_read_chat_messages",
-      description: "Read recent messages from a Teams chat.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          chatId: { type: "string", description: "Chat ID" },
-          maxResults: { type: "number", description: "Max messages (default: 20)" }
-        },
-        required: ["chatId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const data = await graph(token, `/chats/${params.chatId}/messages`, {
-            query: { "$top": String(params.maxResults || 20), "$orderby": "createdDateTime desc" }
-          });
-          const messages = (data.value || []).map((m) => ({
-            id: m.id,
-            from: m.from?.user?.displayName,
-            body: m.body?.content,
-            bodyType: m.body?.contentType,
-            date: m.createdDateTime
-          }));
-          return jsonResult({ messages, count: messages.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "teams_presence",
-      description: "Get presence/availability status for users.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          userIds: { type: "string", description: 'User IDs, comma-separated (use "me" for self)' }
-        },
-        required: ["userIds"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          if (params.userIds === "me") {
-            const p = await graph(token, "/me/presence");
-            return jsonResult({ presence: [{ availability: p.availability, activity: p.activity }] });
-          }
-          const ids = params.userIds.split(",").map((s) => s.trim());
-          const data = await graph(token, "/communications/getPresencesByUserId", {
-            method: "POST",
-            body: { ids }
-          });
-          const presence = (data.value || []).map((p) => ({
-            userId: p.id,
-            availability: p.availability,
-            activity: p.activity
-          }));
-          return jsonResult({ presence });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    }
-  ];
-}
-
-// src/agent-tools/tools/microsoft/todo.ts
-function createTodoTools(config, _options) {
-  const tp = config.tokenProvider;
-  return [
-    {
-      name: "todo_list_lists",
-      description: "List all To Do task lists.",
-      category: "utility",
-      parameters: { type: "object", properties: {}, required: [] },
-      async execute(_id) {
-        try {
-          const token = await tp.getAccessToken();
-          const data = await graph(token, "/me/todo/lists");
-          const lists = (data.value || []).map((l) => ({
-            id: l.id,
-            name: l.displayName,
-            isOwner: l.isOwner,
-            wellknownName: l.wellknownListName
-          }));
-          return jsonResult({ lists, count: lists.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "todo_list_tasks",
-      description: "List tasks in a To Do list.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          listId: { type: "string", description: "Task list ID" },
-          includeCompleted: { type: "boolean", description: "Include completed tasks (default: false)" },
-          maxResults: { type: "number", description: "Max tasks (default: 50)" }
-        },
-        required: ["listId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const query = {
-            "$top": String(params.maxResults || 50),
-            "$orderby": "importance desc,createdDateTime desc",
-            "$select": "id,title,body,status,importance,createdDateTime,lastModifiedDateTime,dueDateTime,completedDateTime,isReminderOn,reminderDateTime"
-          };
-          if (!params.includeCompleted) query["$filter"] = "status ne 'completed'";
-          const data = await graph(token, `/me/todo/lists/${params.listId}/tasks`, { query });
-          const tasks = (data.value || []).map((t) => ({
-            id: t.id,
-            title: t.title,
-            body: t.body?.content,
-            bodyType: t.body?.contentType,
-            status: t.status,
-            importance: t.importance,
-            created: t.createdDateTime,
-            modified: t.lastModifiedDateTime,
-            dueDate: t.dueDateTime?.dateTime,
-            dueTimeZone: t.dueDateTime?.timeZone,
-            completedDate: t.completedDateTime?.dateTime,
-            hasReminder: t.isReminderOn
-          }));
-          return jsonResult({ tasks, count: tasks.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "todo_create_task",
-      description: "Create a new task in a To Do list.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          listId: { type: "string", description: "Task list ID" },
-          title: { type: "string", description: "Task title" },
-          body: { type: "string", description: "Task notes/description" },
-          dueDate: { type: "string", description: 'Due date (ISO 8601 date, e.g., "2026-03-15")' },
-          importance: { type: "string", description: "low, normal, or high (default: normal)" },
-          reminderDateTime: { type: "string", description: "Reminder date/time (ISO 8601)" }
-        },
-        required: ["listId", "title"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const task = { title: params.title };
-          if (params.body) task.body = { contentType: "text", content: params.body };
-          if (params.dueDate) task.dueDateTime = { dateTime: params.dueDate + "T00:00:00", timeZone: "UTC" };
-          if (params.importance) task.importance = params.importance;
-          if (params.reminderDateTime) {
-            task.isReminderOn = true;
-            task.reminderDateTime = { dateTime: params.reminderDateTime, timeZone: "UTC" };
-          }
-          const created = await graph(token, `/me/todo/lists/${params.listId}/tasks`, { method: "POST", body: task });
-          return jsonResult({ id: created.id, title: created.title, status: created.status });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "todo_update_task",
-      description: "Update an existing To Do task (title, status, due date, importance).",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          listId: { type: "string", description: "Task list ID" },
-          taskId: { type: "string", description: "Task ID" },
-          title: { type: "string", description: "New title" },
-          status: { type: "string", description: "notStarted, inProgress, completed, waitingOnOthers, deferred" },
-          importance: { type: "string", description: "low, normal, or high" },
-          dueDate: { type: "string", description: "New due date (ISO 8601 date)" },
-          body: { type: "string", description: "New task notes" }
-        },
-        required: ["listId", "taskId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const update = {};
-          if (params.title) update.title = params.title;
-          if (params.status) update.status = params.status;
-          if (params.importance) update.importance = params.importance;
-          if (params.dueDate) update.dueDateTime = { dateTime: params.dueDate + "T00:00:00", timeZone: "UTC" };
-          if (params.body) update.body = { contentType: "text", content: params.body };
-          const updated = await graph(token, `/me/todo/lists/${params.listId}/tasks/${params.taskId}`, {
-            method: "PATCH",
-            body: update
-          });
-          return jsonResult({ id: updated.id, title: updated.title, status: updated.status, updated: true });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "todo_delete_task",
-      description: "Delete a To Do task.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          listId: { type: "string", description: "Task list ID" },
-          taskId: { type: "string", description: "Task ID to delete" }
-        },
-        required: ["listId", "taskId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          await graph(token, `/me/todo/lists/${params.listId}/tasks/${params.taskId}`, { method: "DELETE" });
-          return jsonResult({ deleted: true, taskId: params.taskId });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "todo_create_list",
-      description: "Create a new To Do task list.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          name: { type: "string", description: "List name" }
-        },
-        required: ["name"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const list = await graph(token, "/me/todo/lists", {
-            method: "POST",
-            body: { displayName: params.name }
-          });
-          return jsonResult({ id: list.id, name: list.displayName });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    }
-  ];
-}
-
-// src/agent-tools/tools/microsoft/contacts.ts
-function createOutlookContactsTools(config, _options) {
-  const tp = config.tokenProvider;
-  return [
-    {
-      name: "outlook_contacts_list",
-      description: "List contacts from the Outlook address book.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          maxResults: { type: "number", description: "Max contacts (default: 50)" },
-          search: { type: "string", description: "Search by name or email" }
-        },
-        required: []
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const query = {
-            "$top": String(params.maxResults || 50),
-            "$select": "id,displayName,givenName,surname,emailAddresses,mobilePhone,businessPhones,companyName,jobTitle",
-            "$orderby": "displayName"
-          };
-          if (params.search) query["$filter"] = `startswith(displayName,'${params.search}') or startswith(givenName,'${params.search}') or startswith(surname,'${params.search}')`;
-          const data = await graph(token, "/me/contacts", { query });
-          const contacts = (data.value || []).map((c) => ({
-            id: c.id,
-            name: c.displayName,
-            firstName: c.givenName,
-            lastName: c.surname,
-            emails: c.emailAddresses?.map((e) => e.address),
-            mobile: c.mobilePhone,
-            phones: c.businessPhones,
-            company: c.companyName,
-            jobTitle: c.jobTitle
-          }));
-          return jsonResult({ contacts, count: contacts.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_contacts_create",
-      description: "Create a new contact in Outlook.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          firstName: { type: "string", description: "First name" },
-          lastName: { type: "string", description: "Last name" },
-          email: { type: "string", description: "Email address" },
-          mobile: { type: "string", description: "Mobile phone number" },
-          company: { type: "string", description: "Company name" },
-          jobTitle: { type: "string", description: "Job title" },
-          notes: { type: "string", description: "Personal notes" }
-        },
-        required: ["firstName", "email"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const contact = {
-            givenName: params.firstName,
-            emailAddresses: [{ address: params.email, name: `${params.firstName} ${params.lastName || ""}`.trim() }]
-          };
-          if (params.lastName) contact.surname = params.lastName;
-          if (params.mobile) contact.mobilePhone = params.mobile;
-          if (params.company) contact.companyName = params.company;
-          if (params.jobTitle) contact.jobTitle = params.jobTitle;
-          if (params.notes) contact.personalNotes = params.notes;
-          const created = await graph(token, "/me/contacts", { method: "POST", body: contact });
-          return jsonResult({ id: created.id, name: created.displayName, email: params.email });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_contacts_update",
-      description: "Update an existing contact.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          contactId: { type: "string", description: "Contact ID" },
-          firstName: { type: "string", description: "First name" },
-          lastName: { type: "string", description: "Last name" },
-          email: { type: "string", description: "Email address" },
-          mobile: { type: "string", description: "Mobile phone" },
-          company: { type: "string", description: "Company name" },
-          jobTitle: { type: "string", description: "Job title" }
-        },
-        required: ["contactId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const update = {};
-          if (params.firstName) update.givenName = params.firstName;
-          if (params.lastName) update.surname = params.lastName;
-          if (params.email) update.emailAddresses = [{ address: params.email }];
-          if (params.mobile) update.mobilePhone = params.mobile;
-          if (params.company) update.companyName = params.company;
-          if (params.jobTitle) update.jobTitle = params.jobTitle;
-          await graph(token, `/me/contacts/${params.contactId}`, { method: "PATCH", body: update });
-          return jsonResult({ updated: true, contactId: params.contactId });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_contacts_delete",
-      description: "Delete a contact from Outlook.",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          contactId: { type: "string", description: "Contact ID to delete" }
-        },
-        required: ["contactId"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          await graph(token, `/me/contacts/${params.contactId}`, { method: "DELETE" });
-          return jsonResult({ deleted: true, contactId: params.contactId });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    },
-    {
-      name: "outlook_people_search",
-      description: "Search for people relevant to the user (contacts, colleagues, recent correspondents).",
-      category: "utility",
-      parameters: {
-        type: "object",
-        properties: {
-          query: { type: "string", description: "Search query (name or email)" },
-          maxResults: { type: "number", description: "Max results (default: 10)" }
-        },
-        required: ["query"]
-      },
-      async execute(_id, params) {
-        try {
-          const token = await tp.getAccessToken();
-          const data = await graph(token, "/me/people", {
-            query: {
-              "$search": `"${params.query}"`,
-              "$top": String(params.maxResults || 10),
-              "$select": "id,displayName,givenName,surname,emailAddresses,companyName,jobTitle,department"
-            }
-          });
-          const people = (data.value || []).map((p) => ({
-            id: p.id,
-            name: p.displayName,
-            firstName: p.givenName,
-            lastName: p.surname,
-            emails: p.emailAddresses?.map((e) => e.address),
-            company: p.companyName,
-            jobTitle: p.jobTitle,
-            department: p.department
-          }));
-          return jsonResult({ people, count: people.length });
-        } catch (e) {
-          return errorResult(e.message);
-        }
-      }
-    }
-  ];
-}
-
-// src/agent-tools/tools/microsoft/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));
-  return tools;
-}
-export {
-  createAllMicrosoftTools,
-  createOneDriveTools,
-  createOutlookCalendarTools,
-  createOutlookContactsTools,
-  createOutlookMailTools,
-  createTeamsTools,
-  createTodoTools
-};