vidspotai-shared 1.0.82-dev.0 → 1.0.83

package/lib/services/agent/llmCallerAnthropic.d.ts

@@ -1,22 +1,18 @@
 import { z } from "zod";
 import { ChatRequest, ChatResponse, LlmCaller, StructuredRequest, StructuredResponse, StructuredWithToolsRequest } from "./llmCaller";
+import { TransientLlmError, isTransientLlmError } from "./llmRetry";
+export { TransientLlmError, isTransientLlmError };
 /**
- * Direct Anthropic SDK LlmCaller. Exists alongside GatewayLlmCaller because
- * Anthropic's server-side tools (`web_search_20260209`, `web_fetch`, etc.)
- * cannot be exposed through the OpenAI-compatible Vercel AI Gateway —
- * they're Anthropic-only constructs that the API executes server-side.
+ * Direct Anthropic SDK LlmCaller — the `anthropic` slice of the native
+ * ProviderRoutingLlmCaller (LLM_NATIVE_MIGRATION_PLAN). Serves all anthropic
+ * models the router picks (router / planner / executor) and is the only caller
+ * that implements `structuredWithTools`, because Anthropic's server-side tools
+ * (`web_search_20260209`, `web_fetch`, etc.) are Anthropic-only constructs the
+ * API executes server-side — no other provider exposes them.
  *
- * Use this caller when:
- *   - You need server-side `web_search` for planner grounding.
- *   - You want Anthropic-native features (prompt caching, extended thinking,
- *     citations) without a translation layer.
- *
- * Use the gateway caller when:
- *   - You want provider portability (GPT-5 / Gemini fallback chains).
- *   - You don't need built-in tools.
- *
- * The Planner reads from `getAnthropicCaller()` only when `useWebResearch`
- * is set; otherwise it stays on the gateway path.
+ * The Planner also reads this directly via `getAnthropicCaller()` when
+ * `useWebResearch` is set (server-side `web_search` grounding); otherwise it
+ * goes through the normal dispatcher, which already routes anthropic natively.
  *
  * Implemented features:
  *   - Prompt caching (`cachePrompt: true`): `cache_control: ephemeral` on
@@ -25,8 +21,10 @@ import { ChatRequest, ChatResponse, LlmCaller, StructuredRequest, StructuredResp
  *   - Extended thinking (`thinking.budgetTokens`): enables Claude's
  *     interleaved reasoning blocks for T3 / complex briefs. Forces
  *     temperature=1 and threads `thinking` blocks through the tool-use loop.
- *   - Transient errors propagate as `TransientLlmError` so callers can
- *     fall back to the gateway path (no web search) on Anthropic outages.
+ *   - Native incremental streaming (`structuredStream`): forces the
+ *     `submit_<schema>` tool and streams its `input_json_delta` partials.
+ *   - Transient errors propagate as `TransientLlmError` so the dispatcher can
+ *     run the cross-provider `fallbackModel` on Anthropic outages.
  *
  * Deferred work (v2):
  *   - Custom client-side tools (Tavily / image search): extend the loop
@@ -46,15 +44,6 @@ export interface AnthropicCallerConfig {
     /** Max retries on transient errors per call. Default 3. */
     maxRetries?: number;
 }
-/**
- * Marks an error worth retrying on the gateway path. The Planner catches
- * this specifically to degrade gracefully — drops research, keeps planning.
- */
-export declare class TransientLlmError extends Error {
-    readonly cause?: unknown | undefined;
-    constructor(message: string, cause?: unknown | undefined);
-}
-export declare function isTransientLlmError(err: unknown): err is TransientLlmError;
 export declare class AnthropicLlmCaller implements LlmCaller {
     private readonly client;
     private readonly timeoutMs;
@@ -63,6 +52,26 @@ export declare class AnthropicLlmCaller implements LlmCaller {
     chat(req: ChatRequest): Promise<ChatResponse>;
     structured<T extends z.ZodTypeAny>(req: StructuredRequest<T>): Promise<StructuredResponse<T>>;
     structuredWithTools<T extends z.ZodTypeAny>(req: StructuredWithToolsRequest<T>): Promise<StructuredResponse<T>>;
+    /**
+     * Native incremental streaming structured output. Forces the
+     * `submit_<schemaName>` tool and streams its argument JSON as
+     * `input_json_delta` chunks — yielding each partial for token-by-token UI —
+     * then takes the authoritative payload from `stream.finalMessage()` (more
+     * robust than re-concatenating partials) and Zod-validates it.
+     *
+     * Scope: the base StructuredRequest carries no server tools / thinking /
+     * caching (those live on StructuredWithToolsRequest and run the blocking
+     * tool-loop), so this is a single forced-tool turn. Failure handling mirrors
+     * the other streaming callers: a post-stream parse/validation miss rejects
+     * `result` and returns cleanly (so the caller's token loop completes and its
+     * `await result` retry path fires); a mid-stream/connect drop rejects AND
+     * throws out so the iteration aborts.
+     */
+    structuredStream<T extends z.ZodTypeAny>(req: StructuredRequest<T>): {
+        tokens: AsyncIterable<string>;
+        result: Promise<StructuredResponse<T>>;
+    };
+    private streamIterator;
     /**
      * Anthropic's API takes a top-level `system` (string or TextBlockParam[])
      * and messages of user/assistant only. Our LlmCaller carries system as
@@ -78,13 +87,17 @@ export declare class AnthropicLlmCaller implements LlmCaller {
     private splitSystem;
     private buildServerTools;
     /**
-     * Map our ModelChoice → Anthropic API model id. Pass-through today since
-     * routing uses Anthropic-shaped ids (e.g. "claude-sonnet-4-6"). If a
-     * future routing entry uses a non-Anthropic id we'd want to throw rather
-     * than silently send GPT names to the Anthropic API.
+     * Map our ModelChoice → Anthropic API model id via the shared registry
+     * (pass-through today). Throws on a non-Anthropic provider rather than
+     * silently sending GPT/Gemini names to the Anthropic API — the dispatcher
+     * routes by provider, so this guards against a mis-wire.
      */
     private resolveModelId;
+    /**
+     * Delegates to the shared transient-retry helper so all native callers share
+     * one backoff/classification policy (Phase 1 extraction). The SDK's own
+     * `status`/connection-error shapes are recognised by `isTransientError`.
+     */
     private withRetry;
-    private isTransient;
 }
 //# sourceMappingURL=llmCallerAnthropic.d.ts.map

package/lib/services/agent/llmCallerAnthropic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"llmCallerAnthropic.d.ts","sourceRoot":"","sources":["../../../src/services/agent/llmCallerAnthropic.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAEL,WAAW,EACX,YAAY,EACZ,SAAS,EACT,iBAAiB,EACjB,kBAAkB,EAClB,0BAA0B,EAC3B,MAAM,aAAa,CAAC;AAGrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,qCAAqC;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,2DAA2D;IAC3D,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAID;;;GAGG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;IACb,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO;gBAAzC,OAAO,EAAE,MAAM,EAAW,KAAK,CAAC,EAAE,OAAO,YAAA;CAItD;AAED,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,iBAAiB,CAE1E;AAED,qBAAa,kBAAmB,YAAW,SAAS;IAClD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAY;IACnC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;gBAExB,GAAG,EAAE,qBAAqB;IAShC,IAAI,CAAC,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IA4B7C,UAAU,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,EACrC,GAAG,EAAE,iBAAiB,CAAC,CAAC,CAAC,GACxB,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC;IAI3B,mBAAmB,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,EAC9C,GAAG,EAAE,0BAA0B,CAAC,CAAC,CAAC,GACjC,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC;IAsHjC;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,WAAW;IAiCnB,OAAO,CAAC,gBAAgB;IAkBxB;;;;;OAKG;IACH,OAAO,CAAC,cAAc;YASR,SAAS;IAyBvB,OAAO,CAAC,WAAW;CAYpB"}
+{"version":3,"file":"llmCallerAnthropic.d.ts","sourceRoot":"","sources":["../../../src/services/agent/llmCallerAnthropic.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAEL,WAAW,EACX,YAAY,EACZ,SAAS,EACT,iBAAiB,EACjB,kBAAkB,EAClB,0BAA0B,EAC3B,MAAM,aAAa,CAAC;AAMrB,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EAEpB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,qCAAqC;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,2DAA2D;IAC3D,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,qBAAa,kBAAmB,YAAW,SAAS;IAClD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAY;IACnC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;gBAExB,GAAG,EAAE,qBAAqB;IAShC,IAAI,CAAC,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IA4B7C,UAAU,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,EACrC,GAAG,EAAE,iBAAiB,CAAC,CAAC,CAAC,GACxB,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC;IAI3B,mBAAmB,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,EAC9C,GAAG,EAAE,0BAA0B,CAAC,CAAC,CAAC,GACjC,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC;IAoHjC;;;;;;;;;;;;;;OAcG;IACH,gBAAgB,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,EACrC,GAAG,EAAE,iBAAiB,CAAC,CAAC,CAAC,GACxB;QACD,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;QAC9B,MAAM,EAAE,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC;KACxC;YAgBc,cAAc;IAsF7B;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,WAAW;IAkDnB,OAAO,CAAC,gBAAgB;IAkBxB;;;;;OAKG;IACH,OAAO,CAAC,cAAc;IAStB;;;;OAIG;IACH,OAAO,CAAC,SAAS;CAGlB"}

package/lib/services/agent/llmCallerAnthropic.js

@@ -3,26 +3,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AnthropicLlmCaller = exports.TransientLlmError = void 0;
-exports.isTransientLlmError = isTransientLlmError;
+exports.AnthropicLlmCaller = exports.isTransientLlmError = exports.TransientLlmError = void 0;
 const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
 const zod_1 = require("zod");
-const TRANSIENT_STATUSES = new Set([408, 425, 429, 500, 502, 503, 504]);
-/**
- * Marks an error worth retrying on the gateway path. The Planner catches
- * this specifically to degrade gracefully — drops research, keeps planning.
- */
-class TransientLlmError extends Error {
-    constructor(message, cause) {
-        super(message);
-        this.cause = cause;
-        this.name = "TransientLlmError";
-    }
-}
-exports.TransientLlmError = TransientLlmError;
-function isTransientLlmError(err) {
-    return err instanceof Error && err.name === "TransientLlmError";
-}
+const llmModelRegistry_1 = require("./llmModelRegistry");
+// Transient-retry primitives are shared across all native callers (Phase 1 of
+// LLM_NATIVE_MIGRATION_PLAN). Re-exported here for backward compat with existing
+// importers that pulled `TransientLlmError` / `isTransientLlmError` from this file.
+const llmRetry_1 = require("./llmRetry");
+Object.defineProperty(exports, "TransientLlmError", { enumerable: true, get: function () { return llmRetry_1.TransientLlmError; } });
+Object.defineProperty(exports, "isTransientLlmError", { enumerable: true, get: function () { return llmRetry_1.isTransientLlmError; } });
 class AnthropicLlmCaller {
     constructor(cfg) {
         this.client = new sdk_1.default({
@@ -149,6 +139,101 @@ class AnthropicLlmCaller {
         }
         throw new Error(`AnthropicLlmCaller.structuredWithTools: exceeded ${maxRounds} tool rounds without ${submitToolName}`);
     }
+    /**
+     * Native incremental streaming structured output. Forces the
+     * `submit_<schemaName>` tool and streams its argument JSON as
+     * `input_json_delta` chunks — yielding each partial for token-by-token UI —
+     * then takes the authoritative payload from `stream.finalMessage()` (more
+     * robust than re-concatenating partials) and Zod-validates it.
+     *
+     * Scope: the base StructuredRequest carries no server tools / thinking /
+     * caching (those live on StructuredWithToolsRequest and run the blocking
+     * tool-loop), so this is a single forced-tool turn. Failure handling mirrors
+     * the other streaming callers: a post-stream parse/validation miss rejects
+     * `result` and returns cleanly (so the caller's token loop completes and its
+     * `await result` retry path fires); a mid-stream/connect drop rejects AND
+     * throws out so the iteration aborts.
+     */
+    structuredStream(req) {
+        let resolveResult;
+        let rejectResult;
+        const result = new Promise((resolve, reject) => {
+            resolveResult = resolve;
+            rejectResult = reject;
+        });
+        const self = this;
+        const tokens = {
+            [Symbol.asyncIterator]() {
+                return self.streamIterator(req, resolveResult, rejectResult);
+            },
+        };
+        return { tokens, result };
+    }
+    async *streamIterator(req, resolveResult, rejectResult) {
+        const submitToolName = `submit_${req.schemaName}`;
+        const jsonSchema = zod_1.z.toJSONSchema(req.schema, { target: "draft-7" });
+        const tools = [
+            {
+                name: submitToolName,
+                description: `Submit the final ${req.schemaName} payload. Call this exactly once when ready.`,
+                input_schema: jsonSchema,
+            },
+        ];
+        const { system, messages } = this.splitSystem(req.messages, false);
+        let requestId;
+        let inputTokens;
+        let outputTokens;
+        try {
+            const stream = this.client.messages.stream({
+                model: this.resolveModelId(req.model),
+                max_tokens: req.maxTokens ?? 8192,
+                temperature: req.temperature,
+                system,
+                tools,
+                tool_choice: { type: "tool", name: submitToolName },
+                messages,
+            });
+            for await (const event of stream) {
+                if (event.type === "message_start") {
+                    requestId = event.message.id;
+                    inputTokens = event.message.usage?.input_tokens;
+                }
+                else if (event.type === "content_block_delta" &&
+                    event.delta.type === "input_json_delta") {
+                    const partial = event.delta.partial_json;
+                    if (partial)
+                        yield partial;
+                }
+                else if (event.type === "message_delta") {
+                    outputTokens = event.usage?.output_tokens ?? outputTokens;
+                }
+            }
+            // Authoritative payload from the assembled final message (the forced
+            // tool_use block's input), not the concatenated partials.
+            const final = await stream.finalMessage();
+            const submit = final.content.find((b) => b.type === "tool_use" && b.name === submitToolName);
+            if (!submit) {
+                rejectResult(new Error(`AnthropicLlmCaller.structuredStream: no ${submitToolName} tool_use in final message`));
+                return;
+            }
+            const parsed = req.schema.safeParse(submit.input);
+            if (!parsed.success) {
+                rejectResult(new Error(`AnthropicLlmCaller.structuredStream: schema validation failed for ${req.schemaName}: ${parsed.error.message}`));
+                return;
+            }
+            resolveResult({
+                data: parsed.data,
+                usage: { promptTokens: inputTokens, completionTokens: outputTokens },
+                requestId,
+                attemptedModels: [req.model],
+                usedFallback: false,
+            });
+        }
+        catch (e) {
+            rejectResult(e);
+            throw e;
+        }
+    }
     // ---------- helpers ----------
     /**
      * Anthropic's API takes a top-level `system` (string or TextBlockParam[])
@@ -170,9 +255,24 @@ class AnthropicLlmCaller {
                 systemText = systemText ? `${systemText}\n\n${m.content}` : m.content;
                 continue;
             }
-            // Image attachments are not yet plumbed for the Anthropic caller —
-            // planner doesn't need them today. When the critic moves over (it's
-            // vision-heavy), wire image blocks here.
+            // Vision: when a message carries imageUrls, emit a content-block array
+            // (text + image blocks) instead of a bare string. Uses Anthropic's native
+            // URL image source (`source.type: "url"`) — no base64 round-trip — which
+            // the direct API supports (unlike the gateway's Anthropic translator,
+            // which rejected raw https URLs). Needed for the critic fallback
+            // (claude-sonnet-4-6, vision) now that it routes here instead of the
+            // gateway.
+            if (m.imageUrls?.length) {
+                const blocks = [
+                    { type: "text", text: m.content },
+                    ...m.imageUrls.map((url) => ({
+                        type: "image",
+                        source: { type: "url", url },
+                    })),
+                ];
+                out.push({ role: m.role, content: blocks });
+                continue;
+            }
             out.push({ role: m.role, content: m.content });
         }
         if (!systemText)
@@ -207,49 +307,24 @@ class AnthropicLlmCaller {
         });
     }
     /**
-     * Map our ModelChoice → Anthropic API model id. Pass-through today since
-     * routing uses Anthropic-shaped ids (e.g. "claude-sonnet-4-6"). If a
-     * future routing entry uses a non-Anthropic id we'd want to throw rather
-     * than silently send GPT names to the Anthropic API.
+     * Map our ModelChoice → Anthropic API model id via the shared registry
+     * (pass-through today). Throws on a non-Anthropic provider rather than
+     * silently sending GPT/Gemini names to the Anthropic API — the dispatcher
+     * routes by provider, so this guards against a mis-wire.
      */
     resolveModelId(m) {
-        if (m.provider !== "anthropic") {
-            throw new Error(`AnthropicLlmCaller cannot serve provider=${m.provider}; route to GatewayLlmCaller instead.`);
-        }
-        return m.modelId;
-    }
-    async withRetry(fn) {
-        let lastErr;
-        for (let attempt = 0; attempt < this.maxRetries; attempt++) {
-            try {
-                return await fn();
-            }
-            catch (err) {
-                lastErr = err;
-                const transient = this.isTransient(err);
-                if (!transient || attempt === this.maxRetries - 1) {
-                    if (transient) {
-                        throw new TransientLlmError(`Anthropic transient error after ${attempt + 1} attempts: ${String(err?.message ?? err)}`, err);
-                    }
-                    throw err;
-                }
-                await new Promise((r) => setTimeout(r, 250 * Math.pow(4, attempt)));
-            }
+        if ((0, llmModelRegistry_1.normalizeProvider)(m.provider) !== "anthropic") {
+            throw new Error(`AnthropicLlmCaller cannot serve provider=${m.provider}; route via the dispatcher.`);
         }
-        throw lastErr;
+        return (0, llmModelRegistry_1.nativeModelId)(m);
     }
-    isTransient(err) {
-        if (!err || typeof err !== "object")
-            return false;
-        const e = err;
-        if (typeof e.status === "number" && TRANSIENT_STATUSES.has(e.status)) {
-            return true;
-        }
-        if (e.name === "APIConnectionError" || e.name === "APIConnectionTimeoutError") {
-            return true;
-        }
-        const msg = String(e.message ?? "");
-        return /timeout|ECONNRESET|ETIMEDOUT|network|socket hang up/i.test(msg);
+    /**
+     * Delegates to the shared transient-retry helper so all native callers share
+     * one backoff/classification policy (Phase 1 extraction). The SDK's own
+     * `status`/connection-error shapes are recognised by `isTransientError`.
+     */
+    withRetry(fn) {
+        return (0, llmRetry_1.withRetry)(fn, { maxRetries: this.maxRetries });
     }
 }
 exports.AnthropicLlmCaller = AnthropicLlmCaller;

package/lib/services/agent/llmCallerFactory.d.ts

@@ -0,0 +1,34 @@
+import { LlmCaller } from "./llmCaller";
+import { ProviderRoutingLlmCaller } from "./llmCallerRouting";
+/**
+ * Build the native provider-dispatching LlmCaller from per-provider API keys
+ * (LLM_NATIVE_MIGRATION_PLAN). This is the single place the "construct three
+ * native callers + wrap in a dispatcher" wiring lives — both app bootstraps
+ * (firebase-functions, node-express-server) and the dev/eval scripts call it
+ * instead of copy-pasting the construction. Replaced the old per-call-site
+ * `new GatewayLlmCaller(...)`.
+ *
+ * Hosts own env reading (keys are passed in, not read here) so this stays a
+ * pure function. A provider with no key is left unwired — calls routed to it
+ * throw at dispatch, and its name is returned in `missing` so the caller can
+ * log/alert at boot rather than at first use.
+ */
+export interface NativeLlmCallerResult {
+    /** The dispatcher to hand to setLlmCaller(). */
+    caller: ProviderRoutingLlmCaller;
+    /**
+     * The Anthropic caller instance (or undefined if no key). Exposed so the
+     * functions host can also setAnthropicCaller() for the planner's web-search
+     * grounding, sharing the one client the dispatcher uses.
+     */
+    anthropic?: LlmCaller;
+    /** Provider env-var names with no key supplied, for boot-time logging. */
+    missing: string[];
+}
+export declare function createNativeLlmCaller(opts: {
+    openaiKey?: string;
+    anthropicKey?: string;
+    geminiKey?: string;
+    timeoutMs?: number;
+}): NativeLlmCallerResult;
+//# sourceMappingURL=llmCallerFactory.d.ts.map

package/lib/services/agent/llmCallerFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"llmCallerFactory.d.ts","sourceRoot":"","sources":["../../../src/services/agent/llmCallerFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAIxC,OAAO,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AAE9D;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,qBAAqB;IACpC,gDAAgD;IAChD,MAAM,EAAE,wBAAwB,CAAC;IACjC;;;;OAIG;IACH,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,0EAA0E;IAC1E,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IAC1C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,GAAG,qBAAqB,CAuBxB"}

package/lib/services/agent/llmCallerFactory.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNativeLlmCaller = createNativeLlmCaller;
+const llmCallerAnthropic_1 = require("./llmCallerAnthropic");
+const llmCallerOpenai_1 = require("./llmCallerOpenai");
+const llmCallerGemini_1 = require("./llmCallerGemini");
+const llmCallerRouting_1 = require("./llmCallerRouting");
+function createNativeLlmCaller(opts) {
+    const { openaiKey, anthropicKey, geminiKey, timeoutMs } = opts;
+    const anthropic = anthropicKey
+        ? new llmCallerAnthropic_1.AnthropicLlmCaller({ apiKey: anthropicKey, timeoutMs })
+        : undefined;
+    const openai = openaiKey
+        ? new llmCallerOpenai_1.OpenAiLlmCaller({ apiKey: openaiKey, timeoutMs })
+        : undefined;
+    const google = geminiKey
+        ? new llmCallerGemini_1.GeminiLlmCaller({ apiKey: geminiKey, timeoutMs })
+        : undefined;
+    const missing = [];
+    if (!openaiKey)
+        missing.push("OPENAI_API_KEY");
+    if (!anthropicKey)
+        missing.push("ANTHROPIC_API_KEY");
+    if (!geminiKey)
+        missing.push("GOOGLE_API_KEY");
+    return {
+        caller: new llmCallerRouting_1.ProviderRoutingLlmCaller({ anthropic, openai, google }),
+        anthropic,
+        missing,
+    };
+}

package/lib/services/agent/llmCallerGemini.d.ts

@@ -0,0 +1,62 @@
+import { z } from "zod";
+import { ChatRequest, ChatResponse, LlmCaller, StructuredRequest, StructuredResponse } from "./llmCaller";
+/**
+ * Direct Google Gemini SDK LlmCaller (`@google/genai`) — native replacement for
+ * the Google slice of the Vercel AI Gateway (LLM_NATIVE_MIGRATION_PLAN Phase 4).
+ *
+ * Required to not regress the critic (gemini-2.5-flash, vision) and reference
+ * (gemini-2.5-pro, vision) roles, which route to `google` today. Single-provider:
+ * only serves `provider === "google"` ModelChoices; transport retry only (the
+ * dispatcher owns cross-provider fallback).
+ *
+ * Structured output uses Gemini's native `responseSchema` + JSON mime type; the
+ * client-side `JSON.parse` + Zod `safeParse` stay the source of truth (same
+ * contract as the OpenAI/gateway callers).
+ *
+ * Mapping notes:
+ *   - system messages → `config.systemInstruction` (Gemini has no system role).
+ *   - assistant role → Gemini's "model" role.
+ *   - maxTokens → `config.maxOutputTokens`.
+ *   - vision: imageUrls are fetched + base64-inlined (`inlineData`); Gemini does
+ *     not accept arbitrary https URLs in `generateContent`.
+ */
+export interface GeminiCallerConfig {
+    apiKey: string;
+    /** Default request timeout in ms. Default 180s. */
+    timeoutMs?: number;
+    /** Max retries on transient errors per call. Default 3. */
+    maxRetries?: number;
+    /** Optional fetch override (tests). */
+    fetchImpl?: typeof fetch;
+}
+export declare class GeminiLlmCaller implements LlmCaller {
+    private readonly ai;
+    private readonly maxRetries;
+    private readonly fetchImpl;
+    constructor(cfg: GeminiCallerConfig);
+    chat(req: ChatRequest): Promise<ChatResponse>;
+    structured<T extends z.ZodTypeAny>(req: StructuredRequest<T>): Promise<StructuredResponse<T>>;
+    structuredStream<T extends z.ZodTypeAny>(req: StructuredRequest<T>): {
+        tokens: AsyncIterable<string>;
+        result: Promise<StructuredResponse<T>>;
+    };
+    private streamIterator;
+    private buildConfig;
+    /**
+     * Split system messages into a merged `systemInstruction` and map the rest to
+     * Gemini `Content` (user/model roles). Vision images are fetched + inlined.
+     */
+    private encode;
+    /** Fetch an image URL and inline it as base64 (Gemini rejects raw https URLs). */
+    private toInlinePart;
+    private parseStructured;
+    private resolveModelId;
+    private usage;
+    /**
+     * Transport retry mapping the genai SDK's error shape (carries a numeric
+     * `status`) into the shared transient policy. Non-transient statuses
+     * (400/401/403/404) propagate immediately.
+     */
+    private withRetry;
+}
+//# sourceMappingURL=llmCallerGemini.d.ts.map

package/lib/services/agent/llmCallerGemini.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"llmCallerGemini.d.ts","sourceRoot":"","sources":["../../../src/services/agent/llmCallerGemini.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAEL,WAAW,EACX,YAAY,EACZ,SAAS,EACT,iBAAiB,EACjB,kBAAkB,EACnB,MAAM,aAAa,CAAC;AAKrB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,mDAAmD;IACnD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,2DAA2D;IAC3D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,uCAAuC;IACvC,SAAS,CAAC,EAAE,OAAO,KAAK,CAAC;CAC1B;AAID,qBAAa,eAAgB,YAAW,SAAS;IAC/C,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAc;IACjC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAe;gBAE7B,GAAG,EAAE,kBAAkB;IAM7B,IAAI,CAAC,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IAuB7C,UAAU,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,EACrC,GAAG,EAAE,iBAAiB,CAAC,CAAC,CAAC,GACxB,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC;IAwBjC,gBAAgB,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,EACrC,GAAG,EAAE,iBAAiB,CAAC,CAAC,CAAC,GACxB;QACD,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;QAC9B,MAAM,EAAE,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC;KACxC;YAgBc,cAAc;IAyD7B,OAAO,CAAC,WAAW;IAmBnB;;;OAGG;YACW,MAAM;IAyBpB,kFAAkF;YACpE,YAAY;IAkB1B,OAAO,CAAC,eAAe;IA0BvB,OAAO,CAAC,cAAc;IAStB,OAAO,CAAC,KAAK;IAcb;;;;OAIG;IACH,OAAO,CAAC,SAAS;CAmBlB"}