@aexol/spectral 0.9.231 → 0.9.234

package/dist/sdk/ai/providers/openrouter-videos.js

@@ -0,0 +1,412 @@
+import { getEnvApiKey } from "../env-api-keys.js";
+import { imageSourceUrlForProvider } from "../utils/image-source.js";
+/**
+ * Video generation routing (mirrors `openrouter-images.ts`).
+ *
+ * PRIMARY PATH: when `options.backendUrl` and `options.apiKey` (the machine
+ * JWT) are provided, generation is submitted to the backend proxy at
+ * `POST ${backendUrl}/video/generation` and polled at
+ * `GET ${backendUrl}/video/generation/{videoId}`. The backend runs the
+ * upstream OpenRouter job with ITS OWN `OPENROUTER_API_KEY`, stores the
+ * finished video in its object storage (`/generated-videos/<id>`) and reports
+ * cost — the CLI never needs a local key and never receives video bytes.
+ *
+ * FALLBACK PATH: when the proxy is unavailable (404/501/5xx, connection
+ * errors — the endpoint may not exist yet) or no backend routing is
+ * configured (standalone SDK use), we submit + poll + download directly
+ * against OpenRouter with a local `OPENROUTER_API_KEY`:
+ *
+ *   POST {baseUrl}/videos                     -> 202 { id, polling_url, status }
+ *   GET  polling_url (every ~30s, <= 15 min)  -> { status: completed|failed, ... }
+ *   GET  {baseUrl}/videos/{id}/content?index=0  (Authorization header; bytes)
+ */
+const DEFAULT_TIMEOUT_MS = 120_000;
+const DEFAULT_MAX_POLL_MS = 900_000; // 15 minutes overall budget
+const DIRECT_POLL_INTERVAL_MS = 30_000;
+const PROXY_POLL_INTERVAL_MS = 15_000; // the backend polls upstream itself
+const VIDEO_MIME_TYPE = "video/mp4";
+const PASSTHROUGH_KEYS = [
+    "duration",
+    "resolution",
+    "aspect_ratio",
+    "size",
+    "generate_audio",
+    "seed",
+];
+function textFromContext(context) {
+    return context.input
+        .filter((item) => item.type === "text")
+        .map((item) => item.text.trim())
+        .filter(Boolean)
+        .join("\n\n");
+}
+function framesFromContext(context) {
+    return context.input.filter((item) => item.type === "image");
+}
+function usageFromCost(cost) {
+    const total = Number(cost ?? 0) || 0;
+    return {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: 0,
+        cost: { input: 0, output: total, cacheRead: 0, cacheWrite: 0, total },
+        credits: total || undefined,
+    };
+}
+function errorResult(model, message, aborted) {
+    return {
+        api: model.api,
+        provider: model.provider,
+        model: model.id,
+        output: [],
+        stopReason: aborted ? "aborted" : "error",
+        errorMessage: message,
+        timestamp: Date.now(),
+    };
+}
+/** True for statuses that mean "the proxy endpoint does not exist / is down". */
+function isProxyUnavailableStatus(status) {
+    return status === 404 || status === 501 || status === 502 || status === 503 || status === 504;
+}
+function errorMessageFromJson(json, fallback) {
+    return json?.error?.message ?? json?.message ?? fallback;
+}
+function fetchJson(url, init) {
+    return (async () => {
+        const response = await fetch(url, init);
+        const rawText = await response.text();
+        let json;
+        try {
+            json = rawText ? JSON.parse(rawText) : {};
+        }
+        catch {
+            throw new Error(`Response was not JSON: ${rawText.slice(0, 500)}`);
+        }
+        return { response, json };
+    })();
+}
+function makeSignal(options, deadline) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), Math.max(1, Math.min(options.timeoutMs ?? DEFAULT_TIMEOUT_MS, deadline.remaining())));
+    if (options.signal) {
+        if (options.signal.aborted)
+            controller.abort();
+        else
+            options.signal.addEventListener("abort", () => controller.abort(), { once: true });
+    }
+    return { signal: controller.signal, done: () => clearTimeout(timeout) };
+}
+async function sleep(ms, signal) {
+    await new Promise((resolvePromise, reject) => {
+        const timer = setTimeout(resolvePromise, ms);
+        if (signal) {
+            if (signal.aborted) {
+                clearTimeout(timer);
+                reject(new DOMException("Aborted", "AbortError"));
+                return;
+            }
+            signal.addEventListener("abort", () => {
+                clearTimeout(timer);
+                reject(new DOMException("Aborted", "AbortError"));
+            }, { once: true });
+        }
+    });
+}
+/**
+ * Backend proxy path. Returns `undefined` when the proxy is unavailable so
+ * the caller can fall back to direct OpenRouter — never for genuine
+ * generation failures (those return an error result).
+ */
+async function generateViaBackendProxy(model, options, backendUrl, machineJwt, prompt, frames) {
+    const base = backendUrl.replace(/\/$/, "");
+    const body = { model: model.id, prompt };
+    for (const key of PASSTHROUGH_KEYS) {
+        if (options[key] !== undefined)
+            body[key] = options[key];
+    }
+    // Backend contract: frameImages is [{ data?, mimeType?, path? }] with raw
+    // (non data-URI) base64 in `data`.
+    if (frames.length > 0) {
+        body.frameImages = frames.map((frame) => ({
+            data: frame.data,
+            mimeType: frame.mimeType,
+        }));
+    }
+    const start = Date.now();
+    const maxPollMs = options.maxPollMs ?? DEFAULT_MAX_POLL_MS;
+    const deadline = { remaining: () => maxPollMs - (Date.now() - start) };
+    const submit = makeSignal(options, deadline);
+    let videoId;
+    try {
+        const { response, json } = await fetchJson(`${base}/video/generation`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${machineJwt}`,
+                ...(options.headers ?? {}),
+            },
+            body: JSON.stringify(body),
+            signal: submit.signal,
+        });
+        if (!response.ok) {
+            const message = errorMessageFromJson(json, `Backend video generation failed: HTTP ${response.status}`);
+            // Fall back to direct OpenRouter only when the proxy itself is
+            // missing (bare 404/501/5xx without an upstream error body — e.g.
+            // an older backend without the video route). A structured error
+            // body means the proxy exists and the upstream rejected the
+            // request (e.g. OpenRouter workspace guardrails); surfacing that
+            // beats a fallback that would fail identically.
+            const hasUpstreamError = Boolean(json?.error?.message ?? json?.message);
+            if (isProxyUnavailableStatus(response.status) && !hasUpstreamError)
+                return undefined;
+            return errorResult(model, message, false);
+        }
+        videoId = typeof json?.videoId === "string" ? json.videoId : undefined;
+        if (!videoId)
+            return errorResult(model, "Backend video generation response had no videoId", false);
+    }
+    catch (error) {
+        // Connection errors (endpoint may not exist yet) → fall back.
+        return undefined;
+    }
+    finally {
+        submit.done();
+    }
+    // Poll until COMPLETED/FAILED.
+    for (;;) {
+        const remaining = deadline.remaining();
+        if (remaining <= 0) {
+            return errorResult(model, `Video generation timed out after ${maxPollMs / 1000}s (proxy)`, false);
+        }
+        const pollInterval = options.pollIntervalMs ?? PROXY_POLL_INTERVAL_MS;
+        await sleep(Math.min(pollInterval, remaining), options.signal).catch(() => null);
+        if (options.signal?.aborted)
+            return errorResult(model, "Video generation aborted", true);
+        // The sleep may have consumed the rest of the budget — fail with a
+        // clean timeout instead of issuing a request that aborts immediately.
+        if (deadline.remaining() <= 0) {
+            return errorResult(model, `Video generation timed out after ${maxPollMs / 1000}s (proxy)`, false);
+        }
+        const poll = makeSignal(options, deadline);
+        try {
+            const { response, json } = await fetchJson(`${base}/video/generation/${videoId}`, {
+                method: "GET",
+                headers: {
+                    Authorization: `Bearer ${machineJwt}`,
+                    ...(options.headers ?? {}),
+                },
+                signal: poll.signal,
+            });
+            if (!response.ok) {
+                if (isProxyUnavailableStatus(response.status))
+                    return undefined;
+                return errorResult(model, errorMessageFromJson(json, `Video polling failed: HTTP ${response.status}`), false);
+            }
+            const status = typeof json?.status === "string" ? json.status.toUpperCase() : "";
+            if (status === "COMPLETED") {
+                const url = typeof json?.url === "string" && json.url ? json.url : `/generated-videos/${videoId}`;
+                const output = [
+                    { type: "video", url, videoId, mimeType: VIDEO_MIME_TYPE },
+                ];
+                return {
+                    api: model.api,
+                    provider: model.provider,
+                    model: model.id,
+                    output,
+                    usage: usageFromCost(Number(json?.cost)),
+                    stopReason: "stop",
+                    responseId: videoId,
+                    timestamp: Date.now(),
+                };
+            }
+            if (status === "FAILED") {
+                return errorResult(model, json?.error ?? "Video generation failed (proxy)", false);
+            }
+            options.onProgress?.(`video ${videoId}: ${status || "PENDING"} (${Math.round((Date.now() - start) / 1000)}s)`);
+        }
+        catch (error) {
+            // Poll request failure (network) → fall back to direct.
+            return undefined;
+        }
+        finally {
+            poll.done();
+        }
+    }
+}
+/**
+ * Direct OpenRouter path: submit -> poll -> download. The download returns
+ * raw bytes (not base64), which are carried as base64 in the video block so
+ * the extension can save a local copy.
+ */
+async function generateDirect(model, options, apiKey, prompt, frames) {
+    const base = model.baseUrl.replace(/\/$/, "");
+    const body = { model: model.id, prompt };
+    for (const key of PASSTHROUGH_KEYS) {
+        if (options[key] !== undefined)
+            body[key] = options[key];
+    }
+    if (frames.length > 0) {
+        const frameImages = frames
+            .map((frame) => {
+            const url = imageSourceUrlForProvider(frame);
+            if (!url) {
+                options.onProgress?.("Skipping frame image without a resolvable url");
+                return null;
+            }
+            return { type: "image_url", image_url: { url } };
+        })
+            .filter((reference) => reference !== null);
+        if (frameImages.length > 0)
+            body.frame_images = frameImages;
+    }
+    const start = Date.now();
+    const maxPollMs = options.maxPollMs ?? DEFAULT_MAX_POLL_MS;
+    const deadline = { remaining: () => maxPollMs - (Date.now() - start) };
+    let videoId;
+    let pollingUrl;
+    try {
+        const submit = makeSignal(options, deadline);
+        try {
+            const { response, json } = await fetchJson(`${base}/videos`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${apiKey}`,
+                    "HTTP-Referer": "https://aexol.ai",
+                    "X-OpenRouter-Title": "Aexol.ai",
+                    "X-OpenRouter-Categories": "cli-agent",
+                    ...(options.headers ?? {}),
+                },
+                body: JSON.stringify(body),
+                signal: submit.signal,
+            });
+            options.onResponse?.({ status: response.status, headers: Object.fromEntries(response.headers.entries()) }, model);
+            if (!response.ok) {
+                return errorResult(model, errorMessageFromJson(json, `OpenRouter video generation failed: HTTP ${response.status}`), false);
+            }
+            videoId = typeof json?.id === "string" ? json.id : undefined;
+            pollingUrl = typeof json?.polling_url === "string" && json.polling_url ? json.polling_url : undefined;
+            if (!videoId && pollingUrl) {
+                // Best effort: recover the id from the polling url's last path segment.
+                const last = pollingUrl.replace(/\/$/, "").split("/").pop();
+                if (last)
+                    videoId = last;
+            }
+            if (!videoId) {
+                return errorResult(model, "OpenRouter video response had no id or polling_url", false);
+            }
+        }
+        finally {
+            submit.done();
+        }
+        // Poll every ~30s (OpenRouter guidance) until completed/failed.
+        for (;;) {
+            const remaining = deadline.remaining();
+            if (remaining <= 0) {
+                return errorResult(model, `Video generation timed out after ${maxPollMs / 1000}s`, false);
+            }
+            const pollInterval = options.pollIntervalMs ?? DIRECT_POLL_INTERVAL_MS;
+            await sleep(Math.min(pollInterval, remaining), options.signal).catch(() => null);
+            if (options.signal?.aborted)
+                return errorResult(model, "Video generation aborted", true);
+            // The sleep may have consumed the rest of the budget — fail with a
+            // clean timeout instead of issuing a request that aborts immediately.
+            if (deadline.remaining() <= 0) {
+                return errorResult(model, `Video generation timed out after ${maxPollMs / 1000}s`, false);
+            }
+            const poll = makeSignal(options, deadline);
+            try {
+                const { response, json } = await fetchJson(pollingUrl ?? `${base}/videos/${videoId}`, {
+                    method: "GET",
+                    headers: {
+                        Authorization: `Bearer ${apiKey}`,
+                        ...(options.headers ?? {}),
+                    },
+                    signal: poll.signal,
+                });
+                if (!response.ok) {
+                    return errorResult(model, errorMessageFromJson(json, `OpenRouter video polling failed: HTTP ${response.status}`), false);
+                }
+                const status = typeof json?.status === "string" ? json.status.toLowerCase() : "";
+                if (status === "completed" || status === "succeeded") {
+                    const cost = Number(json?.usage?.cost ?? json?.cost ?? 0) || 0;
+                    // Download the finished video: raw bytes WITH Authorization.
+                    const download = makeSignal(options, deadline);
+                    try {
+                        const downloadResponse = await fetch(`${base}/videos/${videoId}/content?index=0`, {
+                            method: "GET",
+                            headers: {
+                                Authorization: `Bearer ${apiKey}`,
+                                ...(options.headers ?? {}),
+                            },
+                            signal: download.signal,
+                        });
+                        if (!downloadResponse.ok) {
+                            return errorResult(model, `OpenRouter video download failed: HTTP ${downloadResponse.status}`, false);
+                        }
+                        const buffer = await downloadResponse.arrayBuffer();
+                        const mimeType = downloadResponse.headers.get("content-type")?.split(";")[0]?.trim() || VIDEO_MIME_TYPE;
+                        const output = [
+                            {
+                                type: "video",
+                                data: Buffer.from(buffer).toString("base64"),
+                                mimeType: mimeType.startsWith("video/") ? mimeType : VIDEO_MIME_TYPE,
+                            },
+                        ];
+                        return {
+                            api: model.api,
+                            provider: model.provider,
+                            model: model.id,
+                            output,
+                            usage: usageFromCost(cost),
+                            stopReason: "stop",
+                            responseId: videoId,
+                            timestamp: Date.now(),
+                        };
+                    }
+                    finally {
+                        download.done();
+                    }
+                }
+                if (status === "failed") {
+                    return errorResult(model, json?.error?.message ?? "OpenRouter video generation failed", false);
+                }
+                options.onProgress?.(`video ${videoId}: ${status || "pending"} (${Math.round((Date.now() - start) / 1000)}s)`);
+            }
+            finally {
+                poll.done();
+            }
+        }
+    }
+    catch (error) {
+        return errorResult(model, error instanceof Error ? error.message : String(error), Boolean(options.signal?.aborted));
+    }
+}
+export async function generateOpenRouterVideos(model, context, options = {}) {
+    const backendUrl = typeof options.backendUrl === "string" ? options.backendUrl : undefined;
+    const machineJwt = options.apiKey;
+    const routeThroughBackend = Boolean(backendUrl && machineJwt);
+    const localApiKey = !routeThroughBackend ? getEnvApiKey("openrouter") : undefined;
+    if (!routeThroughBackend && !localApiKey) {
+        throw new Error("Missing OPENROUTER_API_KEY for OpenRouter video generation (no backend routing configured)");
+    }
+    const prompt = textFromContext(context);
+    if (!prompt)
+        throw new Error("Video generation prompt is required");
+    const frames = framesFromContext(context);
+    if (routeThroughBackend) {
+        const viaProxy = await generateViaBackendProxy(model, options, backendUrl, machineJwt, prompt, frames);
+        if (viaProxy)
+            return viaProxy;
+    }
+    // Fallback (not routed, or the proxy was unavailable): direct OpenRouter
+    // requires a LOCAL OPENROUTER_API_KEY — the machine JWT must never be
+    // sent upstream.
+    const fallbackKey = localApiKey ?? getEnvApiKey("openrouter");
+    if (!fallbackKey) {
+        return errorResult(model, "Backend video proxy unavailable and no OPENROUTER_API_KEY configured for direct fallback", false);
+    }
+    return generateDirect(model, options, fallbackKey, prompt, frames);
+}

package/dist/sdk/ai/providers/register-builtins.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"register-builtins.d.ts","sourceRoot":"","sources":["../../../../src/sdk/ai/providers/register-builtins.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAMX,mBAAmB,EACnB,cAAc,EAEd,MAAM,aAAa,CAAC;AAErB,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AAwFxE,eAAO,MAAM,uBAAuB,gEAA0C,CAAC;AAC/E,eAAO,MAAM,6BAA6B,2DAAgD,CAAC;AAE3F;;;GAGG;AACH,wBAAgB,2BAA2B,IAAI,IAAI,CAUlD;AAED,wBAAgB,iBAAiB,IAAI,IAAI,CAGxC"}
+{"version":3,"file":"register-builtins.d.ts","sourceRoot":"","sources":["../../../../src/sdk/ai/providers/register-builtins.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAMX,mBAAmB,EACnB,cAAc,EAEd,MAAM,aAAa,CAAC;AAErB,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AAyFxE,eAAO,MAAM,uBAAuB,gEAA0C,CAAC;AAC/E,eAAO,MAAM,6BAA6B,2DAAgD,CAAC;AAE3F;;;GAGG;AACH,wBAAgB,2BAA2B,IAAI,IAAI,CAclD;AAED,wBAAgB,iBAAiB,IAAI,IAAI,CAGxC"}

package/dist/sdk/ai/providers/register-builtins.js

@@ -1,7 +1,9 @@
 import { clearApiProviders, registerApiProvider } from "../api-registry.js";
 import { registerImagesApiProvider } from "../images-api-registry.js";
+import { registerVideosApiProvider } from "../videos-api-registry.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { generateOpenRouterImages } from "./openrouter-images.js";
+import { generateOpenRouterVideos } from "./openrouter-videos.js";
 function createLazyErrorMessage(model, error) {
     return {
         role: "assistant",
@@ -79,6 +81,10 @@ export function registerBuiltInApiProviders() {
         api: "openrouter-images",
         generateImages: generateOpenRouterImages,
     });
+    registerVideosApiProvider({
+        api: "openrouter-videos",
+        generateVideos: generateOpenRouterVideos,
+    });
 }
 export function resetApiProviders() {
     clearApiProviders();

package/dist/sdk/ai/providers/simple-options.d.ts

@@ -1,8 +1,3 @@
-import type { Api, Model, SimpleStreamOptions, StreamOptions, ThinkingBudgets, ThinkingLevel } from "../types.js";
+import type { Api, Model, SimpleStreamOptions, StreamOptions } from "../types.js";
 export declare function buildBaseOptions(_model: Model<Api>, options?: SimpleStreamOptions, apiKey?: string): StreamOptions;
-export declare function clampReasoning(effort: ThinkingLevel | undefined): Exclude<ThinkingLevel, "xhigh"> | undefined;
-export declare function adjustMaxTokensForThinking(baseMaxTokens: number | undefined, modelMaxTokens: number, reasoningLevel: ThinkingLevel, customBudgets?: ThinkingBudgets): {
-    maxTokens: number;
-    thinkingBudget: number;
-};
 //# sourceMappingURL=simple-options.d.ts.map

package/dist/sdk/ai/providers/simple-options.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"simple-options.d.ts","sourceRoot":"","sources":["../../../../src/sdk/ai/providers/simple-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,mBAAmB,EAAE,aAAa,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAElH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC,EAAE,mBAAmB,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,aAAa,CAmBlH;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,aAAa,GAAG,SAAS,GAAG,OAAO,CAAC,aAAa,EAAE,OAAO,CAAC,GAAG,SAAS,CAE7G;AAED,wBAAgB,0BAA0B,CAEzC,aAAa,EAAE,MAAM,GAAG,SAAS,EACjC,cAAc,EAAE,MAAM,EACtB,cAAc,EAAE,aAAa,EAC7B,aAAa,CAAC,EAAE,eAAe,GAC7B;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,CAoB/C"}
+{"version":3,"file":"simple-options.d.ts","sourceRoot":"","sources":["../../../../src/sdk/ai/providers/simple-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAElF,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC,EAAE,mBAAmB,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,aAAa,CAmBlH"}

package/dist/sdk/ai/providers/simple-options.js

@@ -18,25 +18,3 @@ export function buildBaseOptions(_model, options, apiKey) {
         metadata: options?.metadata,
     };
 }
-export function clampReasoning(effort) {
-    return effort === "xhigh" ? "high" : effort;
-}
-export function adjustMaxTokensForThinking(
-// Undefined means no explicit caller cap. Use the model cap and fit thinking inside it.
-baseMaxTokens, modelMaxTokens, reasoningLevel, customBudgets) {
-    const defaultBudgets = {
-        minimal: 1024,
-        low: 2048,
-        medium: 8192,
-        high: 16384,
-    };
-    const budgets = { ...defaultBudgets, ...customBudgets };
-    const minOutputTokens = 1024;
-    const level = clampReasoning(reasoningLevel);
-    let thinkingBudget = budgets[level];
-    const maxTokens = baseMaxTokens === undefined ? modelMaxTokens : Math.min(baseMaxTokens + thinkingBudget, modelMaxTokens);
-    if (maxTokens <= thinkingBudget) {
-        thinkingBudget = Math.max(0, maxTokens - minOutputTokens);
-    }
-    return { maxTokens, thinkingBudget };
-}

package/dist/sdk/ai/providers/transform-messages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transform-messages.d.ts","sourceRoot":"","sources":["../../../../src/sdk/ai/providers/transform-messages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,GAAG,EACH,gBAAgB,EAEhB,OAAO,EACP,KAAK,EAIL,MAAM,aAAa,CAAC;AAqDrB;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,SAAS,GAAG,EACjD,QAAQ,EAAE,OAAO,EAAE,EACnB,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,EAClB,mBAAmB,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,gBAAgB,KAAK,MAAM,GACxF,OAAO,EAAE,CA2LX"}
+{"version":3,"file":"transform-messages.d.ts","sourceRoot":"","sources":["../../../../src/sdk/ai/providers/transform-messages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,GAAG,EACH,gBAAgB,EAEhB,OAAO,EACP,KAAK,EAKL,MAAM,aAAa,CAAC;AAgHrB;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,SAAS,GAAG,EACjD,QAAQ,EAAE,OAAO,EAAE,EACnB,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,EAClB,mBAAmB,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,gBAAgB,KAAK,MAAM,GACxF,OAAO,EAAE,CA8LX"}

package/dist/sdk/ai/providers/transform-messages.js

@@ -1,6 +1,8 @@
 const NON_VISION_USER_IMAGE_PLACEHOLDER = "(image omitted: model does not support images)";
 const NON_VISION_TOOL_IMAGE_PLACEHOLDER = "(tool image omitted: model does not support images)";
 const IMAGE_GENERATE_SUCCESS_TEXT = "Image generated successfully and shown to the user.";
+const VIDEO_USER_PLACEHOLDER = "(video omitted: models cannot process video)";
+const VIDEO_GENERATE_SUCCESS_TEXT = "Video generated successfully and shown to the user.";
 function replaceImagesWithPlaceholder(content, placeholder) {
     const result = [];
     let previousWasPlaceholder = false;
@@ -12,6 +14,10 @@ function replaceImagesWithPlaceholder(content, placeholder) {
             previousWasPlaceholder = true;
             continue;
         }
+        // Video parts are stripped unconditionally earlier (models cannot read
+        // video) — defensively skip any that slip through.
+        if (block.type === "video")
+            continue;
         result.push(block);
         previousWasPlaceholder = block.text === placeholder;
     }
@@ -40,6 +46,48 @@ function downgradeUnsupportedImages(messages, model) {
         return msg;
     });
 }
+function replaceVideosWithPlaceholder(content, placeholder) {
+    const result = [];
+    let previousWasPlaceholder = false;
+    for (const block of content) {
+        if (block.type === "video") {
+            if (!previousWasPlaceholder) {
+                result.push({ type: "text", text: placeholder });
+            }
+            previousWasPlaceholder = true;
+            continue;
+        }
+        result.push(block);
+        previousWasPlaceholder = block.type === "text" && block.text === placeholder;
+    }
+    return result;
+}
+/**
+ * UNCONDITIONAL video strip: models cannot read video, so video parts are
+ * NEVER sent to any model — for every model, not just non-vision ones.
+ * The raw block (hosted url or inline bytes) stays on the AgentToolResult for
+ * the UI; here it is replaced with a short text note.
+ */
+function stripVideoParts(messages) {
+    return messages.map((msg) => {
+        if (msg.role === "user" && Array.isArray(msg.content)) {
+            return {
+                ...msg,
+                content: replaceVideosWithPlaceholder(msg.content, VIDEO_USER_PLACEHOLDER),
+            };
+        }
+        if (msg.role === "toolResult") {
+            const replacementText = msg.toolName === "video_generate"
+                ? VIDEO_GENERATE_SUCCESS_TEXT
+                : VIDEO_USER_PLACEHOLDER;
+            return {
+                ...msg,
+                content: replaceVideosWithPlaceholder(msg.content, replacementText),
+            };
+        }
+        return msg;
+    });
+}
 /**
  * Normalize tool call ID for cross-provider compatibility.
  * OpenAI Responses API generates IDs that are 450+ chars with special characters like `|`.
@@ -48,7 +96,10 @@ function downgradeUnsupportedImages(messages, model) {
 export function transformMessages(messages, model, normalizeToolCallId) {
     // Build a map of original tool call IDs to normalized IDs
     const toolCallIdMap = new Map();
-    const imageAwareMessages = downgradeUnsupportedImages(messages, model);
+    // Video blocks are stripped for EVERY model (models cannot read video);
+    // images are downgraded only for models without vision support.
+    const videoAwareMessages = stripVideoParts(messages);
+    const imageAwareMessages = downgradeUnsupportedImages(videoAwareMessages, model);
     // First pass: transform messages (unsupported image downgrade, thinking blocks, tool call ID normalization)
     const transformed = imageAwareMessages.map((msg) => {
         // User messages pass through unchanged