@cognipeer/agent-sdk 0.10.6 → 0.12.0

package/dist/index.cjs

@@ -2441,6 +2441,15 @@ function estimatePayloadBytes(value) {
     }
   }
 }
+function toMessageUsage(u) {
+  return {
+    prompt_tokens: u.inputTokens,
+    completion_tokens: u.outputTokens,
+    total_tokens: u.totalTokens,
+    prompt_tokens_details: { cached_tokens: u.cachedInputTokens, cache_write_tokens: u.cachedWriteTokens },
+    completion_tokens_details: { reasoning_tokens: u.reasoningTokens }
+  };
+}
 function fromNativeProvider(provider, options) {
   let boundTools = options?.__tools;
   const modelName = options?.model ?? provider.defaultModel ?? provider.providerName;
@@ -2450,8 +2459,9 @@ function fromNativeProvider(provider, options) {
     invoke: async (messages, _invokeOptions) => {
       const link = linkAbortSignal(_invokeOptions);
       try {
-        const request = buildRequest(messages, boundTools, options, _invokeOptions);
+        let request = buildRequest(messages, boundTools, options, _invokeOptions);
         if (link.signal) request.signal = link.signal;
+        request = await applyTransform(request);
         const response = await provider.complete(request);
         return toBaseChatMessage(response);
       } finally {
@@ -2461,33 +2471,46 @@ function fromNativeProvider(provider, options) {
     stream: async function* (messages, _invokeOptions) {
       const link = linkAbortSignal(_invokeOptions);
       try {
-        const request = buildRequest(messages, boundTools, options, _invokeOptions);
+        let request = buildRequest(messages, boundTools, options, _invokeOptions);
         request.stream = true;
         if (link.signal) request.signal = link.signal;
+        request = await applyTransform(request);
         let fullContent = "";
         let allToolCalls = [];
         let lastUsage;
         let reasoningBlocks;
+        let reasoningText = "";
+        let finishReason;
+        let responseModel;
         const toolCallBuffers = /* @__PURE__ */ new Map();
         for await (const chunk of provider.completeStream(request)) {
           if (chunk.delta.content) {
             fullContent += chunk.delta.content;
             yield chunk.delta.content;
           }
+          if (chunk.model) responseModel = chunk.model;
+          if (chunk.finishReason) finishReason = chunk.finishReason;
           if (chunk.delta.reasoning?.blocks?.length) {
             reasoningBlocks = chunk.delta.reasoning.blocks;
           }
+          const reasoningDelta = chunk.delta.reasoning?.summary;
+          if (reasoningDelta) {
+            reasoningText += reasoningDelta;
+            yield { type: "reasoning", reasoning_content: reasoningDelta };
+          }
           if (chunk.delta.toolCalls) {
             for (const tc of chunk.delta.toolCalls) {
               if (tc.id) {
                 const existing = toolCallBuffers.get(tc.id);
                 if (existing) {
                   if (tc.arguments) existing.arguments += tc.arguments;
+                  if (tc.thoughtSignature) existing.thoughtSignature = tc.thoughtSignature;
                 } else {
                   toolCallBuffers.set(tc.id, {
                     id: tc.id,
                     name: tc.name ?? "",
-                    arguments: tc.arguments ?? ""
+                    arguments: tc.arguments ?? "",
+                    ...tc.thoughtSignature ? { thoughtSignature: tc.thoughtSignature } : {}
                   });
                 }
               }
@@ -2498,8 +2521,18 @@ function fromNativeProvider(provider, options) {
         if (link.signal?.aborted) return;
         allToolCalls = [...toolCallBuffers.values()];
         const finalMessage = assembleMessage(fullContent, allToolCalls, lastUsage);
-        if (reasoningBlocks?.length) {
-          finalMessage.reasoning = { blocks: reasoningBlocks };
+        if (reasoningBlocks?.length || reasoningText) {
+          finalMessage.reasoning = {
+            ...reasoningBlocks?.length ? { blocks: reasoningBlocks } : {},
+            ...reasoningText ? { summary: reasoningText } : {}
+          };
+        }
+        if (finishReason || responseModel) {
+          finalMessage.response_metadata = {
+            ...finalMessage.response_metadata ?? {},
+            ...finishReason ? { finish_reason: finishReason } : {},
+            ...responseModel ? { model_name: responseModel } : {}
+          };
         }
         yield finalMessage;
       } finally {
@@ -2513,6 +2546,11 @@ function fromNativeProvider(provider, options) {
     }
   };
   return adapted;
+  async function applyTransform(req) {
+    if (!options?.transformRequest) return req;
+    const out = await options.transformRequest(req);
+    return out ?? req;
+  }
   function buildRequest(messages, tools, opts, invokeOptions) {
     const req = {
       model: opts?.model ?? modelName,
@@ -2520,6 +2558,10 @@ function fromNativeProvider(provider, options) {
     };
     if (opts?.temperature != null) req.temperature = opts.temperature;
     if (opts?.maxTokens != null) req.maxTokens = opts.maxTokens;
+    if (opts?.topP != null) req.topP = opts.topP;
+    if (opts?.stop?.length) req.stop = opts.stop;
+    if (opts?.presencePenalty != null) req.presencePenalty = opts.presencePenalty;
+    if (opts?.frequencyPenalty != null) req.frequencyPenalty = opts.frequencyPenalty;
     if (tools?.length) req.tools = tools;
     if (opts?.extra) req.extra = opts.extra;
     const reasoningOverride = invokeOptions?.reasoning;
@@ -2572,7 +2614,8 @@ function toUnifiedMessage(msg) {
     unified.toolCalls = msg.tool_calls.map((tc) => ({
       id: tc.id,
       name: tc.function?.name ?? tc.name ?? "",
-      arguments: tc.function?.arguments ?? tc.arguments ?? "{}"
+      arguments: tc.function?.arguments ?? tc.arguments ?? "{}",
+      ...tc.thoughtSignature ? { thoughtSignature: tc.thoughtSignature } : {}
     }));
   }
   const reasoning = msg.reasoning;
@@ -2846,29 +2889,16 @@ function toToolDefinition(tool, strict) {
   }
   return { name, description, parameters, ...useStrict ? { strict: true } : {} };
 }
+function legacyTokenUsage(u) {
+  return { ...toMessageUsage(u), cached_tokens: u.cachedInputTokens, cache_write_tokens: u.cachedWriteTokens };
+}
 function toBaseChatMessage(response) {
   const msg = {
     role: "assistant",
     content: response.content ?? "",
-    usage: {
-      prompt_tokens: response.usage.inputTokens,
-      completion_tokens: response.usage.outputTokens,
-      total_tokens: response.usage.totalTokens,
-      prompt_tokens_details: {
-        cached_tokens: response.usage.cachedInputTokens
-      },
-      completion_tokens_details: {
-        reasoning_tokens: response.usage.reasoningTokens
-      }
-    },
+    usage: toMessageUsage(response.usage),
     response_metadata: {
-      token_usage: {
-        prompt_tokens: response.usage.inputTokens,
-        completion_tokens: response.usage.outputTokens,
-        total_tokens: response.usage.totalTokens,
-        cached_tokens: response.usage.cachedInputTokens,
-        cache_write_tokens: response.usage.cachedWriteTokens
-      },
+      token_usage: legacyTokenUsage(response.usage),
       finish_reason: response.finishReason,
       model_name: response.model
     }
@@ -2877,7 +2907,8 @@ function toBaseChatMessage(response) {
     msg.tool_calls = response.toolCalls.map((tc) => ({
       id: tc.id,
       type: "function",
-      function: { name: tc.name, arguments: tc.arguments }
+      function: { name: tc.name, arguments: tc.arguments },
+      ...tc.thoughtSignature ? { thoughtSignature: tc.thoughtSignature } : {}
     }));
   }
   if (response.reasoning && (response.reasoning.blocks?.length || response.reasoning.summary)) {
@@ -2891,32 +2922,15 @@ function assembleMessage(content, toolCalls, usage) {
     content
   };
   if (usage) {
-    msg.usage = {
-      prompt_tokens: usage.inputTokens,
-      completion_tokens: usage.outputTokens,
-      total_tokens: usage.totalTokens,
-      prompt_tokens_details: {
-        cached_tokens: usage.cachedInputTokens
-      },
-      completion_tokens_details: {
-        reasoning_tokens: usage.reasoningTokens
-      }
-    };
-    msg.response_metadata = {
-      token_usage: {
-        prompt_tokens: usage.inputTokens,
-        completion_tokens: usage.outputTokens,
-        total_tokens: usage.totalTokens,
-        cached_tokens: usage.cachedInputTokens,
-        cache_write_tokens: usage.cachedWriteTokens
-      }
-    };
+    msg.usage = toMessageUsage(usage);
+    msg.response_metadata = { token_usage: legacyTokenUsage(usage) };
   }
   if (toolCalls.length > 0) {
     msg.tool_calls = toolCalls.map((tc) => ({
       id: tc.id,
       type: "function",
-      function: { name: tc.name, arguments: tc.arguments }
+      function: { name: tc.name, arguments: tc.arguments },
+      ...tc.thoughtSignature ? { thoughtSignature: tc.thoughtSignature } : {}
     }));
   }
   return msg;
@@ -2949,8 +2963,8 @@ function resolveCapabilities(provider) {
       return {
         structuredOutput: "tool_based",
         strictToolCalling: false,
-        streaming: false,
-        // streaming uses binary protocol
+        streaming: true,
+        // ConverseStream (AWS event-stream frames)
         provider: "bedrock"
       };
     case "vertex":
@@ -4656,6 +4670,10 @@ ${append}`;
               if (chunk && typeof chunk === "object" && chunk.role) {
                 streamedMessage = chunk;
               }
+              if (chunk && typeof chunk === "object" && chunk.type === "reasoning" && typeof chunk.reasoning_content === "string") {
+                onEvent?.({ type: "reasoning", text: chunk.reasoning_content });
+                continue;
+              }
               const text = extractText2(chunk);
               const isAssembledMessage = Boolean(chunk && typeof chunk === "object" && chunk.role) && text.length > 0 && text === streamedText;
               if (text && !isAssembledMessage) {
@@ -11536,6 +11554,28 @@ async function runSmartAgentEvalHarness(params) {
   return results;
 }
 
+// src/providers/types.ts
+function emptyUsage() {
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0,
+    cachedInputTokens: 0,
+    cachedWriteTokens: 0,
+    cachedOutputTokens: 0,
+    reasoningTokens: 0
+  };
+}
+var ProviderError = class extends Error {
+  constructor(message, provider, statusCode, responseBody) {
+    super(message);
+    this.provider = provider;
+    this.statusCode = statusCode;
+    this.responseBody = responseBody;
+    this.name = "ProviderError";
+  }
+};
+
 // src/providers/base.ts
 var DEFAULT_RETRY = {
   maxRetries: 3,
@@ -11546,6 +11586,55 @@ var BaseProvider = class {
   constructor() {
     this.retryPolicy = DEFAULT_RETRY;
   }
+  /** Applies the transport options shared by every provider config. */
+  configureTransport(config) {
+    this.fetchImpl = config.fetch;
+    this.timeoutMs = typeof config.timeoutMs === "number" && config.timeoutMs > 0 ? config.timeoutMs : void 0;
+  }
+  /**
+   * The single HTTP entry point for every provider call site. Uses the
+   * configured `fetch` and applies `timeoutMs`: the timer covers the time until
+   * the response HEADERS arrive and is cleared after that, so a long-running
+   * stream is never cut by it (use the request `signal` to cancel a stream).
+   * A timeout surfaces as a `ProviderError` with status 408. The caller's
+   * `signal` still aborts the request as before.
+   */
+  async httpFetch(url, init = {}) {
+    const doFetch = this.fetchImpl ?? fetch;
+    const timeoutMs = this.timeoutMs;
+    if (!timeoutMs) return doFetch(url, init);
+    const controller = new AbortController();
+    const outer = init.signal ?? void 0;
+    let timedOut = false;
+    const onOuterAbort = () => controller.abort(outer?.reason);
+    if (outer) {
+      if (outer.aborted) controller.abort(outer.reason);
+      else outer.addEventListener("abort", onOuterAbort, { once: true });
+    }
+    const timer = setTimeout(() => {
+      timedOut = true;
+      controller.abort(new Error(`timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    try {
+      const res = await doFetch(url, { ...init, signal: controller.signal });
+      return res;
+    } catch (err) {
+      if (timedOut) {
+        throw new ProviderError(`${this.providerName} request timed out after ${timeoutMs}ms`, this.providerName, 408);
+      }
+      throw err;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  /**
+   * Embeds `request.input`. Implemented by the providers that have an
+   * embeddings endpoint (OpenAI, Azure, openai-compatible, Bedrock, Vertex);
+   * the others reject with a 400 ProviderError.
+   */
+  async embed(_request) {
+    throw new ProviderError(`${this.providerName} does not support embeddings`, this.providerName, 400);
+  }
   /**
    * Helper concrete providers can wrap their fetch with. Retries 429/5xx
    * with exponential backoff and respects Retry-After if the response
@@ -11587,34 +11676,13 @@ var BaseProvider = class {
   }
 };
 
-// src/providers/types.ts
-function emptyUsage() {
-  return {
-    inputTokens: 0,
-    outputTokens: 0,
-    totalTokens: 0,
-    cachedInputTokens: 0,
-    cachedWriteTokens: 0,
-    cachedOutputTokens: 0,
-    reasoningTokens: 0
-  };
-}
-var ProviderError = class extends Error {
-  constructor(message, provider, statusCode, responseBody) {
-    super(message);
-    this.provider = provider;
-    this.statusCode = statusCode;
-    this.responseBody = responseBody;
-    this.name = "ProviderError";
-  }
-};
-
 // src/providers/jev.ts
 var JEV_DEFAULT_BASE_URL = "https://api.typesafe.ai";
 var JevProvider = class extends BaseProvider {
   constructor(config) {
     super();
     this.providerName = "jev";
+    this.configureTransport(config);
     this.apiKey = config.apiKey;
     this.baseURL = (config.baseURL ?? JEV_DEFAULT_BASE_URL).replace(/\/$/, "");
     this.defaultModel = config.defaultModel;
@@ -11630,7 +11698,7 @@ var JevProvider = class extends BaseProvider {
       questions: request.questions
     };
     const res = await this.doFetchWithRetry(
-      () => fetch(`${this.baseURL}/v1/systemone`, {
+      () => this.httpFetch(`${this.baseURL}/v1/systemone`, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
@@ -13866,12 +13934,12 @@ function responseCache(config = {}) {
   };
 }
 function signRequest(req) {
-  const now = /* @__PURE__ */ new Date();
+  const now = req.now ?? /* @__PURE__ */ new Date();
   const dateStamp = toDateStamp(now);
   const amzDate = toAmzDate(now);
   const parsed = new URL(req.url);
   const host = parsed.host;
-  const canonicalUri = parsed.pathname || "/";
+  const canonicalUri = (parsed.pathname || "/").split("/").map((seg) => encodeURIComponent(seg).replace(/[!'()*]/g, (c) => "%" + c.charCodeAt(0).toString(16).toUpperCase())).join("/");
   const canonicalQuerystring = sortQueryParams(parsed.searchParams);
   const headers = {
     ...req.headers,
@@ -15188,73 +15256,6 @@ function languageGuard(config) {
 // src/index.ts
 init_content();
 
-// src/providers/utils/sse.ts
-async function* parseSSEStream(body, signal) {
-  const reader = body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  try {
-    while (true) {
-      if (signal?.aborted) throw abortReason(signal);
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const parts = buffer.split(/\r?\n\r?\n/);
-      buffer = parts.pop() ?? "";
-      for (const part of parts) {
-        if (!part.trim()) continue;
-        const event = parseSSEBlock(part);
-        if (event) yield event;
-      }
-    }
-    if (buffer.trim()) {
-      const event = parseSSEBlock(buffer);
-      if (event) yield event;
-    }
-  } finally {
-    reader.cancel().catch(() => void 0);
-    reader.releaseLock();
-  }
-}
-function parseSSEBlock(block) {
-  let event;
-  let id;
-  let retry;
-  const dataLines = [];
-  for (const line of block.split(/\r?\n/)) {
-    if (line.startsWith(":")) continue;
-    const colonIdx = line.indexOf(":");
-    let field;
-    let value;
-    if (colonIdx === -1) {
-      field = line;
-      value = "";
-    } else {
-      field = line.slice(0, colonIdx);
-      value = line.slice(colonIdx + 1);
-      if (value.startsWith(" ")) value = value.slice(1);
-    }
-    switch (field) {
-      case "event":
-        event = value;
-        break;
-      case "data":
-        dataLines.push(value);
-        break;
-      case "id":
-        id = value;
-        break;
-      case "retry": {
-        const n = parseInt(value, 10);
-        if (!isNaN(n)) retry = n;
-        break;
-      }
-    }
-  }
-  if (dataLines.length === 0) return null;
-  return { event, data: dataLines.join("\n"), id, retry };
-}
-
 // src/providers/utils/reasoning.ts
 var ANTHROPIC_EFFORT_BUDGET = {
   // 0 = off. `applyAnthropicReasoning` bails on a falsy budget and emits no
@@ -15276,6 +15277,7 @@ var GEMINI_EFFORT_BUDGET = {
   high: 12e3
 };
 var THINKING_OUTPUT_RESERVE = 1024;
+var MIN_THINKING_BUDGET = 1024;
 var THINKING_MIN_MAX_TOKENS = 4096;
 function applyOpenAIReasoning(body, reasoning, mode = "legacy_effort") {
   if (!reasoning) return;
@@ -15291,8 +15293,48 @@ function applyOpenAIReasoning(body, reasoning, mode = "legacy_effort") {
     if (reasoning.providerExtras) Object.assign(body, reasoning.providerExtras);
   }
 }
-function applyAnthropicReasoning(body, reasoning) {
+function supportsAdaptiveThinking(model) {
+  if (typeof model !== "string") return false;
+  const id = model.toLowerCase();
+  const at = id.indexOf("claude-");
+  if (at < 0) return false;
+  for (const tok of id.slice(at + 7).split("-")) {
+    if (tok === "fable") return true;
+    const m = /^(\d+)(?:@|$)/.exec(tok);
+    if (m) {
+      if (m[1].length <= 2) return Number(m[1]) >= 5;
+      return false;
+    }
+  }
+  return false;
+}
+function resolveThinkingForm(model, mode) {
+  if (mode === "adaptive" || mode === "budget") return mode;
+  return supportsAdaptiveThinking(model) ? "adaptive" : "budget";
+}
+function applyAdaptiveThinking(_body, reasoning, setThinking, setOutputConfig) {
+  const requested = normalizeEffort(reasoning.effort);
+  if (requested === "none") return false;
+  let effort;
+  if (requested) effort = requested === "minimal" ? "low" : requested;
+  else if (typeof reasoning.budgetTokens === "number" && reasoning.budgetTokens > 0) {
+    effort = reasoning.budgetTokens <= ANTHROPIC_EFFORT_BUDGET.low ? "low" : reasoning.budgetTokens <= ANTHROPIC_EFFORT_BUDGET.medium ? "medium" : "high";
+  }
+  if (!effort) return false;
+  const thinking = { type: "adaptive" };
+  if (reasoning.includeThoughts !== false) thinking.display = "summarized";
+  if (reasoning.providerExtras) Object.assign(thinking, reasoning.providerExtras);
+  setThinking({ thinking });
+  setOutputConfig({ effort });
+  return true;
+}
+function applyAnthropicReasoning(body, reasoning, opts) {
   if (!reasoning) return;
+  if (resolveThinkingForm(opts?.model ?? body.model, opts?.mode) === "adaptive") {
+    const on = applyAdaptiveThinking(body, reasoning, (extra) => body.thinking = extra.thinking, (o) => body.output_config = { ...body.output_config ?? {}, ...o });
+    if (on) stripSamplingParams(body, ["temperature", "top_p", "top_k"]);
+    return;
+  }
   let budget = resolveBudget(reasoning, ANTHROPIC_EFFORT_BUDGET);
   if (!budget) return;
   const currentMax = typeof body.max_tokens === "number" ? body.max_tokens : 0;
@@ -15300,14 +15342,20 @@ function applyAnthropicReasoning(body, reasoning) {
   if (currentMax < requiredMax) {
     body.max_tokens = requiredMax;
   }
-  budget = clampBudget(budget, body.max_tokens);
+  budget = Math.max(MIN_THINKING_BUDGET, clampBudget(budget, body.max_tokens));
   const thinking = { type: "enabled", budget_tokens: budget };
   if (reasoning.providerExtras) Object.assign(thinking, reasoning.providerExtras);
   body.thinking = thinking;
   stripSamplingParams(body, ["temperature", "top_p", "top_k"]);
 }
-function applyBedrockReasoning(body, reasoning) {
+function applyBedrockReasoning(body, reasoning, opts) {
   if (!reasoning) return;
+  if (resolveThinkingForm(opts?.model ?? body.modelId, opts?.mode) === "adaptive") {
+    const fields = () => body.additionalModelRequestFields ?? (body.additionalModelRequestFields = {});
+    const on = applyAdaptiveThinking(body, reasoning, (extra2) => fields().thinking = extra2.thinking, (o) => fields().output_config = { ...fields().output_config ?? {}, ...o });
+    if (on && body.inferenceConfig) stripSamplingParams(body.inferenceConfig, ["temperature", "topP"]);
+    return;
+  }
   let budget = resolveBudget(reasoning, ANTHROPIC_EFFORT_BUDGET);
   if (!budget) return;
   const inference = body.inferenceConfig ?? (body.inferenceConfig = {});
@@ -15316,7 +15364,7 @@ function applyBedrockReasoning(body, reasoning) {
   if (currentMax < requiredMax) {
     inference.maxTokens = requiredMax;
   }
-  budget = clampBudget(budget, inference.maxTokens);
+  budget = Math.max(MIN_THINKING_BUDGET, clampBudget(budget, inference.maxTokens));
   const extra = body.additionalModelRequestFields ?? (body.additionalModelRequestFields = {});
   const thinking = { type: "enabled", budget_tokens: budget };
   if (reasoning.providerExtras) Object.assign(thinking, reasoning.providerExtras);
@@ -15326,8 +15374,9 @@ function applyBedrockReasoning(body, reasoning) {
 function applyGeminiReasoning(generationConfig, reasoning) {
   if (!reasoning) return;
   const budget = resolveBudget(reasoning, GEMINI_EFFORT_BUDGET);
-  if (budget == null) return;
-  const thinkingConfig = { thinkingBudget: budget };
+  const level = typeof reasoning.thinkingLevel === "string" && reasoning.thinkingLevel ? reasoning.thinkingLevel : void 0;
+  if (budget == null && !level) return;
+  const thinkingConfig = level && budget !== 0 ? { thinkingLevel: level } : { thinkingBudget: budget ?? 0 };
   if (reasoning.includeThoughts) thinkingConfig.includeThoughts = true;
   if (reasoning.providerExtras) Object.assign(thinkingConfig, reasoning.providerExtras);
   generationConfig.thinkingConfig = thinkingConfig;
@@ -15358,6 +15407,73 @@ function resolveBudget(reasoning, effortBudget) {
   return void 0;
 }
 
+// src/providers/utils/sse.ts
+async function* parseSSEStream(body, signal) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      if (signal?.aborted) throw abortReason(signal);
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const parts = buffer.split(/\r?\n\r?\n/);
+      buffer = parts.pop() ?? "";
+      for (const part of parts) {
+        if (!part.trim()) continue;
+        const event = parseSSEBlock(part);
+        if (event) yield event;
+      }
+    }
+    if (buffer.trim()) {
+      const event = parseSSEBlock(buffer);
+      if (event) yield event;
+    }
+  } finally {
+    reader.cancel().catch(() => void 0);
+    reader.releaseLock();
+  }
+}
+function parseSSEBlock(block) {
+  let event;
+  let id;
+  let retry;
+  const dataLines = [];
+  for (const line of block.split(/\r?\n/)) {
+    if (line.startsWith(":")) continue;
+    const colonIdx = line.indexOf(":");
+    let field;
+    let value;
+    if (colonIdx === -1) {
+      field = line;
+      value = "";
+    } else {
+      field = line.slice(0, colonIdx);
+      value = line.slice(colonIdx + 1);
+      if (value.startsWith(" ")) value = value.slice(1);
+    }
+    switch (field) {
+      case "event":
+        event = value;
+        break;
+      case "data":
+        dataLines.push(value);
+        break;
+      case "id":
+        id = value;
+        break;
+      case "retry": {
+        const n = parseInt(value, 10);
+        if (!isNaN(n)) retry = n;
+        break;
+      }
+    }
+  }
+  if (dataLines.length === 0) return null;
+  return { event, data: dataLines.join("\n"), id, retry };
+}
+
 // src/providers/utils/media.ts
 var EXTENSION_MIME = {
   jpg: "image/jpeg",
@@ -15549,11 +15665,64 @@ function isObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// src/providers/utils/embeddings.ts
+function chunkArray(items, size) {
+  const n = Math.max(1, Math.floor(size));
+  const out = [];
+  for (let i = 0; i < items.length; i += n) out.push(items.slice(i, i + n));
+  return out;
+}
+async function mapWithConcurrency(items, limit, fn, signal) {
+  const results = new Array(items.length);
+  let next = 0;
+  let failure;
+  let failed = false;
+  const worker = async () => {
+    while (!failed) {
+      if (signal?.aborted) throw signal.reason ?? new Error("aborted");
+      const i = next++;
+      if (i >= items.length) return;
+      try {
+        results[i] = await fn(items[i], i);
+      } catch (err) {
+        failed = true;
+        failure = err;
+        return;
+      }
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(Math.max(1, limit), items.length) }, worker));
+  if (failed) throw failure;
+  return results;
+}
+function decodeBase64Vector(b64) {
+  const buf = Buffer.from(b64, "base64");
+  const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+  const out = new Array(Math.floor(buf.byteLength / 4));
+  for (let i = 0; i < out.length; i++) out[i] = view.getFloat32(i * 4, true);
+  return out;
+}
+function assertVectorCount(provider, vectors, expected) {
+  if (vectors.length !== expected) {
+    throw new ProviderError(
+      `${provider} embeddings returned ${vectors.length} vectors for ${expected} inputs`,
+      provider,
+      502
+    );
+  }
+}
+function requireEmbeddingModel(provider, model) {
+  if (!model) throw new ProviderError(`${provider} embeddings require a model`, provider, 400);
+  return model;
+}
+
 // src/providers/openai.ts
-var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
+var OpenAIProvider = class extends BaseProvider {
   constructor(config) {
     super();
     this.providerName = "openai";
+    this.configureTransport(config);
+    this.maxTokensParam = config.maxTokensParam ?? "auto";
     this.apiKey = config.apiKey;
     this.baseURL = (config.baseURL ?? "https://api.openai.com/v1").replace(/\/$/, "");
     this.defaultModel = config.defaultModel ?? "gpt-4o";
@@ -15561,10 +15730,14 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
       ...config.defaultHeaders,
       ...config.organization ? { "OpenAI-Organization": config.organization } : {}
     };
-    this.responsesApi = config.responsesApi ?? "auto";
-    const ownInstance = new.target === _OpenAIProvider;
-    this.responsesApiModels = ownInstance ? [...config.responsesApiModels ?? []] : [];
-    this.responsesStreaming = ownInstance && config.responsesStreaming === true;
+    const legacy = config.responsesApi;
+    const explicit = config.api === "chat" || config.api === "responses" ? config.api : void 0;
+    this.responsesApi = explicit === "responses" ? "always" : explicit === "chat" ? "never" : legacy ?? (config._autoMeansChat ? "never" : "auto");
+    this.apiExplicitChat = explicit === "chat" || explicit === void 0 && legacy === "never";
+    this.apiExplicitResponses = this.responsesApi === "always";
+    this.apiResponsesNative = explicit === "responses";
+    this.responsesApiModels = [...config.responsesApiModels ?? []];
+    this.responsesStreaming = config.responsesStreaming ?? this.apiResponsesNative;
     if (config.retry) this.retryPolicy = { ...this.retryPolicy, ...config.retry };
   }
   /** True when the caller listed this request's model in `responsesApiModels`. */
@@ -15590,9 +15763,10 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
    * A model listed in `responsesApiModels` is the caller stating the answer
    * for that model alone; `never` still overrides it. */
   useResponsesApi(request) {
-    if (this.responsesApi === "never") return false;
-    if (this.responsesApi === "always") return true;
+    if (this.apiExplicitChat) return false;
+    if (this.apiExplicitResponses) return true;
     if (this.isResponsesApiModel(request)) return true;
+    if (this.responsesApi !== "auto") return false;
     if (!request.reasoning) return false;
     return isReasoningModel(request.model || this.defaultModel);
   }
@@ -15607,7 +15781,7 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
   }
   async *completeStream(request) {
     if (this.useResponsesApi(request)) {
-      if (this.responsesStreaming && this.isResponsesApiModel(request)) {
+      if (this.responsesStreaming && (this.apiResponsesNative || this.isResponsesApiModel(request))) {
         yield* this.streamResponses(request);
         return;
       }
@@ -15657,9 +15831,14 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
         delta: {},
         finishReason: mapFinishReason(choice.finish_reason)
       };
+      if (typeof choice.finish_reason === "string") out.rawFinishReason = choice.finish_reason;
+      const fields = pickProviderFields(chunk, delta, choice);
+      if (fields) out.providerFields = fields;
       if (delta.content) {
         out.delta.content = delta.content;
       }
+      const reasoningDelta = extractReasoningText(delta);
+      if (reasoningDelta) out.delta.reasoning = { summary: reasoningDelta };
       if (delta.tool_calls) {
         const partials = [];
         for (const tc of delta.tool_calls) {
@@ -15671,7 +15850,7 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
           if (tc.id) buf.id = tc.id;
           if (tc.function?.name) buf.name = tc.function.name;
           if (tc.function?.arguments) buf.arguments += tc.function.arguments;
-          partials.push({ id: buf.id, name: buf.name || void 0, arguments: tc.function?.arguments });
+          partials.push({ id: buf.id, name: buf.name || void 0, arguments: tc.function?.arguments, index: idx });
         }
         out.delta.toolCalls = partials;
       }
@@ -15679,6 +15858,51 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
       yield out;
     }
   }
+  // ─── Embeddings ──────────────────────────────────────────────────────────
+  /** POST /embeddings, batched (default 2048 inputs per request, the OpenAI cap). */
+  async embed(request) {
+    const model = requireEmbeddingModel(this.providerName, request.model);
+    const batches = chunkArray(request.input, request.batchSize ?? 2048);
+    const vectors = [];
+    const raw = [];
+    let inputTokens = 0;
+    let totalTokens = 0;
+    let responseModel = model;
+    for (const batch of batches) {
+      const body = { model, input: batch };
+      if (request.dimensions != null) body.dimensions = request.dimensions;
+      if (request.encodingFormat) body.encoding_format = request.encodingFormat;
+      if (request.extra) Object.assign(body, request.extra);
+      const res = await this.embeddingsFetch(body, request.signal);
+      const json = await res.json();
+      raw.push(json);
+      const data = Array.isArray(json.data) ? [...json.data] : [];
+      data.sort((a, b) => (a.index ?? 0) - (b.index ?? 0));
+      for (const d of data) {
+        vectors.push(typeof d.embedding === "string" ? decodeBase64Vector(d.embedding) : d.embedding);
+      }
+      inputTokens += json.usage?.prompt_tokens ?? 0;
+      totalTokens += json.usage?.total_tokens ?? json.usage?.prompt_tokens ?? 0;
+      responseModel = json.model ?? responseModel;
+    }
+    assertVectorCount(this.providerName, vectors, request.input.length);
+    return { model: responseModel, vectors, usage: { inputTokens, totalTokens }, raw };
+  }
+  async embeddingsFetch(body, signal) {
+    const url = `${this.baseURL}/embeddings`;
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.apiKey}`,
+      ...this.defaultHeaders
+    };
+    const payload = JSON.stringify(body);
+    const res = await this.doFetchWithRetry(() => this.httpFetch(url, { method: "POST", headers, body: payload, signal }), signal);
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new ProviderError(`OpenAI embeddings API error ${res.status}: ${text}`, this.providerName, res.status, text);
+    }
+    return res;
+  }
   // ─── Internals ───────────────────────────────────────────────────────────
   buildRequestBody(request, stream) {
     const body = {
@@ -15686,15 +15910,27 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
       messages: request.messages.map((m) => this.toOpenAIMessage(m)),
       stream
     };
-    if (stream) {
+    if (stream && request.streamUsage !== false) {
       body.stream_options = { include_usage: true };
     }
-    if (request.temperature != null) body.temperature = request.temperature;
-    if (request.maxTokens != null) body.max_tokens = request.maxTokens;
-    if (request.topP != null) body.top_p = request.topP;
+    const modelId = String(body.model);
+    const reasoningModel = isReasoningModel(modelId) && !/chat/i.test(modelId);
+    if (request.temperature != null && !reasoningModel) body.temperature = request.temperature;
+    if (request.maxTokens != null) {
+      const useCompletionTokens = this.maxTokensParam === "max_completion_tokens" || this.maxTokensParam === "auto" && isReasoningModel(modelId);
+      body[useCompletionTokens ? "max_completion_tokens" : "max_tokens"] = request.maxTokens;
+    }
+    if (request.topP != null && !reasoningModel) body.top_p = request.topP;
     if (request.stop) body.stop = request.stop;
+    if (request.presencePenalty != null) body.presence_penalty = request.presencePenalty;
+    if (request.frequencyPenalty != null) body.frequency_penalty = request.frequencyPenalty;
+    if (request.seed != null) body.seed = request.seed;
+    if (request.n != null) body.n = request.n;
+    if (request.logprobs != null) body.logprobs = request.logprobs;
+    if (request.topLogprobs != null) body.top_logprobs = request.topLogprobs;
     if (request.tools?.length) {
       body.tools = request.tools.map((t) => this.toOpenAITool(t));
+      if (request.parallelToolCalls != null) body.parallel_tool_calls = request.parallelToolCalls;
     }
     if (request.toolChoice != null && request.tools?.length) {
       if (typeof request.toolChoice === "string") {
@@ -15726,7 +15962,7 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
   // ─── Responses API (reasoning models) ──────────────────────────────────────
   async completeResponses(request) {
     const body = this.buildResponsesBody(request);
-    if (this.isResponsesApiModel(request)) adaptChatExtrasForResponses(body, request.extra);
+    if (this.apiResponsesNative || this.isResponsesApiModel(request)) adaptChatExtrasForResponses(body, request.extra);
     const res = await this.responsesFetch(body, request.signal);
     const json = await res.json();
     return this.parseResponsesResponse(json, request.model || this.defaultModel);
@@ -15749,6 +15985,7 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
     let model = modelId;
     const calls = /* @__PURE__ */ new Map();
     let final;
+    let streamedSummary = false;
     for await (const event of parseSSEStream(res.body, request.signal)) {
       if (event.data === "[DONE]") break;
       let data;
@@ -15766,19 +16003,28 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
         case "response.output_text.delta":
           if (data.delta) yield { id, model, delta: { content: data.delta } };
           break;
+        case "response.reasoning_summary_part.added":
+          if (streamedSummary) yield { id, model, delta: { reasoning: { summary: "\n\n" } } };
+          break;
+        case "response.reasoning_summary_text.delta":
+          if (typeof data.delta === "string" && data.delta) {
+            streamedSummary = true;
+            yield { id, model, delta: { reasoning: { summary: data.delta } } };
+          }
+          break;
         case "response.output_item.added": {
           const item = data.item;
           if (item?.type !== "function_call") break;
-          const call = { callId: item.call_id ?? item.id ?? "", name: item.name ?? "", arguments: item.arguments ?? "" };
+          const call = { callId: item.call_id ?? item.id ?? "", name: item.name ?? "", arguments: item.arguments ?? "", index: calls.size };
           calls.set(item.id ?? call.callId, call);
-          yield { id, model, delta: { toolCalls: [{ id: call.callId, name: call.name, arguments: call.arguments }] } };
+          yield { id, model, delta: { toolCalls: [{ id: call.callId, name: call.name, arguments: call.arguments, index: call.index }] } };
           break;
         }
         case "response.function_call_arguments.delta": {
           const call = calls.get(data.item_id);
           if (!call || !data.delta) break;
           call.arguments += data.delta;
-          yield { id, model, delta: { toolCalls: [{ id: call.callId, arguments: data.delta }] } };
+          yield { id, model, delta: { toolCalls: [{ id: call.callId, arguments: data.delta, index: call.index }] } };
           break;
         }
         case "response.output_item.done": {
@@ -15787,13 +16033,13 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
           const full = typeof item.arguments === "string" ? item.arguments : "";
           const call = calls.get(item.id ?? item.call_id);
           if (!call) {
-            const added = { callId: item.call_id ?? item.id ?? "", name: item.name ?? "", arguments: full };
+            const added = { callId: item.call_id ?? item.id ?? "", name: item.name ?? "", arguments: full, index: calls.size };
             calls.set(item.id ?? added.callId, added);
-            yield { id, model, delta: { toolCalls: [{ id: added.callId, name: added.name, arguments: full }] } };
+            yield { id, model, delta: { toolCalls: [{ id: added.callId, name: added.name, arguments: full, index: added.index }] } };
           } else if (full.length > call.arguments.length && full.startsWith(call.arguments)) {
             const rest = full.slice(call.arguments.length);
             call.arguments = full;
-            yield { id, model, delta: { toolCalls: [{ id: call.callId, arguments: rest }] } };
+            yield { id, model, delta: { toolCalls: [{ id: call.callId, arguments: rest, index: call.index }] } };
           }
           break;
         }
@@ -15816,7 +16062,8 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
     yield {
       id: final?.id || id,
       model: final?.model || model,
-      delta: final?.reasoning ? { reasoning: final.reasoning } : {},
+      // Summary text already went out as deltas; do not repeat it.
+      delta: final?.reasoning && !streamedSummary ? { reasoning: final.reasoning } : {},
       usage: final?.usage,
       finishReason: final?.finishReason ?? (calls.size > 0 ? "tool_calls" : "stop")
     };
@@ -15926,7 +16173,7 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
       ...this.defaultHeaders
     };
     const payload = JSON.stringify(body);
-    const res = await this.doFetchWithRetry(() => fetch(url, { method: "POST", headers, body: payload, signal }), signal);
+    const res = await this.doFetchWithRetry(() => this.httpFetch(url, { method: "POST", headers, body: payload, signal }), signal);
     if (!res.ok) {
       const text = await res.text().catch(() => "");
       throw new ProviderError(
@@ -16055,7 +16302,7 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
       ...this.defaultHeaders
     };
     const payload = JSON.stringify(body);
-    const res = await this.doFetchWithRetry(() => fetch(url, { method: "POST", headers, body: payload, signal }), signal);
+    const res = await this.doFetchWithRetry(() => this.httpFetch(url, { method: "POST", headers, body: payload, signal }), signal);
     if (!res.ok) {
       const text = await res.text().catch(() => "");
       throw new ProviderError(
@@ -16075,6 +16322,8 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
       name: tc.function?.name ?? "",
       arguments: tc.function?.arguments ?? "{}"
     }));
+    const reasoningText = extractReasoningText(message);
+    const providerFields = pickProviderFields(json, message, choice);
     return {
       id: json.id ?? "",
       model: json.model ?? "",
@@ -16082,6 +16331,9 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
       toolCalls,
       usage: this.extractUsage(json.usage),
       finishReason: mapFinishReason(choice?.finish_reason),
+      ...typeof choice?.finish_reason === "string" ? { rawFinishReason: choice.finish_reason } : {},
+      ...providerFields ? { providerFields } : {},
+      ...reasoningText ? { reasoning: { summary: reasoningText } } : {},
       raw: json
     };
   }
@@ -16100,6 +16352,23 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
     };
   }
 };
+function extractReasoningText(src) {
+  if (!src || typeof src !== "object") return void 0;
+  for (const key of ["reasoning_content", "reasoning"]) {
+    const v = src[key];
+    if (typeof v === "string" && v.length > 0) return v;
+  }
+  return void 0;
+}
+function pickProviderFields(top, message, choice) {
+  const out = {};
+  if (top?.system_fingerprint != null) out.system_fingerprint = top.system_fingerprint;
+  if (top?.service_tier != null) out.service_tier = top.service_tier;
+  if (message?.annotations != null) out.annotations = message.annotations;
+  if (message?.refusal != null) out.refusal = message.refusal;
+  if (choice?.logprobs != null) out.logprobs = choice.logprobs;
+  return Object.keys(out).length > 0 ? out : void 0;
+}
 function isReasoningModel(model) {
   if (!model) return false;
   const m = model.toLowerCase();
@@ -16176,36 +16445,86 @@ function mapFinishReason(reason) {
   }
 }
 
+// src/providers/utils/toolChoice.ts
+function supportsForcedToolChoice(model) {
+  if (typeof model !== "string") return true;
+  const id = model.toLowerCase();
+  const at = id.indexOf("claude-");
+  if (at < 0) return true;
+  const toks = id.slice(at + 7).split("-");
+  let family = false;
+  for (const tok of toks) {
+    if (tok === "sonnet" || tok === "opus") {
+      family = true;
+      continue;
+    }
+    const m = /^(\d+)(?:@|:|$)/.exec(tok);
+    if (m) {
+      if (m[1].length > 2) continue;
+      if (Number(m[1]) < 5) return true;
+      if (family) return false;
+      return !toks.some((t) => t === "sonnet" || t === "opus");
+    }
+  }
+  return true;
+}
+function forcedToolChoiceRejected(text) {
+  const t = text.toLowerCase();
+  return t.indexOf("tool_choice") >= 0 && t.indexOf("not supported for this model") >= 0;
+}
+
 // src/providers/anthropic.ts
+var DEFAULT_MAX_TOKENS = 4096;
+function normalizeExplicitThinking(body) {
+  const t = body.thinking;
+  if (t == null) {
+    delete body.thinking;
+    return;
+  }
+  if (t.type !== "enabled") return;
+  const budget = typeof t.budget_tokens === "number" ? t.budget_tokens : 0;
+  if (budget > 0 && (typeof body.max_tokens !== "number" || body.max_tokens <= budget)) {
+    body.max_tokens = budget + 1024;
+  }
+  for (const k of ["temperature", "top_p", "top_k"]) delete body[k];
+}
+function thinkingFormRejected(text) {
+  const t = text.toLowerCase();
+  if (t.indexOf("thinking.type.enabled") >= 0 && t.indexOf("not supported") >= 0) return "enabled";
+  if (t.indexOf("thinking.type.adaptive") >= 0 && t.indexOf("not supported") >= 0 && t.indexOf("thinking.type.enabled") < 0) return "adaptive";
+  return void 0;
+}
 var AnthropicProvider = class extends BaseProvider {
   constructor(config) {
     super();
     this.providerName = "anthropic";
+    this.configureTransport(config);
     this.apiKey = config.apiKey;
     this.baseURL = (config.baseURL ?? "https://api.anthropic.com").replace(/\/$/, "");
     this.defaultModel = config.defaultModel ?? "claude-sonnet-4-20250514";
     this.defaultHeaders = config.defaultHeaders ?? {};
     this.anthropicVersion = config.anthropicVersion ?? "2023-06-01";
+    this.thinkingMode = config.thinkingMode ?? "auto";
     this.promptCachingEnabled = config.prompt_caching?.enabled === true;
     if (config.retry) this.retryPolicy = { ...this.retryPolicy, ...config.retry };
   }
   async complete(request) {
-    const body = this.buildRequestBody(request, false);
-    const res = await this.doFetch(body, request.signal);
+    const res = await this.send(request, false);
     const json = await res.json();
     return this.parseResponse(json);
   }
   async *completeStream(request) {
-    const body = this.buildRequestBody(request, true);
-    const res = await this.doFetch(body, request.signal);
+    const res = await this.send(request, true);
     if (!res.body) throw new ProviderError("No response body for stream", this.providerName);
     let id = "";
     let model = "";
     let inputTokens = 0;
     let outputTokens = 0;
+    let thinkingTokens = 0;
     let cacheReadInputTokens = 0;
     let cacheCreationInputTokens = 0;
     const currentToolCalls = /* @__PURE__ */ new Map();
+    let toolOrdinal = 0;
     const reasoningBlocks = /* @__PURE__ */ new Map();
     for await (const event of parseSSEStream(res.body, request.signal)) {
       let data;
@@ -16234,8 +16553,11 @@ var AnthropicProvider = class extends BaseProvider {
             currentToolCalls.set(idx, {
               id: block.id ?? "",
               name: block.name ?? "",
-              arguments: ""
+              arguments: "",
+              ordinal: toolOrdinal++
             });
+            const opened = currentToolCalls.get(idx);
+            yield { id, model, delta: { toolCalls: [{ id: opened.id, name: opened.name, arguments: "", index: opened.ordinal }] } };
           } else if (block?.type === "thinking") {
             reasoningBlocks.set(idx, { type: "thinking", text: block.thinking ?? "", signature: block.signature });
           } else if (block?.type === "redacted_thinking") {
@@ -16273,7 +16595,7 @@ var AnthropicProvider = class extends BaseProvider {
                 id,
                 model,
                 delta: {
-                  toolCalls: [{ id: tc.id, name: tc.name, arguments: delta.partial_json }]
+                  toolCalls: [{ id: tc.id, name: tc.name, arguments: delta.partial_json, index: tc.ordinal }]
                 }
               };
             }
@@ -16286,8 +16608,10 @@ var AnthropicProvider = class extends BaseProvider {
           const delta = data.delta;
           if (data.usage) {
             outputTokens = data.usage.output_tokens ?? outputTokens;
+            thinkingTokens = data.usage.output_tokens_details?.thinking_tokens ?? thinkingTokens;
           }
           const finishReason = mapAnthropicStopReason(delta?.stop_reason);
+          const rawFinishReason = typeof delta?.stop_reason === "string" ? delta.stop_reason : void 0;
           const usage = {
             inputTokens,
             outputTokens,
@@ -16295,7 +16619,7 @@ var AnthropicProvider = class extends BaseProvider {
             cachedInputTokens: cacheReadInputTokens,
             cachedWriteTokens: cacheCreationInputTokens,
             cachedOutputTokens: 0,
-            reasoningTokens: 0
+            reasoningTokens: thinkingTokens
           };
           const blocks = [...reasoningBlocks.values()].filter(
             (b) => b.type === "thinking" && b.signature || b.type === "redacted_thinking" && b.data
@@ -16305,6 +16629,7 @@ var AnthropicProvider = class extends BaseProvider {
             model,
             delta: blocks.length > 0 ? { reasoning: { blocks } } : {},
             finishReason,
+            ...rawFinishReason ? { rawFinishReason } : {},
             usage
           };
           break;
@@ -16319,12 +16644,12 @@ var AnthropicProvider = class extends BaseProvider {
     }
   }
   // ─── Internals ───────────────────────────────────────────────────────────
-  buildRequestBody(request, stream) {
+  buildRequestBody(request, stream, modeOverride, downgradeToolChoice = false) {
     const { system, messages } = this.splitSystemMessages(request.messages);
     const body = {
       model: request.model || this.defaultModel,
       messages: this.toAnthropicMessages(messages),
-      max_tokens: request.maxTokens ?? 4096,
+      max_tokens: request.maxTokens ?? DEFAULT_MAX_TOKENS,
       stream
     };
     if (system) {
@@ -16345,18 +16670,27 @@ var AnthropicProvider = class extends BaseProvider {
       body.tools = tools;
     }
     if (request.toolChoice != null) {
+      const forceOk = !downgradeToolChoice && supportsForcedToolChoice(body.model);
       if (request.toolChoice === "auto") {
         body.tool_choice = { type: "auto" };
       } else if (request.toolChoice === "required") {
-        body.tool_choice = { type: "any" };
+        body.tool_choice = forceOk ? { type: "any" } : { type: "auto" };
       } else if (request.toolChoice === "none") ; else {
-        body.tool_choice = { type: "tool", name: request.toolChoice.name };
+        body.tool_choice = forceOk ? { type: "tool", name: request.toolChoice.name } : { type: "auto" };
       }
     }
     if (request.extra) {
       Object.assign(body, request.extra);
     }
-    applyAnthropicReasoning(body, request.reasoning);
+    const explicitThinking = request.extra && typeof request.extra === "object" && "thinking" in request.extra;
+    if (explicitThinking) {
+      normalizeExplicitThinking(body);
+    } else {
+      applyAnthropicReasoning(body, request.reasoning, { model: body.model, mode: modeOverride ?? this.thinkingMode });
+    }
+    if (typeof body.max_tokens !== "number" || !(body.max_tokens > 0)) {
+      body.max_tokens = DEFAULT_MAX_TOKENS;
+    }
     return body;
   }
   splitSystemMessages(messages) {
@@ -16487,6 +16821,34 @@ var AnthropicProvider = class extends BaseProvider {
       input_schema: t.parameters
     };
   }
+  /** Builds and sends the request; retries once with the other thinking form
+   * when the upstream rejects the one we picked. */
+  async send(request, stream) {
+    let mode;
+    let downgrade = false;
+    let flippedThinking = false;
+    for (; ; ) {
+      const body = this.buildRequestBody(request, stream, mode, downgrade);
+      try {
+        return await this.doFetch(body, request.signal);
+      } catch (err) {
+        if (!(err instanceof ProviderError) || err.statusCode !== 400) throw err;
+        const text = String(err.responseBody ?? err.message);
+        if (!downgrade && body.tool_choice && body.tool_choice.type !== "auto" && forcedToolChoiceRejected(text)) {
+          downgrade = true;
+          continue;
+        }
+        const explicit = request.extra && typeof request.extra === "object" && "thinking" in request.extra;
+        if (flippedThinking || explicit || !request.reasoning) throw err;
+        const wrong = thinkingFormRejected(text);
+        if (!wrong) throw err;
+        const used = resolveThinkingForm(request.model ?? this.defaultModel, this.thinkingMode);
+        if (wrong === "enabled" && used !== "budget" || wrong === "adaptive" && used !== "adaptive") throw err;
+        mode = wrong === "enabled" ? "adaptive" : "budget";
+        flippedThinking = true;
+      }
+    }
+  }
   async doFetch(body, signal) {
     const url = `${this.baseURL}/v1/messages`;
     const headers = {
@@ -16496,7 +16858,7 @@ var AnthropicProvider = class extends BaseProvider {
       ...this.defaultHeaders
     };
     const payload = JSON.stringify(body);
-    const res = await this.doFetchWithRetry(() => fetch(url, { method: "POST", headers, body: payload, signal }), signal);
+    const res = await this.doFetchWithRetry(() => this.httpFetch(url, { method: "POST", headers, body: payload, signal }), signal);
     if (!res.ok) {
       const text = await res.text().catch(() => "");
       throw new ProviderError(
@@ -16541,10 +16903,9 @@ var AnthropicProvider = class extends BaseProvider {
       cachedInputTokens: usage.cache_read_input_tokens ?? 0,
       cachedWriteTokens: usage.cache_creation_input_tokens ?? 0,
       cachedOutputTokens: 0,
-      // Anthropic bills thinking tokens inside `output_tokens` and does not
-      // expose a separate count, so reasoningTokens stays 0 here (cost is still
-      // captured via outputTokens). See docs for the limitation.
-      reasoningTokens: 0
+      // Thinking tokens are billed inside `output_tokens`; newer models also
+      // report the split as `output_tokens_details.thinking_tokens`.
+      reasoningTokens: usage.output_tokens_details?.thinking_tokens ?? 0
     };
     return {
       id: json.id ?? "",
@@ -16553,6 +16914,7 @@ var AnthropicProvider = class extends BaseProvider {
       toolCalls,
       usage: tokenUsage,
       finishReason: mapAnthropicStopReason(json.stop_reason),
+      ...typeof json.stop_reason === "string" ? { rawFinishReason: json.stop_reason } : {},
       reasoning: reasoningBlocks.length > 0 ? { blocks: reasoningBlocks, summary: summaryParts.join("\n").trim() || void 0 } : void 0,
       raw: json
     };
@@ -16598,7 +16960,15 @@ var AzureProvider = class extends OpenAIProvider {
       provider: "openai",
       apiKey: config.apiKey,
       defaultModel: config.defaultModel ?? config.deploymentName ?? "gpt-4o",
-      defaultHeaders: config.defaultHeaders
+      defaultHeaders: config.defaultHeaders,
+      retry: config.retry,
+      fetch: config.fetch,
+      timeoutMs: config.timeoutMs,
+      maxTokensParam: config.maxTokensParam,
+      api: config.api,
+      responsesApi: config.responsesApi,
+      responsesApiModels: config.responsesApiModels,
+      responsesStreaming: config.responsesStreaming
     });
     this.providerName = "azure";
     this.endpoint = config.endpoint.replace(/\/$/, "");
@@ -16613,16 +16983,17 @@ var AzureProvider = class extends OpenAIProvider {
     }
     const url = `${this.endpoint}/openai/deployments/${deployment}/chat/completions?api-version=${this.apiVersion}`;
     const { model: _model, ...bodyWithoutModel } = body;
-    const res = await fetch(url, {
+    const payload = JSON.stringify(bodyWithoutModel);
+    const res = await this.doFetchWithRetry(() => this.httpFetch(url, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
         "api-key": this.azureApiKey,
         ...this.defaultHeaders
       },
-      body: JSON.stringify(bodyWithoutModel),
+      body: payload,
       signal
-    });
+    }), signal);
     if (!res.ok) {
       const text = await res.text().catch(() => "");
       throw new ProviderError(
@@ -16634,6 +17005,32 @@ var AzureProvider = class extends OpenAIProvider {
     }
     return res;
   }
+  /** Azure embeddings: the deployment named by the request's model (falling back
+   * to the configured deployment) in the path, api-key auth. */
+  async embeddingsFetch(body, signal) {
+    const deployment = body.model || this.deploymentName;
+    if (!deployment) {
+      throw new ProviderError("Azure embeddings require a deployment name or model", this.providerName, 400);
+    }
+    const url = `${this.endpoint}/openai/deployments/${deployment}/embeddings?api-version=${this.apiVersion}`;
+    const { model: _model, ...bodyWithoutModel } = body;
+    const payload = JSON.stringify(bodyWithoutModel);
+    const res = await this.doFetchWithRetry(() => this.httpFetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "api-key": this.azureApiKey,
+        ...this.defaultHeaders
+      },
+      body: payload,
+      signal
+    }), signal);
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new ProviderError(`Azure OpenAI embeddings API error ${res.status}: ${text}`, this.providerName, res.status, text);
+    }
+    return res;
+  }
   /** Azure exposes the Responses API at /openai/responses with api-key auth.
    * Reasoning summaries require a preview api-version; callers can override via
    * the `apiVersion` config. */
@@ -16645,7 +17042,7 @@ var AzureProvider = class extends OpenAIProvider {
     }
     const url = `${this.endpoint}/openai/responses?api-version=${this.apiVersion}`;
     const payload = JSON.stringify({ ...body, model: deployment });
-    const res = await fetch(url, {
+    const res = await this.doFetchWithRetry(() => this.httpFetch(url, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -16654,7 +17051,7 @@ var AzureProvider = class extends OpenAIProvider {
       },
       body: payload,
       signal
-    });
+    }), signal);
     if (!res.ok) {
       const text = await res.text().catch(() => "");
       throw new ProviderError(
@@ -16690,20 +17087,155 @@ var OpenAICompatibleProvider = class extends OpenAIProvider {
       apiKey: config.apiKey,
       baseURL: config.baseURL,
       defaultModel: config.defaultModel,
-      defaultHeaders: config.defaultHeaders
+      defaultHeaders: config.defaultHeaders,
+      organization: config.organization,
+      retry: config.retry,
+      fetch: config.fetch,
+      timeoutMs: config.timeoutMs,
+      maxTokensParam: config.maxTokensParam,
+      api: config.api,
+      // Unlike OpenAI / Azure, "auto" on a compatible server means Chat
+      // Completions (the 0.11 default): the model name is the operator's.
+      // `responsesApiModels` still applies; `responsesApi: "auto"` opts in.
+      _autoMeansChat: true,
+      responsesApi: config.responsesApi,
+      responsesApiModels: config.responsesApiModels,
+      responsesStreaming: config.responsesStreaming
     });
     this.providerName = "openai-compatible";
   }
 };
 
+// src/providers/utils/eventStream.ts
+var EventStreamError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "EventStreamError";
+  }
+};
+var CRC_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    table[n] = c >>> 0;
+  }
+  return table;
+})();
+function crc32(bytes, start = 0, end = bytes.length) {
+  let c = 4294967295;
+  for (let i = start; i < end; i++) c = CRC_TABLE[(c ^ bytes[i]) & 255] ^ c >>> 8;
+  return (c ^ 4294967295) >>> 0;
+}
+function decodeFrame(frame) {
+  const view = new DataView(frame.buffer, frame.byteOffset, frame.byteLength);
+  const total = view.getUint32(0);
+  const headersLen = view.getUint32(4);
+  if (total !== frame.byteLength) throw new EventStreamError("event-stream frame length mismatch");
+  if (crc32(frame, 0, 8) !== view.getUint32(8)) throw new EventStreamError("event-stream prelude CRC mismatch");
+  if (crc32(frame, 0, total - 4) !== view.getUint32(total - 4)) throw new EventStreamError("event-stream message CRC mismatch");
+  if (12 + headersLen > total - 4) throw new EventStreamError("event-stream headers overflow frame");
+  const headers = {};
+  const td = new TextDecoder();
+  let o = 12;
+  const headersEnd = 12 + headersLen;
+  while (o < headersEnd) {
+    const nameLen = frame[o++];
+    const name = td.decode(frame.subarray(o, o + nameLen));
+    o += nameLen;
+    const type = frame[o++];
+    switch (type) {
+      case 0:
+        headers[name] = true;
+        break;
+      case 1:
+        headers[name] = false;
+        break;
+      case 2:
+        headers[name] = view.getInt8(o);
+        o += 1;
+        break;
+      case 3:
+        headers[name] = view.getInt16(o);
+        o += 2;
+        break;
+      case 4:
+        headers[name] = view.getInt32(o);
+        o += 4;
+        break;
+      case 5:
+        headers[name] = view.getBigInt64(o);
+        o += 8;
+        break;
+      case 6: {
+        const len = view.getUint16(o);
+        o += 2;
+        headers[name] = frame.slice(o, o + len);
+        o += len;
+        break;
+      }
+      case 7: {
+        const len = view.getUint16(o);
+        o += 2;
+        headers[name] = td.decode(frame.subarray(o, o + len));
+        o += len;
+        break;
+      }
+      case 8:
+        headers[name] = view.getBigInt64(o);
+        o += 8;
+        break;
+      case 9:
+        headers[name] = frame.slice(o, o + 16);
+        o += 16;
+        break;
+      default:
+        throw new EventStreamError(`unknown event-stream header type ${type}`);
+    }
+  }
+  return { headers, payload: frame.slice(headersEnd, total - 4) };
+}
+async function* parseEventStream(body, signal) {
+  const reader = body.getReader();
+  let buf = new Uint8Array(0);
+  try {
+    while (true) {
+      if (signal?.aborted) throw abortReason(signal);
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!value?.length) continue;
+      const merged = new Uint8Array(buf.length + value.length);
+      merged.set(buf, 0);
+      merged.set(value, buf.length);
+      buf = merged;
+      while (buf.length >= 12) {
+        const total = new DataView(buf.buffer, buf.byteOffset, buf.byteLength).getUint32(0);
+        if (total < 16) throw new EventStreamError("invalid event-stream frame length");
+        if (buf.length < total) break;
+        yield decodeFrame(buf.subarray(0, total));
+        buf = buf.subarray(total);
+      }
+    }
+    if (buf.length > 0) throw new EventStreamError("event-stream ended inside a frame");
+  } finally {
+    reader.cancel().catch(() => void 0);
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  }
+}
+
 // src/providers/bedrock.ts
 var BedrockProvider = class extends BaseProvider {
   constructor(config) {
     super();
     this.providerName = "bedrock";
+    this.configureTransport(config);
     this.region = config.region;
     this.defaultModel = config.defaultModel ?? "anthropic.claude-sonnet-4-20250514-v1:0";
     this.defaultHeaders = config.defaultHeaders ?? {};
+    this.thinkingMode = config.thinkingMode ?? "auto";
     this.promptCachingEnabled = config.prompt_caching?.enabled === true;
     if (config.retry) this.retryPolicy = { ...this.retryPolicy, ...config.retry };
     this.credentials = {
@@ -16720,25 +17252,202 @@ var BedrockProvider = class extends BaseProvider {
   }
   async complete(request) {
     const modelId = request.model || this.defaultModel;
-    const body = this.buildConverseBody(request);
-    const json = await this.doFetch(modelId, body, request.signal);
-    return this.parseResponse(json, modelId);
+    const res = await this.converseFetch(modelId, request, false);
+    return this.parseResponse(await res.json(), modelId);
   }
+  /**
+   * Real streaming over ConverseStream. The response is an AWS event-stream
+   * (binary frames); each frame carries one JSON event: messageStart,
+   * contentBlockStart/Delta/Stop (text, toolUse, reasoningContent),
+   * messageStop and, last, metadata (usage). Text, tool-call argument and
+   * reasoning deltas are yielded as they arrive; one closing chunk carries the
+   * finish reason, usage and the signed reasoning blocks.
+   */
   async *completeStream(request) {
-    const response = await this.complete(request);
+    const modelId = request.model || this.defaultModel;
+    const res = await this.converseFetch(modelId, request, true);
+    if (!res.body) throw new ProviderError("No response body for stream", this.providerName);
+    const id = res.headers.get("x-amzn-requestid") ?? "";
+    const toolsByIndex = /* @__PURE__ */ new Map();
+    const reasoningByIndex = /* @__PURE__ */ new Map();
+    let finishReason;
+    let rawFinishReason;
+    let toolOrdinal = 0;
+    let usage;
+    for await (const msg of parseEventStream(res.body, request.signal)) {
+      const messageType = String(msg.headers[":message-type"] ?? "event");
+      const eventType = String(msg.headers[":event-type"] ?? msg.headers[":exception-type"] ?? "");
+      let data = {};
+      const text = new TextDecoder().decode(msg.payload);
+      if (text) {
+        try {
+          data = JSON.parse(text);
+        } catch {
+          data = { message: text };
+        }
+      }
+      if (messageType === "exception" || messageType === "error") {
+        const code = String(msg.headers[":exception-type"] ?? msg.headers[":error-code"] ?? eventType);
+        throw new ProviderError(
+          `Bedrock stream error ${code}: ${data.message ?? text}`,
+          this.providerName,
+          bedrockExceptionStatus(code),
+          data
+        );
+      }
+      switch (eventType) {
+        case "contentBlockStart": {
+          const idx = data.contentBlockIndex ?? 0;
+          const tu = data.start?.toolUse;
+          if (tu) {
+            const ordinal = toolOrdinal++;
+            toolsByIndex.set(idx, { id: tu.toolUseId ?? "", name: tu.name ?? "", ordinal });
+            yield { id, model: modelId, delta: { toolCalls: [{ id: tu.toolUseId, name: tu.name, arguments: "", index: ordinal }] } };
+          }
+          break;
+        }
+        case "contentBlockDelta": {
+          const idx = data.contentBlockIndex ?? 0;
+          const d = data.delta ?? {};
+          if (typeof d.text === "string" && d.text) {
+            yield { id, model: modelId, delta: { content: d.text } };
+          } else if (d.toolUse) {
+            const tc = toolsByIndex.get(idx);
+            if (tc && typeof d.toolUse.input === "string" && d.toolUse.input) {
+              yield { id, model: modelId, delta: { toolCalls: [{ id: tc.id, name: tc.name, arguments: d.toolUse.input, index: tc.ordinal }] } };
+            }
+          } else if (d.reasoningContent) {
+            const rc = d.reasoningContent;
+            const blk = reasoningByIndex.get(idx) ?? { type: "thinking", text: "" };
+            if (typeof rc.text === "string" && rc.text) {
+              blk.text = (blk.text ?? "") + rc.text;
+              reasoningByIndex.set(idx, blk);
+              yield { id, model: modelId, delta: { reasoning: { summary: rc.text } } };
+            }
+            if (typeof rc.signature === "string" && rc.signature) {
+              blk.signature = (blk.signature ?? "") + rc.signature;
+              reasoningByIndex.set(idx, blk);
+            }
+            if (rc.redactedContent) {
+              reasoningByIndex.set(idx, { type: "redacted_thinking", data: rc.redactedContent });
+            }
+          }
+          break;
+        }
+        case "messageStop":
+          finishReason = mapBedrockStopReason(data.stopReason);
+          if (typeof data.stopReason === "string") rawFinishReason = data.stopReason;
+          break;
+        case "metadata": {
+          const u = data.usage ?? {};
+          usage = {
+            inputTokens: u.inputTokens ?? 0,
+            outputTokens: u.outputTokens ?? 0,
+            totalTokens: u.totalTokens ?? (u.inputTokens ?? 0) + (u.outputTokens ?? 0),
+            cachedInputTokens: u.cacheReadInputTokens ?? u.cacheReadInputTokenCount ?? 0,
+            cachedWriteTokens: u.cacheWriteInputTokens ?? u.cacheWriteInputTokenCount ?? 0,
+            cachedOutputTokens: 0,
+            reasoningTokens: 0
+          };
+          break;
+        }
+      }
+    }
+    const blocks = [...reasoningByIndex.values()].filter(
+      (b) => b.type === "thinking" && b.signature || b.type === "redacted_thinking" && b.data
+    );
     yield {
-      id: response.id,
-      model: response.model,
-      delta: {
-        content: response.content ?? void 0,
-        toolCalls: response.toolCalls.length > 0 ? response.toolCalls : void 0
-      },
-      usage: response.usage,
-      finishReason: response.finishReason
+      id,
+      model: modelId,
+      delta: blocks.length > 0 ? { reasoning: { blocks } } : {},
+      finishReason: finishReason ?? "stop",
+      ...rawFinishReason ? { rawFinishReason } : {},
+      usage
     };
   }
+  // ─── Embeddings ──────────────────────────────────────────────────────────
+  /**
+   * InvokeModel embeddings. Supported families (by model id, inference-profile
+   * prefixes such as `us.` allowed):
+   *  - Amazon Titan Text Embeddings (v1, v2): one text per call, `dimensions`
+   *    (v2: 256/512/1024) and `normalize` via `extra`.
+   *  - Cohere Embed (v3, v4): a batch of texts per call (default 96), `inputType`
+   *    maps to `input_type`, `dimensions` to `output_dimension` (v4).
+   */
+  async embed(request) {
+    const model = requireEmbeddingModel(this.providerName, request.model);
+    const id = model.toLowerCase();
+    const raw = [];
+    let inputTokens = 0;
+    let vectors = [];
+    if (id.includes("titan-embed")) {
+      const results = await mapWithConcurrency(request.input, 4, async (text) => {
+        const body = { inputText: text };
+        if (request.dimensions != null && !id.includes("titan-embed-text-v1")) body.dimensions = request.dimensions;
+        if (request.extra) Object.assign(body, request.extra);
+        const res = await this.invokeModel(model, body, request.signal);
+        const json = await res.json();
+        return { json, tokens: json.inputTextTokenCount ?? Number(res.headers.get("x-amzn-bedrock-input-token-count") ?? 0) };
+      }, request.signal);
+      for (const r of results) {
+        raw.push(r.json);
+        inputTokens += r.tokens || 0;
+        vectors.push(r.json.embedding ?? r.json.embeddingsByType?.float);
+      }
+    } else if (id.includes("cohere.embed")) {
+      for (const batch of chunkArray(request.input, request.batchSize ?? 96)) {
+        const body = {
+          texts: batch,
+          input_type: request.inputType ?? "search_document",
+          embedding_types: ["float"]
+        };
+        if (request.dimensions != null) body.output_dimension = request.dimensions;
+        if (request.extra) Object.assign(body, request.extra);
+        const res = await this.invokeModel(model, body, request.signal);
+        const json = await res.json();
+        raw.push(json);
+        const emb = Array.isArray(json.embeddings) ? json.embeddings : json.embeddings?.float;
+        vectors.push(...emb ?? []);
+        inputTokens += Number(res.headers.get("x-amzn-bedrock-input-token-count") ?? 0) || 0;
+      }
+    } else {
+      throw new ProviderError(
+        `Bedrock embeddings are supported for Amazon Titan and Cohere Embed models, not "${model}"`,
+        this.providerName,
+        400
+      );
+    }
+    assertVectorCount(this.providerName, vectors, request.input.length);
+    return { model, vectors, usage: { inputTokens, totalTokens: inputTokens }, raw };
+  }
+  async invokeModel(modelId, body, signal) {
+    const host = `bedrock-runtime.${this.region}.amazonaws.com`;
+    const url = `https://${host}/model/${encodeURIComponent(modelId)}/invoke`;
+    const bodyStr = JSON.stringify(body);
+    const res = await this.doFetchWithRetry(() => {
+      const headers = signRequest({
+        method: "POST",
+        url,
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          ...this.defaultHeaders
+        },
+        body: bodyStr,
+        region: this.region,
+        service: "bedrock",
+        credentials: this.credentials
+      });
+      return this.httpFetch(url, { method: "POST", headers, body: bodyStr, signal });
+    }, signal);
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new ProviderError(`Bedrock API error ${res.status}: ${text}`, this.providerName, res.status, text);
+    }
+    return res;
+  }
   // ─── Internals ───────────────────────────────────────────────────────────
-  buildConverseBody(request) {
+  buildConverseBody(request, downgradeToolChoice = false) {
     const { system, messages } = this.splitSystemMessages(request.messages);
     const body = {
       messages: this.toBedrockMessages(messages)
@@ -16762,8 +17471,9 @@ var BedrockProvider = class extends BaseProvider {
       body.toolConfig = {
         tools
       };
+      const forceOk = !downgradeToolChoice && supportsForcedToolChoice(request.model || this.defaultModel);
       if (request.toolChoice != null) {
-        if (request.toolChoice === "auto") {
+        if (request.toolChoice === "auto" || !forceOk && request.toolChoice !== "none") {
           body.toolConfig.toolChoice = { auto: {} };
         } else if (request.toolChoice === "required") {
           body.toolConfig.toolChoice = { any: {} };
@@ -16773,9 +17483,17 @@ var BedrockProvider = class extends BaseProvider {
       }
     }
     if (request.extra) {
-      Object.assign(body, request.extra);
+      const fields = { ...request.extra.additionalModelRequestFields ?? {} };
+      const topLevel = { ...request.extra.__top ?? {} };
+      for (const [key, value] of Object.entries(request.extra)) {
+        if (key === "additionalModelRequestFields" || key === "__top") continue;
+        if (CONVERSE_TOP_LEVEL_FIELDS.has(key)) body[key] = value;
+        else fields[key] = value;
+      }
+      Object.assign(body, topLevel);
+      if (Object.keys(fields).length > 0) body.additionalModelRequestFields = fields;
     }
-    applyBedrockReasoning(body, request.reasoning);
+    applyBedrockReasoning(body, request.reasoning, { model: request.model || this.defaultModel, mode: this.thinkingMode });
     return body;
   }
   splitSystemMessages(messages) {
@@ -16898,9 +17616,22 @@ var BedrockProvider = class extends BaseProvider {
       }
     };
   }
-  async doFetch(modelId, body, signal) {
+  /** Sends the Converse call; retries once with toolChoice auto when the
+   * model rejects forced tool use. */
+  async converseFetch(modelId, request, stream) {
+    const body = this.buildConverseBody(request);
+    try {
+      return await this.doFetch(modelId, body, request.signal, stream);
+    } catch (err) {
+      const tc = body.toolConfig?.toolChoice;
+      if (!(err instanceof ProviderError) || err.statusCode !== 400 || !tc || tc.auto) throw err;
+      if (!forcedToolChoiceRejected(String(err.responseBody ?? err.message))) throw err;
+      return this.doFetch(modelId, this.buildConverseBody(request, true), request.signal, stream);
+    }
+  }
+  async doFetch(modelId, body, signal, stream) {
     const host = `bedrock-runtime.${this.region}.amazonaws.com`;
-    const url = `https://${host}/model/${encodeURIComponent(modelId)}/converse`;
+    const url = `https://${host}/model/${encodeURIComponent(modelId)}/${stream ? "converse-stream" : "converse"}`;
     const bodyStr = JSON.stringify(body);
     const res = await this.doFetchWithRetry(() => {
       const headers = signRequest({
@@ -16908,7 +17639,7 @@ var BedrockProvider = class extends BaseProvider {
         url,
         headers: {
           "Content-Type": "application/json",
-          Accept: "application/json",
+          Accept: stream ? "application/vnd.amazon.eventstream" : "application/json",
           ...this.defaultHeaders
         },
         body: bodyStr,
@@ -16916,7 +17647,7 @@ var BedrockProvider = class extends BaseProvider {
         service: "bedrock",
         credentials: this.credentials
       });
-      return fetch(url, { method: "POST", headers, body: bodyStr, signal });
+      return this.httpFetch(url, { method: "POST", headers, body: bodyStr, signal });
     }, signal);
     if (!res.ok) {
       const text = await res.text().catch(() => "");
@@ -16927,7 +17658,7 @@ var BedrockProvider = class extends BaseProvider {
         text
       );
     }
-    return res.json();
+    return res;
   }
   parseResponse(json, modelId) {
     const output = json.output?.message;
@@ -16963,8 +17694,8 @@ var BedrockProvider = class extends BaseProvider {
       inputTokens: usage.inputTokens ?? 0,
       outputTokens: usage.outputTokens ?? 0,
       totalTokens: usage.totalTokens ?? (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0),
-      cachedInputTokens: usage.cacheReadInputTokenCount ?? 0,
-      cachedWriteTokens: usage.cacheWriteInputTokenCount ?? 0,
+      cachedInputTokens: usage.cacheReadInputTokens ?? usage.cacheReadInputTokenCount ?? 0,
+      cachedWriteTokens: usage.cacheWriteInputTokens ?? usage.cacheWriteInputTokenCount ?? 0,
       cachedOutputTokens: 0,
       // Bedrock bills thinking tokens inside outputTokens; no separate count.
       reasoningTokens: 0
@@ -16976,11 +17707,26 @@ var BedrockProvider = class extends BaseProvider {
       toolCalls,
       usage: tokenUsage,
       finishReason: mapBedrockStopReason(json.stopReason),
+      ...typeof json.stopReason === "string" ? { rawFinishReason: json.stopReason } : {},
       reasoning: reasoningBlocks.length > 0 ? { blocks: reasoningBlocks, summary: summaryParts.join("\n").trim() || void 0 } : void 0,
       raw: json
     };
   }
 };
+var CONVERSE_TOP_LEVEL_FIELDS = /* @__PURE__ */ new Set([
+  "messages",
+  "system",
+  "inferenceConfig",
+  "toolConfig",
+  "guardrailConfig",
+  "additionalModelRequestFields",
+  "additionalModelResponseFieldPaths",
+  "promptVariables",
+  "requestMetadata",
+  "performanceConfig",
+  "serviceTier",
+  "outputConfig"
+]);
 function appendBedrockReasoning(content, blocks) {
   if (!blocks?.length) return;
   for (const b of blocks) {
@@ -16995,6 +17741,23 @@ function appendBedrockReasoning(content, blocks) {
     }
   }
 }
+function bedrockExceptionStatus(code) {
+  switch (code) {
+    case "throttlingException":
+      return 429;
+    case "validationException":
+      return 400;
+    case "modelTimeoutException":
+      return 408;
+    case "serviceUnavailableException":
+      return 503;
+    case "internalServerException":
+    case "modelStreamErrorException":
+      return 500;
+    default:
+      return void 0;
+  }
+}
 function mapBedrockStopReason(reason) {
   switch (reason) {
     case "end_turn":
@@ -17003,8 +17766,10 @@ function mapBedrockStopReason(reason) {
     case "tool_use":
       return "tool_calls";
     case "max_tokens":
+    case "model_context_window_exceeded":
       return "length";
     case "content_filtered":
+    case "guardrail_intervened":
     case "guardrail":
       return "content_filter";
     default:
@@ -17034,10 +17799,12 @@ var VertexProvider = class extends BaseProvider {
     super();
     this.providerName = "vertex";
     this.tokenExpiry = 0;
+    this.configureTransport(config);
     this.projectId = config.projectId;
     this.location = config.location ?? "us-central1";
     this.defaultModel = config.defaultModel ?? "gemini-2.0-flash";
     this.defaultHeaders = config.defaultHeaders ?? {};
+    if (config.retry) this.retryPolicy = { ...this.retryPolicy, ...config.retry };
     if (config.accessToken) {
       this.accessToken = config.accessToken;
       this.tokenExpiry = Date.now() + 36e5;
@@ -17060,6 +17827,7 @@ var VertexProvider = class extends BaseProvider {
     const url = this.buildUrl(modelId, true);
     const res = await this.doFetch(url, body, request.signal);
     if (!res.body) throw new ProviderError("No response body for stream", this.providerName);
+    const counter = { next: 0 };
     const contentType = res.headers.get("content-type") ?? "";
     if (contentType.includes("text/event-stream")) {
       for await (const event of parseSSEStream(res.body, request.signal)) {
@@ -17070,7 +17838,7 @@ var VertexProvider = class extends BaseProvider {
         } catch {
           continue;
         }
-        yield this.parseStreamChunk(chunk, modelId);
+        yield this.parseStreamChunk(chunk, modelId, counter);
       }
     } else {
       const reader = res.body.getReader();
@@ -17088,7 +17856,7 @@ var VertexProvider = class extends BaseProvider {
             if (!trimmed || trimmed === "[" || trimmed === "]") continue;
             try {
               const chunk = JSON.parse(trimmed);
-              yield this.parseStreamChunk(chunk, modelId);
+              yield this.parseStreamChunk(chunk, modelId, counter);
             } catch {
               buffer = line + "\n" + buffer;
               break;
@@ -17099,7 +17867,7 @@ var VertexProvider = class extends BaseProvider {
         if (remaining && remaining !== "[" && remaining !== "]") {
           try {
             const chunk = JSON.parse(remaining);
-            yield this.parseStreamChunk(chunk, modelId);
+            yield this.parseStreamChunk(chunk, modelId, counter);
           } catch {
           }
         }
@@ -17110,6 +17878,48 @@ var VertexProvider = class extends BaseProvider {
     }
   }
   // ─── Internals ───────────────────────────────────────────────────────────
+  /**
+   * Vertex `:predict` embeddings (text-embedding-00x, text-multilingual-embedding,
+   * gemini-embedding-001). `inputType` maps to the task type; `dimensions` to
+   * `outputDimensionality`. gemini-embedding takes one instance per request, the
+   * text-embedding models up to `batchSize` (default 100).
+   */
+  async embed(request) {
+    const model = requireEmbeddingModel(this.providerName, request.model);
+    const perRequest = request.batchSize ?? (/gemini-embedding/i.test(model) ? 1 : 100);
+    const url = `https://${this.location}-aiplatform.googleapis.com/v1/projects/${this.projectId}/locations/${this.location}/publishers/google/models/${model}:predict`;
+    const taskType = request.inputType ? Object.prototype.hasOwnProperty.call(GEMINI_TASK_TYPES, request.inputType) ? GEMINI_TASK_TYPES[request.inputType] : request.inputType.toUpperCase() : void 0;
+    const vectors = [];
+    const raw = [];
+    let inputTokens = 0;
+    for (const batch of chunkArray(request.input, perRequest)) {
+      const body = {
+        instances: batch.map((content) => ({ content, ...taskType ? { task_type: taskType } : {} }))
+      };
+      const { parameters: extraParameters, ...extraRest } = request.extra ?? {};
+      const parameters = {
+        ...request.dimensions != null ? { outputDimensionality: request.dimensions } : {},
+        // Caller-supplied parameters are merged in, not replacing the above (an
+        // explicit extra.parameters.outputDimensionality still wins).
+        ...extraParameters && typeof extraParameters === "object" ? extraParameters : {}
+      };
+      if (Object.keys(parameters).length > 0) body.parameters = parameters;
+      Object.assign(body, extraRest);
+      const res = await this.doFetch(url, body, request.signal);
+      const json = await res.json();
+      raw.push(json);
+      for (const p of json.predictions ?? []) {
+        const values = p.embeddings?.values;
+        if (!Array.isArray(values)) {
+          throw new ProviderError("Vertex embeddings response has a prediction without an embeddings.values array", this.providerName, void 0, json);
+        }
+        vectors.push(values);
+        inputTokens += p.embeddings?.statistics?.token_count ?? 0;
+      }
+    }
+    assertVectorCount(this.providerName, vectors, request.input.length);
+    return { model, vectors, usage: { inputTokens, totalTokens: inputTokens }, raw };
+  }
   buildUrl(modelId, stream) {
     const base = `https://${this.location}-aiplatform.googleapis.com/v1`;
     const path2 = `projects/${this.projectId}/locations/${this.location}/publishers/google/models/${modelId}`;
@@ -17207,7 +18017,9 @@ var VertexProvider = class extends BaseProvider {
           functionCall: {
             name: tc.name,
             args: safeJsonParse3(tc.arguments)
-          }
+          },
+          // Gemini 3 requires the signature of each functionCall echoed back.
+          ...tc.thoughtSignature ? { thoughtSignature: tc.thoughtSignature } : {}
         });
       }
       return { role: "model", parts: parts2 };
@@ -17304,7 +18116,7 @@ var VertexProvider = class extends BaseProvider {
     sign.update(signingInput);
     const signature = sign.sign(sa.private_key, "base64url");
     const jwt = `${signingInput}.${signature}`;
-    const tokenRes = await fetch("https://oauth2.googleapis.com/token", {
+    const tokenRes = await this.httpFetch("https://oauth2.googleapis.com/token", {
       method: "POST",
       headers: { "Content-Type": "application/x-www-form-urlencoded" },
       body: `grant_type=urn:ietf:params:oauth:grant-type:jwt-bearer&assertion=${jwt}`
@@ -17318,16 +18130,20 @@ var VertexProvider = class extends BaseProvider {
   }
   async doFetch(url, body, signal) {
     const token = await this.getAccessToken();
-    const res = await fetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${token}`,
-        ...this.defaultHeaders
-      },
-      body: JSON.stringify(body),
+    const bodyStr = JSON.stringify(body);
+    const res = await this.doFetchWithRetry(
+      () => this.httpFetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${token}`,
+          ...this.defaultHeaders
+        },
+        body: bodyStr,
+        signal
+      }),
       signal
-    });
+    );
     if (!res.ok) {
       const text = await res.text().catch(() => "");
       throw new ProviderError(
@@ -17357,7 +18173,8 @@ var VertexProvider = class extends BaseProvider {
         toolCalls.push({
           id: `call_${toolCallIdx++}`,
           name: part.functionCall.name,
-          arguments: JSON.stringify(part.functionCall.args ?? {})
+          arguments: JSON.stringify(part.functionCall.args ?? {}),
+          ...part.thoughtSignature ? { thoughtSignature: part.thoughtSignature } : {}
         });
       }
     }
@@ -17378,11 +18195,12 @@ var VertexProvider = class extends BaseProvider {
       toolCalls,
       usage: tokenUsage,
       finishReason: mapGeminiFinishReason(candidate?.finishReason),
+      ...typeof candidate?.finishReason === "string" ? { rawFinishReason: candidate.finishReason } : {},
       reasoning: thoughtParts.length > 0 ? { summary: thoughtParts.join("\n").trim() || void 0 } : void 0,
       raw: json
     };
   }
-  parseStreamChunk(chunk, modelId) {
+  parseStreamChunk(chunk, modelId, counter) {
     const candidate = chunk.candidates?.[0];
     const parts = candidate?.content?.parts ?? [];
     const delta = {};
@@ -17396,9 +18214,12 @@ var VertexProvider = class extends BaseProvider {
       } else if (part.functionCall) {
         if (!delta.toolCalls) delta.toolCalls = [];
         delta.toolCalls.push({
-          id: `call_${delta.toolCalls.length}`,
+          // Unique across the whole stream: the adapter merges chunks by id.
+          id: `call_${counter.next}`,
+          index: counter.next++,
           name: part.functionCall.name,
-          arguments: JSON.stringify(part.functionCall.args ?? {})
+          arguments: JSON.stringify(part.functionCall.args ?? {}),
+          ...part.thoughtSignature ? { thoughtSignature: part.thoughtSignature } : {}
         });
       }
     }
@@ -17420,10 +18241,21 @@ var VertexProvider = class extends BaseProvider {
       model: modelId,
       delta,
       usage,
-      finishReason: mapGeminiFinishReason(candidate?.finishReason)
+      finishReason: mapGeminiFinishReason(candidate?.finishReason),
+      ...typeof candidate?.finishReason === "string" ? { rawFinishReason: candidate.finishReason } : {}
     };
   }
 };
+var GEMINI_TASK_TYPES = {
+  search_document: "RETRIEVAL_DOCUMENT",
+  search_query: "RETRIEVAL_QUERY",
+  classification: "CLASSIFICATION",
+  clustering: "CLUSTERING",
+  semantic_similarity: "SEMANTIC_SIMILARITY",
+  question_answering: "QUESTION_ANSWERING",
+  fact_verification: "FACT_VERIFICATION",
+  code_retrieval_query: "CODE_RETRIEVAL_QUERY"
+};
 function mapGeminiFinishReason(reason) {
   switch (reason) {
     case "STOP":
@@ -17667,7 +18499,9 @@ exports.sessionMetrics = sessionMetrics;
 exports.setTokenCounter = setTokenCounter;
 exports.startStreamingSession = startStreamingSession;
 exports.summarizeObject = summarizeObject;
+exports.supportsAdaptiveThinking = supportsAdaptiveThinking;
 exports.textFromContent = textFromContent;
+exports.toMessageUsage = toMessageUsage;
 exports.toStrictCompatible = toStrictCompatible;
 exports.toStrictToolSchema = toStrictToolSchema;
 exports.tokenize = tokenize;