vidspotai-shared 1.0.82-dev.0 → 1.0.83

package/lib/services/agent/llmCallerGemini.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiLlmCaller = void 0;
+const genai_1 = require("@google/genai");
+const zod_1 = require("zod");
+const llmModelRegistry_1 = require("./llmModelRegistry");
+const llmRetry_1 = require("./llmRetry");
+const TRANSIENT_HTTP = new Set([408, 425, 429, 500, 502, 503, 504]);
+class GeminiLlmCaller {
+    constructor(cfg) {
+        this.ai = new genai_1.GoogleGenAI({ apiKey: cfg.apiKey });
+        this.maxRetries = cfg.maxRetries ?? 3;
+        this.fetchImpl = cfg.fetchImpl ?? fetch;
+    }
+    async chat(req) {
+        const { systemInstruction, contents } = await this.encode(req.messages);
+        const resp = await this.withRetry(() => this.ai.models.generateContent({
+            model: this.resolveModelId(req.model),
+            contents,
+            config: this.buildConfig({
+                systemInstruction,
+                temperature: req.temperature,
+                maxTokens: req.maxTokens,
+                stop: req.stop,
+            }),
+        }));
+        return {
+            text: resp.text ?? "",
+            usage: this.usage(resp),
+            requestId: resp.responseId,
+            attemptedModels: [req.model],
+            usedFallback: false,
+        };
+    }
+    async structured(req) {
+        const { systemInstruction, contents } = await this.encode(req.messages);
+        const jsonSchema = zod_1.z.toJSONSchema(req.schema, { target: "draft-7" });
+        const resp = await this.withRetry(() => this.ai.models.generateContent({
+            model: this.resolveModelId(req.model),
+            contents,
+            config: this.buildConfig({
+                systemInstruction,
+                temperature: req.temperature,
+                maxTokens: req.maxTokens,
+                responseSchema: jsonSchema,
+            }),
+        }));
+        return {
+            ...this.parseStructured(req, resp.text ?? ""),
+            usage: this.usage(resp),
+            requestId: resp.responseId,
+            attemptedModels: [req.model],
+            usedFallback: false,
+        };
+    }
+    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) {
+        let accumulated = "";
+        let requestId;
+        let usage;
+        try {
+            const { systemInstruction, contents } = await this.encode(req.messages);
+            const jsonSchema = zod_1.z.toJSONSchema(req.schema, { target: "draft-7" });
+            const stream = await this.withRetry(() => this.ai.models.generateContentStream({
+                model: this.resolveModelId(req.model),
+                contents,
+                config: this.buildConfig({
+                    systemInstruction,
+                    temperature: req.temperature,
+                    maxTokens: req.maxTokens,
+                    responseSchema: jsonSchema,
+                }),
+            }));
+            for await (const chunk of stream) {
+                if (chunk.responseId)
+                    requestId = chunk.responseId;
+                const u = this.usage(chunk);
+                if (u)
+                    usage = u;
+                const delta = chunk.text ?? "";
+                if (delta) {
+                    accumulated += delta;
+                    yield delta;
+                }
+            }
+            // Post-stream parse/validate failures reject the RESULT promise but must
+            // NOT throw out of the generator (same contract as the other callers —
+            // the planner's retry fallback awaits `result`).
+            try {
+                const parsed = this.parseStructured(req, accumulated);
+                resolveResult({
+                    data: parsed.data,
+                    usage,
+                    requestId,
+                    attemptedModels: [req.model],
+                    usedFallback: false,
+                });
+            }
+            catch (e) {
+                rejectResult(e);
+                return;
+            }
+        }
+        catch (e) {
+            rejectResult(e);
+            throw e;
+        }
+    }
+    // ---------- helpers ----------
+    buildConfig(opts) {
+        const config = {};
+        if (opts.systemInstruction)
+            config.systemInstruction = opts.systemInstruction;
+        if (opts.temperature !== undefined)
+            config.temperature = opts.temperature;
+        if (opts.maxTokens !== undefined)
+            config.maxOutputTokens = opts.maxTokens;
+        if (opts.stop?.length)
+            config.stopSequences = opts.stop;
+        if (opts.responseSchema) {
+            config.responseMimeType = "application/json";
+            config.responseSchema = opts.responseSchema;
+        }
+        return config;
+    }
+    /**
+     * Split system messages into a merged `systemInstruction` and map the rest to
+     * Gemini `Content` (user/model roles). Vision images are fetched + inlined.
+     */
+    async encode(messages) {
+        let systemInstruction;
+        const contents = [];
+        for (const m of messages) {
+            if (m.role === "system") {
+                systemInstruction = systemInstruction
+                    ? `${systemInstruction}\n\n${m.content}`
+                    : m.content;
+                continue;
+            }
+            const role = m.role === "assistant" ? "model" : "user";
+            const parts = [{ text: m.content }];
+            if (m.imageUrls?.length) {
+                for (const url of m.imageUrls) {
+                    parts.push(await this.toInlinePart(url));
+                }
+            }
+            contents.push({ role, parts });
+        }
+        return { systemInstruction, contents };
+    }
+    /** Fetch an image URL and inline it as base64 (Gemini rejects raw https URLs). */
+    async toInlinePart(url) {
+        if (url.startsWith("data:")) {
+            const [meta, data] = url.split(",", 2);
+            const mimeType = meta?.slice(5).split(";")[0] || "image/jpeg";
+            return { inlineData: { mimeType, data: data ?? "" } };
+        }
+        const res = await this.fetchImpl(url);
+        if (!res.ok) {
+            throw new Error(`GeminiLlmCaller.toInlinePart: ${res.status} ${res.statusText} fetching ${url}`);
+        }
+        const mimeType = res.headers.get("content-type")?.split(";")[0]?.trim() || "image/jpeg";
+        const buf = Buffer.from(await res.arrayBuffer());
+        return { inlineData: { mimeType, data: buf.toString("base64") } };
+    }
+    parseStructured(req, txt) {
+        if (!txt) {
+            throw new Error(`GeminiLlmCaller.structured: empty response for schema ${req.schemaName}`);
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(txt);
+        }
+        catch {
+            throw new Error(`GeminiLlmCaller.structured: model returned non-JSON for ${req.schemaName}: ${txt.slice(0, 200)}`);
+        }
+        const result = req.schema.safeParse(parsed);
+        if (!result.success) {
+            throw new Error(`GeminiLlmCaller.structured: schema validation failed for ${req.schemaName}: ${result.error.message}`);
+        }
+        return { data: result.data };
+    }
+    resolveModelId(m) {
+        if ((0, llmModelRegistry_1.normalizeProvider)(m.provider) !== "google") {
+            throw new Error(`GeminiLlmCaller cannot serve provider=${m.provider}; route via the dispatcher.`);
+        }
+        return (0, llmModelRegistry_1.nativeModelId)(m);
+    }
+    usage(resp) {
+        const u = resp.usageMetadata;
+        if (!u)
+            return undefined;
+        return {
+            promptTokens: u.promptTokenCount,
+            completionTokens: u.candidatesTokenCount,
+        };
+    }
+    /**
+     * 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.
+     */
+    withRetry(fn) {
+        return (0, llmRetry_1.withRetry)(async () => {
+            try {
+                return await fn();
+            }
+            catch (err) {
+                const status = err?.status;
+                if (typeof status === "number" && !TRANSIENT_HTTP.has(status)) {
+                    throw err;
+                }
+                if (typeof status === "number" && TRANSIENT_HTTP.has(status)) {
+                    throw new llmRetry_1.TransientLlmError(`Gemini ${status} error`, err);
+                }
+                throw err;
+            }
+        }, { maxRetries: this.maxRetries });
+    }
+}
+exports.GeminiLlmCaller = GeminiLlmCaller;

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

@@ -0,0 +1,56 @@
+import { z } from "zod";
+import { ChatRequest, ChatResponse, LlmCaller, StructuredRequest, StructuredResponse } from "./llmCaller";
+/**
+ * Direct OpenAI SDK LlmCaller — native replacement for the OpenAI slice of the
+ * Vercel AI Gateway (LLM_NATIVE_MIGRATION_PLAN Phase 2).
+ *
+ * Single-provider: only serves `provider === "openai"` ModelChoices (the
+ * dispatcher routes by provider). Does NOT implement cross-provider model
+ * fallback — that's the ProviderRoutingLlmCaller's job; this caller only does
+ * transport retry via the shared `withRetry`.
+ *
+ * Structured output uses the native strict `json_schema` response_format —
+ * identical semantics to what the gateway sent to OpenAI, with the client-side
+ * `JSON.parse` + Zod `safeParse` kept as the source of truth so a strict-mode
+ * miss still surfaces as a deterministic (non-transient) error.
+ *
+ * Native wins over the gateway shape: automatic prompt caching on long stable
+ * prefixes (OpenAI caches ≥1024-token prompts server-side, billed at a
+ * discount, no flag needed) and direct provider billing.
+ */
+export interface OpenAiCallerConfig {
+    apiKey: string;
+    /** Optional base URL override (e.g. an OpenAI-compatible endpoint). */
+    baseURL?: string;
+    /** Default request timeout in ms. Default 180s (matches planner budget). */
+    timeoutMs?: number;
+    /** Max retries on transient errors per call. Default 3. */
+    maxRetries?: number;
+}
+export declare class OpenAiLlmCaller implements LlmCaller {
+    private readonly client;
+    private readonly timeoutMs;
+    private readonly maxRetries;
+    constructor(cfg: OpenAiCallerConfig);
+    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;
+    /** Shared non-streaming params: model id, encoded messages, sampling knobs. */
+    private baseParams;
+    private encodeMessage;
+    /** Parse + Zod-validate the model's text. Throws plain (non-transient) Error. */
+    private parseStructured;
+    private resolveModelId;
+    private usage;
+    /**
+     * Transport retry that re-classifies the OpenAI SDK's APIError shape (it
+     * carries a numeric `status`) into the shared transient policy. Non-transient
+     * statuses (400/401/403/404/422) propagate immediately.
+     */
+    private withRetry;
+}
+//# sourceMappingURL=llmCallerOpenai.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"llmCallerOpenai.d.ts","sourceRoot":"","sources":["../../../src/services/agent/llmCallerOpenai.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAEL,WAAW,EACX,YAAY,EACZ,SAAS,EACT,iBAAiB,EACjB,kBAAkB,EACnB,MAAM,aAAa,CAAC;AAKrB;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,uEAAuE;IACvE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,4EAA4E;IAC5E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,2DAA2D;IAC3D,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAID,qBAAa,eAAgB,YAAW,SAAS;IAC/C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;gBAExB,GAAG,EAAE,kBAAkB;IAU7B,IAAI,CAAC,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IAoB7C,UAAU,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,EACrC,GAAG,EAAE,iBAAiB,CAAC,CAAC,CAAC,GACxB,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC;IA4BjC,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;IAqE7B,+EAA+E;IAC/E,OAAO,CAAC,UAAU;IAoBlB,OAAO,CAAC,aAAa;IAkBrB,iFAAiF;IACjF,OAAO,CAAC,eAAe;IA0BvB,OAAO,CAAC,cAAc;IAStB,OAAO,CAAC,KAAK;IAUb;;;;OAIG;IACH,OAAO,CAAC,SAAS;CAyBlB"}

package/lib/services/agent/llmCallerOpenai.js

@@ -0,0 +1,230 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAiLlmCaller = void 0;
+const openai_1 = __importDefault(require("openai"));
+const zod_1 = require("zod");
+const llmModelRegistry_1 = require("./llmModelRegistry");
+const llmRetry_1 = require("./llmRetry");
+const TRANSIENT_HTTP = new Set([408, 425, 429, 500, 502, 503, 504]);
+class OpenAiLlmCaller {
+    constructor(cfg) {
+        this.client = new openai_1.default({
+            apiKey: cfg.apiKey,
+            ...(cfg.baseURL ? { baseURL: cfg.baseURL } : {}),
+            timeout: cfg.timeoutMs ?? 180000,
+        });
+        this.timeoutMs = cfg.timeoutMs ?? 180000;
+        this.maxRetries = cfg.maxRetries ?? 3;
+    }
+    async chat(req) {
+        const completion = await this.withRetry(() => this.client.chat.completions.create(this.baseParams(req.model, req.messages, {
+            temperature: req.temperature,
+            maxTokens: req.maxTokens,
+            stop: req.stop,
+        })));
+        const text = completion.choices?.[0]?.message?.content ?? "";
+        return {
+            text: typeof text === "string" ? text : JSON.stringify(text),
+            usage: this.usage(completion.usage),
+            requestId: completion.id,
+            attemptedModels: [req.model],
+            usedFallback: false,
+        };
+    }
+    async structured(req) {
+        const jsonSchema = zod_1.z.toJSONSchema(req.schema, { target: "draft-7" });
+        const completion = await this.withRetry(() => this.client.chat.completions.create({
+            ...this.baseParams(req.model, req.messages, {
+                temperature: req.temperature,
+                maxTokens: req.maxTokens,
+            }),
+            response_format: {
+                type: "json_schema",
+                json_schema: {
+                    name: req.schemaName,
+                    schema: jsonSchema,
+                    strict: true,
+                },
+            },
+        }));
+        const txt = completion.choices?.[0]?.message?.content ?? "";
+        return {
+            ...this.parseStructured(req, txt),
+            usage: this.usage(completion.usage),
+            requestId: completion.id,
+            attemptedModels: [req.model],
+            usedFallback: false,
+        };
+    }
+    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 jsonSchema = zod_1.z.toJSONSchema(req.schema, { target: "draft-7" });
+        let accumulated = "";
+        let requestId;
+        let usage;
+        try {
+            // Connect with transient retry; once bytes flow a mid-stream drop
+            // propagates and the planner's own retry loop handles it (mirrors the
+            // gateway's streaming contract).
+            const stream = await this.withRetry(() => this.client.chat.completions.create({
+                ...this.baseParams(req.model, req.messages, {
+                    temperature: req.temperature,
+                    maxTokens: req.maxTokens,
+                }),
+                response_format: {
+                    type: "json_schema",
+                    json_schema: {
+                        name: req.schemaName,
+                        schema: jsonSchema,
+                        strict: true,
+                    },
+                },
+                stream: true,
+                stream_options: { include_usage: true },
+            }));
+            for await (const chunk of stream) {
+                if (chunk.id)
+                    requestId = chunk.id;
+                if (chunk.usage) {
+                    usage = {
+                        promptTokens: chunk.usage.prompt_tokens,
+                        completionTokens: chunk.usage.completion_tokens,
+                    };
+                }
+                const delta = chunk.choices?.[0]?.delta?.content ?? "";
+                if (delta) {
+                    accumulated += delta;
+                    yield delta;
+                }
+            }
+            // Post-stream parse/validate failures reject the RESULT promise but must
+            // NOT throw out of the generator — the planner awaits `result` for its
+            // non-streaming retry fallback. (Same rationale as GatewayLlmCaller.)
+            try {
+                const parsed = this.parseStructured(req, accumulated);
+                resolveResult({
+                    data: parsed.data,
+                    usage,
+                    requestId,
+                    attemptedModels: [req.model],
+                    usedFallback: false,
+                });
+            }
+            catch (e) {
+                rejectResult(e);
+                return;
+            }
+        }
+        catch (e) {
+            rejectResult(e);
+            throw e;
+        }
+    }
+    // ---------- helpers ----------
+    /** Shared non-streaming params: model id, encoded messages, sampling knobs. */
+    baseParams(model, messages, opts) {
+        return {
+            model: this.resolveModelId(model),
+            messages: messages.map((m) => this.encodeMessage(m)),
+            // Only send temperature when explicitly set — gpt-5 reasoning models
+            // reject non-default temperatures, and most agent calls leave it unset.
+            ...(opts.temperature !== undefined ? { temperature: opts.temperature } : {}),
+            // gpt-5 family requires max_completion_tokens (max_tokens is rejected on
+            // reasoning models); it's also accepted by non-reasoning models.
+            ...(opts.maxTokens !== undefined
+                ? { max_completion_tokens: opts.maxTokens }
+                : {}),
+            ...(opts.stop?.length ? { stop: opts.stop } : {}),
+        };
+    }
+    encodeMessage(m) {
+        if (!m.imageUrls?.length) {
+            return { role: m.role, content: m.content };
+        }
+        // OpenAI accepts https image URLs directly (no base64 round-trip needed).
+        // Only user messages carry image parts.
+        const parts = [
+            { type: "text", text: m.content },
+            ...m.imageUrls.map((url) => ({
+                type: "image_url",
+                image_url: { url },
+            })),
+        ];
+        return { role: "user", content: parts };
+    }
+    /** Parse + Zod-validate the model's text. Throws plain (non-transient) Error. */
+    parseStructured(req, txt) {
+        if (!txt || typeof txt !== "string") {
+            throw new Error(`OpenAiLlmCaller.structured: empty response for schema ${req.schemaName}`);
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(txt);
+        }
+        catch {
+            throw new Error(`OpenAiLlmCaller.structured: model returned non-JSON for ${req.schemaName}: ${txt.slice(0, 200)}`);
+        }
+        const result = req.schema.safeParse(parsed);
+        if (!result.success) {
+            throw new Error(`OpenAiLlmCaller.structured: schema validation failed for ${req.schemaName}: ${result.error.message}`);
+        }
+        return { data: result.data };
+    }
+    resolveModelId(m) {
+        if ((0, llmModelRegistry_1.normalizeProvider)(m.provider) !== "openai") {
+            throw new Error(`OpenAiLlmCaller cannot serve provider=${m.provider}; route via the dispatcher.`);
+        }
+        return (0, llmModelRegistry_1.nativeModelId)(m);
+    }
+    usage(u) {
+        if (!u)
+            return undefined;
+        return {
+            promptTokens: u.prompt_tokens,
+            completionTokens: u.completion_tokens,
+        };
+    }
+    /**
+     * Transport retry that re-classifies the OpenAI SDK's APIError shape (it
+     * carries a numeric `status`) into the shared transient policy. Non-transient
+     * statuses (400/401/403/404/422) propagate immediately.
+     */
+    withRetry(fn) {
+        return (0, llmRetry_1.withRetry)(async () => {
+            try {
+                return await fn();
+            }
+            catch (err) {
+                // OpenAI APIError exposes `status`; map 5xx/429/408 → transient so the
+                // shared loop retries, everything else short-circuits.
+                const status = err?.status;
+                if (typeof status === "number" && !TRANSIENT_HTTP.has(status)) {
+                    // Deterministic API error — wrap nothing, rethrow as-is.
+                    throw err;
+                }
+                if (typeof status === "number" && TRANSIENT_HTTP.has(status)) {
+                    throw new llmRetry_1.TransientLlmError(`OpenAI ${status} error`, err);
+                }
+                throw err;
+            }
+        }, { maxRetries: this.maxRetries });
+    }
+}
+exports.OpenAiLlmCaller = OpenAiLlmCaller;

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

@@ -1 +1 @@
-{"version":3,"file":"llmCallerRegistry.d.ts","sourceRoot":"","sources":["../../../src/services/agent/llmCallerRegistry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAyB,MAAM,aAAa,CAAC;AAY/D,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAEpD;AAED,wBAAgB,YAAY,IAAI,SAAS,CAExC;AAeD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,GAAG,IAAI,CAEjE;AAED,wBAAgB,kBAAkB,IAAI,SAAS,GAAG,IAAI,CAErD"}
+{"version":3,"file":"llmCallerRegistry.d.ts","sourceRoot":"","sources":["../../../src/services/agent/llmCallerRegistry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAyB,MAAM,aAAa,CAAC;AAa/D,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAEpD;AAED,wBAAgB,YAAY,IAAI,SAAS,CAExC;AAcD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,GAAG,IAAI,CAEjE;AAED,wBAAgB,kBAAkB,IAAI,SAAS,GAAG,IAAI,CAErD"}

package/lib/services/agent/llmCallerRegistry.js

@@ -7,7 +7,8 @@ exports.getAnthropicCaller = getAnthropicCaller;
 const llmCaller_1 = require("./llmCaller");
 /**
  * Singleton LlmCaller accessor. Host wires a concrete impl at boot
- * (e.g. GatewayLlmCaller); agent code reads via getLlmCaller().
+ * (the native ProviderRoutingLlmCaller via createNativeLlmCaller); agent code
+ * reads via getLlmCaller().
  *
  * Throwing UnconfiguredLlmCaller is the default so tests fail loud
  * if the host forgets to wire.
@@ -21,14 +22,13 @@ function getLlmCaller() {
 }
 /**
  * Optional Anthropic-direct caller. Wired only on hosts that have
- * ANTHROPIC_API_KEY set and need Anthropic-specific features (server-side
- * web_search, prompt caching, extended thinking). The Planner reads this
- * only when `useWebResearch` is requested — otherwise the default gateway
- * caller is used so provider portability is preserved.
+ * ANTHROPIC_API_KEY set and need Anthropic server-side web_search for the
+ * planner's research grounding. The Planner reads this only when
+ * `useWebResearch` is requested — otherwise it goes through the normal
+ * dispatcher (getLlmCaller()), which already routes Anthropic models natively.
  *
  * Null when unconfigured rather than throwing — caller code checks and
- * gracefully falls back to the gateway path. See AnthropicLlmCaller docstring
- * for deferred features (Tavily custom tools, fallback chain, streaming).
+ * gracefully falls back to the non-web-research planner path.
  */
 let anthropicInstance = null;
 function setAnthropicCaller(caller) {

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

@@ -0,0 +1,63 @@
+import { z } from "zod";
+import { ChatRequest, ChatResponse, LlmCaller, StructuredRequest, StructuredResponse, StructuredWithToolsRequest } from "./llmCaller";
+/**
+ * Provider-dispatching LlmCaller — the native replacement for GatewayLlmCaller
+ * as the wired singleton (LLM_NATIVE_MIGRATION_PLAN Phase 5).
+ *
+ * It owns the two responsibilities the single gateway endpoint used to give us
+ * for free, now that each provider has its own SDK caller:
+ *   1. Dispatch by `req.model.provider` → the matching native caller.
+ *   2. Cross-provider `fallbackModel` (F2): when the primary exhausts retries on
+ *      a TRANSIENT error, attempt the fallback once (which may be a different
+ *      provider). Deterministic errors (schema/auth/4xx) do NOT trigger fallback
+ *      — identical semantics to the gateway.
+ *
+ * The native callers each handle ONE provider and do transport retry only; the
+ * dispatcher never re-implements backoff.
+ *
+ * Streaming: delegates to the chosen caller's `structuredStream` when present.
+ * All three native callers (Anthropic / OpenAI / Gemini) now implement native
+ * incremental streaming, so the dispatcher streams token-by-token on every
+ * provider. The single-chunk fallback below remains only as a safety net for
+ * any future caller that omits `structuredStream` — the LlmCaller contract
+ * explicitly allows a single full-payload emission.
+ */
+export interface ProviderCallers {
+    anthropic?: LlmCaller;
+    openai?: LlmCaller;
+    google?: LlmCaller;
+}
+export declare class ProviderRoutingLlmCaller implements LlmCaller {
+    private readonly callers;
+    constructor(callers: ProviderCallers);
+    private pick;
+    chat(req: ChatRequest): Promise<ChatResponse>;
+    structured<T extends z.ZodTypeAny>(req: StructuredRequest<T>): Promise<StructuredResponse<T>>;
+    /**
+     * Forward to the chosen caller's native streaming when available; otherwise
+     * emit the full validated payload as a single chunk. Streaming does NOT apply
+     * cross-provider fallback mid-stream (matches the gateway): once bytes flow, a
+     * drop propagates and the planner's own retry loop (which awaits `result`)
+     * handles it.
+     */
+    structuredStream<T extends z.ZodTypeAny>(req: StructuredRequest<T>): {
+        tokens: AsyncIterable<string>;
+        result: Promise<StructuredResponse<T>>;
+    };
+    /**
+     * Anthropic (and any future non-streaming caller) path: run the blocking
+     * `structured` call, then surface its JSON as one token chunk. Failures reject
+     * the result promise and return cleanly from the generator rather than
+     * throwing — so the caller's token loop completes and its `await result`
+     * retry path fires (same contract as the streaming callers).
+     */
+    private singleChunkStream;
+    /**
+     * Anthropic-only server-tool path (web_search). Routes to the anthropic caller
+     * if it implements `structuredWithTools`; otherwise throws, since no other
+     * provider exposes Anthropic's server tools. Preserves the planner's
+     * useWebResearch behavior after the gateway is gone.
+     */
+    structuredWithTools<T extends z.ZodTypeAny>(req: StructuredWithToolsRequest<T>): Promise<StructuredResponse<T>>;
+}
+//# sourceMappingURL=llmCallerRouting.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"llmCallerRouting.d.ts","sourceRoot":"","sources":["../../../src/services/agent/llmCallerRouting.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EACL,WAAW,EACX,YAAY,EACZ,SAAS,EACT,iBAAiB,EACjB,kBAAkB,EAClB,0BAA0B,EAC3B,MAAM,aAAa,CAAC;AAKrB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,eAAe;IAC9B,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB,MAAM,CAAC,EAAE,SAAS,CAAC;CACpB;AAED,qBAAa,wBAAyB,YAAW,SAAS;IAC5C,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,eAAe;IAErD,OAAO,CAAC,IAAI;IAYN,IAAI,CAAC,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IAoB7C,UAAU,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,EACrC,GAAG,EAAE,iBAAiB,CAAC,CAAC,CAAC,GACxB,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC;IAsBjC;;;;;;OAMG;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;IASD;;;;;;OAMG;IACH,OAAO,CAAC,iBAAiB;IAgCzB;;;;;OAKG;IACG,mBAAmB,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,EAC9C,GAAG,EAAE,0BAA0B,CAAC,CAAC,CAAC,GACjC,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC;CAUlC"}