gogcli-mcp 2.8.0 → 2.18.0

package/src/tools/calendar.ts

@@ -13,9 +13,11 @@ export function registerCalendarTools(server: McpServer): void {
       today: z.boolean().optional().describe('Only show today\'s events'),
       query: z.string().optional().describe('Free text search within events'),
       all: z.boolean().optional().describe('Fetch events from all calendars'),
+      eventTypes: z.array(z.enum(['default', 'birthday', 'focus-time', 'from-gmail', 'out-of-office', 'working-location'])).optional().describe('Filter to specific event types (repeatable)'),
+      timezone: z.string().optional().describe('Display timezone for event times (IANA name, e.g. America/New_York, or "local" for the system timezone). Default: each event\'s timezone, then its calendar\'s timezone.'),
       account: accountParam,
     },
-  }, async ({ calendarId, from, to, today, query, all, account }) => {
+  }, async ({ calendarId, from, to, today, query, all, eventTypes, timezone, account }) => {
     const args = ['calendar', 'events'];
     if (calendarId) args.push(calendarId);
     if (from) args.push(`--from=${from}`);
@@ -23,6 +25,8 @@ export function registerCalendarTools(server: McpServer): void {
     if (today) args.push('--today');
     if (query) args.push(`--query=${query}`);
     if (all) args.push('--all');
+    if (eventTypes) for (const t of eventTypes) args.push(`--event-types=${t}`);
+    if (timezone) args.push(`--timezone=${timezone}`);
     return runOrDiagnose(args, { account });
   });
 
@@ -32,10 +36,13 @@ export function registerCalendarTools(server: McpServer): void {
     inputSchema: {
       calendarId: z.string().describe('Calendar ID'),
       eventId: z.string().describe('Event ID'),
+      timezone: z.string().optional().describe('Display timezone for event times (IANA name, e.g. America/New_York, or "local" for the system timezone). Default: the event\'s timezone, then its calendar\'s timezone.'),
       account: accountParam,
     },
-  }, async ({ calendarId, eventId, account }) => {
-    return runOrDiagnose(['calendar', 'event', calendarId, eventId], { account });
+  }, async ({ calendarId, eventId, timezone, account }) => {
+    const args = ['calendar', 'event', calendarId, eventId];
+    if (timezone) args.push(`--timezone=${timezone}`);
+    return runOrDiagnose(args, { account });
   });
 
   server.registerTool('gog_calendar_create', {
@@ -48,23 +55,25 @@ export function registerCalendarTools(server: McpServer): void {
       to: z.string().describe('End time (RFC3339 or date for all-day events)'),
       description: z.string().optional().describe('Event description'),
       location: z.string().optional().describe('Event location'),
-      attendees: z.string().optional().describe('Attendee emails, comma-separated'),
+      attendees: z.string().optional().describe('Attendee emails, comma-separated. Per-attendee modifiers (gog >= 0.31.1 for ;resource): ;optional, ;resource (e.g. meeting rooms), ;comment=TEXT'),
       allDay: z.boolean().optional().describe('All-day event (use date-only in from/to)'),
+      timezone: z.string().optional().describe('IANA timezone metadata applied to from/to (e.g. America/New_York). Sets both start and end timezone unless start/end timezone are overridden.'),
       withZoom: z.boolean().optional().describe('Create a Zoom video conference for this event (requires Zoom S2S OAuth setup)'),
       account: accountParam,
     },
-  }, async ({ calendarId, summary, from, to, description, location, attendees, allDay, withZoom, account }) => {
+  }, async ({ calendarId, summary, from, to, description, location, attendees, allDay, timezone, withZoom, account }) => {
     const args = ['calendar', 'create', calendarId, `--summary=${summary}`, `--from=${from}`, `--to=${to}`];
     if (description) args.push(`--description=${description}`);
     if (location) args.push(`--location=${location}`);
     if (attendees) args.push(`--attendees=${attendees}`);
     if (allDay) args.push('--all-day');
+    if (timezone) args.push(`--timezone=${timezone}`);
     if (withZoom) args.push('--with-zoom');
     return runOrDiagnose(args, { account });
   });
 
   server.registerTool('gog_calendar_update', {
-    description: 'Update an existing calendar event. Zoom: withZoom adds a Zoom meeting, regenerateZoom replaces the existing one, removeZoom strips it (each are independent — use one per call).',
+    description: 'Update an existing calendar event. Zoom: withZoom adds a Zoom meeting, regenerateZoom replaces the existing one, removeZoom strips it. removeMeet clears the event\'s Google Meet conference data (e.g. before attaching another provider). Conference flags are independent — use one per call.',
     annotations: { destructiveHint: false },
     inputSchema: {
       calendarId: z.string().describe('Calendar ID'),
@@ -74,14 +83,16 @@ export function registerCalendarTools(server: McpServer): void {
       to: z.string().optional().describe('New end time (RFC3339)'),
       description: z.string().optional().describe('New description'),
       location: z.string().optional().describe('New location'),
-      attendees: z.string().optional().describe('New attendee emails, comma-separated (replaces existing)'),
+      attendees: z.string().optional().describe('New attendee emails, comma-separated (replaces ALL existing; set empty to clear). Per-attendee modifiers: ;optional, ;resource, ;comment=TEXT'),
+      addAttendees: z.string().optional().describe('Attendee emails to add, comma-separated (preserves existing attendees). Per-attendee modifiers: ;optional, ;resource, ;comment=TEXT'),
       attachments: z.array(z.string()).optional().describe('File attachment URLs (e.g. Drive links). Replaces ALL existing attachments; pass a single empty string to clear them.'),
       withZoom: z.boolean().optional().describe('Create a Zoom video conference for this event'),
       regenerateZoom: z.boolean().optional().describe('Replace the event\'s existing Zoom video conference'),
       removeZoom: z.boolean().optional().describe('Remove the event\'s Zoom video conference'),
+      removeMeet: z.boolean().optional().describe('Remove the event\'s Google Meet video conference (clears conference data only)'),
       account: accountParam,
     },
-  }, async ({ calendarId, eventId, summary, from, to, description, location, attendees, attachments, withZoom, regenerateZoom, removeZoom, account }) => {
+  }, async ({ calendarId, eventId, summary, from, to, description, location, attendees, addAttendees, attachments, withZoom, regenerateZoom, removeZoom, removeMeet, account }) => {
     const args = ['calendar', 'update', calendarId, eventId];
     if (summary !== undefined) args.push(`--summary=${summary}`);
     if (from !== undefined) args.push(`--from=${from}`);
@@ -89,10 +100,12 @@ export function registerCalendarTools(server: McpServer): void {
     if (description !== undefined) args.push(`--description=${description}`);
     if (location !== undefined) args.push(`--location=${location}`);
     if (attendees !== undefined) args.push(`--attendees=${attendees}`);
+    if (addAttendees) args.push(`--add-attendee=${addAttendees}`);
     if (attachments) for (const a of attachments) args.push(`--attachment=${a}`);
     if (withZoom) args.push('--with-zoom');
     if (regenerateZoom) args.push('--regenerate-zoom');
     if (removeZoom) args.push('--remove-zoom');
+    if (removeMeet) args.push('--remove-meet');
     return runOrDiagnose(args, { account });
   });
 
@@ -105,7 +118,9 @@ export function registerCalendarTools(server: McpServer): void {
       account: accountParam,
     },
   }, async ({ calendarId, eventId, account }) => {
-    return runOrDiagnose(['calendar', 'delete', calendarId, eventId], { account });
+    // gog gates this delete behind a confirmation; the runner injects
+    // --no-input, so without --force it refuses at runtime.
+    return runOrDiagnose(['calendar', 'delete', calendarId, eventId, '--force'], { account });
   });
 
   server.registerTool('gog_calendar_respond', {

package/src/tools/docs.ts

@@ -19,10 +19,13 @@ export function registerDocsTools(server: McpServer): void {
     annotations: { readOnlyHint: true },
     inputSchema: {
       docId: z.string().describe('Doc ID (from the URL)'),
+      chips: z.boolean().optional().describe('Render Google Docs smart chips (people, dates, rich links) inline in the text output'),
       account: accountParam,
     },
-  }, async ({ docId, account }) => {
-    return runOrDiagnose(['docs', 'cat', docId], { account });
+  }, async ({ docId, chips, account }) => {
+    const args = ['docs', 'cat', docId];
+    if (chips) args.push('--chips');
+    return runOrDiagnose(args, { account });
   });
 
   server.registerTool('gog_docs_create', {
@@ -43,13 +46,35 @@ export function registerDocsTools(server: McpServer): void {
       text: z.string().describe('Text content to write'),
       append: z.boolean().optional().describe('Append to existing content instead of replacing (default: false)'),
       checkOrphans: z.boolean().optional().describe('Block the write (exit code 11) if it would orphan an open comment — i.e. remove the text the comment is anchored to. Recommended for replacement writes on commented docs.'),
+      bullets: z.boolean().optional().describe('Write the paragraphs as a bulleted list with the default disc preset'),
+      bulletPreset: z.string().optional().describe('Write a bulleted list with a specific Google Docs bullet glyph preset (e.g. BULLET_DISC_CIRCLE_SQUARE)'),
+      ordered: z.boolean().optional().describe('Write the paragraphs as a numbered list with the default decimal preset'),
+      noBullets: z.boolean().optional().describe('Remove bullets or numbering from the written paragraphs'),
+      indentStart: z.number().optional().describe('Paragraph start indentation in points'),
+      indentEnd: z.number().optional().describe('Paragraph end indentation in points'),
+      indentFirstLine: z.number().optional().describe('Paragraph first-line indentation in points'),
+      spaceAbove: z.number().optional().describe('Space above the paragraph in points'),
+      spaceBelow: z.number().optional().describe('Space below the paragraph in points'),
+      keepLinesTogether: z.boolean().optional().describe('Keep all lines of the paragraph on one page/column (true) or clear that setting (false)'),
+      keepWithNext: z.boolean().optional().describe('Keep the paragraph with the next paragraph (true) or clear that setting (false)'),
       batch: z.string().optional().describe('Append this mutation to a persisted batch (from gog_batch_begin in gogcli-mcp-docs) instead of applying it — nothing changes in the doc until the batch is submitted.'),
       account: accountParam,
     },
-  }, async ({ docId, text, append, checkOrphans, batch, account }) => {
+  }, async ({ docId, text, append, checkOrphans, bullets, bulletPreset, ordered, noBullets, indentStart, indentEnd, indentFirstLine, spaceAbove, spaceBelow, keepLinesTogether, keepWithNext, batch, account }) => {
     const args = ['docs', 'write', docId, `--text=${text}`];
     if (append) args.push('--append');
     if (checkOrphans) args.push('--check-orphans');
+    if (bullets) args.push('--bullets');
+    if (bulletPreset) args.push(`--bullet-preset=${bulletPreset}`);
+    if (ordered) args.push('--ordered');
+    if (noBullets) args.push('--no-bullets');
+    if (indentStart !== undefined) args.push(`--indent-start=${indentStart}`);
+    if (indentEnd !== undefined) args.push(`--indent-end=${indentEnd}`);
+    if (indentFirstLine !== undefined) args.push(`--indent-first-line=${indentFirstLine}`);
+    if (spaceAbove !== undefined) args.push(`--space-above=${spaceAbove}`);
+    if (spaceBelow !== undefined) args.push(`--space-below=${spaceBelow}`);
+    if (keepLinesTogether !== undefined) args.push(keepLinesTogether ? '--keep-lines-together' : '--no-keep-lines-together');
+    if (keepWithNext !== undefined) args.push(keepWithNext ? '--keep-with-next' : '--no-keep-with-next');
     if (batch) args.push(`--batch=${batch}`);
     return runOrDiagnose(args, { account });
   });

package/src/tools/drive.ts

@@ -1,6 +1,22 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
 import { z } from 'zod';
-import { accountParam, runOrDiagnose, registerRunTool } from './utils.js';
+import { rawTextResult } from '@chrischall/mcp-utils';
+import { run, runBinary } from '../runner.js';
+import { accountParam, diagnose, runOrDiagnose, registerRunTool } from './utils.js';
+
+// A native Google Doc exports to text directly; anything else (PDF, image,
+// docx, …) is first copied WITH conversion to this type, which makes Drive run
+// OCR, before exporting.
+const GOOGLE_DOC_MIME = 'application/vnd.google-apps.document';
+
+// Parse `gog drive get` JSON into { name, mimeType }. gog nests the payload
+// under `file`; fall back to the top level if that ever changes.
+function fileMeta(raw: string): { name?: string; mimeType?: string } {
+  const parsed = JSON.parse(raw) as { file?: { name?: string; mimeType?: string }; name?: string; mimeType?: string };
+  const f = parsed.file ?? parsed;
+  return { name: f.name, mimeType: f.mimeType };
+}
 
 export function registerDriveTools(server: McpServer): void {
   server.registerTool('gog_drive_ls', {
@@ -92,6 +108,9 @@ export function registerDriveTools(server: McpServer): void {
   }, async ({ fileId, permanent, account }) => {
     const args = ['drive', 'delete', fileId];
     if (permanent) args.push('--permanent');
+    // gog gates drive delete behind a confirmation; the runner injects
+    // --no-input, so without --force it refuses at runtime.
+    args.push('--force');
     return runOrDiagnose(args, { account });
   });
 
@@ -111,8 +130,112 @@ export function registerDriveTools(server: McpServer): void {
     if (email) args.push(`--email=${email}`);
     if (domain) args.push(`--domain=${domain}`);
     if (role) args.push(`--role=${role}`);
+    // gog gates public sharing behind a confirmation; the runner injects
+    // --no-input, so without --force it refuses at runtime.
+    if (to === 'anyone') args.push('--force');
     return runOrDiagnose(args, { account });
   });
 
+  server.registerTool('gog_drive_extract_text', {
+    description:
+      'Extract readable TEXT from a Drive file — PDF, image, docx, or a native Google Doc — and return ' +
+      'it to you directly (closing the webViewLink dead end). Accepts a Drive file id, including the id ' +
+      'from gog_gmail_attachment\'s deliveredVia:"drive" response. For non-Docs it copies the file to a ' +
+      'temporary Google Doc so Drive OCRs it (works for scanned PDFs too), exports plain text, then ' +
+      'deletes the temp Doc. Operates entirely via the Drive API within the existing drive scope — no ' +
+      'host filesystem, no scope widening. For a large file, page through with offset/maxChars.',
+    // Creates and deletes a temporary Doc for non-native files, so not read-only.
+    annotations: { destructiveHint: false },
+    inputSchema: {
+      fileId: z.string().describe('Drive file ID (e.g. the id returned by gog_gmail_attachment)'),
+      ocrLanguage: z.string().optional().describe(
+        'BCP-47 language hint for OCR of scanned/image PDFs (e.g. "en", "fr"). Optional.',
+      ),
+      offset: z.number().int().nonnegative().optional().describe('Character offset to start from (default: 0)'),
+      maxChars: z.number().int().positive().optional().describe('Max characters to return (default: all from offset)'),
+      account: accountParam,
+    },
+  }, async ({ fileId, ocrLanguage, offset = 0, maxChars, account }) => {
+    let tempDocId: string | undefined;
+    try {
+      const { name, mimeType } = fileMeta(await run(['drive', 'get', fileId], { account }));
+
+      // Native Docs export straight to text; everything else is OCR-converted first.
+      let sourceId = fileId;
+      if (mimeType !== GOOGLE_DOC_MIME) {
+        const params = JSON.stringify({ fileId, ...(ocrLanguage ? { ocrLanguage } : {}) });
+        const body = JSON.stringify({ name: `gogcli-ocr-${fileId}`, mimeType: GOOGLE_DOC_MIME });
+        const copied = JSON.parse(await run(
+          ['api', 'call', 'drive', 'v3', 'files.copy', '--allow-write', '--force',
+            `--params=${params}`, `--body=${body}`],
+          { account },
+        )) as { id?: string; result?: { id?: string } };
+        tempDocId = copied.id ?? copied.result?.id;
+        if (!tempDocId) throw new Error('OCR conversion did not return a document id');
+        sourceId = tempDocId;
+      }
+
+      const exportParams = JSON.stringify({ fileId: sourceId, mimeType: 'text/plain' });
+      const raw = await run(['api', 'call', 'drive', 'v3', 'files.export', `--params=${exportParams}`], { account });
+
+      const full = raw.replace(/^/, ''); // drop the export's leading BOM
+      const start = Math.min(offset, full.length);
+      const text = maxChars !== undefined ? full.slice(start, start + maxChars) : full.slice(start);
+      return rawTextResult(JSON.stringify({
+        fileId,
+        name,
+        mimeType,
+        extractedVia: mimeType === GOOGLE_DOC_MIME ? 'native-export' : 'ocr-convert',
+        totalChars: full.length,
+        offset: start,
+        returnedChars: text.length,
+        truncated: start + text.length < full.length,
+        text,
+      }, null, 2));
+    } catch (err) {
+      return diagnose(err);
+    } finally {
+      // Always remove the temp Doc — on success, and on a mid-extraction failure.
+      if (tempDocId) {
+        await run(['drive', 'delete', tempDocId, '--permanent', '--force'], { account }).catch(() => {});
+      }
+    }
+  });
+
+  server.registerTool('gog_drive_read_bytes', {
+    description:
+      'Fetch a Drive file\'s raw bytes and return them base64-encoded as an embedded resource — the ' +
+      'generic fallback for callers that want the file itself (to parse locally) rather than extracted ' +
+      'text. For readable text from a PDF, prefer gog_drive_extract_text. NOTE: only works on the local ' +
+      'stdio server; over the hosted connector the transport is text-only and this returns a clear error ' +
+      '(use gog_drive_extract_text there).',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      fileId: z.string().describe('Drive file ID'),
+      account: accountParam,
+    },
+  }, async ({ fileId, account }): Promise<CallToolResult> => {
+    try {
+      const { name, mimeType } = fileMeta(await run(['drive', 'get', fileId], { account }));
+      const params = JSON.stringify({ fileId, alt: 'media' });
+      const blob = await runBinary(['api', 'call', 'drive', 'v3', 'files.get', `--params=${params}`], { account });
+      return {
+        content: [
+          { type: 'text', text: `${name ?? fileId} (${mimeType ?? 'application/octet-stream'}) — ${Buffer.from(blob, 'base64').length} bytes, base64 resource below.` },
+          {
+            type: 'resource',
+            resource: {
+              uri: `gogdrive://${fileId}/${encodeURIComponent(name ?? 'file')}`,
+              mimeType: mimeType ?? 'application/octet-stream',
+              blob,
+            },
+          },
+        ],
+      };
+    } catch (err) {
+      return diagnose(err);
+    }
+  });
+
   registerRunTool(server, { service: 'drive', examples: '"copy", "upload", "download", "permissions"' });
 }

package/src/tools/gmail.ts

@@ -1,6 +1,7 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
-import { accountParam, runOrDiagnose, registerRunTool } from './utils.js';
+import { accountParam, runOrDiagnose, registerRunTool, payloadArg } from './utils.js';
+import type { GogArg } from '../runner.js';
 
 export function registerGmailTools(server: McpServer): void {
   server.registerTool('gog_gmail_search', {
@@ -39,7 +40,7 @@ export function registerGmailTools(server: McpServer): void {
     inputSchema: {
       to: z.string().describe('Recipient(s), comma-separated'),
       subject: z.string().describe('Subject line'),
-      body: z.string().describe('Email body (plain text)'),
+      body: z.string().describe('Email body (plain text). Any size — a large body is written to a temp file on the gog server rather than inlined into the command line. Note gog strips trailing newlines from a file-delivered body.'),
       cc: z.string().optional().describe('CC recipients, comma-separated'),
       bcc: z.string().optional().describe('BCC recipients, comma-separated'),
       replyToMessageId: z.string().optional().describe('Message ID to reply to'),
@@ -48,7 +49,10 @@ export function registerGmailTools(server: McpServer): void {
       account: accountParam,
     },
   }, async ({ to, subject, body, cc, bcc, replyToMessageId, threadId, attach, account }) => {
-    const args = ['gmail', 'send', `--to=${to}`, `--subject=${subject}`, `--body=${body}`];
+    // A long body cannot ride in argv: the hosted runner caps a single arg and
+    // Linux caps MAX_ARG_STRLEN at 128 KiB. payloadArg swaps it for --body-file
+    // past the shared threshold; the executor materializes the temp file.
+    const args: GogArg[] = ['gmail', 'send', `--to=${to}`, `--subject=${subject}`, payloadArg('body', 'body-file', body)];
     if (cc) args.push(`--cc=${cc}`);
     if (bcc) args.push(`--bcc=${bcc}`);
     if (replyToMessageId) args.push(`--reply-to-message-id=${replyToMessageId}`);

package/src/tools/sheets.ts

@@ -1,7 +1,8 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
 import { run } from '../runner.js';
-import { accountParam, runOrDiagnose, registerRunTool, toText, diagnose } from './utils.js';
+import { rawTextResult } from '@chrischall/mcp-utils';
+import { accountParam, runOrDiagnose, registerRunTool, diagnose } from './utils.js';
 import { expandAnchorRange, countNonEmptyCells } from './sheets-a1.js';
 
 // Cell value type: matches what gog sheets --values-json accepts (passed
@@ -42,9 +43,10 @@ export function registerSheetsTools(server: McpServer): void {
       values: z.array(z.array(cellValueParam)).describe('2D array of values (rows of columns). Cells may be string/number/boolean/null; strings starting with "=" are formulas.'),
       dry_run: dryRunParam,
       fail_if_not_empty: failIfNotEmptyParam,
+      fail_on_formula_error: z.boolean().optional().describe('After writing, read the range back and fail if any cell holds a Sheets formula error (#REF!, #DIV/0!, etc.).'),
       account: accountParam,
     },
-  }, async ({ spreadsheetId, range, values, account, dry_run, fail_if_not_empty }) => {
+  }, async ({ spreadsheetId, range, values, account, dry_run, fail_if_not_empty, fail_on_formula_error }) => {
     const cols = values.reduce((max, row) => Math.max(max, row.length), 0);
     if (fail_if_not_empty && values.length > 0 && cols > 0) {
       const readRange = expandAnchorRange(range, values.length, cols);
@@ -62,7 +64,7 @@ export function registerSheetsTools(server: McpServer): void {
         const detail = occupied < 0
           ? 'could not be verified as empty'
           : `already contains data in ${occupied} cell(s)`;
-        return toText(
+        return rawTextResult(
           `Write aborted (fail_if_not_empty): target range ${readRange} ${detail}. ` +
           'Re-run without fail_if_not_empty to overwrite, or clear it first with gog_sheets_clear.',
         );
@@ -70,6 +72,7 @@ export function registerSheetsTools(server: McpServer): void {
     }
     const args = ['sheets', 'update', spreadsheetId, range, `--values-json=${JSON.stringify(values)}`];
     if (dry_run) args.push('--dry-run');
+    if (fail_on_formula_error) args.push('--fail-on-formula-error');
     return runOrDiagnose(args, { account });
   });
 

package/src/tools/slides.ts

@@ -10,12 +10,14 @@ export function registerSlidesTools(server: McpServer): void {
       presentationId: z.string().describe('Presentation ID'),
       out: z.string().optional().describe('Output file path'),
       format: z.enum(['pdf', 'pptx']).optional().describe('Export format (default: pptx)'),
+      overwrite: z.boolean().optional().describe('Overwrite the output file if it already exists (gog refuses otherwise)'),
       account: accountParam,
     },
-  }, async ({ presentationId, out, format, account }) => {
+  }, async ({ presentationId, out, format, overwrite, account }) => {
     const args = ['slides', 'export', presentationId];
     if (out) args.push(`--out=${out}`);
     if (format) args.push(`--format=${format}`);
+    if (overwrite) args.push('--overwrite');
     return runOrDiagnose(args, { account });
   });
 
@@ -71,15 +73,18 @@ export function registerSlidesTools(server: McpServer): void {
   });
 
   server.registerTool('gog_slides_read_slide', {
-    description: 'Read the content of a slide (text, shapes, speaker notes).',
+    description: 'Read the content of a slide (text, shapes, speaker notes). Set detail=true to also include normalized element geometry, styled text runs, paragraphs, table-cell content, and image source URLs.',
     annotations: { readOnlyHint: true },
     inputSchema: {
       presentationId: z.string().describe('Presentation ID'),
       slideId: z.string().describe('Slide ID to read'),
+      detail: z.boolean().optional().describe('Include normalized element geometry, styled text runs, paragraphs, table-cell content, and image source URLs'),
       account: accountParam,
     },
-  }, async ({ presentationId, slideId, account }) => {
-    return runOrDiagnose(['slides', 'read-slide', presentationId, slideId], { account });
+  }, async ({ presentationId, slideId, detail, account }) => {
+    const args = ['slides', 'read-slide', presentationId, slideId];
+    if (detail) args.push('--detail');
+    return runOrDiagnose(args, { account });
   });
 
   registerRunTool(server, { service: 'slides', examples: '"add-slide", "delete-slide", "update-notes"' });

package/src/tools/tasks.ts

@@ -74,7 +74,9 @@ export function registerTasksTools(server: McpServer): void {
       account: accountParam,
     },
   }, async ({ tasklistId, taskId, account }) => {
-    return runOrDiagnose(['tasks', 'delete', tasklistId, taskId], { account });
+    // gog gates this delete behind a confirmation; the runner injects
+    // --no-input, so without --force it refuses at runtime.
+    return runOrDiagnose(['tasks', 'delete', tasklistId, taskId, '--force'], { account });
   });
 
   registerRunTool(server, { service: 'tasks', examples: '"update", "undo", "clear"' });