gogcli-mcp 2.27.1 → 2.29.0

package/src/tools/utils.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
-import { errorResult, rawTextResult } from '@chrischall/mcp-utils';
+import { errorResult, rawTextResult, minifiedResult, stripMediaUrls } from '@chrischall/mcp-utils';
 import { run, isRunnerTransportError } from '../runner.js';
 import type { GogArg, RunnerFailureKind } from '../runner.js';
 import { normalizeTimestamps } from '../timestamps.js';
@@ -342,9 +342,89 @@ export async function diagnose(err: unknown): Promise<CallToolResult> {
   }
 }
 
+// gog pretty-prints its `--json` output, and that indentation is roughly a
+// fifth of a large response while carrying no information a caller reads —
+// 18.6% of a 19 KB `drive ls`, 38% of a small deeply-nested one. Dropping it is
+// the largest token saving available to a passthrough wrapper, which is what
+// this repo is: a tool's output IS gog's JSON, so there is no projection to
+// make instead.
+//
+// Only FORMATTING whitespace goes. mcp-utils' `minifiedResult` is
+// `JSON.stringify` with no indent, which touches neither whitespace INSIDE a
+// value (the blank line between paragraphs of a mail body, the indentation of a
+// quoted block) nor key ORDER — gog emits `nextPageToken` before its data array,
+// and a truncated read still has to see it. A regex over the serialised text
+// would corrupt exactly the payloads this exists to shrink.
+//
+// Anything that is not JSON passes through byte-for-byte: `gog auth list` is
+// plain text, an empty body is legal, and a mangled non-answer is worse than a
+// large one. The guard mirrors normalizeTimestamps' so the two agree on what
+// counts as JSON.
+function minifiedOrRawText(text: string, stripMedia = false): CallToolResult {
+  const trimmed = text.trim();
+  if (trimmed === '' || !/^[[{]/.test(trimmed)) return rawTextResult(text);
+  try {
+    const parsed: unknown = JSON.parse(trimmed);
+    return minifiedResult(stripMedia ? stripMediaUrls(parsed) : parsed);
+  } catch {
+    return rawTextResult(text);
+  }
+}
+
+// THE SECOND COMPACT MECHANISM. `--fields` below is a projection GOOGLE
+// performs; `stripMedia` is one performed here, for the tools whose gog
+// subcommand accepts no mask at all — `gog schema --json` lists only nine that
+// do. Both surface through the same `view` vocabulary, so a caller never has to
+// know which lever a given tool pulls.
+//
+// It drops `thumbnailLink` and friends: URLs a model cannot see, cannot fetch,
+// and would not benefit from if it could. Worth 30-33% on every Drive
+// file-metadata read, measured live. It is deliberately OPT-IN per tool, per
+// the rule that a tool whose PRODUCT is the image must never strip — the tool's
+// own name is the test.
+//
+// A Google field mask (`--fields`) is the other `compact` rung's projection,
+// and it is applied UPSTREAM — inside the Google API, not here. Two consequences shape
+// this function.
+//
+// First, the mask MUST name the response envelope's paging field. A mask of
+// `files(...)` alone drops `nextPageToken` from the payload, so a compact read
+// returns page one with an empty cursor and reads as "there is nothing more" —
+// silent truncation, and the exact false negative this repo's pagination guards
+// exist to prevent. Verified live against gog 0.39.0 on both drive and
+// calendar; the per-tool masks are asserted to start with the paging field.
+//
+// Second, a mask this wrapper gets wrong is a hard 400 from Google rather than
+// a thin record, so `projectOrRaw`'s local try/fallback cannot apply. This is
+// its analogue across the network: a rejected mask retries UNPROJECTED and says
+// why on stderr, because a large correct answer beats a failed tool call. Only
+// a rejected mask is retried — a missing file is not a bad mask, and retrying
+// it would just spend a second call to fail the same way.
+function isRejectedFieldMask(err: unknown): boolean {
+  return /invalidParameter|invalid field selection/i.test(String(err));
+}
+
+async function runProjected(
+  args: GogArg[],
+  options: { account?: string; lossless?: boolean; fieldsMask?: string },
+): Promise<string> {
+  const { fieldsMask } = options;
+  if (!fieldsMask) return run(args, options);
+  try {
+    return await run([...args, `--fields=${fieldsMask}`], options);
+  } catch (err) {
+    if (!isRejectedFieldMask(err)) throw err;
+    // stderr, never stdout: stdout is the JSON-RPC channel.
+    process.stderr.write(
+      `gogcli-mcp: Google rejected the compact field mask (${fieldsMask}); retrying unprojected\n`,
+    );
+    return run(args, options);
+  }
+}
+
 export async function runOrDiagnose(
   args: GogArg[],
-  options: { account?: string; lossless?: boolean },
+  options: { account?: string; lossless?: boolean; fieldsMask?: string; stripMedia?: boolean },
 ): Promise<CallToolResult> {
   try {
     // The single seam every tool's output passes through. Normalizing here —
@@ -357,11 +437,12 @@ export async function runOrDiagnose(
     // `--pretty` formatting, so the one tool you reach for when you need ground
     // truth would stop telling it. Losslessness wins over presentation there —
     // the friendlier views of the same data are already normalized.
-    const raw = await run(args, options);
+    const raw = await runProjected(args, options);
     // Same seam, same reason as normalizeTimestamps: doing this per call site
     // would let one paginated tool forget and go on reporting a spent cursor as
     // if it were a live one. `lossless` opts the raw dumps out of both.
-    return rawTextResult(options.lossless ? raw : stripConsumedPageToken(normalizeTimestamps(raw)));
+    if (options.lossless) return rawTextResult(raw);
+    return minifiedOrRawText(stripConsumedPageToken(normalizeTimestamps(raw)), options.stripMedia);
   } catch (err) {
     return diagnose(err);
   }

package/src/worker.ts

@@ -38,7 +38,7 @@ import { gogAuth, CONNECTOR_INSTRUCTIONS, type GogProps } from './connector-auth
 // connector with all ~360 tools at once. Add whichever paths you want as separate
 // connectors in claude.ai (each authorizes with the same connector key).
 
-const VERSION = '2.27.1'; // x-release-please-version
+const VERSION = '2.29.0'; // x-release-please-version
 
 // Build an McpAgent subclass whose init() registers `registrars` onto its server,
 // each handler wrapped in the ALS scope carrying the per-session Fly executor.

package/tests/tools/calendar.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { registerCalendarTools } from '../../src/tools/calendar.js';
+import { registerCalendarTools, CALENDAR_EVENTS_COMPACT_FIELDS } from '../../src/tools/calendar.js';
 import * as runner from '../../src/runner.js';
 import { createTestHarness } from '@chrischall/mcp-utils/test';
 
@@ -7,6 +7,13 @@ vi.mock('../../src/runner.js');
 
 const setupHandlers = () => createTestHarness(registerCalendarTools);
 
+// gog_calendar_events answers in the compact rung by default, so every call
+// carries the mask. These keep the window-flag tests below about window flags
+// while still asserting the shipped default rather than an opted-out view.
+const evArgs = (...extra: string[]) =>
+  ['calendar', 'events', ...extra, `--fields=${CALENDAR_EVENTS_COMPACT_FIELDS}`];
+const evOpts = { account: undefined, fieldsMask: CALENDAR_EVENTS_COMPACT_FIELDS };
+
 beforeEach(() => vi.clearAllMocks());
 
 describe('gog_calendar_events', () => {
@@ -14,7 +21,36 @@ describe('gog_calendar_events', () => {
     vi.mocked(runner.run).mockResolvedValue('{"items":[]}');
     const harness = await setupHandlers();
     await harness.callTool('gog_calendar_events', {});
-    expect(runner.run).toHaveBeenCalledWith(['calendar', 'events'], { account: undefined });
+    expect(runner.run).toHaveBeenCalledWith(evArgs(), evOpts);
+  });
+
+  // The cheap rung is the default. Measured at 66% smaller on a 25-event
+  // window — the largest saving available in this repo, because a calendar
+  // event's description and attendee list dwarf the fields a caller acts on.
+  it('sends no mask for the full view', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{"items":[]}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_calendar_events', { view: 'full' });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['calendar', 'events'],
+      { account: undefined, fieldsMask: undefined },
+    );
+  });
+
+  // A Google field mask drops nextPageToken from the envelope, so a compact
+  // read returns page one with an EMPTY cursor. This tool's own description
+  // warns that a wide range is usually incomplete and to page until the cursor
+  // is gone — a mask that silently removes the cursor would turn that guidance
+  // into a guarantee of the wrong answer. Verified live against gog 0.39.0.
+  it('names the paging field in the mask', () => {
+    expect(CALENDAR_EVENTS_COMPACT_FIELDS).toMatch(/^nextPageToken,/);
+  });
+
+  it('rejects a view rung this tool does not honour', async () => {
+    const harness = await setupHandlers();
+    const result = await harness.callTool('gog_calendar_events', { view: 'raw' });
+    expect(result.isError).toBe(true);
+    expect(runner.run).not.toHaveBeenCalled();
   });
 
   // The window flags are pinned as SEPARATE cases on purpose: gog >= 0.36.0
@@ -31,54 +67,42 @@ describe('gog_calendar_events', () => {
       query: 'standup',
       all: true,
     });
-    expect(runner.run).toHaveBeenCalledWith(
-      ['calendar', 'events', 'primary', '--from=2026-01-01', '--to=2026-01-31', '--query=standup', '--all'],
-      { account: undefined },
-    );
+    expect(runner.run).toHaveBeenCalledWith(evArgs('primary', '--from=2026-01-01', '--to=2026-01-31', '--query=standup', '--all'), evOpts);
   });
 
   it('appends --today on its own', async () => {
     vi.mocked(runner.run).mockResolvedValue('{}');
     const harness = await setupHandlers();
     await harness.callTool('gog_calendar_events', { today: true });
-    expect(runner.run).toHaveBeenCalledWith(['calendar', 'events', '--today'], { account: undefined });
+    expect(runner.run).toHaveBeenCalledWith(evArgs('--today'), evOpts);
   });
 
   it('anchors --days at --from when both are given', async () => {
     vi.mocked(runner.run).mockResolvedValue('{}');
     const harness = await setupHandlers();
     await harness.callTool('gog_calendar_events', { from: '2026-09-25', days: 5 });
-    expect(runner.run).toHaveBeenCalledWith(
-      ['calendar', 'events', '--from=2026-09-25', '--days=5'],
-      { account: undefined },
-    );
+    expect(runner.run).toHaveBeenCalledWith(evArgs('--from=2026-09-25', '--days=5'), evOpts);
   });
 
   it('passes --days alone as a today-anchored window', async () => {
     vi.mocked(runner.run).mockResolvedValue('{}');
     const harness = await setupHandlers();
     await harness.callTool('gog_calendar_events', { days: 7 });
-    expect(runner.run).toHaveBeenCalledWith(['calendar', 'events', '--days=7'], { account: undefined });
+    expect(runner.run).toHaveBeenCalledWith(evArgs('--days=7'), evOpts);
   });
 
   it('repeats --event-types for each requested type', async () => {
     vi.mocked(runner.run).mockResolvedValue('{}');
     const harness = await setupHandlers();
     await harness.callTool('gog_calendar_events', { eventTypes: ['default', 'out-of-office'] });
-    expect(runner.run).toHaveBeenCalledWith(
-      ['calendar', 'events', '--event-types=default', '--event-types=out-of-office'],
-      { account: undefined },
-    );
+    expect(runner.run).toHaveBeenCalledWith(evArgs('--event-types=default', '--event-types=out-of-office'), evOpts);
   });
 
   it('appends --timezone when provided', async () => {
     vi.mocked(runner.run).mockResolvedValue('{}');
     const harness = await setupHandlers();
     await harness.callTool('gog_calendar_events', { timezone: 'America/New_York' });
-    expect(runner.run).toHaveBeenCalledWith(
-      ['calendar', 'events', '--timezone=America/New_York'],
-      { account: undefined },
-    );
+    expect(runner.run).toHaveBeenCalledWith(evArgs('--timezone=America/New_York'), evOpts);
   });
 
   it('returns error text on failure', async () => {

package/tests/tools/chat.test.ts

@@ -46,7 +46,7 @@ describe('gog_chat_spaces_list', () => {
       return undefined as never;
     });
     registerChatTools(server);
-    expect(configs.size).toBe(12);
+    expect(configs.size).toBe(13);
     for (const [name, config] of configs) {
       expect(config.description, name).toMatch(/consumer accounts|Workspace/i);
     }
@@ -132,6 +132,66 @@ describe('gog_chat_messages_list', () => {
   });
 });
 
+describe('gog_chat_messages_search', () => {
+  it('searches across every space the account can see', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{"results":[]}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_chat_messages_search', { query: 'project decision' });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['chat', 'messages', 'search', 'project decision'],
+      { account: undefined },
+    );
+  });
+
+  it('passes view, markup, order and pagination flags', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{"results":[]}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_chat_messages_search', {
+      query: 'from:alice@example.com budget',
+      view: 'full',
+      markup: 'markdown',
+      order: 'create_time desc',
+      max: 100,
+      pageToken: 'tok',
+      all: true,
+    });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['chat', 'messages', 'search', 'from:alice@example.com budget', '--order=create_time desc',
+        '--view=full', '--markup=markdown', '--max=100', '--page=tok', '--all'],
+      { account: undefined },
+    );
+  });
+
+  // Chat's own ordering vocabulary is snake_case here and camelCase in
+  // `messages list`; a model that copies the list tool's "createTime desc"
+  // would get a gog error at runtime, so the enum has to reject it here.
+  it('rejects an order value search does not accept', async () => {
+    const harness = await setupHandlers();
+    const result = await harness.callTool('gog_chat_messages_search', {
+      query: 'x', order: 'createTime desc',
+    });
+    expect(result.isError).toBe(true);
+    expect(runner.run).not.toHaveBeenCalled();
+  });
+
+  // Chat caps a search page at 100; `messages list` allows more. Letting the
+  // larger number through would surface as a gog error on a call the tool
+  // already had enough information to refuse.
+  it('rejects a page size above Chat search\'s cap of 100', async () => {
+    const harness = await setupHandlers();
+    const result = await harness.callTool('gog_chat_messages_search', { query: 'x', max: 250 });
+    expect(result.isError).toBe(true);
+    expect(runner.run).not.toHaveBeenCalled();
+  });
+
+  it('returns error text on failure', async () => {
+    vi.mocked(runner.run).mockRejectedValue(new Error('Search failed'));
+    const harness = await setupHandlers();
+    const result = await harness.callTool('gog_chat_messages_search', { query: 'x' });
+    expect(result.content[0].text).toBe('Error: Search failed');
+  });
+});
+
 describe('gog_chat_messages_send', () => {
   it('sends text to a space', async () => {
     vi.mocked(runner.run).mockResolvedValue('{}');

package/tests/tools/drive.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { registerDriveTools } from '../../src/tools/drive.js';
+import { registerDriveTools, DRIVE_LS_COMPACT_FIELDS } from '../../src/tools/drive.js';
 import * as runner from '../../src/runner.js';
 import { createTestHarness } from '@chrischall/mcp-utils/test';
 
@@ -7,6 +7,13 @@ vi.mock('../../src/runner.js');
 
 const setupHandlers = () => createTestHarness(registerDriveTools);
 
+// gog_drive_ls answers in the compact rung by default, so every call carries
+// the mask. These keep the flag-mapping tests below about flag mapping while
+// still asserting the shipped default rather than a view they opted out of.
+const lsArgs = (...extra: string[]) =>
+  ['drive', 'ls', ...extra, `--fields=${DRIVE_LS_COMPACT_FIELDS}`];
+const lsOpts = { account: undefined, fieldsMask: DRIVE_LS_COMPACT_FIELDS };
+
 beforeEach(() => vi.clearAllMocks());
 
 describe('gog_drive_ls', () => {
@@ -14,14 +21,48 @@ describe('gog_drive_ls', () => {
     vi.mocked(runner.run).mockResolvedValue('{"files":[]}');
     const harness = await setupHandlers();
     await harness.callTool('gog_drive_ls', {});
-    expect(runner.run).toHaveBeenCalledWith(['drive', 'ls'], { account: undefined });
+    expect(runner.run).toHaveBeenCalledWith(lsArgs(), lsOpts);
+  });
+
+  // Efficiency is not something a caller should have to ask for: the cheap rung
+  // is the default. Measured at 48% smaller on a 25-row listing.
+  it('defaults to the compact view, applying the field mask', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{"files":[]}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_drive_ls', {});
+    expect(runner.run).toHaveBeenCalledWith(
+      ['drive', 'ls', `--fields=${DRIVE_LS_COMPACT_FIELDS}`],
+      lsOpts,
+    );
+  });
+
+  it('sends no mask for the full view', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{"files":[]}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_drive_ls', { view: 'full' });
+    expect(runner.run).toHaveBeenCalledWith(['drive', 'ls'], { account: undefined, fieldsMask: undefined });
+  });
+
+  // THE BUG THIS ALMOST SHIPPED: a Google field mask drops nextPageToken from
+  // the envelope, so a compact read returns page one with an EMPTY cursor and
+  // reads as "no more results" — silent truncation, verified live against gog
+  // 0.39.0. Naming the paging field in the mask is what brings it back.
+  it('names the paging field in the mask', () => {
+    expect(DRIVE_LS_COMPACT_FIELDS).toMatch(/^nextPageToken,/);
+  });
+
+  it('rejects a view rung this tool does not honour', async () => {
+    const harness = await setupHandlers();
+    const result = await harness.callTool('gog_drive_ls', { view: 'raw' });
+    expect(result.isError).toBe(true);
+    expect(runner.run).not.toHaveBeenCalled();
   });
 
   it('passes folderId as --parent flag', async () => {
     vi.mocked(runner.run).mockResolvedValue('{}');
     const harness = await setupHandlers();
     await harness.callTool('gog_drive_ls', { folderId: 'folder1' });
-    expect(runner.run).toHaveBeenCalledWith(['drive', 'ls', '--parent=folder1'], { account: undefined });
+    expect(runner.run).toHaveBeenCalledWith(lsArgs('--parent=folder1'), lsOpts);
   });
 
   it('supports max, page, query, and allDrives flags', async () => {
@@ -34,8 +75,8 @@ describe('gog_drive_ls', () => {
       query: "name contains 'x'",
     });
     expect(runner.run).toHaveBeenCalledWith(
-      ['drive', 'ls', '--parent=folder1', '--max=50', '--page=tok', "--query=name contains 'x'"],
-      { account: undefined },
+      lsArgs('--parent=folder1', '--max=50', '--page=tok', "--query=name contains 'x'"),
+      lsOpts,
     );
   });
 
@@ -43,14 +84,14 @@ describe('gog_drive_ls', () => {
     vi.mocked(runner.run).mockResolvedValue('{}');
     const harness = await setupHandlers();
     await harness.callTool('gog_drive_ls', { allDrives: false });
-    expect(runner.run).toHaveBeenCalledWith(['drive', 'ls', '--no-all-drives'], { account: undefined });
+    expect(runner.run).toHaveBeenCalledWith(lsArgs('--no-all-drives'), lsOpts);
   });
 
   it('omits all-drives flag when allDrives is true (default)', async () => {
     vi.mocked(runner.run).mockResolvedValue('{}');
     const harness = await setupHandlers();
     await harness.callTool('gog_drive_ls', { allDrives: true });
-    expect(runner.run).toHaveBeenCalledWith(['drive', 'ls'], { account: undefined });
+    expect(runner.run).toHaveBeenCalledWith(lsArgs(), lsOpts);
   });
 
   it('returns error text on failure', async () => {
@@ -62,11 +103,27 @@ describe('gog_drive_ls', () => {
 });
 
 describe('gog_drive_search', () => {
-  it('calls run with query', async () => {
+  // drive search accepts NO field mask — `gog schema --json` lists only nine
+  // commands that do, and this is not one — so the local media strip is the
+  // only projection available to it. Measured 27.8% end to end.
+  it('calls run with query, defaulting to the compact view', async () => {
     vi.mocked(runner.run).mockResolvedValue('{"files":[]}');
     const harness = await setupHandlers();
     await harness.callTool('gog_drive_search', { query: 'budget' });
-    expect(runner.run).toHaveBeenCalledWith(['drive', 'search', 'budget'], { account: undefined });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['drive', 'search', 'budget'],
+      { account: undefined, stripMedia: true },
+    );
+  });
+
+  it('keeps everything for the full view', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{"files":[]}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_drive_search', { query: 'budget', view: 'full' });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['drive', 'search', 'budget'],
+      { account: undefined, stripMedia: false },
+    );
   });
 
   it('returns error text on failure', async () => {
@@ -78,13 +135,24 @@ describe('gog_drive_search', () => {
 });
 
 describe('gog_drive_get', () => {
-  it('calls run with fileId', async () => {
-    vi.mocked(runner.run).mockResolvedValue('{"id":"file1"}');
+  // Excluded from the --fields work because a mask saved only 7% there: its
+  // default field set is already narrow. The media strip saves 27.5% on the
+  // same payload end to end, which clears the bar a parameter has to clear.
+  it('calls run with fileId, defaulting to the compact view', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_drive_get', { fileId: 'f1' });
+    expect(runner.run).toHaveBeenCalledWith(['drive', 'get', 'f1'], { account: undefined, stripMedia: true });
+  });
+
+  it('keeps everything for the full view', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
     const harness = await setupHandlers();
-    await harness.callTool('gog_drive_get', { fileId: 'file1' });
-    expect(runner.run).toHaveBeenCalledWith(['drive', 'get', 'file1'], { account: undefined });
+    await harness.callTool('gog_drive_get', { fileId: 'f1', view: 'full' });
+    expect(runner.run).toHaveBeenCalledWith(['drive', 'get', 'f1'], { account: undefined, stripMedia: false });
   });
 
+
   it('returns error text on failure', async () => {
     vi.mocked(runner.run).mockRejectedValue(new Error('Not found'));
     const harness = await setupHandlers();

package/tests/tools/utils.test.ts

@@ -123,6 +123,147 @@ describe('runOrDiagnose', () => {
     expect(parsed.internalDateDisplay).toBeDefined();
   });
 
+  // Formatting whitespace is roughly a fifth of a large gog response and
+  // carries no information: gog pretty-prints its --json output, and nothing
+  // downstream reads the indent. Measured at 18.6% of a 19 KB `drive ls`.
+  it('minifies gog\'s pretty-printed JSON on the normal path', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{\n  "a": 1,\n  "b": [\n    2,\n    3\n  ]\n}');
+    const result = await runOrDiagnose(['drive', 'ls'], {});
+    expect(result.content[0].text).toBe('{"a":1,"b":[2,3]}');
+  });
+
+  // Only FORMATTING whitespace goes. Whitespace inside a value is content —
+  // the blank line between paragraphs of a mail body — and JSON.stringify
+  // leaves every byte of it alone. A regex over the serialised text would
+  // corrupt exactly the payloads this is meant to shrink.
+  it('preserves whitespace INSIDE string values', async () => {
+    const body = 'Hi,\n\n  indented quote\n\nthanks';
+    vi.mocked(runner.run).mockResolvedValue(JSON.stringify({ body }, null, 2));
+    const result = await runOrDiagnose(['gmail', 'get'], {});
+    expect(JSON.parse(result.content[0].text as string).body).toBe(body);
+  });
+
+  // ofw-mcp emits paging state before its data array so a truncated read still
+  // sees it; the same reasoning applies to gog's nextPageToken. JSON.stringify
+  // preserves insertion order, so minifying must not reorder anything.
+  it('preserves key order', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{\n  "nextPageToken": "t",\n  "files": []\n}');
+    const result = await runOrDiagnose(['drive', 'ls'], {});
+    expect(result.content[0].text).toBe('{"nextPageToken":"t","files":[]}');
+  });
+
+  // gog does not always answer in JSON — `gog auth list` is plain text, and an
+  // empty body is legal. Minification must pass anything unparseable through
+  // untouched rather than mangling it or throwing.
+  it('passes non-JSON output through untouched', async () => {
+    for (const text of ['user@gmail.com\nother@gmail.com', '', '   ', 'not json {']) {
+      vi.mocked(runner.run).mockResolvedValue(text);
+      const result = await runOrDiagnose(['auth', 'list'], {});
+      expect(result.content[0].text).toBe(text);
+    }
+  });
+
+  // Brace-prefixed but unparseable — a truncated response from a killed gog, or
+  // a JSON prelude followed by garbage. It passes the `^[[{]` guard and then
+  // fails JSON.parse, and the only safe answer is the original bytes: a caller
+  // debugging a malformed payload needs to see what actually arrived.
+  //
+  // This path IS reachable through other suites today (gog_docs_structure feeds
+  // exactly this shape), but incidental coverage is not the same as a pinned
+  // behaviour — change that unrelated fixture and this branch goes dark, and
+  // the failure surfaces on whatever PR touched the fixture.
+  it('passes brace-prefixed but unparseable output through untouched', async () => {
+    for (const text of ['{"truncated": ', '[{"a":1},', '{not: json}']) {
+      vi.mocked(runner.run).mockResolvedValue(text);
+      const result = await runOrDiagnose(['drive', 'ls'], {});
+      expect(result.content[0].text).toBe(text);
+      expect(result.isError).toBeUndefined();
+    }
+  });
+
+  // The lossless dumps are the rung a person reaches for when a payload is not
+  // what they expected, and indentation is most of what makes an unfamiliar
+  // shape legible — the same asymmetry mcp-utils' viewResult applies to `raw`.
+  it('does NOT minify a lossless response', async () => {
+    const raw = '{\n  "id": "m1"\n}';
+    vi.mocked(runner.run).mockResolvedValue(raw);
+    const result = await runOrDiagnose(['gmail', 'raw', 'm1'], { lossless: true });
+    expect(result.content[0].text).toBe(raw);
+  });
+
+  // A Google field mask is applied UPSTREAM, inside the API, so a mask this
+  // wrapper gets wrong is a hard 400 rather than a thin record. That makes the
+  // fallback the thing that keeps compact-by-default survivable: the same role
+  // mcp-utils' projectOrRaw plays for a projection done locally.
+  it('applies a compact field mask when one is given', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{"files":[]}');
+    await runOrDiagnose(['drive', 'ls'], { fieldsMask: 'nextPageToken,files(id)' });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['drive', 'ls', '--fields=nextPageToken,files(id)'],
+      expect.objectContaining({ fieldsMask: 'nextPageToken,files(id)' }),
+    );
+  });
+
+  it('retries UNPROJECTED when Google rejects the mask', async () => {
+    vi.mocked(runner.run)
+      .mockRejectedValueOnce(new Error('Google API error (400 invalidParameter): Invalid field selection id'))
+      .mockResolvedValueOnce('{"files":[{"id":"f1"}]}');
+    const result = await runOrDiagnose(['drive', 'ls'], { fieldsMask: 'files(bogus)' });
+    expect(runner.run).toHaveBeenNthCalledWith(1, ['drive', 'ls', '--fields=files(bogus)'], expect.anything());
+    expect(runner.run).toHaveBeenNthCalledWith(2, ['drive', 'ls'], expect.anything());
+    // The caller gets the whole payload, not an error: a projection that trips
+    // returns everything rather than taking the tool call down.
+    expect(result.isError).toBeUndefined();
+    expect(result.content[0].text).toBe('{"files":[{"id":"f1"}]}');
+  });
+
+  // The fallback must not swallow real failures — a missing file is not a bad
+  // mask, and retrying it would just spend a second call to fail identically.
+  it('does NOT retry an error that is not a rejected mask', async () => {
+    vi.mocked(runner.run)
+      .mockRejectedValueOnce(new Error('File not found'))
+      .mockResolvedValueOnce('user@gmail.com');
+    const result = await runOrDiagnose(['drive', 'ls'], { fieldsMask: 'files(id)' });
+    expect(result.isError).toBe(true);
+    expect(runner.run).not.toHaveBeenNthCalledWith(2, ['drive', 'ls'], expect.anything());
+  });
+
+  // The second compact mechanism. `--fields` is a projection Google performs;
+  // this one is performed here, for the tools whose gog subcommand accepts no
+  // mask at all. Both surface through the same `view` vocabulary.
+  it('strips media keys when asked, and minifies the result', async () => {
+    vi.mocked(runner.run).mockResolvedValue(
+      '{\n  "id": "f1",\n  "thumbnailLink": "https://lh3.googleusercontent.com/x=s220",\n  "webViewLink": "https://docs.google.com/d/f1"\n}',
+    );
+    const result = await runOrDiagnose(['drive', 'get', 'f1'], { stripMedia: true });
+    expect(result.content[0].text).toBe('{"id":"f1","webViewLink":"https://docs.google.com/d/f1"}');
+  });
+
+  // webViewLink is the one URL a caller acts on and it sits in the same object
+  // as thumbnailLink. Stripping it would empty the response of the useful half.
+  it('keeps webViewLink and hasThumbnail while stripping the thumbnail', async () => {
+    vi.mocked(runner.run).mockResolvedValue(
+      JSON.stringify({ files: [{ id: 'f1', hasThumbnail: false, thumbnailLink: 'https://x/y=s220', webViewLink: 'https://docs/f1' }] }),
+    );
+    const result = await runOrDiagnose(['drive', 'search', 'q'], { stripMedia: true });
+    const parsed = JSON.parse(result.content[0].text as string);
+    expect(parsed.files[0]).toEqual({ id: 'f1', hasThumbnail: false, webViewLink: 'https://docs/f1' });
+  });
+
+  it('does not strip media unless asked', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{"thumbnailLink":"https://x/y=s220"}');
+    const result = await runOrDiagnose(['drive', 'get', 'f1'], {});
+    expect(result.content[0].text).toBe('{"thumbnailLink":"https://x/y=s220"}');
+  });
+
+  // Non-JSON must survive the strip path exactly as it survives minification —
+  // the guard is shared, so a regression here would be silent.
+  it('passes non-JSON through untouched even when stripping is on', async () => {
+    vi.mocked(runner.run).mockResolvedValue('user@gmail.com');
+    const result = await runOrDiagnose(['auth', 'list'], { stripMedia: true });
+    expect(result.content[0].text).toBe('user@gmail.com');
+  });
+
   it('appends auth list on non-auth failure', async () => {
     vi.mocked(runner.run)
       .mockRejectedValueOnce(new Error('Doc not found'))