@agenticmail/enterprise 0.5.317 → 0.5.318

package/dist/runtime-HTIM7GZR.js

@@ -0,0 +1,45 @@
+import {
+  AgentRuntime,
+  EmailChannel,
+  FollowUpScheduler,
+  SessionManager,
+  SubAgentManager,
+  ToolRegistry,
+  callLLM,
+  createAgentRuntime,
+  createNoopHooks,
+  createRuntimeHooks,
+  estimateMessageTokens,
+  estimateTokens,
+  executeTool,
+  runAgentLoop,
+  toolsToDefinitions
+} from "./chunk-MMYBDHDB.js";
+import {
+  PROVIDER_REGISTRY,
+  listAllProviders,
+  resolveApiKeyForProvider,
+  resolveProvider
+} from "./chunk-UF3ZJMJO.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  AgentRuntime,
+  EmailChannel,
+  FollowUpScheduler,
+  PROVIDER_REGISTRY,
+  SessionManager,
+  SubAgentManager,
+  ToolRegistry,
+  callLLM,
+  createAgentRuntime,
+  createNoopHooks,
+  createRuntimeHooks,
+  estimateMessageTokens,
+  estimateTokens,
+  executeTool,
+  listAllProviders,
+  resolveApiKeyForProvider,
+  resolveProvider,
+  runAgentLoop,
+  toolsToDefinitions
+};

package/dist/server-TXV3ZVVR.js

@@ -0,0 +1,28 @@
+import {
+  createServer
+} from "./chunk-36XNMIHA.js";
+import "./chunk-DJBCRQTD.js";
+import "./chunk-UF3ZJMJO.js";
+import "./chunk-P3HVY2HS.js";
+import "./chunk-VSBC4SWO.js";
+import "./chunk-AF3WSNVX.js";
+import "./chunk-74ZCQKYU.js";
+import "./chunk-BDCFOP7O.js";
+import "./chunk-C6JP5NR6.js";
+import "./chunk-M6ZIC5H3.js";
+import "./chunk-PWWV2U5P.js";
+import "./chunk-RH7KPWRQ.js";
+import "./chunk-3FMK32KQ.js";
+import "./chunk-Z7NVD3OQ.js";
+import "./chunk-YDD5TC5Q.js";
+import "./chunk-37ABTUFU.js";
+import "./chunk-NU657BBQ.js";
+import "./chunk-PGAU3W3M.js";
+import "./chunk-JGEVQZDR.js";
+import "./chunk-WUAWWKTN.js";
+import "./chunk-HS5YWSGM.js";
+import "./chunk-22U7TZPN.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  createServer
+};

package/dist/setup-ADSKKBGV.js

@@ -0,0 +1,20 @@
+import {
+  promptCompanyInfo,
+  promptDatabase,
+  promptDeployment,
+  promptDomain,
+  promptRegistration,
+  provision,
+  runSetupWizard
+} from "./chunk-D24JY75H.js";
+import "./chunk-4EKXYIJF.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  promptCompanyInfo,
+  promptDatabase,
+  promptDeployment,
+  promptDomain,
+  promptRegistration,
+  provision,
+  runSetupWizard
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agenticmail/enterprise",
-  "version": "0.5.317",
+  "version": "0.5.318",
   "description": "AgenticMail Enterprise — cloud-hosted AI agent identity, email, auth & compliance for organizations",
   "type": "module",
   "bin": {

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

@@ -0,0 +1,261 @@
+/**
+ * Microsoft Excel Tools
+ *
+ * Spreadsheet operations via Microsoft Graph API — read/write cells, ranges, tables, worksheets.
+ * Works with Excel files stored in OneDrive or SharePoint.
+ */
+
+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';
+
+function itemPath(p: { itemId?: string; path?: string; driveId?: string }): string {
+  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');
+}
+
+export function createExcelTools(config: MicrosoftToolsConfig, _options?: ToolCreationOptions): AnyAgentTool[] {
+  const tp = config.tokenProvider;
+
+  return [
+    {
+      name: 'excel_list_worksheets',
+      description: 'List all worksheets in an Excel workbook.',
+      category: 'utility' as const,
+      parameters: {
+        type: 'object' as const,
+        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: string, params: any) {
+        try {
+          const token = await tp.getAccessToken();
+          const base = itemPath(params);
+          const data = await graph(token, `${base}/workbook/worksheets`);
+          const sheets = (data.value || []).map((s: any) => ({
+            id: s.id, name: s.name, position: s.position, visibility: s.visibility,
+          }));
+          return jsonResult({ worksheets: sheets, count: sheets.length });
+        } catch (e: any) { 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' as const,
+      parameters: {
+        type: 'object' as const,
+        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: string, params: any) {
+        try {
+          const token = await tp.getAccessToken();
+          const base = itemPath(params);
+          let rangePath: string;
+          if (params.range) {
+            const ws = params.worksheet ? `/worksheets/${encodeURIComponent(params.worksheet)}` : '/worksheets';
+            // If range contains !, it has sheet name embedded
+            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: any) { return errorResult(e.message); }
+      },
+    },
+
+    {
+      name: 'excel_write_range',
+      description: 'Write values to a range of cells in an Excel worksheet.',
+      category: 'utility' as const,
+      parameters: {
+        type: 'object' as const,
+        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 — each inner array is a row (e.g., [["Name","Age"],["Alice",30]])' },
+        },
+        required: ['range', 'values'],
+      },
+      async execute(_id: string, params: any) {
+        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: any) { return errorResult(e.message); }
+      },
+    },
+
+    {
+      name: 'excel_add_row',
+      description: 'Add a row to an Excel table (structured table, not just a range).',
+      category: 'utility' as const,
+      parameters: {
+        type: 'object' as const,
+        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: string, params: any) {
+        try {
+          const token = await tp.getAccessToken();
+          const base = itemPath(params);
+          let tablePath: string;
+          if (params.tableName) {
+            tablePath = params.worksheet
+              ? `${base}/workbook/worksheets/${encodeURIComponent(params.worksheet)}/tables/${encodeURIComponent(params.tableName)}`
+              : `${base}/workbook/tables/${encodeURIComponent(params.tableName)}`;
+          } else {
+            // Get first table
+            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: any) { return errorResult(e.message); }
+      },
+    },
+
+    {
+      name: 'excel_list_tables',
+      description: 'List all tables in an Excel workbook or specific worksheet.',
+      category: 'utility' as const,
+      parameters: {
+        type: 'object' as const,
+        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: string, params: any) {
+        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: any) => ({
+            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: any) { return errorResult(e.message); }
+      },
+    },
+
+    {
+      name: 'excel_read_table',
+      description: 'Read all data from an Excel table including headers.',
+      category: 'utility' as const,
+      parameters: {
+        type: 'object' as const,
+        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: string, params: any) {
+        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: any) { return errorResult(e.message); }
+      },
+    },
+
+    {
+      name: 'excel_create_worksheet',
+      description: 'Add a new worksheet to an Excel workbook.',
+      category: 'utility' as const,
+      parameters: {
+        type: 'object' as const,
+        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: string, params: any) {
+        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: any) { return errorResult(e.message); }
+      },
+    },
+  ];
+}

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

@@ -19,6 +19,9 @@ 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';
@@ -30,6 +33,9 @@ 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;
@@ -37,7 +43,20 @@ export interface MicrosoftToolsConfig {
 
 /**
  * Create all Microsoft 365 tools for an agent.
- * Returns tools covering Outlook Mail, Calendar, OneDrive, Teams, To Do, and Contacts.
+ *
+ * 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;
@@ -45,11 +64,16 @@ export function createAllMicrosoftTools(config: MicrosoftToolsConfig, options?:
   const core = !enabled; // default: load core services
 
   const tools: AnyAgentTool[] = [];
-  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));
+  // 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/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); }
+      },
+    },
+  ];
+}