@cognipeer/agent-sdk 0.10.6 → 0.13.0

package/dist/index.cjs

@@ -2441,6 +2441,15 @@ function estimatePayloadBytes(value) {
     }
   }
 }
+function toMessageUsage(u) {
+  return {
+    prompt_tokens: u.inputTokens,
+    completion_tokens: u.outputTokens,
+    total_tokens: u.totalTokens,
+    prompt_tokens_details: { cached_tokens: u.cachedInputTokens, cache_write_tokens: u.cachedWriteTokens },
+    completion_tokens_details: { reasoning_tokens: u.reasoningTokens }
+  };
+}
 function fromNativeProvider(provider, options) {
   let boundTools = options?.__tools;
   const modelName = options?.model ?? provider.defaultModel ?? provider.providerName;
@@ -2450,8 +2459,9 @@ function fromNativeProvider(provider, options) {
     invoke: async (messages, _invokeOptions) => {
       const link = linkAbortSignal(_invokeOptions);
       try {
-        const request = buildRequest(messages, boundTools, options, _invokeOptions);
+        let request = buildRequest(messages, boundTools, options, _invokeOptions);
         if (link.signal) request.signal = link.signal;
+        request = await applyTransform(request);
         const response = await provider.complete(request);
         return toBaseChatMessage(response);
       } finally {
@@ -2461,33 +2471,46 @@ function fromNativeProvider(provider, options) {
     stream: async function* (messages, _invokeOptions) {
       const link = linkAbortSignal(_invokeOptions);
       try {
-        const request = buildRequest(messages, boundTools, options, _invokeOptions);
+        let request = buildRequest(messages, boundTools, options, _invokeOptions);
         request.stream = true;
         if (link.signal) request.signal = link.signal;
+        request = await applyTransform(request);
         let fullContent = "";
         let allToolCalls = [];
         let lastUsage;
         let reasoningBlocks;
+        let reasoningText = "";
+        let finishReason;
+        let responseModel;
         const toolCallBuffers = /* @__PURE__ */ new Map();
         for await (const chunk of provider.completeStream(request)) {
           if (chunk.delta.content) {
             fullContent += chunk.delta.content;
             yield chunk.delta.content;
           }
+          if (chunk.model) responseModel = chunk.model;
+          if (chunk.finishReason) finishReason = chunk.finishReason;
           if (chunk.delta.reasoning?.blocks?.length) {
             reasoningBlocks = chunk.delta.reasoning.blocks;
           }
+          const reasoningDelta = chunk.delta.reasoning?.summary;
+          if (reasoningDelta) {
+            reasoningText += reasoningDelta;
+            yield { type: "reasoning", reasoning_content: reasoningDelta };
+          }
           if (chunk.delta.toolCalls) {
             for (const tc of chunk.delta.toolCalls) {
               if (tc.id) {
                 const existing = toolCallBuffers.get(tc.id);
                 if (existing) {
                   if (tc.arguments) existing.arguments += tc.arguments;
+                  if (tc.thoughtSignature) existing.thoughtSignature = tc.thoughtSignature;
                 } else {
                   toolCallBuffers.set(tc.id, {
                     id: tc.id,
                     name: tc.name ?? "",
-                    arguments: tc.arguments ?? ""
+                    arguments: tc.arguments ?? "",
+                    ...tc.thoughtSignature ? { thoughtSignature: tc.thoughtSignature } : {}
                   });
                 }
               }
@@ -2498,8 +2521,18 @@ function fromNativeProvider(provider, options) {
         if (link.signal?.aborted) return;
         allToolCalls = [...toolCallBuffers.values()];
         const finalMessage = assembleMessage(fullContent, allToolCalls, lastUsage);
-        if (reasoningBlocks?.length) {
-          finalMessage.reasoning = { blocks: reasoningBlocks };
+        if (reasoningBlocks?.length || reasoningText) {
+          finalMessage.reasoning = {
+            ...reasoningBlocks?.length ? { blocks: reasoningBlocks } : {},
+            ...reasoningText ? { summary: reasoningText } : {}
+          };
+        }
+        if (finishReason || responseModel) {
+          finalMessage.response_metadata = {
+            ...finalMessage.response_metadata ?? {},
+            ...finishReason ? { finish_reason: finishReason } : {},
+            ...responseModel ? { model_name: responseModel } : {}
+          };
         }
         yield finalMessage;
       } finally {
@@ -2513,6 +2546,11 @@ function fromNativeProvider(provider, options) {
     }
   };
   return adapted;
+  async function applyTransform(req) {
+    if (!options?.transformRequest) return req;
+    const out = await options.transformRequest(req);
+    return out ?? req;
+  }
   function buildRequest(messages, tools, opts, invokeOptions) {
     const req = {
       model: opts?.model ?? modelName,
@@ -2520,6 +2558,10 @@ function fromNativeProvider(provider, options) {
     };
     if (opts?.temperature != null) req.temperature = opts.temperature;
     if (opts?.maxTokens != null) req.maxTokens = opts.maxTokens;
+    if (opts?.topP != null) req.topP = opts.topP;
+    if (opts?.stop?.length) req.stop = opts.stop;
+    if (opts?.presencePenalty != null) req.presencePenalty = opts.presencePenalty;
+    if (opts?.frequencyPenalty != null) req.frequencyPenalty = opts.frequencyPenalty;
     if (tools?.length) req.tools = tools;
     if (opts?.extra) req.extra = opts.extra;
     const reasoningOverride = invokeOptions?.reasoning;
@@ -2572,7 +2614,8 @@ function toUnifiedMessage(msg) {
     unified.toolCalls = msg.tool_calls.map((tc) => ({
       id: tc.id,
       name: tc.function?.name ?? tc.name ?? "",
-      arguments: tc.function?.arguments ?? tc.arguments ?? "{}"
+      arguments: tc.function?.arguments ?? tc.arguments ?? "{}",
+      ...tc.thoughtSignature ? { thoughtSignature: tc.thoughtSignature } : {}
     }));
   }
   const reasoning = msg.reasoning;
@@ -2846,29 +2889,16 @@ function toToolDefinition(tool, strict) {
   }
   return { name, description, parameters, ...useStrict ? { strict: true } : {} };
 }
+function legacyTokenUsage(u) {
+  return { ...toMessageUsage(u), cached_tokens: u.cachedInputTokens, cache_write_tokens: u.cachedWriteTokens };
+}
 function toBaseChatMessage(response) {
   const msg = {
     role: "assistant",
     content: response.content ?? "",
-    usage: {
-      prompt_tokens: response.usage.inputTokens,
-      completion_tokens: response.usage.outputTokens,
-      total_tokens: response.usage.totalTokens,
-      prompt_tokens_details: {
-        cached_tokens: response.usage.cachedInputTokens
-      },
-      completion_tokens_details: {
-        reasoning_tokens: response.usage.reasoningTokens
-      }
-    },
+    usage: toMessageUsage(response.usage),
     response_metadata: {
-      token_usage: {
-        prompt_tokens: response.usage.inputTokens,
-        completion_tokens: response.usage.outputTokens,
-        total_tokens: response.usage.totalTokens,
-        cached_tokens: response.usage.cachedInputTokens,
-        cache_write_tokens: response.usage.cachedWriteTokens
-      },
+      token_usage: legacyTokenUsage(response.usage),
       finish_reason: response.finishReason,
       model_name: response.model
     }
@@ -2877,7 +2907,8 @@ function toBaseChatMessage(response) {
     msg.tool_calls = response.toolCalls.map((tc) => ({
       id: tc.id,
       type: "function",
-      function: { name: tc.name, arguments: tc.arguments }
+      function: { name: tc.name, arguments: tc.arguments },
+      ...tc.thoughtSignature ? { thoughtSignature: tc.thoughtSignature } : {}
     }));
   }
   if (response.reasoning && (response.reasoning.blocks?.length || response.reasoning.summary)) {
@@ -2891,32 +2922,15 @@ function assembleMessage(content, toolCalls, usage) {
     content
   };
   if (usage) {
-    msg.usage = {
-      prompt_tokens: usage.inputTokens,
-      completion_tokens: usage.outputTokens,
-      total_tokens: usage.totalTokens,
-      prompt_tokens_details: {
-        cached_tokens: usage.cachedInputTokens
-      },
-      completion_tokens_details: {
-        reasoning_tokens: usage.reasoningTokens
-      }
-    };
-    msg.response_metadata = {
-      token_usage: {
-        prompt_tokens: usage.inputTokens,
-        completion_tokens: usage.outputTokens,
-        total_tokens: usage.totalTokens,
-        cached_tokens: usage.cachedInputTokens,
-        cache_write_tokens: usage.cachedWriteTokens
-      }
-    };
+    msg.usage = toMessageUsage(usage);
+    msg.response_metadata = { token_usage: legacyTokenUsage(usage) };
   }
   if (toolCalls.length > 0) {
     msg.tool_calls = toolCalls.map((tc) => ({
       id: tc.id,
       type: "function",
-      function: { name: tc.name, arguments: tc.arguments }
+      function: { name: tc.name, arguments: tc.arguments },
+      ...tc.thoughtSignature ? { thoughtSignature: tc.thoughtSignature } : {}
     }));
   }
   return msg;
@@ -2949,8 +2963,8 @@ function resolveCapabilities(provider) {
       return {
         structuredOutput: "tool_based",
         strictToolCalling: false,
-        streaming: false,
-        // streaming uses binary protocol
+        streaming: true,
+        // ConverseStream (AWS event-stream frames)
         provider: "bedrock"
       };
     case "vertex":
@@ -4656,6 +4670,10 @@ ${append}`;
               if (chunk && typeof chunk === "object" && chunk.role) {
                 streamedMessage = chunk;
               }
+              if (chunk && typeof chunk === "object" && chunk.type === "reasoning" && typeof chunk.reasoning_content === "string") {
+                onEvent?.({ type: "reasoning", text: chunk.reasoning_content });
+                continue;
+              }
               const text = extractText2(chunk);
               const isAssembledMessage = Boolean(chunk && typeof chunk === "object" && chunk.role) && text.length > 0 && text === streamedText;
               if (text && !isAssembledMessage) {
@@ -5087,10 +5105,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" };
       }
@@ -6101,7 +6119,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)) {
@@ -11536,6 +11554,28 @@ async function runSmartAgentEvalHarness(params) {
   return results;
 }
 
+// src/providers/types.ts
+function emptyUsage() {
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0,
+    cachedInputTokens: 0,
+    cachedWriteTokens: 0,
+    cachedOutputTokens: 0,
+    reasoningTokens: 0
+  };
+}
+var ProviderError = class extends Error {
+  constructor(message, provider, statusCode, responseBody) {
+    super(message);
+    this.provider = provider;
+    this.statusCode = statusCode;
+    this.responseBody = responseBody;
+    this.name = "ProviderError";
+  }
+};
+
 // src/providers/base.ts
 var DEFAULT_RETRY = {
   maxRetries: 3,
@@ -11546,6 +11586,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
@@ -11587,34 +11677,13 @@ var BaseProvider = class {
   }
 };
 
-// src/providers/types.ts
-function emptyUsage() {
-  return {
-    inputTokens: 0,
-    outputTokens: 0,
-    totalTokens: 0,
-    cachedInputTokens: 0,
-    cachedWriteTokens: 0,
-    cachedOutputTokens: 0,
-    reasoningTokens: 0
-  };
-}
-var ProviderError = class extends Error {
-  constructor(message, provider, statusCode, responseBody) {
-    super(message);
-    this.provider = provider;
-    this.statusCode = statusCode;
-    this.responseBody = responseBody;
-    this.name = "ProviderError";
-  }
-};
-
 // src/providers/jev.ts
 var JEV_DEFAULT_BASE_URL = "https://api.typesafe.ai";
 var JevProvider = class extends BaseProvider {
   constructor(config) {
     super();
     this.providerName = "jev";
+    this.configureTransport(config);
     this.apiKey = config.apiKey;
     this.baseURL = (config.baseURL ?? JEV_DEFAULT_BASE_URL).replace(/\/$/, "");
     this.defaultModel = config.defaultModel;
@@ -11630,7 +11699,7 @@ var JevProvider = class extends BaseProvider {
       questions: request.questions
     };
     const res = await this.doFetchWithRetry(
-      () => fetch(`${this.baseURL}/v1/systemone`, {
+      () => this.httpFetch(`${this.baseURL}/v1/systemone`, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
@@ -13866,12 +13935,12 @@ function responseCache(config = {}) {
   };
 }
 function signRequest(req) {
-  const now = /* @__PURE__ */ new Date();
+  const now = req.now ?? /* @__PURE__ */ new Date();
   const dateStamp = toDateStamp(now);
   const amzDate = toAmzDate(now);
   const parsed = new URL(req.url);
   const host = parsed.host;
-  const canonicalUri = parsed.pathname || "/";
+  const canonicalUri = (parsed.pathname || "/").split("/").map((seg) => encodeURIComponent(seg).replace(/[!'()*]/g, (c) => "%" + c.charCodeAt(0).toString(16).toUpperCase())).join("/");
   const canonicalQuerystring = sortQueryParams(parsed.searchParams);
   const headers = {
     ...req.headers,
@@ -15188,98 +15257,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;
@@ -15291,52 +16067,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;
@@ -15345,19 +16176,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",
@@ -15549,11 +16653,64 @@ function isObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// src/providers/utils/embeddings.ts
+function chunkArray(items, size) {
+  const n = Math.max(1, Math.floor(size));
+  const out = [];
+  for (let i = 0; i < items.length; i += n) out.push(items.slice(i, i + n));
+  return out;
+}
+async function mapWithConcurrency(items, limit, fn, signal) {
+  const results = new Array(items.length);
+  let next = 0;
+  let failure;
+  let failed = false;
+  const worker = async () => {
+    while (!failed) {
+      if (signal?.aborted) throw signal.reason ?? new Error("aborted");
+      const i = next++;
+      if (i >= items.length) return;
+      try {
+        results[i] = await fn(items[i], i);
+      } catch (err) {
+        failed = true;
+        failure = err;
+        return;
+      }
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(Math.max(1, limit), items.length) }, worker));
+  if (failed) throw failure;
+  return results;
+}
+function decodeBase64Vector(b64) {
+  const buf = Buffer.from(b64, "base64");
+  const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+  const out = new Array(Math.floor(buf.byteLength / 4));
+  for (let i = 0; i < out.length; i++) out[i] = view.getFloat32(i * 4, true);
+  return out;
+}
+function assertVectorCount(provider, vectors, expected) {
+  if (vectors.length !== expected) {
+    throw new ProviderError(
+      `${provider} embeddings returned ${vectors.length} vectors for ${expected} inputs`,
+      provider,
+      502
+    );
+  }
+}
+function requireEmbeddingModel(provider, model) {
+  if (!model) throw new ProviderError(`${provider} embeddings require a model`, provider, 400);
+  return model;
+}
+
 // src/providers/openai.ts
-var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
+var OpenAIProvider = class extends BaseProvider {
   constructor(config) {
     super();
     this.providerName = "openai";
+    this.configureTransport(config);
+    this.maxTokensParam = config.maxTokensParam ?? "auto";
     this.apiKey = config.apiKey;
     this.baseURL = (config.baseURL ?? "https://api.openai.com/v1").replace(/\/$/, "");
     this.defaultModel = config.defaultModel ?? "gpt-4o";
@@ -15561,10 +16718,14 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
       ...config.defaultHeaders,
       ...config.organization ? { "OpenAI-Organization": config.organization } : {}
     };
-    this.responsesApi = config.responsesApi ?? "auto";
-    const ownInstance = new.target === _OpenAIProvider;
-    this.responsesApiModels = ownInstance ? [...config.responsesApiModels ?? []] : [];
-    this.responsesStreaming = ownInstance && config.responsesStreaming === true;
+    const legacy = config.responsesApi;
+    const explicit = config.api === "chat" || config.api === "responses" ? config.api : void 0;
+    this.responsesApi = explicit === "responses" ? "always" : explicit === "chat" ? "never" : legacy ?? (config._autoMeansChat ? "never" : "auto");
+    this.apiExplicitChat = explicit === "chat" || explicit === void 0 && legacy === "never";
+    this.apiExplicitResponses = this.responsesApi === "always";
+    this.apiResponsesNative = explicit === "responses";
+    this.responsesApiModels = [...config.responsesApiModels ?? []];
+    this.responsesStreaming = config.responsesStreaming ?? this.apiResponsesNative;
     if (config.retry) this.retryPolicy = { ...this.retryPolicy, ...config.retry };
   }
   /** True when the caller listed this request's model in `responsesApiModels`. */
@@ -15590,9 +16751,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);
   }
@@ -15600,14 +16762,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;
       }
@@ -15625,8 +16786,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 = "";
@@ -15657,9 +16817,14 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
         delta: {},
         finishReason: mapFinishReason(choice.finish_reason)
       };
+      if (typeof choice.finish_reason === "string") out.rawFinishReason = choice.finish_reason;
+      const fields = pickProviderFields(chunk, delta, choice);
+      if (fields) out.providerFields = fields;
       if (delta.content) {
         out.delta.content = delta.content;
       }
+      const reasoningDelta = extractReasoningText(delta);
+      if (reasoningDelta) out.delta.reasoning = { summary: reasoningDelta };
       if (delta.tool_calls) {
         const partials = [];
         for (const tc of delta.tool_calls) {
@@ -15671,7 +16836,7 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
           if (tc.id) buf.id = tc.id;
           if (tc.function?.name) buf.name = tc.function.name;
           if (tc.function?.arguments) buf.arguments += tc.function.arguments;
-          partials.push({ id: buf.id, name: buf.name || void 0, arguments: tc.function?.arguments });
+          partials.push({ id: buf.id, name: buf.name || void 0, arguments: tc.function?.arguments, index: idx });
         }
         out.delta.toolCalls = partials;
       }
@@ -15679,22 +16844,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") {
@@ -15720,14 +16978,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);
   }
@@ -15740,15 +17001,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;
@@ -15766,19 +17025,28 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
         case "response.output_text.delta":
           if (data.delta) yield { id, model, delta: { content: data.delta } };
           break;
+        case "response.reasoning_summary_part.added":
+          if (streamedSummary) yield { id, model, delta: { reasoning: { summary: "\n\n" } } };
+          break;
+        case "response.reasoning_summary_text.delta":
+          if (typeof data.delta === "string" && data.delta) {
+            streamedSummary = true;
+            yield { id, model, delta: { reasoning: { summary: data.delta } } };
+          }
+          break;
         case "response.output_item.added": {
           const item = data.item;
           if (item?.type !== "function_call") break;
-          const call = { callId: item.call_id ?? item.id ?? "", name: item.name ?? "", arguments: item.arguments ?? "" };
+          const call = { callId: item.call_id ?? item.id ?? "", name: item.name ?? "", arguments: item.arguments ?? "", index: calls.size };
           calls.set(item.id ?? call.callId, call);
-          yield { id, model, delta: { toolCalls: [{ id: call.callId, name: call.name, arguments: call.arguments }] } };
+          yield { id, model, delta: { toolCalls: [{ id: call.callId, name: call.name, arguments: call.arguments, index: call.index }] } };
           break;
         }
         case "response.function_call_arguments.delta": {
           const call = calls.get(data.item_id);
           if (!call || !data.delta) break;
           call.arguments += data.delta;
-          yield { id, model, delta: { toolCalls: [{ id: call.callId, arguments: data.delta }] } };
+          yield { id, model, delta: { toolCalls: [{ id: call.callId, arguments: data.delta, index: call.index }] } };
           break;
         }
         case "response.output_item.done": {
@@ -15787,13 +17055,13 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
           const full = typeof item.arguments === "string" ? item.arguments : "";
           const call = calls.get(item.id ?? item.call_id);
           if (!call) {
-            const added = { callId: item.call_id ?? item.id ?? "", name: item.name ?? "", arguments: full };
+            const added = { callId: item.call_id ?? item.id ?? "", name: item.name ?? "", arguments: full, index: calls.size };
             calls.set(item.id ?? added.callId, added);
-            yield { id, model, delta: { toolCalls: [{ id: added.callId, name: added.name, arguments: full }] } };
+            yield { id, model, delta: { toolCalls: [{ id: added.callId, name: added.name, arguments: full, index: added.index }] } };
           } else if (full.length > call.arguments.length && full.startsWith(call.arguments)) {
             const rest = full.slice(call.arguments.length);
             call.arguments = full;
-            yield { id, model, delta: { toolCalls: [{ id: call.callId, arguments: rest }] } };
+            yield { id, model, delta: { toolCalls: [{ id: call.callId, arguments: rest, index: call.index }] } };
           }
           break;
         }
@@ -15816,18 +17084,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",
@@ -15859,7 +17129,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. */
@@ -15926,7 +17197,7 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
       ...this.defaultHeaders
     };
     const payload = JSON.stringify(body);
-    const res = await this.doFetchWithRetry(() => fetch(url, { method: "POST", headers, body: payload, signal }), signal);
+    const res = await this.doFetchWithRetry(() => this.httpFetch(url, { method: "POST", headers, body: payload, signal }), signal);
     if (!res.ok) {
       const text = await res.text().catch(() => "");
       throw new ProviderError(
@@ -16055,7 +17326,7 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
       ...this.defaultHeaders
     };
     const payload = JSON.stringify(body);
-    const res = await this.doFetchWithRetry(() => fetch(url, { method: "POST", headers, body: payload, signal }), signal);
+    const res = await this.doFetchWithRetry(() => this.httpFetch(url, { method: "POST", headers, body: payload, signal }), signal);
     if (!res.ok) {
       const text = await res.text().catch(() => "");
       throw new ProviderError(
@@ -16075,6 +17346,8 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
       name: tc.function?.name ?? "",
       arguments: tc.function?.arguments ?? "{}"
     }));
+    const reasoningText = extractReasoningText(message);
+    const providerFields = pickProviderFields(json, message, choice);
     return {
       id: json.id ?? "",
       model: json.model ?? "",
@@ -16082,6 +17355,9 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
       toolCalls,
       usage: this.extractUsage(json.usage),
       finishReason: mapFinishReason(choice?.finish_reason),
+      ...typeof choice?.finish_reason === "string" ? { rawFinishReason: choice.finish_reason } : {},
+      ...providerFields ? { providerFields } : {},
+      ...reasoningText ? { reasoning: { summary: reasoningText } } : {},
       raw: json
     };
   }
@@ -16100,10 +17376,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 ?? {};
@@ -16176,36 +17469,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;
@@ -16234,8 +17571,11 @@ var AnthropicProvider = class extends BaseProvider {
             currentToolCalls.set(idx, {
               id: block.id ?? "",
               name: block.name ?? "",
-              arguments: ""
+              arguments: "",
+              ordinal: toolOrdinal++
             });
+            const opened = currentToolCalls.get(idx);
+            yield { id, model, delta: { toolCalls: [{ id: opened.id, name: opened.name, arguments: "", index: opened.ordinal }] } };
           } else if (block?.type === "thinking") {
             reasoningBlocks.set(idx, { type: "thinking", text: block.thinking ?? "", signature: block.signature });
           } else if (block?.type === "redacted_thinking") {
@@ -16273,7 +17613,7 @@ var AnthropicProvider = class extends BaseProvider {
                 id,
                 model,
                 delta: {
-                  toolCalls: [{ id: tc.id, name: tc.name, arguments: delta.partial_json }]
+                  toolCalls: [{ id: tc.id, name: tc.name, arguments: delta.partial_json, index: tc.ordinal }]
                 }
               };
             }
@@ -16286,8 +17626,10 @@ var AnthropicProvider = class extends BaseProvider {
           const delta = data.delta;
           if (data.usage) {
             outputTokens = data.usage.output_tokens ?? outputTokens;
+            thinkingTokens = data.usage.output_tokens_details?.thinking_tokens ?? thinkingTokens;
           }
           const finishReason = mapAnthropicStopReason(delta?.stop_reason);
+          const rawFinishReason = typeof delta?.stop_reason === "string" ? delta.stop_reason : void 0;
           const usage = {
             inputTokens,
             outputTokens,
@@ -16295,7 +17637,7 @@ var AnthropicProvider = class extends BaseProvider {
             cachedInputTokens: cacheReadInputTokens,
             cachedWriteTokens: cacheCreationInputTokens,
             cachedOutputTokens: 0,
-            reasoningTokens: 0
+            reasoningTokens: thinkingTokens
           };
           const blocks = [...reasoningBlocks.values()].filter(
             (b) => b.type === "thinking" && b.signature || b.type === "redacted_thinking" && b.data
@@ -16305,6 +17647,7 @@ var AnthropicProvider = class extends BaseProvider {
             model,
             delta: blocks.length > 0 ? { reasoning: { blocks } } : {},
             finishReason,
+            ...rawFinishReason ? { rawFinishReason } : {},
             usage
           };
           break;
@@ -16319,12 +17662,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) {
@@ -16334,6 +17677,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;
@@ -16345,18 +17689,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) {
@@ -16487,6 +17842,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 = {
@@ -16496,7 +17876,7 @@ var AnthropicProvider = class extends BaseProvider {
       ...this.defaultHeaders
     };
     const payload = JSON.stringify(body);
-    const res = await this.doFetchWithRetry(() => fetch(url, { method: "POST", headers, body: payload, signal }), signal);
+    const res = await this.doFetchWithRetry(() => this.httpFetch(url, { method: "POST", headers, body: payload, signal }), signal);
     if (!res.ok) {
       const text = await res.text().catch(() => "");
       throw new ProviderError(
@@ -16541,10 +17921,9 @@ var AnthropicProvider = class extends BaseProvider {
       cachedInputTokens: usage.cache_read_input_tokens ?? 0,
       cachedWriteTokens: usage.cache_creation_input_tokens ?? 0,
       cachedOutputTokens: 0,
-      // Anthropic bills thinking tokens inside `output_tokens` and does not
-      // expose a separate count, so reasoningTokens stays 0 here (cost is still
-      // captured via outputTokens). See docs for the limitation.
-      reasoningTokens: 0
+      // Thinking tokens are billed inside `output_tokens`; newer models also
+      // report the split as `output_tokens_details.thinking_tokens`.
+      reasoningTokens: usage.output_tokens_details?.thinking_tokens ?? 0
     };
     return {
       id: json.id ?? "",
@@ -16553,6 +17932,7 @@ var AnthropicProvider = class extends BaseProvider {
       toolCalls,
       usage: tokenUsage,
       finishReason: mapAnthropicStopReason(json.stop_reason),
+      ...typeof json.stop_reason === "string" ? { rawFinishReason: json.stop_reason } : {},
       reasoning: reasoningBlocks.length > 0 ? { blocks: reasoningBlocks, summary: summaryParts.join("\n").trim() || void 0 } : void 0,
       raw: json
     };
@@ -16598,7 +17978,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(/\/$/, "");
@@ -16613,16 +18002,17 @@ var AzureProvider = class extends OpenAIProvider {
     }
     const url = `${this.endpoint}/openai/deployments/${deployment}/chat/completions?api-version=${this.apiVersion}`;
     const { model: _model, ...bodyWithoutModel } = body;
-    const res = await fetch(url, {
+    const payload = JSON.stringify(bodyWithoutModel);
+    const res = await this.doFetchWithRetry(() => this.httpFetch(url, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
         "api-key": this.azureApiKey,
         ...this.defaultHeaders
       },
-      body: JSON.stringify(bodyWithoutModel),
+      body: payload,
       signal
-    });
+    }), signal);
     if (!res.ok) {
       const text = await res.text().catch(() => "");
       throw new ProviderError(
@@ -16634,6 +18024,32 @@ var AzureProvider = class extends OpenAIProvider {
     }
     return res;
   }
+  /** Azure embeddings: the deployment named by the request's model (falling back
+   * to the configured deployment) in the path, api-key auth. */
+  async embeddingsFetch(body, signal) {
+    const deployment = body.model || this.deploymentName;
+    if (!deployment) {
+      throw new ProviderError("Azure embeddings require a deployment name or model", this.providerName, 400);
+    }
+    const url = `${this.endpoint}/openai/deployments/${deployment}/embeddings?api-version=${this.apiVersion}`;
+    const { model: _model, ...bodyWithoutModel } = body;
+    const payload = JSON.stringify(bodyWithoutModel);
+    const res = await this.doFetchWithRetry(() => this.httpFetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "api-key": this.azureApiKey,
+        ...this.defaultHeaders
+      },
+      body: payload,
+      signal
+    }), signal);
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new ProviderError(`Azure OpenAI embeddings API error ${res.status}: ${text}`, this.providerName, res.status, text);
+    }
+    return res;
+  }
   /** Azure exposes the Responses API at /openai/responses with api-key auth.
    * Reasoning summaries require a preview api-version; callers can override via
    * the `apiVersion` config. */
@@ -16645,7 +18061,7 @@ var AzureProvider = class extends OpenAIProvider {
     }
     const url = `${this.endpoint}/openai/responses?api-version=${this.apiVersion}`;
     const payload = JSON.stringify({ ...body, model: deployment });
-    const res = await fetch(url, {
+    const res = await this.doFetchWithRetry(() => this.httpFetch(url, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -16654,7 +18070,7 @@ var AzureProvider = class extends OpenAIProvider {
       },
       body: payload,
       signal
-    });
+    }), signal);
     if (!res.ok) {
       const text = await res.text().catch(() => "");
       throw new ProviderError(
@@ -16690,20 +18106,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 = {
@@ -16720,25 +18272,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)
@@ -16762,8 +18491,9 @@ var BedrockProvider = class extends BaseProvider {
       body.toolConfig = {
         tools
       };
+      const forceOk = !downgradeToolChoice && supportsForcedToolChoice(request.model || this.defaultModel);
       if (request.toolChoice != null) {
-        if (request.toolChoice === "auto") {
+        if (request.toolChoice === "auto" || !forceOk && request.toolChoice !== "none") {
           body.toolConfig.toolChoice = { auto: {} };
         } else if (request.toolChoice === "required") {
           body.toolConfig.toolChoice = { any: {} };
@@ -16773,9 +18503,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) {
@@ -16898,9 +18641,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({
@@ -16908,7 +18677,7 @@ var BedrockProvider = class extends BaseProvider {
         url,
         headers: {
           "Content-Type": "application/json",
-          Accept: "application/json",
+          Accept: stream ? "application/vnd.amazon.eventstream" : "application/json",
           ...this.defaultHeaders
         },
         body: bodyStr,
@@ -16916,7 +18685,7 @@ var BedrockProvider = class extends BaseProvider {
         service: "bedrock",
         credentials: this.credentials
       });
-      return fetch(url, { method: "POST", headers, body: bodyStr, signal });
+      return this.httpFetch(url, { method: "POST", headers, body: bodyStr, signal });
     }, signal);
     if (!res.ok) {
       const text = await res.text().catch(() => "");
@@ -16927,7 +18696,7 @@ var BedrockProvider = class extends BaseProvider {
         text
       );
     }
-    return res.json();
+    return res;
   }
   parseResponse(json, modelId) {
     const output = json.output?.message;
@@ -16963,8 +18732,8 @@ var BedrockProvider = class extends BaseProvider {
       inputTokens: usage.inputTokens ?? 0,
       outputTokens: usage.outputTokens ?? 0,
       totalTokens: usage.totalTokens ?? (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0),
-      cachedInputTokens: usage.cacheReadInputTokenCount ?? 0,
-      cachedWriteTokens: usage.cacheWriteInputTokenCount ?? 0,
+      cachedInputTokens: usage.cacheReadInputTokens ?? usage.cacheReadInputTokenCount ?? 0,
+      cachedWriteTokens: usage.cacheWriteInputTokens ?? usage.cacheWriteInputTokenCount ?? 0,
       cachedOutputTokens: 0,
       // Bedrock bills thinking tokens inside outputTokens; no separate count.
       reasoningTokens: 0
@@ -16976,11 +18745,26 @@ var BedrockProvider = class extends BaseProvider {
       toolCalls,
       usage: tokenUsage,
       finishReason: mapBedrockStopReason(json.stopReason),
+      ...typeof json.stopReason === "string" ? { rawFinishReason: json.stopReason } : {},
       reasoning: reasoningBlocks.length > 0 ? { blocks: reasoningBlocks, summary: summaryParts.join("\n").trim() || void 0 } : void 0,
       raw: json
     };
   }
 };
+var CONVERSE_TOP_LEVEL_FIELDS = /* @__PURE__ */ new Set([
+  "messages",
+  "system",
+  "inferenceConfig",
+  "toolConfig",
+  "guardrailConfig",
+  "additionalModelRequestFields",
+  "additionalModelResponseFieldPaths",
+  "promptVariables",
+  "requestMetadata",
+  "performanceConfig",
+  "serviceTier",
+  "outputConfig"
+]);
 function appendBedrockReasoning(content, blocks) {
   if (!blocks?.length) return;
   for (const b of blocks) {
@@ -16995,6 +18779,23 @@ function appendBedrockReasoning(content, blocks) {
     }
   }
 }
+function bedrockExceptionStatus(code) {
+  switch (code) {
+    case "throttlingException":
+      return 429;
+    case "validationException":
+      return 400;
+    case "modelTimeoutException":
+      return 408;
+    case "serviceUnavailableException":
+      return 503;
+    case "internalServerException":
+    case "modelStreamErrorException":
+      return 500;
+    default:
+      return void 0;
+  }
+}
 function mapBedrockStopReason(reason) {
   switch (reason) {
     case "end_turn":
@@ -17003,8 +18804,10 @@ function mapBedrockStopReason(reason) {
     case "tool_use":
       return "tool_calls";
     case "max_tokens":
+    case "model_context_window_exceeded":
       return "length";
     case "content_filtered":
+    case "guardrail_intervened":
     case "guardrail":
       return "content_filter";
     default:
@@ -17034,10 +18837,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;
@@ -17050,7 +18855,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);
   }
@@ -17058,8 +18863,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)) {
@@ -17070,7 +18876,7 @@ var VertexProvider = class extends BaseProvider {
         } catch {
           continue;
         }
-        yield this.parseStreamChunk(chunk, modelId);
+        yield this.parseStreamChunk(chunk, modelId, counter);
       }
     } else {
       const reader = res.body.getReader();
@@ -17088,7 +18894,7 @@ var VertexProvider = class extends BaseProvider {
             if (!trimmed || trimmed === "[" || trimmed === "]") continue;
             try {
               const chunk = JSON.parse(trimmed);
-              yield this.parseStreamChunk(chunk, modelId);
+              yield this.parseStreamChunk(chunk, modelId, counter);
             } catch {
               buffer = line + "\n" + buffer;
               break;
@@ -17099,7 +18905,7 @@ var VertexProvider = class extends BaseProvider {
         if (remaining && remaining !== "[" && remaining !== "]") {
           try {
             const chunk = JSON.parse(remaining);
-            yield this.parseStreamChunk(chunk, modelId);
+            yield this.parseStreamChunk(chunk, modelId, counter);
           } catch {
           }
         }
@@ -17110,6 +18916,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}`;
@@ -17207,7 +19055,9 @@ var VertexProvider = class extends BaseProvider {
           functionCall: {
             name: tc.name,
             args: safeJsonParse3(tc.arguments)
-          }
+          },
+          // Gemini 3 requires the signature of each functionCall echoed back.
+          ...tc.thoughtSignature ? { thoughtSignature: tc.thoughtSignature } : {}
         });
       }
       return { role: "model", parts: parts2 };
@@ -17304,7 +19154,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}`
@@ -17316,20 +19166,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,
@@ -17357,7 +19225,8 @@ var VertexProvider = class extends BaseProvider {
         toolCalls.push({
           id: `call_${toolCallIdx++}`,
           name: part.functionCall.name,
-          arguments: JSON.stringify(part.functionCall.args ?? {})
+          arguments: JSON.stringify(part.functionCall.args ?? {}),
+          ...part.thoughtSignature ? { thoughtSignature: part.thoughtSignature } : {}
         });
       }
     }
@@ -17378,11 +19247,12 @@ var VertexProvider = class extends BaseProvider {
       toolCalls,
       usage: tokenUsage,
       finishReason: mapGeminiFinishReason(candidate?.finishReason),
+      ...typeof candidate?.finishReason === "string" ? { rawFinishReason: candidate.finishReason } : {},
       reasoning: thoughtParts.length > 0 ? { summary: thoughtParts.join("\n").trim() || void 0 } : void 0,
       raw: json
     };
   }
-  parseStreamChunk(chunk, modelId) {
+  parseStreamChunk(chunk, modelId, counter) {
     const candidate = chunk.candidates?.[0];
     const parts = candidate?.content?.parts ?? [];
     const delta = {};
@@ -17396,9 +19266,12 @@ var VertexProvider = class extends BaseProvider {
       } else if (part.functionCall) {
         if (!delta.toolCalls) delta.toolCalls = [];
         delta.toolCalls.push({
-          id: `call_${delta.toolCalls.length}`,
+          // Unique across the whole stream: the adapter merges chunks by id.
+          id: `call_${counter.next}`,
+          index: counter.next++,
           name: part.functionCall.name,
-          arguments: JSON.stringify(part.functionCall.args ?? {})
+          arguments: JSON.stringify(part.functionCall.args ?? {}),
+          ...part.thoughtSignature ? { thoughtSignature: part.thoughtSignature } : {}
         });
       }
     }
@@ -17420,10 +19293,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":
@@ -17495,6 +19379,9 @@ exports.HOOK_NAMES = HOOK_NAMES;
 exports.HookTimeoutError = HookTimeoutError;
 exports.InMemoryMemoryStore = InMemoryMemoryStore;
 exports.JevProvider = JevProvider;
+exports.MAX_ADJUSTMENTS = MAX_ADJUSTMENTS;
+exports.MODEL_RULES = MODEL_RULES;
+exports.ModelRequestError = ModelRequestError;
 exports.NativeJsonSchemaStrategy = NativeJsonSchemaStrategy;
 exports.OpenAICompatibleProvider = OpenAICompatibleProvider;
 exports.OpenAIProvider = OpenAIProvider;
@@ -17506,7 +19393,10 @@ exports.TOOL_INPUT_DIGEST_KEY = TOOL_INPUT_DIGEST_KEY;
 exports.ToolBasedStrategy = ToolBasedStrategy;
 exports.VertexProvider = VertexProvider;
 exports.agentVerdictRule = agentVerdictRule;
+exports.allowsSampling = allowsSampling;
 exports.appendBoundTools = appendBoundTools;
+exports.applyDropParams = applyDropParams;
+exports.asModelRequestError = asModelRequestError;
 exports.auditLog = auditLog;
 exports.azureContentSafety = azureContentSafety;
 exports.bedrockGuardrail = bedrockGuardrail;
@@ -17521,6 +19411,7 @@ exports.canOpenSkill = canOpenSkill;
 exports.canSpawn = canSpawn;
 exports.captureSnapshot = captureSnapshot;
 exports.checkpointing = checkpointing;
+exports.clearLearnedModelRules = clearLearnedModelRules;
 exports.codePresenceRule = codePresenceRule;
 exports.coerceToolArgs = coerceToolArgs;
 exports.cognipeerGuardrail = cognipeerGuardrail;
@@ -17583,6 +19474,7 @@ exports.detectTextFormat = detectTextFormat;
 exports.detectVolatileContent = detectVolatileContent;
 exports.digestToolInputArguments = digestToolInputArguments;
 exports.digestToolInputValue = digestToolInputValue;
+exports.effortBudget = effortBudget;
 exports.emptyUsage = emptyUsage;
 exports.evaluateGuardrails = evaluateGuardrails;
 exports.extractLatestUserQuery = extractLatestUserQuery;
@@ -17596,6 +19488,7 @@ exports.fromLangchainTools = fromLangchainTools;
 exports.fromNativeProvider = fromNativeProvider;
 exports.generateSpanId = generateSpanId;
 exports.generateTraceId = generateTraceId;
+exports.getLearnedModelRulePatch = getLearnedModelRulePatch;
 exports.getModelCapabilities = getModelCapabilities;
 exports.getNestedValue = getNestedValue;
 exports.getResolvedSmartConfig = getResolvedSmartConfig;
@@ -17616,12 +19509,16 @@ exports.jsonSchemaRule = jsonSchemaRule;
 exports.langfuseDefaultPayload = defaultBuildPayload;
 exports.langfuseTracing = langfuseTracing;
 exports.languageGuard = languageGuard;
+exports.listLearnedModelRules = listLearnedModelRules;
 exports.loadSkillsFromDisk = loadSkillsFromDisk;
 exports.mapConsoleHookVerdict = mapConsoleHookVerdict;
+exports.mapReasoningEffort = mapReasoningEffort;
 exports.mapTextParts = mapTextParts;
 exports.mcp = mcp;
 exports.mediaKindOf = mediaKindOf;
 exports.mediaPolicy = mediaPolicy;
+exports.mergeRulePatch = mergeRulePatch;
+exports.modelIdCandidates = modelIdCandidates;
 exports.normalizeSmartAgentOptions = normalizeSmartAgentOptions;
 exports.normalizeVerdicts = normalizeVerdicts;
 exports.openAIModeration = openAIModeration;
@@ -17629,6 +19526,7 @@ exports.otelTracing = otelTracing;
 exports.otlpSink = otlpSink;
 exports.outputGuard = outputGuard;
 exports.parseApprovalDecision = parseApprovalDecision;
+exports.parseModelError = parseModelError;
 exports.parseSkillFrontmatter = parseSkillFrontmatter;
 exports.pathSandbox = pathSandbox;
 exports.piiRedaction = piiRedaction;
@@ -17644,11 +19542,13 @@ exports.readMemoryFacts = readMemoryFacts;
 exports.redactText = redactText;
 exports.regexGuardrail = regexGuardrail;
 exports.regexRule = regexRule;
+exports.rememberModelRulePatch = rememberModelRulePatch;
 exports.replaceTextContent = replaceTextContent;
 exports.resolveAvailableSkills = resolveAvailableSkills;
 exports.resolveAvailableSubagents = resolveAvailableSubagents;
 exports.resolveInputRetention = resolveInputRetention;
 exports.resolveMemoryStore = resolveMemoryStore;
+exports.resolveModelRule = resolveModelRule;
 exports.resolveReasoning = resolveReasoning;
 exports.resolveStrategy = resolveStrategy;
 exports.resolveSubagentTools = resolveSubagentTools;
@@ -17659,6 +19559,7 @@ exports.responseCache = responseCache;
 exports.restoreSnapshot = restoreSnapshot;
 exports.restoreToolCalls = restoreToolCalls;
 exports.runSmartAgentEvalHarness = runSmartAgentEvalHarness;
+exports.runWithModelAdjustments = runWithModelAdjustments;
 exports.scoreItemsByRelevance = scoreItemsByRelevance;
 exports.searchSkills = searchSkills;
 exports.seedChildMessages = seedChildMessages;
@@ -17667,7 +19568,9 @@ exports.sessionMetrics = sessionMetrics;
 exports.setTokenCounter = setTokenCounter;
 exports.startStreamingSession = startStreamingSession;
 exports.summarizeObject = summarizeObject;
+exports.supportsAdaptiveThinking = supportsAdaptiveThinking;
 exports.textFromContent = textFromContent;
+exports.toMessageUsage = toMessageUsage;
 exports.toStrictCompatible = toStrictCompatible;
 exports.toStrictToolSchema = toStrictToolSchema;
 exports.tokenize = tokenize;