vidspotai-shared 1.0.82 → 1.0.84

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"}

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"}