@cognipeer/agent-sdk 0.10.6 → 0.13.0

package/dist/index.mjs

@@ -2431,6 +2431,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;
@@ -2440,8 +2449,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 {
@@ -2451,33 +2461,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 } : {}
                   });
                 }
               }
@@ -2488,8 +2511,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 {
@@ -2503,6 +2536,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,
@@ -2510,6 +2548,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;
@@ -2562,7 +2604,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;
@@ -2836,29 +2879,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
     }
@@ -2867,7 +2897,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)) {
@@ -2881,32 +2912,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;
@@ -2939,8 +2953,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":
@@ -4646,6 +4660,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) {
@@ -5077,10 +5095,10 @@ function createToolsNode(initialTools, opts) {
       const toolCallId = tc.id || `${tc.name}_${toolCount + 1}`;
       const validatedArgs = validateToolArgs(tool, args);
       if (!validatedArgs.ok && resolved.toolResponses.schemaValidation === "strict") {
-        const errorMessage = `Tool argument validation failed for ${tc.name}: ${validatedArgs.message}`;
-        push({ role: "tool", content: errorMessage, tool_call_id: toolCallId, name: tc.name });
-        markToolFailure(errorMessage, tc.name, toolCallId);
-        onEvent?.({ type: "tool_call", phase: "error", name: tc.name, id: tc.id, args, error: { message: errorMessage } });
+        const errorMessage2 = `Tool argument validation failed for ${tc.name}: ${validatedArgs.message}`;
+        push({ role: "tool", content: errorMessage2, tool_call_id: toolCallId, name: tc.name });
+        markToolFailure(errorMessage2, tc.name, toolCallId);
+        onEvent?.({ type: "tool_call", phase: "error", name: tc.name, id: tc.id, args, error: { message: errorMessage2 } });
         toolCount += 1;
         return { status: "error" };
       }
@@ -6091,7 +6109,7 @@ var LEVEL_DEFAULTS = {
 };
 var VALID_LEVELS = ["minimal", "low", "medium", "high"];
 var VALID_CADENCES = ["off", "every_turn", "after_tool", "on_branch", "initial_then_after_tool"];
-var VALID_EFFORTS = ["none", "minimal", "low", "medium", "high"];
+var VALID_EFFORTS = ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
 function validateReasoningConfig(input) {
   if (!input) return;
   if (input.level !== void 0 && !VALID_LEVELS.includes(input.level)) {
@@ -11526,6 +11544,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,
@@ -11536,6 +11576,56 @@ var BaseProvider = class {
   constructor() {
     this.retryPolicy = DEFAULT_RETRY;
   }
+  /** Applies the transport options shared by every provider config. */
+  configureTransport(config) {
+    this.fetchImpl = config.fetch;
+    this.onModelRuleLearned = config.onModelRuleLearned;
+    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
@@ -11577,34 +11667,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;
@@ -11620,7 +11689,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",
@@ -13856,12 +13925,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,
@@ -15178,98 +15247,805 @@ 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;
-      }
+// src/models/model-rules.json
+var model_rules_default = {
+  version: 1,
+  effortLadder: [
+    "none",
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max"
+  ],
+  budgets: {
+    minimal: 1024,
+    low: 2048,
+    medium: 8192,
+    high: 16384,
+    xhigh: 24576,
+    max: 32768
+  },
+  geminiBudgets: {
+    minimal: 512,
+    low: 1024,
+    medium: 4096,
+    high: 12e3,
+    xhigh: 24576,
+    max: 24576
+  },
+  rules: [
+    {
+      id: "openai-chat-models",
+      family: "openai",
+      match: "^(?:chatgpt|gpt-[\\d.]+[a-z0-9.-]*?-chat)",
+      reasoning: {
+        style: "none",
+        efforts: [],
+        off: null
+      },
+      sampling: {
+        temperature: "any",
+        topP: true,
+        topK: true,
+        penalties: true,
+        logprobs: true
+      },
+      maxTokensParam: "max_completion_tokens",
+      chatTools: {
+        reasoning: "any"
+      },
+      source: "docs",
+      note: "Chat-tuned *-chat variants are not reasoning models: ordinary sampling, no reasoning field."
+    },
+    {
+      id: "openai-gpt-6-plus",
+      family: "openai",
+      match: "^gpt-?(?:[6-9]|(?!35(?!\\d))[1-9]\\d+)(?:[.-]|$)",
+      reasoning: {
+        style: "effort",
+        efforts: [
+          "none",
+          "low",
+          "medium",
+          "high",
+          "xhigh"
+        ],
+        off: "none",
+        responsesEfforts: [
+          "none",
+          "low",
+          "medium",
+          "high",
+          "xhigh",
+          "max"
+        ]
+      },
+      sampling: {
+        temperature: "default-only",
+        topP: false,
+        topK: false,
+        penalties: false,
+        logprobs: false
+      },
+      maxTokensParam: "max_completion_tokens",
+      chatTools: {
+        reasoning: "force-none"
+      },
+      source: "verified-2026-10-14",
+      note: "gpt-N, N>=6. Chat Completions takes none/low/medium/high/xhigh (minimal and max are 400s); Responses also takes max. Function tools with an effort other than none are a 400 on Chat Completions and the default effort is not none, so none is sent explicitly. Rejects max_tokens, temperature != 1, top_p, penalties, logprobs."
+    },
+    {
+      id: "openai-gpt-5x",
+      family: "openai",
+      match: "^gpt-?5\\.[1-9]",
+      reasoning: {
+        style: "effort",
+        efforts: [
+          "none",
+          "low",
+          "medium",
+          "high",
+          "xhigh"
+        ],
+        off: "none",
+        responsesEfforts: [
+          "none",
+          "low",
+          "medium",
+          "high",
+          "xhigh",
+          "max"
+        ]
+      },
+      sampling: {
+        temperature: "default-only",
+        topP: false,
+        topK: false,
+        penalties: false,
+        logprobs: false
+      },
+      maxTokensParam: "max_completion_tokens",
+      chatTools: {
+        reasoning: "force-none"
+      },
+      source: "verified-2026-10-14",
+      note: "gpt-5.1 and newer 5.x. Same wire rules as gpt-6: no minimal/max on Chat Completions (Responses takes max), function tools need reasoning_effort none on Chat Completions."
+    },
+    {
+      id: "openai-gpt-5-base",
+      family: "openai",
+      match: "^gpt-?5(?![.\\d])",
+      reasoning: {
+        style: "effort",
+        efforts: [
+          "minimal",
+          "low",
+          "medium",
+          "high"
+        ],
+        off: null
+      },
+      sampling: {
+        temperature: "default-only",
+        topP: false,
+        topK: false,
+        penalties: false,
+        logprobs: false
+      },
+      maxTokensParam: "max_completion_tokens",
+      chatTools: {
+        reasoning: "any"
+      },
+      source: "docs",
+      note: "gpt-5, -mini, -nano, -codex: minimal/low/medium/high, reasoning cannot be turned off (none maps to minimal)."
+    },
+    {
+      id: "openai-o-series",
+      family: "openai",
+      match: "^o[1-9]\\d?(?![a-z0-9])",
+      reasoning: {
+        style: "effort",
+        efforts: [
+          "low",
+          "medium",
+          "high"
+        ],
+        off: null
+      },
+      sampling: {
+        temperature: "default-only",
+        topP: false,
+        topK: false,
+        penalties: false,
+        logprobs: false
+      },
+      maxTokensParam: "max_completion_tokens",
+      chatTools: {
+        reasoning: "any"
+      },
+      source: "docs",
+      note: "o1/o3/o4 family: low/medium/high, no sampling overrides."
+    },
+    {
+      id: "openai-gpt-oss",
+      family: "openai",
+      match: "^gpt-?oss",
+      reasoning: {
+        style: "effort",
+        efforts: [
+          "low",
+          "medium",
+          "high"
+        ],
+        off: null
+      },
+      sampling: {
+        temperature: "any",
+        topP: true,
+        topK: true,
+        penalties: true,
+        logprobs: true
+      },
+      maxTokensParam: "max_tokens",
+      chatTools: {
+        reasoning: "any"
+      },
+      source: "docs",
+      note: "Open-weight gpt-oss: low/medium/high; sampling and max_tokens behave like an ordinary chat model."
+    },
+    {
+      id: "openai-legacy-gpt",
+      family: "openai",
+      match: "^(?:gpt-?(?:[0-4]|35)(?![0-9])|text-|davinci|babbage)",
+      reasoning: {
+        style: "none",
+        efforts: [],
+        off: null
+      },
+      sampling: {
+        temperature: "any",
+        topP: true,
+        topK: true,
+        penalties: true,
+        logprobs: true
+      },
+      maxTokensParam: "max_tokens",
+      chatTools: {
+        reasoning: "any"
+      },
+      source: "docs",
+      note: "gpt-4o, gpt-4.1, gpt-3.5 and older: no reasoning, ordinary sampling."
+    },
+    {
+      id: "openai-compatible-toggle",
+      family: "openai",
+      match: "^(?:deepseek-(?:r\\d|reasoner)|qwq|qwen-?3)",
+      reasoning: {
+        style: "toggle",
+        efforts: [
+          "none",
+          "minimal",
+          "low",
+          "medium",
+          "high",
+          "xhigh",
+          "max"
+        ],
+        off: "none"
+      },
+      sampling: {
+        temperature: "any",
+        topP: true,
+        topK: true,
+        penalties: true,
+        logprobs: true
+      },
+      maxTokensParam: "max_tokens",
+      chatTools: {
+        reasoning: "any"
+      },
+      source: "docs",
+      note: "DeepSeek R/reasoner, QwQ, Qwen3: on/off style hosts. The effort is forwarded as-is (including none, which switches thinking off on thinking-by-default models)."
+    },
+    {
+      id: "openai-default",
+      family: "openai",
+      match: ".*",
+      reasoning: {
+        style: "effort",
+        efforts: [
+          "none",
+          "minimal",
+          "low",
+          "medium",
+          "high",
+          "xhigh",
+          "max"
+        ],
+        off: "none"
+      },
+      sampling: {
+        temperature: "any",
+        topP: true,
+        topK: true,
+        penalties: true,
+        logprobs: true
+      },
+      maxTokensParam: "max_tokens",
+      chatTools: {
+        reasoning: "any"
+      },
+      source: "docs",
+      note: "Permissive default for unknown OpenAI-wire models: pass what the caller asked; the provider learns from 400s."
+    },
+    {
+      id: "claude-haiku-5",
+      family: "anthropic",
+      match: "^claude-(?:haiku-5|5(?:-\\d+)?-haiku)(?!\\d)",
+      reasoning: {
+        style: "adaptive",
+        efforts: [
+          "low",
+          "medium",
+          "high",
+          "xhigh",
+          "max"
+        ],
+        off: "disabled"
+      },
+      sampling: {
+        temperature: "unsupported",
+        topP: false,
+        topK: false,
+        penalties: false,
+        logprobs: false
+      },
+      maxTokensParam: "max_tokens",
+      chatTools: {
+        reasoning: "any"
+      },
+      source: "verified-2026-10-14",
+      note: "Claude Haiku 5.x: thinking:{type:adaptive} + output_config.effort; thinking:{type:enabled,budget_tokens} is rejected. Off = thinking:{type:disabled}. Sampling params are rejected."
+    },
+    {
+      id: "claude-sonnet-5",
+      family: "anthropic",
+      match: "^claude-(?:sonnet-5|5(?:-\\d+)?-sonnet)(?!\\d)",
+      reasoning: {
+        style: "adaptive",
+        efforts: [
+          "low",
+          "medium",
+          "high",
+          "xhigh",
+          "max"
+        ],
+        off: "between_tools"
+      },
+      sampling: {
+        temperature: "unsupported",
+        topP: false,
+        topK: false,
+        penalties: false,
+        logprobs: false
+      },
+      maxTokensParam: "max_tokens",
+      chatTools: {
+        reasoning: "any"
+      },
+      source: "verified-2026-10-14",
+      note: "Claude Sonnet 5.x: adaptive + output_config.effort. thinking:{type:disabled} is rejected; off = thinking:{type:between_tools}. Sampling params are rejected."
+    },
+    {
+      id: "claude-opus-5",
+      family: "anthropic",
+      match: "^claude-(?:opus-5|5(?:-\\d+)?-opus)(?!\\d)",
+      reasoning: {
+        style: "adaptive",
+        efforts: [
+          "low",
+          "medium",
+          "high",
+          "xhigh",
+          "max"
+        ],
+        off: null
+      },
+      sampling: {
+        temperature: "unsupported",
+        topP: false,
+        topK: false,
+        penalties: false,
+        logprobs: false
+      },
+      maxTokensParam: "max_tokens",
+      chatTools: {
+        reasoning: "any"
+      },
+      source: "verified-2026-10-14",
+      note: "Claude Opus 5.x: adaptive + output_config.effort; thinking cannot be turned off (none maps to the lowest effort). Sampling params are rejected."
+    },
+    {
+      id: "claude-fable",
+      family: "anthropic",
+      match: "^claude-fable",
+      reasoning: {
+        style: "adaptive",
+        efforts: [
+          "low",
+          "medium",
+          "high",
+          "xhigh",
+          "max"
+        ],
+        off: null
+      },
+      sampling: {
+        temperature: "unsupported",
+        topP: false,
+        topK: false,
+        penalties: false,
+        logprobs: false
+      },
+      maxTokensParam: "max_tokens",
+      chatTools: {
+        reasoning: "any"
+      },
+      source: "docs",
+      note: "Claude Fable line: treated like the 5.x adaptive models."
+    },
+    {
+      id: "claude-4-7",
+      family: "anthropic",
+      match: "^claude-(?:(?:opus|sonnet|haiku)-4[-.]7|4[-.]7-(?:opus|sonnet|haiku))(?!\\d)",
+      reasoning: {
+        style: "adaptive",
+        efforts: [
+          "low",
+          "medium",
+          "high",
+          "xhigh",
+          "max"
+        ],
+        off: "disabled"
+      },
+      sampling: {
+        temperature: "thinking-requires-1",
+        topP: true,
+        topK: true,
+        penalties: true,
+        logprobs: true
+      },
+      maxTokensParam: "max_tokens",
+      chatTools: {
+        reasoning: "any"
+      },
+      source: "docs",
+      note: "Claude 4.7: adaptive thinking, low/medium/high/xhigh/max."
+    },
+    {
+      id: "claude-4-6",
+      family: "anthropic",
+      match: "^claude-(?:(?:opus|sonnet|haiku)-4[-.]6|4[-.]6-(?:opus|sonnet|haiku))(?!\\d)",
+      reasoning: {
+        style: "adaptive",
+        efforts: [
+          "low",
+          "medium",
+          "high",
+          "max"
+        ],
+        off: "disabled"
+      },
+      sampling: {
+        temperature: "thinking-requires-1",
+        topP: true,
+        topK: true,
+        penalties: true,
+        logprobs: true
+      },
+      maxTokensParam: "max_tokens",
+      chatTools: {
+        reasoning: "any"
+      },
+      source: "docs",
+      note: "Claude 4.6: adaptive thinking, low/medium/high/max (no xhigh)."
+    },
+    {
+      id: "claude-legacy-budget",
+      family: "anthropic",
+      match: "^claude-(?:3|4-|(?:opus|sonnet|haiku)-4)",
+      reasoning: {
+        style: "budget",
+        efforts: [
+          "none",
+          "minimal",
+          "low",
+          "medium",
+          "high",
+          "xhigh",
+          "max"
+        ],
+        off: null
+      },
+      sampling: {
+        temperature: "thinking-requires-1",
+        topP: true,
+        topK: true,
+        penalties: true,
+        logprobs: true
+      },
+      maxTokensParam: "max_tokens",
+      chatTools: {
+        reasoning: "any"
+      },
+      source: "docs",
+      note: "Claude 3.7 and 4.0-4.5: thinking:{type:enabled,budget_tokens}; every effort maps to a budget; sampling overrides are not allowed while thinking."
+    },
+    {
+      id: "anthropic-default",
+      family: "anthropic",
+      match: ".*",
+      reasoning: {
+        style: "budget",
+        efforts: [
+          "none",
+          "minimal",
+          "low",
+          "medium",
+          "high",
+          "xhigh",
+          "max"
+        ],
+        off: null
+      },
+      sampling: {
+        temperature: "thinking-requires-1",
+        topP: true,
+        topK: true,
+        penalties: true,
+        logprobs: true
+      },
+      maxTokensParam: "max_tokens",
+      chatTools: {
+        reasoning: "any"
+      },
+      source: "docs",
+      note: "Permissive default for unknown Anthropic-wire models: budget style (the long-standing form); the provider flips the thinking form when the API says so."
+    },
+    {
+      id: "gemini-budget",
+      family: "gemini",
+      match: "^gemini",
+      reasoning: {
+        style: "budget",
+        efforts: [
+          "none",
+          "minimal",
+          "low",
+          "medium",
+          "high",
+          "xhigh",
+          "max"
+        ],
+        off: "none"
+      },
+      sampling: {
+        temperature: "any",
+        topP: true,
+        topK: true,
+        penalties: true,
+        logprobs: true
+      },
+      maxTokensParam: "max_tokens",
+      chatTools: {
+        reasoning: "any"
+      },
+      source: "docs",
+      note: "Gemini 2.5-style thinkingBudget; effort maps to a token budget, none = budget 0."
+    },
+    {
+      id: "gemini-default",
+      family: "gemini",
+      match: ".*",
+      reasoning: {
+        style: "budget",
+        efforts: [
+          "none",
+          "minimal",
+          "low",
+          "medium",
+          "high",
+          "xhigh",
+          "max"
+        ],
+        off: "none"
+      },
+      sampling: {
+        temperature: "any",
+        topP: true,
+        topK: true,
+        penalties: true,
+        logprobs: true
+      },
+      maxTokensParam: "max_tokens",
+      chatTools: {
+        reasoning: "any"
+      },
+      source: "docs",
+      note: "Permissive default for unknown Gemini-wire models."
+    },
+    {
+      id: "other-default",
+      family: "other",
+      match: ".*",
+      reasoning: {
+        style: "effort",
+        efforts: [
+          "none",
+          "minimal",
+          "low",
+          "medium",
+          "high",
+          "xhigh",
+          "max"
+        ],
+        off: "none"
+      },
+      sampling: {
+        temperature: "any",
+        topP: true,
+        topK: true,
+        penalties: true,
+        logprobs: true
+      },
+      maxTokensParam: "max_tokens",
+      chatTools: {
+        reasoning: "any"
+      },
+      source: "docs",
+      note: "Permissive default for model families the SDK has no rules for."
     }
-    if (buffer.trim()) {
-      const event = parseSSEBlock(buffer);
-      if (event) yield event;
+  ]
+};
+
+// src/models/rules.ts
+var MODEL_RULES = model_rules_default;
+var LADDER = MODEL_RULES.effortLadder;
+var compiled = /* @__PURE__ */ new Map();
+function regexFor(rule) {
+  let re = compiled.get(rule.id);
+  if (!re) {
+    re = new RegExp(rule.match, "i");
+    compiled.set(rule.id, re);
+  }
+  return re;
+}
+var GATEWAY_PREFIX = /^(?:(?:global|us|eu|apac|jp|au|ca|us-gov)\.)?(?:(?:openai|anthropic|google|meta|amazon|deepseek|qwen|mistral|cohere|ai21)\.)?/;
+function modelIdCandidates(model) {
+  if (!model) return [];
+  const lower = String(model).trim().toLowerCase();
+  const last = lower.split("/").pop() ?? lower;
+  const out = [];
+  for (const id of [lower, last]) {
+    for (const c of [id, id.replace(GATEWAY_PREFIX, "")]) {
+      if (c && !out.includes(c)) out.push(c);
     }
-  } finally {
-    reader.cancel().catch(() => void 0);
-    reader.releaseLock();
   }
+  return out;
 }
-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;
-      }
+var OPENAI_WIRE = /* @__PURE__ */ new Set(["openai", "azure", "openai-compatible", "together", "openrouter", "groq", "fireworks", "ollama", "vllm", "litellm", "mistral", "deepseek", "xai", "jev"]);
+function familiesFor(provider) {
+  const p = (provider ?? "").toLowerCase();
+  if (OPENAI_WIRE.has(p)) return ["openai"];
+  if (p === "anthropic") return ["anthropic"];
+  if (p === "bedrock") return ["anthropic", "openai", "other"];
+  if (p === "vertex" || p === "gemini" || p === "google") return ["gemini", "anthropic"];
+  return ["openai", "anthropic", "gemini", "other"];
+}
+function matchRule(family, ids, allowDefault) {
+  for (const rule of MODEL_RULES.rules) {
+    if (rule.family !== family) continue;
+    if (rule.match === ".*") {
+      if (allowDefault) return rule;
+      continue;
     }
+    const re = regexFor(rule);
+    if (ids.some((id) => re.test(id))) return rule;
   }
-  if (dataLines.length === 0) return null;
-  return { event, data: dataLines.join("\n"), id, retry };
+  return void 0;
 }
-
-// src/providers/utils/reasoning.ts
-var ANTHROPIC_EFFORT_BUDGET = {
-  // 0 = off. `applyAnthropicReasoning` bails on a falsy budget and emits no
-  // thinking block, which on Anthropic IS off — thinking there is opt-in.
+function mergeRulePatch(base, patch) {
+  if (!patch) return base;
+  const out = { ...base };
+  if (patch.reasoning) out.reasoning = { ...base.reasoning ?? {}, ...patch.reasoning };
+  if (patch.sampling) out.sampling = { ...base.sampling ?? {}, ...patch.sampling };
+  if (patch.chatTools) out.chatTools = { ...base.chatTools ?? {}, ...patch.chatTools };
+  if (patch.maxTokensParam) out.maxTokensParam = patch.maxTokensParam;
+  if (patch.dropParams) out.dropParams = [.../* @__PURE__ */ new Set([...base.dropParams ?? [], ...patch.dropParams])];
+  return out;
+}
+var LEARNED_MAX = 500;
+var learned = /* @__PURE__ */ new Map();
+function learnedKey(provider, model, scope) {
+  return `${(provider ?? "").toLowerCase()}@${scope ?? ""}::${(model ?? "").trim().toLowerCase()}`;
+}
+function rememberModelRulePatch(provider, model, patch, scope) {
+  const key = learnedKey(provider, model, scope);
+  const merged = mergeRulePatch(learned.get(key)?.patch ?? {}, patch);
+  learned.delete(key);
+  learned.set(key, { provider: provider.toLowerCase(), model: model.trim().toLowerCase(), scope, patch: merged });
+  if (learned.size > LEARNED_MAX) learned.delete(learned.keys().next().value);
+}
+function getLearnedModelRulePatch(provider, model, scope) {
+  return learned.get(learnedKey(provider, model, scope))?.patch;
+}
+function listLearnedModelRules() {
+  return [...learned.values()].map((e) => ({ ...e }));
+}
+function clearLearnedModelRules() {
+  learned.clear();
+}
+function resolveModelRule(opts) {
+  const families = familiesFor(opts.provider);
+  const ids = modelIdCandidates(opts.model);
+  let rule;
+  for (const family of families) {
+    rule = matchRule(family, ids, false);
+    if (rule) break;
+  }
+  let isDefault = false;
+  if (!rule) {
+    isDefault = true;
+    rule = matchRule(families[0], ids, true) ?? MODEL_RULES.rules[MODEL_RULES.rules.length - 1];
+  }
+  let effective = rule;
+  const known = opts.model ? learned.get(learnedKey(opts.provider, opts.model, opts.scope))?.patch : void 0;
+  if (known) effective = mergeRulePatch(effective, known);
+  if (opts.patch) effective = mergeRulePatch(effective, opts.patch);
+  return { ...effective, matchedRuleId: rule.id, isDefault, learned: !!known };
+}
+function mapReasoningEffort(rule, effort, endpoint = "chat") {
+  const efforts = endpoint === "responses" && rule.reasoning.responsesEfforts || rule.reasoning.efforts;
+  if (rule.reasoning.style === "none" || efforts.length === 0) return { mapped: true };
+  const supported = LADDER.filter((e) => efforts.includes(e));
+  if (supported.includes(effort)) return { effort, mapped: false };
+  if (effort === "none") {
+    const off = rule.reasoning.off;
+    if (off && off !== "none") return { off, mapped: true };
+    const lowest = supported.find((e) => e !== "none");
+    return lowest ? { effort: lowest, mapped: true } : { mapped: true };
+  }
+  const at = LADDER.indexOf(effort);
+  if (at < 0) return { mapped: true };
+  for (let i = at - 1; i >= 1; i--) if (supported.includes(LADDER[i])) return { effort: LADDER[i], mapped: true };
+  for (let i = at + 1; i < LADDER.length; i++) if (supported.includes(LADDER[i])) return { effort: LADDER[i], mapped: true };
+  return supported.includes("none") ? { effort: "none", mapped: true } : { mapped: true };
+}
+function allowsSampling(rule, field, value, thinkingOn = false) {
+  const s = rule.sampling;
+  switch (field) {
+    case "temperature":
+      switch (s.temperature) {
+        case "any":
+          return true;
+        case "unsupported":
+          return false;
+        // The default is what the server applies anyway, so it is never sent.
+        case "default-only":
+          return false;
+        case "thinking-requires-1":
+          return !thinkingOn || value === 1;
+      }
+      return true;
+    // Anthropic's thinking restriction covers top_p / top_k as well as temperature.
+    case "topP":
+      return s.topP && !(thinkingOn && s.temperature === "thinking-requires-1");
+    case "topK":
+      return s.topK && !(thinkingOn && s.temperature === "thinking-requires-1");
+    case "presencePenalty":
+    case "frequencyPenalty":
+      return s.penalties;
+    case "logprobs":
+      return s.logprobs;
+  }
+}
+function applyDropParams(body, rule) {
+  for (const p of rule.dropParams ?? []) {
+    const dot = p.indexOf(".");
+    if (dot < 0) delete body[p];
+    else if (body[p.slice(0, dot)] && typeof body[p.slice(0, dot)] === "object") delete body[p.slice(0, dot)][p.slice(dot + 1)];
+  }
+}
+function effortBudget(effort, table = "anthropic") {
+  if (effort === "none") return 0;
+  return (table === "gemini" ? MODEL_RULES.geminiBudgets : MODEL_RULES.budgets)[effort] ?? 0;
+}
+
+// src/providers/utils/reasoning.ts
+var ANTHROPIC_EFFORT_BUDGET = {
+  // 0 = off. `applyAnthropicReasoning` bails on a falsy budget and emits no
+  // thinking block, which on Anthropic IS off — thinking there is opt-in.
   none: 0,
-  minimal: 1024,
-  low: 2048,
-  medium: 8192,
-  high: 16384
+  ...MODEL_RULES.budgets
 };
 var GEMINI_EFFORT_BUDGET = {
   // 0 is Gemini's own documented spelling for "do not think", and unlike
   // Anthropic it has to be SENT — hence `applyGeminiReasoning` testing for null
   // rather than falsiness.
   none: 0,
-  minimal: 512,
-  low: 1024,
-  medium: 4096,
-  high: 12e3
+  ...MODEL_RULES.geminiBudgets
 };
 var THINKING_OUTPUT_RESERVE = 1024;
+var MIN_THINKING_BUDGET = 1024;
 var THINKING_MIN_MAX_TOKENS = 4096;
-function applyOpenAIReasoning(body, reasoning, mode = "legacy_effort") {
+function applyOpenAIReasoning(body, reasoning, mode = "legacy_effort", model, rule) {
   if (!reasoning) return;
-  const effort = normalizeEffort(reasoning.effort);
+  const requested = normalizeEffort(reasoning.effort);
+  const r = rule ?? resolveModelRule({ provider: "openai", model: model ?? body.model });
+  const effort = requested && mapReasoningEffort(r, requested, mode === "responses" ? "responses" : "chat").effort;
   if (mode === "responses") {
     const obj = {};
     if (effort) obj.effort = effort;
@@ -15281,52 +16057,107 @@ function applyOpenAIReasoning(body, reasoning, mode = "legacy_effort") {
     if (reasoning.providerExtras) Object.assign(body, reasoning.providerExtras);
   }
 }
-function applyAnthropicReasoning(body, reasoning) {
-  if (!reasoning) return;
-  let budget = resolveBudget(reasoning, ANTHROPIC_EFFORT_BUDGET);
-  if (!budget) return;
+function supportsAdaptiveThinking(model) {
+  if (typeof model !== "string") return false;
+  return resolveModelRule({ provider: "anthropic", model }).reasoning.style === "adaptive";
+}
+function resolveThinkingForm(model, mode, rule) {
+  if (mode === "adaptive" || mode === "budget") return mode;
+  if (rule) return rule.reasoning.style === "adaptive" ? "adaptive" : "budget";
+  return supportsAdaptiveThinking(model) ? "adaptive" : "budget";
+}
+function enforceAnthropicSampling(target, rule, thinkingOn, bedrock = false) {
+  const fields = bedrock ? [["temperature", "temperature"], ["topP", "topP"]] : [["temperature", "temperature"], ["top_p", "topP"], ["top_k", "topK"]];
+  for (const [key, field] of fields) {
+    if (key in target && !allowsSampling(rule, field, target[key], thinkingOn)) delete target[key];
+  }
+}
+function applyAdaptiveThinking(reasoning, rule, setThinking, setOutputConfig) {
+  let requested = normalizeEffort(reasoning.effort);
+  if (!requested && typeof reasoning.budgetTokens === "number" && reasoning.budgetTokens > 0) {
+    requested = reasoning.budgetTokens <= ANTHROPIC_EFFORT_BUDGET.low ? "low" : reasoning.budgetTokens <= ANTHROPIC_EFFORT_BUDGET.medium ? "medium" : "high";
+  }
+  if (!requested) return false;
+  const mapped = mapReasoningEffort(rule, requested);
+  if (mapped.off) {
+    setThinking({ type: mapped.off });
+    return false;
+  }
+  if (!mapped.effort || mapped.effort === "none") 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: mapped.effort });
+  return true;
+}
+function applyAnthropicReasoning(body, reasoning, opts) {
+  const rule = opts?.rule ?? resolveModelRule({ provider: "anthropic", model: opts?.model ?? body.model });
+  if (!reasoning) {
+    enforceAnthropicSampling(body, rule, false);
+    return;
+  }
+  if (resolveThinkingForm(opts?.model ?? body.model, opts?.mode, rule) === "adaptive") {
+    const on = applyAdaptiveThinking(reasoning, rule, (t) => body.thinking = t, (o) => body.output_config = { ...body.output_config ?? {}, ...o });
+    enforceAnthropicSampling(body, rule, on);
+    return;
+  }
+  let budget = resolveBudget(reasoning, ANTHROPIC_EFFORT_BUDGET, rule);
+  if (!budget) {
+    enforceAnthropicSampling(body, rule, false);
+    return;
+  }
   const currentMax = typeof body.max_tokens === "number" ? body.max_tokens : 0;
   const requiredMax = Math.max(THINKING_MIN_MAX_TOKENS, budget + THINKING_OUTPUT_RESERVE);
   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"]);
+  enforceAnthropicSampling(body, rule, true);
 }
-function applyBedrockReasoning(body, reasoning) {
-  if (!reasoning) return;
-  let budget = resolveBudget(reasoning, ANTHROPIC_EFFORT_BUDGET);
-  if (!budget) return;
+function applyBedrockReasoning(body, reasoning, opts) {
+  const rule = opts?.rule ?? resolveModelRule({ provider: "bedrock", model: opts?.model ?? body.modelId });
+  if (!reasoning) {
+    if (body.inferenceConfig) enforceAnthropicSampling(body.inferenceConfig, rule, false, true);
+    return;
+  }
+  if (resolveThinkingForm(opts?.model ?? body.modelId, opts?.mode, rule) === "adaptive") {
+    const fields = () => body.additionalModelRequestFields ?? (body.additionalModelRequestFields = {});
+    const on = applyAdaptiveThinking(reasoning, rule, (t) => fields().thinking = t, (o) => fields().output_config = { ...fields().output_config ?? {}, ...o });
+    if (body.inferenceConfig) enforceAnthropicSampling(body.inferenceConfig, rule, on, true);
+    return;
+  }
+  let budget = resolveBudget(reasoning, ANTHROPIC_EFFORT_BUDGET, rule);
+  if (!budget) {
+    if (body.inferenceConfig) enforceAnthropicSampling(body.inferenceConfig, rule, false, true);
+    return;
+  }
   const inference = body.inferenceConfig ?? (body.inferenceConfig = {});
   const currentMax = typeof inference.maxTokens === "number" ? inference.maxTokens : 0;
   const requiredMax = Math.max(THINKING_MIN_MAX_TOKENS, budget + THINKING_OUTPUT_RESERVE);
   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);
   extra.thinking = thinking;
-  stripSamplingParams(inference, ["temperature", "topP"]);
+  enforceAnthropicSampling(inference, rule, true, true);
 }
 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;
 }
-function stripSamplingParams(target, keys) {
-  for (const k of keys) {
-    if (k in target) delete target[k];
-  }
-}
 function clampBudget(budget, maxTokens) {
   if (typeof maxTokens !== "number" || maxTokens <= 0) return budget;
   const ceiling = maxTokens - THINKING_OUTPUT_RESERVE;
@@ -15335,19 +16166,292 @@ function clampBudget(budget, maxTokens) {
 }
 function normalizeEffort(effort) {
   if (!effort) return void 0;
-  const allowed = ["none", "minimal", "low", "medium", "high"];
+  const allowed = ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
   return allowed.includes(effort) ? effort : void 0;
 }
-function resolveBudget(reasoning, effortBudget) {
+function resolveBudget(reasoning, effortBudget2, rule) {
   const effort = normalizeEffort(reasoning.effort);
   if (effort === "none") return 0;
   if (typeof reasoning.budgetTokens === "number" && reasoning.budgetTokens > 0) {
     return Math.floor(reasoning.budgetTokens);
   }
-  if (effort && effortBudget[effort]) return effortBudget[effort];
+  const mapped = effort && rule ? mapReasoningEffort(rule, effort).effort : effort;
+  if (mapped && effortBudget2[mapped]) return effortBudget2[mapped];
   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/models/errors.ts
+var ModelRequestError = class extends ProviderError {
+  constructor(init) {
+    super(init.message, init.provider, init.status ?? 400, init.responseBody);
+    this.status = init.status ?? 400;
+    this.code = init.code;
+    this.param = init.param;
+    this.value = init.value;
+    this.supportedValues = init.supportedValues;
+    this.model = init.model;
+  }
+};
+
+// src/models/adjust.ts
+var MAX_ADJUSTMENTS = 3;
+var Q = "['\"`]";
+function errorMessage(text) {
+  try {
+    const j = JSON.parse(text);
+    const e = j?.error ?? j;
+    const message = typeof e?.message === "string" ? e.message : typeof j?.message === "string" ? j.message : text;
+    return { message, param: typeof e?.param === "string" ? e.param : void 0, code: typeof e?.code === "string" ? e.code : void 0 };
+  } catch {
+    return { message: text };
+  }
+}
+function quotedList(s) {
+  const quoted = [...s.matchAll(new RegExp(`${Q}([^'"\`]+)${Q}`, "g"))].map((m) => m[1]);
+  if (quoted.length > 0) return quoted;
+  return s.split(/[,\s]+/).map((x) => x.replace(/[.\s]+$/, "")).filter(Boolean);
+}
+function parseModelError(text) {
+  const { message, param: errParam } = errorMessage(String(text ?? ""));
+  const m = message.toLowerCase();
+  if (m.includes("function tools with reasoning_effort") && m.includes("not supported")) {
+    return { kind: "chat_tools_effort", message };
+  }
+  if (m.includes("between_tools") && m.includes("thinking")) return { kind: "thinking_off_between_tools", message };
+  if (m.includes("thinking.type.enabled") && m.includes("not supported")) return { kind: "thinking_enabled_unsupported", message };
+  if (m.includes("thinking.type.adaptive") && m.includes("not supported")) return { kind: "thinking_adaptive_unsupported", message };
+  if (m.includes("thinking.type.disabled") && m.includes("not supported")) return { kind: "thinking_disabled_unsupported", message };
+  const tt = new RegExp(`${Q}?(temperature|top_p|top_k)${Q}?\\s+may only be set to 1 when thinking is enabled`, "i").exec(message);
+  if (tt) return { kind: "temperature_thinking", param: tt[1].toLowerCase(), message };
+  const dep = new RegExp(`${Q}([\\w.]+)${Q}\\s+is deprecated for this model`, "i").exec(message);
+  if (dep) return { kind: "unsupported_parameter", param: dep[1], message };
+  const rename = new RegExp(`use ${Q}(max_completion_tokens|max_tokens)${Q} instead`, "i").exec(message);
+  if (rename) return { kind: "max_tokens_rename", renameTo: rename[1].toLowerCase(), param: rename[1].toLowerCase() === "max_tokens" ? "max_completion_tokens" : "max_tokens", message };
+  const val = new RegExp(`unsupported value:?\\s*${Q}?([\\w.]+)${Q}?\\s+does not support\\s+(${Q}[^'"\`]*${Q}|[^\\s]+)`, "i").exec(message);
+  if (val) {
+    const param = val[1];
+    const value = val[2].replace(/^['"`]|['"`]$/g, "");
+    if (m.includes("only the default") && m.includes("value is supported")) return { kind: "default_only", param, value, message };
+    const sup = /supported values? (?:are|is):?\s*([^\n]*)/i.exec(message);
+    return { kind: "unsupported_value", param, value, supportedValues: sup ? quotedList(sup[1]) : void 0, message };
+  }
+  if (m.includes("only the default") && m.includes("value is supported")) {
+    return { kind: "default_only", param: errParam ?? "temperature", message };
+  }
+  const prm = new RegExp(`unsupported parameter:?\\s*${Q}?([\\w.]+)${Q}?`, "i").exec(message);
+  if (prm) return { kind: "unsupported_parameter", param: prm[1], message };
+  return void 0;
+}
+var normParam = (p) => p.toLowerCase().replace(/[-\s]/g, "_");
+var LADDER2 = new Set(MODEL_RULES.effortLadder);
+function patchFromParsedError(parsed, endpoint = "chat") {
+  const param = parsed.param ? normParam(parsed.param) : "";
+  switch (parsed.kind) {
+    case "chat_tools_effort":
+      return { patch: { chatTools: { reasoning: "force-none" } }, adjustment: "chat-tools:force-effort-none" };
+    case "max_tokens_rename":
+      return { patch: { maxTokensParam: parsed.renameTo }, adjustment: `${parsed.param}->${parsed.renameTo}` };
+    case "thinking_enabled_unsupported":
+      return { patch: { reasoning: { style: "adaptive" } }, adjustment: "thinking:adaptive" };
+    case "thinking_adaptive_unsupported":
+      return { patch: { reasoning: { style: "budget" } }, adjustment: "thinking:budget" };
+    case "thinking_off_between_tools":
+      return { patch: { reasoning: { off: "between_tools" } }, adjustment: "thinking-off:between_tools" };
+    case "thinking_disabled_unsupported":
+      return { patch: { reasoning: { off: null } }, adjustment: "thinking-off:none" };
+    case "temperature_thinking":
+      return { patch: { sampling: { temperature: "unsupported" } }, adjustment: "drop:temperature" };
+    case "default_only":
+      if (param === "temperature") return { patch: { sampling: { temperature: "default-only" } }, adjustment: "temperature:default-only" };
+      return { patch: { dropParams: [parsed.param ?? param] }, adjustment: `drop:${parsed.param ?? param}` };
+    case "unsupported_value": {
+      if (/^(reasoning_effort|reasoning\.effort|effort|output_config\.effort)$/.test(param)) {
+        const list = (parsed.supportedValues ?? []).map((v) => v.toLowerCase()).filter((v) => LADDER2.has(v));
+        if (list.length === 0) return void 0;
+        const reasoning = endpoint === "responses" ? { responsesEfforts: list } : { efforts: list };
+        return { patch: { reasoning }, adjustment: `efforts:${list.join("|")}` };
+      }
+      return paramDropPatch(param, parsed);
+    }
+    case "unsupported_parameter":
+      return paramDropPatch(param, parsed);
+  }
+}
+function paramDropPatch(param, parsed) {
+  if (!param) return void 0;
+  const label = `drop:${parsed.param ?? param}`;
+  switch (param) {
+    case "temperature":
+      return { patch: { sampling: { temperature: "unsupported" } }, adjustment: label };
+    case "top_p":
+      return { patch: { sampling: { topP: false } }, adjustment: label };
+    case "top_k":
+      return { patch: { sampling: { topK: false } }, adjustment: label };
+    case "presence_penalty":
+    case "frequency_penalty":
+      return { patch: { sampling: { penalties: false } }, adjustment: label };
+    case "logprobs":
+    case "top_logprobs":
+      return { patch: { sampling: { logprobs: false } }, adjustment: label };
+    case "max_tokens":
+      return { patch: { maxTokensParam: "max_completion_tokens" }, adjustment: "max_tokens->max_completion_tokens" };
+    case "max_completion_tokens":
+      return { patch: { maxTokensParam: "max_tokens" }, adjustment: "max_completion_tokens->max_tokens" };
+    case "reasoning_effort":
+    case "reasoning.effort":
+    case "reasoning":
+      return { patch: { reasoning: { style: "none", efforts: [], responsesEfforts: [] }, dropParams: [param] }, adjustment: label };
+    default:
+      return { patch: { dropParams: [parsed.param ?? param] }, adjustment: label };
+  }
+}
+function codeFor(parsed) {
+  if (!parsed) return "model_request_invalid";
+  if (parsed.kind === "unsupported_value" || parsed.kind === "default_only") return "unsupported_value";
+  if (parsed.kind === "unsupported_parameter" || parsed.kind === "max_tokens_rename" || parsed.kind === "temperature_thinking") return "unsupported_parameter";
+  return "model_request_invalid";
+}
+function toModelRequestError(err, parsed, provider, model) {
+  return new ModelRequestError({
+    status: err.statusCode ?? 400,
+    code: codeFor(parsed),
+    param: parsed?.param,
+    value: parsed?.value,
+    supportedValues: parsed?.supportedValues,
+    provider: err.provider || provider,
+    model,
+    message: err.message,
+    responseBody: err.responseBody
+  });
+}
+var SameRequest = class extends Error {
+};
+function withoutCallerParams(step, callerParams) {
+  const drops = step.patch.dropParams;
+  if (!callerParams?.length || !drops) return step;
+  const mine = (p) => callerParams.includes(p.split(".")[0]);
+  if (!drops.some(mine)) return step;
+  const { dropParams: _ignored, ...rest } = step.patch;
+  const kept = drops.filter((p) => !mine(p));
+  const patch = kept.length ? { ...rest, dropParams: kept } : rest;
+  return Object.keys(patch).length ? { ...step, patch } : void 0;
+}
+async function runWithModelAdjustments(opts) {
+  let overlay = {};
+  const steps = [];
+  let previous;
+  let lastError;
+  let lastParsed;
+  for (; ; ) {
+    const guard = (body) => {
+      let json;
+      try {
+        json = JSON.stringify(body);
+      } catch {
+        return;
+      }
+      if (previous !== void 0 && json === previous) throw new SameRequest();
+      previous = json;
+    };
+    try {
+      const result = await opts.run(overlay, guard);
+      for (const step of steps) {
+        const s = withoutCallerParams(step, opts.callerParams);
+        if (!s) continue;
+        rememberModelRulePatch(opts.provider, opts.model, s.patch, opts.scope);
+        if (opts.onLearned) {
+          try {
+            opts.onLearned({ provider: opts.provider, model: opts.model, adjustment: s.adjustment, patch: s.patch, reason: s.reason });
+          } catch {
+          }
+        }
+      }
+      return result;
+    } catch (err) {
+      if (err instanceof SameRequest) throw toModelRequestError(lastError, lastParsed, opts.provider, opts.model);
+      if (!(err instanceof ProviderError) || err instanceof ModelRequestError || err.statusCode !== 400) throw err;
+      const parsed = parseModelError(String(err.responseBody ?? err.message));
+      const fix = parsed ? patchFromParsedError(parsed, opts.endpoint) : void 0;
+      lastError = err;
+      lastParsed = parsed;
+      if (!fix || steps.length >= MAX_ADJUSTMENTS) throw toModelRequestError(err, parsed, opts.provider, opts.model);
+      overlay = mergeRulePatch(overlay, fix.patch);
+      steps.push({ ...fix, reason: parsed.message });
+    }
+  }
+}
+function asModelRequestError(err, provider, model) {
+  if (!(err instanceof ProviderError) || err instanceof ModelRequestError || err.statusCode !== 400) return err;
+  return toModelRequestError(err, parseModelError(String(err.responseBody ?? err.message)), provider, model);
+}
+
 // src/providers/utils/media.ts
 var EXTENSION_MIME = {
   jpg: "image/jpeg",
@@ -15539,11 +16643,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";
@@ -15551,10 +16708,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`. */
@@ -15580,9 +16741,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);
   }
@@ -15590,14 +16752,13 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
     if (this.useResponsesApi(request)) {
       return this.completeResponses(request);
     }
-    const body = this.buildRequestBody(request, false);
-    const res = await this.doFetch(body, request.signal);
+    const res = await this.fetchChat(request, false);
     const json = await res.json();
     return this.parseResponse(json);
   }
   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;
       }
@@ -15615,8 +16776,7 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
       };
       return;
     }
-    const body = this.buildRequestBody(request, true);
-    const res = await this.doFetch(body, request.signal);
+    const res = await this.fetchChat(request, true);
     if (!res.body) throw new ProviderError("No response body for stream", this.providerName);
     let id = "";
     let model = "";
@@ -15647,9 +16807,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) {
@@ -15661,7 +16826,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;
       }
@@ -15669,22 +16834,115 @@ 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) {
+  /** Chat Completions call that corrects itself from the provider's own 400s (see models/adjust.ts). */
+  fetchChat(request, stream) {
+    const model = request.model || this.defaultModel;
+    return runWithModelAdjustments({
+      provider: this.providerName,
+      model,
+      endpoint: "chat",
+      scope: this.baseURL,
+      callerParams: request.extra ? Object.keys(request.extra) : void 0,
+      onLearned: this.onModelRuleLearned,
+      run: (overlay, guard) => {
+        const body = this.buildRequestBody(request, stream, overlay);
+        guard(body);
+        return this.doFetch(body, request.signal);
+      }
+    });
+  }
+  /** Same for the Responses API. */
+  fetchResponses(request, adaptExtras, stream = false) {
+    const model = request.model || this.defaultModel;
+    return runWithModelAdjustments({
+      provider: this.providerName,
+      model,
+      endpoint: "responses",
+      scope: this.baseURL,
+      callerParams: request.extra ? Object.keys(request.extra) : void 0,
+      onLearned: this.onModelRuleLearned,
+      run: (overlay, guard) => {
+        const body = this.buildResponsesBody(request, overlay);
+        if (adaptExtras) adaptChatExtrasForResponses(body, request.extra);
+        if (stream) body.stream = true;
+        guard(body);
+        return this.responsesFetch(body, request.signal);
+      }
+    });
+  }
+  buildRequestBody(request, stream, overlay) {
     const body = {
       model: request.model || this.defaultModel,
       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 rule = resolveModelRule({ provider: this.providerName, model: modelId, patch: overlay, scope: this.baseURL });
+    if (request.temperature != null && allowsSampling(rule, "temperature", request.temperature)) body.temperature = request.temperature;
+    if (request.maxTokens != null) {
+      const param = this.maxTokensParam === "auto" ? rule.maxTokensParam : this.maxTokensParam;
+      body[param] = request.maxTokens;
+    }
+    if (request.topP != null && allowsSampling(rule, "topP")) body.top_p = request.topP;
     if (request.stop) body.stop = request.stop;
+    if (request.presencePenalty != null && allowsSampling(rule, "presencePenalty")) body.presence_penalty = request.presencePenalty;
+    if (request.frequencyPenalty != null && allowsSampling(rule, "frequencyPenalty")) 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 && allowsSampling(rule, "logprobs")) body.logprobs = request.logprobs;
+    if (request.topLogprobs != null && allowsSampling(rule, "logprobs")) 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") {
@@ -15710,14 +16968,17 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
     if (request.extra) {
       Object.assign(body, request.extra);
     }
-    applyOpenAIReasoning(body, request.reasoning, "legacy_effort");
+    applyOpenAIReasoning(body, request.reasoning, "legacy_effort", modelId, rule);
+    if (body.tools?.length && rule.chatTools.reasoning === "force-none" && rule.reasoning.style !== "none") {
+      body.reasoning_effort = "none";
+    }
+    applyDropParams(body, rule);
     return body;
   }
   // ─── Responses API (reasoning models) ──────────────────────────────────────
   async completeResponses(request) {
-    const body = this.buildResponsesBody(request);
-    if (this.isResponsesApiModel(request)) adaptChatExtrasForResponses(body, request.extra);
-    const res = await this.responsesFetch(body, request.signal);
+    const adapt = this.apiResponsesNative || this.isResponsesApiModel(request);
+    const res = await this.fetchResponses(request, adapt);
     const json = await res.json();
     return this.parseResponsesResponse(json, request.model || this.defaultModel);
   }
@@ -15730,15 +16991,13 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
    * reads it). */
   async *streamResponses(request) {
     const modelId = request.model || this.defaultModel;
-    const body = this.buildResponsesBody(request);
-    adaptChatExtrasForResponses(body, request.extra);
-    body.stream = true;
-    const res = await this.responsesFetch(body, request.signal);
+    const res = await this.fetchResponses(request, true, true);
     if (!res.body) throw new ProviderError("No response body for stream", this.providerName);
     let id = "";
     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;
@@ -15756,19 +17015,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": {
@@ -15777,13 +17045,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;
         }
@@ -15806,18 +17074,20 @@ 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")
     };
   }
-  buildResponsesBody(request) {
+  buildResponsesBody(request, overlay) {
     const body = {
       model: request.model || this.defaultModel,
       input: request.messages.map((m) => this.toResponsesInput(m))
     };
     if (request.maxTokens != null) body.max_output_tokens = request.maxTokens;
-    if (request.topP != null) body.top_p = request.topP;
+    const rule = resolveModelRule({ provider: this.providerName, model: String(body.model), patch: overlay, scope: this.baseURL });
+    if (request.topP != null && allowsSampling(rule, "topP")) body.top_p = request.topP;
     if (request.tools?.length) {
       body.tools = request.tools.map((t) => ({
         type: "function",
@@ -15849,7 +17119,8 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
       }
     }
     if (request.extra) Object.assign(body, request.extra);
-    applyOpenAIReasoning(body, request.reasoning, "responses");
+    applyOpenAIReasoning(body, request.reasoning, "responses", String(body.model), rule);
+    applyDropParams(body, rule);
     return body;
   }
   /** Maps a unified message to a Responses API `input` item. */
@@ -15916,7 +17187,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(
@@ -16045,7 +17316,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(
@@ -16065,6 +17336,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 ?? "",
@@ -16072,6 +17345,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
     };
   }
@@ -16090,10 +17366,27 @@ 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();
-  return /(^|[/_-])o[0-9]/.test(m) || m.startsWith("o1") || m.startsWith("o3") || m.startsWith("o4") || m.includes("gpt-5") || m.includes("gpt5");
+  const rule = resolveModelRule({ provider: "openai", model });
+  return !rule.isDefault && rule.reasoning.style === "effort" && rule.sampling.temperature !== "any";
 }
 function adaptChatExtrasForResponses(body, extra) {
   const native = extra ?? {};
@@ -16166,36 +17459,80 @@ 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];
+}
 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;
@@ -16224,8 +17561,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") {
@@ -16263,7 +17603,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 }]
                 }
               };
             }
@@ -16276,8 +17616,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,
@@ -16285,7 +17627,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
@@ -16295,6 +17637,7 @@ var AnthropicProvider = class extends BaseProvider {
             model,
             delta: blocks.length > 0 ? { reasoning: { blocks } } : {},
             finishReason,
+            ...rawFinishReason ? { rawFinishReason } : {},
             usage
           };
           break;
@@ -16309,12 +17652,12 @@ var AnthropicProvider = class extends BaseProvider {
     }
   }
   // ─── Internals ───────────────────────────────────────────────────────────
-  buildRequestBody(request, stream) {
+  buildRequestBody(request, stream, overlay, 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) {
@@ -16324,6 +17667,7 @@ var AnthropicProvider = class extends BaseProvider {
         body.system = system;
       }
     }
+    const rule = resolveModelRule({ provider: this.providerName, model: String(body.model), patch: overlay });
     if (request.temperature != null) body.temperature = request.temperature;
     if (request.topP != null) body.top_p = request.topP;
     if (request.stop) body.stop_sequences = request.stop;
@@ -16335,18 +17679,29 @@ 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);
+      enforceAnthropicSampling(body, rule, body.thinking?.type === "enabled" || body.thinking?.type === "adaptive");
+    } else {
+      applyAnthropicReasoning(body, request.reasoning, { model: body.model, mode: this.thinkingMode, rule });
+    }
+    applyDropParams(body, rule);
+    if (typeof body.max_tokens !== "number" || !(body.max_tokens > 0)) {
+      body.max_tokens = DEFAULT_MAX_TOKENS;
+    }
     return body;
   }
   splitSystemMessages(messages) {
@@ -16477,6 +17832,31 @@ 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. */
+  send(request, stream) {
+    let downgrade = false;
+    return runWithModelAdjustments({
+      provider: this.providerName,
+      model: request.model || this.defaultModel,
+      endpoint: "messages",
+      callerParams: request.extra ? Object.keys(request.extra) : void 0,
+      onLearned: this.onModelRuleLearned,
+      run: async (overlay, guard) => {
+        for (; ; ) {
+          const body = this.buildRequestBody(request, stream, overlay, downgrade);
+          guard(body);
+          try {
+            return await this.doFetch(body, request.signal);
+          } catch (err) {
+            const rejected = err instanceof ProviderError && err.statusCode === 400 && !downgrade && body.tool_choice && body.tool_choice.type !== "auto" && forcedToolChoiceRejected(String(err.responseBody ?? err.message));
+            if (!rejected) throw err;
+            downgrade = true;
+          }
+        }
+      }
+    });
+  }
   async doFetch(body, signal) {
     const url = `${this.baseURL}/v1/messages`;
     const headers = {
@@ -16486,7 +17866,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(
@@ -16531,10 +17911,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 ?? "",
@@ -16543,6 +17922,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
     };
@@ -16588,7 +17968,16 @@ 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,
+      onModelRuleLearned: config.onModelRuleLearned,
+      maxTokensParam: config.maxTokensParam,
+      api: config.api,
+      responsesApi: config.responsesApi,
+      responsesApiModels: config.responsesApiModels,
+      responsesStreaming: config.responsesStreaming
     });
     this.providerName = "azure";
     this.endpoint = config.endpoint.replace(/\/$/, "");
@@ -16603,16 +17992,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(
@@ -16624,6 +18014,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. */
@@ -16635,7 +18051,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",
@@ -16644,7 +18060,7 @@ var AzureProvider = class extends OpenAIProvider {
       },
       body: payload,
       signal
-    });
+    }), signal);
     if (!res.ok) {
       const text = await res.text().catch(() => "");
       throw new ProviderError(
@@ -16680,20 +18096,156 @@ 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,
+      onModelRuleLearned: config.onModelRuleLearned,
+      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 = {
@@ -16710,25 +18262,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, overlay) {
     const { system, messages } = this.splitSystemMessages(request.messages);
     const body = {
       messages: this.toBedrockMessages(messages)
@@ -16752,8 +18481,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: {} };
@@ -16763,9 +18493,22 @@ var BedrockProvider = class extends BaseProvider {
       }
     }
     if (request.extra) {
-      Object.assign(body, request.extra);
-    }
-    applyBedrockReasoning(body, request.reasoning);
+      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;
+    }
+    const rule = resolveModelRule({ provider: this.providerName, model: request.model || this.defaultModel, patch: overlay });
+    applyBedrockReasoning(body, request.reasoning, { model: request.model || this.defaultModel, mode: this.thinkingMode, rule });
+    if (body.inferenceConfig && rule.dropParams?.length) {
+      for (const p of rule.dropParams) delete body.inferenceConfig[p === "top_p" ? "topP" : p === "max_tokens" ? "maxTokens" : p];
+    }
+    applyDropParams(body, rule);
     return body;
   }
   splitSystemMessages(messages) {
@@ -16888,9 +18631,35 @@ 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. */
+  converseFetch(modelId, request, stream) {
+    let downgrade = false;
+    return runWithModelAdjustments({
+      provider: this.providerName,
+      model: modelId,
+      endpoint: "converse",
+      callerParams: request.extra ? Object.keys(request.extra) : void 0,
+      onLearned: this.onModelRuleLearned,
+      run: async (overlay, guard) => {
+        for (; ; ) {
+          const body = this.buildConverseBody(request, downgrade, overlay);
+          guard(body);
+          try {
+            return await this.doFetch(modelId, body, request.signal, stream);
+          } catch (err) {
+            const tc = body.toolConfig?.toolChoice;
+            const rejected = err instanceof ProviderError && err.statusCode === 400 && !downgrade && !!tc && !tc.auto && forcedToolChoiceRejected(String(err.responseBody ?? err.message));
+            if (!rejected) throw err;
+            downgrade = true;
+          }
+        }
+      }
+    });
+  }
+  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({
@@ -16898,7 +18667,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,
@@ -16906,7 +18675,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(() => "");
@@ -16917,7 +18686,7 @@ var BedrockProvider = class extends BaseProvider {
         text
       );
     }
-    return res.json();
+    return res;
   }
   parseResponse(json, modelId) {
     const output = json.output?.message;
@@ -16953,8 +18722,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
@@ -16966,11 +18735,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) {
@@ -16985,6 +18769,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":
@@ -16993,8 +18794,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:
@@ -17024,10 +18827,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;
@@ -17040,7 +18845,7 @@ var VertexProvider = class extends BaseProvider {
     const modelId = request.model || this.defaultModel;
     const body = this.buildGeminiBody(request);
     const url = this.buildUrl(modelId, false);
-    const res = await this.doFetch(url, body, request.signal);
+    const res = await this.doFetch(url, body, request.signal, modelId);
     const json = await res.json();
     return this.parseResponse(json, modelId);
   }
@@ -17048,8 +18853,9 @@ var VertexProvider = class extends BaseProvider {
     const modelId = request.model || this.defaultModel;
     const body = this.buildGeminiBody(request);
     const url = this.buildUrl(modelId, true);
-    const res = await this.doFetch(url, body, request.signal);
+    const res = await this.doFetch(url, body, request.signal, modelId);
     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)) {
@@ -17060,7 +18866,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();
@@ -17078,7 +18884,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;
@@ -17089,7 +18895,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 {
           }
         }
@@ -17100,6 +18906,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, model);
+      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}`;
@@ -17197,7 +19045,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 };
@@ -17294,7 +19144,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}`
@@ -17306,20 +19156,38 @@ var VertexProvider = class extends BaseProvider {
     const tokenJson = await tokenRes.json();
     return tokenJson.access_token;
   }
-  async doFetch(url, body, signal) {
+  async doFetch(url, body, signal, model = "") {
     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(() => "");
+      if (res.status === 400) {
+        const parsed = parseModelError(text);
+        throw new ModelRequestError({
+          status: 400,
+          code: parsed?.kind === "unsupported_value" ? "unsupported_value" : parsed?.kind === "unsupported_parameter" ? "unsupported_parameter" : "model_request_invalid",
+          param: parsed?.param,
+          value: parsed?.value,
+          supportedValues: parsed?.supportedValues,
+          provider: this.providerName,
+          model,
+          message: `Vertex AI API error ${res.status}: ${text}`,
+          responseBody: text
+        });
+      }
       throw new ProviderError(
         `Vertex AI API error ${res.status}: ${text}`,
         this.providerName,
@@ -17347,7 +19215,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 } : {}
         });
       }
     }
@@ -17368,11 +19237,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 = {};
@@ -17386,9 +19256,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 } : {}
         });
       }
     }
@@ -17410,10 +19283,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":
@@ -17462,6 +19346,6 @@ function createProvider(config) {
   }
 }
 
-export { ASK_USER_TOOL_NAME, AnthropicProvider, AzureProvider, BaseProvider, BedrockProvider, CCRStore, CONSOLE_HOOK_MAP, CONTEXT_PILOT_JSON_MARKER_KEY, CONTROL_PLANE_TOOL_NAMES, DEFAULT_MAX_TOOL_INPUT_FIELD_CHARS, DEFAULT_PROFILE_CONFIGS, DEFAULT_SKILL_POLICY, DEFAULT_SUBAGENT_POLICY, DEFAULT_SUBAGENT_TOOL_NAMES, DEFAULT_TOOL_INPUT_DIGEST_HEAD_CHARS, DELEGATION_TOOL_NAMES, DedupTracker, GuardrailPhase, HOOK_CONTRACT_VERSION, HOOK_NAMES, HookTimeoutError, InMemoryMemoryStore, JevProvider, NativeJsonSchemaStrategy, OpenAICompatibleProvider, OpenAIProvider, PREOPEN_TOOL_CALL_PREFIX, ProviderError, SMALL_TIER_SKILL_POLICY, StructuredOutputManager, TOOL_INPUT_DIGEST_KEY, ToolBasedStrategy, VertexProvider, agentVerdictRule, appendBoundTools, auditLog, azureContentSafety, bedrockGuardrail, budgetGuard, buildHandoffTools, buildResponseFormatSection, buildSkillHeaderBlock, buildSubagentCatalogBlock, buildSystemPrompt, buildToolDefinitionsSection, canOpenSkill, canSpawn, captureSnapshot, checkpointing, codePresenceRule, coerceToolArgs, cognipeerGuardrail, cognipeerSink, collectAttachments, collectToolRetentionDeclarations, composeToolSets, compressDiffOutput, compressJsonOutput, compressLogOutput, compressSearchOutput, compressTextOutput, compressToolOutput, contentPartToText, contentToString, conversationHistory, countApproxTokens, countMessagesTokens, createAgent, createAgentNode, createAskUserQuestionTool, createBindSkillToolsTool, createCodeGuardrail, createContextPilotRuntime, createContextSummarizeNode, createContextTools, createDelegateTool, createGetToolResponseTool, createGuardrail, createGuardrailPlugin, createJsonGuardrail, createManageTodoListAliasTool, createManageTodoTool, createOpenSkillTool, createParallelTool, createPluginHost, createProvider, createRegexGuardrail, createResolverNode, createSearchSkillsTool, createSkillRegistryRef, createSkillTools, createSmartAgent, createSpawnTool, createSubagentRegistryRef, createSubagentTools, createTool, createToolLimitFinalizeNode, createToolsNode, customCallbackRule, customGuardrail, customSink, dedupeToolsByName, defaultTokenCounter, defineHook, definePlugin, describeContentPart, detectLanguage, detectTextFormat, detectVolatileContent, digestToolInputArguments, digestToolInputValue, emptyUsage, evaluateGuardrails, extractLatestUserQuery, extractMessageText, fileCheckpointStore, fileSink, findSubagent, formatZodError, fromLangchainModel, fromLangchainTools, fromNativeProvider, generateSpanId, generateTraceId, getModelCapabilities, getNestedValue, getResolvedSmartConfig, getTokenCounter, hasMediaPart, hasToolResponseRecoveryReference, httpGuardrail, httpSink, inMemoryCheckpointStore, inMemoryConversationStore, isHookImplemented, isOpenAIHostedEndpoint, isSmartModel, isValidIban, isValidLuhn, isValidTckn, jsonSchemaRule, defaultBuildPayload as langfuseDefaultPayload, langfuseTracing, languageGuard, loadSkillsFromDisk, mapConsoleHookVerdict, mapTextParts, mcp, mediaKindOf, mediaPolicy, normalizeSmartAgentOptions, normalizeVerdicts, openAIModeration, otelTracing, otlpSink, outputGuard, parseApprovalDecision, parseSkillFrontmatter, pathSandbox, piiRedaction, pluginCapabilities, portkeyGateway, portkeyGuardrail, preopenSkills, preopenToolCallId, prepareStrictToolMenu, promptInjectionGuard, rateLimit, readMemoryFacts, redactText, regexGuardrail, regexRule, replaceTextContent, resolveAvailableSkills, resolveAvailableSubagents, resolveInputRetention, resolveMemoryStore, resolveReasoning, resolveStrategy, resolveSubagentTools, resolveSummarizationRetention, resolveToolApprovalState, resolveUserQuestionState, responseCache, restoreSnapshot, restoreToolCalls, runSmartAgentEvalHarness, scoreItemsByRelevance, searchSkills, seedChildMessages, selectTopIndicesInOrder, sessionMetrics, setTokenCounter, startStreamingSession, summarizeObject, textFromContent, toStrictCompatible, toStrictToolSchema, tokenize, toolPolicy, traceSessionToOtlp, validateReasoningConfig, validateToolArgs, webhookApproval, withTools, withinDepth, writeSummaryFactsToMemory };
+export { ASK_USER_TOOL_NAME, AnthropicProvider, AzureProvider, BaseProvider, BedrockProvider, CCRStore, CONSOLE_HOOK_MAP, CONTEXT_PILOT_JSON_MARKER_KEY, CONTROL_PLANE_TOOL_NAMES, DEFAULT_MAX_TOOL_INPUT_FIELD_CHARS, DEFAULT_PROFILE_CONFIGS, DEFAULT_SKILL_POLICY, DEFAULT_SUBAGENT_POLICY, DEFAULT_SUBAGENT_TOOL_NAMES, DEFAULT_TOOL_INPUT_DIGEST_HEAD_CHARS, DELEGATION_TOOL_NAMES, DedupTracker, GuardrailPhase, HOOK_CONTRACT_VERSION, HOOK_NAMES, HookTimeoutError, InMemoryMemoryStore, JevProvider, MAX_ADJUSTMENTS, MODEL_RULES, ModelRequestError, NativeJsonSchemaStrategy, OpenAICompatibleProvider, OpenAIProvider, PREOPEN_TOOL_CALL_PREFIX, ProviderError, SMALL_TIER_SKILL_POLICY, StructuredOutputManager, TOOL_INPUT_DIGEST_KEY, ToolBasedStrategy, VertexProvider, agentVerdictRule, allowsSampling, appendBoundTools, applyDropParams, asModelRequestError, auditLog, azureContentSafety, bedrockGuardrail, budgetGuard, buildHandoffTools, buildResponseFormatSection, buildSkillHeaderBlock, buildSubagentCatalogBlock, buildSystemPrompt, buildToolDefinitionsSection, canOpenSkill, canSpawn, captureSnapshot, checkpointing, clearLearnedModelRules, codePresenceRule, coerceToolArgs, cognipeerGuardrail, cognipeerSink, collectAttachments, collectToolRetentionDeclarations, composeToolSets, compressDiffOutput, compressJsonOutput, compressLogOutput, compressSearchOutput, compressTextOutput, compressToolOutput, contentPartToText, contentToString, conversationHistory, countApproxTokens, countMessagesTokens, createAgent, createAgentNode, createAskUserQuestionTool, createBindSkillToolsTool, createCodeGuardrail, createContextPilotRuntime, createContextSummarizeNode, createContextTools, createDelegateTool, createGetToolResponseTool, createGuardrail, createGuardrailPlugin, createJsonGuardrail, createManageTodoListAliasTool, createManageTodoTool, createOpenSkillTool, createParallelTool, createPluginHost, createProvider, createRegexGuardrail, createResolverNode, createSearchSkillsTool, createSkillRegistryRef, createSkillTools, createSmartAgent, createSpawnTool, createSubagentRegistryRef, createSubagentTools, createTool, createToolLimitFinalizeNode, createToolsNode, customCallbackRule, customGuardrail, customSink, dedupeToolsByName, defaultTokenCounter, defineHook, definePlugin, describeContentPart, detectLanguage, detectTextFormat, detectVolatileContent, digestToolInputArguments, digestToolInputValue, effortBudget, emptyUsage, evaluateGuardrails, extractLatestUserQuery, extractMessageText, fileCheckpointStore, fileSink, findSubagent, formatZodError, fromLangchainModel, fromLangchainTools, fromNativeProvider, generateSpanId, generateTraceId, getLearnedModelRulePatch, getModelCapabilities, getNestedValue, getResolvedSmartConfig, getTokenCounter, hasMediaPart, hasToolResponseRecoveryReference, httpGuardrail, httpSink, inMemoryCheckpointStore, inMemoryConversationStore, isHookImplemented, isOpenAIHostedEndpoint, isSmartModel, isValidIban, isValidLuhn, isValidTckn, jsonSchemaRule, defaultBuildPayload as langfuseDefaultPayload, langfuseTracing, languageGuard, listLearnedModelRules, loadSkillsFromDisk, mapConsoleHookVerdict, mapReasoningEffort, mapTextParts, mcp, mediaKindOf, mediaPolicy, mergeRulePatch, modelIdCandidates, normalizeSmartAgentOptions, normalizeVerdicts, openAIModeration, otelTracing, otlpSink, outputGuard, parseApprovalDecision, parseModelError, parseSkillFrontmatter, pathSandbox, piiRedaction, pluginCapabilities, portkeyGateway, portkeyGuardrail, preopenSkills, preopenToolCallId, prepareStrictToolMenu, promptInjectionGuard, rateLimit, readMemoryFacts, redactText, regexGuardrail, regexRule, rememberModelRulePatch, replaceTextContent, resolveAvailableSkills, resolveAvailableSubagents, resolveInputRetention, resolveMemoryStore, resolveModelRule, resolveReasoning, resolveStrategy, resolveSubagentTools, resolveSummarizationRetention, resolveToolApprovalState, resolveUserQuestionState, responseCache, restoreSnapshot, restoreToolCalls, runSmartAgentEvalHarness, runWithModelAdjustments, scoreItemsByRelevance, searchSkills, seedChildMessages, selectTopIndicesInOrder, sessionMetrics, setTokenCounter, startStreamingSession, summarizeObject, supportsAdaptiveThinking, textFromContent, toMessageUsage, toStrictCompatible, toStrictToolSchema, tokenize, toolPolicy, traceSessionToOtlp, validateReasoningConfig, validateToolArgs, webhookApproval, withTools, withinDepth, writeSummaryFactsToMemory };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map