@cognipeer/agent-sdk 0.10.6 → 0.12.0

package/dist/index.mjs

@@ -2431,6 +2431,15 @@ function estimatePayloadBytes(value) {
     }
   }
 }
+function toMessageUsage(u) {
+  return {
+    prompt_tokens: u.inputTokens,
+    completion_tokens: u.outputTokens,
+    total_tokens: u.totalTokens,
+    prompt_tokens_details: { cached_tokens: u.cachedInputTokens, cache_write_tokens: u.cachedWriteTokens },
+    completion_tokens_details: { reasoning_tokens: u.reasoningTokens }
+  };
+}
 function fromNativeProvider(provider, options) {
   let boundTools = options?.__tools;
   const modelName = options?.model ?? provider.defaultModel ?? provider.providerName;
@@ -2440,8 +2449,9 @@ function fromNativeProvider(provider, options) {
     invoke: async (messages, _invokeOptions) => {
       const link = linkAbortSignal(_invokeOptions);
       try {
-        const request = buildRequest(messages, boundTools, options, _invokeOptions);
+        let request = buildRequest(messages, boundTools, options, _invokeOptions);
         if (link.signal) request.signal = link.signal;
+        request = await applyTransform(request);
         const response = await provider.complete(request);
         return toBaseChatMessage(response);
       } finally {
@@ -2451,33 +2461,46 @@ function fromNativeProvider(provider, options) {
     stream: async function* (messages, _invokeOptions) {
       const link = linkAbortSignal(_invokeOptions);
       try {
-        const request = buildRequest(messages, boundTools, options, _invokeOptions);
+        let request = buildRequest(messages, boundTools, options, _invokeOptions);
         request.stream = true;
         if (link.signal) request.signal = link.signal;
+        request = await applyTransform(request);
         let fullContent = "";
         let allToolCalls = [];
         let lastUsage;
         let reasoningBlocks;
+        let reasoningText = "";
+        let finishReason;
+        let responseModel;
         const toolCallBuffers = /* @__PURE__ */ new Map();
         for await (const chunk of provider.completeStream(request)) {
           if (chunk.delta.content) {
             fullContent += chunk.delta.content;
             yield chunk.delta.content;
           }
+          if (chunk.model) responseModel = chunk.model;
+          if (chunk.finishReason) finishReason = chunk.finishReason;
           if (chunk.delta.reasoning?.blocks?.length) {
             reasoningBlocks = chunk.delta.reasoning.blocks;
           }
+          const reasoningDelta = chunk.delta.reasoning?.summary;
+          if (reasoningDelta) {
+            reasoningText += reasoningDelta;
+            yield { type: "reasoning", reasoning_content: reasoningDelta };
+          }
           if (chunk.delta.toolCalls) {
             for (const tc of chunk.delta.toolCalls) {
               if (tc.id) {
                 const existing = toolCallBuffers.get(tc.id);
                 if (existing) {
                   if (tc.arguments) existing.arguments += tc.arguments;
+                  if (tc.thoughtSignature) existing.thoughtSignature = tc.thoughtSignature;
                 } else {
                   toolCallBuffers.set(tc.id, {
                     id: tc.id,
                     name: tc.name ?? "",
-                    arguments: tc.arguments ?? ""
+                    arguments: tc.arguments ?? "",
+                    ...tc.thoughtSignature ? { thoughtSignature: tc.thoughtSignature } : {}
                   });
                 }
               }
@@ -2488,8 +2511,18 @@ function fromNativeProvider(provider, options) {
         if (link.signal?.aborted) return;
         allToolCalls = [...toolCallBuffers.values()];
         const finalMessage = assembleMessage(fullContent, allToolCalls, lastUsage);
-        if (reasoningBlocks?.length) {
-          finalMessage.reasoning = { blocks: reasoningBlocks };
+        if (reasoningBlocks?.length || reasoningText) {
+          finalMessage.reasoning = {
+            ...reasoningBlocks?.length ? { blocks: reasoningBlocks } : {},
+            ...reasoningText ? { summary: reasoningText } : {}
+          };
+        }
+        if (finishReason || responseModel) {
+          finalMessage.response_metadata = {
+            ...finalMessage.response_metadata ?? {},
+            ...finishReason ? { finish_reason: finishReason } : {},
+            ...responseModel ? { model_name: responseModel } : {}
+          };
         }
         yield finalMessage;
       } finally {
@@ -2503,6 +2536,11 @@ function fromNativeProvider(provider, options) {
     }
   };
   return adapted;
+  async function applyTransform(req) {
+    if (!options?.transformRequest) return req;
+    const out = await options.transformRequest(req);
+    return out ?? req;
+  }
   function buildRequest(messages, tools, opts, invokeOptions) {
     const req = {
       model: opts?.model ?? modelName,
@@ -2510,6 +2548,10 @@ function fromNativeProvider(provider, options) {
     };
     if (opts?.temperature != null) req.temperature = opts.temperature;
     if (opts?.maxTokens != null) req.maxTokens = opts.maxTokens;
+    if (opts?.topP != null) req.topP = opts.topP;
+    if (opts?.stop?.length) req.stop = opts.stop;
+    if (opts?.presencePenalty != null) req.presencePenalty = opts.presencePenalty;
+    if (opts?.frequencyPenalty != null) req.frequencyPenalty = opts.frequencyPenalty;
     if (tools?.length) req.tools = tools;
     if (opts?.extra) req.extra = opts.extra;
     const reasoningOverride = invokeOptions?.reasoning;
@@ -2562,7 +2604,8 @@ function toUnifiedMessage(msg) {
     unified.toolCalls = msg.tool_calls.map((tc) => ({
       id: tc.id,
       name: tc.function?.name ?? tc.name ?? "",
-      arguments: tc.function?.arguments ?? tc.arguments ?? "{}"
+      arguments: tc.function?.arguments ?? tc.arguments ?? "{}",
+      ...tc.thoughtSignature ? { thoughtSignature: tc.thoughtSignature } : {}
     }));
   }
   const reasoning = msg.reasoning;
@@ -2836,29 +2879,16 @@ function toToolDefinition(tool, strict) {
   }
   return { name, description, parameters, ...useStrict ? { strict: true } : {} };
 }
+function legacyTokenUsage(u) {
+  return { ...toMessageUsage(u), cached_tokens: u.cachedInputTokens, cache_write_tokens: u.cachedWriteTokens };
+}
 function toBaseChatMessage(response) {
   const msg = {
     role: "assistant",
     content: response.content ?? "",
-    usage: {
-      prompt_tokens: response.usage.inputTokens,
-      completion_tokens: response.usage.outputTokens,
-      total_tokens: response.usage.totalTokens,
-      prompt_tokens_details: {
-        cached_tokens: response.usage.cachedInputTokens
-      },
-      completion_tokens_details: {
-        reasoning_tokens: response.usage.reasoningTokens
-      }
-    },
+    usage: toMessageUsage(response.usage),
     response_metadata: {
-      token_usage: {
-        prompt_tokens: response.usage.inputTokens,
-        completion_tokens: response.usage.outputTokens,
-        total_tokens: response.usage.totalTokens,
-        cached_tokens: response.usage.cachedInputTokens,
-        cache_write_tokens: response.usage.cachedWriteTokens
-      },
+      token_usage: legacyTokenUsage(response.usage),
       finish_reason: response.finishReason,
       model_name: response.model
     }
@@ -2867,7 +2897,8 @@ function toBaseChatMessage(response) {
     msg.tool_calls = response.toolCalls.map((tc) => ({
       id: tc.id,
       type: "function",
-      function: { name: tc.name, arguments: tc.arguments }
+      function: { name: tc.name, arguments: tc.arguments },
+      ...tc.thoughtSignature ? { thoughtSignature: tc.thoughtSignature } : {}
     }));
   }
   if (response.reasoning && (response.reasoning.blocks?.length || response.reasoning.summary)) {
@@ -2881,32 +2912,15 @@ function assembleMessage(content, toolCalls, usage) {
     content
   };
   if (usage) {
-    msg.usage = {
-      prompt_tokens: usage.inputTokens,
-      completion_tokens: usage.outputTokens,
-      total_tokens: usage.totalTokens,
-      prompt_tokens_details: {
-        cached_tokens: usage.cachedInputTokens
-      },
-      completion_tokens_details: {
-        reasoning_tokens: usage.reasoningTokens
-      }
-    };
-    msg.response_metadata = {
-      token_usage: {
-        prompt_tokens: usage.inputTokens,
-        completion_tokens: usage.outputTokens,
-        total_tokens: usage.totalTokens,
-        cached_tokens: usage.cachedInputTokens,
-        cache_write_tokens: usage.cachedWriteTokens
-      }
-    };
+    msg.usage = toMessageUsage(usage);
+    msg.response_metadata = { token_usage: legacyTokenUsage(usage) };
   }
   if (toolCalls.length > 0) {
     msg.tool_calls = toolCalls.map((tc) => ({
       id: tc.id,
       type: "function",
-      function: { name: tc.name, arguments: tc.arguments }
+      function: { name: tc.name, arguments: tc.arguments },
+      ...tc.thoughtSignature ? { thoughtSignature: tc.thoughtSignature } : {}
     }));
   }
   return msg;
@@ -2939,8 +2953,8 @@ function resolveCapabilities(provider) {
       return {
         structuredOutput: "tool_based",
         strictToolCalling: false,
-        streaming: false,
-        // streaming uses binary protocol
+        streaming: true,
+        // ConverseStream (AWS event-stream frames)
         provider: "bedrock"
       };
     case "vertex":
@@ -4646,6 +4660,10 @@ ${append}`;
               if (chunk && typeof chunk === "object" && chunk.role) {
                 streamedMessage = chunk;
               }
+              if (chunk && typeof chunk === "object" && chunk.type === "reasoning" && typeof chunk.reasoning_content === "string") {
+                onEvent?.({ type: "reasoning", text: chunk.reasoning_content });
+                continue;
+              }
               const text = extractText2(chunk);
               const isAssembledMessage = Boolean(chunk && typeof chunk === "object" && chunk.role) && text.length > 0 && text === streamedText;
               if (text && !isAssembledMessage) {
@@ -11526,6 +11544,28 @@ async function runSmartAgentEvalHarness(params) {
   return results;
 }
 
+// src/providers/types.ts
+function emptyUsage() {
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0,
+    cachedInputTokens: 0,
+    cachedWriteTokens: 0,
+    cachedOutputTokens: 0,
+    reasoningTokens: 0
+  };
+}
+var ProviderError = class extends Error {
+  constructor(message, provider, statusCode, responseBody) {
+    super(message);
+    this.provider = provider;
+    this.statusCode = statusCode;
+    this.responseBody = responseBody;
+    this.name = "ProviderError";
+  }
+};
+
 // src/providers/base.ts
 var DEFAULT_RETRY = {
   maxRetries: 3,
@@ -11536,6 +11576,55 @@ var BaseProvider = class {
   constructor() {
     this.retryPolicy = DEFAULT_RETRY;
   }
+  /** Applies the transport options shared by every provider config. */
+  configureTransport(config) {
+    this.fetchImpl = config.fetch;
+    this.timeoutMs = typeof config.timeoutMs === "number" && config.timeoutMs > 0 ? config.timeoutMs : void 0;
+  }
+  /**
+   * The single HTTP entry point for every provider call site. Uses the
+   * configured `fetch` and applies `timeoutMs`: the timer covers the time until
+   * the response HEADERS arrive and is cleared after that, so a long-running
+   * stream is never cut by it (use the request `signal` to cancel a stream).
+   * A timeout surfaces as a `ProviderError` with status 408. The caller's
+   * `signal` still aborts the request as before.
+   */
+  async httpFetch(url, init = {}) {
+    const doFetch = this.fetchImpl ?? fetch;
+    const timeoutMs = this.timeoutMs;
+    if (!timeoutMs) return doFetch(url, init);
+    const controller = new AbortController();
+    const outer = init.signal ?? void 0;
+    let timedOut = false;
+    const onOuterAbort = () => controller.abort(outer?.reason);
+    if (outer) {
+      if (outer.aborted) controller.abort(outer.reason);
+      else outer.addEventListener("abort", onOuterAbort, { once: true });
+    }
+    const timer = setTimeout(() => {
+      timedOut = true;
+      controller.abort(new Error(`timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    try {
+      const res = await doFetch(url, { ...init, signal: controller.signal });
+      return res;
+    } catch (err) {
+      if (timedOut) {
+        throw new ProviderError(`${this.providerName} request timed out after ${timeoutMs}ms`, this.providerName, 408);
+      }
+      throw err;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  /**
+   * Embeds `request.input`. Implemented by the providers that have an
+   * embeddings endpoint (OpenAI, Azure, openai-compatible, Bedrock, Vertex);
+   * the others reject with a 400 ProviderError.
+   */
+  async embed(_request) {
+    throw new ProviderError(`${this.providerName} does not support embeddings`, this.providerName, 400);
+  }
   /**
    * Helper concrete providers can wrap their fetch with. Retries 429/5xx
    * with exponential backoff and respects Retry-After if the response
@@ -11577,34 +11666,13 @@ var BaseProvider = class {
   }
 };
 
-// src/providers/types.ts
-function emptyUsage() {
-  return {
-    inputTokens: 0,
-    outputTokens: 0,
-    totalTokens: 0,
-    cachedInputTokens: 0,
-    cachedWriteTokens: 0,
-    cachedOutputTokens: 0,
-    reasoningTokens: 0
-  };
-}
-var ProviderError = class extends Error {
-  constructor(message, provider, statusCode, responseBody) {
-    super(message);
-    this.provider = provider;
-    this.statusCode = statusCode;
-    this.responseBody = responseBody;
-    this.name = "ProviderError";
-  }
-};
-
 // src/providers/jev.ts
 var JEV_DEFAULT_BASE_URL = "https://api.typesafe.ai";
 var JevProvider = class extends BaseProvider {
   constructor(config) {
     super();
     this.providerName = "jev";
+    this.configureTransport(config);
     this.apiKey = config.apiKey;
     this.baseURL = (config.baseURL ?? JEV_DEFAULT_BASE_URL).replace(/\/$/, "");
     this.defaultModel = config.defaultModel;
@@ -11620,7 +11688,7 @@ var JevProvider = class extends BaseProvider {
       questions: request.questions
     };
     const res = await this.doFetchWithRetry(
-      () => fetch(`${this.baseURL}/v1/systemone`, {
+      () => this.httpFetch(`${this.baseURL}/v1/systemone`, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
@@ -13856,12 +13924,12 @@ function responseCache(config = {}) {
   };
 }
 function signRequest(req) {
-  const now = /* @__PURE__ */ new Date();
+  const now = req.now ?? /* @__PURE__ */ new Date();
   const dateStamp = toDateStamp(now);
   const amzDate = toAmzDate(now);
   const parsed = new URL(req.url);
   const host = parsed.host;
-  const canonicalUri = parsed.pathname || "/";
+  const canonicalUri = (parsed.pathname || "/").split("/").map((seg) => encodeURIComponent(seg).replace(/[!'()*]/g, (c) => "%" + c.charCodeAt(0).toString(16).toUpperCase())).join("/");
   const canonicalQuerystring = sortQueryParams(parsed.searchParams);
   const headers = {
     ...req.headers,
@@ -15178,73 +15246,6 @@ function languageGuard(config) {
 // src/index.ts
 init_content();
 
-// src/providers/utils/sse.ts
-async function* parseSSEStream(body, signal) {
-  const reader = body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  try {
-    while (true) {
-      if (signal?.aborted) throw abortReason(signal);
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const parts = buffer.split(/\r?\n\r?\n/);
-      buffer = parts.pop() ?? "";
-      for (const part of parts) {
-        if (!part.trim()) continue;
-        const event = parseSSEBlock(part);
-        if (event) yield event;
-      }
-    }
-    if (buffer.trim()) {
-      const event = parseSSEBlock(buffer);
-      if (event) yield event;
-    }
-  } finally {
-    reader.cancel().catch(() => void 0);
-    reader.releaseLock();
-  }
-}
-function parseSSEBlock(block) {
-  let event;
-  let id;
-  let retry;
-  const dataLines = [];
-  for (const line of block.split(/\r?\n/)) {
-    if (line.startsWith(":")) continue;
-    const colonIdx = line.indexOf(":");
-    let field;
-    let value;
-    if (colonIdx === -1) {
-      field = line;
-      value = "";
-    } else {
-      field = line.slice(0, colonIdx);
-      value = line.slice(colonIdx + 1);
-      if (value.startsWith(" ")) value = value.slice(1);
-    }
-    switch (field) {
-      case "event":
-        event = value;
-        break;
-      case "data":
-        dataLines.push(value);
-        break;
-      case "id":
-        id = value;
-        break;
-      case "retry": {
-        const n = parseInt(value, 10);
-        if (!isNaN(n)) retry = n;
-        break;
-      }
-    }
-  }
-  if (dataLines.length === 0) return null;
-  return { event, data: dataLines.join("\n"), id, retry };
-}
-
 // src/providers/utils/reasoning.ts
 var ANTHROPIC_EFFORT_BUDGET = {
   // 0 = off. `applyAnthropicReasoning` bails on a falsy budget and emits no
@@ -15266,6 +15267,7 @@ var GEMINI_EFFORT_BUDGET = {
   high: 12e3
 };
 var THINKING_OUTPUT_RESERVE = 1024;
+var MIN_THINKING_BUDGET = 1024;
 var THINKING_MIN_MAX_TOKENS = 4096;
 function applyOpenAIReasoning(body, reasoning, mode = "legacy_effort") {
   if (!reasoning) return;
@@ -15281,8 +15283,48 @@ function applyOpenAIReasoning(body, reasoning, mode = "legacy_effort") {
     if (reasoning.providerExtras) Object.assign(body, reasoning.providerExtras);
   }
 }
-function applyAnthropicReasoning(body, reasoning) {
+function supportsAdaptiveThinking(model) {
+  if (typeof model !== "string") return false;
+  const id = model.toLowerCase();
+  const at = id.indexOf("claude-");
+  if (at < 0) return false;
+  for (const tok of id.slice(at + 7).split("-")) {
+    if (tok === "fable") return true;
+    const m = /^(\d+)(?:@|$)/.exec(tok);
+    if (m) {
+      if (m[1].length <= 2) return Number(m[1]) >= 5;
+      return false;
+    }
+  }
+  return false;
+}
+function resolveThinkingForm(model, mode) {
+  if (mode === "adaptive" || mode === "budget") return mode;
+  return supportsAdaptiveThinking(model) ? "adaptive" : "budget";
+}
+function applyAdaptiveThinking(_body, reasoning, setThinking, setOutputConfig) {
+  const requested = normalizeEffort(reasoning.effort);
+  if (requested === "none") return false;
+  let effort;
+  if (requested) effort = requested === "minimal" ? "low" : requested;
+  else if (typeof reasoning.budgetTokens === "number" && reasoning.budgetTokens > 0) {
+    effort = reasoning.budgetTokens <= ANTHROPIC_EFFORT_BUDGET.low ? "low" : reasoning.budgetTokens <= ANTHROPIC_EFFORT_BUDGET.medium ? "medium" : "high";
+  }
+  if (!effort) return false;
+  const thinking = { type: "adaptive" };
+  if (reasoning.includeThoughts !== false) thinking.display = "summarized";
+  if (reasoning.providerExtras) Object.assign(thinking, reasoning.providerExtras);
+  setThinking({ thinking });
+  setOutputConfig({ effort });
+  return true;
+}
+function applyAnthropicReasoning(body, reasoning, opts) {
   if (!reasoning) return;
+  if (resolveThinkingForm(opts?.model ?? body.model, opts?.mode) === "adaptive") {
+    const on = applyAdaptiveThinking(body, reasoning, (extra) => body.thinking = extra.thinking, (o) => body.output_config = { ...body.output_config ?? {}, ...o });
+    if (on) stripSamplingParams(body, ["temperature", "top_p", "top_k"]);
+    return;
+  }
   let budget = resolveBudget(reasoning, ANTHROPIC_EFFORT_BUDGET);
   if (!budget) return;
   const currentMax = typeof body.max_tokens === "number" ? body.max_tokens : 0;
@@ -15290,14 +15332,20 @@ function applyAnthropicReasoning(body, reasoning) {
   if (currentMax < requiredMax) {
     body.max_tokens = requiredMax;
   }
-  budget = clampBudget(budget, body.max_tokens);
+  budget = Math.max(MIN_THINKING_BUDGET, clampBudget(budget, body.max_tokens));
   const thinking = { type: "enabled", budget_tokens: budget };
   if (reasoning.providerExtras) Object.assign(thinking, reasoning.providerExtras);
   body.thinking = thinking;
   stripSamplingParams(body, ["temperature", "top_p", "top_k"]);
 }
-function applyBedrockReasoning(body, reasoning) {
+function applyBedrockReasoning(body, reasoning, opts) {
   if (!reasoning) return;
+  if (resolveThinkingForm(opts?.model ?? body.modelId, opts?.mode) === "adaptive") {
+    const fields = () => body.additionalModelRequestFields ?? (body.additionalModelRequestFields = {});
+    const on = applyAdaptiveThinking(body, reasoning, (extra2) => fields().thinking = extra2.thinking, (o) => fields().output_config = { ...fields().output_config ?? {}, ...o });
+    if (on && body.inferenceConfig) stripSamplingParams(body.inferenceConfig, ["temperature", "topP"]);
+    return;
+  }
   let budget = resolveBudget(reasoning, ANTHROPIC_EFFORT_BUDGET);
   if (!budget) return;
   const inference = body.inferenceConfig ?? (body.inferenceConfig = {});
@@ -15306,7 +15354,7 @@ function applyBedrockReasoning(body, reasoning) {
   if (currentMax < requiredMax) {
     inference.maxTokens = requiredMax;
   }
-  budget = clampBudget(budget, inference.maxTokens);
+  budget = Math.max(MIN_THINKING_BUDGET, clampBudget(budget, inference.maxTokens));
   const extra = body.additionalModelRequestFields ?? (body.additionalModelRequestFields = {});
   const thinking = { type: "enabled", budget_tokens: budget };
   if (reasoning.providerExtras) Object.assign(thinking, reasoning.providerExtras);
@@ -15316,8 +15364,9 @@ function applyBedrockReasoning(body, reasoning) {
 function applyGeminiReasoning(generationConfig, reasoning) {
   if (!reasoning) return;
   const budget = resolveBudget(reasoning, GEMINI_EFFORT_BUDGET);
-  if (budget == null) return;
-  const thinkingConfig = { thinkingBudget: budget };
+  const level = typeof reasoning.thinkingLevel === "string" && reasoning.thinkingLevel ? reasoning.thinkingLevel : void 0;
+  if (budget == null && !level) return;
+  const thinkingConfig = level && budget !== 0 ? { thinkingLevel: level } : { thinkingBudget: budget ?? 0 };
   if (reasoning.includeThoughts) thinkingConfig.includeThoughts = true;
   if (reasoning.providerExtras) Object.assign(thinkingConfig, reasoning.providerExtras);
   generationConfig.thinkingConfig = thinkingConfig;
@@ -15348,6 +15397,73 @@ function resolveBudget(reasoning, effortBudget) {
   return void 0;
 }
 
+// src/providers/utils/sse.ts
+async function* parseSSEStream(body, signal) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      if (signal?.aborted) throw abortReason(signal);
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const parts = buffer.split(/\r?\n\r?\n/);
+      buffer = parts.pop() ?? "";
+      for (const part of parts) {
+        if (!part.trim()) continue;
+        const event = parseSSEBlock(part);
+        if (event) yield event;
+      }
+    }
+    if (buffer.trim()) {
+      const event = parseSSEBlock(buffer);
+      if (event) yield event;
+    }
+  } finally {
+    reader.cancel().catch(() => void 0);
+    reader.releaseLock();
+  }
+}
+function parseSSEBlock(block) {
+  let event;
+  let id;
+  let retry;
+  const dataLines = [];
+  for (const line of block.split(/\r?\n/)) {
+    if (line.startsWith(":")) continue;
+    const colonIdx = line.indexOf(":");
+    let field;
+    let value;
+    if (colonIdx === -1) {
+      field = line;
+      value = "";
+    } else {
+      field = line.slice(0, colonIdx);
+      value = line.slice(colonIdx + 1);
+      if (value.startsWith(" ")) value = value.slice(1);
+    }
+    switch (field) {
+      case "event":
+        event = value;
+        break;
+      case "data":
+        dataLines.push(value);
+        break;
+      case "id":
+        id = value;
+        break;
+      case "retry": {
+        const n = parseInt(value, 10);
+        if (!isNaN(n)) retry = n;
+        break;
+      }
+    }
+  }
+  if (dataLines.length === 0) return null;
+  return { event, data: dataLines.join("\n"), id, retry };
+}
+
 // src/providers/utils/media.ts
 var EXTENSION_MIME = {
   jpg: "image/jpeg",
@@ -15539,11 +15655,64 @@ function isObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// src/providers/utils/embeddings.ts
+function chunkArray(items, size) {
+  const n = Math.max(1, Math.floor(size));
+  const out = [];
+  for (let i = 0; i < items.length; i += n) out.push(items.slice(i, i + n));
+  return out;
+}
+async function mapWithConcurrency(items, limit, fn, signal) {
+  const results = new Array(items.length);
+  let next = 0;
+  let failure;
+  let failed = false;
+  const worker = async () => {
+    while (!failed) {
+      if (signal?.aborted) throw signal.reason ?? new Error("aborted");
+      const i = next++;
+      if (i >= items.length) return;
+      try {
+        results[i] = await fn(items[i], i);
+      } catch (err) {
+        failed = true;
+        failure = err;
+        return;
+      }
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(Math.max(1, limit), items.length) }, worker));
+  if (failed) throw failure;
+  return results;
+}
+function decodeBase64Vector(b64) {
+  const buf = Buffer.from(b64, "base64");
+  const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+  const out = new Array(Math.floor(buf.byteLength / 4));
+  for (let i = 0; i < out.length; i++) out[i] = view.getFloat32(i * 4, true);
+  return out;
+}
+function assertVectorCount(provider, vectors, expected) {
+  if (vectors.length !== expected) {
+    throw new ProviderError(
+      `${provider} embeddings returned ${vectors.length} vectors for ${expected} inputs`,
+      provider,
+      502
+    );
+  }
+}
+function requireEmbeddingModel(provider, model) {
+  if (!model) throw new ProviderError(`${provider} embeddings require a model`, provider, 400);
+  return model;
+}
+
 // src/providers/openai.ts
-var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
+var OpenAIProvider = class extends BaseProvider {
   constructor(config) {
     super();
     this.providerName = "openai";
+    this.configureTransport(config);
+    this.maxTokensParam = config.maxTokensParam ?? "auto";
     this.apiKey = config.apiKey;
     this.baseURL = (config.baseURL ?? "https://api.openai.com/v1").replace(/\/$/, "");
     this.defaultModel = config.defaultModel ?? "gpt-4o";
@@ -15551,10 +15720,14 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
       ...config.defaultHeaders,
       ...config.organization ? { "OpenAI-Organization": config.organization } : {}
     };
-    this.responsesApi = config.responsesApi ?? "auto";
-    const ownInstance = new.target === _OpenAIProvider;
-    this.responsesApiModels = ownInstance ? [...config.responsesApiModels ?? []] : [];
-    this.responsesStreaming = ownInstance && config.responsesStreaming === true;
+    const legacy = config.responsesApi;
+    const explicit = config.api === "chat" || config.api === "responses" ? config.api : void 0;
+    this.responsesApi = explicit === "responses" ? "always" : explicit === "chat" ? "never" : legacy ?? (config._autoMeansChat ? "never" : "auto");
+    this.apiExplicitChat = explicit === "chat" || explicit === void 0 && legacy === "never";
+    this.apiExplicitResponses = this.responsesApi === "always";
+    this.apiResponsesNative = explicit === "responses";
+    this.responsesApiModels = [...config.responsesApiModels ?? []];
+    this.responsesStreaming = config.responsesStreaming ?? this.apiResponsesNative;
     if (config.retry) this.retryPolicy = { ...this.retryPolicy, ...config.retry };
   }
   /** True when the caller listed this request's model in `responsesApiModels`. */
@@ -15580,9 +15753,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);
   }
@@ -15597,7 +15771,7 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
   }
   async *completeStream(request) {
     if (this.useResponsesApi(request)) {
-      if (this.responsesStreaming && this.isResponsesApiModel(request)) {
+      if (this.responsesStreaming && (this.apiResponsesNative || this.isResponsesApiModel(request))) {
         yield* this.streamResponses(request);
         return;
       }
@@ -15647,9 +15821,14 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
         delta: {},
         finishReason: mapFinishReason(choice.finish_reason)
       };
+      if (typeof choice.finish_reason === "string") out.rawFinishReason = choice.finish_reason;
+      const fields = pickProviderFields(chunk, delta, choice);
+      if (fields) out.providerFields = fields;
       if (delta.content) {
         out.delta.content = delta.content;
       }
+      const reasoningDelta = extractReasoningText(delta);
+      if (reasoningDelta) out.delta.reasoning = { summary: reasoningDelta };
       if (delta.tool_calls) {
         const partials = [];
         for (const tc of delta.tool_calls) {
@@ -15661,7 +15840,7 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
           if (tc.id) buf.id = tc.id;
           if (tc.function?.name) buf.name = tc.function.name;
           if (tc.function?.arguments) buf.arguments += tc.function.arguments;
-          partials.push({ id: buf.id, name: buf.name || void 0, arguments: tc.function?.arguments });
+          partials.push({ id: buf.id, name: buf.name || void 0, arguments: tc.function?.arguments, index: idx });
         }
         out.delta.toolCalls = partials;
       }
@@ -15669,6 +15848,51 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
       yield out;
     }
   }
+  // ─── Embeddings ──────────────────────────────────────────────────────────
+  /** POST /embeddings, batched (default 2048 inputs per request, the OpenAI cap). */
+  async embed(request) {
+    const model = requireEmbeddingModel(this.providerName, request.model);
+    const batches = chunkArray(request.input, request.batchSize ?? 2048);
+    const vectors = [];
+    const raw = [];
+    let inputTokens = 0;
+    let totalTokens = 0;
+    let responseModel = model;
+    for (const batch of batches) {
+      const body = { model, input: batch };
+      if (request.dimensions != null) body.dimensions = request.dimensions;
+      if (request.encodingFormat) body.encoding_format = request.encodingFormat;
+      if (request.extra) Object.assign(body, request.extra);
+      const res = await this.embeddingsFetch(body, request.signal);
+      const json = await res.json();
+      raw.push(json);
+      const data = Array.isArray(json.data) ? [...json.data] : [];
+      data.sort((a, b) => (a.index ?? 0) - (b.index ?? 0));
+      for (const d of data) {
+        vectors.push(typeof d.embedding === "string" ? decodeBase64Vector(d.embedding) : d.embedding);
+      }
+      inputTokens += json.usage?.prompt_tokens ?? 0;
+      totalTokens += json.usage?.total_tokens ?? json.usage?.prompt_tokens ?? 0;
+      responseModel = json.model ?? responseModel;
+    }
+    assertVectorCount(this.providerName, vectors, request.input.length);
+    return { model: responseModel, vectors, usage: { inputTokens, totalTokens }, raw };
+  }
+  async embeddingsFetch(body, signal) {
+    const url = `${this.baseURL}/embeddings`;
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.apiKey}`,
+      ...this.defaultHeaders
+    };
+    const payload = JSON.stringify(body);
+    const res = await this.doFetchWithRetry(() => this.httpFetch(url, { method: "POST", headers, body: payload, signal }), signal);
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new ProviderError(`OpenAI embeddings API error ${res.status}: ${text}`, this.providerName, res.status, text);
+    }
+    return res;
+  }
   // ─── Internals ───────────────────────────────────────────────────────────
   buildRequestBody(request, stream) {
     const body = {
@@ -15676,15 +15900,27 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
       messages: request.messages.map((m) => this.toOpenAIMessage(m)),
       stream
     };
-    if (stream) {
+    if (stream && request.streamUsage !== false) {
       body.stream_options = { include_usage: true };
     }
-    if (request.temperature != null) body.temperature = request.temperature;
-    if (request.maxTokens != null) body.max_tokens = request.maxTokens;
-    if (request.topP != null) body.top_p = request.topP;
+    const modelId = String(body.model);
+    const reasoningModel = isReasoningModel(modelId) && !/chat/i.test(modelId);
+    if (request.temperature != null && !reasoningModel) body.temperature = request.temperature;
+    if (request.maxTokens != null) {
+      const useCompletionTokens = this.maxTokensParam === "max_completion_tokens" || this.maxTokensParam === "auto" && isReasoningModel(modelId);
+      body[useCompletionTokens ? "max_completion_tokens" : "max_tokens"] = request.maxTokens;
+    }
+    if (request.topP != null && !reasoningModel) body.top_p = request.topP;
     if (request.stop) body.stop = request.stop;
+    if (request.presencePenalty != null) body.presence_penalty = request.presencePenalty;
+    if (request.frequencyPenalty != null) body.frequency_penalty = request.frequencyPenalty;
+    if (request.seed != null) body.seed = request.seed;
+    if (request.n != null) body.n = request.n;
+    if (request.logprobs != null) body.logprobs = request.logprobs;
+    if (request.topLogprobs != null) body.top_logprobs = request.topLogprobs;
     if (request.tools?.length) {
       body.tools = request.tools.map((t) => this.toOpenAITool(t));
+      if (request.parallelToolCalls != null) body.parallel_tool_calls = request.parallelToolCalls;
     }
     if (request.toolChoice != null && request.tools?.length) {
       if (typeof request.toolChoice === "string") {
@@ -15716,7 +15952,7 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
   // ─── Responses API (reasoning models) ──────────────────────────────────────
   async completeResponses(request) {
     const body = this.buildResponsesBody(request);
-    if (this.isResponsesApiModel(request)) adaptChatExtrasForResponses(body, request.extra);
+    if (this.apiResponsesNative || this.isResponsesApiModel(request)) adaptChatExtrasForResponses(body, request.extra);
     const res = await this.responsesFetch(body, request.signal);
     const json = await res.json();
     return this.parseResponsesResponse(json, request.model || this.defaultModel);
@@ -15739,6 +15975,7 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
     let model = modelId;
     const calls = /* @__PURE__ */ new Map();
     let final;
+    let streamedSummary = false;
     for await (const event of parseSSEStream(res.body, request.signal)) {
       if (event.data === "[DONE]") break;
       let data;
@@ -15756,19 +15993,28 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
         case "response.output_text.delta":
           if (data.delta) yield { id, model, delta: { content: data.delta } };
           break;
+        case "response.reasoning_summary_part.added":
+          if (streamedSummary) yield { id, model, delta: { reasoning: { summary: "\n\n" } } };
+          break;
+        case "response.reasoning_summary_text.delta":
+          if (typeof data.delta === "string" && data.delta) {
+            streamedSummary = true;
+            yield { id, model, delta: { reasoning: { summary: data.delta } } };
+          }
+          break;
         case "response.output_item.added": {
           const item = data.item;
           if (item?.type !== "function_call") break;
-          const call = { callId: item.call_id ?? item.id ?? "", name: item.name ?? "", arguments: item.arguments ?? "" };
+          const call = { callId: item.call_id ?? item.id ?? "", name: item.name ?? "", arguments: item.arguments ?? "", index: calls.size };
           calls.set(item.id ?? call.callId, call);
-          yield { id, model, delta: { toolCalls: [{ id: call.callId, name: call.name, arguments: call.arguments }] } };
+          yield { id, model, delta: { toolCalls: [{ id: call.callId, name: call.name, arguments: call.arguments, index: call.index }] } };
           break;
         }
         case "response.function_call_arguments.delta": {
           const call = calls.get(data.item_id);
           if (!call || !data.delta) break;
           call.arguments += data.delta;
-          yield { id, model, delta: { toolCalls: [{ id: call.callId, arguments: data.delta }] } };
+          yield { id, model, delta: { toolCalls: [{ id: call.callId, arguments: data.delta, index: call.index }] } };
           break;
         }
         case "response.output_item.done": {
@@ -15777,13 +16023,13 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
           const full = typeof item.arguments === "string" ? item.arguments : "";
           const call = calls.get(item.id ?? item.call_id);
           if (!call) {
-            const added = { callId: item.call_id ?? item.id ?? "", name: item.name ?? "", arguments: full };
+            const added = { callId: item.call_id ?? item.id ?? "", name: item.name ?? "", arguments: full, index: calls.size };
             calls.set(item.id ?? added.callId, added);
-            yield { id, model, delta: { toolCalls: [{ id: added.callId, name: added.name, arguments: full }] } };
+            yield { id, model, delta: { toolCalls: [{ id: added.callId, name: added.name, arguments: full, index: added.index }] } };
           } else if (full.length > call.arguments.length && full.startsWith(call.arguments)) {
             const rest = full.slice(call.arguments.length);
             call.arguments = full;
-            yield { id, model, delta: { toolCalls: [{ id: call.callId, arguments: rest }] } };
+            yield { id, model, delta: { toolCalls: [{ id: call.callId, arguments: rest, index: call.index }] } };
           }
           break;
         }
@@ -15806,7 +16052,8 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
     yield {
       id: final?.id || id,
       model: final?.model || model,
-      delta: final?.reasoning ? { reasoning: final.reasoning } : {},
+      // Summary text already went out as deltas; do not repeat it.
+      delta: final?.reasoning && !streamedSummary ? { reasoning: final.reasoning } : {},
       usage: final?.usage,
       finishReason: final?.finishReason ?? (calls.size > 0 ? "tool_calls" : "stop")
     };
@@ -15916,7 +16163,7 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
       ...this.defaultHeaders
     };
     const payload = JSON.stringify(body);
-    const res = await this.doFetchWithRetry(() => fetch(url, { method: "POST", headers, body: payload, signal }), signal);
+    const res = await this.doFetchWithRetry(() => this.httpFetch(url, { method: "POST", headers, body: payload, signal }), signal);
     if (!res.ok) {
       const text = await res.text().catch(() => "");
       throw new ProviderError(
@@ -16045,7 +16292,7 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
       ...this.defaultHeaders
     };
     const payload = JSON.stringify(body);
-    const res = await this.doFetchWithRetry(() => fetch(url, { method: "POST", headers, body: payload, signal }), signal);
+    const res = await this.doFetchWithRetry(() => this.httpFetch(url, { method: "POST", headers, body: payload, signal }), signal);
     if (!res.ok) {
       const text = await res.text().catch(() => "");
       throw new ProviderError(
@@ -16065,6 +16312,8 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
       name: tc.function?.name ?? "",
       arguments: tc.function?.arguments ?? "{}"
     }));
+    const reasoningText = extractReasoningText(message);
+    const providerFields = pickProviderFields(json, message, choice);
     return {
       id: json.id ?? "",
       model: json.model ?? "",
@@ -16072,6 +16321,9 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
       toolCalls,
       usage: this.extractUsage(json.usage),
       finishReason: mapFinishReason(choice?.finish_reason),
+      ...typeof choice?.finish_reason === "string" ? { rawFinishReason: choice.finish_reason } : {},
+      ...providerFields ? { providerFields } : {},
+      ...reasoningText ? { reasoning: { summary: reasoningText } } : {},
       raw: json
     };
   }
@@ -16090,6 +16342,23 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
     };
   }
 };
+function extractReasoningText(src) {
+  if (!src || typeof src !== "object") return void 0;
+  for (const key of ["reasoning_content", "reasoning"]) {
+    const v = src[key];
+    if (typeof v === "string" && v.length > 0) return v;
+  }
+  return void 0;
+}
+function pickProviderFields(top, message, choice) {
+  const out = {};
+  if (top?.system_fingerprint != null) out.system_fingerprint = top.system_fingerprint;
+  if (top?.service_tier != null) out.service_tier = top.service_tier;
+  if (message?.annotations != null) out.annotations = message.annotations;
+  if (message?.refusal != null) out.refusal = message.refusal;
+  if (choice?.logprobs != null) out.logprobs = choice.logprobs;
+  return Object.keys(out).length > 0 ? out : void 0;
+}
 function isReasoningModel(model) {
   if (!model) return false;
   const m = model.toLowerCase();
@@ -16166,36 +16435,86 @@ function mapFinishReason(reason) {
   }
 }
 
+// src/providers/utils/toolChoice.ts
+function supportsForcedToolChoice(model) {
+  if (typeof model !== "string") return true;
+  const id = model.toLowerCase();
+  const at = id.indexOf("claude-");
+  if (at < 0) return true;
+  const toks = id.slice(at + 7).split("-");
+  let family = false;
+  for (const tok of toks) {
+    if (tok === "sonnet" || tok === "opus") {
+      family = true;
+      continue;
+    }
+    const m = /^(\d+)(?:@|:|$)/.exec(tok);
+    if (m) {
+      if (m[1].length > 2) continue;
+      if (Number(m[1]) < 5) return true;
+      if (family) return false;
+      return !toks.some((t) => t === "sonnet" || t === "opus");
+    }
+  }
+  return true;
+}
+function forcedToolChoiceRejected(text) {
+  const t = text.toLowerCase();
+  return t.indexOf("tool_choice") >= 0 && t.indexOf("not supported for this model") >= 0;
+}
+
 // src/providers/anthropic.ts
+var DEFAULT_MAX_TOKENS = 4096;
+function normalizeExplicitThinking(body) {
+  const t = body.thinking;
+  if (t == null) {
+    delete body.thinking;
+    return;
+  }
+  if (t.type !== "enabled") return;
+  const budget = typeof t.budget_tokens === "number" ? t.budget_tokens : 0;
+  if (budget > 0 && (typeof body.max_tokens !== "number" || body.max_tokens <= budget)) {
+    body.max_tokens = budget + 1024;
+  }
+  for (const k of ["temperature", "top_p", "top_k"]) delete body[k];
+}
+function thinkingFormRejected(text) {
+  const t = text.toLowerCase();
+  if (t.indexOf("thinking.type.enabled") >= 0 && t.indexOf("not supported") >= 0) return "enabled";
+  if (t.indexOf("thinking.type.adaptive") >= 0 && t.indexOf("not supported") >= 0 && t.indexOf("thinking.type.enabled") < 0) return "adaptive";
+  return void 0;
+}
 var AnthropicProvider = class extends BaseProvider {
   constructor(config) {
     super();
     this.providerName = "anthropic";
+    this.configureTransport(config);
     this.apiKey = config.apiKey;
     this.baseURL = (config.baseURL ?? "https://api.anthropic.com").replace(/\/$/, "");
     this.defaultModel = config.defaultModel ?? "claude-sonnet-4-20250514";
     this.defaultHeaders = config.defaultHeaders ?? {};
     this.anthropicVersion = config.anthropicVersion ?? "2023-06-01";
+    this.thinkingMode = config.thinkingMode ?? "auto";
     this.promptCachingEnabled = config.prompt_caching?.enabled === true;
     if (config.retry) this.retryPolicy = { ...this.retryPolicy, ...config.retry };
   }
   async complete(request) {
-    const body = this.buildRequestBody(request, false);
-    const res = await this.doFetch(body, request.signal);
+    const res = await this.send(request, false);
     const json = await res.json();
     return this.parseResponse(json);
   }
   async *completeStream(request) {
-    const body = this.buildRequestBody(request, true);
-    const res = await this.doFetch(body, request.signal);
+    const res = await this.send(request, true);
     if (!res.body) throw new ProviderError("No response body for stream", this.providerName);
     let id = "";
     let model = "";
     let inputTokens = 0;
     let outputTokens = 0;
+    let thinkingTokens = 0;
     let cacheReadInputTokens = 0;
     let cacheCreationInputTokens = 0;
     const currentToolCalls = /* @__PURE__ */ new Map();
+    let toolOrdinal = 0;
     const reasoningBlocks = /* @__PURE__ */ new Map();
     for await (const event of parseSSEStream(res.body, request.signal)) {
       let data;
@@ -16224,8 +16543,11 @@ var AnthropicProvider = class extends BaseProvider {
             currentToolCalls.set(idx, {
               id: block.id ?? "",
               name: block.name ?? "",
-              arguments: ""
+              arguments: "",
+              ordinal: toolOrdinal++
             });
+            const opened = currentToolCalls.get(idx);
+            yield { id, model, delta: { toolCalls: [{ id: opened.id, name: opened.name, arguments: "", index: opened.ordinal }] } };
           } else if (block?.type === "thinking") {
             reasoningBlocks.set(idx, { type: "thinking", text: block.thinking ?? "", signature: block.signature });
           } else if (block?.type === "redacted_thinking") {
@@ -16263,7 +16585,7 @@ var AnthropicProvider = class extends BaseProvider {
                 id,
                 model,
                 delta: {
-                  toolCalls: [{ id: tc.id, name: tc.name, arguments: delta.partial_json }]
+                  toolCalls: [{ id: tc.id, name: tc.name, arguments: delta.partial_json, index: tc.ordinal }]
                 }
               };
             }
@@ -16276,8 +16598,10 @@ var AnthropicProvider = class extends BaseProvider {
           const delta = data.delta;
           if (data.usage) {
             outputTokens = data.usage.output_tokens ?? outputTokens;
+            thinkingTokens = data.usage.output_tokens_details?.thinking_tokens ?? thinkingTokens;
           }
           const finishReason = mapAnthropicStopReason(delta?.stop_reason);
+          const rawFinishReason = typeof delta?.stop_reason === "string" ? delta.stop_reason : void 0;
           const usage = {
             inputTokens,
             outputTokens,
@@ -16285,7 +16609,7 @@ var AnthropicProvider = class extends BaseProvider {
             cachedInputTokens: cacheReadInputTokens,
             cachedWriteTokens: cacheCreationInputTokens,
             cachedOutputTokens: 0,
-            reasoningTokens: 0
+            reasoningTokens: thinkingTokens
           };
           const blocks = [...reasoningBlocks.values()].filter(
             (b) => b.type === "thinking" && b.signature || b.type === "redacted_thinking" && b.data
@@ -16295,6 +16619,7 @@ var AnthropicProvider = class extends BaseProvider {
             model,
             delta: blocks.length > 0 ? { reasoning: { blocks } } : {},
             finishReason,
+            ...rawFinishReason ? { rawFinishReason } : {},
             usage
           };
           break;
@@ -16309,12 +16634,12 @@ var AnthropicProvider = class extends BaseProvider {
     }
   }
   // ─── Internals ───────────────────────────────────────────────────────────
-  buildRequestBody(request, stream) {
+  buildRequestBody(request, stream, modeOverride, downgradeToolChoice = false) {
     const { system, messages } = this.splitSystemMessages(request.messages);
     const body = {
       model: request.model || this.defaultModel,
       messages: this.toAnthropicMessages(messages),
-      max_tokens: request.maxTokens ?? 4096,
+      max_tokens: request.maxTokens ?? DEFAULT_MAX_TOKENS,
       stream
     };
     if (system) {
@@ -16335,18 +16660,27 @@ var AnthropicProvider = class extends BaseProvider {
       body.tools = tools;
     }
     if (request.toolChoice != null) {
+      const forceOk = !downgradeToolChoice && supportsForcedToolChoice(body.model);
       if (request.toolChoice === "auto") {
         body.tool_choice = { type: "auto" };
       } else if (request.toolChoice === "required") {
-        body.tool_choice = { type: "any" };
+        body.tool_choice = forceOk ? { type: "any" } : { type: "auto" };
       } else if (request.toolChoice === "none") ; else {
-        body.tool_choice = { type: "tool", name: request.toolChoice.name };
+        body.tool_choice = forceOk ? { type: "tool", name: request.toolChoice.name } : { type: "auto" };
       }
     }
     if (request.extra) {
       Object.assign(body, request.extra);
     }
-    applyAnthropicReasoning(body, request.reasoning);
+    const explicitThinking = request.extra && typeof request.extra === "object" && "thinking" in request.extra;
+    if (explicitThinking) {
+      normalizeExplicitThinking(body);
+    } else {
+      applyAnthropicReasoning(body, request.reasoning, { model: body.model, mode: modeOverride ?? this.thinkingMode });
+    }
+    if (typeof body.max_tokens !== "number" || !(body.max_tokens > 0)) {
+      body.max_tokens = DEFAULT_MAX_TOKENS;
+    }
     return body;
   }
   splitSystemMessages(messages) {
@@ -16477,6 +16811,34 @@ var AnthropicProvider = class extends BaseProvider {
       input_schema: t.parameters
     };
   }
+  /** Builds and sends the request; retries once with the other thinking form
+   * when the upstream rejects the one we picked. */
+  async send(request, stream) {
+    let mode;
+    let downgrade = false;
+    let flippedThinking = false;
+    for (; ; ) {
+      const body = this.buildRequestBody(request, stream, mode, downgrade);
+      try {
+        return await this.doFetch(body, request.signal);
+      } catch (err) {
+        if (!(err instanceof ProviderError) || err.statusCode !== 400) throw err;
+        const text = String(err.responseBody ?? err.message);
+        if (!downgrade && body.tool_choice && body.tool_choice.type !== "auto" && forcedToolChoiceRejected(text)) {
+          downgrade = true;
+          continue;
+        }
+        const explicit = request.extra && typeof request.extra === "object" && "thinking" in request.extra;
+        if (flippedThinking || explicit || !request.reasoning) throw err;
+        const wrong = thinkingFormRejected(text);
+        if (!wrong) throw err;
+        const used = resolveThinkingForm(request.model ?? this.defaultModel, this.thinkingMode);
+        if (wrong === "enabled" && used !== "budget" || wrong === "adaptive" && used !== "adaptive") throw err;
+        mode = wrong === "enabled" ? "adaptive" : "budget";
+        flippedThinking = true;
+      }
+    }
+  }
   async doFetch(body, signal) {
     const url = `${this.baseURL}/v1/messages`;
     const headers = {
@@ -16486,7 +16848,7 @@ var AnthropicProvider = class extends BaseProvider {
       ...this.defaultHeaders
     };
     const payload = JSON.stringify(body);
-    const res = await this.doFetchWithRetry(() => fetch(url, { method: "POST", headers, body: payload, signal }), signal);
+    const res = await this.doFetchWithRetry(() => this.httpFetch(url, { method: "POST", headers, body: payload, signal }), signal);
     if (!res.ok) {
       const text = await res.text().catch(() => "");
       throw new ProviderError(
@@ -16531,10 +16893,9 @@ var AnthropicProvider = class extends BaseProvider {
       cachedInputTokens: usage.cache_read_input_tokens ?? 0,
       cachedWriteTokens: usage.cache_creation_input_tokens ?? 0,
       cachedOutputTokens: 0,
-      // Anthropic bills thinking tokens inside `output_tokens` and does not
-      // expose a separate count, so reasoningTokens stays 0 here (cost is still
-      // captured via outputTokens). See docs for the limitation.
-      reasoningTokens: 0
+      // Thinking tokens are billed inside `output_tokens`; newer models also
+      // report the split as `output_tokens_details.thinking_tokens`.
+      reasoningTokens: usage.output_tokens_details?.thinking_tokens ?? 0
     };
     return {
       id: json.id ?? "",
@@ -16543,6 +16904,7 @@ var AnthropicProvider = class extends BaseProvider {
       toolCalls,
       usage: tokenUsage,
       finishReason: mapAnthropicStopReason(json.stop_reason),
+      ...typeof json.stop_reason === "string" ? { rawFinishReason: json.stop_reason } : {},
       reasoning: reasoningBlocks.length > 0 ? { blocks: reasoningBlocks, summary: summaryParts.join("\n").trim() || void 0 } : void 0,
       raw: json
     };
@@ -16588,7 +16950,15 @@ var AzureProvider = class extends OpenAIProvider {
       provider: "openai",
       apiKey: config.apiKey,
       defaultModel: config.defaultModel ?? config.deploymentName ?? "gpt-4o",
-      defaultHeaders: config.defaultHeaders
+      defaultHeaders: config.defaultHeaders,
+      retry: config.retry,
+      fetch: config.fetch,
+      timeoutMs: config.timeoutMs,
+      maxTokensParam: config.maxTokensParam,
+      api: config.api,
+      responsesApi: config.responsesApi,
+      responsesApiModels: config.responsesApiModels,
+      responsesStreaming: config.responsesStreaming
     });
     this.providerName = "azure";
     this.endpoint = config.endpoint.replace(/\/$/, "");
@@ -16603,16 +16973,17 @@ var AzureProvider = class extends OpenAIProvider {
     }
     const url = `${this.endpoint}/openai/deployments/${deployment}/chat/completions?api-version=${this.apiVersion}`;
     const { model: _model, ...bodyWithoutModel } = body;
-    const res = await fetch(url, {
+    const payload = JSON.stringify(bodyWithoutModel);
+    const res = await this.doFetchWithRetry(() => this.httpFetch(url, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
         "api-key": this.azureApiKey,
         ...this.defaultHeaders
       },
-      body: JSON.stringify(bodyWithoutModel),
+      body: payload,
       signal
-    });
+    }), signal);
     if (!res.ok) {
       const text = await res.text().catch(() => "");
       throw new ProviderError(
@@ -16624,6 +16995,32 @@ var AzureProvider = class extends OpenAIProvider {
     }
     return res;
   }
+  /** Azure embeddings: the deployment named by the request's model (falling back
+   * to the configured deployment) in the path, api-key auth. */
+  async embeddingsFetch(body, signal) {
+    const deployment = body.model || this.deploymentName;
+    if (!deployment) {
+      throw new ProviderError("Azure embeddings require a deployment name or model", this.providerName, 400);
+    }
+    const url = `${this.endpoint}/openai/deployments/${deployment}/embeddings?api-version=${this.apiVersion}`;
+    const { model: _model, ...bodyWithoutModel } = body;
+    const payload = JSON.stringify(bodyWithoutModel);
+    const res = await this.doFetchWithRetry(() => this.httpFetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "api-key": this.azureApiKey,
+        ...this.defaultHeaders
+      },
+      body: payload,
+      signal
+    }), signal);
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new ProviderError(`Azure OpenAI embeddings API error ${res.status}: ${text}`, this.providerName, res.status, text);
+    }
+    return res;
+  }
   /** Azure exposes the Responses API at /openai/responses with api-key auth.
    * Reasoning summaries require a preview api-version; callers can override via
    * the `apiVersion` config. */
@@ -16635,7 +17032,7 @@ var AzureProvider = class extends OpenAIProvider {
     }
     const url = `${this.endpoint}/openai/responses?api-version=${this.apiVersion}`;
     const payload = JSON.stringify({ ...body, model: deployment });
-    const res = await fetch(url, {
+    const res = await this.doFetchWithRetry(() => this.httpFetch(url, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -16644,7 +17041,7 @@ var AzureProvider = class extends OpenAIProvider {
       },
       body: payload,
       signal
-    });
+    }), signal);
     if (!res.ok) {
       const text = await res.text().catch(() => "");
       throw new ProviderError(
@@ -16680,20 +17077,155 @@ var OpenAICompatibleProvider = class extends OpenAIProvider {
       apiKey: config.apiKey,
       baseURL: config.baseURL,
       defaultModel: config.defaultModel,
-      defaultHeaders: config.defaultHeaders
+      defaultHeaders: config.defaultHeaders,
+      organization: config.organization,
+      retry: config.retry,
+      fetch: config.fetch,
+      timeoutMs: config.timeoutMs,
+      maxTokensParam: config.maxTokensParam,
+      api: config.api,
+      // Unlike OpenAI / Azure, "auto" on a compatible server means Chat
+      // Completions (the 0.11 default): the model name is the operator's.
+      // `responsesApiModels` still applies; `responsesApi: "auto"` opts in.
+      _autoMeansChat: true,
+      responsesApi: config.responsesApi,
+      responsesApiModels: config.responsesApiModels,
+      responsesStreaming: config.responsesStreaming
     });
     this.providerName = "openai-compatible";
   }
 };
 
+// src/providers/utils/eventStream.ts
+var EventStreamError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "EventStreamError";
+  }
+};
+var CRC_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    table[n] = c >>> 0;
+  }
+  return table;
+})();
+function crc32(bytes, start = 0, end = bytes.length) {
+  let c = 4294967295;
+  for (let i = start; i < end; i++) c = CRC_TABLE[(c ^ bytes[i]) & 255] ^ c >>> 8;
+  return (c ^ 4294967295) >>> 0;
+}
+function decodeFrame(frame) {
+  const view = new DataView(frame.buffer, frame.byteOffset, frame.byteLength);
+  const total = view.getUint32(0);
+  const headersLen = view.getUint32(4);
+  if (total !== frame.byteLength) throw new EventStreamError("event-stream frame length mismatch");
+  if (crc32(frame, 0, 8) !== view.getUint32(8)) throw new EventStreamError("event-stream prelude CRC mismatch");
+  if (crc32(frame, 0, total - 4) !== view.getUint32(total - 4)) throw new EventStreamError("event-stream message CRC mismatch");
+  if (12 + headersLen > total - 4) throw new EventStreamError("event-stream headers overflow frame");
+  const headers = {};
+  const td = new TextDecoder();
+  let o = 12;
+  const headersEnd = 12 + headersLen;
+  while (o < headersEnd) {
+    const nameLen = frame[o++];
+    const name = td.decode(frame.subarray(o, o + nameLen));
+    o += nameLen;
+    const type = frame[o++];
+    switch (type) {
+      case 0:
+        headers[name] = true;
+        break;
+      case 1:
+        headers[name] = false;
+        break;
+      case 2:
+        headers[name] = view.getInt8(o);
+        o += 1;
+        break;
+      case 3:
+        headers[name] = view.getInt16(o);
+        o += 2;
+        break;
+      case 4:
+        headers[name] = view.getInt32(o);
+        o += 4;
+        break;
+      case 5:
+        headers[name] = view.getBigInt64(o);
+        o += 8;
+        break;
+      case 6: {
+        const len = view.getUint16(o);
+        o += 2;
+        headers[name] = frame.slice(o, o + len);
+        o += len;
+        break;
+      }
+      case 7: {
+        const len = view.getUint16(o);
+        o += 2;
+        headers[name] = td.decode(frame.subarray(o, o + len));
+        o += len;
+        break;
+      }
+      case 8:
+        headers[name] = view.getBigInt64(o);
+        o += 8;
+        break;
+      case 9:
+        headers[name] = frame.slice(o, o + 16);
+        o += 16;
+        break;
+      default:
+        throw new EventStreamError(`unknown event-stream header type ${type}`);
+    }
+  }
+  return { headers, payload: frame.slice(headersEnd, total - 4) };
+}
+async function* parseEventStream(body, signal) {
+  const reader = body.getReader();
+  let buf = new Uint8Array(0);
+  try {
+    while (true) {
+      if (signal?.aborted) throw abortReason(signal);
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!value?.length) continue;
+      const merged = new Uint8Array(buf.length + value.length);
+      merged.set(buf, 0);
+      merged.set(value, buf.length);
+      buf = merged;
+      while (buf.length >= 12) {
+        const total = new DataView(buf.buffer, buf.byteOffset, buf.byteLength).getUint32(0);
+        if (total < 16) throw new EventStreamError("invalid event-stream frame length");
+        if (buf.length < total) break;
+        yield decodeFrame(buf.subarray(0, total));
+        buf = buf.subarray(total);
+      }
+    }
+    if (buf.length > 0) throw new EventStreamError("event-stream ended inside a frame");
+  } finally {
+    reader.cancel().catch(() => void 0);
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  }
+}
+
 // src/providers/bedrock.ts
 var BedrockProvider = class extends BaseProvider {
   constructor(config) {
     super();
     this.providerName = "bedrock";
+    this.configureTransport(config);
     this.region = config.region;
     this.defaultModel = config.defaultModel ?? "anthropic.claude-sonnet-4-20250514-v1:0";
     this.defaultHeaders = config.defaultHeaders ?? {};
+    this.thinkingMode = config.thinkingMode ?? "auto";
     this.promptCachingEnabled = config.prompt_caching?.enabled === true;
     if (config.retry) this.retryPolicy = { ...this.retryPolicy, ...config.retry };
     this.credentials = {
@@ -16710,25 +17242,202 @@ var BedrockProvider = class extends BaseProvider {
   }
   async complete(request) {
     const modelId = request.model || this.defaultModel;
-    const body = this.buildConverseBody(request);
-    const json = await this.doFetch(modelId, body, request.signal);
-    return this.parseResponse(json, modelId);
+    const res = await this.converseFetch(modelId, request, false);
+    return this.parseResponse(await res.json(), modelId);
   }
+  /**
+   * Real streaming over ConverseStream. The response is an AWS event-stream
+   * (binary frames); each frame carries one JSON event: messageStart,
+   * contentBlockStart/Delta/Stop (text, toolUse, reasoningContent),
+   * messageStop and, last, metadata (usage). Text, tool-call argument and
+   * reasoning deltas are yielded as they arrive; one closing chunk carries the
+   * finish reason, usage and the signed reasoning blocks.
+   */
   async *completeStream(request) {
-    const response = await this.complete(request);
+    const modelId = request.model || this.defaultModel;
+    const res = await this.converseFetch(modelId, request, true);
+    if (!res.body) throw new ProviderError("No response body for stream", this.providerName);
+    const id = res.headers.get("x-amzn-requestid") ?? "";
+    const toolsByIndex = /* @__PURE__ */ new Map();
+    const reasoningByIndex = /* @__PURE__ */ new Map();
+    let finishReason;
+    let rawFinishReason;
+    let toolOrdinal = 0;
+    let usage;
+    for await (const msg of parseEventStream(res.body, request.signal)) {
+      const messageType = String(msg.headers[":message-type"] ?? "event");
+      const eventType = String(msg.headers[":event-type"] ?? msg.headers[":exception-type"] ?? "");
+      let data = {};
+      const text = new TextDecoder().decode(msg.payload);
+      if (text) {
+        try {
+          data = JSON.parse(text);
+        } catch {
+          data = { message: text };
+        }
+      }
+      if (messageType === "exception" || messageType === "error") {
+        const code = String(msg.headers[":exception-type"] ?? msg.headers[":error-code"] ?? eventType);
+        throw new ProviderError(
+          `Bedrock stream error ${code}: ${data.message ?? text}`,
+          this.providerName,
+          bedrockExceptionStatus(code),
+          data
+        );
+      }
+      switch (eventType) {
+        case "contentBlockStart": {
+          const idx = data.contentBlockIndex ?? 0;
+          const tu = data.start?.toolUse;
+          if (tu) {
+            const ordinal = toolOrdinal++;
+            toolsByIndex.set(idx, { id: tu.toolUseId ?? "", name: tu.name ?? "", ordinal });
+            yield { id, model: modelId, delta: { toolCalls: [{ id: tu.toolUseId, name: tu.name, arguments: "", index: ordinal }] } };
+          }
+          break;
+        }
+        case "contentBlockDelta": {
+          const idx = data.contentBlockIndex ?? 0;
+          const d = data.delta ?? {};
+          if (typeof d.text === "string" && d.text) {
+            yield { id, model: modelId, delta: { content: d.text } };
+          } else if (d.toolUse) {
+            const tc = toolsByIndex.get(idx);
+            if (tc && typeof d.toolUse.input === "string" && d.toolUse.input) {
+              yield { id, model: modelId, delta: { toolCalls: [{ id: tc.id, name: tc.name, arguments: d.toolUse.input, index: tc.ordinal }] } };
+            }
+          } else if (d.reasoningContent) {
+            const rc = d.reasoningContent;
+            const blk = reasoningByIndex.get(idx) ?? { type: "thinking", text: "" };
+            if (typeof rc.text === "string" && rc.text) {
+              blk.text = (blk.text ?? "") + rc.text;
+              reasoningByIndex.set(idx, blk);
+              yield { id, model: modelId, delta: { reasoning: { summary: rc.text } } };
+            }
+            if (typeof rc.signature === "string" && rc.signature) {
+              blk.signature = (blk.signature ?? "") + rc.signature;
+              reasoningByIndex.set(idx, blk);
+            }
+            if (rc.redactedContent) {
+              reasoningByIndex.set(idx, { type: "redacted_thinking", data: rc.redactedContent });
+            }
+          }
+          break;
+        }
+        case "messageStop":
+          finishReason = mapBedrockStopReason(data.stopReason);
+          if (typeof data.stopReason === "string") rawFinishReason = data.stopReason;
+          break;
+        case "metadata": {
+          const u = data.usage ?? {};
+          usage = {
+            inputTokens: u.inputTokens ?? 0,
+            outputTokens: u.outputTokens ?? 0,
+            totalTokens: u.totalTokens ?? (u.inputTokens ?? 0) + (u.outputTokens ?? 0),
+            cachedInputTokens: u.cacheReadInputTokens ?? u.cacheReadInputTokenCount ?? 0,
+            cachedWriteTokens: u.cacheWriteInputTokens ?? u.cacheWriteInputTokenCount ?? 0,
+            cachedOutputTokens: 0,
+            reasoningTokens: 0
+          };
+          break;
+        }
+      }
+    }
+    const blocks = [...reasoningByIndex.values()].filter(
+      (b) => b.type === "thinking" && b.signature || b.type === "redacted_thinking" && b.data
+    );
     yield {
-      id: response.id,
-      model: response.model,
-      delta: {
-        content: response.content ?? void 0,
-        toolCalls: response.toolCalls.length > 0 ? response.toolCalls : void 0
-      },
-      usage: response.usage,
-      finishReason: response.finishReason
+      id,
+      model: modelId,
+      delta: blocks.length > 0 ? { reasoning: { blocks } } : {},
+      finishReason: finishReason ?? "stop",
+      ...rawFinishReason ? { rawFinishReason } : {},
+      usage
     };
   }
+  // ─── Embeddings ──────────────────────────────────────────────────────────
+  /**
+   * InvokeModel embeddings. Supported families (by model id, inference-profile
+   * prefixes such as `us.` allowed):
+   *  - Amazon Titan Text Embeddings (v1, v2): one text per call, `dimensions`
+   *    (v2: 256/512/1024) and `normalize` via `extra`.
+   *  - Cohere Embed (v3, v4): a batch of texts per call (default 96), `inputType`
+   *    maps to `input_type`, `dimensions` to `output_dimension` (v4).
+   */
+  async embed(request) {
+    const model = requireEmbeddingModel(this.providerName, request.model);
+    const id = model.toLowerCase();
+    const raw = [];
+    let inputTokens = 0;
+    let vectors = [];
+    if (id.includes("titan-embed")) {
+      const results = await mapWithConcurrency(request.input, 4, async (text) => {
+        const body = { inputText: text };
+        if (request.dimensions != null && !id.includes("titan-embed-text-v1")) body.dimensions = request.dimensions;
+        if (request.extra) Object.assign(body, request.extra);
+        const res = await this.invokeModel(model, body, request.signal);
+        const json = await res.json();
+        return { json, tokens: json.inputTextTokenCount ?? Number(res.headers.get("x-amzn-bedrock-input-token-count") ?? 0) };
+      }, request.signal);
+      for (const r of results) {
+        raw.push(r.json);
+        inputTokens += r.tokens || 0;
+        vectors.push(r.json.embedding ?? r.json.embeddingsByType?.float);
+      }
+    } else if (id.includes("cohere.embed")) {
+      for (const batch of chunkArray(request.input, request.batchSize ?? 96)) {
+        const body = {
+          texts: batch,
+          input_type: request.inputType ?? "search_document",
+          embedding_types: ["float"]
+        };
+        if (request.dimensions != null) body.output_dimension = request.dimensions;
+        if (request.extra) Object.assign(body, request.extra);
+        const res = await this.invokeModel(model, body, request.signal);
+        const json = await res.json();
+        raw.push(json);
+        const emb = Array.isArray(json.embeddings) ? json.embeddings : json.embeddings?.float;
+        vectors.push(...emb ?? []);
+        inputTokens += Number(res.headers.get("x-amzn-bedrock-input-token-count") ?? 0) || 0;
+      }
+    } else {
+      throw new ProviderError(
+        `Bedrock embeddings are supported for Amazon Titan and Cohere Embed models, not "${model}"`,
+        this.providerName,
+        400
+      );
+    }
+    assertVectorCount(this.providerName, vectors, request.input.length);
+    return { model, vectors, usage: { inputTokens, totalTokens: inputTokens }, raw };
+  }
+  async invokeModel(modelId, body, signal) {
+    const host = `bedrock-runtime.${this.region}.amazonaws.com`;
+    const url = `https://${host}/model/${encodeURIComponent(modelId)}/invoke`;
+    const bodyStr = JSON.stringify(body);
+    const res = await this.doFetchWithRetry(() => {
+      const headers = signRequest({
+        method: "POST",
+        url,
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          ...this.defaultHeaders
+        },
+        body: bodyStr,
+        region: this.region,
+        service: "bedrock",
+        credentials: this.credentials
+      });
+      return this.httpFetch(url, { method: "POST", headers, body: bodyStr, signal });
+    }, signal);
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new ProviderError(`Bedrock API error ${res.status}: ${text}`, this.providerName, res.status, text);
+    }
+    return res;
+  }
   // ─── Internals ───────────────────────────────────────────────────────────
-  buildConverseBody(request) {
+  buildConverseBody(request, downgradeToolChoice = false) {
     const { system, messages } = this.splitSystemMessages(request.messages);
     const body = {
       messages: this.toBedrockMessages(messages)
@@ -16752,8 +17461,9 @@ var BedrockProvider = class extends BaseProvider {
       body.toolConfig = {
         tools
       };
+      const forceOk = !downgradeToolChoice && supportsForcedToolChoice(request.model || this.defaultModel);
       if (request.toolChoice != null) {
-        if (request.toolChoice === "auto") {
+        if (request.toolChoice === "auto" || !forceOk && request.toolChoice !== "none") {
           body.toolConfig.toolChoice = { auto: {} };
         } else if (request.toolChoice === "required") {
           body.toolConfig.toolChoice = { any: {} };
@@ -16763,9 +17473,17 @@ var BedrockProvider = class extends BaseProvider {
       }
     }
     if (request.extra) {
-      Object.assign(body, request.extra);
+      const fields = { ...request.extra.additionalModelRequestFields ?? {} };
+      const topLevel = { ...request.extra.__top ?? {} };
+      for (const [key, value] of Object.entries(request.extra)) {
+        if (key === "additionalModelRequestFields" || key === "__top") continue;
+        if (CONVERSE_TOP_LEVEL_FIELDS.has(key)) body[key] = value;
+        else fields[key] = value;
+      }
+      Object.assign(body, topLevel);
+      if (Object.keys(fields).length > 0) body.additionalModelRequestFields = fields;
     }
-    applyBedrockReasoning(body, request.reasoning);
+    applyBedrockReasoning(body, request.reasoning, { model: request.model || this.defaultModel, mode: this.thinkingMode });
     return body;
   }
   splitSystemMessages(messages) {
@@ -16888,9 +17606,22 @@ var BedrockProvider = class extends BaseProvider {
       }
     };
   }
-  async doFetch(modelId, body, signal) {
+  /** Sends the Converse call; retries once with toolChoice auto when the
+   * model rejects forced tool use. */
+  async converseFetch(modelId, request, stream) {
+    const body = this.buildConverseBody(request);
+    try {
+      return await this.doFetch(modelId, body, request.signal, stream);
+    } catch (err) {
+      const tc = body.toolConfig?.toolChoice;
+      if (!(err instanceof ProviderError) || err.statusCode !== 400 || !tc || tc.auto) throw err;
+      if (!forcedToolChoiceRejected(String(err.responseBody ?? err.message))) throw err;
+      return this.doFetch(modelId, this.buildConverseBody(request, true), request.signal, stream);
+    }
+  }
+  async doFetch(modelId, body, signal, stream) {
     const host = `bedrock-runtime.${this.region}.amazonaws.com`;
-    const url = `https://${host}/model/${encodeURIComponent(modelId)}/converse`;
+    const url = `https://${host}/model/${encodeURIComponent(modelId)}/${stream ? "converse-stream" : "converse"}`;
     const bodyStr = JSON.stringify(body);
     const res = await this.doFetchWithRetry(() => {
       const headers = signRequest({
@@ -16898,7 +17629,7 @@ var BedrockProvider = class extends BaseProvider {
         url,
         headers: {
           "Content-Type": "application/json",
-          Accept: "application/json",
+          Accept: stream ? "application/vnd.amazon.eventstream" : "application/json",
           ...this.defaultHeaders
         },
         body: bodyStr,
@@ -16906,7 +17637,7 @@ var BedrockProvider = class extends BaseProvider {
         service: "bedrock",
         credentials: this.credentials
       });
-      return fetch(url, { method: "POST", headers, body: bodyStr, signal });
+      return this.httpFetch(url, { method: "POST", headers, body: bodyStr, signal });
     }, signal);
     if (!res.ok) {
       const text = await res.text().catch(() => "");
@@ -16917,7 +17648,7 @@ var BedrockProvider = class extends BaseProvider {
         text
       );
     }
-    return res.json();
+    return res;
   }
   parseResponse(json, modelId) {
     const output = json.output?.message;
@@ -16953,8 +17684,8 @@ var BedrockProvider = class extends BaseProvider {
       inputTokens: usage.inputTokens ?? 0,
       outputTokens: usage.outputTokens ?? 0,
       totalTokens: usage.totalTokens ?? (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0),
-      cachedInputTokens: usage.cacheReadInputTokenCount ?? 0,
-      cachedWriteTokens: usage.cacheWriteInputTokenCount ?? 0,
+      cachedInputTokens: usage.cacheReadInputTokens ?? usage.cacheReadInputTokenCount ?? 0,
+      cachedWriteTokens: usage.cacheWriteInputTokens ?? usage.cacheWriteInputTokenCount ?? 0,
       cachedOutputTokens: 0,
       // Bedrock bills thinking tokens inside outputTokens; no separate count.
       reasoningTokens: 0
@@ -16966,11 +17697,26 @@ var BedrockProvider = class extends BaseProvider {
       toolCalls,
       usage: tokenUsage,
       finishReason: mapBedrockStopReason(json.stopReason),
+      ...typeof json.stopReason === "string" ? { rawFinishReason: json.stopReason } : {},
       reasoning: reasoningBlocks.length > 0 ? { blocks: reasoningBlocks, summary: summaryParts.join("\n").trim() || void 0 } : void 0,
       raw: json
     };
   }
 };
+var CONVERSE_TOP_LEVEL_FIELDS = /* @__PURE__ */ new Set([
+  "messages",
+  "system",
+  "inferenceConfig",
+  "toolConfig",
+  "guardrailConfig",
+  "additionalModelRequestFields",
+  "additionalModelResponseFieldPaths",
+  "promptVariables",
+  "requestMetadata",
+  "performanceConfig",
+  "serviceTier",
+  "outputConfig"
+]);
 function appendBedrockReasoning(content, blocks) {
   if (!blocks?.length) return;
   for (const b of blocks) {
@@ -16985,6 +17731,23 @@ function appendBedrockReasoning(content, blocks) {
     }
   }
 }
+function bedrockExceptionStatus(code) {
+  switch (code) {
+    case "throttlingException":
+      return 429;
+    case "validationException":
+      return 400;
+    case "modelTimeoutException":
+      return 408;
+    case "serviceUnavailableException":
+      return 503;
+    case "internalServerException":
+    case "modelStreamErrorException":
+      return 500;
+    default:
+      return void 0;
+  }
+}
 function mapBedrockStopReason(reason) {
   switch (reason) {
     case "end_turn":
@@ -16993,8 +17756,10 @@ function mapBedrockStopReason(reason) {
     case "tool_use":
       return "tool_calls";
     case "max_tokens":
+    case "model_context_window_exceeded":
       return "length";
     case "content_filtered":
+    case "guardrail_intervened":
     case "guardrail":
       return "content_filter";
     default:
@@ -17024,10 +17789,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,6 +17817,7 @@ var VertexProvider = class extends BaseProvider {
     const url = this.buildUrl(modelId, true);
     const res = await this.doFetch(url, body, request.signal);
     if (!res.body) throw new ProviderError("No response body for stream", this.providerName);
+    const counter = { next: 0 };
     const contentType = res.headers.get("content-type") ?? "";
     if (contentType.includes("text/event-stream")) {
       for await (const event of parseSSEStream(res.body, request.signal)) {
@@ -17060,7 +17828,7 @@ var VertexProvider = class extends BaseProvider {
         } catch {
           continue;
         }
-        yield this.parseStreamChunk(chunk, modelId);
+        yield this.parseStreamChunk(chunk, modelId, counter);
       }
     } else {
       const reader = res.body.getReader();
@@ -17078,7 +17846,7 @@ var VertexProvider = class extends BaseProvider {
             if (!trimmed || trimmed === "[" || trimmed === "]") continue;
             try {
               const chunk = JSON.parse(trimmed);
-              yield this.parseStreamChunk(chunk, modelId);
+              yield this.parseStreamChunk(chunk, modelId, counter);
             } catch {
               buffer = line + "\n" + buffer;
               break;
@@ -17089,7 +17857,7 @@ var VertexProvider = class extends BaseProvider {
         if (remaining && remaining !== "[" && remaining !== "]") {
           try {
             const chunk = JSON.parse(remaining);
-            yield this.parseStreamChunk(chunk, modelId);
+            yield this.parseStreamChunk(chunk, modelId, counter);
           } catch {
           }
         }
@@ -17100,6 +17868,48 @@ var VertexProvider = class extends BaseProvider {
     }
   }
   // ─── Internals ───────────────────────────────────────────────────────────
+  /**
+   * Vertex `:predict` embeddings (text-embedding-00x, text-multilingual-embedding,
+   * gemini-embedding-001). `inputType` maps to the task type; `dimensions` to
+   * `outputDimensionality`. gemini-embedding takes one instance per request, the
+   * text-embedding models up to `batchSize` (default 100).
+   */
+  async embed(request) {
+    const model = requireEmbeddingModel(this.providerName, request.model);
+    const perRequest = request.batchSize ?? (/gemini-embedding/i.test(model) ? 1 : 100);
+    const url = `https://${this.location}-aiplatform.googleapis.com/v1/projects/${this.projectId}/locations/${this.location}/publishers/google/models/${model}:predict`;
+    const taskType = request.inputType ? Object.prototype.hasOwnProperty.call(GEMINI_TASK_TYPES, request.inputType) ? GEMINI_TASK_TYPES[request.inputType] : request.inputType.toUpperCase() : void 0;
+    const vectors = [];
+    const raw = [];
+    let inputTokens = 0;
+    for (const batch of chunkArray(request.input, perRequest)) {
+      const body = {
+        instances: batch.map((content) => ({ content, ...taskType ? { task_type: taskType } : {} }))
+      };
+      const { parameters: extraParameters, ...extraRest } = request.extra ?? {};
+      const parameters = {
+        ...request.dimensions != null ? { outputDimensionality: request.dimensions } : {},
+        // Caller-supplied parameters are merged in, not replacing the above (an
+        // explicit extra.parameters.outputDimensionality still wins).
+        ...extraParameters && typeof extraParameters === "object" ? extraParameters : {}
+      };
+      if (Object.keys(parameters).length > 0) body.parameters = parameters;
+      Object.assign(body, extraRest);
+      const res = await this.doFetch(url, body, request.signal);
+      const json = await res.json();
+      raw.push(json);
+      for (const p of json.predictions ?? []) {
+        const values = p.embeddings?.values;
+        if (!Array.isArray(values)) {
+          throw new ProviderError("Vertex embeddings response has a prediction without an embeddings.values array", this.providerName, void 0, json);
+        }
+        vectors.push(values);
+        inputTokens += p.embeddings?.statistics?.token_count ?? 0;
+      }
+    }
+    assertVectorCount(this.providerName, vectors, request.input.length);
+    return { model, vectors, usage: { inputTokens, totalTokens: inputTokens }, raw };
+  }
   buildUrl(modelId, stream) {
     const base = `https://${this.location}-aiplatform.googleapis.com/v1`;
     const path2 = `projects/${this.projectId}/locations/${this.location}/publishers/google/models/${modelId}`;
@@ -17197,7 +18007,9 @@ var VertexProvider = class extends BaseProvider {
           functionCall: {
             name: tc.name,
             args: safeJsonParse3(tc.arguments)
-          }
+          },
+          // Gemini 3 requires the signature of each functionCall echoed back.
+          ...tc.thoughtSignature ? { thoughtSignature: tc.thoughtSignature } : {}
         });
       }
       return { role: "model", parts: parts2 };
@@ -17294,7 +18106,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}`
@@ -17308,16 +18120,20 @@ var VertexProvider = class extends BaseProvider {
   }
   async doFetch(url, body, signal) {
     const token = await this.getAccessToken();
-    const res = await fetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${token}`,
-        ...this.defaultHeaders
-      },
-      body: JSON.stringify(body),
+    const bodyStr = JSON.stringify(body);
+    const res = await this.doFetchWithRetry(
+      () => this.httpFetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${token}`,
+          ...this.defaultHeaders
+        },
+        body: bodyStr,
+        signal
+      }),
       signal
-    });
+    );
     if (!res.ok) {
       const text = await res.text().catch(() => "");
       throw new ProviderError(
@@ -17347,7 +18163,8 @@ var VertexProvider = class extends BaseProvider {
         toolCalls.push({
           id: `call_${toolCallIdx++}`,
           name: part.functionCall.name,
-          arguments: JSON.stringify(part.functionCall.args ?? {})
+          arguments: JSON.stringify(part.functionCall.args ?? {}),
+          ...part.thoughtSignature ? { thoughtSignature: part.thoughtSignature } : {}
         });
       }
     }
@@ -17368,11 +18185,12 @@ var VertexProvider = class extends BaseProvider {
       toolCalls,
       usage: tokenUsage,
       finishReason: mapGeminiFinishReason(candidate?.finishReason),
+      ...typeof candidate?.finishReason === "string" ? { rawFinishReason: candidate.finishReason } : {},
       reasoning: thoughtParts.length > 0 ? { summary: thoughtParts.join("\n").trim() || void 0 } : void 0,
       raw: json
     };
   }
-  parseStreamChunk(chunk, modelId) {
+  parseStreamChunk(chunk, modelId, counter) {
     const candidate = chunk.candidates?.[0];
     const parts = candidate?.content?.parts ?? [];
     const delta = {};
@@ -17386,9 +18204,12 @@ var VertexProvider = class extends BaseProvider {
       } else if (part.functionCall) {
         if (!delta.toolCalls) delta.toolCalls = [];
         delta.toolCalls.push({
-          id: `call_${delta.toolCalls.length}`,
+          // Unique across the whole stream: the adapter merges chunks by id.
+          id: `call_${counter.next}`,
+          index: counter.next++,
           name: part.functionCall.name,
-          arguments: JSON.stringify(part.functionCall.args ?? {})
+          arguments: JSON.stringify(part.functionCall.args ?? {}),
+          ...part.thoughtSignature ? { thoughtSignature: part.thoughtSignature } : {}
         });
       }
     }
@@ -17410,10 +18231,21 @@ var VertexProvider = class extends BaseProvider {
       model: modelId,
       delta,
       usage,
-      finishReason: mapGeminiFinishReason(candidate?.finishReason)
+      finishReason: mapGeminiFinishReason(candidate?.finishReason),
+      ...typeof candidate?.finishReason === "string" ? { rawFinishReason: candidate.finishReason } : {}
     };
   }
 };
+var GEMINI_TASK_TYPES = {
+  search_document: "RETRIEVAL_DOCUMENT",
+  search_query: "RETRIEVAL_QUERY",
+  classification: "CLASSIFICATION",
+  clustering: "CLUSTERING",
+  semantic_similarity: "SEMANTIC_SIMILARITY",
+  question_answering: "QUESTION_ANSWERING",
+  fact_verification: "FACT_VERIFICATION",
+  code_retrieval_query: "CODE_RETRIEVAL_QUERY"
+};
 function mapGeminiFinishReason(reason) {
   switch (reason) {
     case "STOP":
@@ -17462,6 +18294,6 @@ function createProvider(config) {
   }
 }
 
-export { ASK_USER_TOOL_NAME, AnthropicProvider, AzureProvider, BaseProvider, BedrockProvider, CCRStore, CONSOLE_HOOK_MAP, CONTEXT_PILOT_JSON_MARKER_KEY, CONTROL_PLANE_TOOL_NAMES, DEFAULT_MAX_TOOL_INPUT_FIELD_CHARS, DEFAULT_PROFILE_CONFIGS, DEFAULT_SKILL_POLICY, DEFAULT_SUBAGENT_POLICY, DEFAULT_SUBAGENT_TOOL_NAMES, DEFAULT_TOOL_INPUT_DIGEST_HEAD_CHARS, DELEGATION_TOOL_NAMES, DedupTracker, GuardrailPhase, HOOK_CONTRACT_VERSION, HOOK_NAMES, HookTimeoutError, InMemoryMemoryStore, JevProvider, NativeJsonSchemaStrategy, OpenAICompatibleProvider, OpenAIProvider, PREOPEN_TOOL_CALL_PREFIX, ProviderError, SMALL_TIER_SKILL_POLICY, StructuredOutputManager, TOOL_INPUT_DIGEST_KEY, ToolBasedStrategy, VertexProvider, agentVerdictRule, appendBoundTools, auditLog, azureContentSafety, bedrockGuardrail, budgetGuard, buildHandoffTools, buildResponseFormatSection, buildSkillHeaderBlock, buildSubagentCatalogBlock, buildSystemPrompt, buildToolDefinitionsSection, canOpenSkill, canSpawn, captureSnapshot, checkpointing, codePresenceRule, coerceToolArgs, cognipeerGuardrail, cognipeerSink, collectAttachments, collectToolRetentionDeclarations, composeToolSets, compressDiffOutput, compressJsonOutput, compressLogOutput, compressSearchOutput, compressTextOutput, compressToolOutput, contentPartToText, contentToString, conversationHistory, countApproxTokens, countMessagesTokens, createAgent, createAgentNode, createAskUserQuestionTool, createBindSkillToolsTool, createCodeGuardrail, createContextPilotRuntime, createContextSummarizeNode, createContextTools, createDelegateTool, createGetToolResponseTool, createGuardrail, createGuardrailPlugin, createJsonGuardrail, createManageTodoListAliasTool, createManageTodoTool, createOpenSkillTool, createParallelTool, createPluginHost, createProvider, createRegexGuardrail, createResolverNode, createSearchSkillsTool, createSkillRegistryRef, createSkillTools, createSmartAgent, createSpawnTool, createSubagentRegistryRef, createSubagentTools, createTool, createToolLimitFinalizeNode, createToolsNode, customCallbackRule, customGuardrail, customSink, dedupeToolsByName, defaultTokenCounter, defineHook, definePlugin, describeContentPart, detectLanguage, detectTextFormat, detectVolatileContent, digestToolInputArguments, digestToolInputValue, emptyUsage, evaluateGuardrails, extractLatestUserQuery, extractMessageText, fileCheckpointStore, fileSink, findSubagent, formatZodError, fromLangchainModel, fromLangchainTools, fromNativeProvider, generateSpanId, generateTraceId, getModelCapabilities, getNestedValue, getResolvedSmartConfig, getTokenCounter, hasMediaPart, hasToolResponseRecoveryReference, httpGuardrail, httpSink, inMemoryCheckpointStore, inMemoryConversationStore, isHookImplemented, isOpenAIHostedEndpoint, isSmartModel, isValidIban, isValidLuhn, isValidTckn, jsonSchemaRule, defaultBuildPayload as langfuseDefaultPayload, langfuseTracing, languageGuard, loadSkillsFromDisk, mapConsoleHookVerdict, mapTextParts, mcp, mediaKindOf, mediaPolicy, normalizeSmartAgentOptions, normalizeVerdicts, openAIModeration, otelTracing, otlpSink, outputGuard, parseApprovalDecision, parseSkillFrontmatter, pathSandbox, piiRedaction, pluginCapabilities, portkeyGateway, portkeyGuardrail, preopenSkills, preopenToolCallId, prepareStrictToolMenu, promptInjectionGuard, rateLimit, readMemoryFacts, redactText, regexGuardrail, regexRule, replaceTextContent, resolveAvailableSkills, resolveAvailableSubagents, resolveInputRetention, resolveMemoryStore, resolveReasoning, resolveStrategy, resolveSubagentTools, resolveSummarizationRetention, resolveToolApprovalState, resolveUserQuestionState, responseCache, restoreSnapshot, restoreToolCalls, runSmartAgentEvalHarness, scoreItemsByRelevance, searchSkills, seedChildMessages, selectTopIndicesInOrder, sessionMetrics, setTokenCounter, startStreamingSession, summarizeObject, textFromContent, toStrictCompatible, toStrictToolSchema, tokenize, toolPolicy, traceSessionToOtlp, validateReasoningConfig, validateToolArgs, webhookApproval, withTools, withinDepth, writeSummaryFactsToMemory };
+export { ASK_USER_TOOL_NAME, AnthropicProvider, AzureProvider, BaseProvider, BedrockProvider, CCRStore, CONSOLE_HOOK_MAP, CONTEXT_PILOT_JSON_MARKER_KEY, CONTROL_PLANE_TOOL_NAMES, DEFAULT_MAX_TOOL_INPUT_FIELD_CHARS, DEFAULT_PROFILE_CONFIGS, DEFAULT_SKILL_POLICY, DEFAULT_SUBAGENT_POLICY, DEFAULT_SUBAGENT_TOOL_NAMES, DEFAULT_TOOL_INPUT_DIGEST_HEAD_CHARS, DELEGATION_TOOL_NAMES, DedupTracker, GuardrailPhase, HOOK_CONTRACT_VERSION, HOOK_NAMES, HookTimeoutError, InMemoryMemoryStore, JevProvider, NativeJsonSchemaStrategy, OpenAICompatibleProvider, OpenAIProvider, PREOPEN_TOOL_CALL_PREFIX, ProviderError, SMALL_TIER_SKILL_POLICY, StructuredOutputManager, TOOL_INPUT_DIGEST_KEY, ToolBasedStrategy, VertexProvider, agentVerdictRule, appendBoundTools, auditLog, azureContentSafety, bedrockGuardrail, budgetGuard, buildHandoffTools, buildResponseFormatSection, buildSkillHeaderBlock, buildSubagentCatalogBlock, buildSystemPrompt, buildToolDefinitionsSection, canOpenSkill, canSpawn, captureSnapshot, checkpointing, codePresenceRule, coerceToolArgs, cognipeerGuardrail, cognipeerSink, collectAttachments, collectToolRetentionDeclarations, composeToolSets, compressDiffOutput, compressJsonOutput, compressLogOutput, compressSearchOutput, compressTextOutput, compressToolOutput, contentPartToText, contentToString, conversationHistory, countApproxTokens, countMessagesTokens, createAgent, createAgentNode, createAskUserQuestionTool, createBindSkillToolsTool, createCodeGuardrail, createContextPilotRuntime, createContextSummarizeNode, createContextTools, createDelegateTool, createGetToolResponseTool, createGuardrail, createGuardrailPlugin, createJsonGuardrail, createManageTodoListAliasTool, createManageTodoTool, createOpenSkillTool, createParallelTool, createPluginHost, createProvider, createRegexGuardrail, createResolverNode, createSearchSkillsTool, createSkillRegistryRef, createSkillTools, createSmartAgent, createSpawnTool, createSubagentRegistryRef, createSubagentTools, createTool, createToolLimitFinalizeNode, createToolsNode, customCallbackRule, customGuardrail, customSink, dedupeToolsByName, defaultTokenCounter, defineHook, definePlugin, describeContentPart, detectLanguage, detectTextFormat, detectVolatileContent, digestToolInputArguments, digestToolInputValue, emptyUsage, evaluateGuardrails, extractLatestUserQuery, extractMessageText, fileCheckpointStore, fileSink, findSubagent, formatZodError, fromLangchainModel, fromLangchainTools, fromNativeProvider, generateSpanId, generateTraceId, getModelCapabilities, getNestedValue, getResolvedSmartConfig, getTokenCounter, hasMediaPart, hasToolResponseRecoveryReference, httpGuardrail, httpSink, inMemoryCheckpointStore, inMemoryConversationStore, isHookImplemented, isOpenAIHostedEndpoint, isSmartModel, isValidIban, isValidLuhn, isValidTckn, jsonSchemaRule, defaultBuildPayload as langfuseDefaultPayload, langfuseTracing, languageGuard, loadSkillsFromDisk, mapConsoleHookVerdict, mapTextParts, mcp, mediaKindOf, mediaPolicy, normalizeSmartAgentOptions, normalizeVerdicts, openAIModeration, otelTracing, otlpSink, outputGuard, parseApprovalDecision, parseSkillFrontmatter, pathSandbox, piiRedaction, pluginCapabilities, portkeyGateway, portkeyGuardrail, preopenSkills, preopenToolCallId, prepareStrictToolMenu, promptInjectionGuard, rateLimit, readMemoryFacts, redactText, regexGuardrail, regexRule, replaceTextContent, resolveAvailableSkills, resolveAvailableSubagents, resolveInputRetention, resolveMemoryStore, resolveReasoning, resolveStrategy, resolveSubagentTools, resolveSummarizationRetention, resolveToolApprovalState, resolveUserQuestionState, responseCache, restoreSnapshot, restoreToolCalls, runSmartAgentEvalHarness, scoreItemsByRelevance, searchSkills, seedChildMessages, selectTopIndicesInOrder, sessionMetrics, setTokenCounter, startStreamingSession, summarizeObject, supportsAdaptiveThinking, textFromContent, toMessageUsage, toStrictCompatible, toStrictToolSchema, tokenize, toolPolicy, traceSessionToOtlp, validateReasoningConfig, validateToolArgs, webhookApproval, withTools, withinDepth, writeSummaryFactsToMemory };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map