@cognipeer/agent-sdk 0.10.4 → 0.10.6

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
     });
   }
@@ -2067,50 +2448,63 @@ 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 {
+        const request = buildRequest(messages, boundTools, options, _invokeOptions);
+        if (link.signal) request.signal = link.signal;
+        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 {
+        const request = buildRequest(messages, boundTools, options, _invokeOptions);
+        request.stream = true;
+        if (link.signal) request.signal = link.signal;
+        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 ?? ""
+                  });
+                }
               }
             }
           }
+          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) {
+          finalMessage.reasoning = { blocks: reasoningBlocks };
+        }
+        yield finalMessage;
+      } finally {
+        link.dispose();
       }
-      yield finalMessage;
     },
     bindTools: (tools, _bindOptions) => {
       const strict = _bindOptions?.strict ?? false;
@@ -2573,136 +2967,7 @@ function resolveCapabilities(provider) {
 
 // src/smart/toolResponses.ts
 init_utilTokens();
-
-// 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;
-}
+init_content();
 
 // src/smart/toolArgCoercion.ts
 var PLACEHOLDER_TEXT = /* @__PURE__ */ new Set(["", "null", "undefined", "none", "nil", "n/a", "na"]);
@@ -3591,6 +3856,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 +4069,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 +4443,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 || {};
@@ -4331,9 +4600,32 @@ ${append}`;
       }
       return merged;
     };
-    let response;
-    let modelAttempt = 0;
-    const maxModelRetries = host?.maxModelRetries ?? 0;
+    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,14 +4641,16 @@ ${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) {
@@ -4370,6 +4664,7 @@ ${append}`;
                 onEvent?.({ type: "stream", text });
               }
             }
+            if (cutByCancel) return finishCancelledTurn(streamedText);
             if (streamedMessage) {
               response = { ...streamedMessage };
               if (response.content == null || response.content === "") {
@@ -4382,6 +4677,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 +4775,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 +6666,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 +6901,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 +7438,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 +7908,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 +7979,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 +8035,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 +8297,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 +8556,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 +8622,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 +8962,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 +9807,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 +10824,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 +11535,132 @@ async function runSmartAgentEvalHarness(params) {
   }
   return results;
 }
+
+// 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.
+   *
+   * `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/types.ts
+function emptyUsage() {
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0,
+    cachedInputTokens: 0,
+    cachedWriteTokens: 0,
+    cachedOutputTokens: 0,
+    reasoningTokens: 0
+  };
+}
+var ProviderError = class extends Error {
+  constructor(message, provider, statusCode, responseBody) {
+    super(message);
+    this.provider = provider;
+    this.statusCode = statusCode;
+    this.responseBody = responseBody;
+    this.name = "ProviderError";
+  }
+};
+
+// src/providers/jev.ts
+var JEV_DEFAULT_BASE_URL = "https://api.typesafe.ai";
+var JevProvider = class extends BaseProvider {
+  constructor(config) {
+    super();
+    this.providerName = "jev";
+    this.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(
+      () => fetch(`${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 +11810,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 +12101,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 +12388,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 +12658,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 +12778,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;
@@ -14681,74 +15185,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/index.ts
+init_content();
 
 // src/providers/utils/sse.ts
 async function* parseSSEStream(body, signal) {
@@ -14757,7 +15195,7 @@ async function* parseSSEStream(body, signal) {
   let buffer = "";
   try {
     while (true) {
-      if (signal?.aborted) ;
+      if (signal?.aborted) throw abortReason(signal);
       const { done, value } = await reader.read();
       if (done) break;
       buffer += decoder.decode(value, { stream: true });
@@ -14774,6 +15212,7 @@ async function* parseSSEStream(body, signal) {
       if (event) yield event;
     }
   } finally {
+    reader.cancel().catch(() => void 0);
     reader.releaseLock();
   }
 }
@@ -14991,8 +15430,127 @@ function sanitizeBedrockDocName(name, fallback = "document") {
   return cleaned || fallback;
 }
 
+// src/providers/utils/jsonSchemaRefs.ts
+var DEFINITION_KEYS = ["definitions", "$defs"];
+function inlineJsonSchemaRefs(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 isObject2(target) ? target : void 0;
+  };
+  const reachesItself = (target) => {
+    const known = selfReaching.get(target);
+    if (known !== void 0) return known;
+    const seen = /* @__PURE__ */ new Set();
+    const walk = (node) => {
+      if (Array.isArray(node)) return node.some(walk);
+      if (!isObject2(node)) return false;
+      if (typeof node.$ref === "string") {
+        const next = targetOf(node.$ref);
+        if (next === target) return true;
+        if (next && !seen.has(next)) {
+          seen.add(next);
+          if (walk(next)) return true;
+        }
+      }
+      return Object.entries(node).some(([key, value]) => key !== "$ref" && walk(value));
+    };
+    const result2 = walk(target);
+    selfReaching.set(target, result2);
+    return result2;
+  };
+  const keptRefs = /* @__PURE__ */ new Set();
+  const expand = (node) => {
+    if (Array.isArray(node)) return node.map(expand);
+    if (!isObject2(node)) return node;
+    if (typeof node.$ref === "string") {
+      const target = targetOf(node.$ref);
+      if (target && !reachesItself(target)) {
+        const { $ref: _inlined, ...siblings } = node;
+        return { ...expand(target), ...expandEntries(siblings) };
+      }
+      keptRefs.add(node.$ref);
+      return expandEntries(node);
+    }
+    return expandEntries(node);
+  };
+  const expandEntries = (node) => {
+    const out = {};
+    for (const [key, value] of Object.entries(node)) out[key] = key === "$ref" ? value : expand(value);
+    return out;
+  };
+  const { definitions: _definitions, $defs: _defs, ...rootBody } = root;
+  const result = typeof root.$ref === "string" ? expand(rootBody) : expandEntries(rootBody);
+  for (const key of DEFINITION_KEYS) delete result[key];
+  for (const key of DEFINITION_KEYS) {
+    const block = root[key];
+    if (!isObject2(block)) continue;
+    const needed = neededEntries(key, block, keptRefs);
+    if (needed.length === 0) continue;
+    const kept = {};
+    for (const name of Object.keys(block)) if (needed.includes(name)) kept[name] = block[name];
+    result[key] = kept;
+  }
+  return result;
+}
+function neededEntries(key, block, keptRefs) {
+  const needed = [];
+  const queue = [...keptRefs];
+  while (queue.length > 0) {
+    const ref = queue.shift();
+    const segments = pointerSegments(ref);
+    if (!segments || segments[0] !== key || segments.length < 2) continue;
+    const name = segments[1];
+    if (needed.includes(name) || !(name in block)) continue;
+    needed.push(name);
+    collectRefs(block[name], queue);
+  }
+  return needed;
+}
+function collectRefs(node, into) {
+  if (Array.isArray(node)) {
+    node.forEach((child) => collectRefs(child, into));
+    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 (!isObject2(node)) return false;
+  if (typeof node.$ref === "string") return true;
+  return Object.values(node).some(containsRef);
+}
+function pointerSegments(ref) {
+  if (ref === "#") return [];
+  if (!ref.startsWith("#/")) return null;
+  return ref.slice(2).split("/").map((segment) => segment.replace(/~1/g, "/").replace(/~0/g, "~"));
+}
+function resolvePointer(document, ref) {
+  const segments = pointerSegments(ref);
+  if (!segments) return void 0;
+  let current = document;
+  for (const segment of segments) {
+    if (Array.isArray(current)) {
+      if (!/^\d+$/.test(segment)) return void 0;
+      current = current[Number(segment)];
+    } else if (isObject2(current) && Object.prototype.hasOwnProperty.call(current, segment)) {
+      current = current[segment];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function isObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // src/providers/openai.ts
-var OpenAIProvider = class extends BaseProvider {
+var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
   constructor(config) {
     super();
     this.providerName = "openai";
@@ -15004,8 +15562,21 @@ var OpenAIProvider = class extends BaseProvider {
       ...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;
     if (config.retry) this.retryPolicy = { ...this.retryPolicy, ...config.retry };
   }
+  /** True when the caller listed this request's model in `responsesApiModels`. */
+  isResponsesApiModel(request) {
+    if (this.responsesApiModels.length === 0) return false;
+    const model = request.model || this.defaultModel;
+    return this.responsesApiModels.some((entry) => {
+      if (typeof entry === "string") return entry === model;
+      entry.lastIndex = 0;
+      return entry.test(model);
+    });
+  }
   /** True when this request should go to the Responses API rather than Chat
    * Completions — which exposes `reasoning.effort` and reasoning summaries that
    * Chat Completions silently drops.
@@ -15014,10 +15585,14 @@ var OpenAIProvider = class extends BaseProvider {
    * carries a reasoning config AND the model name looks like an o-series/gpt-5
    * model. `never`/`always` let a caller state the answer instead, because the
    * name check is a guess and the two APIs differ in far more than reasoning —
-   * see `responsesApi` in OpenAIProviderConfig. */
+   * see `responsesApi` in OpenAIProviderConfig.
+   *
+   * 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.isResponsesApiModel(request)) return true;
     if (!request.reasoning) return false;
     return isReasoningModel(request.model || this.defaultModel);
   }
@@ -15026,12 +15601,16 @@ var OpenAIProvider = class 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)) {
+        yield* this.streamResponses(request);
+        return;
+      }
       const response = await this.completeResponses(request);
       yield {
         id: response.id,
@@ -15047,13 +15626,13 @@ var OpenAIProvider = class 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 {
@@ -15147,10 +15726,101 @@ var OpenAIProvider = class extends BaseProvider {
   // ─── Responses API (reasoning models) ──────────────────────────────────────
   async completeResponses(request) {
     const body = this.buildResponsesBody(request);
-    const res = await this.responsesFetch(body);
+    if (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);
   }
+  /** Real Responses SSE streaming, for models opted in through
+   * `responsesApiModels` with `responsesStreaming` on. Emits the same chunk
+   * shapes as the Chat Completions stream: text deltas as they arrive, a tool
+   * call's id + name when it opens and its argument fragments under that id,
+   * then one final chunk with usage, finish reason and any reasoning summary
+   * (taken from the completed response, exactly as the non-streaming parse
+   * reads it). */
+  async *streamResponses(request) {
+    const modelId = request.model || this.defaultModel;
+    const body = this.buildResponsesBody(request);
+    adaptChatExtrasForResponses(body, request.extra);
+    body.stream = true;
+    const res = await this.responsesFetch(body, request.signal);
+    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, request.signal)) {
+      if (event.data === "[DONE]") break;
+      let data;
+      try {
+        data = JSON.parse(event.data);
+      } catch {
+        continue;
+      }
+      switch (data.type ?? event.event) {
+        case "response.created":
+        case "response.in_progress":
+          id = data.response?.id ?? id;
+          model = data.response?.model ?? model;
+          break;
+        case "response.output_text.delta":
+          if (data.delta) yield { id, model, delta: { content: 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 ?? "" };
+          calls.set(item.id ?? call.callId, call);
+          yield { id, model, delta: { toolCalls: [{ id: call.callId, name: call.name, arguments: call.arguments }] } };
+          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 }] } };
+          break;
+        }
+        case "response.output_item.done": {
+          const item = data.item;
+          if (item?.type !== "function_call") break;
+          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 };
+            calls.set(item.id ?? added.callId, added);
+            yield { id, model, delta: { toolCalls: [{ id: added.callId, name: added.name, arguments: full }] } };
+          } 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 }] } };
+          }
+          break;
+        }
+        case "response.completed":
+        case "response.incomplete":
+          final = this.parseResponsesResponse(data.response ?? {}, modelId);
+          break;
+        case "response.failed":
+        case "error": {
+          const err = data.response?.error ?? data.error ?? data;
+          throw new ProviderError(
+            `OpenAI Responses API stream error: ${err?.message ?? "unknown error"}`,
+            this.providerName,
+            void 0,
+            data
+          );
+        }
+      }
+    }
+    yield {
+      id: final?.id || id,
+      model: final?.model || model,
+      delta: final?.reasoning ? { reasoning: final.reasoning } : {},
+      usage: final?.usage,
+      finishReason: final?.finishReason ?? (calls.size > 0 ? "tool_calls" : "stop")
+    };
+  }
   buildResponsesBody(request) {
     const body = {
       model: request.model || this.defaultModel,
@@ -15180,7 +15850,7 @@ var OpenAIProvider = class extends BaseProvider {
           format: {
             type: "json_schema",
             name: request.responseFormat.name ?? "response",
-            schema: request.responseFormat.schema,
+            schema: inlineJsonSchemaRefs(request.responseFormat.schema),
             strict: true
           }
         };
@@ -15247,7 +15917,7 @@ var OpenAIProvider = class extends BaseProvider {
     });
     return { role, content };
   }
-  async responsesFetch(body) {
+  async responsesFetch(body, signal) {
     body.input = expandResponsesInput(body.input);
     const url = `${this.baseURL}/responses`;
     const headers = {
@@ -15256,7 +15926,7 @@ var OpenAIProvider = 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(() => fetch(url, { method: "POST", headers, body: payload, signal }), signal);
     if (!res.ok) {
       const text = await res.text().catch(() => "");
       throw new ProviderError(
@@ -15377,7 +16047,7 @@ var OpenAIProvider = class 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",
@@ -15385,7 +16055,7 @@ var OpenAIProvider = 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(() => fetch(url, { method: "POST", headers, body: payload, signal }), signal);
     if (!res.ok) {
       const text = await res.text().catch(() => "");
       throw new ProviderError(
@@ -15435,6 +16105,48 @@ function isReasoningModel(model) {
   const m = model.toLowerCase();
   return /(^|[/_-])o[0-9]/.test(m) || m.startsWith("o1") || m.startsWith("o3") || m.startsWith("o4") || m.includes("gpt-5") || m.includes("gpt5");
 }
+function adaptChatExtrasForResponses(body, extra) {
+  const native = extra ?? {};
+  if ("reasoning_effort" in body) {
+    const effort = body.reasoning_effort;
+    delete body.reasoning_effort;
+    if (effort != null) {
+      const reasoning = body.reasoning && typeof body.reasoning === "object" ? body.reasoning : {};
+      if (reasoning.effort == null) body.reasoning = { ...reasoning, effort };
+    }
+  }
+  for (const key of ["max_tokens", "max_completion_tokens"]) {
+    if (!(key in body)) continue;
+    const value = body[key];
+    delete body[key];
+    if (value != null && !("max_output_tokens" in native)) body.max_output_tokens = value;
+  }
+  if ("response_format" in body) {
+    const format = toResponsesTextFormat(body.response_format);
+    delete body.response_format;
+    if (format && !("text" in native)) body.text = { ...body.text, format };
+  }
+  if (body.stream_options && typeof body.stream_options === "object" && "include_usage" in body.stream_options) {
+    const { include_usage: _dropped, ...rest } = body.stream_options;
+    if (Object.keys(rest).length > 0) body.stream_options = rest;
+    else delete body.stream_options;
+  }
+}
+function toResponsesTextFormat(rf) {
+  if (!rf || typeof rf !== "object") return void 0;
+  if (rf.type === "json_schema") {
+    const js = rf.json_schema ?? {};
+    return {
+      type: "json_schema",
+      name: js.name ?? "response",
+      schema: inlineJsonSchemaRefs(js.schema),
+      ...js.description != null ? { description: js.description } : {},
+      ...js.strict != null ? { strict: js.strict } : {}
+    };
+  }
+  if (rf.type === "json_object" || rf.type === "text") return { type: rf.type };
+  return void 0;
+}
 function expandResponsesInput(input) {
   const out = [];
   for (const item of input) {
@@ -15479,13 +16191,13 @@ var AnthropicProvider = class extends BaseProvider {
   }
   async complete(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) {
     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 = "";
@@ -15495,7 +16207,7 @@ var AnthropicProvider = class extends BaseProvider {
     let cacheCreationInputTokens = 0;
     const currentToolCalls = /* @__PURE__ */ new Map();
     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);
@@ -15775,7 +16487,7 @@ var AnthropicProvider = class extends BaseProvider {
       input_schema: t.parameters
     };
   }
-  async doFetch(body) {
+  async doFetch(body, signal) {
     const url = `${this.baseURL}/v1/messages`;
     const headers = {
       "Content-Type": "application/json",
@@ -15784,7 +16496,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(() => fetch(url, { method: "POST", headers, body: payload, signal }), signal);
     if (!res.ok) {
       const text = await res.text().catch(() => "");
       throw new ProviderError(
@@ -15894,7 +16606,7 @@ 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);
@@ -15908,7 +16620,8 @@ var AzureProvider = class extends OpenAIProvider {
         "api-key": this.azureApiKey,
         ...this.defaultHeaders
       },
-      body: JSON.stringify(bodyWithoutModel)
+      body: JSON.stringify(bodyWithoutModel),
+      signal
     });
     if (!res.ok) {
       const text = await res.text().catch(() => "");
@@ -15924,7 +16637,7 @@ var AzureProvider = class extends OpenAIProvider {
   /** 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) {
@@ -15939,7 +16652,8 @@ var AzureProvider = class extends OpenAIProvider {
         "api-key": this.azureApiKey,
         ...this.defaultHeaders
       },
-      body: payload
+      body: payload,
+      signal
     });
     if (!res.ok) {
       const text = await res.text().catch(() => "");
@@ -16007,7 +16721,7 @@ 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);
+    const json = await this.doFetch(modelId, body, request.signal);
     return this.parseResponse(json, modelId);
   }
   async *completeStream(request) {
@@ -16184,7 +16898,7 @@ var BedrockProvider = class extends BaseProvider {
       }
     };
   }
-  async doFetch(modelId, body) {
+  async doFetch(modelId, body, signal) {
     const host = `bedrock-runtime.${this.region}.amazonaws.com`;
     const url = `https://${host}/model/${encodeURIComponent(modelId)}/converse`;
     const bodyStr = JSON.stringify(body);
@@ -16202,8 +16916,8 @@ var BedrockProvider = class extends BaseProvider {
         service: "bedrock",
         credentials: this.credentials
       });
-      return fetch(url, { method: "POST", headers, body: bodyStr });
-    });
+      return fetch(url, { method: "POST", headers, body: bodyStr, signal });
+    }, signal);
     if (!res.ok) {
       const text = await res.text().catch(() => "");
       throw new ProviderError(
@@ -16336,7 +17050,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);
   }
@@ -16344,11 +17058,11 @@ 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 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 {
@@ -16390,6 +17104,7 @@ var VertexProvider = class extends BaseProvider {
           }
         }
       } finally {
+        reader.cancel().catch(() => void 0);
         reader.releaseLock();
       }
     }
@@ -16601,7 +17316,7 @@ 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",
@@ -16610,7 +17325,8 @@ var VertexProvider = class extends BaseProvider {
         Authorization: `Bearer ${token}`,
         ...this.defaultHeaders
       },
-      body: JSON.stringify(body)
+      body: JSON.stringify(body),
+      signal
     });
     if (!res.ok) {
       const text = await res.text().catch(() => "");
@@ -16749,6 +17465,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}`);
   }
@@ -16776,6 +17494,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;
@@ -16815,6 +17534,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;
@@ -16857,6 +17577,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;
@@ -16865,7 +17586,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;
@@ -16879,6 +17600,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;
@@ -16898,6 +17620,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;