@combycode/llm-sdk 1.6.1 → 1.7.0

package/dist/index.js

@@ -23418,7 +23418,8 @@ var catalog_default5 = {
       video: false,
       imageGeneration: false,
       audioGeneration: false,
-      videoGeneration: true
+      videoGeneration: true,
+      videoExtension: true
     },
     reasoning: {
       supported: false,
@@ -25101,7 +25102,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;
       }
     }
@@ -25618,6 +25621,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 {
@@ -25698,9 +25716,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";
@@ -25716,6 +25741,9 @@ var GoogleAdapter = class {
       if (req.providerOptions.imageConfig) {
         config.imageConfig = req.providerOptions.imageConfig;
       }
+      if (req.providerOptions.translationConfig) {
+        config.translationConfig = req.providerOptions.translationConfig;
+      }
     }
     return {
       body,
@@ -26066,8 +26094,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) => ({
@@ -26078,9 +26104,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;
@@ -26383,6 +26407,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 } };
@@ -26533,7 +26575,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,
@@ -26937,8 +26979,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;
@@ -27048,8 +27092,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")
@@ -27225,7 +27273,7 @@ var OpenAIAdapter = class {
       raw
     };
   }
-  parseStreamEvent(event) {
+  parseStreamEvent(event, state) {
     const data = JSON.parse(event.data);
     if (data.moderation) {
       const report = parseNativeModeration(data.moderation);
@@ -27251,29 +27299,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) {
@@ -27281,9 +27332,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();
@@ -27296,7 +27349,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
     };
   }
@@ -27942,8 +27995,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) => {
@@ -27953,7 +28010,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 };
@@ -27981,9 +28041,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 } : {}
       };
@@ -28127,9 +28191,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 });
@@ -28249,7 +28312,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
     };
   }
@@ -28339,8 +28402,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;
@@ -28511,8 +28575,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 ?? [];
@@ -28635,7 +28699,8 @@ var XAIMediaAdapter = class {
       imageEditing: true,
       audioGeneration: true,
       videoGeneration: true,
-      audioStreaming: true
+      audioStreaming: true,
+      videoExtension: true
     };
   }
   authHeaders() {
@@ -28749,13 +28814,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,
@@ -28766,6 +28827,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}`,
@@ -28779,13 +28864,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({
@@ -28801,8 +28888,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",
@@ -28812,13 +28910,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({
@@ -30231,7 +30323,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 ?? [],
@@ -30440,7 +30536,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 ?? [],
@@ -34765,9 +34865,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);
@@ -34800,7 +34904,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 });
@@ -34833,6 +34938,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(

package/dist/llm/moderation/native.d.ts

@@ -9,10 +9,11 @@
  *    - Chat Completions:   moderation.{input,output} = moderation_results | error,
  *                          where moderation_results wraps `results: [moderation_result]`. */
 import type { ModerationReport, ModerationRequest } from './types';
-/** The `moderation` request field for the OpenAI native path. */
-export declare function buildNativeModeration(mod: ModerationRequest): {
-    model: string;
-};
+/** The `moderation` request field for the OpenAI native path. `policy` is an
+ *  OpenAI-only opt-in (via `providerOptions.moderationPolicy`) for server-side
+ *  BLOCKING — `{ input?: { mode: 'score'|'block' }, output?: {...} }`; our unified
+ *  moderation stays report-only, so it's a passthrough, not a first-class knob. */
+export declare function buildNativeModeration(mod?: ModerationRequest, policy?: unknown): Record<string, unknown>;
 /** Parse OpenAI's returned `moderation` object into a unified report, or undefined
  *  when the server returned nothing usable. */
 export declare function parseNativeModeration(raw: unknown): ModerationReport | undefined;

package/dist/llm/providers/google/constants.d.ts

@@ -1,6 +1,21 @@
 /** Google provider constants. */
 /**
- * Map from unified thinking effort levels to Gemini thinkingLevel enum strings.
- * Used in both generate.ts and interactions.ts.
+ * Map from unified thinking effort levels to Gemini `thinkingLevel` enum strings.
+ * `thinkingLevel` is the Gemini 3.x thinking control (LOW/HIGH).
  */
 export declare const GOOGLE_THINKING_LEVELS: Record<string, string>;
+/**
+ * Map from unified thinking effort to a Gemini `thinkingBudget` (token count).
+ * Gemini **2.5** models only accept a token budget — they 400 on `thinkingLevel`
+ * ("Thinking level is not supported for this model", live-verified 2026-07-16).
+ * Values sit inside the 2.5 range (flash/flash-lite cap ~24576, pro ~32768).
+ */
+export declare const GOOGLE_THINKING_BUDGETS: Record<string, number>;
+/** Gemini 2.5 series uses `thinkingBudget`; 3.x+ uses `thinkingLevel`. */
+export declare function googleUsesThinkingBudget(model: string): boolean;
+/**
+ * Effort → Interactions `thinking_level`. The Interactions API uses **lowercase**
+ * values (`minimal`/`low`/`medium`/`high`) — distinct from generateContent's
+ * uppercase `thinkingLevel`, and it 400s on the uppercase form (live 2026-07-16).
+ */
+export declare const GOOGLE_INTERACTION_THINKING_LEVELS: Record<string, string>;

package/dist/llm/providers/openai/completions.d.ts

@@ -8,6 +8,12 @@ export interface OpenAIAdapterConfig {
     apiKey: string;
     baseURL?: string;
 }
+/** Per-stream state threaded through `createStreamParser` — maps a streamed
+ *  tool call's `index` to its resolved id (real, or a synthesized `call_<uuid>`
+ *  for backends that omit ids), stable across the stream's chunks. */
+export interface OpenAIStreamState {
+    toolIdByIndex: Map<number, string>;
+}
 export declare class OpenAIAdapter implements ProviderAdapter {
     readonly name: ProviderAdapter['name'];
     protected readonly apiKey: string;
@@ -20,8 +26,9 @@ export declare class OpenAIAdapter implements ProviderAdapter {
     private buildMessage;
     enableStreaming(providerReq: ProviderHttpRequest, _req: NormalizedRequest): void;
     parseResponse(raw: unknown, latencyMs: number): CompletionResponse;
-    parseStreamEvent(event: SSEEvent): StreamEvent[];
-    /** Stateless — Chat Completions has no hosted code-execution file outputs. */
+    parseStreamEvent(event: SSEEvent, state?: OpenAIStreamState): StreamEvent[];
+    /** Per-stream: correlates streamed tool-call fragments by index and synthesizes
+     *  a stable id for backends that omit tool-call ids (see `parseStreamEvent`). */
     createStreamParser(): (event: SSEEvent) => StreamEvent[];
     private parseUsage;
 }

package/dist/llm/providers/xai/completions.d.ts

@@ -9,7 +9,7 @@ import type { ProviderAdapter, ProviderHttpRequest } from '../../types/provider'
 import type { NormalizedRequest } from '../../types/request';
 import type { CompletionResponse } from '../../types/response';
 import type { StreamEvent } from '../../types/stream';
-import { OpenAIAdapter } from '../openai/completions';
+import { OpenAIAdapter, type OpenAIStreamState } from '../openai/completions';
 export interface XAIAdapterConfig {
     apiKey: string;
     baseURL?: string;
@@ -20,5 +20,5 @@ export declare class XAIAdapter extends OpenAIAdapter {
     baseURL(): string;
     buildRequest(req: NormalizedRequest): ProviderHttpRequest;
     parseResponse(raw: unknown, latencyMs: number): CompletionResponse;
-    parseStreamEvent(event: SSEEvent): StreamEvent[];
+    parseStreamEvent(event: SSEEvent, state?: OpenAIStreamState): StreamEvent[];
 }

package/dist/llm/providers/xai/media.d.ts

@@ -21,6 +21,14 @@ export declare class XAIMediaAdapter implements MediaProviderAdapter {
     private parseImages;
     generateAudio(req: AudioGenRequest, fetch: EngineFetch): Promise<RawMediaResult>;
     submitVideo(req: VideoGenRequest, fetch: EngineFetch): Promise<string>;
+    /** 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. */
+    private buildVideoSubmit;
     getVideoStatus(operationId: string, fetch: EngineFetch): Promise<VideoStatus>;
     downloadVideo(operationId: string, fetch: EngineFetch): Promise<RawMediaResult>;
     cancelVideo(operationId: string, fetch: EngineFetch): Promise<void>;

package/dist/llm/types/request.d.ts

@@ -49,13 +49,21 @@ export interface NormalizedRequest {
  *  token cost; `current_turn` drops earlier reasoning; `auto` lets OpenAI decide.
  *  Ignored by every other provider. */
 export type ReasoningContext = 'auto' | 'current_turn' | 'all_turns';
+/** How much of the model's reasoning is returned. `full` (default) returns it as
+ *  fully as the provider allows; `summary` a condensed form where the provider
+ *  supports one (else full); `hidden` keeps reasoning internal. Best-effort per
+ *  provider — Anthropic `enabled.display`, OpenAI Responses `summary`, Google
+ *  `includeThoughts`; providers without a control ignore it. */
+export type ThinkingVisibility = 'full' | 'summary' | 'hidden';
 export type ThinkingConfig = {
     mode: 'auto';
     effort?: 'low' | 'medium' | 'high' | 'max';
+    visibility?: ThinkingVisibility;
     context?: ReasoningContext;
 } | {
     mode: 'on';
     effort?: 'low' | 'medium' | 'high' | 'max';
+    visibility?: ThinkingVisibility;
     context?: ReasoningContext;
 } | {
     mode: 'off';

package/dist/llm/types/tools.d.ts

@@ -6,9 +6,18 @@ export interface FunctionTool {
     parameters: JsonSchema;
     strict?: boolean;
     cache?: boolean;
+    /** OpenAI **Responses** programmatic tool calling: which callers may invoke this
+     *  tool — `direct` (the model calls it) and/or `programmatic` (generated
+     *  orchestration code calls it). OpenAI-Responses-only; ignored elsewhere. */
+    allowedCallers?: Array<'direct' | 'programmatic'>;
+    /** OpenAI **Responses** JSON schema for the tool's return value (lets the model
+     *  reason over structured tool output). OpenAI-Responses-only. */
+    outputSchema?: JsonSchema;
 }
 export interface BuiltinTool {
-    type: 'image_generation' | 'web_search' | 'web_fetch' | 'code_interpreter' | 'file_search' | 'mcp';
+    type: 'image_generation' | 'web_search' | 'web_fetch' | 'code_interpreter' | 'file_search' | 'mcp'
+    /** OpenAI Responses: lets the model write JS to orchestrate tool calls. */
+     | 'programmatic_tool_calling';
     params?: Record<string, unknown>;
 }
 /** Typed shape for an `mcp` builtin's `params` (OpenAI hosted MCP tool). The

package/dist/plugins/media/source-image.d.ts

@@ -26,6 +26,15 @@ export declare function toDataUrl(ref: NormalizedImageRef): string;
 export declare function openaiImageRef(ref: NormalizedImageRef): Record<string, string>;
 /** xAI image-ref object (`/v1/images/edits` image, video image). */
 export declare function xaiImageRef(ref: NormalizedImageRef): Record<string, string>;
+/** xAI video-ref object (`/v1/videos/extensions` + `/v1/videos/edits` `video`
+ *  field) — `{ url }` (public URL or base64 data-URL) or `{ file_id }`. Kept
+ *  separate from the image path so it doesn't run image mime-sniffing over
+ *  video bytes; the video mime is taken from the DataSource as declared. */
+export declare function xaiVideoRef(src: DataSource): {
+    url: string;
+} | {
+    file_id: string;
+};
 /** Google generateContent image part (inline base64 or Files-API file_uri). */
 export declare function googleImagePart(ref: NormalizedImageRef): Record<string, unknown>;
 /** Google Veo instance image (`:predictLongRunning` instances[].image).