@agenticmail/enterprise 0.5.75 → 0.5.77

package/src/agent-tools/tools/google/contacts.ts

@@ -0,0 +1,209 @@
+/**
+ * Google Contacts (People API) Tools
+ *
+ * Search, list, create, and update contacts via Google People API v1.
+ */
+
+import type { AnyAgentTool, ToolCreationOptions } from '../../types.js';
+import { jsonResult, errorResult } from '../../common.js';
+import type { GoogleToolsConfig } from './index.js';
+
+const BASE = 'https://people.googleapis.com/v1';
+
+async function papi(token: string, path: string, opts?: { method?: string; body?: any; query?: Record<string, string> }): Promise<any> {
+  const url = new URL(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: opts?.method || 'GET',
+    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(`People API ${res.status}: ${err}`); }
+  return res.json();
+}
+
+function mapPerson(p: any) {
+  return {
+    resourceName: p.resourceName,
+    name: p.names?.[0]?.displayName,
+    firstName: p.names?.[0]?.givenName,
+    lastName: p.names?.[0]?.familyName,
+    emails: (p.emailAddresses || []).map((e: any) => ({ value: e.value, type: e.type })),
+    phones: (p.phoneNumbers || []).map((ph: any) => ({ value: ph.value, type: ph.type })),
+    organization: p.organizations?.[0]?.name,
+    jobTitle: p.organizations?.[0]?.title,
+    department: p.organizations?.[0]?.department,
+    addresses: (p.addresses || []).map((a: any) => ({ formatted: a.formattedValue, type: a.type })),
+    birthday: p.birthdays?.[0]?.date ? `${p.birthdays[0].date.year || '????'}-${String(p.birthdays[0].date.month).padStart(2, '0')}-${String(p.birthdays[0].date.day).padStart(2, '0')}` : undefined,
+    notes: p.biographies?.[0]?.value,
+  };
+}
+
+const PERSON_FIELDS = 'names,emailAddresses,phoneNumbers,organizations,addresses,birthdays,biographies';
+
+export function createGoogleContactsTools(config: GoogleToolsConfig, _options?: ToolCreationOptions): AnyAgentTool[] {
+  const tp = config.tokenProvider;
+  return [
+    {
+      name: 'google_contacts_list',
+      description: 'List contacts from the agent\'s Google directory. Returns names, emails, phones, organizations.',
+      category: 'utility' as const,
+      parameters: {
+        type: 'object' as const,
+        properties: {
+          maxResults: { type: 'number', description: 'Max contacts to return (default: 50, max: 200)' },
+          sortOrder: { type: 'string', description: '"FIRST_NAME_ASCENDING" or "LAST_NAME_ASCENDING"' },
+        },
+        required: [],
+      },
+      async execute(_id: string, params: any) {
+        try {
+          const token = await tp.getAccessToken();
+          const data = await papi(token, '/people/me/connections', {
+            query: {
+              personFields: PERSON_FIELDS,
+              pageSize: String(Math.min(params.maxResults || 50, 200)),
+              sortOrder: params.sortOrder || 'FIRST_NAME_ASCENDING',
+            },
+          });
+          const contacts = (data.connections || []).map(mapPerson);
+          return jsonResult({ contacts, count: contacts.length, totalPeople: data.totalPeople });
+        } catch (e: any) { return errorResult(e.message); }
+      },
+    },
+    {
+      name: 'google_contacts_search',
+      description: 'Search contacts by name, email, or phone number.',
+      category: 'utility' as const,
+      parameters: {
+        type: 'object' as const,
+        properties: {
+          query: { type: 'string', description: 'Search term (required)' },
+          maxResults: { type: 'number', description: 'Max results (default: 20)' },
+        },
+        required: ['query'],
+      },
+      async execute(_id: string, params: any) {
+        try {
+          const token = await tp.getAccessToken();
+          const data = await papi(token, '/people:searchContacts', {
+            query: {
+              query: params.query,
+              readMask: PERSON_FIELDS,
+              pageSize: String(Math.min(params.maxResults || 20, 30)),
+            },
+          });
+          const contacts = (data.results || []).map((r: any) => mapPerson(r.person));
+          return jsonResult({ contacts, count: contacts.length, query: params.query });
+        } catch (e: any) { return errorResult(e.message); }
+      },
+    },
+    {
+      name: 'google_contacts_search_directory',
+      description: 'Search the organization\'s Google Workspace directory (all employees). Requires domain-wide access.',
+      category: 'utility' as const,
+      parameters: {
+        type: 'object' as const,
+        properties: {
+          query: { type: 'string', description: 'Search term (required)' },
+          maxResults: { type: 'number', description: 'Max results (default: 20)' },
+        },
+        required: ['query'],
+      },
+      async execute(_id: string, params: any) {
+        try {
+          const token = await tp.getAccessToken();
+          const data = await papi(token, '/people:searchDirectoryPeople', {
+            query: {
+              query: params.query,
+              readMask: PERSON_FIELDS,
+              pageSize: String(Math.min(params.maxResults || 20, 50)),
+              sources: 'DIRECTORY_SOURCE_TYPE_DOMAIN_PROFILE',
+            },
+          });
+          const people = (data.people || []).map(mapPerson);
+          return jsonResult({ people, count: people.length, query: params.query });
+        } catch (e: any) { return errorResult(e.message); }
+      },
+    },
+    {
+      name: 'google_contacts_create',
+      description: 'Create a new contact in the agent\'s Google Contacts.',
+      category: 'utility' as const,
+      parameters: {
+        type: 'object' as const,
+        properties: {
+          firstName: { type: 'string', description: 'First name (required)' },
+          lastName: { type: 'string', description: 'Last name' },
+          email: { type: 'string', description: 'Email address' },
+          phone: { type: 'string', description: 'Phone number' },
+          organization: { type: 'string', description: 'Company/organization name' },
+          jobTitle: { type: 'string', description: 'Job title' },
+          notes: { type: 'string', description: 'Notes about this contact' },
+        },
+        required: ['firstName'],
+      },
+      async execute(_id: string, params: any) {
+        try {
+          const token = await tp.getAccessToken();
+          const person: any = { names: [{ givenName: params.firstName, familyName: params.lastName }] };
+          if (params.email) person.emailAddresses = [{ value: params.email, type: 'work' }];
+          if (params.phone) person.phoneNumbers = [{ value: params.phone, type: 'work' }];
+          if (params.organization || params.jobTitle) {
+            person.organizations = [{ name: params.organization, title: params.jobTitle }];
+          }
+          if (params.notes) person.biographies = [{ value: params.notes, contentType: 'TEXT_PLAIN' }];
+          const result = await papi(token, '/people:createContact', {
+            method: 'POST', body: person,
+            query: { personFields: PERSON_FIELDS },
+          });
+          return jsonResult({ created: true, contact: mapPerson(result) });
+        } catch (e: any) { return errorResult(e.message); }
+      },
+    },
+    {
+      name: 'google_contacts_update',
+      description: 'Update an existing contact.',
+      category: 'utility' as const,
+      parameters: {
+        type: 'object' as const,
+        properties: {
+          resourceName: { type: 'string', description: 'Contact resource name, e.g. "people/c1234567890" (required)' },
+          firstName: { type: 'string', description: 'New first name' },
+          lastName: { type: 'string', description: 'New last name' },
+          email: { type: 'string', description: 'New email' },
+          phone: { type: 'string', description: 'New phone' },
+          organization: { type: 'string', description: 'New organization' },
+          jobTitle: { type: 'string', description: 'New job title' },
+        },
+        required: ['resourceName'],
+      },
+      async execute(_id: string, params: any) {
+        try {
+          const token = await tp.getAccessToken();
+          // Get current etag
+          const current = await papi(token, `/${params.resourceName}`, {
+            query: { personFields: PERSON_FIELDS },
+          });
+          const person: any = { etag: current.etag };
+          const updateFields: string[] = [];
+          if (params.firstName || params.lastName) {
+            person.names = [{ givenName: params.firstName || current.names?.[0]?.givenName, familyName: params.lastName || current.names?.[0]?.familyName }];
+            updateFields.push('names');
+          }
+          if (params.email) { person.emailAddresses = [{ value: params.email, type: 'work' }]; updateFields.push('emailAddresses'); }
+          if (params.phone) { person.phoneNumbers = [{ value: params.phone, type: 'work' }]; updateFields.push('phoneNumbers'); }
+          if (params.organization || params.jobTitle) {
+            person.organizations = [{ name: params.organization || current.organizations?.[0]?.name, title: params.jobTitle || current.organizations?.[0]?.title }];
+            updateFields.push('organizations');
+          }
+          const result = await papi(token, `/${params.resourceName}:updateContact`, {
+            method: 'PATCH', body: person,
+            query: { updatePersonFields: updateFields.join(','), personFields: PERSON_FIELDS },
+          });
+          return jsonResult({ updated: true, contact: mapPerson(result) });
+        } catch (e: any) { return errorResult(e.message); }
+      },
+    },
+  ];
+}

package/src/agent-tools/tools/google/docs.ts

@@ -0,0 +1,162 @@
+/**
+ * Google Docs Tools
+ *
+ * Read and write Google Docs via Google Docs API v1.
+ */
+
+import type { AnyAgentTool, ToolCreationOptions } from '../../types.js';
+import { jsonResult, errorResult } from '../../common.js';
+import type { GoogleToolsConfig } from './index.js';
+
+const DOCS_BASE = 'https://docs.googleapis.com/v1/documents';
+const DRIVE_BASE = 'https://www.googleapis.com/drive/v3';
+
+async function dapi(token: string, path: string, opts?: { method?: string; body?: any; base?: string }): Promise<any> {
+  const base = opts?.base || DOCS_BASE;
+  const res = await fetch(base + path, {
+    method: opts?.method || 'GET',
+    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(`Google Docs API ${res.status}: ${err}`); }
+  return res.json();
+}
+
+function extractText(doc: any): string {
+  const parts: string[] = [];
+  for (const el of doc.body?.content || []) {
+    if (el.paragraph) {
+      for (const pe of el.paragraph.elements || []) {
+        if (pe.textRun?.content) parts.push(pe.textRun.content);
+      }
+    } else if (el.table) {
+      for (const row of el.table.tableRows || []) {
+        const cells: string[] = [];
+        for (const cell of row.tableCells || []) {
+          const cellText: string[] = [];
+          for (const cp of cell.content || []) {
+            if (cp.paragraph) {
+              for (const pe of cp.paragraph.elements || []) {
+                if (pe.textRun?.content) cellText.push(pe.textRun.content.trim());
+              }
+            }
+          }
+          cells.push(cellText.join(''));
+        }
+        parts.push(cells.join('\t'));
+      }
+    }
+  }
+  return parts.join('');
+}
+
+export function createGoogleDocsTools(config: GoogleToolsConfig, _options?: ToolCreationOptions): AnyAgentTool[] {
+  const tp = config.tokenProvider;
+  return [
+    {
+      name: 'google_docs_read',
+      description: 'Read the full text content of a Google Doc.',
+      category: 'utility' as const,
+      parameters: {
+        type: 'object' as const,
+        properties: {
+          documentId: { type: 'string', description: 'Document ID (required)' },
+        },
+        required: ['documentId'],
+      },
+      async execute(_id: string, params: any) {
+        try {
+          const token = await tp.getAccessToken();
+          const doc = await dapi(token, `/${params.documentId}`);
+          const text = extractText(doc);
+          return jsonResult({
+            documentId: doc.documentId, title: doc.title,
+            content: text.slice(0, 80000),
+            truncated: text.length > 80000,
+            characterCount: text.length,
+          });
+        } catch (e: any) { return errorResult(e.message); }
+      },
+    },
+    {
+      name: 'google_docs_create',
+      description: 'Create a new Google Doc with optional initial content.',
+      category: 'utility' as const,
+      parameters: {
+        type: 'object' as const,
+        properties: {
+          title: { type: 'string', description: 'Document title (required)' },
+          content: { type: 'string', description: 'Initial text content to insert' },
+          folderId: { type: 'string', description: 'Parent folder ID in Drive' },
+        },
+        required: ['title'],
+      },
+      async execute(_id: string, params: any) {
+        try {
+          const token = await tp.getAccessToken();
+          const doc = await dapi(token, '', { method: 'POST', body: { title: params.title } });
+          // Insert content if provided
+          if (params.content) {
+            await dapi(token, `/${doc.documentId}:batchUpdate`, {
+              method: 'POST',
+              body: { requests: [{ insertText: { location: { index: 1 }, text: params.content } }] },
+            });
+          }
+          // Move to folder if specified
+          if (params.folderId) {
+            const file = await fetch(`${DRIVE_BASE}/files/${doc.documentId}?fields=parents`, {
+              headers: { Authorization: `Bearer ${token}` },
+            }).then(r => r.json()) as any;
+            await fetch(`${DRIVE_BASE}/files/${doc.documentId}?addParents=${params.folderId}&removeParents=${(file.parents || []).join(',')}&fields=id`, {
+              method: 'PATCH', headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+            });
+          }
+          return jsonResult({ created: true, documentId: doc.documentId, title: doc.title, url: `https://docs.google.com/document/d/${doc.documentId}/edit` });
+        } catch (e: any) { return errorResult(e.message); }
+      },
+    },
+    {
+      name: 'google_docs_write',
+      description: 'Insert, replace, or append text in a Google Doc.',
+      category: 'utility' as const,
+      parameters: {
+        type: 'object' as const,
+        properties: {
+          documentId: { type: 'string', description: 'Document ID (required)' },
+          action: { type: 'string', description: '"append" (add to end), "insert" (at index), or "replace" (find & replace) (required)' },
+          text: { type: 'string', description: 'Text to insert/append (required for append/insert)' },
+          index: { type: 'number', description: 'Character index for insert (1-based, required for insert action)' },
+          find: { type: 'string', description: 'Text to find (required for replace action)' },
+          replaceWith: { type: 'string', description: 'Replacement text (required for replace action)' },
+          matchCase: { type: 'string', description: '"true" for case-sensitive replace (default: "false")' },
+        },
+        required: ['documentId', 'action'],
+      },
+      async execute(_id: string, params: any) {
+        try {
+          const token = await tp.getAccessToken();
+          const requests: any[] = [];
+          if (params.action === 'append') {
+            const doc = await dapi(token, `/${params.documentId}`);
+            const endIndex = doc.body?.content?.slice(-1)?.[0]?.endIndex || 1;
+            requests.push({ insertText: { location: { index: Math.max(endIndex - 1, 1) }, text: params.text } });
+          } else if (params.action === 'insert') {
+            requests.push({ insertText: { location: { index: params.index || 1 }, text: params.text } });
+          } else if (params.action === 'replace') {
+            requests.push({
+              replaceAllText: {
+                containsText: { text: params.find, matchCase: params.matchCase === 'true' },
+                replaceText: params.replaceWith || '',
+              },
+            });
+          } else {
+            return errorResult('action must be "append", "insert", or "replace"');
+          }
+          const result = await dapi(token, `/${params.documentId}:batchUpdate`, { method: 'POST', body: { requests } });
+          const replaceCount = result.replies?.[0]?.replaceAllText?.occurrencesChanged;
+          return jsonResult({ success: true, action: params.action, ...(replaceCount !== undefined && { replacements: replaceCount }) });
+        } catch (e: any) { return errorResult(e.message); }
+      },
+    },
+  ];
+}

package/src/agent-tools/tools/google/drive.ts

@@ -0,0 +1,262 @@
+/**
+ * Google Drive Tools
+ *
+ * File management, search, sharing, and content access via Google Drive API v3.
+ */
+
+import type { AnyAgentTool, ToolCreationOptions } from '../../types.js';
+import { jsonResult, errorResult } from '../../common.js';
+import type { GoogleToolsConfig } from './index.js';
+
+const BASE = 'https://www.googleapis.com/drive/v3';
+const UPLOAD_BASE = 'https://www.googleapis.com/upload/drive/v3';
+
+async function gapi(token: string, path: string, opts?: { method?: string; body?: any; query?: Record<string, string>; base?: string; rawBody?: BodyInit; headers?: Record<string, string> }): Promise<any> {
+  const method = opts?.method || 'GET';
+  const base = opts?.base || BASE;
+  const url = new URL(base + path);
+  if (opts?.query) for (const [k, v] of Object.entries(opts.query)) { if (v) url.searchParams.set(k, v); }
+  const headers: Record<string, string> = { Authorization: `Bearer ${token}`, ...opts?.headers };
+  if (!opts?.rawBody) 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(`Google Drive API ${res.status}: ${err}`); }
+  if (res.status === 204) return {};
+  return res.json();
+}
+
+export function createGoogleDriveTools(config: GoogleToolsConfig, _options?: ToolCreationOptions): AnyAgentTool[] {
+  const tp = config.tokenProvider;
+  return [
+    {
+      name: 'google_drive_list',
+      description: 'List files and folders in Google Drive. Supports search queries, folder filtering, and MIME type filtering.',
+      category: 'utility' as const,
+      parameters: {
+        type: 'object' as const,
+        properties: {
+          query: { type: 'string', description: 'Search query (Drive query syntax, e.g. "name contains \'report\'" or free text)' },
+          folderId: { type: 'string', description: 'List files in a specific folder' },
+          mimeType: { type: 'string', description: 'Filter by MIME type (e.g. "application/vnd.google-apps.spreadsheet")' },
+          maxResults: { type: 'number', description: 'Max results (default: 25, max: 100)' },
+          orderBy: { type: 'string', description: 'Sort order (e.g. "modifiedTime desc", "name")' },
+          sharedWithMe: { type: 'string', description: 'If "true", show only files shared with agent' },
+          trashed: { type: 'string', description: 'If "true", show trashed files' },
+        },
+        required: [],
+      },
+      async execute(_id: string, params: any) {
+        try {
+          const token = await tp.getAccessToken();
+          const parts: string[] = [];
+          if (params.folderId) parts.push(`'${params.folderId}' in parents`);
+          if (params.mimeType) parts.push(`mimeType = '${params.mimeType}'`);
+          if (params.sharedWithMe === 'true') parts.push('sharedWithMe = true');
+          if (params.trashed !== 'true') parts.push('trashed = false');
+          if (params.query) {
+            // If it looks like Drive query syntax, use as-is; otherwise wrap in fullText
+            if (params.query.includes('=') || params.query.includes('in parents') || params.query.includes('contains')) {
+              parts.push(params.query);
+            } else {
+              parts.push(`fullText contains '${params.query.replace(/'/g, "\\'")}'`);
+            }
+          }
+          const q: Record<string, string> = {
+            fields: 'files(id,name,mimeType,size,modifiedTime,createdTime,owners,shared,webViewLink,parents)',
+            pageSize: String(Math.min(params.maxResults || 25, 100)),
+          };
+          if (parts.length) q.q = parts.join(' and ');
+          if (params.orderBy) q.orderBy = params.orderBy;
+          const data = await gapi(token, '/files', { query: q });
+          const files = (data.files || []).map((f: any) => ({
+            id: f.id, name: f.name, mimeType: f.mimeType,
+            size: f.size ? Number(f.size) : undefined,
+            modifiedTime: f.modifiedTime, createdTime: f.createdTime,
+            owner: f.owners?.[0]?.emailAddress, shared: f.shared,
+            webViewLink: f.webViewLink, parentId: f.parents?.[0],
+            isFolder: f.mimeType === 'application/vnd.google-apps.folder',
+          }));
+          return jsonResult({ files, count: files.length });
+        } catch (e: any) { return errorResult(e.message); }
+      },
+    },
+    {
+      name: 'google_drive_get',
+      description: 'Get metadata and content of a file. For Google Docs/Sheets/Slides, exports as text. For other files, returns metadata only.',
+      category: 'utility' as const,
+      parameters: {
+        type: 'object' as const,
+        properties: {
+          fileId: { type: 'string', description: 'File ID (required)' },
+          exportFormat: { type: 'string', description: 'Export format for Google Docs types: "text", "html", "pdf", "csv" (for Sheets)' },
+        },
+        required: ['fileId'],
+      },
+      async execute(_id: string, params: any) {
+        try {
+          const token = await tp.getAccessToken();
+          const meta = await gapi(token, `/files/${params.fileId}`, {
+            query: { fields: 'id,name,mimeType,size,modifiedTime,createdTime,description,webViewLink,owners,shared' },
+          });
+          const result: any = {
+            id: meta.id, name: meta.name, mimeType: meta.mimeType,
+            size: meta.size ? Number(meta.size) : undefined,
+            modifiedTime: meta.modifiedTime, description: meta.description,
+            webViewLink: meta.webViewLink, owner: meta.owners?.[0]?.emailAddress,
+          };
+          // Export Google Docs content
+          const exportMap: Record<string, Record<string, string>> = {
+            'application/vnd.google-apps.document': { text: 'text/plain', html: 'text/html', pdf: 'application/pdf' },
+            'application/vnd.google-apps.spreadsheet': { csv: 'text/csv', text: 'text/csv', html: 'text/html' },
+            'application/vnd.google-apps.presentation': { text: 'text/plain', html: 'text/html', pdf: 'application/pdf' },
+          };
+          const formats = exportMap[meta.mimeType];
+          if (formats) {
+            const fmt = params.exportFormat || 'text';
+            const exportMime = formats[fmt] || formats['text'];
+            if (exportMime && (fmt === 'text' || fmt === 'csv' || fmt === 'html')) {
+              const exportRes = await fetch(`${BASE}/files/${params.fileId}/export?mimeType=${encodeURIComponent(exportMime)}`, {
+                headers: { Authorization: `Bearer ${token}` },
+              });
+              if (exportRes.ok) {
+                const text = await exportRes.text();
+                result.content = text.slice(0, 50000); // Truncate large files
+                result.truncated = text.length > 50000;
+                result.exportFormat = fmt;
+              }
+            }
+          }
+          return jsonResult(result);
+        } catch (e: any) { return errorResult(e.message); }
+      },
+    },
+    {
+      name: 'google_drive_create',
+      description: 'Create a new file or folder in Google Drive. For text files, provide content directly.',
+      category: 'utility' as const,
+      parameters: {
+        type: 'object' as const,
+        properties: {
+          name: { type: 'string', description: 'File/folder name (required)' },
+          mimeType: { type: 'string', description: 'MIME type. Use "application/vnd.google-apps.folder" for folders, "application/vnd.google-apps.document" for Docs, "application/vnd.google-apps.spreadsheet" for Sheets' },
+          parentId: { type: 'string', description: 'Parent folder ID' },
+          content: { type: 'string', description: 'Text content for the file' },
+          description: { type: 'string', description: 'File description' },
+        },
+        required: ['name'],
+      },
+      async execute(_id: string, params: any) {
+        try {
+          const token = await tp.getAccessToken();
+          const metadata: any = { name: params.name };
+          if (params.mimeType) metadata.mimeType = params.mimeType;
+          if (params.parentId) metadata.parents = [params.parentId];
+          if (params.description) metadata.description = params.description;
+
+          if (params.content && !params.mimeType?.startsWith('application/vnd.google-apps.')) {
+            // Multipart upload for files with content
+            const boundary = '===agenticmail_boundary===';
+            const body = `--${boundary}\r\nContent-Type: application/json; charset=UTF-8\r\n\r\n${JSON.stringify(metadata)}\r\n--${boundary}\r\nContent-Type: text/plain; charset=UTF-8\r\n\r\n${params.content}\r\n--${boundary}--`;
+            const result = await gapi(token, '/files?uploadType=multipart', {
+              method: 'POST', base: UPLOAD_BASE,
+              rawBody: body,
+              headers: { 'Content-Type': `multipart/related; boundary=${boundary}` },
+              query: { fields: 'id,name,mimeType,webViewLink' },
+            });
+            return jsonResult({ created: true, fileId: result.id, name: result.name, webViewLink: result.webViewLink });
+          } else {
+            // Metadata-only (folders, Google Docs types)
+            const result = await gapi(token, '/files', {
+              method: 'POST', body: metadata,
+              query: { fields: 'id,name,mimeType,webViewLink' },
+            });
+            return jsonResult({ created: true, fileId: result.id, name: result.name, mimeType: result.mimeType, webViewLink: result.webViewLink });
+          }
+        } catch (e: any) { return errorResult(e.message); }
+      },
+    },
+    {
+      name: 'google_drive_delete',
+      description: 'Move a file to trash (or permanently delete).',
+      category: 'utility' as const,
+      parameters: {
+        type: 'object' as const,
+        properties: {
+          fileId: { type: 'string', description: 'File ID (required)' },
+          permanent: { type: 'string', description: 'If "true", permanently delete instead of trashing' },
+        },
+        required: ['fileId'],
+      },
+      async execute(_id: string, params: any) {
+        try {
+          const token = await tp.getAccessToken();
+          if (params.permanent === 'true') {
+            await gapi(token, `/files/${params.fileId}`, { method: 'DELETE' });
+            return jsonResult({ deleted: true, permanent: true, fileId: params.fileId });
+          } else {
+            await gapi(token, `/files/${params.fileId}`, { method: 'PATCH', body: { trashed: true } });
+            return jsonResult({ trashed: true, fileId: params.fileId });
+          }
+        } catch (e: any) { return errorResult(e.message); }
+      },
+    },
+    {
+      name: 'google_drive_share',
+      description: 'Share a file with a user, group, or make it accessible via link.',
+      category: 'utility' as const,
+      parameters: {
+        type: 'object' as const,
+        properties: {
+          fileId: { type: 'string', description: 'File ID (required)' },
+          email: { type: 'string', description: 'Email to share with' },
+          role: { type: 'string', description: 'Permission role: "reader", "writer", "commenter" (default: "reader")' },
+          type: { type: 'string', description: 'Permission type: "user", "group", "domain", "anyone" (default: "user")' },
+          sendNotification: { type: 'string', description: 'Send email notification? "true" or "false" (default: "true")' },
+        },
+        required: ['fileId'],
+      },
+      async execute(_id: string, params: any) {
+        try {
+          const token = await tp.getAccessToken();
+          const permission: any = {
+            role: params.role || 'reader',
+            type: params.type || (params.email ? 'user' : 'anyone'),
+          };
+          if (params.email) permission.emailAddress = params.email;
+          const query: Record<string, string> = {};
+          if (params.sendNotification === 'false') query.sendNotificationEmail = 'false';
+          const result = await gapi(token, `/files/${params.fileId}/permissions`, { method: 'POST', body: permission, query });
+          return jsonResult({ shared: true, permissionId: result.id, role: result.role, type: result.type });
+        } catch (e: any) { return errorResult(e.message); }
+      },
+    },
+    {
+      name: 'google_drive_move',
+      description: 'Move a file to a different folder.',
+      category: 'utility' as const,
+      parameters: {
+        type: 'object' as const,
+        properties: {
+          fileId: { type: 'string', description: 'File ID to move (required)' },
+          destinationFolderId: { type: 'string', description: 'Target folder ID (required)' },
+        },
+        required: ['fileId', 'destinationFolderId'],
+      },
+      async execute(_id: string, params: any) {
+        try {
+          const token = await tp.getAccessToken();
+          // Get current parents
+          const file = await gapi(token, `/files/${params.fileId}`, { query: { fields: 'parents' } });
+          const removeParents = (file.parents || []).join(',');
+          const result = await gapi(token, `/files/${params.fileId}`, {
+            method: 'PATCH', body: {},
+            query: { addParents: params.destinationFolderId, removeParents, fields: 'id,name,parents' },
+          });
+          return jsonResult({ moved: true, fileId: result.id, name: result.name, newParent: params.destinationFolderId });
+        } catch (e: any) { return errorResult(e.message); }
+      },
+    },
+  ];
+}