@agenticmail/enterprise 0.5.316 → 0.5.318

package/src/agent-tools/tools/microsoft/graph-api.ts

@@ -0,0 +1,50 @@
+/**
+ * Microsoft Graph API helper
+ *
+ * Shared fetch wrapper for all Microsoft 365 tools.
+ * Uses Microsoft Graph API v1.0.
+ */
+
+const GRAPH_BASE = 'https://graph.microsoft.com/v1.0';
+
+export async function graph(
+  token: string,
+  path: string,
+  opts?: {
+    method?: string;
+    body?: any;
+    query?: Record<string, string>;
+    rawBody?: BodyInit;
+    headers?: Record<string, string>;
+    beta?: boolean;
+  }
+): Promise<any> {
+  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 !== undefined && v !== '') url.searchParams.set(k, v);
+    }
+  }
+  const headers: Record<string, string> = {
+    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) : undefined),
+  });
+  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() };
+}

package/src/agent-tools/tools/microsoft/index.ts

@@ -0,0 +1,79 @@
+/**
+ * Microsoft 365 Tools — Index
+ *
+ * All Microsoft Graph API tools for enterprise agents.
+ * Requires agent to have Microsoft OAuth configured with appropriate scopes.
+ *
+ * Services covered:
+ * - Outlook Mail (send, read, search, drafts, folders, attachments)
+ * - Outlook Calendar (events, free/busy, scheduling)
+ * - OneDrive (files, folders, search, sharing)
+ * - Teams (messages, channels, chats)
+ * - To Do (tasks, lists)
+ * - Contacts (people, address book)
+ */
+
+export { createOutlookMailTools } from './outlook-mail.js';
+export { createOutlookCalendarTools } from './outlook-calendar.js';
+export { createOneDriveTools } from './onedrive.js';
+export { createTeamsTools } from './teams.js';
+export { createTodoTools } from './todo.js';
+export { createOutlookContactsTools } from './contacts.js';
+export { createExcelTools } from './excel.js';
+export { createSharePointTools } from './sharepoint.js';
+export { createOneNoteTools } from './onenote.js';
+
+import type { AnyAgentTool, ToolCreationOptions } from '../../types.js';
+import type { TokenProvider } from '../oauth-token-provider.js';
+export type { TokenProvider };
+
+import { createOutlookMailTools } from './outlook-mail.js';
+import { createOutlookCalendarTools } from './outlook-calendar.js';
+import { createOneDriveTools } from './onedrive.js';
+import { createTeamsTools } from './teams.js';
+import { createTodoTools } from './todo.js';
+import { createOutlookContactsTools } from './contacts.js';
+import { createExcelTools } from './excel.js';
+import { createSharePointTools } from './sharepoint.js';
+import { createOneNoteTools } from './onenote.js';
+
+export interface MicrosoftToolsConfig {
+  tokenProvider: TokenProvider;
+}
+
+/**
+ * Create all Microsoft 365 tools for an agent.
+ *
+ * 9 services, 70+ tools:
+ * - Outlook Mail (13 tools) — inbox, send, reply, forward, search, drafts, attachments
+ * - Outlook Calendar (7 tools) — events, create, free/busy, respond to invites
+ * - OneDrive (7 tools) — files, folders, search, upload, share
+ * - Teams (8 tools) — channels, chats, messages, presence
+ * - To Do (6 tools) — task lists, tasks CRUD
+ * - Contacts (5 tools) — address book, people search
+ * - Excel (7 tools) — read/write cells, ranges, tables, worksheets
+ * - SharePoint (10 tools) — sites, document libraries, lists, search
+ * - OneNote (6 tools) — notebooks, sections, pages, read/write
+ *
+ * Core services (mail, calendar, onedrive, tasks) load by default.
+ * Enable additional services via enabledMicrosoftServices option.
+ */
+export function createAllMicrosoftTools(config: MicrosoftToolsConfig, options?: ToolCreationOptions): AnyAgentTool[] {
+  const enabled = (options as any)?.enabledMicrosoftServices as string[] | undefined;
+  const has = (s: string) => enabled ? enabled.includes(s) : false;
+  const core = !enabled; // default: load core services
+
+  const tools: AnyAgentTool[] = [];
+  // Core services (always loaded unless explicitly selecting)
+  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));
+  // Extended services (opt-in)
+  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('sharepoint'))         tools.push(...createSharePointTools(config, options));
+  if (has('onenote'))            tools.push(...createOneNoteTools(config, options));
+  return tools;
+}

package/src/agent-tools/tools/microsoft/onedrive.ts

@@ -0,0 +1,228 @@
+/**
+ * Microsoft OneDrive Tools
+ *
+ * File management via Microsoft Graph API — upload, download, search, share, folders.
+ */
+
+import type { AnyAgentTool, ToolCreationOptions } from '../../types.js';
+import { jsonResult, errorResult } from '../../common.js';
+import type { MicrosoftToolsConfig } from './index.js';
+import { graph } from './graph-api.js';
+
+export function createOneDriveTools(config: MicrosoftToolsConfig, _options?: ToolCreationOptions): AnyAgentTool[] {
+  const tp = config.tokenProvider;
+
+  return [
+    {
+      name: 'onedrive_list',
+      description: 'List files and folders in OneDrive. Defaults to root folder.',
+      category: 'utility' as const,
+      parameters: {
+        type: 'object' as const,
+        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: string, params: any) {
+        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: any) => ({
+            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: any) { return errorResult(e.message); }
+      },
+    },
+
+    {
+      name: 'onedrive_search',
+      description: 'Search for files in OneDrive by name or content.',
+      category: 'utility' as const,
+      parameters: {
+        type: 'object' as const,
+        properties: {
+          query: { type: 'string', description: 'Search query' },
+          maxResults: { type: 'number', description: 'Max results (default: 20)' },
+        },
+        required: ['query'],
+      },
+      async execute(_id: string, params: any) {
+        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: any) => ({
+            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: any) { 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' as const,
+      parameters: {
+        type: 'object' as const,
+        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: string, params: any) {
+        try {
+          const token = await tp.getAccessToken();
+          const itemPath = params.itemId
+            ? `/me/drive/items/${params.itemId}`
+            : `/me/drive/root:${params.path}:`;
+          // Get metadata
+          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) { // < 1MB text files: return content
+            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: any) { return errorResult(e.message); }
+      },
+    },
+
+    {
+      name: 'onedrive_upload',
+      description: 'Upload a text file to OneDrive. For small files (< 4MB).',
+      category: 'utility' as const,
+      parameters: {
+        type: 'object' as const,
+        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: string, params: any) {
+        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: any) { return errorResult(e.message); }
+      },
+    },
+
+    {
+      name: 'onedrive_create_folder',
+      description: 'Create a new folder in OneDrive.',
+      category: 'utility' as const,
+      parameters: {
+        type: 'object' as const,
+        properties: {
+          name: { type: 'string', description: 'Folder name' },
+          parentPath: { type: 'string', description: 'Parent folder path (default: root)' },
+        },
+        required: ['name'],
+      },
+      async execute(_id: string, params: any) {
+        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: any) { return errorResult(e.message); }
+      },
+    },
+
+    {
+      name: 'onedrive_delete',
+      description: 'Delete a file or folder from OneDrive.',
+      category: 'utility' as const,
+      parameters: {
+        type: 'object' as const,
+        properties: {
+          itemId: { type: 'string', description: 'Item ID to delete' },
+        },
+        required: ['itemId'],
+      },
+      async execute(_id: string, params: any) {
+        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: any) { return errorResult(e.message); }
+      },
+    },
+
+    {
+      name: 'onedrive_share',
+      description: 'Create a sharing link for a file or folder.',
+      category: 'utility' as const,
+      parameters: {
+        type: 'object' as const,
+        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: string, params: any) {
+        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: any) { return errorResult(e.message); }
+      },
+    },
+  ];
+}

package/src/agent-tools/tools/microsoft/onenote.ts

@@ -0,0 +1,186 @@
+/**
+ * Microsoft OneNote Tools
+ *
+ * Notebooks, sections, and pages via Microsoft Graph API.
+ */
+
+import type { AnyAgentTool, ToolCreationOptions } from '../../types.js';
+import { jsonResult, errorResult } from '../../common.js';
+import type { MicrosoftToolsConfig } from './index.js';
+import { graph } from './graph-api.js';
+
+export function createOneNoteTools(config: MicrosoftToolsConfig, _options?: ToolCreationOptions): AnyAgentTool[] {
+  const tp = config.tokenProvider;
+
+  return [
+    {
+      name: 'onenote_list_notebooks',
+      description: 'List all OneNote notebooks.',
+      category: 'utility' as const,
+      parameters: { type: 'object' as const, properties: {}, required: [] },
+      async execute(_id: string) {
+        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: any) => ({
+            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: any) { return errorResult(e.message); }
+      },
+    },
+
+    {
+      name: 'onenote_list_sections',
+      description: 'List sections in a OneNote notebook.',
+      category: 'utility' as const,
+      parameters: {
+        type: 'object' as const,
+        properties: {
+          notebookId: { type: 'string', description: 'Notebook ID' },
+        },
+        required: ['notebookId'],
+      },
+      async execute(_id: string, params: any) {
+        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: any) => ({
+            id: s.id, name: s.displayName,
+            created: s.createdDateTime, modified: s.lastModifiedDateTime,
+          }));
+          return jsonResult({ sections, count: sections.length });
+        } catch (e: any) { return errorResult(e.message); }
+      },
+    },
+
+    {
+      name: 'onenote_list_pages',
+      description: 'List pages in a OneNote section.',
+      category: 'utility' as const,
+      parameters: {
+        type: 'object' as const,
+        properties: {
+          sectionId: { type: 'string', description: 'Section ID' },
+          maxResults: { type: 'number', description: 'Max pages (default: 20)' },
+        },
+        required: ['sectionId'],
+      },
+      async execute(_id: string, params: any) {
+        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: any) => ({
+            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: any) { return errorResult(e.message); }
+      },
+    },
+
+    {
+      name: 'onenote_read_page',
+      description: 'Read the HTML content of a OneNote page.',
+      category: 'utility' as const,
+      parameters: {
+        type: 'object' as const,
+        properties: {
+          pageId: { type: 'string', description: 'Page ID' },
+        },
+        required: ['pageId'],
+      },
+      async execute(_id: string, params: any) {
+        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();
+          // Strip HTML tags for a cleaner text view
+          const text = html.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
+          return jsonResult({ pageId: params.pageId, html, text: text.substring(0, 10000) });
+        } catch (e: any) { return errorResult(e.message); }
+      },
+    },
+
+    {
+      name: 'onenote_create_page',
+      description: 'Create a new page in a OneNote section. Content is HTML.',
+      category: 'utility' as const,
+      parameters: {
+        type: 'object' as const,
+        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: string, params: any) {
+        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: any) { return errorResult(e.message); }
+      },
+    },
+
+    {
+      name: 'onenote_update_page',
+      description: 'Append content to an existing OneNote page.',
+      category: 'utility' as const,
+      parameters: {
+        type: 'object' as const,
+        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: string, params: any) {
+        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: any) { return errorResult(e.message); }
+      },
+    },
+  ];
+}