gogcli-mcp 2.28.0 → 2.29.0

package/src/tools/calendar.ts

@@ -1,5 +1,6 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
+import { viewParam, resolveView } from '@chrischall/mcp-utils';
 import { accountParam, runOrDiagnose, registerRunTool, pageTokenParam, pageAliasParam, resolvePageToken } from './utils.js';
 import { annotateTruncatedList } from '../pagination.js';
 
@@ -53,6 +54,27 @@ function pushReminderFlags(
   for (const reminder of p.reminders) args.push(`--reminder=${reminder}`);
 }
 
+
+// The `compact` rung for gog_calendar_events, as a Google Calendar field mask.
+//
+// nextPageToken FIRST and always. This tool's own description tells a caller
+// that a wide range is usually incomplete and to page until the cursor is gone;
+// a mask of `items(...)` alone drops that cursor from the envelope, which would
+// turn that instruction into a guarantee of the wrong answer. Verified live
+// against gog 0.39.0.
+//
+// Chosen from the DATA over a 25-event window: description costs 5,951 bytes
+// and attendees 3,145 — the two fat blobs `full` exists to return — while etag,
+// kind, iCalUID, eventType, timezone, guestsCanInviteOthers and privateCopy are
+// internal or single-valued across every row. Net: 21,260 -> 7,292 bytes, 66%
+// smaller. status is kept despite being single-valued in that sample precisely
+// because its whole value is flagging the rare cancelled event.
+//
+// gog's derived fields (startLocal, endDayOfWeek, ...) survive the mask, since
+// gog computes them from start/end, which the mask keeps.
+export const CALENDAR_EVENTS_COMPACT_FIELDS =
+  'nextPageToken,items(id,summary,start,end,location,status,htmlLink)';
+
 export function registerCalendarTools(server: McpServer): void {
   server.registerTool('gog_calendar_events', {
     description: 'List calendar events. Describe the window ONE way and one way only (gog >= 0.36.0 rejects the rest as ambiguous rather than silently discarding a flag): '
@@ -78,9 +100,13 @@ export function registerCalendarTools(server: McpServer): void {
       all: z.boolean().optional().describe('Fetch events from ALL CALENDARS. NOTE: unlike the gmail search tools, this does NOT mean "all pages" — it widens the calendar set, not the page window. Use pageToken to reach later pages.'),
       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.'),
+      view: viewParam(['compact', 'full'], {
+        note: 'compact (the default) drops description and attendees — together two thirds of a '
+          + 'listing\'s bytes — plus etag/iCalUID/kind. Ask for full when you need a body or a guest list.',
+      }),
       account: accountParam,
     },
-  }, async ({ calendarId, from, to, days, today, query, max, pageToken, page, all, eventTypes, timezone, account }) => {
+  }, async ({ calendarId, from, to, days, today, query, max, pageToken, page, all, eventTypes, timezone, view, account }) => {
     const args = ['calendar', 'events'];
     if (calendarId) args.push(calendarId);
     if (from) args.push(`--from=${from}`);
@@ -94,7 +120,11 @@ export function registerCalendarTools(server: McpServer): void {
     if (all) args.push('--all');
     if (eventTypes) for (const t of eventTypes) args.push(`--event-types=${t}`);
     if (timezone) args.push(`--timezone=${timezone}`);
-    const result = await runOrDiagnose(args, { account });
+    const rung = resolveView(view, ['compact', 'full']);
+    const result = await runOrDiagnose(args, {
+      account,
+      fieldsMask: rung === 'compact' ? CALENDAR_EVENTS_COMPACT_FIELDS : undefined,
+    });
     // No count probe here: unlike Gmail's list endpoints, the Calendar API has
     // no cheap way to count a range exactly, so the warning carries the fact of
     // truncation without inventing a total.

package/src/tools/drive.ts

@@ -1,7 +1,8 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
 import { z } from 'zod';
-import { rawTextResult } from '@chrischall/mcp-utils';
+import { rawTextResult, viewParam, resolveView } from '@chrischall/mcp-utils';
+
 import { run, runBinary } from '../runner.js';
 import { accountParam, diagnose, runOrDiagnose, registerRunTool, pageTokenParam, pageAliasParam, resolvePageToken} from './utils.js';
 
@@ -18,6 +19,21 @@ function fileMeta(raw: string): { name?: string; mimeType?: string } {
   return { name: f.name, mimeType: f.mimeType };
 }
 
+
+// The `compact` rung for gog_drive_ls, as a Google Drive field mask.
+//
+// nextPageToken FIRST and always: a mask of `files(...)` alone drops the cursor
+// from the envelope, and a compact listing would then look complete when it was
+// one page of many. Verified live against gog 0.39.0.
+//
+// The dropped fields were chosen from the DATA, not from taste — measured over
+// a 25-row listing: thumbnailLink costs 4,998 bytes at ONE distinct value,
+// owners 1,400 at one, parents 900 at one, hasThumbnail 550 at one. Everything
+// kept below varies across rows. Net: 15,718 -> 8,095 bytes, 48% smaller.
+// A caller who needs an owner or a parent asks for view="full".
+export const DRIVE_LS_COMPACT_FIELDS =
+  'nextPageToken,files(id,name,mimeType,modifiedTime,size,webViewLink)';
+
 export function registerDriveTools(server: McpServer): void {
   server.registerTool('gog_drive_ls', {
     description: 'List files in a Google Drive folder (default: root).',
@@ -29,9 +45,13 @@ export function registerDriveTools(server: McpServer): void {
       page: pageAliasParam,
       query: z.string().optional().describe('Drive query filter (e.g. "name contains \'budget\'")'),
       allDrives: z.boolean().optional().describe('Include shared drives (default: true). Set false for My Drive only.'),
+      view: viewParam(['compact', 'full'], {
+        note: 'compact (the default) drops owners, parents, thumbnailLink and hasThumbnail — '
+          + 'near-constant across a listing and 48% of its bytes. Ask for full to get them.',
+      }),
       account: accountParam,
     },
-  }, async ({ folderId, max, pageToken, page, query, allDrives, account }) => {
+  }, async ({ folderId, max, pageToken, page, query, allDrives, view, account }) => {
     const args = ['drive', 'ls'];
     if (folderId) args.push(`--parent=${folderId}`);
     if (max !== undefined) args.push(`--max=${max}`);
@@ -39,7 +59,11 @@ export function registerDriveTools(server: McpServer): void {
     if (token) args.push(`--page=${token}`);
     if (query) args.push(`--query=${query}`);
     if (allDrives === false) args.push('--no-all-drives');
-    return runOrDiagnose(args, { account });
+    const rung = resolveView(view, ['compact', 'full']);
+    return runOrDiagnose(args, {
+      account,
+      fieldsMask: rung === 'compact' ? DRIVE_LS_COMPACT_FIELDS : undefined,
+    });
   });
 
   server.registerTool('gog_drive_search', {
@@ -47,10 +71,17 @@ export function registerDriveTools(server: McpServer): void {
     annotations: { readOnlyHint: true },
     inputSchema: {
       query: z.string().describe('Search query'),
+      // gog's `drive search` accepts no --fields mask, so unlike gog_drive_ls
+      // this tool's compact rung is a LOCAL projection. Same vocabulary either
+      // way: a caller does not need to know which lever is being pulled.
+      view: viewParam(['compact', 'full'], { note: 'compact (the default) drops thumbnailLink — a URL a model cannot see, and 30%+ of a Drive file record. Ask for full to get it back.' }),
       account: accountParam,
     },
-  }, async ({ query, account }) => {
-    return runOrDiagnose(['drive', 'search', query], { account });
+  }, async ({ query, view, account }) => {
+    return runOrDiagnose(['drive', 'search', query], {
+      account,
+      stripMedia: resolveView(view, ['compact', 'full']) === 'compact',
+    });
   });
 
   server.registerTool('gog_drive_get', {
@@ -58,10 +89,20 @@ export function registerDriveTools(server: McpServer): void {
     annotations: { readOnlyHint: true },
     inputSchema: {
       fileId: z.string().describe('File ID'),
+      // A --fields mask saves only 7% here: the default set is already narrow,
+      // which is why this tool takes no mask. The media strip saves 27.5% of
+      // the tool's actual output, measured end to end over stdio, which is why
+      // it takes a view after all. (An earlier note said 32.9%; that was a
+      // minified-vs-stripped comparison of the raw gog payload rather than of
+      // what the tool returns. The end-to-end figure is the one a caller sees.)
+      view: viewParam(['compact', 'full'], { note: 'compact (the default) drops thumbnailLink — a URL a model cannot see, and 30%+ of a Drive file record. Ask for full to get it back.' }),
       account: accountParam,
     },
-  }, async ({ fileId, account }) => {
-    return runOrDiagnose(['drive', 'get', fileId], { account });
+  }, async ({ fileId, view, account }) => {
+    return runOrDiagnose(['drive', 'get', fileId], {
+      account,
+      stripMedia: resolveView(view, ['compact', 'full']) === 'compact',
+    });
   });
 
   server.registerTool('gog_drive_mkdir', {

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.28.0'; // 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/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();