@chrischall/gemini-mcp 1.13.0 → 1.14.0

package/dist/client.js

@@ -175,7 +175,7 @@ export function normalizeFileName(ref) {
     const match = /(?:^|\/)(files\/[\w-]+)\/?$/.exec(trimmed);
     if (!match) {
         throw new McpToolError(`Not a Gemini Files API reference: "${ref}"`, {
-            hint: 'Pass the `files/<id>` name (or the full https://…/v1beta/files/<id> uri) returned by gemini_upload_file / POST /upload.',
+            hint: 'Pass the `files/<id>` name (or the full https://…/v1beta/files/<id> uri) returned by gemini_upload_file.',
         });
     }
     return match[1];
@@ -372,8 +372,13 @@ export class GeminiClient {
      * payload, an inline `gemini_upload_file` body) to the Files API. Same three
      * steps as {@link uploadVideo}, minus the filesystem — which is what makes it
      * usable on the hosted connector, where there is no disk to stream from.
+     *
+     * `signal` bounds the two HTTP round trips. It exists for callers that
+     * upload OPPORTUNISTICALLY — the base64 promotion in `inputs.ts` puts an
+     * upload in front of a generation the caller did not ask to wait for, so a
+     * stalled upload must be abandonable rather than open-ended.
      */
-    async uploadBytes(bytes, mimeType, displayName) {
+    async uploadBytes(bytes, mimeType, displayName, signal) {
         const view = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
         if (view.byteLength > FILE_MAX_BYTES) {
             throw new McpToolError(`File is ${view.byteLength} bytes, over the Gemini Files API limit of ${FILE_MAX_BYTES} bytes (2 GB).`);
@@ -386,24 +391,7 @@ export class GeminiClient {
         // `ArrayBuffer`-backed views, while a `Uint8Array` is generic in its buffer
         // type. The runtime accepts any view.
         const body = new Blob([view], { type: mimeType });
-        return this.uploadToFilesApi(body, mimeType, displayName, view.byteLength);
-    }
-    /**
-     * Upload a request body straight through to the Files API without buffering
-     * it — the direct-upload HTTP endpoint (`POST /upload` on the Worker) hands
-     * us a `ReadableStream` and a `Content-Length`, and the whole point of that
-     * endpoint is that the bytes never materialize anywhere they'd cost context
-     * or memory.
-     *
-     * `contentLength` is REQUIRED because the resumable protocol's start step
-     * declares it up front (`X-Goog-Upload-Header-Content-Length`); a stream of
-     * unknown length has to be buffered by the caller first.
-     */
-    async uploadStream(stream, mimeType, displayName, contentLength) {
-        if (contentLength > FILE_MAX_BYTES) {
-            throw new McpToolError(`File is ${contentLength} bytes, over the Gemini Files API limit of ${FILE_MAX_BYTES} bytes (2 GB).`);
-        }
-        return this.uploadToFilesApi(stream, mimeType, displayName, contentLength);
+        return this.uploadToFilesApi(body, mimeType, displayName, view.byteLength, signal);
     }
     /**
      * The resumable upload itself. Three live-verified steps (docs/GEMINI-API.md
@@ -420,10 +408,15 @@ export class GeminiClient {
      * These two upload calls are raw `fetchImpl` (not `createApiClient`): step 1
      * needs the response *header* and step 2 posts a binary body — neither fits
      * `fetchJson`. The poll DOES go through the shared client (timeout + retry).
-     * Uploads deliberately have no abort timeout: a multi-hundred-MB file can
-     * legitimately take longer than any fixed budget.
+     * Uploads carry no abort timeout by default: a multi-hundred-MB file can
+     * legitimately take longer than any fixed budget. A caller that is uploading
+     * OPPORTUNISTICALLY passes its own `signal` (see `uploadBytes`).
      */
-    async uploadToFilesApi(body, mimeType, displayName, contentLength) {
+    async uploadToFilesApi(body, mimeType, displayName, contentLength, 
+    /** Bounds the two upload round trips. The PROCESSING poll below is left
+     * alone: it is already bounded by FILE_POLL_MAX_ATTEMPTS, and it runs for
+     * video rather than for the images this is used to bound. */
+    signal) {
         const key = this.requireKey();
         // Local alias so the calls below carry NO receiver: `this.fetchImpl(...)`
         // would hand native fetch this GeminiClient as `this`, which workerd
@@ -442,6 +435,7 @@ export class GeminiClient {
                 'Content-Type': 'application/json',
             },
             body: JSON.stringify({ file: { display_name: displayName } }),
+            ...(signal ? { signal } : {}),
         });
         if (!startRes.ok) {
             throw new McpToolError(formatApiError(startRes.status, 'POST', `/upload/v1beta${startPath}`, await startRes.text(), { service: SERVICE }));
@@ -454,23 +448,19 @@ export class GeminiClient {
         }
         // 2. upload + finalize — single shot; the session URL is self-authorizing
         // (no api-key header needed; verified live).
-        // A Blob body is left EXACTLY as the live-verified video upload sent it:
+        // The Blob body is left EXACTLY as the live-verified video upload sent it:
         // fetch derives Content-Length from the blob, and setting the header by
-        // hand is the kind of change that breaks a verified path for no gain. A
-        // stream has no inherent length, so it declares one — otherwise the runtime
-        // falls back to chunked encoding, which the resumable protocol does not
-        // accept (this half is docs-derived; see docs/GEMINI-API.md).
-        const streaming = !(body instanceof Blob);
+        // hand is the kind of change that breaks a verified path for no gain.
+        // (A ReadableStream branch lived here for the retired direct-upload HTTP
+        // endpoint. Nothing streams into this function any more.)
         const upRes = await doFetch(uploadUrl, {
             method: 'POST',
             headers: {
                 'X-Goog-Upload-Offset': '0',
                 'X-Goog-Upload-Command': 'upload, finalize',
-                ...(streaming ? { 'Content-Length': String(contentLength) } : {}),
             },
             body: body,
-            // Required by undici/workerd to send a ReadableStream body at all.
-            ...(streaming ? { duplex: 'half' } : {}),
+            ...(signal ? { signal } : {}),
         });
         if (!upRes.ok) {
             throw new McpToolError(formatApiError(upRes.status, 'POST', '/upload/v1beta/files (finalize)', await upRes.text(), { service: SERVICE }));
@@ -541,7 +531,7 @@ export class GeminiClient {
         const file = await this.call('GET', `/${resource}`);
         if (!file.uri) {
             throw new McpToolError(`${SERVICE} returned no uri for ${resource}`, {
-                hint: 'Files expire ~48h after upload — re-upload with gemini_upload_file (or POST /upload) and use the new uri.',
+                hint: 'Files expire ~48h after upload — re-upload with gemini_upload_file and use the new uri.',
             });
         }
         if (file.state && file.state !== 'ACTIVE') {
@@ -706,6 +696,8 @@ export class GeminiClient {
                 responseFormat.delivery = delivery;
             if (opts.aspectRatio)
                 responseFormat.aspect_ratio = opts.aspectRatio;
+            if (opts.resolution)
+                responseFormat.resolution = opts.resolution;
             const body = { model, input: inputParts, response_format: responseFormat };
             if (opts.task)
                 body.generation_config = { video_config: { task: opts.task } };
@@ -755,9 +747,20 @@ export class GeminiClient {
         const inputParts = [{ type: 'text', text: opts.input }];
         for (const img of opts.images ?? [])
             inputParts.push(interactPart(img));
+        // No format field. The one the server used to send — `audio_format` —
+        // does not exist: every call carrying it answered `400 Unknown parameter
+        // 'audio_format' at 'response_format'`, on every Lyria model, which is
+        // what a docs-derived shape buys you. The real field is `mime_type`
+        // (`audio/mp3 | audio/ogg_opus | audio/l16 | audio/wav | audio/alaw |
+        // audio/mulaw`), and as of 2026-09-09 every value but MP3 is refused
+        // per-model — `Audio MIME type AUDIO_WAV is not supported for
+        // models/lyria-3.5`, and the same for the clip model. So there is no
+        // format lever to expose yet; when there is, it goes here as `mime_type`.
+        //
+        // `delivery` is absent for the same class of reason: the enum accepts
+        // `uri`, the runtime answers `Audio delivery mode is not supported.`
+        // (re-verified 2026-09-09). Lyria audio always comes back inline base64.
         const responseFormat = { type: 'audio' };
-        if (opts.audioFormat)
-            responseFormat.audio_format = opts.audioFormat;
         const body = { model, input: inputParts, response_format: responseFormat };
         if (opts.previousInteractionId !== undefined)
             body.previous_interaction_id = opts.previousInteractionId;

package/dist/inputs.js

@@ -10,6 +10,14 @@ export function hasImageInput(args) {
         args.images_r2_keys?.length ||
         args.from_clipboard);
 }
+/**
+ * How long the opportunistic base64 upload gets before it is abandoned.
+ *
+ * The promotion adds two round trips in front of a generation nobody asked to
+ * wait for, and `uploadToFilesApi` is otherwise untimed. Past this the call
+ * proceeds inline: slower to repeat, but not stalled.
+ */
+const BASE64_UPLOAD_TIMEOUT_MS = 30_000;
 /** Conservative TTL when the API doesn't tell us: documented retention is ~48h. */
 const ASSUMED_TTL_MS = 47 * 60 * 60 * 1000;
 function expiresAtMs(expirationTime, now) {
@@ -44,11 +52,14 @@ export async function resolveImageInputs(args, client) {
     for (const path of args.images ?? []) {
         inputs.push(await resolveLocalPath(path, client, onDisk, report));
     }
-    // 3. raw base64 / data URIs
+    // 3. raw base64 / data URIs — the one form that already cost the caller
+    // tokens, so it is promoted to a Files API upload immediately (see
+    // resolveBase64).
     if (args.images_base64?.length) {
         const { decodeImageInput } = await import('./images.js');
-        for (const b64 of args.images_base64)
-            inputs.push(decodeImageInput(b64));
+        for (const [index, b64] of args.images_base64.entries()) {
+            inputs.push(await resolveBase64(decodeImageInput(b64), index, client, report));
+        }
     }
     // 4. https URLs, fetched by the server. Deduped within the call.
     const fetched = new Map();
@@ -169,6 +180,72 @@ async function resolveLocalPath(path, client, onDisk, report) {
         return inline;
     }
 }
+/**
+ * One base64 input → a Files API reference, uploaded on FIRST sighting.
+ *
+ * Every other form in this funnel keeps bytes out of the conversation
+ * altogether. `images_base64` cannot: by the time the server sees it the
+ * caller has already spent ~14k tokens per photo emitting it. So the rule is
+ * deliberately not the local-path rule (inline once, upload on the second
+ * sighting) — waiting for a second sighting here means waiting until the cost
+ * this is meant to prevent has been paid twice. Uploading now buys a
+ * `files/<id>` that the report hands back, and the next call references that
+ * instead of pasting anything.
+ *
+ * Identity is the bytes, so the same image pasted into two calls uploads once.
+ * Best-effort: an upload failure falls back to inline, because a promotion
+ * that fails the call is worse than one that does not happen.
+ */
+async function resolveBase64(inline, index, client, report) {
+    if (!inline.base64)
+        return inline;
+    // EVERYTHING is inside the try, decoding included. `decodeImageInput` does
+    // not validate a data: payload, so a URL-safe alphabet or a truncated paste
+    // reaches `atob` here and throws — and a promotion that fails the generation
+    // it was meant to make cheaper is worse than no promotion.
+    try {
+        const bytes = base64ToBytes(inline.base64);
+        // NUL-separated, written as the \u0000 escape — see resolveLocalPath for
+        // why a literal NUL must not appear in this file.
+        const key = `b64\u0000${inline.mimeType}\u0000${bytes.byteLength}\u0000${await digestOf(bytes)}`;
+        const cached = client.session.cachedUpload(key);
+        if (cached) {
+            // Reported on the cache hit as well. The description tells callers to
+            // reuse `base64_uploaded[].file_uri`, and the SECOND paste of a photo is
+            // precisely the call that needs to hear it — staying silent there tells
+            // the one caller who is repeating themselves nothing.
+            (report.base64_uploaded ??= []).push({ index, file_uri: cached.name, bytes: bytes.byteLength });
+            return { uri: cached.uri, mimeType: cached.mimeType };
+        }
+        const uploaded = await client.uploadBytes(bytes, inline.mimeType, `pasted-${index + 1}`, AbortSignal.timeout(BASE64_UPLOAD_TIMEOUT_MS));
+        client.session.uploadCache.set(key, {
+            name: uploaded.name,
+            uri: uploaded.uri,
+            mimeType: uploaded.mimeType,
+            expiresAtMs: expiresAtMs(uploaded.expirationTime, Date.now()),
+        });
+        (report.base64_uploaded ??= []).push({
+            index,
+            file_uri: uploaded.name,
+            bytes: bytes.byteLength,
+            ...(uploaded.expirationTime ? { expires: uploaded.expirationTime } : {}),
+        });
+        return { uri: uploaded.uri, mimeType: uploaded.mimeType };
+    }
+    catch {
+        return inline;
+    }
+}
+/**
+ * SHA-256 of the bytes, hex. Content identity for the upload cache — two
+ * pastes of the same photo must resolve to one upload even when the base64
+ * text differs (a data: prefix, different line wrapping).
+ */
+async function digestOf(bytes) {
+    const view = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+    const hash = await crypto.subtle.digest('SHA-256', view);
+    return [...new Uint8Array(hash)].map((n) => n.toString(16).padStart(2, '0')).join('');
+}
 /** One https URL → inline bytes, or a Files API reference when it's large. */
 async function resolveUrl(url, client, report) {
     const fetched = await client.fetchRemoteImage(url);

package/dist/jobs.js

@@ -39,6 +39,17 @@ function isExpired(entry, now) {
 export function fingerprintRequest(toolName, parts) {
     return createHash('sha256').update(`${toolName}\u0000${JSON.stringify(parts)}`).digest('hex');
 }
+/**
+ * The in-memory replay key: an idempotency key is only ever honoured for the
+ * REQUEST it was first used with.
+ *
+ * Same NUL separator, same reason, as {@link fingerprintRequest} — and the
+ * fingerprint is already namespaced by tool, so two tools handed the same "1"
+ * cannot collide either.
+ */
+function replayKey(idempotencyKey, fingerprint) {
+    return `${idempotencyKey}\u0000${fingerprint}`;
+}
 /**
  * Re-mint any media URLs a recorded result carries, before it is replayed.
  *
@@ -150,10 +161,19 @@ function annotateReused(result, jobId) {
     };
 }
 /** Immediate handle for an async call — the caller polls `gemini_get_result`. */
-function jobHandle(jobId, status, durable = false) {
+/**
+ * `interactionId` is on the handle, not held back until the job settles.
+ *
+ * It is the one thing that outlives a lost response: the generation continues
+ * upstream whatever happens to this request, and the id is how a later call
+ * chains onto it or recovers its output. Withholding it until the settle is
+ * withholding it exactly in the case where the settle never comes.
+ */
+function jobHandle(jobId, status, durable = false, interactionId) {
     return minifiedResult({
         job_id: jobId,
         status,
+        ...(interactionId ? { interaction_id: interactionId } : {}),
         hint: durable
             ? `Generation running in the background. Poll gemini_get_result with job_id "${jobId}" until status is "done". The job record is stored durably, so a poll still works if this connector restarts — but background work is NOT restarted, so a long generation is safer with max_wait_ms than with async.`
             : `Generation running in the background. Poll gemini_get_result with job_id "${jobId}" until status is "done" (results are per-process and expire ~10 min after completion).`,
@@ -232,7 +252,18 @@ export class JobRegistry {
     /** Injectable clock (tests). */
     now = () => Date.now();
     jobs = new Map();
-    byKey = new Map(); // idempotencyKey -> jobId
+    /**
+     * `idempotencyKey + fingerprint` -> jobId. Keyed on BOTH, never the key
+     * alone: an idempotency_key is a habit as often as a promise ("1", "test",
+     * "retry"), so a key-only lookup hands a caller a different prompt's result
+     * and labels it `reused`. This is the rule `durableByKey` has always applied
+     * to the 24h window; the 10-minute in-memory window now applies it too.
+     *
+     * Composite rather than a stored comparison so that reusing a key for a
+     * second request cannot evict the first: both pairings coexist, and a retry
+     * of either still replays.
+     */
+    byKey = new Map();
     runningByFingerprint = new Map(); // fingerprint -> jobId (only while running)
     /** Durable bookkeeping still in flight — awaited by `drain()` in tests. */
     pending = new Set();
@@ -345,8 +376,11 @@ export class JobRegistry {
     }
     remove(id, entry) {
         this.jobs.delete(id);
-        if (entry.idempotencyKey !== undefined && this.byKey.get(entry.idempotencyKey) === id)
-            this.byKey.delete(entry.idempotencyKey);
+        if (entry.idempotencyKey !== undefined) {
+            const key = replayKey(entry.idempotencyKey, entry.fingerprint);
+            if (this.byKey.get(key) === id)
+                this.byKey.delete(key);
+        }
         if (this.runningByFingerprint.get(entry.fingerprint) === id)
             this.runningByFingerprint.delete(entry.fingerprint);
     }
@@ -376,7 +410,7 @@ export class JobRegistry {
         const now = this.now();
         let hit;
         if (idempotencyKey !== undefined) {
-            const id = this.byKey.get(idempotencyKey);
+            const id = this.byKey.get(replayKey(idempotencyKey, fingerprint));
             const entry = id ? this.jobs.get(id) : undefined;
             if (entry && entry.status !== 'failed' && !isExpired(entry, now))
                 hit = entry;
@@ -397,12 +431,12 @@ export class JobRegistry {
         }
         if (hit) {
             if (async)
-                return jobHandle(hit.jobId, hit.status);
+                return jobHandle(hit.jobId, hit.status, this.store !== undefined, hit.interactionId);
             const settled = waitMs !== undefined && hit.status === 'running'
                 ? await awaitWithBudget(hit.promise, waitMs)
                 : await hit.promise;
             if (settled === undefined)
-                return jobHandle(hit.jobId, 'running');
+                return jobHandle(hit.jobId, 'running', this.store !== undefined, hit.interactionId);
             // Refresh before annotating: a recorded result can outlive the signed
             // URLs inside it, and replaying an expired link is its own kind of wrong
             // answer — it looks like success.
@@ -437,7 +471,7 @@ export class JobRegistry {
         };
         this.jobs.set(jobId, entry);
         if (idempotencyKey !== undefined)
-            this.byKey.set(idempotencyKey, jobId);
+            this.byKey.set(replayKey(idempotencyKey, fingerprint), jobId);
         this.runningByFingerprint.set(fingerprint, jobId);
         // Write the "running" record BEFORE the work can finish. A record that only
         // appeared on completion would be missing for exactly the window this whole
@@ -459,13 +493,13 @@ export class JobRegistry {
         if (this.store)
             void settle.then(() => this.track(this.writeRecord(entry)));
         if (async)
-            return jobHandle(jobId, 'running', this.store !== undefined);
+            return jobHandle(jobId, 'running', this.store !== undefined, this.jobs.get(jobId)?.interactionId);
         if (waitMs !== undefined) {
             const settled = await awaitWithBudget(promise, waitMs);
             // Budget expired with the work still running: hand back the job id — the
             // work continues and the caller polls, exactly as with `async: true`,
             // except a fast result would have been returned in-band.
-            return settled ?? jobHandle(jobId, 'running', this.store !== undefined);
+            return settled ?? jobHandle(jobId, 'running', this.store !== undefined, this.jobs.get(jobId)?.interactionId);
         }
         return promise;
     }
@@ -497,7 +531,7 @@ export class JobRegistry {
         if (this.now() - record.updatedAt > DURABLE_JOB_REUSE_MS)
             return undefined;
         if (record.status === 'running')
-            return jobHandle(id, 'running', true);
+            return jobHandle(id, 'running', true, record.interactionId);
         if (record.status !== 'done' || !record.result)
             return undefined;
         return annotateReused(await refreshMedia(record.result, this.resigner), id);
@@ -571,7 +605,7 @@ export class JobRegistry {
             });
         }
         if (entry.status === 'running')
-            return jobHandle(jobId, 'running', this.store !== undefined);
+            return jobHandle(jobId, 'running', this.store !== undefined, entry.interactionId);
         if (entry.status === 'failed') {
             throw new McpToolError(entry.error?.message ?? 'Job failed.', entry.error?.hint ? { hint: entry.error.hint } : undefined);
         }
@@ -593,7 +627,7 @@ export class JobRegistry {
      */
     async fromRecord(record) {
         if (record.status === 'running')
-            return jobHandle(record.jobId, 'running', true);
+            return jobHandle(record.jobId, 'running', true, record.interactionId);
         if (record.status === 'failed') {
             throw new McpToolError(record.error?.message ?? 'Job failed.', record.error?.hint ? { hint: record.error.hint } : undefined);
         }

package/dist/models.js

@@ -5,10 +5,20 @@
  * `model` param when the task warrants it (see MODEL_CHOICE_GUIDE).
  */
 export const DEFAULT_IMAGE_MODEL = 'gemini-3.1-flash-image';
-/** Default video model (omni, Interactions API). Preview — overridable per-call. */
-export const DEFAULT_VIDEO_MODEL = 'gemini-omni-flash-preview';
-/** Default music model (Lyria clips, Interactions API). `lyria-3-pro-preview` is
- * the longer-form opt-in; both are preview and need a funded account. */
+/**
+ * Default video model (omni, Interactions API) — overridable per-call.
+ *
+ * GA since 2026-08-27. Its predecessor `gemini-omni-flash-preview` shuts down
+ * 2026-09-30, so this is a migration and not a preference; the GA model bills
+ * at the same rate and adds `resolution` and the `extend` task.
+ */
+export const DEFAULT_VIDEO_MODEL = 'gemini-omni-1.1-flash';
+/**
+ * Default music model (Lyria clips, Interactions API) — 30s, MP3, the cheapest
+ * of the three at $0.04 a song. `lyria-3.5` (minutes-long, vocals) and
+ * `lyria-3-pro-preview` are the opt-ins at twice the price, so neither is the
+ * default. All need a funded account.
+ */
 export const DEFAULT_MUSIC_MODEL = 'lyria-3-clip-preview';
 /** Per-call → env override → hardcoded default. Blank/whitespace counts as unset. */
 export function resolveModel(perCall, envOverride) {

package/dist/pricing.js

@@ -49,7 +49,7 @@
  */
 import { readEnvVar } from '@chrischall/mcp-utils';
 /** The date the shipped rates were read from Google's pricing page. */
-export const PRICED_AT = '2026-08-28';
+export const PRICED_AT = '2026-09-09';
 /**
  * Paid-tier rates, USD per 1M tokens. Image generation has no free tier.
  * `-preview` ids are priced as their GA twin (see {@link normalizeModel}).
@@ -73,9 +73,17 @@ export const RATE_CARD = Object.freeze({
     // from flash-image), along with a $0.50 input and $3.00 text rate that were
     // both a third of the real figures. Every number here is now quoted.
     'gemini-omni-flash': { input: 1.5, text_output: 9.0, video_output: 17.5 },
+    // The GA model (2026-08-27) bills at the preview's rates. It needs its own
+    // key: `normalizeModel` strips a `-preview` suffix and nothing else, so
+    // `gemini-omni-1.1-flash` would otherwise price as undefined — and undefined
+    // is what the server's DEFAULT video model would have reported.
+    'gemini-omni-1.1-flash': { input: 1.5, text_output: 9.0, video_output: 17.5 },
     // Lyria bills per song, so tokens describe the work and not the bill.
     'lyria-3-clip': { input: 0, text_output: 0, per_generation: 0.04 },
     'lyria-3-pro': { input: 0, text_output: 0, per_generation: 0.08 },
+    // lyria-3.5 (2026-09-03): minutes-long songs with vocals, $0.08 a song. A
+    // bare id with no `-preview` to strip, so it is listed rather than derived.
+    'lyria-3.5': { input: 0, text_output: 0, per_generation: 0.08 },
 });
 /** `foo-preview` prices as `foo` — the fleet uses both spellings. */
 function normalizeModel(model) {

package/dist/session.js

@@ -33,12 +33,14 @@ export class SessionState {
      */
     lastInteractionId;
     /**
-     * The same, for the media-specific tools, which keep their own chains.
-     * `gemini_music_generate` IS served by the hosted connector, so this one
-     * leaked across tenants exactly as `lastInteractionId` did; video is
-     * stdio-only today but carries the identical hazard, so both are scoped here.
+     * The same, for `gemini_video_generate`, which keeps its own chain. Video is
+     * stdio-only today, but it carries the identical cross-tenant hazard
+     * `lastInteractionId` did, so it is scoped here rather than at module level.
+     *
+     * There is deliberately no music equivalent: Lyria is single-turn (a chained
+     * call 400s on the track it is handed back), so `gemini_music_generate` has
+     * no continue_last to remember.
      */
-    lastMusicInteractionId;
     lastVideoInteractionId;
     /**
      * Absolute paths of every image this session has written. Used to drop a
@@ -138,7 +140,6 @@ export class SessionState {
         this.costUsd = undefined;
         this.pricedCalls = 0;
         this.lastInteractionId = undefined;
-        this.lastMusicInteractionId = undefined;
         this.lastVideoInteractionId = undefined;
         this.writtenOutputs.clear();
         this.uploadCache.clear();