@cognipeer/agent-sdk 0.10.5 → 0.12.0

package/dist/index.cjs

@@ -28,6 +28,238 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/utils/content.ts
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function nonEmpty(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function kindFromMediaType(mediaType) {
+  const top = mediaType?.split("/")[0];
+  return top === "image" || top === "audio" || top === "video" ? top : "file";
+}
+function inlineDataOf(part) {
+  const inline = part.inlineData ?? part.inline_data ?? part.fileData ?? part.file_data;
+  return isRecord(inline) ? inline : void 0;
+}
+function mediaKindOf(part) {
+  if (!isRecord(part)) return void 0;
+  const type = nonEmpty(part.type);
+  if (type) return MEDIA_PART_KINDS[type];
+  const inline = inlineDataOf(part);
+  if (inline) return kindFromMediaType(nonEmpty(inline.mimeType) ?? nonEmpty(inline.mime_type));
+  return void 0;
+}
+function hasMediaPart(content) {
+  return Array.isArray(content) && content.some((part) => mediaKindOf(part) !== void 0);
+}
+function urlOfPart(part) {
+  const image = part.image_url;
+  const video = part.video_url;
+  return nonEmpty(typeof image === "string" ? image : image?.url) ?? nonEmpty(typeof video === "string" ? video : video?.url) ?? nonEmpty(part.url) ?? nonEmpty(part.source?.url) ?? nonEmpty(inlineDataOf(part)?.fileUri) ?? nonEmpty(inlineDataOf(part)?.file_uri);
+}
+function mediaTypeOfPart(part) {
+  const image = isRecord(part.image_url) ? part.image_url : void 0;
+  const source = isRecord(part.source) ? part.source : void 0;
+  const inline = inlineDataOf(part);
+  const audioFormat = nonEmpty(part.input_audio?.format);
+  const fromDataUrl = /^data:([^;,]+)/i.exec(urlOfPart(part) ?? "")?.[1];
+  return nonEmpty(part.mediaType) ?? nonEmpty(part.media_type) ?? nonEmpty(part.mimeType) ?? nonEmpty(part.mime_type) ?? nonEmpty(source?.mediaType) ?? nonEmpty(source?.media_type) ?? nonEmpty(image?.mediaType) ?? nonEmpty(image?.media_type) ?? nonEmpty(inline?.mimeType) ?? nonEmpty(inline?.mime_type) ?? nonEmpty(fromDataUrl) ?? (audioFormat ? `audio/${audioFormat}` : void 0);
+}
+function nameOfPart(part) {
+  const file = isRecord(part.file) ? part.file : void 0;
+  const image = isRecord(part.image_url) ? part.image_url : void 0;
+  const source = isRecord(part.source) ? part.source : void 0;
+  return nonEmpty(part.name) ?? nonEmpty(part.fileName) ?? nonEmpty(part.filename) ?? nonEmpty(part.file_name) ?? nonEmpty(file?.filename) ?? nonEmpty(file?.fileName) ?? nonEmpty(image?.name) ?? nonEmpty(source?.fileName) ?? nonEmpty(source?.filename) ?? nonEmpty(part.fileId) ?? nonEmpty(part.file_id) ?? nonEmpty(file?.file_id) ?? nonEmpty(file?.fileId) ?? nonEmpty(image?.fileId) ?? nonEmpty(image?.file_id) ?? nonEmpty(part.image_file?.file_id);
+}
+function labelFromUrl(url) {
+  if (!url || url.startsWith("data:")) return void 0;
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol === "session-file:") return nonEmpty(parsed.hostname) ?? nonEmpty(parsed.pathname.replace(/^\/+/, ""));
+    if (parsed.protocol === "http:" || parsed.protocol === "https:") {
+      return nonEmpty(decodeURIComponent(parsed.pathname.split("/").filter(Boolean).pop() ?? ""));
+    }
+  } catch {
+  }
+  return void 0;
+}
+function describeContentPart(part) {
+  const kind = mediaKindOf(part);
+  if (!kind || !isRecord(part)) return void 0;
+  const label = nameOfPart(part) ?? mediaTypeOfPart(part) ?? labelFromUrl(urlOfPart(part));
+  if (!label) return `[${kind}]`;
+  const clean = label.replace(/[\r\n\]]+/g, " ").slice(0, PLACEHOLDER_LABEL_MAX);
+  return `[${kind}: ${clean}]`;
+}
+function contentPartToText(part, fallback) {
+  if (typeof part === "string") return part;
+  if (!isRecord(part)) return part == null ? "" : String(part);
+  const media = describeContentPart(part);
+  if (media) return media;
+  if (typeof part.text === "string") return part.text;
+  if (typeof part.content === "string") return part.content;
+  if (fallback) return fallback(part);
+  try {
+    return JSON.stringify(part);
+  } catch {
+    return String(part);
+  }
+}
+function contentToString(content) {
+  try {
+    if (content == null) return "";
+    if (typeof content === "string") return content;
+    if (Array.isArray(content)) {
+      return content.map((p) => {
+        if (!p || typeof p !== "object") return String(p);
+        if (p.type === "text") return String(p.text ?? "");
+        if (p.type === "image_url") {
+          const img = p.image_url;
+          const url = typeof img === "string" ? img : img?.url;
+          if (typeof url === "string" && /^https?:\/\//i.test(url)) {
+            const detail = typeof img === "string" ? void 0 : img?.detail;
+            return `[image:${url}${detail ? ` detail=${detail}` : ""}]`;
+          }
+          return describeContentPart(p) ?? "[image]";
+        }
+        const media = describeContentPart(p);
+        if (media) return media;
+        return JSON.stringify(p);
+      }).join("\n");
+    }
+    return describeContentPart(content) ?? JSON.stringify(content);
+  } catch {
+    return String(content);
+  }
+}
+function mergeContentsToString(contents) {
+  return contents.map((c) => contentToString(c)).join("\n");
+}
+function safeStringify(value, pretty = false) {
+  if (value == null) return "";
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value, null, pretty ? 2 : void 0) ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+function extractMessageText(message) {
+  if (!message) return "";
+  const content = message.content;
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((part) => typeof part === "string" ? part : part?.text ?? part?.content ?? "").join("");
+  }
+  return "";
+}
+function textFromContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.filter((part) => isTextPart(part)).map((part) => part.text ?? "").join("\n");
+}
+function isTextPart(part) {
+  return !!part && typeof part === "object" && part.type === "text";
+}
+function mapTextParts(content, fn) {
+  if (typeof content === "string") return fn(content);
+  if (!Array.isArray(content)) return content;
+  return content.map((part) => isTextPart(part) ? { ...part, text: fn(part.text) } : part);
+}
+function replaceTextContent(content, text) {
+  if (typeof content === "string" || content == null) return text;
+  if (!Array.isArray(content)) return text;
+  const textIndexes = content.reduce((acc, part, index) => {
+    if (isTextPart(part)) acc.push(index);
+    return acc;
+  }, []);
+  if (textIndexes.length === 0) {
+    return text.length > 0 ? [{ type: "text", text }, ...content] : content;
+  }
+  const [first, ...rest] = textIndexes;
+  const dropped = new Set(rest);
+  return content.map((part, index) => index === first ? { ...part, text } : part).filter((_part, index) => !dropped.has(index));
+}
+function normalizeSource(source) {
+  if (!source || typeof source !== "object") return {};
+  const src = source;
+  if (src.type === "base64" && typeof src.data === "string") {
+    return {
+      sourceType: "base64",
+      mediaType: typeof src.mediaType === "string" ? src.mediaType : void 0,
+      // base64 encodes 3 bytes per 4 characters; padding makes this an upper bound.
+      approxBytes: Math.floor(src.data.length * 3 / 4)
+    };
+  }
+  if (src.type === "url" && typeof src.url === "string") {
+    return {
+      sourceType: "url",
+      url: src.url,
+      mediaType: typeof src.mediaType === "string" ? src.mediaType : void 0
+    };
+  }
+  return {};
+}
+function collectAttachments(content) {
+  if (!Array.isArray(content)) return [];
+  const attachments = [];
+  content.forEach((part, index) => {
+    if (!part || typeof part !== "object") return;
+    const type = part.type;
+    if (!type || type === "text") return;
+    if (type === "image" || type === "audio" || type === "video" || type === "file") {
+      attachments.push({
+        index,
+        kind: type,
+        fileName: typeof part.fileName === "string" ? part.fileName : void 0,
+        ...normalizeSource(part.source)
+      });
+      return;
+    }
+    if (type === "image_url") {
+      const image = part.image_url;
+      const url = typeof image === "string" ? image : image?.url;
+      if (typeof url === "string" && url.startsWith("data:")) {
+        const comma = url.indexOf(",");
+        const header = url.slice(5, comma);
+        attachments.push({
+          index,
+          kind: "image",
+          sourceType: "base64",
+          mediaType: header.split(";")[0] || void 0,
+          approxBytes: Math.floor((url.length - comma - 1) * 3 / 4)
+        });
+      } else {
+        attachments.push({ index, kind: "image", sourceType: "url", url });
+      }
+      return;
+    }
+    attachments.push({ index, kind: "unknown" });
+  });
+  return attachments;
+}
+var MEDIA_PART_KINDS, PLACEHOLDER_LABEL_MAX;
+var init_content = __esm({
+  "src/utils/content.ts"() {
+    MEDIA_PART_KINDS = {
+      image: "image",
+      image_url: "image",
+      input_image: "image",
+      image_file: "image",
+      audio: "audio",
+      input_audio: "audio",
+      video: "video",
+      video_url: "video",
+      file: "file",
+      input_file: "file",
+      document: "file"
+    };
+    PLACEHOLDER_LABEL_MAX = 80;
+  }
+});
+
 // src/utils/utilTokens.ts
 var utilTokens_exports = {};
 __export(utilTokens_exports, {
@@ -52,7 +284,7 @@ function getTokenCounter() {
 function countApproxTokens(text) {
   return activeTokenCounter(text || "");
 }
-function extractMessageText(m) {
+function extractMessageText2(m) {
   if (!m) return "";
   const parts = [];
   parts.push(m.role || "");
@@ -62,6 +294,7 @@ function extractMessageText(m) {
   } else if (Array.isArray(m.content)) {
     for (const c of m.content) {
       if (typeof c === "string") parts.push(c);
+      else if (describeContentPart(c)) parts.push(describeContentPart(c));
       else if (c?.text) parts.push(c.text);
       else if (c?.content) parts.push(c.content);
       else if (c?.type === "tool_use" && c?.input) {
@@ -72,7 +305,7 @@ function extractMessageText(m) {
       }
     }
   } else if (m.content != null && typeof m.content === "object") {
-    parts.push(JSON.stringify(m.content));
+    parts.push(describeContentPart(m.content) ?? JSON.stringify(m.content));
   }
   if (Array.isArray(m.tool_calls)) {
     for (const tc of m.tool_calls) {
@@ -102,12 +335,13 @@ function extractMessageText(m) {
 }
 function countMessagesTokens(messages) {
   if (!Array.isArray(messages) || messages.length === 0) return 0;
-  const allText = messages.map(extractMessageText).join("\n");
+  const allText = messages.map(extractMessageText2).join("\n");
   return countApproxTokens(allText) + messages.length * 4;
 }
 var activeTokenCounter;
 var init_utilTokens = __esm({
   "src/utils/utilTokens.ts"() {
+    init_content();
     activeTokenCounter = defaultTokenCounter;
   }
 });
@@ -568,6 +802,125 @@ function isOpenAIHostedEndpoint(lcModel) {
   }
 }
 
+// src/utils/abort.ts
+var POLL_INTERVAL_MS = 100;
+var NOOP = () => void 0;
+function isObject(value) {
+  return value !== null && typeof value === "object";
+}
+function isRealSignal(value) {
+  return typeof AbortSignal !== "undefined" && value instanceof AbortSignal;
+}
+function isCancellationRequested(source) {
+  if (!source) return false;
+  for (const candidate of [source.signal, source.cancellationToken]) {
+    if (!isObject(candidate)) continue;
+    if (candidate.aborted === true || candidate.isCancellationRequested === true) return true;
+  }
+  return false;
+}
+function linkAbortSignal(source) {
+  if (!source) return { signal: void 0, dispose: NOOP };
+  const candidates = [];
+  for (const candidate of [source.signal, source.cancellationToken]) {
+    if (isObject(candidate) && !candidates.includes(candidate)) candidates.push(candidate);
+  }
+  if (candidates.length === 0) return { signal: void 0, dispose: NOOP };
+  const real = candidates.filter(isRealSignal);
+  if (candidates.length === 1 && real.length === 1) {
+    return { signal: real[0], dispose: NOOP };
+  }
+  const controller = new AbortController();
+  const cleanups = [];
+  let polled = [];
+  let timer;
+  const fire = (reason) => {
+    if (controller.signal.aborted) return;
+    try {
+      controller.abort(reason);
+    } catch {
+      controller.abort();
+    }
+  };
+  const dispose = () => {
+    if (timer !== void 0) {
+      clearInterval(timer);
+      timer = void 0;
+    }
+    polled = [];
+    for (const cleanup of cleanups.splice(0)) {
+      try {
+        cleanup();
+      } catch {
+      }
+    }
+  };
+  for (const candidate of candidates) {
+    if (candidate.aborted === true || candidate.isCancellationRequested === true) {
+      fire(isRealSignal(candidate) ? candidate.reason : void 0);
+      return { signal: controller.signal, dispose };
+    }
+  }
+  for (const candidate of candidates) {
+    if (typeof candidate.addEventListener === "function") {
+      const onAbort = () => fire(isRealSignal(candidate) ? candidate.reason : void 0);
+      candidate.addEventListener("abort", onAbort, { once: true });
+      cleanups.push(() => candidate.removeEventListener?.("abort", onAbort));
+      continue;
+    }
+    if (typeof candidate.onCancellationRequested === "function") {
+      let handle;
+      try {
+        handle = candidate.onCancellationRequested(() => fire());
+      } catch {
+        handle = void 0;
+      }
+      if (isObject(handle) && typeof handle.dispose === "function") {
+        cleanups.push(() => handle.dispose());
+      }
+      polled.push(candidate);
+      continue;
+    }
+    if ("isCancellationRequested" in candidate || "aborted" in candidate) {
+      polled.push(candidate);
+    }
+  }
+  if (polled.length > 0) {
+    timer = setInterval(() => {
+      for (const candidate of polled) {
+        if (candidate.aborted === true || candidate.isCancellationRequested === true) {
+          fire();
+          dispose();
+          return;
+        }
+      }
+    }, POLL_INTERVAL_MS);
+    timer.unref?.();
+  }
+  return { signal: controller.signal, dispose };
+}
+function abortableSleep(ms, signal) {
+  if (!signal) return new Promise((resolve) => setTimeout(resolve, ms));
+  if (signal.aborted) return Promise.reject(abortReason(signal));
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(abortReason(signal));
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function abortReason(signal) {
+  if (signal.reason !== void 0) return signal.reason;
+  const error = new Error("This operation was aborted");
+  error.name = "AbortError";
+  return error;
+}
+
 // src/model.ts
 function isSmartModel(m) {
   return !!m && typeof m === "object" && typeof m.invoke === "function";
@@ -576,6 +929,10 @@ function withTools(model, tools, options) {
   if (model?.bindTools) return model.bindTools(tools, options);
   return model;
 }
+function withLinkedSignal(options, signal) {
+  if (!signal || options?.signal === signal) return options;
+  return { ...options || {}, signal };
+}
 function fromLangchainModel(lcModel) {
   if (!lcModel) throw new Error("fromLangchainModel: model is undefined/null");
   const normalizeContent = (content) => {
@@ -611,7 +968,13 @@ function fromLangchainModel(lcModel) {
   const adapted = {
     invoke: async (messages, options) => {
       const lcMessages = messages.map(toLC);
-      const response = await lcModel.invoke(lcMessages, options);
+      const link = linkAbortSignal(options);
+      let response;
+      try {
+        response = await lcModel.invoke(lcMessages, withLinkedSignal(options, link.signal));
+      } finally {
+        link.dispose();
+      }
       if (response && typeof response === "object") {
         const content = response.content ?? response.text ?? "";
         return {
@@ -629,10 +992,15 @@ function fromLangchainModel(lcModel) {
     stream: async function* (messages, options) {
       if (typeof lcModel.stream !== "function") return;
       const lcMessages = messages.map(toLC);
-      const streamResult = lcModel.stream(lcMessages, options);
-      const stream = typeof streamResult?.then === "function" ? await streamResult : streamResult;
-      for await (const chunk of stream) {
-        yield chunk;
+      const link = linkAbortSignal(options);
+      try {
+        const streamResult = lcModel.stream(lcMessages, withLinkedSignal(options, link.signal));
+        const stream = typeof streamResult?.then === "function" ? await streamResult : streamResult;
+        for await (const chunk of stream) {
+          yield chunk;
+        }
+      } finally {
+        link.dispose();
       }
     },
     bindTools: (tools, options) => {
@@ -811,6 +1179,9 @@ function safe(v) {
   const n = Number(v);
   return Number.isFinite(n) && n >= 0 ? n : 0;
 }
+
+// src/utils/tracing.ts
+init_content();
 var DEFAULT_COGNIPEER_URL = "https://console.cognipeer.com/api/client/v1/tracing/sessions";
 function fileSink(path2) {
   return { type: "file", path: path2 };
@@ -1555,6 +1926,12 @@ function buildMessageLabel(role, index) {
   const base = `${normalized.charAt(0).toUpperCase()}${normalized.slice(1)} Message`;
   return index > 1 ? `${base} #${index}` : base;
 }
+function structuredMessageParts(content) {
+  if (!hasMediaPart(content)) return void 0;
+  const cloned = sanitizeTracePayload(content);
+  if (!Array.isArray(cloned)) return void 0;
+  return cloned.map((part) => typeof part === "string" ? { type: "text", text: part } : part);
+}
 function toDisplayString(value) {
   const sanitized = sanitizeTracePayload(value);
   if (sanitized == null) return "";
@@ -1563,7 +1940,9 @@ function toDisplayString(value) {
     return sanitized.map((item) => toDisplayString(item)).filter((part) => part && part.trim().length > 0).join("\n");
   }
   if (typeof sanitized === "object") {
-    if (typeof sanitized.text === "string" && Object.keys(sanitized).length === 1) {
+    const media = describeContentPart(sanitized);
+    if (media) return media;
+    if (typeof sanitized.text === "string" && (Object.keys(sanitized).length === 1 || sanitized.type === "text")) {
       return sanitized.text;
     }
     if (typeof sanitized.content === "string") {
@@ -1635,11 +2014,13 @@ function convertMessageListToSections(messageList) {
         if (!content || !content.trim().length) continue;
       }
     }
+    const parts = structuredMessageParts(message?.content);
     sections.push({
       kind: "message",
       label: buildMessageLabel(role, next),
       role,
       content,
+      ...parts ? { parts } : {},
       metadata: typeof message?.name === "string" ? { name: message.name } : void 0
     });
   }
@@ -2060,6 +2441,15 @@ function estimatePayloadBytes(value) {
     }
   }
 }
+function toMessageUsage(u) {
+  return {
+    prompt_tokens: u.inputTokens,
+    completion_tokens: u.outputTokens,
+    total_tokens: u.totalTokens,
+    prompt_tokens_details: { cached_tokens: u.cachedInputTokens, cache_write_tokens: u.cachedWriteTokens },
+    completion_tokens_details: { reasoning_tokens: u.reasoningTokens }
+  };
+}
 function fromNativeProvider(provider, options) {
   let boundTools = options?.__tools;
   const modelName = options?.model ?? provider.defaultModel ?? provider.providerName;
@@ -2067,50 +2457,87 @@ function fromNativeProvider(provider, options) {
     modelName,
     capabilities: resolveCapabilities(provider.providerName),
     invoke: async (messages, _invokeOptions) => {
-      const request = buildRequest(messages, boundTools, options, _invokeOptions);
-      const response = await provider.complete(request);
-      return toBaseChatMessage(response);
+      const link = linkAbortSignal(_invokeOptions);
+      try {
+        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 {
+        link.dispose();
+      }
     },
     stream: async function* (messages, _invokeOptions) {
-      const request = buildRequest(messages, boundTools, options, _invokeOptions);
-      request.stream = true;
-      let fullContent = "";
-      let allToolCalls = [];
-      let lastUsage;
-      let reasoningBlocks;
-      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.delta.reasoning?.blocks?.length) {
-          reasoningBlocks = chunk.delta.reasoning.blocks;
-        }
-        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;
-              } else {
-                toolCallBuffers.set(tc.id, {
-                  id: tc.id,
-                  name: tc.name ?? "",
-                  arguments: tc.arguments ?? ""
-                });
+      const link = linkAbortSignal(_invokeOptions);
+      try {
+        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 ?? "",
+                    ...tc.thoughtSignature ? { thoughtSignature: tc.thoughtSignature } : {}
+                  });
+                }
               }
             }
           }
+          if (chunk.usage) lastUsage = chunk.usage;
         }
-        if (chunk.usage) lastUsage = chunk.usage;
-      }
-      allToolCalls = [...toolCallBuffers.values()];
-      const finalMessage = assembleMessage(fullContent, allToolCalls, lastUsage);
-      if (reasoningBlocks?.length) {
-        finalMessage.reasoning = { blocks: reasoningBlocks };
+        if (link.signal?.aborted) return;
+        allToolCalls = [...toolCallBuffers.values()];
+        const finalMessage = assembleMessage(fullContent, allToolCalls, lastUsage);
+        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 {
+        link.dispose();
       }
-      yield finalMessage;
     },
     bindTools: (tools, _bindOptions) => {
       const strict = _bindOptions?.strict ?? false;
@@ -2119,6 +2546,11 @@ function fromNativeProvider(provider, options) {
     }
   };
   return adapted;
+  async function applyTransform(req) {
+    if (!options?.transformRequest) return req;
+    const out = await options.transformRequest(req);
+    return out ?? req;
+  }
   function buildRequest(messages, tools, opts, invokeOptions) {
     const req = {
       model: opts?.model ?? modelName,
@@ -2126,6 +2558,10 @@ function fromNativeProvider(provider, options) {
     };
     if (opts?.temperature != null) req.temperature = opts.temperature;
     if (opts?.maxTokens != null) req.maxTokens = opts.maxTokens;
+    if (opts?.topP != null) req.topP = opts.topP;
+    if (opts?.stop?.length) req.stop = opts.stop;
+    if (opts?.presencePenalty != null) req.presencePenalty = opts.presencePenalty;
+    if (opts?.frequencyPenalty != null) req.frequencyPenalty = opts.frequencyPenalty;
     if (tools?.length) req.tools = tools;
     if (opts?.extra) req.extra = opts.extra;
     const reasoningOverride = invokeOptions?.reasoning;
@@ -2178,7 +2614,8 @@ function toUnifiedMessage(msg) {
     unified.toolCalls = msg.tool_calls.map((tc) => ({
       id: tc.id,
       name: tc.function?.name ?? tc.name ?? "",
-      arguments: tc.function?.arguments ?? tc.arguments ?? "{}"
+      arguments: tc.function?.arguments ?? tc.arguments ?? "{}",
+      ...tc.thoughtSignature ? { thoughtSignature: tc.thoughtSignature } : {}
     }));
   }
   const reasoning = msg.reasoning;
@@ -2452,29 +2889,16 @@ function toToolDefinition(tool, strict) {
   }
   return { name, description, parameters, ...useStrict ? { strict: true } : {} };
 }
+function legacyTokenUsage(u) {
+  return { ...toMessageUsage(u), cached_tokens: u.cachedInputTokens, cache_write_tokens: u.cachedWriteTokens };
+}
 function toBaseChatMessage(response) {
   const msg = {
     role: "assistant",
     content: response.content ?? "",
-    usage: {
-      prompt_tokens: response.usage.inputTokens,
-      completion_tokens: response.usage.outputTokens,
-      total_tokens: response.usage.totalTokens,
-      prompt_tokens_details: {
-        cached_tokens: response.usage.cachedInputTokens
-      },
-      completion_tokens_details: {
-        reasoning_tokens: response.usage.reasoningTokens
-      }
-    },
+    usage: toMessageUsage(response.usage),
     response_metadata: {
-      token_usage: {
-        prompt_tokens: response.usage.inputTokens,
-        completion_tokens: response.usage.outputTokens,
-        total_tokens: response.usage.totalTokens,
-        cached_tokens: response.usage.cachedInputTokens,
-        cache_write_tokens: response.usage.cachedWriteTokens
-      },
+      token_usage: legacyTokenUsage(response.usage),
       finish_reason: response.finishReason,
       model_name: response.model
     }
@@ -2483,7 +2907,8 @@ function toBaseChatMessage(response) {
     msg.tool_calls = response.toolCalls.map((tc) => ({
       id: tc.id,
       type: "function",
-      function: { name: tc.name, arguments: tc.arguments }
+      function: { name: tc.name, arguments: tc.arguments },
+      ...tc.thoughtSignature ? { thoughtSignature: tc.thoughtSignature } : {}
     }));
   }
   if (response.reasoning && (response.reasoning.blocks?.length || response.reasoning.summary)) {
@@ -2497,32 +2922,15 @@ function assembleMessage(content, toolCalls, usage) {
     content
   };
   if (usage) {
-    msg.usage = {
-      prompt_tokens: usage.inputTokens,
-      completion_tokens: usage.outputTokens,
-      total_tokens: usage.totalTokens,
-      prompt_tokens_details: {
-        cached_tokens: usage.cachedInputTokens
-      },
-      completion_tokens_details: {
-        reasoning_tokens: usage.reasoningTokens
-      }
-    };
-    msg.response_metadata = {
-      token_usage: {
-        prompt_tokens: usage.inputTokens,
-        completion_tokens: usage.outputTokens,
-        total_tokens: usage.totalTokens,
-        cached_tokens: usage.cachedInputTokens,
-        cache_write_tokens: usage.cachedWriteTokens
-      }
-    };
+    msg.usage = toMessageUsage(usage);
+    msg.response_metadata = { token_usage: legacyTokenUsage(usage) };
   }
   if (toolCalls.length > 0) {
     msg.tool_calls = toolCalls.map((tc) => ({
       id: tc.id,
       type: "function",
-      function: { name: tc.name, arguments: tc.arguments }
+      function: { name: tc.name, arguments: tc.arguments },
+      ...tc.thoughtSignature ? { thoughtSignature: tc.thoughtSignature } : {}
     }));
   }
   return msg;
@@ -2555,8 +2963,8 @@ function resolveCapabilities(provider) {
       return {
         structuredOutput: "tool_based",
         strictToolCalling: false,
-        streaming: false,
-        // streaming uses binary protocol
+        streaming: true,
+        // ConverseStream (AWS event-stream frames)
         provider: "bedrock"
       };
     case "vertex":
@@ -2573,150 +2981,21 @@ function resolveCapabilities(provider) {
 
 // src/smart/toolResponses.ts
 init_utilTokens();
+init_content();
 
-// src/utils/content.ts
-function contentToString(content) {
-  try {
-    if (content == null) return "";
-    if (typeof content === "string") return content;
-    if (Array.isArray(content)) {
-      return content.map((p) => {
-        if (!p || typeof p !== "object") return String(p);
-        if (p.type === "text") return String(p.text ?? "");
-        if (p.type === "image_url") {
-          const img = p.image_url;
-          const url = typeof img === "string" ? img : img?.url;
-          const detail = typeof img === "string" ? void 0 : img?.detail;
-          return `[image:${url || "unknown"}${detail ? ` detail=${detail}` : ""}]`;
-        }
-        return JSON.stringify(p);
-      }).join("\n");
-    }
-    return JSON.stringify(content);
-  } catch {
-    return String(content);
-  }
-}
-function mergeContentsToString(contents) {
-  return contents.map((c) => contentToString(c)).join("\n");
-}
-function safeStringify(value, pretty = false) {
-  if (value == null) return "";
-  if (typeof value === "string") return value;
-  try {
-    return JSON.stringify(value, null, pretty ? 2 : void 0) ?? String(value);
-  } catch {
-    return String(value);
-  }
-}
-function extractMessageText2(message) {
-  if (!message) return "";
-  const content = message.content;
-  if (typeof content === "string") return content;
-  if (Array.isArray(content)) {
-    return content.map((part) => typeof part === "string" ? part : part?.text ?? part?.content ?? "").join("");
-  }
-  return "";
-}
-function textFromContent(content) {
-  if (typeof content === "string") return content;
-  if (!Array.isArray(content)) return "";
-  return content.filter((part) => isTextPart(part)).map((part) => part.text ?? "").join("\n");
-}
-function isTextPart(part) {
-  return !!part && typeof part === "object" && part.type === "text";
-}
-function mapTextParts(content, fn) {
-  if (typeof content === "string") return fn(content);
-  if (!Array.isArray(content)) return content;
-  return content.map((part) => isTextPart(part) ? { ...part, text: fn(part.text) } : part);
-}
-function replaceTextContent(content, text) {
-  if (typeof content === "string" || content == null) return text;
-  if (!Array.isArray(content)) return text;
-  const textIndexes = content.reduce((acc, part, index) => {
-    if (isTextPart(part)) acc.push(index);
-    return acc;
-  }, []);
-  if (textIndexes.length === 0) {
-    return text.length > 0 ? [{ type: "text", text }, ...content] : content;
-  }
-  const [first, ...rest] = textIndexes;
-  const dropped = new Set(rest);
-  return content.map((part, index) => index === first ? { ...part, text } : part).filter((_part, index) => !dropped.has(index));
-}
-function normalizeSource(source) {
-  if (!source || typeof source !== "object") return {};
-  const src = source;
-  if (src.type === "base64" && typeof src.data === "string") {
-    return {
-      sourceType: "base64",
-      mediaType: typeof src.mediaType === "string" ? src.mediaType : void 0,
-      // base64 encodes 3 bytes per 4 characters; padding makes this an upper bound.
-      approxBytes: Math.floor(src.data.length * 3 / 4)
-    };
-  }
-  if (src.type === "url" && typeof src.url === "string") {
-    return {
-      sourceType: "url",
-      url: src.url,
-      mediaType: typeof src.mediaType === "string" ? src.mediaType : void 0
-    };
-  }
-  return {};
-}
-function collectAttachments(content) {
-  if (!Array.isArray(content)) return [];
-  const attachments = [];
-  content.forEach((part, index) => {
-    if (!part || typeof part !== "object") return;
-    const type = part.type;
-    if (!type || type === "text") return;
-    if (type === "image" || type === "audio" || type === "video" || type === "file") {
-      attachments.push({
-        index,
-        kind: type,
-        fileName: typeof part.fileName === "string" ? part.fileName : void 0,
-        ...normalizeSource(part.source)
-      });
-      return;
-    }
-    if (type === "image_url") {
-      const image = part.image_url;
-      const url = typeof image === "string" ? image : image?.url;
-      if (typeof url === "string" && url.startsWith("data:")) {
-        const comma = url.indexOf(",");
-        const header = url.slice(5, comma);
-        attachments.push({
-          index,
-          kind: "image",
-          sourceType: "base64",
-          mediaType: header.split(";")[0] || void 0,
-          approxBytes: Math.floor((url.length - comma - 1) * 3 / 4)
-        });
-      } else {
-        attachments.push({ index, kind: "image", sourceType: "url", url });
-      }
-      return;
-    }
-    attachments.push({ index, kind: "unknown" });
-  });
-  return attachments;
-}
-
-// src/smart/toolArgCoercion.ts
-var PLACEHOLDER_TEXT = /* @__PURE__ */ new Set(["", "null", "undefined", "none", "nil", "n/a", "na"]);
-var ENVELOPE_KEYS = ["input", "args", "arguments", "params", "parameters", "payload"];
-function defOf(schema) {
-  const def = schema?._def;
-  return def && typeof def === "object" ? def : null;
-}
-function isPlaceholder(value) {
-  return typeof value === "string" && PLACEHOLDER_TEXT.has(value.trim().toLowerCase());
-}
-function parseJsonish(value) {
-  const text = value.trim();
-  if (!text.startsWith("{") && !text.startsWith("[")) return { ok: false };
+// src/smart/toolArgCoercion.ts
+var PLACEHOLDER_TEXT = /* @__PURE__ */ new Set(["", "null", "undefined", "none", "nil", "n/a", "na"]);
+var ENVELOPE_KEYS = ["input", "args", "arguments", "params", "parameters", "payload"];
+function defOf(schema) {
+  const def = schema?._def;
+  return def && typeof def === "object" ? def : null;
+}
+function isPlaceholder(value) {
+  return typeof value === "string" && PLACEHOLDER_TEXT.has(value.trim().toLowerCase());
+}
+function parseJsonish(value) {
+  const text = value.trim();
+  if (!text.startsWith("{") && !text.startsWith("[")) return { ok: false };
   try {
     return { ok: true, value: JSON.parse(text) };
   } catch {
@@ -3591,6 +3870,7 @@ function detectVolatileContent(text, limit = 20) {
 
 // src/smart/contextPilot/jsonCrusher.ts
 init_utilTokens();
+init_content();
 var CONTEXT_PILOT_JSON_MARKER_KEY = "__contextPilotDropped";
 function findCompressibleArray(output, minItems) {
   if (Array.isArray(output)) {
@@ -3803,6 +4083,7 @@ function compressSearchOutput(text, config, ccrStore) {
 
 // src/smart/contextPilot/pipeline.ts
 init_utilTokens();
+init_content();
 function createContextPilotRuntime(config) {
   return {
     ccrStore: new CCRStore({ ttlMs: config.ccr.ttlMs, maxEntries: config.ccr.maxEntries }),
@@ -4176,6 +4457,8 @@ function createAgentCoreNode(opts) {
     const streamingEnabled = Boolean(state.ctx?.__streaming);
     const cancellationToken = state.ctx?.__cancellationToken;
     const abortSignal = state.ctx?.__abortSignal;
+    const onProgress = state.ctx?.__onProgress;
+    const cancelRequested = () => isCancellationRequested({ signal: abortSignal, cancellationToken });
     const resolvedForCachePilot = getResolvedSmartConfig(opts, runtime);
     if (resolvedForCachePilot.contextPilot.enabled && resolvedForCachePilot.contextPilot.cacheAlignment.enabled) {
       const ctxForCacheWarning = state.ctx = state.ctx || {};
@@ -4334,6 +4617,29 @@ ${append}`;
     let response;
     let modelAttempt = 0;
     const maxModelRetries = host?.maxModelRetries ?? 0;
+    const finishCancelledTurn = (partialText) => {
+      const reason = abortSignal?.aborted ? "aborted" : "cancelled";
+      const ctx = state.ctx = state.ctx || {};
+      ctx.__cancelled = { stage: "agent", reason, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+      recordTraceEvent(traceSession, {
+        type: "ai_call",
+        label: "Assistant Cancelled",
+        actor: { scope: "agent", name: actorName, role: "assistant", version: actorVersion },
+        // "skipped", not "error": the call did not fail, the caller ended it —
+        // and an "error" would flip the whole session to error.
+        status: "skipped",
+        durationMs: Date.now() - start,
+        requestBytes: promptBytes,
+        model: getModelName(runtime.model || opts.model),
+        provider: getProviderName(runtime.model || opts.model),
+        messageList: state.messages,
+        toolDefinitions: traceToolDefinitions
+      });
+      onEvent?.({ type: "cancelled", stage: "agent", reason });
+      onProgress?.({ stage: "agent", message: "Cancelled", detail: { reason } });
+      const partial = partialText.trim().length > 0 ? [{ role: "assistant", content: partialText }] : [];
+      return { messages: [...state.messages, ...partial], usage: state.usage };
+    };
     while (true) {
       start = Date.now();
       if (shortCircuited !== void 0) {
@@ -4349,19 +4655,25 @@ ${append}`;
           toolDefinitions: traceToolDefinitions
         });
       } else {
+        let streamedText = "";
         try {
           const normalizedMessages = normalizeBedrockToolPairing([...wireMessages]);
           debugToolPairing(normalizedMessages);
           if (streamingEnabled && typeof modelWithTools.stream === "function") {
-            let streamedText = "";
             let streamedMessage;
+            let cutByCancel = false;
             for await (const chunk of modelWithTools.stream(normalizedMessages, invokeParams)) {
-              if (cancellationToken && cancellationToken.isCancellationRequested || abortSignal?.aborted) {
+              if (cancelRequested()) {
+                cutByCancel = true;
                 break;
               }
               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) {
@@ -4370,6 +4682,7 @@ ${append}`;
                 onEvent?.({ type: "stream", text });
               }
             }
+            if (cutByCancel) return finishCancelledTurn(streamedText);
             if (streamedMessage) {
               response = { ...streamedMessage };
               if (response.content == null || response.content === "") {
@@ -4382,6 +4695,7 @@ ${append}`;
             response = await modelWithTools.invoke(normalizedMessages, invokeParams);
           }
         } catch (err) {
+          if (cancelRequested()) return finishCancelledTurn(streamedText);
           const durationMs2 = Date.now() - start;
           recordTraceEvent(traceSession, {
             type: "ai_call",
@@ -4479,6 +4793,7 @@ ${append}`;
 }
 
 // src/utils/traceSections.ts
+init_content();
 function truncate(text, max = 500) {
   if (!text) return "";
   return text.length > max ? `${text.slice(0, max)}\u2026` : text;
@@ -6369,6 +6684,9 @@ function isCompactedToolContent(content) {
   return typeof content === "string" && (content === "SUMMARIZED" || content.startsWith("SUMMARIZED_TOOL_RESPONSE") || content.startsWith("ARCHIVED_TOOL_RESPONSE") || content.startsWith("STRUCTURED_TOOL_RESPONSE") || content.startsWith("DROPPED_TOOL_RESPONSE"));
 }
 
+// src/agent.ts
+init_content();
+
 // src/structuredOutput/manager.ts
 var StructuredOutputManager = class {
   constructor(schema, strategy, config) {
@@ -6601,6 +6919,7 @@ function buildSubagentCatalogBlock(subagents, policy, toolNames) {
 }
 
 // src/plugins/host.ts
+init_content();
 var DEFAULT_PRIORITY = 100;
 var DEFAULT_TIMEOUT_MS = 1e4;
 var HOOK_SPECS = {
@@ -7137,6 +7456,7 @@ function performanceNow() {
 }
 
 // src/plugins/session.ts
+init_content();
 async function openPluginSession(runHost, params) {
   let messages = params.messages;
   const startGate = await runHost.runGate("sessionStart", {
@@ -7606,6 +7926,7 @@ function createAgent(opts) {
         onProgress?.({ stage: "agent", message: "Invoking model" });
         if (cancelIfRequested("before_agent")) break;
         state = publish({ ...state, ...await agentCore(state) });
+        if (state.ctx?.__cancelled) break;
         onProgress?.({ stage: "agent", message: "Model response received" });
         if (checkpointIfRequested("after_agent")) break;
         const postGuardrails = getGuardrailConfig(state);
@@ -7676,7 +7997,7 @@ function createAgent(opts) {
       if (toolCalls.length === 0) {
         if (soManager && !state.ctx?.__finalizedDueToStructuredOutput && !state.ctx?.__structuredOutputForceFinalize && !state.ctx?.__guardrailBlocked) {
           if (soManager.strategy.kind === "native") {
-            const assistantText = extractMessageText2(lastMsg);
+            const assistantText = extractMessageText(lastMsg);
             if (assistantText) {
               const parsed = soManager.parseFromContent(assistantText);
               if (parsed.success) {
@@ -7732,7 +8053,7 @@ function createAgent(opts) {
     if (soManager && !state.ctx?.__finalizedDueToStructuredOutput && !structuredFinalizeBlocked) {
       const lastForParse = state.messages[state.messages.length - 1];
       if (lastForParse?.role === "assistant") {
-        const assistantText = extractMessageText2(lastForParse);
+        const assistantText = extractMessageText(lastForParse);
         if (assistantText) {
           const parsed = soManager.parseFromContent(assistantText);
           if (parsed.success) {
@@ -7994,7 +8315,7 @@ function createAgent(opts) {
     const isTransientSummarizationExit = !!res.ctx?.__needsSummarization;
     const finalAssistantMsg = isTransientSummarizationExit ? void 0 : getLastAssistantMessage(res.messages);
     const finalIsSyntheticSummary = !isTransientSummarizationExit && finalAssistantMsg && isSyntheticSummaryMessage(finalAssistantMsg);
-    let content = isTransientSummarizationExit || finalIsSyntheticSummary ? "" : extractMessageText2(finalAssistantMsg);
+    let content = isTransientSummarizationExit || finalIsSyntheticSummary ? "" : extractMessageText(finalAssistantMsg);
     const finalAnswerBlocked = Boolean(
       isTransientSummarizationExit || res.ctx?.__awaitingApproval || res.ctx?.__awaitingUserQuestion || res.ctx?.__cancelled || res.ctx?.__paused || res.ctx?.__limitBreached
     );
@@ -8253,9 +8574,11 @@ function createAgentNode(opts) {
 
 // src/nodes/contextSummarize.ts
 init_utilTokens();
+init_content();
 
 // src/smart/contextPolicy.ts
 init_utilTokens();
+init_content();
 function collectRecentTurns(messages, lastTurnsToKeep) {
   if (lastTurnsToKeep <= 0) return [];
   const systemPrefix = messages.filter((message, index) => index === 0 && message.role === "system");
@@ -8317,7 +8640,7 @@ function isClampProtected(message, index, firstUserIndex) {
 function clampToBudget(messages, maxContextTokens) {
   let working = [...messages];
   while (working.length > 2) {
-    const tokenCount = countApproxTokens(working.map(extractMessageText2).join("\n"));
+    const tokenCount = countApproxTokens(working.map(extractMessageText).join("\n"));
     if (tokenCount <= maxContextTokens) return working;
     const firstUserIndex = working.findIndex((message) => message.role === "user");
     const firstNonSystem = working.findIndex((message, index) => !isClampProtected(message, index, firstUserIndex));
@@ -8657,7 +8980,7 @@ function createContextSummarizeNode(opts) {
       let content = "";
       if (typeof m.content === "string") content = m.content;
       else if (Array.isArray(m.content)) {
-        content = m.content.map((c) => c.text || JSON.stringify(c)).join(" ");
+        content = m.content.map((c) => contentPartToText(c, (part) => JSON.stringify(part))).join(" ");
       }
       if (m.role === "tool" && isSummarizedToolPlaceholder(content)) {
         const historyEntry = findToolHistoryEntry(state, m.tool_call_id, m.name);
@@ -9502,6 +9825,9 @@ async function writeSummaryFactsToMemory(store, config, summary, sourceTurn) {
   return store.get(config.memory.scope, { limit: config.context.lastTurnsToKeep + summary.stable_facts.length });
 }
 
+// src/smart/index.ts
+init_content();
+
 // src/smart/skills/types.ts
 var DEFAULT_SKILL_POLICY = {
   maxOpenSkills: 4,
@@ -10516,7 +10842,7 @@ function createSmartAgent(opts) {
   ].join("\n");
   function latestUserPrompt(messages) {
     const latest = [...messages].reverse().find((message) => message.role === "user");
-    return latest ? extractMessageText2(latest) : "";
+    return latest ? extractMessageText(latest) : "";
   }
   async function syncMemory(state) {
     const query = latestUserPrompt(state.messages || []);
@@ -11227,6 +11553,182 @@ 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,
+  baseDelayMs: 500,
+  maxDelayMs: 8e3
+};
+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
+   * carries one.
+   *
+   * `signal` is the call's cancellation: a run that is cancelled while the
+   * provider is backing off must not sit out the delay, nor start another attempt.
+   */
+  async doFetchWithRetry(execute, signal) {
+    const policy = this.retryPolicy;
+    const maxRetries = Math.max(0, policy.maxRetries ?? DEFAULT_RETRY.maxRetries);
+    const baseDelay = Math.max(0, policy.baseDelayMs ?? DEFAULT_RETRY.baseDelayMs);
+    const maxDelay = Math.max(baseDelay, policy.maxDelayMs ?? DEFAULT_RETRY.maxDelayMs);
+    let lastResp;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      if (signal?.aborted) throw abortReason(signal);
+      const res = await execute();
+      const isRetryable = res.status === 429 || res.status >= 500 && res.status < 600;
+      if (!isRetryable) return res;
+      const predicate = policy.shouldRetry;
+      if (predicate && !predicate({ status: res.status }, attempt)) return res;
+      if (attempt === maxRetries) {
+        lastResp = res;
+        break;
+      }
+      const retryAfter = res.headers.get("retry-after");
+      let delay2 = Math.min(maxDelay, baseDelay * Math.pow(2, attempt));
+      if (retryAfter) {
+        const asNumber = Number(retryAfter);
+        if (!Number.isNaN(asNumber)) delay2 = Math.min(maxDelay, Math.max(delay2, asNumber * 1e3));
+      }
+      try {
+        await res.text();
+      } catch {
+      }
+      await abortableSleep(delay2, signal);
+    }
+    return lastResp;
+  }
+};
+
+// 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;
+    this.defaultHeaders = config.defaultHeaders ?? {};
+    if (config.retry) this.retryPolicy = { ...this.retryPolicy, ...config.retry };
+  }
+  /** Ask System One questions about `state`. */
+  async systemOne(request, options) {
+    const model = request.model ?? this.defaultModel;
+    const body = {
+      ...model ? { model } : {},
+      state: request.state,
+      questions: request.questions
+    };
+    const res = await this.doFetchWithRetry(
+      () => this.httpFetch(`${this.baseURL}/v1/systemone`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`,
+          ...this.defaultHeaders
+        },
+        body: JSON.stringify(body),
+        signal: options?.signal
+      })
+    );
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new ProviderError(`Jev API error ${res.status}: ${text}`, this.providerName, res.status, text);
+    }
+    return await res.json();
+  }
+  async complete(_request) {
+    throw new ProviderError(
+      'Jev is a decision model and has no chat completion; use systemOne() or agentVerdictRule({ engine: "jev" })',
+      this.providerName
+    );
+  }
+  // eslint-disable-next-line require-yield
+  async *completeStream(_request) {
+    throw new ProviderError("Jev does not stream; use systemOne()", this.providerName);
+  }
+};
+
+// src/guardrails/checks.ts
+init_content();
 var Ajv = AjvModule__default.default?.default ?? AjvModule__default.default;
 var defaultAjv = new Ajv({ allErrors: true });
 defaultAjv.opts.strict = false;
@@ -11376,14 +11878,82 @@ function defaultPayload(context) {
     2
   );
 }
+var DEFAULT_JEV_THRESHOLD = 0.5;
+var JEV_QUESTION_KEY = "shouldBlock";
+var DEFAULT_JEV_QUESTION = "Does this conversation payload pose a safety, security, or policy risk that should stop the agent from continuing? Answer yes when the latest message or action should be blocked, and no when it is safe to allow.";
+var DEFAULT_JEV_CRITERIA = {
+  true: "The payload is unsafe, non-compliant, or otherwise warrants blocking.",
+  false: "The payload is benign and the agent should be allowed to continue."
+};
+function resolveJevClient(config) {
+  if (config.client) return config.client;
+  const apiKey = config.apiKey ?? process.env.TYPESAFE_API_KEY;
+  if (!apiKey) {
+    throw new Error(
+      "Jev engine requires an API key: pass `jev.apiKey`, set TYPESAFE_API_KEY, or pass a `jev.client`."
+    );
+  }
+  return new JevProvider({
+    provider: "jev",
+    apiKey,
+    baseURL: config.baseURL ?? process.env.TYPESAFE_BASE_URL
+  });
+}
 function agentVerdictRule(options) {
   const payloadBuilder = options.payloadBuilder || defaultPayload;
   const fallbackDisposition = options.dispositionFallback || "block";
+  const engine = options.engine || "llm";
+  const jevOptions = options.jev || {};
+  const jevThreshold = typeof jevOptions.threshold === "number" ? jevOptions.threshold : DEFAULT_JEV_THRESHOLD;
+  let jevClient;
+  async function evaluateWithJev(context) {
+    const client = jevClient ?? (jevClient = resolveJevClient(jevOptions));
+    const instructions = jevOptions.question ? jevOptions.question(context) : DEFAULT_JEV_QUESTION;
+    const result = await client.systemOne({
+      state: payloadBuilder(context),
+      questions: {
+        [JEV_QUESTION_KEY]: {
+          type: "noul",
+          instructions,
+          criteria: jevOptions.criteria ?? DEFAULT_JEV_CRITERIA
+        }
+      },
+      ...jevOptions.model ? { model: jevOptions.model } : {}
+    });
+    const answer = result?.answers?.[JEV_QUESTION_KEY];
+    const probability = typeof answer?.noul === "number" ? answer.noul : void 0;
+    if (probability === void 0) {
+      return {
+        passed: false,
+        disposition: fallbackDisposition,
+        reason: "Jev engine did not return a noul probability.",
+        details: { jevModel: result?.model, jevUsage: result?.usage }
+      };
+    }
+    const passed = probability < jevThreshold;
+    return {
+      passed,
+      disposition: passed ? "allow" : fallbackDisposition,
+      reason: passed ? void 0 : `Jev risk probability ${probability.toFixed(3)} met or exceeded threshold ${jevThreshold}.`,
+      details: {
+        jevProbability: probability,
+        jevThreshold,
+        jevModel: result?.model,
+        jevUsage: result?.usage
+      }
+    };
+  }
   return {
     id: options.id,
     title: options.title || "Agent-based guardrail",
     description: options.description,
     async evaluate(context) {
+      if (engine === "jev") {
+        return evaluateWithJev(context);
+      }
+      if (!options.agent) {
+        throw new Error("agentVerdictRule requires an `agent` when using the default 'llm' engine.");
+      }
       const payload = payloadBuilder(context);
       const systemPrompt = options.systemPrompt || "You are a safety auditor. Review the provided conversation payload and decide whether it should continue. Return JSON with keys allow (boolean), optional disposition ('allow' | 'warn' | 'block'), optional reason (string), and optional details (object).";
       const review = await options.agent.invoke({
@@ -11599,6 +12169,7 @@ function isHookImplemented(hook) {
 }
 
 // src/plugins/builtin/guardrail.ts
+init_content();
 var ALLOW = { action: "allow" };
 var RETRYABLE_STATUS = /* @__PURE__ */ new Set([408, 425, 429, 500, 502, 503, 504]);
 var RetryableGuardrailError = class extends Error {
@@ -11885,7 +12456,7 @@ function createGuardrailPlugin(options) {
       return { decision: "deny", reason: verdict.message ?? "Request blocked by guardrail policy." };
     },
     postModelCall: async ({ message }, ctx) => {
-      const text = extractMessageText2(message);
+      const text = extractMessageText(message);
       if (!text) return void 0;
       const verdict = await check({ phase: "output", content: text, hook: "postModelCall" }, ctx);
       if (!raiseIfFailed(verdict, ctx) || verdict.action === "allow") return void 0;
@@ -12155,6 +12726,7 @@ function portkeyGuardrail(config = {}) {
 }
 
 // src/plugins/builtin/piiRedaction.ts
+init_content();
 function isValidTckn(value) {
   const digits = value.replace(/\D/g, "");
   if (digits.length !== 11 || digits[0] === "0") return false;
@@ -12274,7 +12846,7 @@ function piiRedaction(config = {}) {
       },
       postModelCall: ({ message }, ctx) => {
         if (!applied.has("modelOutput")) return void 0;
-        const text = extractMessageText2(message);
+        const text = extractMessageText(message);
         if (!text) return void 0;
         const result = redactText(text, detectors, mask);
         if (result.findings.length === 0) return void 0;
@@ -13362,12 +13934,12 @@ function responseCache(config = {}) {
   };
 }
 function signRequest(req) {
-  const now = /* @__PURE__ */ new Date();
+  const now = req.now ?? /* @__PURE__ */ new Date();
   const dateStamp = toDateStamp(now);
   const amzDate = toAmzDate(now);
   const parsed = new URL(req.url);
   const host = parsed.host;
-  const canonicalUri = parsed.pathname || "/";
+  const canonicalUri = (parsed.pathname || "/").split("/").map((seg) => encodeURIComponent(seg).replace(/[!'()*]/g, (c) => "%" + c.charCodeAt(0).toString(16).toUpperCase())).join("/");
   const canonicalQuerystring = sortQueryParams(parsed.searchParams);
   const headers = {
     ...req.headers,
@@ -14681,140 +15253,8 @@ function languageGuard(config) {
   };
 }
 
-// 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,
-  baseDelayMs: 500,
-  maxDelayMs: 8e3
-};
-var BaseProvider = class {
-  constructor() {
-    this.retryPolicy = DEFAULT_RETRY;
-  }
-  /**
-   * Helper concrete providers can wrap their fetch with. Retries 429/5xx
-   * with exponential backoff and respects Retry-After if the response
-   * carries one.
-   */
-  async doFetchWithRetry(execute) {
-    const policy = this.retryPolicy;
-    const maxRetries = Math.max(0, policy.maxRetries ?? DEFAULT_RETRY.maxRetries);
-    const baseDelay = Math.max(0, policy.baseDelayMs ?? DEFAULT_RETRY.baseDelayMs);
-    const maxDelay = Math.max(baseDelay, policy.maxDelayMs ?? DEFAULT_RETRY.maxDelayMs);
-    let lastResp;
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-      const res = await execute();
-      const isRetryable = res.status === 429 || res.status >= 500 && res.status < 600;
-      if (!isRetryable) return res;
-      const predicate = policy.shouldRetry;
-      if (predicate && !predicate({ status: res.status }, attempt)) return res;
-      if (attempt === maxRetries) {
-        lastResp = res;
-        break;
-      }
-      const retryAfter = res.headers.get("retry-after");
-      let delay2 = Math.min(maxDelay, baseDelay * Math.pow(2, attempt));
-      if (retryAfter) {
-        const asNumber = Number(retryAfter);
-        if (!Number.isNaN(asNumber)) delay2 = Math.min(maxDelay, Math.max(delay2, asNumber * 1e3));
-      }
-      try {
-        await res.text();
-      } catch {
-      }
-      await new Promise((r) => setTimeout(r, delay2));
-    }
-    return lastResp;
-  }
-};
-
-// 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) ;
-      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.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/index.ts
+init_content();
 
 // src/providers/utils/reasoning.ts
 var ANTHROPIC_EFFORT_BUDGET = {
@@ -14837,6 +15277,7 @@ var GEMINI_EFFORT_BUDGET = {
   high: 12e3
 };
 var THINKING_OUTPUT_RESERVE = 1024;
+var MIN_THINKING_BUDGET = 1024;
 var THINKING_MIN_MAX_TOKENS = 4096;
 function applyOpenAIReasoning(body, reasoning, mode = "legacy_effort") {
   if (!reasoning) return;
@@ -14852,8 +15293,48 @@ function applyOpenAIReasoning(body, reasoning, mode = "legacy_effort") {
     if (reasoning.providerExtras) Object.assign(body, reasoning.providerExtras);
   }
 }
-function applyAnthropicReasoning(body, reasoning) {
+function supportsAdaptiveThinking(model) {
+  if (typeof model !== "string") return false;
+  const id = model.toLowerCase();
+  const at = id.indexOf("claude-");
+  if (at < 0) return false;
+  for (const tok of id.slice(at + 7).split("-")) {
+    if (tok === "fable") return true;
+    const m = /^(\d+)(?:@|$)/.exec(tok);
+    if (m) {
+      if (m[1].length <= 2) return Number(m[1]) >= 5;
+      return false;
+    }
+  }
+  return false;
+}
+function resolveThinkingForm(model, mode) {
+  if (mode === "adaptive" || mode === "budget") return mode;
+  return supportsAdaptiveThinking(model) ? "adaptive" : "budget";
+}
+function applyAdaptiveThinking(_body, reasoning, setThinking, setOutputConfig) {
+  const requested = normalizeEffort(reasoning.effort);
+  if (requested === "none") return false;
+  let effort;
+  if (requested) effort = requested === "minimal" ? "low" : requested;
+  else if (typeof reasoning.budgetTokens === "number" && reasoning.budgetTokens > 0) {
+    effort = reasoning.budgetTokens <= ANTHROPIC_EFFORT_BUDGET.low ? "low" : reasoning.budgetTokens <= ANTHROPIC_EFFORT_BUDGET.medium ? "medium" : "high";
+  }
+  if (!effort) return false;
+  const thinking = { type: "adaptive" };
+  if (reasoning.includeThoughts !== false) thinking.display = "summarized";
+  if (reasoning.providerExtras) Object.assign(thinking, reasoning.providerExtras);
+  setThinking({ thinking });
+  setOutputConfig({ effort });
+  return true;
+}
+function applyAnthropicReasoning(body, reasoning, opts) {
   if (!reasoning) return;
+  if (resolveThinkingForm(opts?.model ?? body.model, opts?.mode) === "adaptive") {
+    const on = applyAdaptiveThinking(body, reasoning, (extra) => body.thinking = extra.thinking, (o) => body.output_config = { ...body.output_config ?? {}, ...o });
+    if (on) stripSamplingParams(body, ["temperature", "top_p", "top_k"]);
+    return;
+  }
   let budget = resolveBudget(reasoning, ANTHROPIC_EFFORT_BUDGET);
   if (!budget) return;
   const currentMax = typeof body.max_tokens === "number" ? body.max_tokens : 0;
@@ -14861,14 +15342,20 @@ function applyAnthropicReasoning(body, reasoning) {
   if (currentMax < requiredMax) {
     body.max_tokens = requiredMax;
   }
-  budget = clampBudget(budget, body.max_tokens);
+  budget = Math.max(MIN_THINKING_BUDGET, clampBudget(budget, body.max_tokens));
   const thinking = { type: "enabled", budget_tokens: budget };
   if (reasoning.providerExtras) Object.assign(thinking, reasoning.providerExtras);
   body.thinking = thinking;
   stripSamplingParams(body, ["temperature", "top_p", "top_k"]);
 }
-function applyBedrockReasoning(body, reasoning) {
+function applyBedrockReasoning(body, reasoning, opts) {
   if (!reasoning) return;
+  if (resolveThinkingForm(opts?.model ?? body.modelId, opts?.mode) === "adaptive") {
+    const fields = () => body.additionalModelRequestFields ?? (body.additionalModelRequestFields = {});
+    const on = applyAdaptiveThinking(body, reasoning, (extra2) => fields().thinking = extra2.thinking, (o) => fields().output_config = { ...fields().output_config ?? {}, ...o });
+    if (on && body.inferenceConfig) stripSamplingParams(body.inferenceConfig, ["temperature", "topP"]);
+    return;
+  }
   let budget = resolveBudget(reasoning, ANTHROPIC_EFFORT_BUDGET);
   if (!budget) return;
   const inference = body.inferenceConfig ?? (body.inferenceConfig = {});
@@ -14877,7 +15364,7 @@ function applyBedrockReasoning(body, reasoning) {
   if (currentMax < requiredMax) {
     inference.maxTokens = requiredMax;
   }
-  budget = clampBudget(budget, inference.maxTokens);
+  budget = Math.max(MIN_THINKING_BUDGET, clampBudget(budget, inference.maxTokens));
   const extra = body.additionalModelRequestFields ?? (body.additionalModelRequestFields = {});
   const thinking = { type: "enabled", budget_tokens: budget };
   if (reasoning.providerExtras) Object.assign(thinking, reasoning.providerExtras);
@@ -14887,8 +15374,9 @@ function applyBedrockReasoning(body, reasoning) {
 function applyGeminiReasoning(generationConfig, reasoning) {
   if (!reasoning) return;
   const budget = resolveBudget(reasoning, GEMINI_EFFORT_BUDGET);
-  if (budget == null) return;
-  const thinkingConfig = { thinkingBudget: budget };
+  const level = typeof reasoning.thinkingLevel === "string" && reasoning.thinkingLevel ? reasoning.thinkingLevel : void 0;
+  if (budget == null && !level) return;
+  const thinkingConfig = level && budget !== 0 ? { thinkingLevel: level } : { thinkingBudget: budget ?? 0 };
   if (reasoning.includeThoughts) thinkingConfig.includeThoughts = true;
   if (reasoning.providerExtras) Object.assign(thinkingConfig, reasoning.providerExtras);
   generationConfig.thinkingConfig = thinkingConfig;
@@ -14919,6 +15407,73 @@ function resolveBudget(reasoning, effortBudget) {
   return void 0;
 }
 
+// src/providers/utils/sse.ts
+async function* parseSSEStream(body, signal) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      if (signal?.aborted) throw abortReason(signal);
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const parts = buffer.split(/\r?\n\r?\n/);
+      buffer = parts.pop() ?? "";
+      for (const part of parts) {
+        if (!part.trim()) continue;
+        const event = parseSSEBlock(part);
+        if (event) yield event;
+      }
+    }
+    if (buffer.trim()) {
+      const event = parseSSEBlock(buffer);
+      if (event) yield event;
+    }
+  } finally {
+    reader.cancel().catch(() => void 0);
+    reader.releaseLock();
+  }
+}
+function parseSSEBlock(block) {
+  let event;
+  let id;
+  let retry;
+  const dataLines = [];
+  for (const line of block.split(/\r?\n/)) {
+    if (line.startsWith(":")) continue;
+    const colonIdx = line.indexOf(":");
+    let field;
+    let value;
+    if (colonIdx === -1) {
+      field = line;
+      value = "";
+    } else {
+      field = line.slice(0, colonIdx);
+      value = line.slice(colonIdx + 1);
+      if (value.startsWith(" ")) value = value.slice(1);
+    }
+    switch (field) {
+      case "event":
+        event = value;
+        break;
+      case "data":
+        dataLines.push(value);
+        break;
+      case "id":
+        id = value;
+        break;
+      case "retry": {
+        const n = parseInt(value, 10);
+        if (!isNaN(n)) retry = n;
+        break;
+      }
+    }
+  }
+  if (dataLines.length === 0) return null;
+  return { event, data: dataLines.join("\n"), id, retry };
+}
+
 // src/providers/utils/media.ts
 var EXTENSION_MIME = {
   jpg: "image/jpeg",
@@ -14994,12 +15549,12 @@ function sanitizeBedrockDocName(name, fallback = "document") {
 // src/providers/utils/jsonSchemaRefs.ts
 var DEFINITION_KEYS = ["definitions", "$defs"];
 function inlineJsonSchemaRefs(schema) {
-  if (!isObject(schema) || !containsRef(schema)) return schema;
+  if (!isObject2(schema) || !containsRef(schema)) return schema;
   const root = structuredClone(schema);
   const selfReaching = /* @__PURE__ */ new Map();
   const targetOf = (ref) => {
     const target = resolvePointer(root, ref);
-    return isObject(target) ? target : void 0;
+    return isObject2(target) ? target : void 0;
   };
   const reachesItself = (target) => {
     const known = selfReaching.get(target);
@@ -15007,7 +15562,7 @@ function inlineJsonSchemaRefs(schema) {
     const seen = /* @__PURE__ */ new Set();
     const walk = (node) => {
       if (Array.isArray(node)) return node.some(walk);
-      if (!isObject(node)) return false;
+      if (!isObject2(node)) return false;
       if (typeof node.$ref === "string") {
         const next = targetOf(node.$ref);
         if (next === target) return true;
@@ -15025,7 +15580,7 @@ function inlineJsonSchemaRefs(schema) {
   const keptRefs = /* @__PURE__ */ new Set();
   const expand = (node) => {
     if (Array.isArray(node)) return node.map(expand);
-    if (!isObject(node)) return node;
+    if (!isObject2(node)) return node;
     if (typeof node.$ref === "string") {
       const target = targetOf(node.$ref);
       if (target && !reachesItself(target)) {
@@ -15047,7 +15602,7 @@ function inlineJsonSchemaRefs(schema) {
   for (const key of DEFINITION_KEYS) delete result[key];
   for (const key of DEFINITION_KEYS) {
     const block = root[key];
-    if (!isObject(block)) continue;
+    if (!isObject2(block)) continue;
     const needed = neededEntries(key, block, keptRefs);
     if (needed.length === 0) continue;
     const kept = {};
@@ -15075,13 +15630,13 @@ function collectRefs(node, into) {
     node.forEach((child) => collectRefs(child, into));
     return;
   }
-  if (!isObject(node)) return;
+  if (!isObject2(node)) return;
   if (typeof node.$ref === "string") into.push(node.$ref);
   for (const [k, value] of Object.entries(node)) if (k !== "$ref") collectRefs(value, into);
 }
 function containsRef(node) {
   if (Array.isArray(node)) return node.some(containsRef);
-  if (!isObject(node)) return false;
+  if (!isObject2(node)) return false;
   if (typeof node.$ref === "string") return true;
   return Object.values(node).some(containsRef);
 }
@@ -15098,7 +15653,7 @@ function resolvePointer(document, ref) {
     if (Array.isArray(current)) {
       if (!/^\d+$/.test(segment)) return void 0;
       current = current[Number(segment)];
-    } else if (isObject(current) && Object.prototype.hasOwnProperty.call(current, segment)) {
+    } else if (isObject2(current) && Object.prototype.hasOwnProperty.call(current, segment)) {
       current = current[segment];
     } else {
       return void 0;
@@ -15106,15 +15661,68 @@ function resolvePointer(document, ref) {
   }
   return current;
 }
-function isObject(value) {
+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";
@@ -15122,10 +15730,14 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
       ...config.defaultHeaders,
       ...config.organization ? { "OpenAI-Organization": config.organization } : {}
     };
-    this.responsesApi = config.responsesApi ?? "auto";
-    const ownInstance = new.target === _OpenAIProvider;
-    this.responsesApiModels = ownInstance ? [...config.responsesApiModels ?? []] : [];
-    this.responsesStreaming = ownInstance && config.responsesStreaming === true;
+    const legacy = config.responsesApi;
+    const explicit = config.api === "chat" || config.api === "responses" ? config.api : void 0;
+    this.responsesApi = explicit === "responses" ? "always" : explicit === "chat" ? "never" : legacy ?? (config._autoMeansChat ? "never" : "auto");
+    this.apiExplicitChat = explicit === "chat" || explicit === void 0 && legacy === "never";
+    this.apiExplicitResponses = this.responsesApi === "always";
+    this.apiResponsesNative = explicit === "responses";
+    this.responsesApiModels = [...config.responsesApiModels ?? []];
+    this.responsesStreaming = config.responsesStreaming ?? this.apiResponsesNative;
     if (config.retry) this.retryPolicy = { ...this.retryPolicy, ...config.retry };
   }
   /** True when the caller listed this request's model in `responsesApiModels`. */
@@ -15151,9 +15763,10 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
    * A model listed in `responsesApiModels` is the caller stating the answer
    * for that model alone; `never` still overrides it. */
   useResponsesApi(request) {
-    if (this.responsesApi === "never") return false;
-    if (this.responsesApi === "always") return true;
+    if (this.apiExplicitChat) return false;
+    if (this.apiExplicitResponses) return true;
     if (this.isResponsesApiModel(request)) return true;
+    if (this.responsesApi !== "auto") return false;
     if (!request.reasoning) return false;
     return isReasoningModel(request.model || this.defaultModel);
   }
@@ -15162,13 +15775,13 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
       return this.completeResponses(request);
     }
     const body = this.buildRequestBody(request, false);
-    const res = await this.doFetch(body);
+    const res = await this.doFetch(body, request.signal);
     const json = await res.json();
     return this.parseResponse(json);
   }
   async *completeStream(request) {
     if (this.useResponsesApi(request)) {
-      if (this.responsesStreaming && this.isResponsesApiModel(request)) {
+      if (this.responsesStreaming && (this.apiResponsesNative || this.isResponsesApiModel(request))) {
         yield* this.streamResponses(request);
         return;
       }
@@ -15187,13 +15800,13 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
       return;
     }
     const body = this.buildRequestBody(request, true);
-    const res = await this.doFetch(body);
+    const res = await this.doFetch(body, request.signal);
     if (!res.body) throw new ProviderError("No response body for stream", this.providerName);
     let id = "";
     let model = "";
     const toolCallBuffers = /* @__PURE__ */ new Map();
     let usage;
-    for await (const event of parseSSEStream(res.body)) {
+    for await (const event of parseSSEStream(res.body, request.signal)) {
       if (event.data === "[DONE]") break;
       let chunk;
       try {
@@ -15218,9 +15831,14 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
         delta: {},
         finishReason: mapFinishReason(choice.finish_reason)
       };
+      if (typeof choice.finish_reason === "string") out.rawFinishReason = choice.finish_reason;
+      const fields = pickProviderFields(chunk, delta, choice);
+      if (fields) out.providerFields = fields;
       if (delta.content) {
         out.delta.content = delta.content;
       }
+      const reasoningDelta = extractReasoningText(delta);
+      if (reasoningDelta) out.delta.reasoning = { summary: reasoningDelta };
       if (delta.tool_calls) {
         const partials = [];
         for (const tc of delta.tool_calls) {
@@ -15232,7 +15850,7 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
           if (tc.id) buf.id = tc.id;
           if (tc.function?.name) buf.name = tc.function.name;
           if (tc.function?.arguments) buf.arguments += tc.function.arguments;
-          partials.push({ id: buf.id, name: buf.name || void 0, arguments: tc.function?.arguments });
+          partials.push({ id: buf.id, name: buf.name || void 0, arguments: tc.function?.arguments, index: idx });
         }
         out.delta.toolCalls = partials;
       }
@@ -15240,6 +15858,51 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
       yield out;
     }
   }
+  // ─── Embeddings ──────────────────────────────────────────────────────────
+  /** POST /embeddings, batched (default 2048 inputs per request, the OpenAI cap). */
+  async embed(request) {
+    const model = requireEmbeddingModel(this.providerName, request.model);
+    const batches = chunkArray(request.input, request.batchSize ?? 2048);
+    const vectors = [];
+    const raw = [];
+    let inputTokens = 0;
+    let totalTokens = 0;
+    let responseModel = model;
+    for (const batch of batches) {
+      const body = { model, input: batch };
+      if (request.dimensions != null) body.dimensions = request.dimensions;
+      if (request.encodingFormat) body.encoding_format = request.encodingFormat;
+      if (request.extra) Object.assign(body, request.extra);
+      const res = await this.embeddingsFetch(body, request.signal);
+      const json = await res.json();
+      raw.push(json);
+      const data = Array.isArray(json.data) ? [...json.data] : [];
+      data.sort((a, b) => (a.index ?? 0) - (b.index ?? 0));
+      for (const d of data) {
+        vectors.push(typeof d.embedding === "string" ? decodeBase64Vector(d.embedding) : d.embedding);
+      }
+      inputTokens += json.usage?.prompt_tokens ?? 0;
+      totalTokens += json.usage?.total_tokens ?? json.usage?.prompt_tokens ?? 0;
+      responseModel = json.model ?? responseModel;
+    }
+    assertVectorCount(this.providerName, vectors, request.input.length);
+    return { model: responseModel, vectors, usage: { inputTokens, totalTokens }, raw };
+  }
+  async embeddingsFetch(body, signal) {
+    const url = `${this.baseURL}/embeddings`;
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.apiKey}`,
+      ...this.defaultHeaders
+    };
+    const payload = JSON.stringify(body);
+    const res = await this.doFetchWithRetry(() => this.httpFetch(url, { method: "POST", headers, body: payload, signal }), signal);
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new ProviderError(`OpenAI embeddings API error ${res.status}: ${text}`, this.providerName, res.status, text);
+    }
+    return res;
+  }
   // ─── Internals ───────────────────────────────────────────────────────────
   buildRequestBody(request, stream) {
     const body = {
@@ -15247,15 +15910,27 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
       messages: request.messages.map((m) => this.toOpenAIMessage(m)),
       stream
     };
-    if (stream) {
+    if (stream && request.streamUsage !== false) {
       body.stream_options = { include_usage: true };
     }
-    if (request.temperature != null) body.temperature = request.temperature;
-    if (request.maxTokens != null) body.max_tokens = request.maxTokens;
-    if (request.topP != null) body.top_p = request.topP;
+    const modelId = String(body.model);
+    const reasoningModel = isReasoningModel(modelId) && !/chat/i.test(modelId);
+    if (request.temperature != null && !reasoningModel) body.temperature = request.temperature;
+    if (request.maxTokens != null) {
+      const useCompletionTokens = this.maxTokensParam === "max_completion_tokens" || this.maxTokensParam === "auto" && isReasoningModel(modelId);
+      body[useCompletionTokens ? "max_completion_tokens" : "max_tokens"] = request.maxTokens;
+    }
+    if (request.topP != null && !reasoningModel) body.top_p = request.topP;
     if (request.stop) body.stop = request.stop;
+    if (request.presencePenalty != null) body.presence_penalty = request.presencePenalty;
+    if (request.frequencyPenalty != null) body.frequency_penalty = request.frequencyPenalty;
+    if (request.seed != null) body.seed = request.seed;
+    if (request.n != null) body.n = request.n;
+    if (request.logprobs != null) body.logprobs = request.logprobs;
+    if (request.topLogprobs != null) body.top_logprobs = request.topLogprobs;
     if (request.tools?.length) {
       body.tools = request.tools.map((t) => this.toOpenAITool(t));
+      if (request.parallelToolCalls != null) body.parallel_tool_calls = request.parallelToolCalls;
     }
     if (request.toolChoice != null && request.tools?.length) {
       if (typeof request.toolChoice === "string") {
@@ -15287,8 +15962,8 @@ 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);
-    const res = await this.responsesFetch(body);
+    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);
   }
@@ -15304,13 +15979,14 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
     const body = this.buildResponsesBody(request);
     adaptChatExtrasForResponses(body, request.extra);
     body.stream = true;
-    const res = await this.responsesFetch(body);
+    const res = await this.responsesFetch(body, request.signal);
     if (!res.body) throw new ProviderError("No response body for stream", this.providerName);
     let id = "";
     let model = modelId;
     const calls = /* @__PURE__ */ new Map();
     let final;
-    for await (const event of parseSSEStream(res.body)) {
+    let streamedSummary = false;
+    for await (const event of parseSSEStream(res.body, request.signal)) {
       if (event.data === "[DONE]") break;
       let data;
       try {
@@ -15327,19 +16003,28 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
         case "response.output_text.delta":
           if (data.delta) yield { id, model, delta: { content: data.delta } };
           break;
+        case "response.reasoning_summary_part.added":
+          if (streamedSummary) yield { id, model, delta: { reasoning: { summary: "\n\n" } } };
+          break;
+        case "response.reasoning_summary_text.delta":
+          if (typeof data.delta === "string" && data.delta) {
+            streamedSummary = true;
+            yield { id, model, delta: { reasoning: { summary: data.delta } } };
+          }
+          break;
         case "response.output_item.added": {
           const item = data.item;
           if (item?.type !== "function_call") break;
-          const call = { callId: item.call_id ?? item.id ?? "", name: item.name ?? "", arguments: item.arguments ?? "" };
+          const call = { callId: item.call_id ?? item.id ?? "", name: item.name ?? "", arguments: item.arguments ?? "", index: calls.size };
           calls.set(item.id ?? call.callId, call);
-          yield { id, model, delta: { toolCalls: [{ id: call.callId, name: call.name, arguments: call.arguments }] } };
+          yield { id, model, delta: { toolCalls: [{ id: call.callId, name: call.name, arguments: call.arguments, index: call.index }] } };
           break;
         }
         case "response.function_call_arguments.delta": {
           const call = calls.get(data.item_id);
           if (!call || !data.delta) break;
           call.arguments += data.delta;
-          yield { id, model, delta: { toolCalls: [{ id: call.callId, arguments: data.delta }] } };
+          yield { id, model, delta: { toolCalls: [{ id: call.callId, arguments: data.delta, index: call.index }] } };
           break;
         }
         case "response.output_item.done": {
@@ -15348,13 +16033,13 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
           const full = typeof item.arguments === "string" ? item.arguments : "";
           const call = calls.get(item.id ?? item.call_id);
           if (!call) {
-            const added = { callId: item.call_id ?? item.id ?? "", name: item.name ?? "", arguments: full };
+            const added = { callId: item.call_id ?? item.id ?? "", name: item.name ?? "", arguments: full, index: calls.size };
             calls.set(item.id ?? added.callId, added);
-            yield { id, model, delta: { toolCalls: [{ id: added.callId, name: added.name, arguments: full }] } };
+            yield { id, model, delta: { toolCalls: [{ id: added.callId, name: added.name, arguments: full, index: added.index }] } };
           } else if (full.length > call.arguments.length && full.startsWith(call.arguments)) {
             const rest = full.slice(call.arguments.length);
             call.arguments = full;
-            yield { id, model, delta: { toolCalls: [{ id: call.callId, arguments: rest }] } };
+            yield { id, model, delta: { toolCalls: [{ id: call.callId, arguments: rest, index: call.index }] } };
           }
           break;
         }
@@ -15377,7 +16062,8 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
     yield {
       id: final?.id || id,
       model: final?.model || model,
-      delta: final?.reasoning ? { reasoning: final.reasoning } : {},
+      // Summary text already went out as deltas; do not repeat it.
+      delta: final?.reasoning && !streamedSummary ? { reasoning: final.reasoning } : {},
       usage: final?.usage,
       finishReason: final?.finishReason ?? (calls.size > 0 ? "tool_calls" : "stop")
     };
@@ -15478,7 +16164,7 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
     });
     return { role, content };
   }
-  async responsesFetch(body) {
+  async responsesFetch(body, signal) {
     body.input = expandResponsesInput(body.input);
     const url = `${this.baseURL}/responses`;
     const headers = {
@@ -15487,7 +16173,7 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
       ...this.defaultHeaders
     };
     const payload = JSON.stringify(body);
-    const res = await this.doFetchWithRetry(() => fetch(url, { method: "POST", headers, body: payload }));
+    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(
@@ -15608,7 +16294,7 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
     }
     return { type: "function", function: fn };
   }
-  async doFetch(body) {
+  async doFetch(body, signal) {
     const url = `${this.baseURL}/chat/completions`;
     const headers = {
       "Content-Type": "application/json",
@@ -15616,7 +16302,7 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
       ...this.defaultHeaders
     };
     const payload = JSON.stringify(body);
-    const res = await this.doFetchWithRetry(() => fetch(url, { method: "POST", headers, body: payload }));
+    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(
@@ -15636,6 +16322,8 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
       name: tc.function?.name ?? "",
       arguments: tc.function?.arguments ?? "{}"
     }));
+    const reasoningText = extractReasoningText(message);
+    const providerFields = pickProviderFields(json, message, choice);
     return {
       id: json.id ?? "",
       model: json.model ?? "",
@@ -15643,6 +16331,9 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
       toolCalls,
       usage: this.extractUsage(json.usage),
       finishReason: mapFinishReason(choice?.finish_reason),
+      ...typeof choice?.finish_reason === "string" ? { rawFinishReason: choice.finish_reason } : {},
+      ...providerFields ? { providerFields } : {},
+      ...reasoningText ? { reasoning: { summary: reasoningText } } : {},
       raw: json
     };
   }
@@ -15661,6 +16352,23 @@ var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
     };
   }
 };
+function extractReasoningText(src) {
+  if (!src || typeof src !== "object") return void 0;
+  for (const key of ["reasoning_content", "reasoning"]) {
+    const v = src[key];
+    if (typeof v === "string" && v.length > 0) return v;
+  }
+  return void 0;
+}
+function pickProviderFields(top, message, choice) {
+  const out = {};
+  if (top?.system_fingerprint != null) out.system_fingerprint = top.system_fingerprint;
+  if (top?.service_tier != null) out.service_tier = top.service_tier;
+  if (message?.annotations != null) out.annotations = message.annotations;
+  if (message?.refusal != null) out.refusal = message.refusal;
+  if (choice?.logprobs != null) out.logprobs = choice.logprobs;
+  return Object.keys(out).length > 0 ? out : void 0;
+}
 function isReasoningModel(model) {
   if (!model) return false;
   const m = model.toLowerCase();
@@ -15737,38 +16445,88 @@ 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);
+    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);
+    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)) {
+    for await (const event of parseSSEStream(res.body, request.signal)) {
       let data;
       try {
         data = JSON.parse(event.data);
@@ -15795,8 +16553,11 @@ var AnthropicProvider = class extends BaseProvider {
             currentToolCalls.set(idx, {
               id: block.id ?? "",
               name: block.name ?? "",
-              arguments: ""
+              arguments: "",
+              ordinal: toolOrdinal++
             });
+            const opened = currentToolCalls.get(idx);
+            yield { id, model, delta: { toolCalls: [{ id: opened.id, name: opened.name, arguments: "", index: opened.ordinal }] } };
           } else if (block?.type === "thinking") {
             reasoningBlocks.set(idx, { type: "thinking", text: block.thinking ?? "", signature: block.signature });
           } else if (block?.type === "redacted_thinking") {
@@ -15834,7 +16595,7 @@ var AnthropicProvider = class extends BaseProvider {
                 id,
                 model,
                 delta: {
-                  toolCalls: [{ id: tc.id, name: tc.name, arguments: delta.partial_json }]
+                  toolCalls: [{ id: tc.id, name: tc.name, arguments: delta.partial_json, index: tc.ordinal }]
                 }
               };
             }
@@ -15847,8 +16608,10 @@ var AnthropicProvider = class extends BaseProvider {
           const delta = data.delta;
           if (data.usage) {
             outputTokens = data.usage.output_tokens ?? outputTokens;
+            thinkingTokens = data.usage.output_tokens_details?.thinking_tokens ?? thinkingTokens;
           }
           const finishReason = mapAnthropicStopReason(delta?.stop_reason);
+          const rawFinishReason = typeof delta?.stop_reason === "string" ? delta.stop_reason : void 0;
           const usage = {
             inputTokens,
             outputTokens,
@@ -15856,7 +16619,7 @@ var AnthropicProvider = class extends BaseProvider {
             cachedInputTokens: cacheReadInputTokens,
             cachedWriteTokens: cacheCreationInputTokens,
             cachedOutputTokens: 0,
-            reasoningTokens: 0
+            reasoningTokens: thinkingTokens
           };
           const blocks = [...reasoningBlocks.values()].filter(
             (b) => b.type === "thinking" && b.signature || b.type === "redacted_thinking" && b.data
@@ -15866,6 +16629,7 @@ var AnthropicProvider = class extends BaseProvider {
             model,
             delta: blocks.length > 0 ? { reasoning: { blocks } } : {},
             finishReason,
+            ...rawFinishReason ? { rawFinishReason } : {},
             usage
           };
           break;
@@ -15880,12 +16644,12 @@ var AnthropicProvider = class extends BaseProvider {
     }
   }
   // ─── Internals ───────────────────────────────────────────────────────────
-  buildRequestBody(request, stream) {
+  buildRequestBody(request, stream, modeOverride, downgradeToolChoice = false) {
     const { system, messages } = this.splitSystemMessages(request.messages);
     const body = {
       model: request.model || this.defaultModel,
       messages: this.toAnthropicMessages(messages),
-      max_tokens: request.maxTokens ?? 4096,
+      max_tokens: request.maxTokens ?? DEFAULT_MAX_TOKENS,
       stream
     };
     if (system) {
@@ -15906,18 +16670,27 @@ var AnthropicProvider = class extends BaseProvider {
       body.tools = tools;
     }
     if (request.toolChoice != null) {
+      const forceOk = !downgradeToolChoice && supportsForcedToolChoice(body.model);
       if (request.toolChoice === "auto") {
         body.tool_choice = { type: "auto" };
       } else if (request.toolChoice === "required") {
-        body.tool_choice = { type: "any" };
+        body.tool_choice = forceOk ? { type: "any" } : { type: "auto" };
       } else if (request.toolChoice === "none") ; else {
-        body.tool_choice = { type: "tool", name: request.toolChoice.name };
+        body.tool_choice = forceOk ? { type: "tool", name: request.toolChoice.name } : { type: "auto" };
       }
     }
     if (request.extra) {
       Object.assign(body, request.extra);
     }
-    applyAnthropicReasoning(body, request.reasoning);
+    const explicitThinking = request.extra && typeof request.extra === "object" && "thinking" in request.extra;
+    if (explicitThinking) {
+      normalizeExplicitThinking(body);
+    } else {
+      applyAnthropicReasoning(body, request.reasoning, { model: body.model, mode: modeOverride ?? this.thinkingMode });
+    }
+    if (typeof body.max_tokens !== "number" || !(body.max_tokens > 0)) {
+      body.max_tokens = DEFAULT_MAX_TOKENS;
+    }
     return body;
   }
   splitSystemMessages(messages) {
@@ -16048,7 +16821,35 @@ var AnthropicProvider = class extends BaseProvider {
       input_schema: t.parameters
     };
   }
-  async doFetch(body) {
+  /** 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 = {
       "Content-Type": "application/json",
@@ -16057,7 +16858,7 @@ var AnthropicProvider = class extends BaseProvider {
       ...this.defaultHeaders
     };
     const payload = JSON.stringify(body);
-    const res = await this.doFetchWithRetry(() => fetch(url, { method: "POST", headers, body: payload }));
+    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(
@@ -16102,10 +16903,9 @@ var AnthropicProvider = class extends BaseProvider {
       cachedInputTokens: usage.cache_read_input_tokens ?? 0,
       cachedWriteTokens: usage.cache_creation_input_tokens ?? 0,
       cachedOutputTokens: 0,
-      // Anthropic bills thinking tokens inside `output_tokens` and does not
-      // expose a separate count, so reasoningTokens stays 0 here (cost is still
-      // captured via outputTokens). See docs for the limitation.
-      reasoningTokens: 0
+      // Thinking tokens are billed inside `output_tokens`; newer models also
+      // report the split as `output_tokens_details.thinking_tokens`.
+      reasoningTokens: usage.output_tokens_details?.thinking_tokens ?? 0
     };
     return {
       id: json.id ?? "",
@@ -16114,6 +16914,7 @@ var AnthropicProvider = class extends BaseProvider {
       toolCalls,
       usage: tokenUsage,
       finishReason: mapAnthropicStopReason(json.stop_reason),
+      ...typeof json.stop_reason === "string" ? { rawFinishReason: json.stop_reason } : {},
       reasoning: reasoningBlocks.length > 0 ? { blocks: reasoningBlocks, summary: summaryParts.join("\n").trim() || void 0 } : void 0,
       raw: json
     };
@@ -16159,7 +16960,15 @@ var AzureProvider = class extends OpenAIProvider {
       provider: "openai",
       apiKey: config.apiKey,
       defaultModel: config.defaultModel ?? config.deploymentName ?? "gpt-4o",
-      defaultHeaders: config.defaultHeaders
+      defaultHeaders: config.defaultHeaders,
+      retry: config.retry,
+      fetch: config.fetch,
+      timeoutMs: config.timeoutMs,
+      maxTokensParam: config.maxTokensParam,
+      api: config.api,
+      responsesApi: config.responsesApi,
+      responsesApiModels: config.responsesApiModels,
+      responsesStreaming: config.responsesStreaming
     });
     this.providerName = "azure";
     this.endpoint = config.endpoint.replace(/\/$/, "");
@@ -16167,22 +16976,24 @@ var AzureProvider = class extends OpenAIProvider {
     this.deploymentName = config.deploymentName;
     this.azureApiKey = config.apiKey;
   }
-  async doFetch(body) {
+  async doFetch(body, signal) {
     const deployment = this.deploymentName ?? body.model;
     if (!deployment) {
       throw new ProviderError("Azure requires a deploymentName or model", this.providerName);
     }
     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(
@@ -16194,10 +17005,36 @@ 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. */
-  async responsesFetch(body) {
+  async responsesFetch(body, signal) {
     body.input = expandAzureResponsesInput(body.input);
     const deployment = this.deploymentName ?? body.model;
     if (!deployment) {
@@ -16205,15 +17042,16 @@ 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",
         "api-key": this.azureApiKey,
         ...this.defaultHeaders
       },
-      body: payload
-    });
+      body: payload,
+      signal
+    }), signal);
     if (!res.ok) {
       const text = await res.text().catch(() => "");
       throw new ProviderError(
@@ -16249,20 +17087,155 @@ var OpenAICompatibleProvider = class extends OpenAIProvider {
       apiKey: config.apiKey,
       baseURL: config.baseURL,
       defaultModel: config.defaultModel,
-      defaultHeaders: config.defaultHeaders
+      defaultHeaders: config.defaultHeaders,
+      organization: config.organization,
+      retry: config.retry,
+      fetch: config.fetch,
+      timeoutMs: config.timeoutMs,
+      maxTokensParam: config.maxTokensParam,
+      api: config.api,
+      // Unlike OpenAI / Azure, "auto" on a compatible server means Chat
+      // Completions (the 0.11 default): the model name is the operator's.
+      // `responsesApiModels` still applies; `responsesApi: "auto"` opts in.
+      _autoMeansChat: true,
+      responsesApi: config.responsesApi,
+      responsesApiModels: config.responsesApiModels,
+      responsesStreaming: config.responsesStreaming
     });
     this.providerName = "openai-compatible";
   }
 };
 
+// src/providers/utils/eventStream.ts
+var EventStreamError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "EventStreamError";
+  }
+};
+var CRC_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    table[n] = c >>> 0;
+  }
+  return table;
+})();
+function crc32(bytes, start = 0, end = bytes.length) {
+  let c = 4294967295;
+  for (let i = start; i < end; i++) c = CRC_TABLE[(c ^ bytes[i]) & 255] ^ c >>> 8;
+  return (c ^ 4294967295) >>> 0;
+}
+function decodeFrame(frame) {
+  const view = new DataView(frame.buffer, frame.byteOffset, frame.byteLength);
+  const total = view.getUint32(0);
+  const headersLen = view.getUint32(4);
+  if (total !== frame.byteLength) throw new EventStreamError("event-stream frame length mismatch");
+  if (crc32(frame, 0, 8) !== view.getUint32(8)) throw new EventStreamError("event-stream prelude CRC mismatch");
+  if (crc32(frame, 0, total - 4) !== view.getUint32(total - 4)) throw new EventStreamError("event-stream message CRC mismatch");
+  if (12 + headersLen > total - 4) throw new EventStreamError("event-stream headers overflow frame");
+  const headers = {};
+  const td = new TextDecoder();
+  let o = 12;
+  const headersEnd = 12 + headersLen;
+  while (o < headersEnd) {
+    const nameLen = frame[o++];
+    const name = td.decode(frame.subarray(o, o + nameLen));
+    o += nameLen;
+    const type = frame[o++];
+    switch (type) {
+      case 0:
+        headers[name] = true;
+        break;
+      case 1:
+        headers[name] = false;
+        break;
+      case 2:
+        headers[name] = view.getInt8(o);
+        o += 1;
+        break;
+      case 3:
+        headers[name] = view.getInt16(o);
+        o += 2;
+        break;
+      case 4:
+        headers[name] = view.getInt32(o);
+        o += 4;
+        break;
+      case 5:
+        headers[name] = view.getBigInt64(o);
+        o += 8;
+        break;
+      case 6: {
+        const len = view.getUint16(o);
+        o += 2;
+        headers[name] = frame.slice(o, o + len);
+        o += len;
+        break;
+      }
+      case 7: {
+        const len = view.getUint16(o);
+        o += 2;
+        headers[name] = td.decode(frame.subarray(o, o + len));
+        o += len;
+        break;
+      }
+      case 8:
+        headers[name] = view.getBigInt64(o);
+        o += 8;
+        break;
+      case 9:
+        headers[name] = frame.slice(o, o + 16);
+        o += 16;
+        break;
+      default:
+        throw new EventStreamError(`unknown event-stream header type ${type}`);
+    }
+  }
+  return { headers, payload: frame.slice(headersEnd, total - 4) };
+}
+async function* parseEventStream(body, signal) {
+  const reader = body.getReader();
+  let buf = new Uint8Array(0);
+  try {
+    while (true) {
+      if (signal?.aborted) throw abortReason(signal);
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!value?.length) continue;
+      const merged = new Uint8Array(buf.length + value.length);
+      merged.set(buf, 0);
+      merged.set(value, buf.length);
+      buf = merged;
+      while (buf.length >= 12) {
+        const total = new DataView(buf.buffer, buf.byteOffset, buf.byteLength).getUint32(0);
+        if (total < 16) throw new EventStreamError("invalid event-stream frame length");
+        if (buf.length < total) break;
+        yield decodeFrame(buf.subarray(0, total));
+        buf = buf.subarray(total);
+      }
+    }
+    if (buf.length > 0) throw new EventStreamError("event-stream ended inside a frame");
+  } finally {
+    reader.cancel().catch(() => void 0);
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  }
+}
+
 // src/providers/bedrock.ts
 var BedrockProvider = class extends BaseProvider {
   constructor(config) {
     super();
     this.providerName = "bedrock";
+    this.configureTransport(config);
     this.region = config.region;
     this.defaultModel = config.defaultModel ?? "anthropic.claude-sonnet-4-20250514-v1:0";
     this.defaultHeaders = config.defaultHeaders ?? {};
+    this.thinkingMode = config.thinkingMode ?? "auto";
     this.promptCachingEnabled = config.prompt_caching?.enabled === true;
     if (config.retry) this.retryPolicy = { ...this.retryPolicy, ...config.retry };
     this.credentials = {
@@ -16279,25 +17252,202 @@ var BedrockProvider = class extends BaseProvider {
   }
   async complete(request) {
     const modelId = request.model || this.defaultModel;
-    const body = this.buildConverseBody(request);
-    const json = await this.doFetch(modelId, body);
-    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)
@@ -16321,8 +17471,9 @@ var BedrockProvider = class extends BaseProvider {
       body.toolConfig = {
         tools
       };
+      const forceOk = !downgradeToolChoice && supportsForcedToolChoice(request.model || this.defaultModel);
       if (request.toolChoice != null) {
-        if (request.toolChoice === "auto") {
+        if (request.toolChoice === "auto" || !forceOk && request.toolChoice !== "none") {
           body.toolConfig.toolChoice = { auto: {} };
         } else if (request.toolChoice === "required") {
           body.toolConfig.toolChoice = { any: {} };
@@ -16332,9 +17483,17 @@ var BedrockProvider = class extends BaseProvider {
       }
     }
     if (request.extra) {
-      Object.assign(body, request.extra);
+      const fields = { ...request.extra.additionalModelRequestFields ?? {} };
+      const topLevel = { ...request.extra.__top ?? {} };
+      for (const [key, value] of Object.entries(request.extra)) {
+        if (key === "additionalModelRequestFields" || key === "__top") continue;
+        if (CONVERSE_TOP_LEVEL_FIELDS.has(key)) body[key] = value;
+        else fields[key] = value;
+      }
+      Object.assign(body, topLevel);
+      if (Object.keys(fields).length > 0) body.additionalModelRequestFields = fields;
     }
-    applyBedrockReasoning(body, request.reasoning);
+    applyBedrockReasoning(body, request.reasoning, { model: request.model || this.defaultModel, mode: this.thinkingMode });
     return body;
   }
   splitSystemMessages(messages) {
@@ -16457,9 +17616,22 @@ var BedrockProvider = class extends BaseProvider {
       }
     };
   }
-  async doFetch(modelId, body) {
+  /** 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({
@@ -16467,7 +17639,7 @@ var BedrockProvider = class extends BaseProvider {
         url,
         headers: {
           "Content-Type": "application/json",
-          Accept: "application/json",
+          Accept: stream ? "application/vnd.amazon.eventstream" : "application/json",
           ...this.defaultHeaders
         },
         body: bodyStr,
@@ -16475,8 +17647,8 @@ var BedrockProvider = class extends BaseProvider {
         service: "bedrock",
         credentials: this.credentials
       });
-      return fetch(url, { method: "POST", headers, body: bodyStr });
-    });
+      return this.httpFetch(url, { method: "POST", headers, body: bodyStr, signal });
+    }, signal);
     if (!res.ok) {
       const text = await res.text().catch(() => "");
       throw new ProviderError(
@@ -16486,7 +17658,7 @@ var BedrockProvider = class extends BaseProvider {
         text
       );
     }
-    return res.json();
+    return res;
   }
   parseResponse(json, modelId) {
     const output = json.output?.message;
@@ -16522,8 +17694,8 @@ var BedrockProvider = class extends BaseProvider {
       inputTokens: usage.inputTokens ?? 0,
       outputTokens: usage.outputTokens ?? 0,
       totalTokens: usage.totalTokens ?? (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0),
-      cachedInputTokens: usage.cacheReadInputTokenCount ?? 0,
-      cachedWriteTokens: usage.cacheWriteInputTokenCount ?? 0,
+      cachedInputTokens: usage.cacheReadInputTokens ?? usage.cacheReadInputTokenCount ?? 0,
+      cachedWriteTokens: usage.cacheWriteInputTokens ?? usage.cacheWriteInputTokenCount ?? 0,
       cachedOutputTokens: 0,
       // Bedrock bills thinking tokens inside outputTokens; no separate count.
       reasoningTokens: 0
@@ -16535,11 +17707,26 @@ var BedrockProvider = class extends BaseProvider {
       toolCalls,
       usage: tokenUsage,
       finishReason: mapBedrockStopReason(json.stopReason),
+      ...typeof json.stopReason === "string" ? { rawFinishReason: json.stopReason } : {},
       reasoning: reasoningBlocks.length > 0 ? { blocks: reasoningBlocks, summary: summaryParts.join("\n").trim() || void 0 } : void 0,
       raw: json
     };
   }
 };
+var CONVERSE_TOP_LEVEL_FIELDS = /* @__PURE__ */ new Set([
+  "messages",
+  "system",
+  "inferenceConfig",
+  "toolConfig",
+  "guardrailConfig",
+  "additionalModelRequestFields",
+  "additionalModelResponseFieldPaths",
+  "promptVariables",
+  "requestMetadata",
+  "performanceConfig",
+  "serviceTier",
+  "outputConfig"
+]);
 function appendBedrockReasoning(content, blocks) {
   if (!blocks?.length) return;
   for (const b of blocks) {
@@ -16554,6 +17741,23 @@ function appendBedrockReasoning(content, blocks) {
     }
   }
 }
+function bedrockExceptionStatus(code) {
+  switch (code) {
+    case "throttlingException":
+      return 429;
+    case "validationException":
+      return 400;
+    case "modelTimeoutException":
+      return 408;
+    case "serviceUnavailableException":
+      return 503;
+    case "internalServerException":
+    case "modelStreamErrorException":
+      return 500;
+    default:
+      return void 0;
+  }
+}
 function mapBedrockStopReason(reason) {
   switch (reason) {
     case "end_turn":
@@ -16562,8 +17766,10 @@ function mapBedrockStopReason(reason) {
     case "tool_use":
       return "tool_calls";
     case "max_tokens":
+    case "model_context_window_exceeded":
       return "length";
     case "content_filtered":
+    case "guardrail_intervened":
     case "guardrail":
       return "content_filter";
     default:
@@ -16593,10 +17799,12 @@ var VertexProvider = class extends BaseProvider {
     super();
     this.providerName = "vertex";
     this.tokenExpiry = 0;
+    this.configureTransport(config);
     this.projectId = config.projectId;
     this.location = config.location ?? "us-central1";
     this.defaultModel = config.defaultModel ?? "gemini-2.0-flash";
     this.defaultHeaders = config.defaultHeaders ?? {};
+    if (config.retry) this.retryPolicy = { ...this.retryPolicy, ...config.retry };
     if (config.accessToken) {
       this.accessToken = config.accessToken;
       this.tokenExpiry = Date.now() + 36e5;
@@ -16609,7 +17817,7 @@ var VertexProvider = class extends BaseProvider {
     const modelId = request.model || this.defaultModel;
     const body = this.buildGeminiBody(request);
     const url = this.buildUrl(modelId, false);
-    const res = await this.doFetch(url, body);
+    const res = await this.doFetch(url, body, request.signal);
     const json = await res.json();
     return this.parseResponse(json, modelId);
   }
@@ -16617,11 +17825,12 @@ var VertexProvider = class extends BaseProvider {
     const modelId = request.model || this.defaultModel;
     const body = this.buildGeminiBody(request);
     const url = this.buildUrl(modelId, true);
-    const res = await this.doFetch(url, body);
+    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)) {
+      for await (const event of parseSSEStream(res.body, request.signal)) {
         if (event.data === "[DONE]") break;
         let chunk;
         try {
@@ -16629,7 +17838,7 @@ var VertexProvider = class extends BaseProvider {
         } catch {
           continue;
         }
-        yield this.parseStreamChunk(chunk, modelId);
+        yield this.parseStreamChunk(chunk, modelId, counter);
       }
     } else {
       const reader = res.body.getReader();
@@ -16647,7 +17856,7 @@ var VertexProvider = class extends BaseProvider {
             if (!trimmed || trimmed === "[" || trimmed === "]") continue;
             try {
               const chunk = JSON.parse(trimmed);
-              yield this.parseStreamChunk(chunk, modelId);
+              yield this.parseStreamChunk(chunk, modelId, counter);
             } catch {
               buffer = line + "\n" + buffer;
               break;
@@ -16658,16 +17867,59 @@ 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 {
           }
         }
       } finally {
+        reader.cancel().catch(() => void 0);
         reader.releaseLock();
       }
     }
   }
   // ─── 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}`;
@@ -16765,7 +18017,9 @@ var VertexProvider = class extends BaseProvider {
           functionCall: {
             name: tc.name,
             args: safeJsonParse3(tc.arguments)
-          }
+          },
+          // Gemini 3 requires the signature of each functionCall echoed back.
+          ...tc.thoughtSignature ? { thoughtSignature: tc.thoughtSignature } : {}
         });
       }
       return { role: "model", parts: parts2 };
@@ -16862,7 +18116,7 @@ var VertexProvider = class extends BaseProvider {
     sign.update(signingInput);
     const signature = sign.sign(sa.private_key, "base64url");
     const jwt = `${signingInput}.${signature}`;
-    const tokenRes = await fetch("https://oauth2.googleapis.com/token", {
+    const tokenRes = await this.httpFetch("https://oauth2.googleapis.com/token", {
       method: "POST",
       headers: { "Content-Type": "application/x-www-form-urlencoded" },
       body: `grant_type=urn:ietf:params:oauth:grant-type:jwt-bearer&assertion=${jwt}`
@@ -16874,17 +18128,22 @@ var VertexProvider = class extends BaseProvider {
     const tokenJson = await tokenRes.json();
     return tokenJson.access_token;
   }
-  async doFetch(url, body) {
+  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(
@@ -16914,7 +18173,8 @@ var VertexProvider = class extends BaseProvider {
         toolCalls.push({
           id: `call_${toolCallIdx++}`,
           name: part.functionCall.name,
-          arguments: JSON.stringify(part.functionCall.args ?? {})
+          arguments: JSON.stringify(part.functionCall.args ?? {}),
+          ...part.thoughtSignature ? { thoughtSignature: part.thoughtSignature } : {}
         });
       }
     }
@@ -16935,11 +18195,12 @@ var VertexProvider = class extends BaseProvider {
       toolCalls,
       usage: tokenUsage,
       finishReason: mapGeminiFinishReason(candidate?.finishReason),
+      ...typeof candidate?.finishReason === "string" ? { rawFinishReason: candidate.finishReason } : {},
       reasoning: thoughtParts.length > 0 ? { summary: thoughtParts.join("\n").trim() || void 0 } : void 0,
       raw: json
     };
   }
-  parseStreamChunk(chunk, modelId) {
+  parseStreamChunk(chunk, modelId, counter) {
     const candidate = chunk.candidates?.[0];
     const parts = candidate?.content?.parts ?? [];
     const delta = {};
@@ -16953,9 +18214,12 @@ var VertexProvider = class extends BaseProvider {
       } else if (part.functionCall) {
         if (!delta.toolCalls) delta.toolCalls = [];
         delta.toolCalls.push({
-          id: `call_${delta.toolCalls.length}`,
+          // Unique across the whole stream: the adapter merges chunks by id.
+          id: `call_${counter.next}`,
+          index: counter.next++,
           name: part.functionCall.name,
-          arguments: JSON.stringify(part.functionCall.args ?? {})
+          arguments: JSON.stringify(part.functionCall.args ?? {}),
+          ...part.thoughtSignature ? { thoughtSignature: part.thoughtSignature } : {}
         });
       }
     }
@@ -16977,10 +18241,21 @@ var VertexProvider = class extends BaseProvider {
       model: modelId,
       delta,
       usage,
-      finishReason: mapGeminiFinishReason(candidate?.finishReason)
+      finishReason: mapGeminiFinishReason(candidate?.finishReason),
+      ...typeof candidate?.finishReason === "string" ? { rawFinishReason: candidate.finishReason } : {}
     };
   }
 };
+var GEMINI_TASK_TYPES = {
+  search_document: "RETRIEVAL_DOCUMENT",
+  search_query: "RETRIEVAL_QUERY",
+  classification: "CLASSIFICATION",
+  clustering: "CLUSTERING",
+  semantic_similarity: "SEMANTIC_SIMILARITY",
+  question_answering: "QUESTION_ANSWERING",
+  fact_verification: "FACT_VERIFICATION",
+  code_retrieval_query: "CODE_RETRIEVAL_QUERY"
+};
 function mapGeminiFinishReason(reason) {
   switch (reason) {
     case "STOP":
@@ -17022,6 +18297,8 @@ function createProvider(config) {
       return new BedrockProvider(config);
     case "vertex":
       return new VertexProvider(config);
+    case "jev":
+      return new JevProvider(config);
     default:
       throw new Error(`Unknown provider: ${config.provider}`);
   }
@@ -17049,6 +18326,7 @@ exports.HOOK_CONTRACT_VERSION = HOOK_CONTRACT_VERSION;
 exports.HOOK_NAMES = HOOK_NAMES;
 exports.HookTimeoutError = HookTimeoutError;
 exports.InMemoryMemoryStore = InMemoryMemoryStore;
+exports.JevProvider = JevProvider;
 exports.NativeJsonSchemaStrategy = NativeJsonSchemaStrategy;
 exports.OpenAICompatibleProvider = OpenAICompatibleProvider;
 exports.OpenAIProvider = OpenAIProvider;
@@ -17088,6 +18366,7 @@ exports.compressLogOutput = compressLogOutput;
 exports.compressSearchOutput = compressSearchOutput;
 exports.compressTextOutput = compressTextOutput;
 exports.compressToolOutput = compressToolOutput;
+exports.contentPartToText = contentPartToText;
 exports.contentToString = contentToString;
 exports.conversationHistory = conversationHistory;
 exports.countApproxTokens = countApproxTokens;
@@ -17130,6 +18409,7 @@ exports.dedupeToolsByName = dedupeToolsByName;
 exports.defaultTokenCounter = defaultTokenCounter;
 exports.defineHook = defineHook;
 exports.definePlugin = definePlugin;
+exports.describeContentPart = describeContentPart;
 exports.detectLanguage = detectLanguage;
 exports.detectTextFormat = detectTextFormat;
 exports.detectVolatileContent = detectVolatileContent;
@@ -17138,7 +18418,7 @@ exports.digestToolInputValue = digestToolInputValue;
 exports.emptyUsage = emptyUsage;
 exports.evaluateGuardrails = evaluateGuardrails;
 exports.extractLatestUserQuery = extractLatestUserQuery;
-exports.extractMessageText = extractMessageText2;
+exports.extractMessageText = extractMessageText;
 exports.fileCheckpointStore = fileCheckpointStore;
 exports.fileSink = fileSink;
 exports.findSubagent = findSubagent;
@@ -17152,6 +18432,7 @@ exports.getModelCapabilities = getModelCapabilities;
 exports.getNestedValue = getNestedValue;
 exports.getResolvedSmartConfig = getResolvedSmartConfig;
 exports.getTokenCounter = getTokenCounter;
+exports.hasMediaPart = hasMediaPart;
 exports.hasToolResponseRecoveryReference = hasToolResponseRecoveryReference;
 exports.httpGuardrail = httpGuardrail;
 exports.httpSink = httpSink;
@@ -17171,6 +18452,7 @@ exports.loadSkillsFromDisk = loadSkillsFromDisk;
 exports.mapConsoleHookVerdict = mapConsoleHookVerdict;
 exports.mapTextParts = mapTextParts;
 exports.mcp = mcp;
+exports.mediaKindOf = mediaKindOf;
 exports.mediaPolicy = mediaPolicy;
 exports.normalizeSmartAgentOptions = normalizeSmartAgentOptions;
 exports.normalizeVerdicts = normalizeVerdicts;
@@ -17217,7 +18499,9 @@ exports.sessionMetrics = sessionMetrics;
 exports.setTokenCounter = setTokenCounter;
 exports.startStreamingSession = startStreamingSession;
 exports.summarizeObject = summarizeObject;
+exports.supportsAdaptiveThinking = supportsAdaptiveThinking;
 exports.textFromContent = textFromContent;
+exports.toMessageUsage = toMessageUsage;
 exports.toStrictCompatible = toStrictCompatible;
 exports.toStrictToolSchema = toStrictToolSchema;
 exports.tokenize = tokenize;