@ossclip/core 0.1.0

package/src/producer/gemini.ts

@@ -0,0 +1,197 @@
+import { z } from "zod/v4";
+import type { LlmProvider } from "./provider";
+import { estimateTokens, type LlmUsage } from "./usage";
+
+export const DEFAULT_GEMINI_MODEL = "gemini-3.6-flash";
+
+/**
+ * Convert a zod-derived JSON Schema into Gemini's `responseSchema` dialect
+ * (R20 §98). The API takes an OpenAPI-style subset — no $refs, no `const`,
+ * no `additionalProperties` — so this converts what it can and THROWS on
+ * what it cannot; the caller falls back to prompt-stated JSON mode for that
+ * call rather than sending a schema the API would reject. The critical
+ * schemas (transcript repair, beat sheet, clip beat sheet) are pinned
+ * convertible by unit test — those are the calls whose malformed output has
+ * actually cost a run (the R20 repair failure).
+ */
+export function toGeminiSchema(schema: unknown): Record<string, unknown> {
+  if (typeof schema !== "object" || schema === null) {
+    throw new Error("not a schema object");
+  }
+  const s = schema as Record<string, unknown>;
+  if (s.$ref !== undefined) throw new Error("$ref unsupported by responseSchema");
+  if (s.additionalProperties !== undefined && s.additionalProperties !== false) {
+    throw new Error("open records unsupported by responseSchema");
+  }
+
+  // z.literal → {const}: Gemini has no `const`, but a one-value enum is the
+  // same constraint.
+  if (s.const !== undefined) {
+    return { type: typeof s.const === "number" ? "number" : "string", enum: [String(s.const)] };
+  }
+
+  // .nullable() → anyOf [T, {type:"null"}]: fold into `nullable`.
+  const variants = (s.anyOf ?? s.oneOf) as unknown[] | undefined;
+  if (Array.isArray(variants)) {
+    const nonNull = variants.filter(
+      (v) => !(typeof v === "object" && v !== null && (v as { type?: string }).type === "null"),
+    );
+    const hadNull = nonNull.length !== variants.length;
+    if (nonNull.length === 1) {
+      return { ...toGeminiSchema(nonNull[0]), ...(hadNull ? { nullable: true } : {}) };
+    }
+    // A union of string literals flattens to one enum; anything else stays
+    // an anyOf, which the API accepts for genuine unions.
+    const enums = nonNull.map((v) => {
+      const c = toGeminiSchema(v);
+      return c.type === "string" && Array.isArray(c.enum) ? (c.enum as string[]) : null;
+    });
+    if (enums.every((e) => e !== null)) {
+      return { type: "string", enum: enums.flatMap((e) => e!), ...(hadNull ? { nullable: true } : {}) };
+    }
+    return { anyOf: nonNull.map(toGeminiSchema), ...(hadNull ? { nullable: true } : {}) };
+  }
+
+  const out: Record<string, unknown> = {};
+  if (typeof s.type === "string") out.type = s.type;
+  if (typeof s.description === "string") out.description = s.description;
+  if (typeof s.format === "string" && ["enum", "date-time"].includes(s.format)) out.format = s.format;
+  if (Array.isArray(s.enum)) out.enum = s.enum;
+  if (typeof s.minimum === "number") out.minimum = s.minimum;
+  if (typeof s.maximum === "number") out.maximum = s.maximum;
+  if (s.items !== undefined) out.items = toGeminiSchema(s.items);
+  if (typeof s.properties === "object" && s.properties !== null) {
+    out.properties = Object.fromEntries(
+      Object.entries(s.properties as Record<string, unknown>).map(([k, v]) => [
+        k,
+        toGeminiSchema(v),
+      ]),
+    );
+    if (Array.isArray(s.required)) out.required = s.required;
+  }
+  if (out.type === undefined && out.properties === undefined && out.enum === undefined) {
+    throw new Error("schema fragment with no representable shape");
+  }
+  return out;
+}
+
+/**
+ * Gemini via the generateContent REST API. JSON output is constrained BOTH
+ * ways (R20 §98, from the field failure where a repair response came back
+ * as an unterminated string): `responseSchema` makes the decoder emit only
+ * schema-valid JSON when the schema converts to the API's subset, and the
+ * schema stays stated in the prompt — which is also the whole story for the
+ * calls whose schema does not convert. zod remains the authority on the way
+ * out either way. A MAX_TOKENS finish is reported as the truncation it is,
+ * not as a JSON syntax error at some position.
+ * Auth: GEMINI_API_KEY env (PHASE1 §4) or constructor arg.
+ */
+export class GeminiProvider implements LlmProvider {
+  readonly name = "gemini";
+  readonly usage: LlmUsage[] = [];
+
+  constructor(
+    private model: string = DEFAULT_GEMINI_MODEL,
+    private apiKey: string | undefined = process.env.GEMINI_API_KEY,
+    private baseUrl = "https://generativelanguage.googleapis.com/v1beta",
+  ) {}
+
+  async complete<T>(req: {
+    system: string;
+    user: string;
+    schema: z.ZodType<T>;
+    schemaName: string;
+    maxTokens?: number;
+  }): Promise<T> {
+    if (!this.apiKey) throw new Error("GEMINI_API_KEY is not set");
+    const jsonSchema = z.toJSONSchema(req.schema);
+    const schemaText = JSON.stringify(jsonSchema);
+    let responseSchema: Record<string, unknown> | null = null;
+    try {
+      responseSchema = toGeminiSchema(jsonSchema);
+    } catch {
+      // Not convertible (records, refs) — prompt-stated JSON mode carries it.
+    }
+    const maxOutputTokens = req.maxTokens ?? 16000;
+    const body = {
+      system_instruction: { parts: [{ text: req.system }] },
+      contents: [
+        {
+          role: "user",
+          parts: [
+            {
+              text:
+                `${req.user}\n\n` +
+                `Respond with ONLY a JSON object valid against this JSON Schema ` +
+                `("${req.schemaName}"):\n${schemaText}`,
+            },
+          ],
+        },
+      ],
+      generationConfig: {
+        responseMimeType: "application/json",
+        ...(responseSchema ? { responseSchema } : {}),
+        maxOutputTokens,
+      },
+    };
+    const started = Date.now();
+    const res = await fetch(
+      `${this.baseUrl}/models/${this.model}:generateContent?key=${this.apiKey}`,
+      { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) },
+    );
+    if (!res.ok) {
+      throw new Error(`gemini request failed: ${res.status} ${(await res.text()).slice(0, 300)}`);
+    }
+    const data = (await res.json()) as {
+      candidates?: Array<{ finishReason?: string; content?: { parts?: Array<{ text?: string }> } }>;
+      usageMetadata?: {
+        promptTokenCount?: number;
+        candidatesTokenCount?: number;
+        cachedContentTokenCount?: number;
+        // Thinking tokens are billed as output but reported apart from it.
+        thoughtsTokenCount?: number;
+      };
+    };
+    const text = data.candidates?.[0]?.content?.parts?.map((p) => p.text ?? "").join("");
+    const meta = data.usageMetadata;
+    // Recorded before the failure checks — a truncated response still
+    // consumed tokens, and a run that fell over is exactly when the cost of
+    // getting there matters (same rule the Anthropic provider follows).
+    this.usage.push({
+      provider: this.name,
+      model: this.model,
+      schemaName: req.schemaName,
+      inputTokens: meta?.promptTokenCount ?? estimateTokens(`${req.system}${req.user}`),
+      outputTokens:
+        meta?.candidatesTokenCount === undefined
+          ? estimateTokens(text ?? "")
+          : meta.candidatesTokenCount + (meta.thoughtsTokenCount ?? 0),
+      cachedInputTokens: meta?.cachedContentTokenCount,
+      exact: meta?.promptTokenCount !== undefined,
+      billed: true,
+      ms: Date.now() - started,
+    });
+    const finish = data.candidates?.[0]?.finishReason;
+    if (finish === "MAX_TOKENS") {
+      // On a thinking model the thought tokens draw from the same budget, so
+      // the visible JSON can be cut off long before maxOutputTokens reads
+      // "spent" — say so instead of failing as a syntax error mid-string.
+      throw new Error(
+        `gemini output truncated at maxOutputTokens (${maxOutputTokens}` +
+          `${meta?.thoughtsTokenCount ? `, ${meta.thoughtsTokenCount} of it thinking` : ""}) — ` +
+          "the call needs a bigger budget",
+      );
+    }
+    if (!text) throw new Error(`gemini returned no text candidate (finishReason ${finish ?? "?"})`);
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(text);
+    } catch (err) {
+      throw new Error(
+        `gemini returned invalid JSON (finishReason ${finish ?? "?"}): ` +
+          `${err instanceof Error ? err.message : String(err)} — head: ${text.slice(0, 120)}`,
+      );
+    }
+    return req.schema.parse(parsed);
+  }
+}

package/src/producer/index.ts

@@ -0,0 +1,217 @@
+import type { Transcript } from "../schema";
+import type { Scene, SceneComponentId } from "../scene-schema";
+import type { LlmProvider, ProviderName } from "./provider";
+import { AnthropicProvider, DEFAULT_CLAUDE_MODEL } from "./anthropic";
+import { ClaudeCliProvider } from "./claude-cli";
+import { GeminiProvider, DEFAULT_GEMINI_MODEL } from "./gemini";
+import { MockProvider } from "./mock";
+import { TieredProvider } from "./tiered";
+import {
+  generateBeatSheet,
+  normalizeBeatSheet,
+  type BeatSheet,
+  type BeatsValidationIssue,
+} from "./beats";
+import { generateScenes, type ScenePropsFailure } from "./scene-props";
+import { buildFramingBrief, repairMomentLayouts, type FramingContext } from "../framing";
+import {
+  resolveClipWindow,
+  sliceMoments,
+  sliceTranscript,
+  type ClipWindow,
+} from "../clip";
+
+export * from "./provider";
+export * from "./usage";
+export * from "./beats";
+export * from "./scene-props";
+export * from "./repair";
+export { AnthropicProvider, DEFAULT_CLAUDE_MODEL } from "./anthropic";
+export { ClaudeCliProvider } from "./claude-cli";
+export { GeminiProvider, DEFAULT_GEMINI_MODEL } from "./gemini";
+export { MockProvider } from "./mock";
+export { TieredProvider } from "./tiered";
+
+export function createProvider(name: ProviderName, model?: string): LlmProvider {
+  switch (name) {
+    case "claude":
+      return new AnthropicProvider(model ?? DEFAULT_CLAUDE_MODEL);
+    case "claude-cli":
+      // Rides the Claude Code subscription (Pro/Max) — no API key involved.
+      return new ClaudeCliProvider(model);
+    case "gemini":
+      return new GeminiProvider(model ?? DEFAULT_GEMINI_MODEL);
+    case "mock":
+      return new MockProvider();
+  }
+}
+
+/**
+ * The small model each provider reaches for on mechanical calls. Deliberately
+ * a same-family sibling of the default rather than a cross-vendor pick, so
+ * tiering changes cost without also changing who you are talking to. Override
+ * with `--llm-fast-model` (or `fastModel` in the config) — for a model this
+ * code has never heard of, that flag is the whole interface.
+ */
+export const DEFAULT_FAST_MODEL: Partial<Record<ProviderName, string>> = {
+  claude: "claude-haiku-4-5-20251001",
+  "claude-cli": "claude-haiku-4-5-20251001",
+  gemini: "gemini-3.5-flash-lite",
+};
+
+export interface TieringOptions {
+  /** Model for the editorial call (the beat sheet). */
+  model?: string;
+  /**
+   * Model for mechanical calls (repair, scene props). `"same"` disables
+   * tiering and sends everything to the editorial model.
+   */
+  fastModel?: string;
+}
+
+/**
+ * A provider that sizes the model to the call (FINDINGS §37). Falls back to a
+ * single un-tiered provider when the two models resolve to the same thing, so
+ * `usage` stays a plain log and nothing wraps for no reason.
+ */
+export function createTieredProvider(
+  name: ProviderName,
+  opts: TieringOptions = {},
+): LlmProvider {
+  const editorial = createProvider(name, opts.model);
+  const fast = opts.fastModel === "same" ? undefined : opts.fastModel ?? DEFAULT_FAST_MODEL[name];
+  if (!fast || fast === opts.model) return editorial;
+  return new TieredProvider(editorial, createProvider(name, fast));
+}
+
+/**
+ * Default provider when --llm isn't given, in preference order.
+ *
+ * Gemini leads on measured evidence, not vendor preference: on the same clip
+ * it ran 3,540 input tokens against the Claude CLI's 83,378 — the CLI re-sends
+ * its whole harness prefix per invocation — for ~$0.05 against ~$0.85 and 27s
+ * against 171s, with editorial output that held up. Both models recovered the
+ * mishearing that matters ("coach and" → "code churn"); Claude is stronger only
+ * at recovering a mangled PROPER NOUN, which `--speaker` addresses directly.
+ *
+ * Falling back to the Claude Code CLI last keeps the no-keys-configured path
+ * working on a Pro/Max subscription rather than failing.
+ */
+export function defaultProviderName(env: NodeJS.ProcessEnv = process.env): ProviderName {
+  if (env.GEMINI_API_KEY) return "gemini";
+  if (env.ANTHROPIC_API_KEY) return "claude";
+  return "claude-cli";
+}
+
+export interface ProduceScenesResult {
+  beatSheet: BeatSheet;
+  beatIssues: BeatsValidationIssue[];
+  scenes: Scene[];
+  failures: ScenePropsFailure[];
+  /**
+   * Present on a `--clip` run (R19 §93): the resolved window (pre-slice index
+   * space + source seconds), the transcript sliced to it — which is the space
+   * the returned moments and scenes live in — and what resolution changed
+   * about the model's raw pick.
+   */
+  clip?: { window: ClipWindow; transcript: Transcript; notes: string[] };
+}
+
+/** The full producer-brain pipeline: beat sheet → per-moment scene props. */
+export async function produceScenes(
+  provider: LlmProvider,
+  args: {
+    transcript: Transcript;
+    outputDuration: number;
+    intent?: string;
+    /** Who is on camera — see `--speaker`. */
+    speaker?: string;
+    /**
+     * Debug: render every graphic moment with this component instead of the
+     * one the producer picked. Exists because a component the producer never
+     * chooses is a component never tested on real copy — FlowDiagram went
+     * three rounds unexercised (FINDINGS §20).
+     */
+    forceComponent?: SceneComponentId;
+    /**
+     * Camera-framing constraints (PLAN Tasks A+B), present when the source
+     * went through normalization. Feeds the beat-sheet prompt (the brief) AND
+     * the repair pass that enforces it — ship both, trust neither alone.
+     */
+    framing?: FramingContext;
+    /**
+     * `--clip` (R19 §93): select ONE ~targetSec window and plan only inside
+     * it. The window request rides the beat-sheet call (§93d); the returned
+     * moments/scenes are re-anchored to the sliced transcript, and the caller
+     * slices the rest of its pipeline state to `clip.window`.
+     */
+    clip?: { targetSec: number };
+    /** Output frame shape (R21 §101) — landscape gets layout-variety
+     * guidance in the beat prompt. Omitted = portrait, no extra text. */
+    aspect?: "9:16" | "16:9";
+  },
+): Promise<ProduceScenesResult> {
+  const framingBrief = args.framing
+    ? buildFramingBrief(args.framing, args.transcript)
+    : undefined;
+  const { sheet, issues, highlight } = await generateBeatSheet(
+    provider,
+    args.transcript,
+    args.outputDuration,
+    args.intent,
+    args.speaker,
+    framingBrief || undefined,
+    args.clip,
+    args.aspect,
+  );
+
+  // ---- Clip window (R19 §93) ----------------------------------------------
+  // Resolve (validate + sentence-snap) the highlight, slice the transcript,
+  // and re-anchor the moments into the slice. Then re-run normalization
+  // against the SLICED transcript: the coverage budget and variety passes
+  // were computed against the full take's runtime above, and a 60s window
+  // deserves a 60s window's graphics schedule.
+  let transcript = args.transcript;
+  let workingSheet = sheet;
+  let clip: ProduceScenesResult["clip"];
+  if (args.clip) {
+    const resolved = resolveClipWindow(args.transcript, highlight, args.clip.targetSec);
+    transcript = sliceTranscript(args.transcript, resolved.window);
+    const anchored = sliceMoments(sheet.moments, resolved.window);
+    if (anchored.length === 0) {
+      issues.push({
+        moment: -1,
+        issue: "no moments inside the highlight — the clip renders as a plain captioned take",
+      });
+    }
+    const renorm = normalizeBeatSheet(
+      { hook: sheet.hook, coverText: sheet.coverText, moments: anchored },
+      transcript,
+    );
+    workingSheet = renorm.sheet;
+    issues.push(...renorm.issues);
+    clip = { window: resolved.window, transcript, notes: resolved.notes };
+  }
+
+  // Applied AFTER normalization: the coverage budget and variety passes may
+  // demote moments to "none", and forcing before them can leave nothing to
+  // render — the flag would appear to work and produce no scenes at all.
+  // The forced component drops the producer's layout too: it was chosen for
+  // a different component and may not even be in the forced one's repertoire.
+  let moments = args.forceComponent
+    ? workingSheet.moments.map((m) =>
+        m.sceneKind === "none" ? m : { ...m, sceneKind: args.forceComponent!, layout: undefined },
+      )
+    : workingSheet.moments;
+  // The safety net (Task B): whatever the prompt did, no moment leaves here
+  // with a layout that would crop the head at its own moment's framing.
+  if (args.framing) {
+    const repaired = repairMomentLayouts(moments, transcript, args.framing);
+    moments = repaired.moments;
+    issues.push(...repaired.issues);
+  }
+  const { scenes, failures } = await generateScenes(provider, moments, transcript, {
+    framing: args.framing,
+  });
+  return { beatSheet: { ...workingSheet, moments }, beatIssues: issues, scenes, failures, clip };
+}

package/src/producer/mock.ts

@@ -0,0 +1,101 @@
+import type { z } from "zod/v4";
+import type { LlmProvider } from "./provider";
+import { estimateTokens, type LlmUsage } from "./usage";
+import { BeatSheetSchema } from "./beats";
+
+/**
+ * Deterministic offline producer: segments the transcript into fixed-size
+ * moments and cycles through a few scene kinds. Exists so the whole
+ * produce path is exercisable with zero network (PHASE1 §4 "offline path is
+ * first-class") — and so tests can run the exact code path `--produce` runs.
+ */
+export class MockProvider implements LlmProvider {
+  readonly name = "mock";
+  readonly usage: LlmUsage[] = [];
+
+  async complete<T>(req: {
+    system: string;
+    user: string;
+    schema: z.ZodType<T>;
+    schemaName: string;
+  }): Promise<T> {
+    const result =
+      req.schemaName === "beat_sheet" || req.schemaName === "clip_beat_sheet"
+        ? this.beatSheet(req.user, req.schema, req.schemaName === "clip_beat_sheet")
+        : req.schemaName === "transcript_repair"
+          ? // A deterministic no-op: the offline path must exercise the repair
+            // call without inventing corrections a real provider would justify.
+            req.schema.parse({ repairs: [] })
+          : this.sceneProps(req.user, req.schema, req.schemaName);
+    // Estimated, and costing exactly nothing — but recorded, because the
+    // offline path is first-class and "how big are the prompts this pipeline
+    // sends" is worth answering without spending anything to find out.
+    this.usage.push({
+      provider: this.name,
+      schemaName: req.schemaName,
+      inputTokens: estimateTokens(`${req.system}\n${req.user}`),
+      outputTokens: estimateTokens(JSON.stringify(result)),
+      reportedCostUsd: 0,
+      exact: false,
+      billed: false,
+      ms: 0,
+    });
+    return result;
+  }
+
+  private beatSheet<T>(user: string, schema: z.ZodType<T>, clip: boolean): T {
+    const wordCount = (user.match(/\[\d+\]/g) ?? []).length;
+    // Clip mode (R19 §93): a deterministic highlight — a stretch starting 40%
+    // in, sized at ~2.8 words/sec of the requested target. No timestamps here,
+    // so `resolveClipWindow` does the real fitting (trim + sentence snap) on
+    // the actual word stamps downstream.
+    const targetSec = Number.parseFloat(/Target clip length: ~(\d+(?:\.\d+)?)s/.exec(user)?.[1] ?? "60");
+    const winStart = clip ? Math.min(Math.floor(wordCount * 0.4), Math.max(0, wordCount - 2)) : 0;
+    const winEnd = clip
+      ? Math.min(wordCount - 1, winStart + Math.max(3, Math.round(targetSec * 2.8)))
+      : wordCount - 1;
+    const kinds = ["TitleCard", "none", "StatCard", "none", "FlowDiagram", "none", "RuleCard"] as const;
+    const per = Math.max(3, Math.ceil((winEnd - winStart + 1) / 6));
+    const moments = [];
+    for (let start = winStart, k = 0; start <= winEnd; start += per, k++) {
+      moments.push({
+        startWord: start,
+        endWord: Math.min(start + per - 1, winEnd),
+        purpose: `beat ${k + 1}`,
+        onScreenCopy: `BEAT ${k + 1}`,
+        sceneKind: kinds[k % kinds.length]!,
+      });
+      if (moments.length >= 8) break;
+    }
+    const sheet = {
+      hook: "MOCK HOOK",
+      moments,
+      ...(clip
+        ? { highlight: { startWord: winStart, endWord: winEnd, reason: "mock: fixed 40%-in window" } }
+        : {}),
+    };
+    return schema.parse(sheet);
+  }
+
+  private sceneProps<T>(_user: string, schema: z.ZodType<T>, schemaName: string): T {
+    const canned: Record<string, unknown> = {
+      TitleCard_props: { eyebrow: "MOCK", title: "THE RAW TAKE", emphasis: "861%", sub: "becomes a clean edit" },
+      StatCard_props: { label: "FILLERS REMOVED", value: "+100%", caption: "MORE SIGNAL. LESS UM.", inverted: true },
+      RuleCard_props: { kicker: "PRODUCER RULE", text: "SHOW, THEN TELL", struck: "NOT: WALLS OF TEXT" },
+      StrikethroughReveal_props: { lines: [{ text: "MORE WORDS", struck: true }, { text: "MORE SIGNAL", struck: false }] },
+      FlowDiagram_props: { nodes: ["RAW TAKE", "CUT", "PRODUCED"], emphasizeLast: true },
+      TerminalMock_props: {
+        windows: [
+          { title: "ossclip-01", lines: ["$ ossclip produce raw.mp4", "▸ transcribing…", "▸ cutting…"] },
+          { title: "ossclip-02", lines: ["▸ rendering…", "✓ done"] },
+        ],
+        fanOut: "OUTPUT ×1",
+      },
+      ChatMock_props: { messages: [{ from: "user", text: "can it cut my ums?" }, { from: "agent", text: "already did." }] },
+      ScreenshotFrame_props: { label: "REVIEW STATUS: TODAY", kenBurns: true },
+    };
+    const props = canned[schemaName];
+    if (!props) throw new Error(`mock provider: unknown schema ${schemaName}`);
+    return schema.parse(props);
+  }
+}

package/src/producer/provider.ts

@@ -0,0 +1,42 @@
+import type { z } from "zod/v4";
+import type { LlmUsage } from "./usage";
+
+/**
+ * The one seam between ossclip and any LLM. Implementations must return a
+ * value that already validates against `schema` (they may use native
+ * structured output or parse-and-validate); on failure they throw.
+ * No provider types leak past this interface (PHASE1 §4).
+ */
+/**
+ * Which kind of thinking a call needs.
+ *
+ * `editorial` is the beat sheet — picking the hook, segmenting the take,
+ * writing the copy. That is the judgement the whole product rests on.
+ * `mechanical` is everything else: repairing a mishearing, filling props
+ * against a schema. Both are cheap to check and expensive to over-buy — on the
+ * CLI path a call costs ~$0.26 on the top model and ~$0.04 on the small one,
+ * and the harness prefix dominates either way (FINDINGS §37).
+ */
+export type CallTier = "editorial" | "mechanical";
+
+export interface LlmProvider {
+  readonly name: string;
+  /**
+   * One record per completed call, in call order — tokens and timing, never
+   * money (pricing lives in `usage.ts`). Producing a video is a repair pass, a
+   * beat sheet and one call per scene, so this is how a run answers "what did
+   * that cost". Providers append; nobody else writes to it.
+   */
+  readonly usage: readonly LlmUsage[];
+  complete<T>(req: {
+    system: string;
+    user: string;
+    schema: z.ZodType<T>;
+    schemaName: string;
+    maxTokens?: number;
+    /** Defaults to `editorial` — a caller that says nothing gets the good model. */
+    tier?: CallTier;
+  }): Promise<T>;
+}
+
+export type ProviderName = "claude" | "claude-cli" | "gemini" | "mock";