vidspotai-shared 1.0.84 → 1.0.86

package/lib/services/agent/llmCallerGateway.js

@@ -1,368 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GatewayLlmCaller = void 0;
-const zod_1 = require("zod");
-/**
- * Marks a transient error that should trigger HTTP retry (and, when exhausted,
- * model fallback). Non-transient errors (4xx other than 408/429, schema
- * validation, malformed JSON) are NOT wrapped and propagate immediately.
- */
-class TransientLlmError extends Error {
-    constructor(message, cause) {
-        super(message);
-        this.cause = cause;
-        this.name = "TransientLlmError";
-    }
-}
-const TRANSIENT_HTTP_STATUSES = new Set([408, 425, 429, 500, 502, 503, 504]);
-function isTransientNetworkError(err) {
-    if (!err || typeof err !== "object")
-        return false;
-    const e = err;
-    const code = e.code ?? e.cause?.code;
-    if (code && /^(ECONNRESET|ECONNREFUSED|ETIMEDOUT|EAI_AGAIN|EPIPE|UND_ERR_.*)$/.test(code)) {
-        return true;
-    }
-    // Our own per-request timeout (ctrl.abort() in postOnce / structuredStream)
-    // surfaces as AbortError "This operation was aborted". Treat as transient so
-    // the retry loop (and then the fallback model) gets a chance — otherwise a
-    // single slow Gemini Flash vision call sinks the entire critic stage with
-    // no recovery.
-    if (e.name === "AbortError")
-        return true;
-    const msg = String(e.message ?? "");
-    return /fetch failed|socket hang up|other side closed|network|timeout|operation was aborted/i.test(msg);
-}
-class GatewayLlmCaller {
-    constructor(cfg) {
-        this.cfg = cfg;
-        this.fetchImpl = cfg.fetchImpl ?? fetch;
-        this.timeoutMs = cfg.timeoutMs ?? 60000;
-        this.maxRetries = cfg.maxRetries ?? 3;
-        this.retryBaseMs = cfg.retryBaseMs ?? 250;
-    }
-    async chat(req) {
-        const attempted = [];
-        const run = async (model) => {
-            attempted.push(model);
-            const messages = await Promise.all(req.messages.map((m) => this.encodeMessage(m)));
-            const raw = await this.postWithRetry({
-                model: this.modelId(model),
-                messages,
-                temperature: req.temperature,
-                max_tokens: req.maxTokens,
-                stop: req.stop,
-            });
-            const text = raw.choices?.[0]?.message?.content ?? "";
-            return {
-                text: typeof text === "string" ? text : JSON.stringify(text),
-                usage: this.usage(raw),
-                requestId: raw.id,
-            };
-        };
-        try {
-            const out = await run(req.model);
-            return { ...out, attemptedModels: attempted, usedFallback: false };
-        }
-        catch (err) {
-            if (req.fallbackModel && err instanceof TransientLlmError) {
-                const out = await run(req.fallbackModel);
-                return { ...out, attemptedModels: attempted, usedFallback: true };
-            }
-            throw err;
-        }
-    }
-    async structured(req) {
-        const attempted = [];
-        const jsonSchema = zod_1.z.toJSONSchema(req.schema, { target: "draft-7" });
-        const run = async (model) => {
-            attempted.push(model);
-            const messages = await Promise.all(req.messages.map((m) => this.encodeMessage(m)));
-            const raw = await this.postWithRetry({
-                model: this.modelId(model),
-                messages,
-                temperature: req.temperature,
-                max_tokens: req.maxTokens,
-                response_format: {
-                    type: "json_schema",
-                    json_schema: {
-                        name: req.schemaName,
-                        schema: jsonSchema,
-                        strict: true,
-                    },
-                },
-            });
-            const txt = raw.choices?.[0]?.message?.content ?? "";
-            if (!txt || typeof txt !== "string") {
-                // Empty body from the model is not retryable across providers —
-                // surface immediately; planner-level retry can re-prompt.
-                throw new Error(`GatewayLlmCaller.structured: empty response for schema ${req.schemaName}`);
-            }
-            let parsed;
-            try {
-                parsed = JSON.parse(txt);
-            }
-            catch {
-                throw new Error(`GatewayLlmCaller.structured: model returned non-JSON for schema ${req.schemaName}: ${txt.slice(0, 200)}`);
-            }
-            const result = req.schema.safeParse(parsed);
-            if (!result.success) {
-                throw new Error(`GatewayLlmCaller.structured: schema validation failed for ${req.schemaName}: ${result.error.message}`);
-            }
-            return {
-                data: result.data,
-                usage: this.usage(raw),
-                requestId: raw.id,
-            };
-        };
-        try {
-            const out = await run(req.model);
-            return { ...out, attemptedModels: attempted, usedFallback: false };
-        }
-        catch (err) {
-            if (req.fallbackModel && err instanceof TransientLlmError) {
-                const out = await run(req.fallbackModel);
-                return { ...out, attemptedModels: attempted, usedFallback: true };
-            }
-            throw err;
-        }
-    }
-    structuredStream(req) {
-        // Streaming: fall back is NOT applied mid-stream (would confuse UI
-        // chunks). Transport retry IS applied on the initial connect; once
-        // bytes start flowing, a mid-stream drop propagates as an error and
-        // the caller (planner) handles it via its own retry loop.
-        let resolveResult;
-        let rejectResult;
-        const result = new Promise((resolve, reject) => {
-            resolveResult = resolve;
-            rejectResult = reject;
-        });
-        const self = this;
-        const tokens = {
-            [Symbol.asyncIterator]() {
-                return self.createStreamingIterator(req, resolveResult, rejectResult);
-            },
-        };
-        return { tokens, result };
-    }
-    async *createStreamingIterator(req, resolveResult, rejectResult) {
-        const jsonSchema = zod_1.z.toJSONSchema(req.schema, { target: "draft-7" });
-        const messages = await Promise.all(req.messages.map((m) => this.encodeMessage(m)));
-        const ctrl = new AbortController();
-        const t = setTimeout(() => ctrl.abort(), this.timeoutMs);
-        let accumulated = "";
-        let requestId;
-        let usage;
-        try {
-            // Connect attempt with retry on transient connect failures (pre-stream).
-            const res = await this.withRetry(() => this.fetchImpl(`${this.cfg.baseUrl.replace(/\/$/, "")}/chat/completions`, {
-                method: "POST",
-                headers: {
-                    "content-type": "application/json",
-                    authorization: `Bearer ${this.cfg.apiKey}`,
-                },
-                body: JSON.stringify({
-                    model: this.modelId(req.model),
-                    messages,
-                    temperature: req.temperature,
-                    max_tokens: req.maxTokens,
-                    stream: true,
-                    response_format: {
-                        type: "json_schema",
-                        json_schema: {
-                            name: req.schemaName,
-                            schema: jsonSchema,
-                            strict: true,
-                        },
-                    },
-                }),
-                signal: ctrl.signal,
-            }).then((r) => {
-                if (!r.ok && TRANSIENT_HTTP_STATUSES.has(r.status)) {
-                    throw new TransientLlmError(`GatewayLlmCaller.structuredStream: ${r.status} ${r.statusText}`);
-                }
-                return r;
-            }));
-            if (!res.ok || !res.body) {
-                const text = await res.text().catch(() => "");
-                const err = new Error(`GatewayLlmCaller.structuredStream: ${res.status} ${res.statusText} — ${text.slice(0, 500)}`);
-                rejectResult(err);
-                throw err;
-            }
-            const reader = res.body.getReader();
-            const decoder = new TextDecoder();
-            let buf = "";
-            while (true) {
-                const { value, done } = await reader.read();
-                if (done)
-                    break;
-                buf += decoder.decode(value, { stream: true });
-                let nl;
-                while ((nl = buf.indexOf("\n")) !== -1) {
-                    const line = buf.slice(0, nl).trim();
-                    buf = buf.slice(nl + 1);
-                    if (!line || !line.startsWith("data:"))
-                        continue;
-                    const payload = line.slice(5).trim();
-                    if (payload === "[DONE]")
-                        break;
-                    try {
-                        const obj = JSON.parse(payload);
-                        if (obj.id)
-                            requestId = obj.id;
-                        if (obj.usage) {
-                            usage = {
-                                promptTokens: obj.usage.prompt_tokens,
-                                completionTokens: obj.usage.completion_tokens,
-                            };
-                        }
-                        const delta = obj.choices?.[0]?.delta?.content ?? "";
-                        if (delta) {
-                            accumulated += delta;
-                            yield delta;
-                        }
-                    }
-                    catch {
-                        // skip malformed line
-                    }
-                }
-            }
-            // Post-stream failures (bad JSON / schema mismatch) reject the RESULT
-            // promise but must NOT throw out of this generator. The tokens already
-            // streamed fine; throwing here would propagate into the caller's
-            // `for await (...stream.tokens)` loop and abort it before the caller can
-            // reach `await stream.result` — which is exactly where the planner's
-            // non-streaming retry fallback lives (Planner.planStream). Returning
-            // cleanly lets the token loop complete, then the rejected result drives
-            // the retry. See plan.controller.ts:planProjectStream.
-            let parsed;
-            try {
-                parsed = JSON.parse(accumulated);
-            }
-            catch {
-                const err = new Error(`GatewayLlmCaller.structuredStream: model returned non-JSON for ${req.schemaName}: ${accumulated.slice(0, 200)}`);
-                rejectResult(err);
-                return;
-            }
-            const validated = req.schema.safeParse(parsed);
-            if (!validated.success) {
-                const err = new Error(`GatewayLlmCaller.structuredStream: schema validation failed for ${req.schemaName}: ${validated.error.message}`);
-                rejectResult(err);
-                return;
-            }
-            resolveResult({
-                data: validated.data,
-                usage,
-                requestId,
-                attemptedModels: [req.model],
-                usedFallback: false,
-            });
-        }
-        catch (e) {
-            rejectResult(e);
-            throw e;
-        }
-        finally {
-            clearTimeout(t);
-        }
-    }
-    modelId(m) {
-        return `${m.provider}/${m.modelId}`;
-    }
-    async encodeMessage(m) {
-        if (!m.imageUrls?.length) {
-            return { role: m.role, content: m.content };
-        }
-        // Fetch + base64-encode each URL into a data URI. The gateway's Anthropic
-        // translator rejects raw https URLs ("URL sources are not supported"); data
-        // URIs round-trip through every provider's OpenAI-compat shim correctly.
-        const dataUris = await Promise.all(m.imageUrls.map((u) => this.toDataUri(u)));
-        return {
-            role: m.role,
-            content: [
-                { type: "text", text: m.content },
-                ...dataUris.map((url) => ({ type: "image_url", image_url: { url } })),
-            ],
-        };
-    }
-    async toDataUri(url) {
-        if (url.startsWith("data:"))
-            return url;
-        const res = await this.fetchImpl(url);
-        if (!res.ok) {
-            throw new Error(`GatewayLlmCaller.toDataUri: ${res.status} ${res.statusText} fetching ${url}`);
-        }
-        const contentType = res.headers.get("content-type")?.split(";")[0]?.trim() || "image/jpeg";
-        const buf = Buffer.from(await res.arrayBuffer());
-        return `data:${contentType};base64,${buf.toString("base64")}`;
-    }
-    usage(raw) {
-        if (!raw.usage)
-            return undefined;
-        return {
-            promptTokens: raw.usage.prompt_tokens,
-            completionTokens: raw.usage.completion_tokens,
-        };
-    }
-    /**
-     * POST /chat/completions with transient-error retry (F1).
-     * Throws TransientLlmError after exhausting retries on transient failures —
-     * caller catches it to trigger model fallback (F2). Non-transient errors
-     * (4xx other than 408/425/429, malformed responses) propagate as plain Error.
-     */
-    async postWithRetry(body) {
-        return this.withRetry(() => this.postOnce(body));
-    }
-    async withRetry(fn) {
-        let lastErr;
-        for (let attempt = 0; attempt < this.maxRetries; attempt++) {
-            try {
-                return await fn();
-            }
-            catch (err) {
-                lastErr = err;
-                const transient = err instanceof TransientLlmError || isTransientNetworkError(err);
-                if (!transient || attempt === this.maxRetries - 1) {
-                    if (transient) {
-                        // Wrap so the fallback-model path can catch it explicitly.
-                        throw err instanceof TransientLlmError
-                            ? err
-                            : new TransientLlmError(`transient LLM error after ${attempt + 1} attempts: ${String(err?.message ?? err)}`, err);
-                    }
-                    throw err;
-                }
-                await new Promise((r) => setTimeout(r, this.retryBaseMs * Math.pow(4, attempt)));
-            }
-        }
-        throw lastErr;
-    }
-    async postOnce(body) {
-        const ctrl = new AbortController();
-        const t = setTimeout(() => ctrl.abort(), this.timeoutMs);
-        try {
-            const res = await this.fetchImpl(`${this.cfg.baseUrl.replace(/\/$/, "")}/chat/completions`, {
-                method: "POST",
-                headers: {
-                    "content-type": "application/json",
-                    authorization: `Bearer ${this.cfg.apiKey}`,
-                },
-                body: JSON.stringify(body),
-                signal: ctrl.signal,
-            });
-            if (!res.ok) {
-                const text = await res.text().catch(() => "");
-                const msg = `GatewayLlmCaller: ${res.status} ${res.statusText} — ${text.slice(0, 500)}`;
-                if (TRANSIENT_HTTP_STATUSES.has(res.status)) {
-                    throw new TransientLlmError(msg);
-                }
-                throw new Error(msg);
-            }
-            return (await res.json());
-        }
-        finally {
-            clearTimeout(t);
-        }
-    }
-}
-exports.GatewayLlmCaller = GatewayLlmCaller;