@combycode/llm-sdk 1.6.1 → 1.7.0

package/CHANGELOG.md

@@ -6,6 +6,94 @@ All notable changes to `@combycode/llm-sdk` are documented here. The format foll
 
 ## [Unreleased]
 
+## [1.7.0] - 2026-07-16
+
+### Added
+- **Video extend + edit (xAI grok-imagine-video).** `VideoGenRequest` gains `sourceVideo?: DataSource`
+  and `params.videoMode?: 'extend' | 'edit'`. When a source video is present the xAI adapter routes to
+  the right endpoint instead of plain generation: `extend` (default) → `POST /v1/videos/extensions`
+  (continues from the last frame; takes `duration`, ignores aspect/resolution), `edit` →
+  `POST /v1/videos/edits` (prompt + video only). The clip is passed as a public URL, a Files-API id, or
+  an inline base64 data-URL. `MediaCapabilities` gains `videoExtension`; `MediaOutput.generateVideo`
+  throws if a `sourceVideo` is sent to a provider that doesn't support it (rather than silently
+  generating). `generateVideo(req)` is unchanged — the new fields flow through. Verified live end-to-end
+  on `grok-imagine-video`: generate → extend → edit all return video bytes. (Note: extend/edit require
+  `grok-imagine-video`, not `grok-imagine-video-1.5`, which is generation-only.)
+- **`onMediaProgress` hook.** Long-running async video ops (generate/extend/edit) now emit an
+  `onMediaProgress` event once per poll (`{ type, provider, operationId, progress, model }`), so a UI can
+  render a progress bar. Progress values confirmed live (0→100).
+- **`RawMediaResult.sourceUrl` + `MediaMeta.sourceUrl`.** Async video results now carry the provider's
+  hosted URL, so callers can render or re-submit the asset without holding the bytes.
+- **Unified reasoning visibility.** `ThinkingConfig` gains `visibility: 'full' (default) | 'summary' |
+  'hidden'`, mapping to Anthropic `enabled.display`, OpenAI Responses `summary`, and Google
+  `includeThoughts` — one knob for "how much reasoning comes back" across providers (best-effort; a
+  provider without a middle state degrades `summary` to full). Default `full` = prior behaviour.
+- **OpenAI reasoning execution mode.** `providerOptions.reasoningMode: 'standard' | 'pro'` maps to
+  `reasoning.mode` on the OpenAI **Responses** path (chat-completions rejects it). Kept in
+  `providerOptions` rather than a first-class knob since only one provider/API honours it.
+- **Google `translationConfig` passthrough.** `providerOptions.translationConfig` forwards to
+  `generationConfig.translationConfig` on generateContent (Gemini Developer API; live-verified 200).
+- **OpenAI native moderation blocking.** `providerOptions.moderationPolicy`
+  (`{ input?: { mode: 'score'|'block' }, output?: {…} }`) forwards to OpenAI's `moderation.policy` on
+  Responses + chat for server-side blocking. Unified moderation stays report-only by design (blocking is
+  `moderationGuardrail` at the agent layer); this is an OpenAI-specific opt-in, so it lives in
+  `providerOptions`. Live-verified the field is accepted.
+- **OpenAI explicit prompt caching.** `providerOptions.promptCacheOptions`
+  (`{ mode: 'implicit'|'explicit', ttl: '30m' }`) forwards to `prompt_cache_options` (gpt-5.6+),
+  true-OpenAI only (xai/openrouter inherit the builder and don't emit it). Note: OpenAI caches
+  **implicitly by default**, so the unified `cache` config already works there with no config — this
+  passthrough is for manual control. (`prompt_cache_retention` is deprecated upstream in favour of
+  `prompt_cache_options.ttl`.)
+- **OpenAI programmatic tool calling (Responses).** `BuiltinTool` gains `programmatic_tool_calling`, and
+  `FunctionTool` gains `allowedCallers?: ('direct'|'programmatic')[]` + `outputSchema?` — emitted on the
+  OpenAI Responses path only. Live-verified on gpt-5.6 (tool calls succeed; older models reject the
+  builtin, which is model-gated). (Surfacing the `program`/`program_output` output items is deferred; the
+  parser already tolerates them without error.)
+
+### Fixed
+- **OpenAI prompt-cache write tokens were dropped.** Both usage parsers hardcoded `cacheWriteTokens: 0`;
+  they now read `input_tokens_details.cache_write_tokens` (Responses) / `prompt_tokens_details.
+  cache_write_tokens` (chat), so cost accounting no longer under-reports explicit prompt caching.
+- **Google reasoning was live-broken (two paths).** generateContent sent `thinkingLevel`, which the
+  Gemini Developer API 400s on **2.5** models (it is 3.x-only) — now routed per series: 2.5 →
+  `thinkingBudget` (token count), 3.x → `thinkingLevel`. The Interactions path wrapped `thinking_config`
+  (rejected outright) and used uppercase values — it takes `thinking_level` **flat** on `generation_config`
+  and **lowercase** (`minimal/low/medium/high`). Both live-verified across gemini-2.5 + 3.5.
+- **Google Interactions rejected sampling penalties.** We emitted `presence_penalty`/`frequency_penalty`
+  on the Interactions path, which the API 400s ("Unknown parameter") — upstream removed them from its
+  Interactions config. No longer emitted there (still valid on generateContent).
+- **Streamed tool-call id collision on OpenAI-compatible backends.** The chat-completions stream parser
+  keyed tool-call fragments by `id ?? ''`, so parallel calls from backends that omit ids (LiteLLM/Bedrock,
+  some OpenRouter routes) merged into one. Fragments are now correlated by `index`, with a stable
+  `call_<uuid>` synthesized once per index when the backend omits ids.
+- **`content_filter` finish reason was flattened to `stop`/`length`.** The chat-completions stream reason
+  map lacked `content_filter`, `AgentLoop` derived every normal-completion finish as `stop`, and the
+  Responses parser mapped `status: 'incomplete'` to `length` regardless of `incomplete_details.reason` —
+  all discarding the provider's actual reason. Now the stream map, the loop, and the Responses parser
+  (reading `incomplete_details.reason`) all surface `content_filter` (and `length`) to consumers — so a
+  moderation/safety block is distinguishable from a token cap. (Our loop already terminates on non-tool
+  finishes, so it never retry-looped on an empty filtered turn.)
+- **Browser: xAI video result was unusable (CORS).** The generated clip lives on a cross-origin bucket
+  (`vidgen.x.ai`) that sends no `Access-Control-Allow-Origin`, so `downloadVideo`'s programmatic
+  byte-fetch was blocked in the browser and video generation failed outright. In the browser the adapter
+  now returns the hosted URL (via `sourceUrl`) with empty bytes instead of fetching — `<video src>` plays
+  it cross-origin without CORS, and it can be re-submitted as a `sourceVideo`. Node/Bun still download the
+  bytes. (Node-only tests couldn't surface this; CORS isn't enforced off-browser.)
+- **Google `editImage` aspect ratio / size (same bug, second code path).** The 1.6.1 fix moved
+  `aspectRatio` / `imageSize` to `generationConfig.imageConfig` only in `generateImage`; the sibling
+  `editImage` method still wrote `generationConfig.responseFormat.image` and so 400'd on any edit that
+  passed an aspect ratio or size. Now both image paths use `imageConfig`. Verified live end-to-end:
+  generate → edit round-trip both return an image at `16:9` / `2K`. Locked with a unit regression on the
+  `editImage` request body.
+- **xAI video generation polled forever after the job finished.** `getVideoStatus` only treated
+  `status: "completed"`/`"ready"` (or a `download_url`) as done, but xAI reports terminal success as
+  `status: "done"` with the URL under `video.url` — so a finished job kept polling until the wait cap and
+  never returned. `downloadVideo` likewise read `download_url`/`url` and missed `video.url` (and duration
+  under `video.duration`). Both now read the real `video.*` shape (flat fallbacks kept), and terminal
+  `status: "done"`/`"expired"` are handled. Progress is now carried on the processing status. Verified
+  live end-to-end (grok-imagine-video-1.5 image-to-video: progress 0→75→100 → downloaded 2.5 MB); locked
+  with a unit test replaying the real server payload.
+
 ## [1.6.1] - 2026-07-13
 
 ### Fixed

package/dist/bus/hook-map.d.ts

@@ -467,6 +467,16 @@ export interface MediaErrorContext {
     /** For async ops (video). */
     operationId?: string;
 }
+/** Progress ping for a long-running async media op (video generation/extend/
+ *  edit) — emitted once per poll while the job runs, so a UI can show a bar. */
+export interface MediaProgressContext {
+    type: 'video';
+    provider: string;
+    operationId: string;
+    /** 0–100 when the provider reports it; omitted otherwise. */
+    progress?: number;
+    model?: string;
+}
 export interface ServerRequestContext {
     serverId: string;
     requestId: string;
@@ -581,6 +591,7 @@ export interface HookMap {
     onContextMeasure: ContextMeasureContext;
     onMediaGenerated: MediaGeneratedContext;
     onMediaError: MediaErrorContext;
+    onMediaProgress: MediaProgressContext;
     onInternalToolCallStart: InternalToolCallStartContext;
     onInternalToolCallComplete: InternalToolCallCompleteContext;
     onInternalToolCallError: InternalToolCallErrorContext;

package/dist/index.browser.js

@@ -23491,7 +23491,8 @@ var catalog_default5 = {
       video: false,
       imageGeneration: false,
       audioGeneration: false,
-      videoGeneration: true
+      videoGeneration: true,
+      videoExtension: true
     },
     reasoning: {
       supported: false,
@@ -25174,7 +25175,9 @@ var AnthropicAdapter = class {
       if (req.thinking.mode === "off") {
       } else {
         const budget = req.thinking.effort ? ANTHROPIC_THINKING_BUDGETS[req.thinking.effort] ?? DEFAULT_ANTHROPIC_THINKING_BUDGET : DEFAULT_ANTHROPIC_THINKING_BUDGET;
-        body.thinking = { type: "enabled", budget_tokens: budget };
+        const thinking = { type: "enabled", budget_tokens: budget };
+        if (req.thinking.visibility === "hidden") thinking.display = "omitted";
+        body.thinking = thinking;
         if (body.max_tokens <= budget) body.max_tokens = budget + 1024;
       }
     }
@@ -25691,6 +25694,21 @@ var GOOGLE_THINKING_LEVELS = {
   high: "HIGH",
   max: "HIGH"
 };
+var GOOGLE_THINKING_BUDGETS = {
+  low: 2048,
+  medium: 8192,
+  high: 16384,
+  max: 24576
+};
+function googleUsesThinkingBudget(model) {
+  return /gemini-2\.5/.test(model);
+}
+var GOOGLE_INTERACTION_THINKING_LEVELS = {
+  low: "low",
+  medium: "medium",
+  high: "high",
+  max: "high"
+};
 
 // src/llm/providers/google/generate.ts
 var GoogleAdapter = class {
@@ -25771,9 +25789,16 @@ var GoogleAdapter = class {
       body.toolConfig = { functionCallingConfig: { mode } };
     }
     if (req.thinking && req.thinking.mode !== "off") {
-      config.thinkingConfig = {
-        thinkingLevel: GOOGLE_THINKING_LEVELS[req.thinking.effort ?? "high"] ?? "HIGH"
+      const effort = req.thinking.effort ?? "high";
+      const thinkingConfig = {
+        includeThoughts: req.thinking.visibility !== "hidden"
       };
+      if (googleUsesThinkingBudget(req.model)) {
+        thinkingConfig.thinkingBudget = GOOGLE_THINKING_BUDGETS[effort] ?? GOOGLE_THINKING_BUDGETS.high;
+      } else {
+        thinkingConfig.thinkingLevel = GOOGLE_THINKING_LEVELS[effort] ?? "HIGH";
+      }
+      config.thinkingConfig = thinkingConfig;
     }
     if (req.structured) {
       config.responseMimeType = "application/json";
@@ -25789,6 +25814,9 @@ var GoogleAdapter = class {
       if (req.providerOptions.imageConfig) {
         config.imageConfig = req.providerOptions.imageConfig;
       }
+      if (req.providerOptions.translationConfig) {
+        config.translationConfig = req.providerOptions.translationConfig;
+      }
     }
     return {
       body,
@@ -26139,8 +26167,6 @@ var GoogleInteractionsAdapter = class {
     if (req.maxTokens) genConfig.max_output_tokens = req.maxTokens;
     if (req.temperature !== void 0) genConfig.temperature = req.temperature;
     if (req.topP !== void 0) genConfig.top_p = req.topP;
-    if (req.presencePenalty !== void 0) genConfig.presence_penalty = req.presencePenalty;
-    if (req.frequencyPenalty !== void 0) genConfig.frequency_penalty = req.frequencyPenalty;
     if (req.stop) genConfig.stop_sequences = req.stop;
     if (req.tools?.length) {
       body.tools = req.tools.filter(isFunctionTool).map((t) => ({
@@ -26151,9 +26177,7 @@ var GoogleInteractionsAdapter = class {
       }));
     }
     if (req.thinking && req.thinking.mode !== "off") {
-      genConfig.thinking_config = {
-        thinking_level: GOOGLE_THINKING_LEVELS[req.thinking.effort ?? "high"] ?? "HIGH"
-      };
+      genConfig.thinking_level = GOOGLE_INTERACTION_THINKING_LEVELS[req.thinking.effort ?? "high"] ?? "high";
     }
     if (Object.keys(genConfig).length > 0) body.generation_config = genConfig;
     const cachedContent = req.providerOptions?.cachedContent;
@@ -26456,6 +26480,24 @@ function openaiImageRef(ref) {
 function xaiImageRef(ref) {
   return ref.fileId ? { file_id: ref.fileId } : { url: toDataUrl(ref) };
 }
+function xaiVideoRef(src) {
+  switch (src.type) {
+    case "url":
+      return { url: src.url };
+    case "file":
+      return { file_id: src.fileId };
+    case "provider_ref":
+      return { file_id: src.refId };
+    case "base64":
+      return { url: `data:${src.mimeType};base64,${src.data}` };
+    case "buffer":
+      return { url: `data:${src.mimeType};base64,${bytesToBase64(src.data)}` };
+    case "path":
+      throw new Error(
+        "media source video: `path` DataSource is not supported here \u2014 read the file and pass base64/buffer."
+      );
+  }
+}
 function googleImagePart(ref) {
   const mimeType = ref.mimeType ?? "image/png";
   if (ref.base64) return { inline_data: { mime_type: mimeType, data: ref.base64 } };
@@ -26606,7 +26648,7 @@ var GoogleMediaAdapter = class {
     const image = {};
     if (req.params?.aspectRatio) image.aspectRatio = req.params.aspectRatio;
     if (req.params?.imageSize) image.imageSize = req.params.imageSize;
-    if (Object.keys(image).length) generationConfig.responseFormat = { image };
+    if (Object.keys(image).length) generationConfig.imageConfig = image;
     const imagePart = googleImagePart(normalizeImageSource(req.sourceImage));
     const { items, usage } = await this.generateContentMedia(
       model,
@@ -27010,8 +27052,10 @@ var OpenAIBatchAdapter = class {
 };
 
 // src/llm/moderation/native.ts
-function buildNativeModeration(mod) {
-  return { model: mod.model ?? MODERATION_DEFAULT_MODEL };
+function buildNativeModeration(mod, policy) {
+  const out = { model: mod?.model ?? MODERATION_DEFAULT_MODEL };
+  if (policy && typeof policy === "object") out.policy = policy;
+  return out;
 }
 function parseNativeModeration(raw) {
   if (!raw || typeof raw !== "object") return void 0;
@@ -27121,8 +27165,12 @@ var OpenAIAdapter = class {
     if (req.stop) body.stop = req.stop;
     const tier = openaiRequestTier(req.serviceTier);
     if (tier) body.service_tier = tier;
-    if (req.moderation && req.moderation.mode !== "emulate") {
-      body.moderation = buildNativeModeration(req.moderation);
+    const modPolicy = req.providerOptions?.moderationPolicy;
+    if (req.moderation && req.moderation.mode !== "emulate" || modPolicy) {
+      body.moderation = buildNativeModeration(req.moderation, modPolicy);
+    }
+    if (this.name === "openai" && req.providerOptions?.promptCacheOptions) {
+      body.prompt_cache_options = req.providerOptions.promptCacheOptions;
     }
     const hasAudioInput = req.messages.some(
       (m) => Array.isArray(m.content) && m.content.some((p) => p.type === "audio")
@@ -27298,7 +27346,7 @@ var OpenAIAdapter = class {
       raw
     };
   }
-  parseStreamEvent(event) {
+  parseStreamEvent(event, state) {
     const data = JSON.parse(event.data);
     if (data.moderation) {
       const report = parseNativeModeration(data.moderation);
@@ -27324,29 +27372,32 @@ var OpenAIAdapter = class {
     if (delta.content) {
       events.push({ type: "text", text: delta.content });
     }
+    const toolIdByIndex = state?.toolIdByIndex ?? /* @__PURE__ */ new Map();
     const toolCalls = delta.tool_calls ?? [];
     for (const tc of toolCalls) {
+      const index = tc.index ?? 0;
+      let id = toolIdByIndex.get(index);
+      if (id === void 0) {
+        id = tc.id || `call_${crypto.randomUUID()}`;
+        toolIdByIndex.set(index, id);
+      }
       const fn = tc.function;
       if (fn?.name) {
-        events.push({
-          type: "tool_call_start",
-          id: tc.id ?? "",
-          name: fn.name
-        });
+        events.push({ type: "tool_call_start", id, name: fn.name });
       }
       if (fn?.arguments) {
-        events.push({
-          type: "tool_call_delta",
-          id: tc.id ?? "",
-          arguments: fn.arguments
-        });
+        events.push({ type: "tool_call_delta", id, arguments: fn.arguments });
       }
     }
     const fr = choice.finish_reason;
     if (fr) {
       events.push({
         type: "done",
-        finishReason: extractFinishReason(false, fr, { tool_calls: "tool_use", length: "length" })
+        finishReason: extractFinishReason(false, fr, {
+          tool_calls: "tool_use",
+          length: "length",
+          content_filter: "content_filter"
+        })
       });
     }
     if (data.usage) {
@@ -27354,9 +27405,11 @@ var OpenAIAdapter = class {
     }
     return events;
   }
-  /** Stateless — Chat Completions has no hosted code-execution file outputs. */
+  /** Per-stream: correlates streamed tool-call fragments by index and synthesizes
+   *  a stable id for backends that omit tool-call ids (see `parseStreamEvent`). */
   createStreamParser() {
-    return (event) => this.parseStreamEvent(event);
+    const state = { toolIdByIndex: /* @__PURE__ */ new Map() };
+    return (event) => this.parseStreamEvent(event, state);
   }
   parseUsage(u) {
     if (!u) return emptyUsage();
@@ -27369,7 +27422,7 @@ var OpenAIAdapter = class {
       outputTokens: output,
       totalTokens: input + output,
       cachedTokens: details.cached_tokens ?? 0,
-      cacheWriteTokens: 0,
+      cacheWriteTokens: details.cache_write_tokens ?? 0,
       reasoningTokens: outDetails.reasoning_tokens ?? 0
     };
   }
@@ -28015,8 +28068,12 @@ var OpenAIResponsesAdapter = class {
     if (req.topP !== void 0) body.top_p = req.topP;
     const tier = openaiRequestTier(req.serviceTier);
     if (tier) body.service_tier = tier;
-    if (req.moderation && req.moderation.mode !== "emulate") {
-      body.moderation = buildNativeModeration(req.moderation);
+    const modPolicy = req.providerOptions?.moderationPolicy;
+    if (req.moderation && req.moderation.mode !== "emulate" || modPolicy) {
+      body.moderation = buildNativeModeration(req.moderation, modPolicy);
+    }
+    if (this.name === "openai" && req.providerOptions?.promptCacheOptions) {
+      body.prompt_cache_options = req.providerOptions.promptCacheOptions;
     }
     if (req.tools?.length) {
       body.tools = req.tools.map((t) => {
@@ -28026,7 +28083,10 @@ var OpenAIResponsesAdapter = class {
             name: t.name,
             description: t.description,
             parameters: ensureAdditionalProperties(t.parameters),
-            strict: t.strict ?? true
+            strict: t.strict ?? true,
+            // Programmatic tool calling (Responses): who may call it + return schema.
+            ...t.allowedCallers ? { allowed_callers: t.allowedCallers } : {},
+            ...t.outputSchema ? { output_schema: t.outputSchema } : {}
           };
         }
         const builtin = { type: t.type, ...t.params };
@@ -28054,9 +28114,13 @@ var OpenAIResponsesAdapter = class {
       };
     }
     if (req.thinking && req.thinking.mode !== "off") {
+      const visibility = req.thinking.visibility ?? "full";
+      const summary = visibility === "hidden" ? null : visibility === "summary" ? "concise" : "auto";
+      const mode = req.providerOptions?.reasoningMode;
       body.reasoning = {
         effort: req.thinking.effort ?? "medium",
-        summary: "auto",
+        ...summary !== null ? { summary } : {},
+        ...mode ? { mode } : {},
         // Cross-turn reasoning persistence (gpt-5/o-series, Responses only).
         ...req.thinking.context ? { context: req.thinking.context } : {}
       };
@@ -28200,9 +28264,8 @@ var OpenAIResponsesAdapter = class {
       }
     }
     const status = r.status;
-    const finishReason = extractFinishReason(toolCalls.length > 0, status, {
-      incomplete: "length"
-    });
+    const incompleteReason = r.incomplete_details?.reason;
+    const finishReason = incompleteReason === "content_filter" ? "content_filter" : extractFinishReason(toolCalls.length > 0, status, { incomplete: "length" });
     if (!text && typeof r.output_text === "string") {
       text = r.output_text;
       if (text && content.length === 0) content.push({ type: "text", text });
@@ -28322,7 +28385,7 @@ var OpenAIResponsesAdapter = class {
       outputTokens: output,
       totalTokens: u.total_tokens ?? input + output,
       cachedTokens: inputDetails.cached_tokens ?? 0,
-      cacheWriteTokens: 0,
+      cacheWriteTokens: inputDetails.cache_write_tokens ?? 0,
       reasoningTokens: outputDetails.reasoning_tokens ?? 0
     };
   }
@@ -28412,8 +28475,9 @@ var OpenRouterAdapter = class extends OpenAIAdapter {
    *  `url_citation` annotations appear in the stream (the `:online` search signal). */
   createStreamParser() {
     let webSearchEmitted = false;
+    const state = { toolIdByIndex: /* @__PURE__ */ new Map() };
     return (event) => {
-      const events = this.parseStreamEvent(event);
+      const events = this.parseStreamEvent(event, state);
       if (!webSearchEmitted) {
         const choice = JSON.parse(event.data).choices?.[0];
         const annotations = choice?.delta?.annotations ?? choice?.message?.annotations;
@@ -28584,8 +28648,8 @@ var XAIAdapter = class extends OpenAIAdapter {
     }
     return result;
   }
-  parseStreamEvent(event) {
-    const events = super.parseStreamEvent(event);
+  parseStreamEvent(event, state) {
+    const events = super.parseStreamEvent(event, state);
     try {
       const data = JSON.parse(event.data);
       const choices = data.choices ?? [];
@@ -28708,7 +28772,8 @@ var XAIMediaAdapter = class {
       imageEditing: true,
       audioGeneration: true,
       videoGeneration: true,
-      audioStreaming: true
+      audioStreaming: true,
+      videoExtension: true
     };
   }
   authHeaders() {
@@ -28822,13 +28887,9 @@ var XAIMediaAdapter = class {
   }
   async submitVideo(req, fetch2) {
     const model = req.model ?? "grok-imagine-video";
-    const body = { model, prompt: req.prompt };
-    if (req.params?.duration) body.duration = req.params.duration;
-    if (req.params?.aspectRatio) body.aspect_ratio = req.params.aspectRatio;
-    if (req.params?.resolution) body.resolution = req.params.resolution;
-    if (req.sourceImage) body.image = xaiImageRef(normalizeImageSource(req.sourceImage));
+    const { url, body } = this.buildVideoSubmit(req, model);
     const res = await fetch2({
-      url: `${this.baseURL}/v1/videos/generations`,
+      url,
       method: "POST",
       headers: this.authHeaders(),
       body,
@@ -28839,6 +28900,30 @@ var XAIMediaAdapter = class {
     const data = res.body;
     return data.request_id ?? data.id ?? "";
   }
+  /** Route a video request to the right xAI endpoint by input + mode:
+   *   - no `sourceVideo` → `/v1/videos/generations` (text/image-to-video)
+   *   - `sourceVideo` + `videoMode:'extend'` (default) → `/v1/videos/extensions`
+   *     — continues from the last frame; takes `duration`, NOT aspect/resolution.
+   *   - `sourceVideo` + `videoMode:'edit'` → `/v1/videos/edits` — prompt + video
+   *     only (no duration/aspect/resolution).
+   *  All three return a `request_id` polled via the same status endpoint. */
+  buildVideoSubmit(req, model) {
+    if (req.sourceVideo) {
+      const video = xaiVideoRef(req.sourceVideo);
+      if ((req.params?.videoMode ?? "extend") === "edit") {
+        return { url: `${this.baseURL}/v1/videos/edits`, body: { model, prompt: req.prompt, video } };
+      }
+      const body2 = { model, prompt: req.prompt, video };
+      if (req.params?.duration) body2.duration = req.params.duration;
+      return { url: `${this.baseURL}/v1/videos/extensions`, body: body2 };
+    }
+    const body = { model, prompt: req.prompt };
+    if (req.params?.duration) body.duration = req.params.duration;
+    if (req.params?.aspectRatio) body.aspect_ratio = req.params.aspectRatio;
+    if (req.params?.resolution) body.resolution = req.params.resolution;
+    if (req.sourceImage) body.image = xaiImageRef(normalizeImageSource(req.sourceImage));
+    return { url: `${this.baseURL}/v1/videos/generations`, body };
+  }
   async getVideoStatus(operationId, fetch2) {
     const res = await fetch2({
       url: `${this.baseURL}/v1/videos/${operationId}`,
@@ -28852,13 +28937,15 @@ var XAIMediaAdapter = class {
     if (res.status >= 400) return { status: "failed", error: `HTTP ${res.status}` };
     const data = res.body;
     const state = data.status ?? "";
-    if (state === "completed" || state === "ready" || data.download_url) {
-      return { status: "completed" };
+    const video = data.video;
+    const progress = data.progress;
+    if (state === "done" || state === "completed" || state === "ready" || video?.url || data.download_url) {
+      return { status: "completed", progress };
     }
-    if (state === "failed" || state === "error") {
+    if (state === "failed" || state === "error" || state === "expired") {
       return { status: "failed", error: data.error ?? "Unknown error" };
     }
-    return { status: "processing", progress: data.progress };
+    return { status: "processing", progress };
   }
   async downloadVideo(operationId, fetch2) {
     const statusRes = await fetch2({
@@ -28874,8 +28961,19 @@ var XAIMediaAdapter = class {
       throw new Error(`xAI video download failed: HTTP ${statusRes.status}`);
     }
     const data = statusRes.body;
-    const downloadUrl = data.download_url ?? data.url;
+    const video = data.video;
+    const downloadUrl = video?.url ?? data.download_url ?? data.url;
     if (!downloadUrl) throw new Error("No download URL in video response");
+    const durationSec = video?.duration ?? data.duration;
+    const base = {
+      data: new Uint8Array(0),
+      mimeType: "video/mp4",
+      sourceUrl: downloadUrl,
+      durationMs: durationSec ? durationSec * 1e3 : void 0,
+      // Provider-reported cost (usage.cost_in_usd_ticks), when present.
+      providerMeta: data.usage ? { usage: data.usage } : void 0
+    };
+    if (isBrowser()) return base;
     const videoRes = await fetch2({
       url: downloadUrl,
       method: "GET",
@@ -28885,13 +28983,7 @@ var XAIMediaAdapter = class {
       model: "",
       responseType: "arraybuffer"
     });
-    return {
-      data: videoRes.body,
-      mimeType: "video/mp4",
-      durationMs: data.duration ? data.duration * 1e3 : void 0,
-      // Provider-reported cost (usage.cost_in_usd_ticks), when present.
-      providerMeta: data.usage ? { usage: data.usage } : void 0
-    };
+    return { ...base, data: videoRes.body };
   }
   async cancelVideo(operationId, fetch2) {
     await fetch2({
@@ -30304,7 +30396,11 @@ var AgentLoop = class _AgentLoop {
       id: lastResponse?.id ?? `agent-${runId}`,
       model: this.client.model,
       content: finalContent,
-      finishReason: reason === "done" ? "stop" : reason === "stopped" ? "stop" : reason === "guardrail" ? "stop" : reason === "max_steps" ? "length" : "error",
+      finishReason: reason === "done" ? (
+        // Ended because the model requested no tools — surface the provider's
+        // actual reason (stop / content_filter / length), not a flat 'stop'.
+        lastResponse?.finishReason ?? "stop"
+      ) : reason === "stopped" ? "stop" : reason === "guardrail" ? "stop" : reason === "max_steps" ? "length" : "error",
       usage: totalUsage,
       text: finalText,
       toolCalls: lastResponse?.toolCalls ?? [],
@@ -30513,7 +30609,11 @@ var AgentLoop = class _AgentLoop {
       id: lastResponse?.id ?? `agent-${runId}`,
       model: this.client.model,
       content: finalContent,
-      finishReason: reason === "done" ? "stop" : reason === "stopped" ? "stop" : reason === "guardrail" ? "stop" : reason === "max_steps" ? "length" : "error",
+      finishReason: reason === "done" ? (
+        // Ended because the model requested no tools — surface the provider's
+        // actual reason (stop / content_filter / length), not a flat 'stop'.
+        lastResponse?.finishReason ?? "stop"
+      ) : reason === "stopped" ? "stop" : reason === "guardrail" ? "stop" : reason === "max_steps" ? "length" : "error",
       usage: totalUsage,
       text: finalText,
       toolCalls: lastResponse?.toolCalls ?? [],
@@ -34838,9 +34938,13 @@ var MediaOutput = class {
   }
   async generateVideo(req) {
     const adapter = this.getAdapter(req.provider);
-    if (!adapter.capabilities().videoGeneration || !adapter.submitVideo) {
+    const caps = adapter.capabilities();
+    if (!caps.videoGeneration || !adapter.submitVideo) {
       throw new Error(`Provider ${req.provider} does not support video generation`);
     }
+    if (req.sourceVideo && !caps.videoExtension) {
+      throw new Error(`Provider ${req.provider} does not support video extension/editing`);
+    }
     const { trace, fetch: fetch2 } = this.tracedOp();
     const operationId = await adapter.submitVideo(req, fetch2);
     return this.pollVideoCompletion(adapter, operationId, req, fetch2, trace);
@@ -34873,7 +34977,8 @@ var MediaOutput = class {
         width: raw.width,
         height: raw.height,
         durationMs: raw.durationMs,
-        sampleRate: raw.sampleRate
+        sampleRate: raw.sampleRate,
+        sourceUrl: raw.sourceUrl
       };
       await this.mediaStore.save(id, raw.data, meta);
       results.push({ id, type, mimeType: raw.mimeType, meta });
@@ -34906,6 +35011,15 @@ var MediaOutput = class {
     const start = Date.now();
     while (Date.now() - start < this.maxPollWaitMs) {
       const status = await adapter.getVideoStatus(operationId, fetch2);
+      if (status.status === "processing" || status.status === "pending") {
+        await this.hooks.emit("onMediaProgress", {
+          type: "video",
+          provider: req.provider,
+          operationId,
+          progress: status.progress,
+          model: req.model
+        });
+      }
       if (status.status === "completed") {
         const raw = await adapter.downloadVideo(operationId, fetch2);
         const results = await this.saveResults(