@vellumai/assistant 0.11.2-staging.2 → 0.11.2

package/openapi.yaml

@@ -27286,10 +27286,13 @@ paths:
                     type: string
                   name:
                     type: string
+                  error:
+                    description:
+                      Why the secret was not stored (e.g. provider-side API key validation failed). Present only when success is
+                      false.
+                    type: string
                 required:
                   - success
-                  - type
-                  - name
                 additionalProperties: false
   /v1/secrets/read:
     post:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.2-staging.2",
+  "version": "0.11.2",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/compactor-truncation-pairing.test.ts

@@ -0,0 +1,368 @@
+/**
+ * The compaction summary call's front truncation must never split a
+ * tool_use/tool_result pair, and the outbound request must be repaired
+ * before the provider call.
+ *
+ * The token-budget drop loop advances one message at a time, so without a
+ * boundary check its cut can drop an assistant `tool_use` while keeping its
+ * user `tool_result` in the retained portion. Providers that validate
+ * pairing (OpenAI Responses: "No tool call found for function call output
+ * with call_id ...") reject such a request, and the retry ladder reproduces
+ * the same rejection every pass. The cut must advance to a pair-safe user
+ * boundary, and `buildCompactionRequest` runs the deterministic history
+ * repair so even a malformed input history reaches the provider valid.
+ */
+import { describe, expect, mock, test } from "bun:test";
+
+mock.module("../persistence/conversation-crud.js", () => ({
+  setConversationProcessingStartedAt: () => {},
+  isConversationProcessing: () => false,
+  getMessages: () => [],
+}));
+
+mock.module("../persistence/attachments-store.js", () => ({
+  getAttachmentMetadataForMessage: () => [],
+  getAttachmentContent: () => null,
+}));
+
+mock.module("../persistence/llm-request-log-store.js", () => ({
+  recordRequestLog: () => {},
+}));
+
+import { runAssistantDrivenCompaction } from "../context/compactor.js";
+import { estimatePromptTokens } from "../context/token-estimator.js";
+import type { ContentBlock, Message, Provider } from "../providers/types.js";
+
+const SUMMARY = "Earlier turns summarized in the assistant's own voice.";
+
+function turnTimestamp(turn: number): string {
+  const hour = String(10 + Math.floor(turn / 60)).padStart(2, "0");
+  const minute = String(turn % 60).padStart(2, "0");
+  return `2026-05-21 (Thursday) ${hour}:${minute}:00 -05:00 (America/Chicago)`;
+}
+
+function userTurn(turn: number, body: string): Message {
+  return {
+    role: "user",
+    content: [
+      {
+        type: "text",
+        text: `<turn_context>\ncurrent_time: ${turnTimestamp(
+          turn,
+        )}\n</turn_context>\n[U${turn}] ${body}`,
+      },
+    ],
+  };
+}
+
+function compactionResponse(tailTurn: number, preview: string): string {
+  return `<compaction_result>
+<summary>
+${SUMMARY}
+</summary>
+<key_state>
+- Nothing critical pending.
+</key_state>
+<tail_start timestamp="${turnTimestamp(tailTurn)}" preview="${preview}" />
+</compaction_result>`;
+}
+
+/**
+ * Fake provider enforcing the same pairing contract the OpenAI Responses
+ * serialization is subject to: a `tool_result` may only reference a
+ * `tool_use` emitted earlier in the same request (a `function_call_output`
+ * with no preceding matching `function_call` is a 400). Rejects with the
+ * provider's live error phrasing so a regression reproduces the real
+ * failure mode.
+ */
+function makeValidatingProvider(response: string): {
+  provider: Provider;
+  lastRequest: () => Message[] | null;
+} {
+  let captured: Message[] | null = null;
+  const provider: Provider = {
+    name: "mock-provider",
+    sendMessage: async (messages: Message[]) => {
+      const emittedToolUseIds = new Set<string>();
+      for (const msg of messages) {
+        for (const block of msg.content) {
+          if (msg.role === "assistant" && block.type === "tool_use") {
+            emittedToolUseIds.add(block.id);
+          }
+          if (block.type === "tool_result") {
+            // guard:allow-tool-result-only: the fake validates client-side pairing only
+            const toolUseId = (block as { tool_use_id: string }).tool_use_id;
+            if (!emittedToolUseIds.has(toolUseId)) {
+              throw new Error(
+                `No tool call found for function call output with call_id ${toolUseId}.`,
+              );
+            }
+          }
+        }
+      }
+      captured = messages;
+      return {
+        content: [{ type: "text", text: response }],
+        model: "mock-model",
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: "end_turn",
+      };
+    },
+  };
+  return { provider, lastRequest: () => captured };
+}
+
+function estimate(messages: Message[]): number {
+  return estimatePromptTokens(messages, "system", {
+    providerName: "mock-provider",
+  });
+}
+
+/** Mirror of the compactor's pair-safe cut predicate for fixture guards. */
+function isCleanUserBoundary(message: Message | undefined): boolean {
+  return (
+    message != null &&
+    message.role === "user" &&
+    // guard:allow-tool-result-only: mirrors the compactor's boundary predicate
+    !message.content.some((block) => block.type === "tool_result")
+  );
+}
+
+/**
+ * Replay the token-budget drop loop without the pairing advance, to locate
+ * where the raw budget cut lands for a fixture.
+ */
+function naiveDropCount(messages: Message[], budgetTokens: number): number {
+  let dropCount = 0;
+  let estimated = estimate(messages);
+  while (estimated > budgetTokens && dropCount < messages.length - 1) {
+    dropCount++;
+    estimated = estimate(messages.slice(dropCount));
+  }
+  return dropCount;
+}
+
+function textOfMessage(message: Message | undefined): string {
+  return (message?.content ?? [])
+    .map((block) => ("text" in block ? (block.text as string) : ""))
+    .join("\n");
+}
+
+function requestText(messages: Message[]): string {
+  return messages.map(textOfMessage).join("\n");
+}
+
+describe("compaction summary call: pair-safe front truncation", () => {
+  // Rounds of [user text, assistant tool_use (heavy), user tool_result,
+  // assistant text]: the heavy tool_use messages dominate the estimate, so
+  // the raw budget loop settles right after dropping one of them, landing
+  // the cut on its orphaned tool_result (or the assistant text behind it),
+  // never on a clean user boundary.
+  function buildToolHeavyHistory(rounds: number, idPrefix: string): Message[] {
+    const messages: Message[] = [];
+    for (let i = 0; i < rounds; i++) {
+      messages.push(userTurn(i, "please inspect the next data batch"));
+      messages.push({
+        role: "assistant",
+        content: [
+          {
+            type: "tool_use",
+            id: `${idPrefix}_${i}`,
+            name: "inspect_batch",
+            input: { payload: `batch ${i} `.repeat(600) },
+          },
+        ],
+      });
+      messages.push({
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: `${idPrefix}_${i}`,
+            content: `inspection ${i} complete. `.repeat(8),
+          },
+        ],
+      });
+      messages.push({
+        role: "assistant",
+        content: [
+          { type: "text", text: `[A${i}] batch ${i} looks consistent.` },
+        ],
+      });
+    }
+    return messages;
+  }
+
+  /** tool_result blocks in `messages` with no tool_use anywhere in `messages`. */
+  function orphanedResultIds(messages: Message[]): string[] {
+    const toolUseIds = new Set<string>();
+    for (const msg of messages) {
+      for (const block of msg.content) {
+        if (msg.role === "assistant" && block.type === "tool_use") {
+          toolUseIds.add(block.id);
+        }
+      }
+    }
+    const orphans: string[] = [];
+    for (const msg of messages) {
+      for (const block of msg.content) {
+        if (block.type === "tool_result") {
+          // guard:allow-tool-result-only: counting client-side orphans
+          const toolUseId = (block as { tool_use_id: string }).tool_use_id;
+          if (!toolUseIds.has(toolUseId)) {
+            orphans.push(toolUseId);
+          }
+        }
+      }
+    }
+    return orphans;
+  }
+
+  // Pairing must be id-format-agnostic, so the fixture runs across both
+  // persisted tool id shapes: Anthropic-style `toolu_` ids and OpenAI
+  // Responses-native `call_` ids.
+  for (const idPrefix of ["toolu", "call"] as const) {
+    test(`advances the cut to a pair-safe boundary and succeeds against a pairing-validating provider (${idPrefix}_ ids)`, async () => {
+      const rounds = 30;
+      const messages = buildToolHeavyHistory(rounds, idPrefix);
+
+      const maxInputTokens = 20_000;
+      // Mirrors compactor.compactionPrefixBudget: window minus the
+      // instruction reserve (800) and the 15% output reserve.
+      const prefixBudget =
+        maxInputTokens - 800 - Math.floor(maxInputTokens * 0.15);
+      expect(estimate(messages)).toBeGreaterThan(prefixBudget);
+
+      // Fixture guard: without the pairing advance, the budget cut lands on
+      // an unsafe index and the retained tail carries a tool_result whose
+      // tool_use sits in the dropped prefix (the exact shape the provider
+      // rejects). If token-estimation changes ever make this land safely,
+      // the fixture must be re-tuned or this test proves nothing.
+      const rawCut = naiveDropCount(messages, prefixBudget);
+      expect(rawCut).toBeGreaterThan(0);
+      expect(isCleanUserBoundary(messages[rawCut])).toBe(false);
+      expect(orphanedResultIds(messages.slice(rawCut)).length).toBeGreaterThan(
+        0,
+      );
+
+      const { provider, lastRequest } = makeValidatingProvider(
+        compactionResponse(rounds - 2, "please inspect the next"),
+      );
+
+      const result = await runAssistantDrivenCompaction({
+        conversationId: "conv-test",
+        messages,
+        provider,
+        systemPrompt: "system",
+        compaction: { enabled: true, autoThreshold: 0.7 },
+        maxInputTokens,
+        force: true,
+        previousEstimatedInputTokens: 90_000,
+      });
+
+      // The pairing-validating provider accepted the request and the pass
+      // applied.
+      expect(result.compacted).toBe(true);
+
+      const sent = lastRequest();
+      expect(sent).not.toBeNull();
+      const sentMessages = sent ?? [];
+
+      // Every tool_result in the outbound request is preceded by its
+      // tool_use.
+      expect(orphanedResultIds(sentMessages)).toEqual([]);
+
+      // The cut itself was pair-safe: nothing needed the repair pass's
+      // orphan downgrade, and the retained pairs survive intact.
+      const sentText = requestText(sentMessages);
+      expect(sentText).not.toContain("[orphaned");
+
+      // The request still fits the window and announces the truncation.
+      expect(estimate(sentMessages)).toBeLessThan(maxInputTokens);
+      expect(sentText).toContain("summary covers only the visible portion");
+
+      // Recent valid content is retained verbatim: the last round's user
+      // turn, tool pair, and assistant reply all reach the provider.
+      const lastRound = rounds - 1;
+      expect(sentText).toContain(`[U${lastRound}] please inspect`);
+      expect(sentText).toContain(`[A${lastRound}] batch ${lastRound}`);
+      const sentToolUseIds = new Set<string>();
+      for (const msg of sentMessages) {
+        for (const block of msg.content) {
+          if (msg.role === "assistant" && block.type === "tool_use") {
+            sentToolUseIds.add(block.id);
+          }
+        }
+      }
+      expect(sentToolUseIds.has(`${idPrefix}_${lastRound}`)).toBe(true);
+    });
+  }
+
+  test("repairs a malformed below-budget history before the provider call", async () => {
+    // Orphan tool_result (its tool_use exists nowhere in the history) and a
+    // consecutive same-role user run, below the truncation budget so the
+    // request-build repair is the only transform in play.
+    const messages: Message[] = [
+      userTurn(0, "start the job"),
+      {
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: "toolu_missing",
+            content: "stale result payload",
+          },
+        ],
+      },
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "[A0] acknowledged." }],
+      },
+      userTurn(1, "carry on with the job"),
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "[A1] done." }],
+      },
+    ];
+
+    const { provider, lastRequest } = makeValidatingProvider(
+      compactionResponse(1, "carry on with the job"),
+    );
+
+    const result = await runAssistantDrivenCompaction({
+      conversationId: "conv-test",
+      messages,
+      provider,
+      systemPrompt: "system",
+      compaction: { enabled: true, autoThreshold: 0.7 },
+      maxInputTokens: 200_000,
+      force: true,
+      previousEstimatedInputTokens: 90_000,
+    });
+
+    expect(result.compacted).toBe(true);
+
+    const sentMessages = lastRequest() ?? [];
+    // The orphan was downgraded to text: no tool_result blocks reach the
+    // provider, and the payload is preserved in the degraded form.
+    const hasToolResult = sentMessages.some((msg) =>
+      // guard:allow-tool-result-only: asserting the repair removed them
+      msg.content.some((block: ContentBlock) => block.type === "tool_result"),
+    );
+    expect(hasToolResult).toBe(false);
+    const sentText = requestText(sentMessages);
+    expect(sentText).toContain("stale result payload");
+    expect(sentText).toContain("orphaned tool_result");
+
+    // Same-role runs were merged: roles strictly alternate in the history
+    // portion of the request (everything before the trailing instruction).
+    const historyPortion = sentMessages.slice(0, -1);
+    for (let i = 1; i < historyPortion.length; i++) {
+      expect(historyPortion[i].role).not.toBe(historyPortion[i - 1].role);
+    }
+
+    // Valid user text survives the repair verbatim.
+    expect(sentText).toContain("[U0] start the job");
+    expect(sentText).toContain("[U1] carry on with the job");
+  });
+});

package/src/__tests__/history-repair.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, test } from "bun:test";
 
 import { deepRepairHistory } from "../agent/history-repair/history-repair.js";
+import { isRepairableOrderingError } from "../agent/history-repair/history-repair.js";
 import { repairHistory } from "../agent/history-repair/history-repair.js";
 import type { Message } from "../providers/types.js";
 
@@ -1110,3 +1111,41 @@ describe("deepRepairHistory", () => {
     expect(stats.orphanToolResultsDowngraded).toBe(0);
   });
 });
+
+describe("isRepairableOrderingError", () => {
+  test("matches Anthropic tool ordering rejections", () => {
+    expect(
+      isRepairableOrderingError(
+        "Requests which include `tool_use` blocks must have a corresponding `tool_result` block in the next message.",
+      ),
+    ).toBe(true);
+    expect(
+      isRepairableOrderingError(
+        "messages.5: tool_result block references tool_use_id toolu_abc which was not found",
+      ),
+    ).toBe(true);
+  });
+
+  test("matches the OpenAI Responses orphan function_call_output rejection", () => {
+    expect(
+      isRepairableOrderingError(
+        "No tool call found for function call output with call_id call_abc123.",
+      ),
+    ).toBe(true);
+  });
+
+  test("matches the OpenAI Chat Completions orphan tool_call_id rejection", () => {
+    expect(
+      isRepairableOrderingError(
+        "Invalid parameter: 'tool_call_id' of 'call_abc123' not found in 'tool_calls' of previous message.",
+      ),
+    ).toBe(true);
+  });
+
+  test("does not match unrelated provider errors", () => {
+    expect(isRepairableOrderingError("Rate limit exceeded")).toBe(false);
+    expect(
+      isRepairableOrderingError("Request too large for model context window"),
+    ).toBe(false);
+  });
+});

package/src/agent/history-repair/history-repair.ts

@@ -399,6 +399,14 @@ export const ORDERING_ERROR_PATTERNS: readonly RegExp[] = [
   /tool_use_id.*without.*tool_result/i,
   /tool_result.*tool_use_id.*not found/i,
   /messages.*invalid.*order/i,
+  // OpenAI Responses API: a function_call_output whose call_id has no
+  // matching function_call earlier in the request ("No tool call found for
+  // function call output with call_id ...").
+  /no tool call found for function call output/i,
+  // OpenAI Chat Completions API: a tool message whose tool_call_id is not in
+  // a preceding assistant message's tool_calls ("Invalid parameter:
+  // 'tool_call_id' of '...' not found in 'tool_calls' of previous message").
+  /tool_call_id.*not found/i,
 ];
 
 /**

package/src/config/bundled-skills/media-processing/SKILL.md

@@ -72,7 +72,7 @@ Parameters:
 - `output_schema` (required) - JSON Schema for structured output.
 - `mode` - Analysis mode: `'keyframes'` (default) or `'direct_video'`.
 - `context` - Additional context to include in the prompt.
-- `model` - Gemini model to use (default: `gemini-2.5-flash`).
+- `model` - Gemini model to use (defaults to the Gemini provider's recommended vision model).
 - `concurrency` - Maximum concurrent API requests (default: 10, keyframes mode only).
 - `max_retries` - Retry attempts per segment on failure (default: 3).
 

package/src/config/bundled-skills/media-processing/TOOLS.json

@@ -130,7 +130,7 @@
           },
           "model": {
             "type": "string",
-            "description": "Gemini model to use. Default: 'gemini-2.5-flash'"
+            "description": "Gemini model to use. Defaults to the Gemini provider's recommended vision model."
           },
           "concurrency": {
             "type": "number",

package/src/config/bundled-skills/media-processing/__tests__/media-analysis-default-model.test.ts

@@ -0,0 +1,177 @@
+import { mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Mock @google/genai module: must be before importing the services
+// ---------------------------------------------------------------------------
+
+let capturedModels: string[] = [];
+
+mock.module("@google/genai", () => ({
+  GoogleGenAI: class MockGoogleGenAI {
+    constructor(_opts: Record<string, unknown>) {}
+    models = {
+      generateContent: async (params: { model: string }) => {
+        capturedModels.push(params.model);
+        return {
+          text: '{"frames":[]}',
+          usageMetadata: { promptTokenCount: 10, candidatesTokenCount: 5 },
+          modelVersion: params.model,
+        };
+      },
+    };
+    files = {
+      upload: async (_params: Record<string, unknown>) => ({
+        name: "files/test-upload",
+        uri: "https://example.com/files/test-upload",
+        mimeType: "video/mp4",
+      }),
+      get: async (_params: Record<string, unknown>) => ({ state: "ACTIVE" }),
+      delete: async (_params: Record<string, unknown>) => ({}),
+    };
+  },
+  ApiError: class MockApiError extends Error {
+    status: number;
+    constructor(status: number, message: string) {
+      super(message);
+      this.status = status;
+    }
+  },
+}));
+
+// Import after mocking
+import { resolveModelIntent } from "../../../../providers/model-intents.js";
+import { mapSegments } from "../services/gemini-map.js";
+import { analyzeVideoDirectly } from "../services/gemini-video.js";
+import { resolveMediaAnalysisModel } from "../services/media-analysis-model.js";
+import type { Segment } from "../services/preprocess.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const EXPECTED_DEFAULT = resolveModelIntent("gemini", "vision-optimized");
+
+const OUTPUT_SCHEMA = { type: "object", properties: {} };
+
+async function createPipelineDir(): Promise<{
+  pipelineDir: string;
+  segments: Segment[];
+}> {
+  const pipelineDir = await mkdtemp(join(tmpdir(), "media-model-test-"));
+  const framePath = join(pipelineDir, "frame-000.jpg");
+  await writeFile(framePath, Buffer.from("fake-jpeg-bytes"));
+  const segments: Segment[] = [
+    {
+      id: "seg-000",
+      startSeconds: 0,
+      endSeconds: 10,
+      framePaths: [framePath],
+      frameTimestamps: [0],
+    },
+  ];
+  return { pipelineDir, segments };
+}
+
+function mapOptions(model?: string) {
+  return {
+    apiKey: "test-key",
+    systemPrompt: "Describe the frames.",
+    outputSchema: OUTPUT_SCHEMA,
+    model,
+  };
+}
+
+beforeEach(() => {
+  capturedModels = [];
+});
+
+// ---------------------------------------------------------------------------
+// Automatic no-override path (the background media-processing job passes no
+// model, so the services' default is what runs in production)
+// ---------------------------------------------------------------------------
+
+describe("media analysis default model (no-override path)", () => {
+  test("resolveMediaAnalysisModel defaults to the vision-optimized catalog intent", () => {
+    expect(resolveMediaAnalysisModel(undefined)).toBe(EXPECTED_DEFAULT);
+    // Regression (LUM-3038): the default must not be the retired pinned model.
+    expect(resolveMediaAnalysisModel(undefined)).not.toBe("gemini-2.5-flash");
+    expect(resolveMediaAnalysisModel("custom-model")).toBe("custom-model");
+  });
+
+  test("keyframe mapping without a model override executes the resolved default", async () => {
+    const { pipelineDir, segments } = await createPipelineDir();
+
+    const output = await mapSegments(
+      "asset-1",
+      pipelineDir,
+      segments,
+      mapOptions(),
+    );
+
+    expect(capturedModels).toEqual([EXPECTED_DEFAULT]);
+    expect(output.model).toBe(EXPECTED_DEFAULT);
+    expect(output.successCount).toBe(1);
+  });
+
+  test("cache identity agrees with the execution default", async () => {
+    const { pipelineDir, segments } = await createPipelineDir();
+
+    await mapSegments("asset-1", pipelineDir, segments, mapOptions());
+    expect(capturedModels).toHaveLength(1);
+
+    // A rerun that pins the same model the default resolved to must hit the
+    // per-segment cache: the config hash and the executed model agree.
+    const rerun = await mapSegments(
+      "asset-1",
+      pipelineDir,
+      segments,
+      mapOptions(EXPECTED_DEFAULT),
+    );
+    expect(capturedModels).toHaveLength(1);
+    expect(rerun.successCount).toBe(1);
+
+    // A different model must miss the cache (hash covers the model).
+    await mapSegments(
+      "asset-1",
+      pipelineDir,
+      segments,
+      mapOptions("custom-model"),
+    );
+    expect(capturedModels).toEqual([EXPECTED_DEFAULT, "custom-model"]);
+  });
+
+  test("direct video analysis without a model override executes the resolved default", async () => {
+    const { pipelineDir } = await createPipelineDir();
+    const videoPath = join(pipelineDir, "video.mp4");
+    await writeFile(videoPath, Buffer.from("fake-mp4-bytes"));
+
+    const output = await analyzeVideoDirectly(
+      "asset-1",
+      pipelineDir,
+      mapOptions(),
+      videoPath,
+      12,
+      "video/mp4",
+    );
+
+    expect(capturedModels).toEqual([EXPECTED_DEFAULT]);
+    expect(output.model).toBe(EXPECTED_DEFAULT);
+  });
+
+  test("an explicit model override wins over the default", async () => {
+    const { pipelineDir, segments } = await createPipelineDir();
+
+    const output = await mapSegments(
+      "asset-1",
+      pipelineDir,
+      segments,
+      mapOptions("gemini-explicit-override"),
+    );
+
+    expect(capturedModels).toEqual(["gemini-explicit-override"]);
+    expect(output.model).toBe("gemini-explicit-override");
+  });
+});

package/src/config/bundled-skills/media-processing/services/gemini-map.ts

@@ -15,6 +15,7 @@ import { ApiError, GoogleGenAI } from "@google/genai";
 import { computeRetryDelay, sleep } from "../../../../util/retry.js";
 import { ConcurrencyPool } from "./concurrency-pool.js";
 import { type CostSummary, CostTracker } from "./cost-tracker.js";
+import { resolveMediaAnalysisModel } from "./media-analysis-model.js";
 import type { Segment } from "./preprocess.js";
 
 // ---------------------------------------------------------------------------
@@ -92,7 +93,7 @@ function computeConfigHash(options: GeminiMapOptions): string {
   const payload = JSON.stringify({
     systemPrompt: options.systemPrompt,
     outputSchema: options.outputSchema,
-    model: options.model ?? "gemini-2.5-flash",
+    model: resolveMediaAnalysisModel(options.model),
     context: options.context,
   });
   return createHash("sha256").update(payload).digest("hex").slice(0, 8);
@@ -137,7 +138,7 @@ async function processSegment(
 
   parts.push({ text: promptText });
 
-  const model = options.model ?? "gemini-2.5-flash";
+  const model = resolveMediaAnalysisModel(options.model);
 
   const response = await client.models.generateContent({
     model,
@@ -284,7 +285,7 @@ export async function mapSegments(
   options: GeminiMapOptions,
   onProgress?: (msg: string) => void,
 ): Promise<MapOutput> {
-  const model = options.model ?? "gemini-2.5-flash";
+  const model = resolveMediaAnalysisModel(options.model);
   const concurrency = options.concurrency ?? 10;
   const maxRetries = options.maxRetries ?? 3;