@agenticmail/enterprise 0.5.326 → 0.5.328

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

@@ -1,200 +0,0 @@
-/**
- * Microsoft Planner Tools
- *
- * Project/task management boards via Microsoft Graph API.
- * Planner is Microsoft's Kanban board tool (similar to Trello).
- */
-
-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 createPlannerTools(config: MicrosoftToolsConfig, _options?: ToolCreationOptions): AnyAgentTool[] {
-  const tp = config.tokenProvider;
-
-  return [
-    {
-      name: 'planner_list_plans',
-      description: 'List all Planner plans the agent has access to (via group membership).',
-      category: 'utility' as const,
-      parameters: {
-        type: 'object' as const,
-        properties: {
-          groupId: { type: 'string', description: 'Microsoft 365 Group/Team ID to list plans for' },
-        },
-        required: ['groupId'],
-      },
-      async execute(_id: string, params: any) {
-        try {
-          const token = await tp.getAccessToken();
-          const data = await graph(token, `/groups/${params.groupId}/planner/plans`);
-          const plans = (data.value || []).map((p: any) => ({
-            id: p.id, title: p.title, created: p.createdDateTime, owner: p.owner,
-          }));
-          return jsonResult({ plans, count: plans.length });
-        } catch (e: any) { return errorResult(e.message); }
-      },
-    },
-
-    {
-      name: 'planner_list_buckets',
-      description: 'List buckets (columns) in a Planner plan.',
-      category: 'utility' as const,
-      parameters: {
-        type: 'object' as const,
-        properties: {
-          planId: { type: 'string', description: 'Plan ID' },
-        },
-        required: ['planId'],
-      },
-      async execute(_id: string, params: any) {
-        try {
-          const token = await tp.getAccessToken();
-          const data = await graph(token, `/planner/plans/${params.planId}/buckets`);
-          const buckets = (data.value || []).map((b: any) => ({
-            id: b.id, name: b.name, orderHint: b.orderHint, planId: b.planId,
-          }));
-          return jsonResult({ buckets, count: buckets.length });
-        } catch (e: any) { return errorResult(e.message); }
-      },
-    },
-
-    {
-      name: 'planner_list_tasks',
-      description: 'List tasks in a Planner plan or bucket.',
-      category: 'utility' as const,
-      parameters: {
-        type: 'object' as const,
-        properties: {
-          planId: { type: 'string', description: 'Plan ID (lists all tasks in plan)' },
-          bucketId: { type: 'string', description: 'Bucket ID (lists tasks in specific bucket)' },
-        },
-        required: [],
-      },
-      async execute(_id: string, params: any) {
-        try {
-          const token = await tp.getAccessToken();
-          const path = params.bucketId
-            ? `/planner/buckets/${params.bucketId}/tasks`
-            : `/planner/plans/${params.planId}/tasks`;
-          if (!params.planId && !params.bucketId) throw new Error('Provide planId or bucketId');
-          const data = await graph(token, path);
-          const tasks = (data.value || []).map((t: any) => ({
-            id: t.id, title: t.title, bucketId: t.bucketId,
-            percentComplete: t.percentComplete,
-            priority: t.priority, // 0-10, lower = higher
-            assignees: t.assignments ? Object.keys(t.assignments) : [],
-            dueDate: t.dueDateTime,
-            created: t.createdDateTime,
-            startDate: t.startDateTime,
-            hasDescription: t.hasDescription,
-          }));
-          return jsonResult({ tasks, count: tasks.length });
-        } catch (e: any) { return errorResult(e.message); }
-      },
-    },
-
-    {
-      name: 'planner_create_task',
-      description: 'Create a new task in a Planner plan.',
-      category: 'utility' as const,
-      parameters: {
-        type: 'object' as const,
-        properties: {
-          planId: { type: 'string', description: 'Plan ID' },
-          title: { type: 'string', description: 'Task title' },
-          bucketId: { type: 'string', description: 'Bucket ID to place the task in' },
-          assignees: { type: 'string', description: 'Comma-separated user IDs to assign' },
-          dueDate: { type: 'string', description: 'Due date (ISO 8601)' },
-          startDate: { type: 'string', description: 'Start date (ISO 8601)' },
-          priority: { type: 'number', description: 'Priority: 1 (urgent), 3 (important), 5 (medium), 9 (low)' },
-          percentComplete: { type: 'number', description: '0, 50, or 100' },
-        },
-        required: ['planId', 'title'],
-      },
-      async execute(_id: string, params: any) {
-        try {
-          const token = await tp.getAccessToken();
-          const task: any = { planId: params.planId, title: params.title };
-          if (params.bucketId) task.bucketId = params.bucketId;
-          if (params.dueDate) task.dueDateTime = params.dueDate;
-          if (params.startDate) task.startDateTime = params.startDate;
-          if (params.priority !== undefined) task.priority = params.priority;
-          if (params.percentComplete !== undefined) task.percentComplete = params.percentComplete;
-          if (params.assignees) {
-            task.assignments = {};
-            params.assignees.split(',').forEach((id: string) => {
-              task.assignments[id.trim()] = { '@odata.type': '#microsoft.graph.plannerAssignment', orderHint: ' !' };
-            });
-          }
-          const created = await graph(token, '/planner/tasks', { method: 'POST', body: task });
-          return jsonResult({ id: created.id, title: created.title, created: true });
-        } catch (e: any) { return errorResult(e.message); }
-      },
-    },
-
-    {
-      name: 'planner_update_task',
-      description: 'Update a Planner task (title, progress, bucket, priority, assignments).',
-      category: 'utility' as const,
-      parameters: {
-        type: 'object' as const,
-        properties: {
-          taskId: { type: 'string', description: 'Task ID' },
-          title: { type: 'string', description: 'New title' },
-          percentComplete: { type: 'number', description: '0 (not started), 50 (in progress), 100 (completed)' },
-          bucketId: { type: 'string', description: 'Move to different bucket' },
-          priority: { type: 'number', description: '1 (urgent), 3 (important), 5 (medium), 9 (low)' },
-          dueDate: { type: 'string', description: 'Due date (ISO 8601)' },
-        },
-        required: ['taskId'],
-      },
-      async execute(_id: string, params: any) {
-        try {
-          const token = await tp.getAccessToken();
-          // Need etag for update
-          const existing = await graph(token, `/planner/tasks/${params.taskId}`, {
-            query: { '$select': 'id' }
-          });
-          const etag = existing['@odata.etag'];
-          const update: any = {};
-          if (params.title) update.title = params.title;
-          if (params.percentComplete !== undefined) update.percentComplete = params.percentComplete;
-          if (params.bucketId) update.bucketId = params.bucketId;
-          if (params.priority !== undefined) update.priority = params.priority;
-          if (params.dueDate) update.dueDateTime = params.dueDate;
-          await graph(token, `/planner/tasks/${params.taskId}`, {
-            method: 'PATCH', body: update,
-            headers: { 'If-Match': etag },
-          });
-          return jsonResult({ updated: true, taskId: params.taskId });
-        } catch (e: any) { return errorResult(e.message); }
-      },
-    },
-
-    {
-      name: 'planner_delete_task',
-      description: 'Delete a Planner task.',
-      category: 'utility' as const,
-      parameters: {
-        type: 'object' as const,
-        properties: {
-          taskId: { type: 'string', description: 'Task ID to delete' },
-        },
-        required: ['taskId'],
-      },
-      async execute(_id: string, params: any) {
-        try {
-          const token = await tp.getAccessToken();
-          const existing = await graph(token, `/planner/tasks/${params.taskId}`, { query: { '$select': 'id' } });
-          await graph(token, `/planner/tasks/${params.taskId}`, {
-            method: 'DELETE',
-            headers: { 'If-Match': existing['@odata.etag'] },
-          });
-          return jsonResult({ deleted: true, taskId: params.taskId });
-        } catch (e: any) { return errorResult(e.message); }
-      },
-    },
-  ];
-}

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

@@ -1,266 +0,0 @@
-/**
- * Microsoft Power BI Tools
- *
- * Reports, dashboards, datasets, and data refresh via Power BI REST API.
- * Uses Microsoft Graph API + Power BI API endpoints.
- */
-
-import type { AnyAgentTool, ToolCreationOptions } from '../../types.js';
-import { jsonResult, errorResult } from '../../common.js';
-import type { MicrosoftToolsConfig } from './index.js';
-
-const PBI_BASE = 'https://api.powerbi.com/v1.0/myorg';
-
-async function pbi(token: string, path: string, opts?: { method?: string; body?: any; query?: Record<string, string> }): Promise<any> {
-  const method = opts?.method || 'GET';
-  const url = new URL(PBI_BASE + path);
-  if (opts?.query) for (const [k, v] of Object.entries(opts.query)) { if (v) url.searchParams.set(k, v); }
-  const res = await fetch(url.toString(), {
-    method,
-    headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
-    body: opts?.body ? JSON.stringify(opts.body) : undefined,
-  });
-  if (!res.ok) {
-    const err = await res.text();
-    throw new Error(`Power BI API ${res.status}: ${err}`);
-  }
-  if (res.status === 200 || res.status === 201) return res.json().catch(() => ({}));
-  return {};
-}
-
-export function createPowerBITools(config: MicrosoftToolsConfig, _options?: ToolCreationOptions): AnyAgentTool[] {
-  const tp = config.tokenProvider;
-
-  return [
-    {
-      name: 'powerbi_list_workspaces',
-      description: 'List Power BI workspaces (groups) the agent has access to.',
-      category: 'utility' as const,
-      parameters: { type: 'object' as const, properties: {}, required: [] },
-      async execute(_id: string) {
-        try {
-          const token = await tp.getAccessToken();
-          const data = await pbi(token, '/groups');
-          const workspaces = (data.value || []).map((w: any) => ({
-            id: w.id, name: w.name, isOnDedicatedCapacity: w.isOnDedicatedCapacity,
-            type: w.type,
-          }));
-          return jsonResult({ workspaces, count: workspaces.length });
-        } catch (e: any) { return errorResult(e.message); }
-      },
-    },
-
-    {
-      name: 'powerbi_list_reports',
-      description: 'List reports in a Power BI workspace.',
-      category: 'utility' as const,
-      parameters: {
-        type: 'object' as const,
-        properties: {
-          workspaceId: { type: 'string', description: 'Workspace (group) ID. Omit for "My Workspace".' },
-        },
-        required: [],
-      },
-      async execute(_id: string, params: any) {
-        try {
-          const token = await tp.getAccessToken();
-          const path = params.workspaceId
-            ? `/groups/${params.workspaceId}/reports`
-            : '/reports';
-          const data = await pbi(token, path);
-          const reports = (data.value || []).map((r: any) => ({
-            id: r.id, name: r.name, datasetId: r.datasetId,
-            webUrl: r.webUrl, embedUrl: r.embedUrl,
-            reportType: r.reportType,
-          }));
-          return jsonResult({ reports, count: reports.length });
-        } catch (e: any) { return errorResult(e.message); }
-      },
-    },
-
-    {
-      name: 'powerbi_list_dashboards',
-      description: 'List dashboards in a Power BI workspace.',
-      category: 'utility' as const,
-      parameters: {
-        type: 'object' as const,
-        properties: {
-          workspaceId: { type: 'string', description: 'Workspace ID. Omit for "My Workspace".' },
-        },
-        required: [],
-      },
-      async execute(_id: string, params: any) {
-        try {
-          const token = await tp.getAccessToken();
-          const path = params.workspaceId
-            ? `/groups/${params.workspaceId}/dashboards`
-            : '/dashboards';
-          const data = await pbi(token, path);
-          const dashboards = (data.value || []).map((d: any) => ({
-            id: d.id, displayName: d.displayName,
-            webUrl: d.webUrl, embedUrl: d.embedUrl,
-            isReadOnly: d.isReadOnly,
-          }));
-          return jsonResult({ dashboards, count: dashboards.length });
-        } catch (e: any) { return errorResult(e.message); }
-      },
-    },
-
-    {
-      name: 'powerbi_list_datasets',
-      description: 'List datasets in a Power BI workspace.',
-      category: 'utility' as const,
-      parameters: {
-        type: 'object' as const,
-        properties: {
-          workspaceId: { type: 'string', description: 'Workspace ID. Omit for "My Workspace".' },
-        },
-        required: [],
-      },
-      async execute(_id: string, params: any) {
-        try {
-          const token = await tp.getAccessToken();
-          const path = params.workspaceId
-            ? `/groups/${params.workspaceId}/datasets`
-            : '/datasets';
-          const data = await pbi(token, path);
-          const datasets = (data.value || []).map((d: any) => ({
-            id: d.id, name: d.name,
-            configuredBy: d.configuredBy,
-            isRefreshable: d.isRefreshable,
-            isOnPremGatewayRequired: d.isOnPremGatewayRequired,
-            webUrl: d.webUrl,
-          }));
-          return jsonResult({ datasets, count: datasets.length });
-        } catch (e: any) { return errorResult(e.message); }
-      },
-    },
-
-    {
-      name: 'powerbi_refresh_dataset',
-      description: 'Trigger a data refresh on a Power BI dataset.',
-      category: 'utility' as const,
-      parameters: {
-        type: 'object' as const,
-        properties: {
-          datasetId: { type: 'string', description: 'Dataset ID to refresh' },
-          workspaceId: { type: 'string', description: 'Workspace ID (omit for My Workspace)' },
-          notifyOption: { type: 'string', description: 'NoNotification, MailOnFailure, or MailOnCompletion (default: NoNotification)' },
-        },
-        required: ['datasetId'],
-      },
-      async execute(_id: string, params: any) {
-        try {
-          const token = await tp.getAccessToken();
-          const path = params.workspaceId
-            ? `/groups/${params.workspaceId}/datasets/${params.datasetId}/refreshes`
-            : `/datasets/${params.datasetId}/refreshes`;
-          await pbi(token, path, {
-            method: 'POST',
-            body: { notifyOption: params.notifyOption || 'NoNotification' },
-          });
-          return jsonResult({ refreshTriggered: true, datasetId: params.datasetId });
-        } catch (e: any) { return errorResult(e.message); }
-      },
-    },
-
-    {
-      name: 'powerbi_refresh_history',
-      description: 'Get refresh history for a dataset.',
-      category: 'utility' as const,
-      parameters: {
-        type: 'object' as const,
-        properties: {
-          datasetId: { type: 'string', description: 'Dataset ID' },
-          workspaceId: { type: 'string', description: 'Workspace ID' },
-          maxResults: { type: 'number', description: 'Max results (default: 10)' },
-        },
-        required: ['datasetId'],
-      },
-      async execute(_id: string, params: any) {
-        try {
-          const token = await tp.getAccessToken();
-          const path = params.workspaceId
-            ? `/groups/${params.workspaceId}/datasets/${params.datasetId}/refreshes`
-            : `/datasets/${params.datasetId}/refreshes`;
-          const data = await pbi(token, path, {
-            query: { '$top': String(params.maxResults || 10) }
-          });
-          const history = (data.value || []).map((r: any) => ({
-            id: r.requestId, refreshType: r.refreshType,
-            status: r.status, startTime: r.startTime, endTime: r.endTime,
-            serviceExceptionJson: r.serviceExceptionJson,
-          }));
-          return jsonResult({ refreshHistory: history, count: history.length });
-        } catch (e: any) { return errorResult(e.message); }
-      },
-    },
-
-    {
-      name: 'powerbi_execute_query',
-      description: 'Execute a DAX query against a Power BI dataset. Returns tabular results.',
-      category: 'utility' as const,
-      parameters: {
-        type: 'object' as const,
-        properties: {
-          datasetId: { type: 'string', description: 'Dataset ID' },
-          workspaceId: { type: 'string', description: 'Workspace ID' },
-          query: { type: 'string', description: 'DAX query (e.g., "EVALUATE TOPN(10, \'Sales\', \'Sales\'[Amount], DESC)")' },
-        },
-        required: ['datasetId', 'query'],
-      },
-      async execute(_id: string, params: any) {
-        try {
-          const token = await tp.getAccessToken();
-          const path = params.workspaceId
-            ? `/groups/${params.workspaceId}/datasets/${params.datasetId}/executeQueries`
-            : `/datasets/${params.datasetId}/executeQueries`;
-          const data = await pbi(token, path, {
-            method: 'POST',
-            body: {
-              queries: [{ query: params.query }],
-              serializerSettings: { includeNulls: true },
-            },
-          });
-          const result = data.results?.[0];
-          const tables = result?.tables?.[0];
-          return jsonResult({
-            columns: tables?.columns?.map((c: any) => c.name),
-            rows: tables?.rows,
-            rowCount: tables?.rows?.length || 0,
-          });
-        } catch (e: any) { return errorResult(e.message); }
-      },
-    },
-
-    {
-      name: 'powerbi_dashboard_tiles',
-      description: 'List tiles (widgets) on a Power BI dashboard.',
-      category: 'utility' as const,
-      parameters: {
-        type: 'object' as const,
-        properties: {
-          dashboardId: { type: 'string', description: 'Dashboard ID' },
-          workspaceId: { type: 'string', description: 'Workspace ID' },
-        },
-        required: ['dashboardId'],
-      },
-      async execute(_id: string, params: any) {
-        try {
-          const token = await tp.getAccessToken();
-          const path = params.workspaceId
-            ? `/groups/${params.workspaceId}/dashboards/${params.dashboardId}/tiles`
-            : `/dashboards/${params.dashboardId}/tiles`;
-          const data = await pbi(token, path);
-          const tiles = (data.value || []).map((t: any) => ({
-            id: t.id, title: t.title,
-            reportId: t.reportId, datasetId: t.datasetId,
-            embedUrl: t.embedUrl,
-            rowSpan: t.rowSpan, colSpan: t.colSpan,
-          }));
-          return jsonResult({ tiles, count: tiles.length });
-        } catch (e: any) { return errorResult(e.message); }
-      },
-    },
-  ];
-}

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

@@ -1,186 +0,0 @@
-/**
- * Microsoft PowerPoint Tools
- *
- * Presentation operations via Microsoft Graph API — slides, export, create from template.
- * PowerPoint files must be 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 PowerPoint file');
-}
-
-export function createPowerPointTools(config: MicrosoftToolsConfig, _options?: ToolCreationOptions): AnyAgentTool[] {
-  const tp = config.tokenProvider;
-
-  return [
-    {
-      name: 'powerpoint_get_info',
-      description: 'Get metadata and slide count of a PowerPoint presentation.',
-      category: 'utility' as const,
-      parameters: {
-        type: 'object' as const,
-        properties: {
-          itemId: { type: 'string', description: 'OneDrive/SharePoint item ID' },
-          path: { type: 'string', description: 'File path (e.g., "/Documents/Deck.pptx")' },
-          driveId: { type: 'string', description: 'Drive ID (for SharePoint)' },
-        },
-        required: [],
-      },
-      async execute(_id: string, params: any) {
-        try {
-          const token = await tp.getAccessToken();
-          const base = itemPath(params);
-          const meta = await graph(token, base, {
-            query: { '$select': 'id,name,size,webUrl,createdDateTime,lastModifiedDateTime,file' }
-          });
-          // Get slide count via preview
-          let slideCount: number | null = null;
-          try {
-            const _preview = await graph(token, `${base}/preview`, { method: 'POST', body: {} });
-            // Preview doesn't directly give count, but we can try thumbnails
-            const thumbs = await graph(token, `${base}/thumbnails`);
-            if (thumbs.value?.[0]) slideCount = Object.keys(thumbs.value[0]).filter((k: string) => k !== 'id').length;
-          } catch {}
-          return jsonResult({
-            id: meta.id, name: meta.name, size: meta.size,
-            webUrl: meta.webUrl, mimeType: meta.file?.mimeType,
-            created: meta.createdDateTime, modified: meta.lastModifiedDateTime,
-            slideCount,
-          });
-        } catch (e: any) { return errorResult(e.message); }
-      },
-    },
-
-    {
-      name: 'powerpoint_export_pdf',
-      description: 'Export/convert a PowerPoint presentation to PDF.',
-      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' },
-        },
-        required: [],
-      },
-      async execute(_id: string, params: any) {
-        try {
-          const token = await tp.getAccessToken();
-          const base = itemPath(params);
-          const res = await fetch(`https://graph.microsoft.com/v1.0${base}/content?format=pdf`, {
-            headers: { Authorization: `Bearer ${token}` },
-            redirect: 'follow',
-          });
-          if (!res.ok) throw new Error(`Export failed: ${res.status}`);
-          const buf = Buffer.from(await res.arrayBuffer());
-          return jsonResult({
-            format: 'pdf',
-            sizeBytes: buf.length,
-            base64: buf.toString('base64'),
-            note: 'PDF content returned as base64. Save to file or send as attachment.',
-          });
-        } catch (e: any) { return errorResult(e.message); }
-      },
-    },
-
-    {
-      name: 'powerpoint_get_thumbnails',
-      description: 'Get thumbnail images of slides in a presentation.',
-      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' },
-          size: { type: 'string', description: 'Thumbnail size: small, medium, large (default: medium)' },
-        },
-        required: [],
-      },
-      async execute(_id: string, params: any) {
-        try {
-          const token = await tp.getAccessToken();
-          const base = itemPath(params);
-          const data = await graph(token, `${base}/thumbnails`);
-          const size = params.size || 'medium';
-          const thumbs = (data.value || []).map((set: any, i: number) => {
-            const t = set[size] || set.medium || set.large || set.small;
-            return { slide: i + 1, url: t?.url, width: t?.width, height: t?.height };
-          }).filter((t: any) => t.url);
-          return jsonResult({ thumbnails: thumbs, count: thumbs.length });
-        } catch (e: any) { return errorResult(e.message); }
-      },
-    },
-
-    {
-      name: 'powerpoint_create_from_template',
-      description: 'Create a new PowerPoint by copying a template file. Returns the new file for editing.',
-      category: 'utility' as const,
-      parameters: {
-        type: 'object' as const,
-        properties: {
-          templateItemId: { type: 'string', description: 'Item ID of the template .pptx' },
-          templatePath: { type: 'string', description: 'Path of the template (alternative to itemId)' },
-          newName: { type: 'string', description: 'Name for the new file (e.g., "Q1 Report.pptx")' },
-          destFolder: { type: 'string', description: 'Destination folder path (default: same as template)' },
-        },
-        required: ['newName'],
-      },
-      async execute(_id: string, params: any) {
-        try {
-          const token = await tp.getAccessToken();
-          const base = params.templateItemId
-            ? `/me/drive/items/${params.templateItemId}`
-            : `/me/drive/root:${params.templatePath}:`;
-          const parentRef: any = {};
-          if (params.destFolder) parentRef.path = `/drive/root:${params.destFolder}`;
-          const copy = await graph(token, `${base}/copy`, {
-            method: 'POST',
-            body: { name: params.newName, ...(params.destFolder ? { parentReference: parentRef } : {}) },
-          });
-          return jsonResult({
-            status: 'copy_initiated',
-            monitorUrl: copy['@odata.context'] || null,
-            name: params.newName,
-            note: 'Copy is async. File will appear in OneDrive shortly.',
-          });
-        } catch (e: any) { return errorResult(e.message); }
-      },
-    },
-
-    {
-      name: 'powerpoint_get_embed_url',
-      description: 'Get an embeddable preview URL for a PowerPoint presentation.',
-      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' },
-        },
-        required: [],
-      },
-      async execute(_id: string, params: any) {
-        try {
-          const token = await tp.getAccessToken();
-          const base = itemPath(params);
-          const preview = await graph(token, `${base}/preview`, { method: 'POST', body: {} });
-          return jsonResult({
-            embedUrl: preview.getUrl,
-            editUrl: preview.postUrl,
-          });
-        } catch (e: any) { return errorResult(e.message); }
-      },
-    },
-  ];
-}