@agentskit/adapters 0.13.13 → 0.14.0

package/dist/index.cjs

@@ -2,26 +2,175 @@
 
 var core = require('@agentskit/core');
 
+// src/stream-errors.ts
+function isAbortError(err) {
+  if (err instanceof DOMException && err.name === "AbortError") return true;
+  if (err instanceof Error && err.name === "AbortError") return true;
+  return false;
+}
+function adapterErrorChunk(message, options) {
+  const error = new core.AdapterError({
+    code: options?.code ?? core.ErrorCodes.AK_ADAPTER_STREAM_FAILED,
+    message,
+    cause: options?.cause
+  });
+  return {
+    type: "error",
+    content: message,
+    metadata: { error }
+  };
+}
+function parseCompleteToolArgs(args) {
+  const raw = args.length > 0 ? args : "{}";
+  try {
+    JSON.parse(raw);
+    return { ok: true, args: raw };
+  } catch (cause) {
+    return {
+      ok: false,
+      error: new core.AdapterError({
+        code: core.ErrorCodes.AK_ADAPTER_STREAM_FAILED,
+        message: "Incomplete or malformed tool-call arguments JSON",
+        cause
+      })
+    };
+  }
+}
+function raceAbort(promise, signal) {
+  if (signal.aborted) {
+    return Promise.reject(new DOMException("Aborted", "AbortError"));
+  }
+  return new Promise((resolve2, reject) => {
+    let settled = false;
+    const onAbort = () => {
+      if (settled) return;
+      settled = true;
+      signal.removeEventListener("abort", onAbort);
+      reject(new DOMException("Aborted", "AbortError"));
+    };
+    signal.addEventListener("abort", onAbort);
+    promise.then(
+      (value) => {
+        if (settled) return;
+        settled = true;
+        signal.removeEventListener("abort", onAbort);
+        resolve2(value);
+      },
+      (err) => {
+        if (settled) return;
+        settled = true;
+        signal.removeEventListener("abort", onAbort);
+        reject(err);
+      }
+    );
+  });
+}
+async function abortableSleep(ms, signal, sleep) {
+  if (signal.aborted) throw new DOMException("Aborted", "AbortError");
+  await raceAbort(sleep(ms), signal);
+  if (signal.aborted) throw new DOMException("Aborted", "AbortError");
+}
+async function cancelBody(body) {
+  if (!body) return;
+  try {
+    await body.cancel();
+  } catch {
+  }
+}
+
 // src/createAdapter.ts
 function createAdapter(config) {
   return {
-    createSource: (request) => ({
-      stream: async function* () {
+    createSource: (request) => {
+      const controller = new AbortController();
+      let activeStream = null;
+      let parseIter = null;
+      const cleanup = () => {
         try {
-          const result = await config.send(request);
-          const stream = result instanceof Response ? result.body : result;
-          yield* config.parse(stream);
-        } catch (err) {
-          yield {
-            type: "error",
-            content: err instanceof Error ? err.message : String(err)
-          };
+          void activeStream?.cancel();
+        } catch {
         }
-      },
-      abort: () => {
-        config.abort?.();
-      }
-    })
+        activeStream = null;
+        if (parseIter && typeof parseIter.return === "function") {
+          void parseIter.return(void 0).catch(() => {
+          });
+        }
+        parseIter = null;
+        try {
+          config.abort?.();
+        } catch {
+        }
+      };
+      return {
+        stream: async function* () {
+          if (controller.signal.aborted) return;
+          try {
+            const result = await raceAbort(config.send(request, controller.signal), controller.signal);
+            if (controller.signal.aborted) {
+              if (result instanceof Response) {
+                try {
+                  await result.body?.cancel();
+                } catch {
+                }
+              }
+              return;
+            }
+            const stream = result instanceof Response ? result.body : result;
+            if (!stream) {
+              yield adapterErrorChunk("Adapter send() returned empty body");
+              return;
+            }
+            activeStream = stream;
+            const response = result instanceof Response ? result : void 0;
+            const iterable = config.parse(stream, response);
+            parseIter = iterable[Symbol.asyncIterator]();
+            while (true) {
+              if (controller.signal.aborted) {
+                cleanup();
+                return;
+              }
+              let next;
+              try {
+                next = await raceAbort(parseIter.next(), controller.signal);
+              } catch (err) {
+                if (isAbortError(err) || controller.signal.aborted) {
+                  cleanup();
+                  return;
+                }
+                throw err;
+              }
+              if (next.done) break;
+              if (controller.signal.aborted) {
+                cleanup();
+                return;
+              }
+              yield next.value;
+              if (next.value.type === "done" || next.value.type === "error") {
+                if (typeof parseIter.return === "function") {
+                  await parseIter.return(void 0).catch(() => {
+                  });
+                }
+                parseIter = null;
+                activeStream = null;
+                return;
+              }
+            }
+            yield adapterErrorChunk("Adapter parser ended without a terminal chunk");
+            activeStream = null;
+          } catch (err) {
+            if (isAbortError(err) || controller.signal.aborted) return;
+            const message = err instanceof Error ? err.message : String(err);
+            yield adapterErrorChunk(message, { cause: err });
+          } finally {
+            if (controller.signal.aborted) cleanup();
+          }
+        },
+        abort: () => {
+          if (!controller.signal.aborted) controller.abort();
+          cleanup();
+        }
+      };
+    }
   };
 }
 
@@ -29,73 +178,67 @@ function createAdapter(config) {
 function generic(config) {
   return {
     createSource: (request) => {
+      const controller = new AbortController();
       let reader = null;
       const decoder = new TextDecoder();
       return {
         stream: async function* () {
+          if (controller.signal.aborted) return;
           try {
-            const stream = await config.send(request);
+            const stream = await raceAbort(
+              config.send(request, controller.signal),
+              controller.signal
+            );
+            if (controller.signal.aborted) {
+              try {
+                await stream.cancel();
+              } catch {
+              }
+              return;
+            }
             reader = stream.getReader();
             while (true) {
-              const { done, value } = await reader.read();
+              if (controller.signal.aborted) {
+                try {
+                  await reader.cancel();
+                } catch {
+                }
+                return;
+              }
+              const { done, value } = await raceAbort(reader.read(), controller.signal);
               if (done) break;
               const text = decoder.decode(value, { stream: true });
               yield { type: "text", content: text };
             }
+            if (controller.signal.aborted) return;
             yield { type: "done" };
           } catch (err) {
+            if (isAbortError(err) || controller.signal.aborted) return;
             yield {
               type: "error",
-              content: err instanceof Error ? err.message : String(err)
+              content: err instanceof Error ? err.message : String(err),
+              metadata: {
+                error: err instanceof Error ? err : new Error(String(err))
+              }
             };
           } finally {
-            reader?.releaseLock();
+            try {
+              reader?.releaseLock();
+            } catch {
+            }
           }
         },
         abort: () => {
-          void reader?.cancel();
+          if (!controller.signal.aborted) controller.abort();
+          void reader?.cancel().catch(() => {
+          });
         }
       };
     }
   };
 }
 
-// src/utils.ts
-function toProviderMessages(messages) {
-  const knownToolCallIds = /* @__PURE__ */ new Set();
-  const output = [];
-  for (const message of messages) {
-    if (message.role === "tool") {
-      const id = message.toolCallId;
-      if (!id || !knownToolCallIds.has(id)) continue;
-      output.push({
-        role: "tool",
-        content: message.content,
-        tool_call_id: id
-      });
-      continue;
-    }
-    if (message.role === "assistant" && message.toolCalls && message.toolCalls.length > 0) {
-      for (const tc of message.toolCalls) knownToolCallIds.add(tc.id);
-      output.push({
-        role: "assistant",
-        content: message.content || null,
-        tool_calls: message.toolCalls.map((tc) => ({
-          id: tc.id,
-          type: "function",
-          function: {
-            name: tc.name,
-            arguments: typeof tc.args === "string" ? tc.args : JSON.stringify(tc.args ?? {})
-          }
-        }))
-      });
-      continue;
-    }
-    if (message.role === "assistant" && !message.content) continue;
-    output.push({ role: message.role, content: message.content });
-  }
-  return output;
-}
+// src/stream-lines.ts
 async function* readSSELines(stream) {
   const reader = stream.getReader();
   const decoder = new TextDecoder();
@@ -137,23 +280,61 @@ async function* readNDJSONLines(stream) {
     reader.releaseLock();
   }
 }
+
+// src/openai-stream.ts
+var SUCCESS_FINISH_REASONS = /* @__PURE__ */ new Set(["stop", "tool_calls", "function_call"]);
 async function* parseOpenAIStream(stream) {
   const pendingToolCalls = /* @__PURE__ */ new Map();
+  let finishReason;
+  const terminalError = (message, extra) => {
+    const chunk = adapterErrorChunk(message);
+    return {
+      ...chunk,
+      metadata: { ...chunk.metadata, ...extra, finishReason }
+    };
+  };
+  const flushToolCalls = function* () {
+    for (const [, toolCall] of pendingToolCalls) {
+      const parsed = parseCompleteToolArgs(toolCall.args);
+      if (!parsed.ok) {
+        pendingToolCalls.clear();
+        yield {
+          type: "error",
+          content: parsed.error.message,
+          metadata: { error: parsed.error, finishReason }
+        };
+        return false;
+      }
+      yield {
+        type: "tool_call",
+        toolCall: { id: toolCall.id, name: toolCall.name, args: parsed.args }
+      };
+    }
+    pendingToolCalls.clear();
+    return true;
+  };
   for await (const data of readSSELines(stream)) {
     if (data === "[DONE]") {
-      for (const [, tc] of pendingToolCalls) {
-        yield { type: "tool_call", toolCall: { id: tc.id, name: tc.name, args: tc.args || "{}" } };
+      if (finishReason !== void 0 && !SUCCESS_FINISH_REASONS.has(finishReason)) {
+        pendingToolCalls.clear();
+        yield terminalError(
+          `OpenAI stream ended with non-success finish reason "${finishReason}".`,
+          { finishReason }
+        );
+        return;
       }
-      pendingToolCalls.clear();
+      if (!(yield* flushToolCalls())) return;
       yield { type: "done" };
       return;
     }
     try {
       const event = JSON.parse(data);
       const delta = event.choices?.[0]?.delta;
-      if (typeof delta?.content === "string") {
-        yield { type: "text", content: delta.content };
-      }
+      const candidateFinishReason = event.choices?.find(
+        (choice) => typeof choice.finish_reason === "string"
+      )?.finish_reason;
+      if (typeof candidateFinishReason === "string") finishReason = candidateFinishReason;
+      if (typeof delta?.content === "string") yield { type: "text", content: delta.content };
       if (Array.isArray(delta?.tool_calls)) {
         for (const toolCall of delta.tool_calls) {
           const index = toolCall.index ?? 0;
@@ -182,18 +363,87 @@ async function* parseOpenAIStream(stream) {
     } catch {
     }
   }
-  for (const [, tc] of pendingToolCalls) {
-    yield { type: "tool_call", toolCall: { id: tc.id, name: tc.name, args: tc.args || "{}" } };
+  if (finishReason !== void 0 && !SUCCESS_FINISH_REASONS.has(finishReason)) {
+    pendingToolCalls.clear();
+    yield terminalError(
+      `OpenAI stream ended with non-success finish reason "${finishReason}".`,
+      { finishReason }
+    );
+    return;
   }
-  pendingToolCalls.clear();
+  if (!finishReason) {
+    pendingToolCalls.clear();
+    yield terminalError("OpenAI stream ended before a terminal marker.");
+    return;
+  }
+  if (!(yield* flushToolCalls())) return;
   yield { type: "done" };
 }
+
+// src/utils.ts
+function toProviderMessages(messages) {
+  const knownToolCallIds = /* @__PURE__ */ new Set();
+  const output = [];
+  for (const message of messages) {
+    if (message.role === "tool") {
+      const id = message.toolCallId;
+      if (!id || !knownToolCallIds.has(id)) continue;
+      output.push({
+        role: "tool",
+        content: message.content,
+        tool_call_id: id
+      });
+      continue;
+    }
+    if (message.role === "assistant" && message.toolCalls && message.toolCalls.length > 0) {
+      for (const tc of message.toolCalls) knownToolCallIds.add(tc.id);
+      output.push({
+        role: "assistant",
+        content: message.content || null,
+        tool_calls: message.toolCalls.map((tc) => ({
+          id: tc.id,
+          type: "function",
+          function: {
+            name: tc.name,
+            arguments: typeof tc.args === "string" ? tc.args : JSON.stringify(tc.args ?? {})
+          }
+        }))
+      });
+      continue;
+    }
+    if (message.role === "assistant" && !message.content) continue;
+    output.push({ role: message.role, content: message.content });
+  }
+  return output;
+}
 async function* parseAnthropicStream(stream) {
   const pendingToolCalls = /* @__PURE__ */ new Map();
+  let sawMessageStop = false;
+  const emitToolCall = function* (tc) {
+    const parsed = parseCompleteToolArgs(tc.args);
+    if (!parsed.ok) {
+      yield {
+        type: "error",
+        content: parsed.error.message,
+        metadata: { error: parsed.error }
+      };
+      return false;
+    }
+    yield {
+      type: "tool_call",
+      toolCall: { id: tc.id, name: tc.name, args: parsed.args }
+    };
+    return true;
+  };
   for await (const data of readSSELines(stream)) {
     if (data === "[DONE]") continue;
     try {
       const event = JSON.parse(data);
+      if (event.type === "error") {
+        const msg = event.error?.message ?? event.error?.type ?? "Anthropic stream error";
+        yield adapterErrorChunk(String(msg));
+        return;
+      }
       if (event.type === "content_block_delta" && event.delta?.type === "text_delta" && event.delta?.text) {
         yield { type: "text", content: event.delta.text };
       } else if (event.type === "content_block_delta" && event.delta?.type === "input_json_delta") {
@@ -205,22 +455,18 @@ async function* parseAnthropicStream(stream) {
       } else if (event.type === "content_block_start" && event.content_block?.type === "tool_use") {
         const index = event.index ?? 0;
         pendingToolCalls.set(index, {
-          id: event.content_block.id,
-          name: event.content_block.name,
+          id: event.content_block.id ?? `tool-${index}`,
+          name: event.content_block.name ?? "unknown",
           args: ""
         });
       } else if (event.type === "content_block_stop") {
         const index = event.index ?? 0;
         const tc = pendingToolCalls.get(index);
         if (tc) {
-          yield {
-            type: "tool_call",
-            toolCall: {
-              id: tc.id,
-              name: tc.name,
-              args: tc.args || "{}"
-            }
-          };
+          if (!(yield* emitToolCall(tc))) {
+            pendingToolCalls.clear();
+            return;
+          }
           pendingToolCalls.delete(index);
         }
       } else if (event.type === "message_delta" && event.usage) {
@@ -242,8 +488,12 @@ async function* parseAnthropicStream(stream) {
           }
         };
       } else if (event.type === "message_stop") {
+        sawMessageStop = true;
         for (const [, tc] of pendingToolCalls) {
-          yield { type: "tool_call", toolCall: { id: tc.id, name: tc.name, args: tc.args || "{}" } };
+          if (!(yield* emitToolCall(tc))) {
+            pendingToolCalls.clear();
+            return;
+          }
         }
         pendingToolCalls.clear();
         yield { type: "done" };
@@ -252,13 +502,20 @@ async function* parseAnthropicStream(stream) {
     } catch {
     }
   }
-  for (const [, tc] of pendingToolCalls) {
-    yield { type: "tool_call", toolCall: { id: tc.id, name: tc.name, args: tc.args || "{}" } };
-  }
   pendingToolCalls.clear();
+  if (!sawMessageStop) {
+    yield adapterErrorChunk("Anthropic stream ended before message_stop");
+    return;
+  }
   yield { type: "done" };
 }
+var GEMINI_SUCCESS_FINISH = /* @__PURE__ */ new Set([
+  "STOP",
+  "stop",
+  "FINISH_REASON_STOP"
+]);
 async function* parseGeminiStream(stream) {
+  let finishReason;
   for await (const data of readSSELines(stream)) {
     try {
       const event = JSON.parse(data);
@@ -272,19 +529,33 @@ async function* parseGeminiStream(stream) {
           }
         };
       }
-      const parts = event.candidates?.[0]?.content?.parts;
+      const candidate = event.candidates?.[0];
+      if (typeof candidate?.finishReason === "string") {
+        finishReason = candidate.finishReason;
+      }
+      const parts = candidate?.content?.parts;
       if (!Array.isArray(parts)) continue;
       for (const part of parts) {
         if (typeof part.text === "string" && part.text) {
           yield { type: "text", content: part.text };
         } else if (part.functionCall) {
           const fc = part.functionCall;
+          const args = typeof fc.args === "string" ? fc.args : JSON.stringify(fc.args ?? {});
+          const parsed = parseCompleteToolArgs(args);
+          if (!parsed.ok) {
+            yield {
+              type: "error",
+              content: parsed.error.message,
+              metadata: { error: parsed.error }
+            };
+            return;
+          }
           yield {
             type: "tool_call",
             toolCall: {
               id: fc.id ?? `${fc.name}-${Date.now()}`,
-              name: fc.name,
-              args: JSON.stringify(fc.args ?? {})
+              name: fc.name ?? "unknown",
+              args: parsed.args
             }
           };
         }
@@ -292,9 +563,20 @@ async function* parseGeminiStream(stream) {
     } catch {
     }
   }
+  if (!finishReason || !GEMINI_SUCCESS_FINISH.has(finishReason)) {
+    if (finishReason && !GEMINI_SUCCESS_FINISH.has(finishReason)) {
+      yield adapterErrorChunk(
+        `Gemini stream ended with non-success finish reason "${finishReason}"`
+      );
+      return;
+    }
+    yield adapterErrorChunk("Gemini stream ended without a successful finishReason");
+    return;
+  }
   yield { type: "done" };
 }
 async function* parseOllamaStream(stream) {
+  let sawDone = false;
   for await (const data of readNDJSONLines(stream)) {
     try {
       const event = JSON.parse(data);
@@ -304,18 +586,29 @@ async function* parseOllamaStream(stream) {
       if (Array.isArray(event.message?.tool_calls)) {
         for (const tc of event.message.tool_calls) {
           if (tc?.function?.name) {
+            const args = typeof tc.function.arguments === "string" ? tc.function.arguments : JSON.stringify(tc.function.arguments ?? {});
+            const parsed = parseCompleteToolArgs(args);
+            if (!parsed.ok) {
+              yield {
+                type: "error",
+                content: parsed.error.message,
+                metadata: { error: parsed.error }
+              };
+              return;
+            }
             yield {
               type: "tool_call",
               toolCall: {
                 id: tc.id ?? `${tc.function.name}-${Date.now()}`,
                 name: tc.function.name,
-                args: typeof tc.function.arguments === "string" ? tc.function.arguments : JSON.stringify(tc.function.arguments ?? {})
+                args: parsed.args
               }
             };
           }
         }
       }
       if (event.done) {
+        sawDone = true;
         if (typeof event.prompt_eval_count === "number" || typeof event.eval_count === "number") {
           const promptTokens = event.prompt_eval_count ?? 0;
           const completionTokens = event.eval_count ?? 0;
@@ -334,6 +627,10 @@ async function* parseOllamaStream(stream) {
     } catch {
     }
   }
+  if (!sawDone) {
+    yield adapterErrorChunk("Ollama stream ended without done:true");
+    return;
+  }
   yield { type: "done" };
 }
 var DEFAULT_RETRY = {
@@ -345,7 +642,7 @@ var DEFAULT_RETRY = {
     if (response) {
       return [408, 429, 500, 502, 503, 504].includes(response.status);
     }
-    if (error instanceof DOMException && error.name === "AbortError") return false;
+    if (isAbortError(error)) return false;
     return true;
   }
 };
@@ -383,47 +680,23 @@ async function fetchWithRetry(doFetch, signal, retryOpt = {}) {
       const retryAfterMs = parseRetryAfter(response.headers.get("retry-after"));
       const delay = retryAfterMs ?? computeDelay(attempt, opts);
       retryOpt.onRetry?.({ attempt, delayMs: delay, reason: `HTTP ${response.status}` });
-      await sleep(delay);
-      response.body?.cancel().catch(() => {
-      });
+      await cancelBody(response.body);
+      await abortableSleep(delay, signal, sleep);
     } catch (err) {
       lastError = err;
-      if (err instanceof DOMException && err.name === "AbortError") throw err;
+      if (isAbortError(err)) throw err;
       if (attempt >= opts.maxAttempts || !opts.retryOn({ error: err, attempt })) throw err;
       const delay = computeDelay(attempt, opts);
-      retryOpt.onRetry?.({ attempt, delayMs: delay, reason: err.message });
-      await sleep(delay);
+      retryOpt.onRetry?.({
+        attempt,
+        delayMs: delay,
+        reason: err instanceof Error ? err.message : String(err)
+      });
+      await abortableSleep(delay, signal, sleep);
     }
   }
   throw lastError ?? new Error("fetchWithRetry: exhausted attempts");
 }
-function createStreamSource(doFetch, parse, errorLabel, retry) {
-  let abortController = new AbortController();
-  return {
-    stream: async function* () {
-      const controller = abortController;
-      if (!controller) return;
-      try {
-        const response = await fetchWithRetry(doFetch, controller.signal, retry ?? {});
-        if (!response.ok || !response.body) {
-          yield { type: "error", content: `${errorLabel} error: ${response.status}` };
-          return;
-        }
-        yield* parse(response.body);
-      } catch (err) {
-        if (err instanceof DOMException && err.name === "AbortError") return;
-        yield {
-          type: "error",
-          content: err instanceof Error ? err.message : String(err)
-        };
-      }
-    },
-    abort: () => {
-      abortController?.abort();
-      abortController = null;
-    }
-  };
-}
 function chunkText(text, targetSize = 32) {
   if (text.length <= targetSize) return [text];
   const out = [];
@@ -449,35 +722,68 @@ function simulateStream(doFetch, extractText, errorLabel, options = {}) {
       try {
         const response = await fetchWithRetry(doFetch, controller.signal, retry ?? {});
         if (!response.ok) {
-          yield { type: "error", content: `${errorLabel} error: ${response.status}` };
+          await cancelBody(response.body);
+          yield adapterErrorChunk(`${errorLabel} error: ${response.status}`);
+          return;
+        }
+        let text;
+        try {
+          text = await extractText(response);
+        } catch (err) {
+          await cancelBody(response.body);
+          if (isAbortError(err)) return;
+          const message = err instanceof Error ? err.message : String(err);
+          yield adapterErrorChunk(message, { cause: err });
           return;
         }
-        const text = await extractText(response);
         const chunks = chunkText(text, chunkSize);
         for (const chunk of chunks) {
-          if (abortController === null) return;
+          if (abortController === null || controller.signal.aborted) return;
           if (delayMs > 0) {
-            await new Promise((resolve2, reject) => {
-              const timer = setTimeout(resolve2, delayMs);
-              controller.signal.addEventListener(
-                "abort",
-                () => {
-                  clearTimeout(timer);
-                  reject(new DOMException("Aborted", "AbortError"));
-                },
-                { once: true }
-              );
-            });
+            await abortableSleep(delayMs, controller.signal, defaultSleep);
           }
           yield { type: "text", content: chunk };
         }
         yield { type: "done" };
       } catch (err) {
-        if (err instanceof DOMException && err.name === "AbortError") return;
-        yield {
-          type: "error",
-          content: err instanceof Error ? err.message : String(err)
-        };
+        if (isAbortError(err)) return;
+        const message = err instanceof Error ? err.message : String(err);
+        yield adapterErrorChunk(message, { cause: err });
+      }
+    },
+    abort: () => {
+      abortController?.abort();
+      abortController = null;
+    }
+  };
+}
+
+// src/stream-source.ts
+function createStreamSource(doFetch, parse, errorLabel, retry) {
+  let abortController = new AbortController();
+  return {
+    stream: async function* () {
+      const controller = abortController;
+      if (!controller) return;
+      try {
+        const response = await fetchWithRetry(doFetch, controller.signal, retry ?? {});
+        if (!response.ok) {
+          await cancelBody(response.body);
+          yield adapterErrorChunk(`${errorLabel} error: ${response.status}`);
+          return;
+        }
+        if (!response.body) {
+          yield adapterErrorChunk(`${errorLabel} error: empty response body`);
+          return;
+        }
+        for await (const chunk of parse(response.body, response)) {
+          if (controller.signal.aborted || abortController === null) return;
+          yield chunk;
+        }
+      } catch (err) {
+        if (isAbortError(err) || controller.signal.aborted || abortController === null) return;
+        const message = err instanceof Error ? err.message : String(err);
+        yield adapterErrorChunk(message, { cause: err });
       }
     },
     abort: () => {
@@ -487,6 +793,139 @@ function simulateStream(doFetch, extractText, errorLabel, options = {}) {
   };
 }
 
+// src/tool-history.ts
+function toolInput(args) {
+  if (args == null) return {};
+  if (typeof args === "string") {
+    try {
+      const parsed = JSON.parse(args);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed;
+      }
+      return { value: parsed };
+    } catch {
+      return {};
+    }
+  }
+  if (typeof args === "object" && !Array.isArray(args)) {
+    return args;
+  }
+  return { value: args };
+}
+function toolResponsePayload(content) {
+  try {
+    const parsed = JSON.parse(content);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    return { result: parsed };
+  } catch {
+    return { result: content };
+  }
+}
+function toAnthropicMessages(messages) {
+  const knownNames = /* @__PURE__ */ new Map();
+  const output = [];
+  for (const message of messages) {
+    if (message.role === "system") continue;
+    if (message.role === "assistant" && message.toolCalls && message.toolCalls.length > 0) {
+      for (const tc of message.toolCalls) knownNames.set(tc.id, tc.name);
+      const blocks = [];
+      if (message.content) {
+        blocks.push({ type: "text", text: message.content });
+      }
+      for (const tc of message.toolCalls) {
+        blocks.push({
+          type: "tool_use",
+          id: tc.id,
+          name: tc.name,
+          input: toolInput(tc.args)
+        });
+      }
+      output.push({ role: "assistant", content: blocks });
+      continue;
+    }
+    if (message.role === "tool") {
+      const id = message.toolCallId;
+      if (!id || !knownNames.has(id)) continue;
+      const block = {
+        type: "tool_result",
+        tool_use_id: id,
+        content: message.content
+      };
+      const previous2 = output[output.length - 1];
+      if (previous2?.role === "user" && Array.isArray(previous2.content) && previous2.content.every((item) => item && typeof item === "object" && item.type === "tool_result")) {
+        previous2.content.push(block);
+      } else {
+        output.push({ role: "user", content: [block] });
+      }
+      continue;
+    }
+    if (message.role === "assistant" && !message.content) continue;
+    const previous = output[output.length - 1];
+    if (message.role === "user" && previous?.role === "user") {
+      const previousBlocks = Array.isArray(previous.content) ? previous.content : [{ type: "text", text: previous.content }];
+      previous.content = [...previousBlocks, { type: "text", text: message.content }];
+    } else {
+      output.push({ role: message.role, content: message.content });
+    }
+  }
+  return output;
+}
+function toGeminiContents(messages) {
+  const knownNames = /* @__PURE__ */ new Map();
+  const output = [];
+  for (const message of messages) {
+    if (message.role === "system") continue;
+    if (message.role === "assistant" && message.toolCalls && message.toolCalls.length > 0) {
+      for (const tc of message.toolCalls) knownNames.set(tc.id, tc.name);
+      const parts = [];
+      if (message.content) {
+        parts.push({ text: message.content });
+      }
+      for (const tc of message.toolCalls) {
+        parts.push({
+          functionCall: {
+            id: tc.id,
+            name: tc.name,
+            args: toolInput(tc.args)
+          }
+        });
+      }
+      output.push({ role: "model", parts });
+      continue;
+    }
+    if (message.role === "tool") {
+      const id = message.toolCallId;
+      const name = id ? knownNames.get(id) : void 0;
+      if (!name) continue;
+      const part = {
+        functionResponse: {
+          id,
+          name,
+          response: toolResponsePayload(message.content)
+        }
+      };
+      const previous2 = output[output.length - 1];
+      if (previous2?.role === "user" && previous2.parts.every((item) => item.functionResponse !== void 0)) {
+        previous2.parts.push(part);
+      } else {
+        output.push({ role: "user", parts: [part] });
+      }
+      continue;
+    }
+    if (message.role === "assistant" && !message.content) continue;
+    const role = message.role === "assistant" ? "model" : "user";
+    const previous = output[output.length - 1];
+    if (previous?.role === role) {
+      previous.parts.push({ text: message.content });
+    } else {
+      output.push({ role, parts: [{ text: message.content }] });
+    }
+  }
+  return output;
+}
+
 // src/anthropic.ts
 function anthropic(config) {
   const { apiKey, model, baseUrl = "https://api.anthropic.com", maxTokens = 4096, retry } = config;
@@ -502,7 +941,7 @@ function anthropic(config) {
       const body = {
         model,
         max_tokens: request.context?.maxTokens ?? maxTokens,
-        messages: request.messages.filter((message) => message.role !== "system").map((message) => ({ role: message.role, content: message.content })),
+        messages: toAnthropicMessages(request.messages),
         system: request.messages.find((message) => message.role === "system")?.content,
         tools: request.context?.tools?.map((tool) => ({
           name: tool.name,
@@ -600,18 +1039,25 @@ function gemini(config) {
     createSource: (request) => {
       const systemMessage = request.messages.find((message) => message.role === "system");
       const body = {
-        contents: request.messages.filter((message) => message.role !== "system").map((message) => ({
-          role: message.role === "assistant" ? "model" : "user",
-          parts: [{ text: message.content }]
-        })),
-        systemInstruction: systemMessage ? { role: "system", parts: [{ text: systemMessage.content }] } : void 0
+        contents: toGeminiContents(request.messages),
+        systemInstruction: systemMessage ? { role: "system", parts: [{ text: systemMessage.content }] } : void 0,
+        tools: request.context?.tools && request.context.tools.length > 0 ? [{
+          functionDeclarations: request.context.tools.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.schema
+          }))
+        }] : void 0
       };
       return createStreamSource(
         (signal) => fetch(
-          `${baseUrl}/v1beta/models/${model}:streamGenerateContent?alt=sse&key=${apiKey}`,
+          `${baseUrl}/v1beta/models/${model}:streamGenerateContent?alt=sse`,
           {
             method: "POST",
-            headers: { "Content-Type": "application/json" },
+            headers: {
+              "Content-Type": "application/json",
+              "x-goog-api-key": apiKey
+            },
             body: JSON.stringify(body),
             signal
           }
@@ -686,56 +1132,71 @@ function asText(value) {
   }
   return "";
 }
+function isToolStartEvent(eventName) {
+  return eventName === "on_tool_start" || eventName.endsWith("_tool_start");
+}
 function langchain(config) {
   const { runnable, mode = "stream" } = config;
   return {
-    createSource: (request) => ({
-      stream: async function* () {
-        try {
-          if (mode === "events" && runnable.streamEvents) {
-            const events = await runnable.streamEvents(
-              { messages: request.messages },
-              { version: "v2" }
-            );
-            for await (const event of events) {
-              const eventName = String(event.event ?? "");
-              if (eventName.endsWith("_stream")) {
-                const chunk = asText(event.data);
+    createSource: (request) => {
+      const controller = new AbortController();
+      return {
+        stream: async function* () {
+          if (controller.signal.aborted) return;
+          try {
+            const runnableConfig = {
+              version: "v2",
+              signal: controller.signal
+            };
+            if (mode === "events" && runnable.streamEvents) {
+              const events = await runnable.streamEvents(
+                { messages: request.messages },
+                runnableConfig
+              );
+              for await (const event of events) {
+                if (controller.signal.aborted) return;
+                const eventName = String(event.event ?? "");
+                if (eventName.endsWith("_stream")) {
+                  const chunk = asText(event.data);
+                  if (chunk) yield { type: "text", content: chunk };
+                } else if (isToolStartEvent(eventName) && event.name) {
+                  yield {
+                    type: "tool_call",
+                    toolCall: {
+                      id: String(event.run_id ?? `${event.name}-${Date.now()}`),
+                      name: String(event.name),
+                      args: JSON.stringify(event.data ?? {})
+                    }
+                  };
+                }
+              }
+            } else if (runnable.stream) {
+              const stream = await runnable.stream(
+                { messages: request.messages },
+                runnableConfig
+              );
+              for await (const value of stream) {
+                if (controller.signal.aborted) return;
+                const chunk = asText(value);
                 if (chunk) yield { type: "text", content: chunk };
-              } else if (eventName.endsWith("_start") && event.name) {
-                yield {
-                  type: "tool_call",
-                  toolCall: {
-                    id: String(event.run_id ?? `${event.name}-${Date.now()}`),
-                    name: String(event.name),
-                    args: JSON.stringify(event.data ?? {})
-                  }
-                };
-              } else if (eventName.endsWith("_end")) {
-                continue;
               }
+            } else {
+              yield adapterErrorChunk("Runnable does not implement stream() or streamEvents()");
+              return;
             }
-          } else if (runnable.stream) {
-            const stream = await runnable.stream({ messages: request.messages });
-            for await (const value of stream) {
-              const chunk = asText(value);
-              if (chunk) yield { type: "text", content: chunk };
-            }
-          } else {
-            yield { type: "error", content: "Runnable does not implement stream() or streamEvents()" };
-            return;
+            if (controller.signal.aborted) return;
+            yield { type: "done" };
+          } catch (error) {
+            if (isAbortError(error) || controller.signal.aborted) return;
+            const message = error instanceof Error ? error.message : String(error);
+            yield adapterErrorChunk(message, { cause: error });
           }
-          yield { type: "done" };
-        } catch (error) {
-          yield {
-            type: "error",
-            content: error instanceof Error ? error.message : String(error)
-          };
+        },
+        abort: () => {
+          controller.abort();
         }
-      },
-      abort: () => {
-      }
-    })
+      };
+    }
   };
 }
 function langgraph(config) {
@@ -746,7 +1207,8 @@ function langgraph(config) {
 }
 
 // src/vercel-ai.ts
-async function* parseVercelStream(stream) {
+var UI_STREAM_HEADER = "x-vercel-ai-ui-message-stream";
+async function* parseVercelTextStream(stream) {
   const reader = stream.getReader();
   const decoder = new TextDecoder();
   try {
@@ -761,6 +1223,48 @@ async function* parseVercelStream(stream) {
   }
   yield { type: "done" };
 }
+async function* parseVercelUiMessageStreamV1(stream) {
+  for await (const data of readSSELines(stream)) {
+    if (data === "[DONE]") {
+      yield { type: "done" };
+      return;
+    }
+    try {
+      const part = JSON.parse(data);
+      const type = part.type;
+      if (type === "text-delta") {
+        const delta = part.delta ?? part.textDelta;
+        if (typeof delta === "string" && delta) {
+          yield { type: "text", content: delta };
+        }
+      } else if (type === "reasoning-delta") {
+        const delta = part.delta ?? part.textDelta;
+        if (typeof delta === "string" && delta) {
+          yield { type: "reasoning", content: delta };
+        }
+      } else if (type === "error") {
+        const message = part.errorText ?? part.message ?? "Vercel AI UI stream error";
+        yield adapterErrorChunk(String(message));
+        return;
+      } else if (type === "abort") {
+        yield adapterErrorChunk(part.reason ?? "Vercel AI UI stream aborted by provider");
+        return;
+      } else if (type === "finish") {
+        continue;
+      }
+    } catch {
+    }
+  }
+  yield adapterErrorChunk("Vercel AI UI stream truncated before [DONE]");
+}
+async function* parseVercelStream(stream, response) {
+  const header = response?.headers.get(UI_STREAM_HEADER) ?? response?.headers.get(UI_STREAM_HEADER.toLowerCase());
+  if (header === "v1") {
+    yield* parseVercelUiMessageStreamV1(stream);
+    return;
+  }
+  yield* parseVercelTextStream(stream);
+}
 function vercelAI(config) {
   const { api, headers = {}, retry } = config;
   return {
@@ -934,6 +1438,7 @@ async function* parseReplicateStream(stream) {
   const decoder = new TextDecoder();
   let buffer = "";
   let currentEvent = "";
+  let sawDone = false;
   try {
     while (true) {
       const { done, value } = await reader.read();
@@ -951,10 +1456,11 @@ async function* parseReplicateStream(stream) {
         if (currentEvent === "output" && data) {
           yield { type: "text", content: data };
         } else if (currentEvent === "done") {
+          sawDone = true;
           yield { type: "done" };
           return;
         } else if (currentEvent === "error") {
-          yield { type: "error", content: data || "replicate stream error" };
+          yield adapterErrorChunk(data || "replicate stream error");
           return;
         }
       }
@@ -962,6 +1468,10 @@ async function* parseReplicateStream(stream) {
   } finally {
     reader.releaseLock();
   }
+  if (!sawDone) {
+    yield adapterErrorChunk("Replicate stream ended without done event");
+    return;
+  }
   yield { type: "done" };
 }
 function replicate(config) {
@@ -994,17 +1504,17 @@ function replicate(config) {
               signal: controller.signal
             });
             if (!response.ok) {
-              yield { type: "error", content: `Replicate API error: ${response.status}` };
+              yield adapterErrorChunk(`Replicate API error: ${response.status}`);
               return;
             }
             const prediction = await response.json();
             if (prediction.error) {
-              yield { type: "error", content: prediction.error };
+              yield adapterErrorChunk(prediction.error);
               return;
             }
             const streamUrl = prediction.urls?.stream;
             if (!streamUrl) {
-              yield { type: "error", content: "Replicate prediction has no stream URL" };
+              yield adapterErrorChunk("Replicate prediction has no stream URL");
               return;
             }
             const streamResponse = await fetch(streamUrl, {
@@ -1013,7 +1523,7 @@ function replicate(config) {
               signal: controller.signal
             });
             if (!streamResponse.ok || !streamResponse.body) {
-              yield { type: "error", content: `Replicate stream error: ${streamResponse.status}` };
+              yield adapterErrorChunk(`Replicate stream error: ${streamResponse.status}`);
               return;
             }
             for await (const chunk of parseReplicateStream(streamResponse.body)) {
@@ -1021,8 +1531,9 @@ function replicate(config) {
               yield chunk;
             }
           } catch (err) {
-            if (err instanceof DOMException && err.name === "AbortError") return;
-            yield { type: "error", content: err instanceof Error ? err.message : String(err) };
+            if (isAbortError(err) || aborted) return;
+            const message = err instanceof Error ? err.message : String(err);
+            yield adapterErrorChunk(message, { cause: err });
           }
         },
         abort: () => {
@@ -1072,10 +1583,7 @@ function vertex(config) {
     createSource: (request) => {
       const systemMessage = request.messages.find((message) => message.role === "system");
       const body = {
-        contents: request.messages.filter((message) => message.role !== "system").map((message) => ({
-          role: message.role === "assistant" ? "model" : "user",
-          parts: [{ text: message.content }]
-        })),
+        contents: toGeminiContents(request.messages),
         systemInstruction: systemMessage ? { role: "system", parts: [{ text: systemMessage.content }] } : void 0,
         tools: request.context?.tools && request.context.tools.length > 0 ? [{
           functionDeclarations: request.context.tools.map((tool) => ({
@@ -1131,7 +1639,7 @@ function isAnthropicModel(model) {
   return model.startsWith("anthropic.");
 }
 function buildAnthropicBody(request, maxTokens) {
-  const messages = request.messages.filter((m) => m.role !== "system").map((m) => ({ role: m.role, content: m.content }));
+  const messages = toAnthropicMessages(request.messages);
   const system = request.messages.find((m) => m.role === "system")?.content;
   const tools = request.context?.tools?.map((tool) => ({
     name: tool.name,
@@ -1150,6 +1658,19 @@ function buildAnthropicBody(request, maxTokens) {
 async function* parseAnthropicBedrockEvents(events) {
   const decoder = new TextDecoder();
   const pendingToolCalls = /* @__PURE__ */ new Map();
+  const emitTool = function* (tc) {
+    const parsed = parseCompleteToolArgs(tc.args);
+    if (!parsed.ok) {
+      yield {
+        type: "error",
+        content: parsed.error.message,
+        metadata: { error: parsed.error }
+      };
+      return false;
+    }
+    yield { type: "tool_call", toolCall: { id: tc.id, name: tc.name, args: parsed.args } };
+    return true;
+  };
   for await (const item of events) {
     const bytes = item.chunk?.bytes;
     if (!bytes) continue;
@@ -1179,7 +1700,10 @@ async function* parseAnthropicBedrockEvents(events) {
       const index = event.index ?? 0;
       const tc = pendingToolCalls.get(index);
       if (tc) {
-        yield { type: "tool_call", toolCall: { id: tc.id, name: tc.name, args: tc.args || "{}" } };
+        if (!(yield* emitTool(tc))) {
+          pendingToolCalls.clear();
+          return;
+        }
         pendingToolCalls.delete(index);
       }
     } else if (type === "message_delta") {
@@ -1206,18 +1730,18 @@ async function* parseAnthropicBedrockEvents(events) {
       }
     } else if (type === "message_stop") {
       for (const [, tc] of pendingToolCalls) {
-        yield { type: "tool_call", toolCall: { id: tc.id, name: tc.name, args: tc.args || "{}" } };
+        if (!(yield* emitTool(tc))) {
+          pendingToolCalls.clear();
+          return;
+        }
       }
       pendingToolCalls.clear();
       yield { type: "done" };
       return;
     }
   }
-  for (const [, tc] of pendingToolCalls) {
-    yield { type: "tool_call", toolCall: { id: tc.id, name: tc.name, args: tc.args || "{}" } };
-  }
   pendingToolCalls.clear();
-  yield { type: "done" };
+  yield adapterErrorChunk("Bedrock stream ended before message_stop");
 }
 function bedrock(config) {
   const { model, region, maxTokens = 4096 } = config;
@@ -1252,9 +1776,10 @@ function bedrock(config) {
       let aborted = false;
       return {
         stream: async function* () {
-          if (aborted) return;
+          if (aborted || controller.signal.aborted) return;
           try {
             const client = await getClient();
+            if (aborted || controller.signal.aborted) return;
             const sdk = config.client ? null : await loadSdk();
             const input = {
               modelId: model,
@@ -1263,17 +1788,19 @@ function bedrock(config) {
               body: buildAnthropicBody(request, maxTokens)
             };
             const command = sdk ? new sdk.InvokeModelWithResponseStreamCommand(input) : { input };
-            const response = await client.send(command);
+            const response = await client.send(command, { abortSignal: controller.signal });
             if (!response.body) {
-              yield { type: "error", content: "Bedrock: empty response body" };
+              yield adapterErrorChunk("Bedrock: empty response body");
               return;
             }
             for await (const chunk of parseAnthropicBedrockEvents(response.body)) {
-              if (aborted) return;
+              if (aborted || controller.signal.aborted) return;
               yield chunk;
             }
           } catch (err) {
-            yield { type: "error", content: err instanceof Error ? err.message : String(err) };
+            if (isAbortError(err) || aborted) return;
+            const message = err instanceof Error ? err.message : String(err);
+            yield adapterErrorChunk(message, { cause: err });
           }
         },
         abort: () => {
@@ -1324,26 +1851,62 @@ function webllm(config) {
       tools: false
     },
     createSource: (request) => {
+      const controller = new AbortController();
       let aborted = false;
+      let activeIter = null;
+      const softAbort = () => {
+        aborted = true;
+        if (!controller.signal.aborted) controller.abort();
+        if (activeIter && typeof activeIter.return === "function") {
+          void activeIter.return(void 0).catch(() => {
+          });
+        }
+      };
       return {
         stream: async function* () {
-          if (aborted) return;
+          if (aborted || controller.signal.aborted) return;
           try {
-            const engine = await getEngine();
+            const engine = await raceAbort(getEngine(), controller.signal);
+            if (aborted || controller.signal.aborted) return;
             const messages = request.messages.map((m) => ({ role: m.role, content: m.content }));
-            const completion = await engine.chat.completions.create({ messages, stream: true });
-            for await (const chunk of completion) {
-              if (aborted) return;
-              const delta = chunk.choices[0]?.delta?.content;
+            const completion = await raceAbort(
+              Promise.resolve(
+                engine.chat.completions.create({ messages, stream: true })
+              ),
+              controller.signal
+            );
+            if (aborted || controller.signal.aborted) return;
+            activeIter = completion[Symbol.asyncIterator]();
+            while (true) {
+              if (aborted || controller.signal.aborted) {
+                if (typeof activeIter.return === "function") {
+                  await activeIter.return(void 0).catch(() => {
+                  });
+                }
+                return;
+              }
+              const next = await raceAbort(activeIter.next(), controller.signal);
+              if (next.done) break;
+              if (aborted || controller.signal.aborted) {
+                if (typeof activeIter.return === "function") {
+                  await activeIter.return(void 0).catch(() => {
+                  });
+                }
+                return;
+              }
+              const delta = next.value.choices[0]?.delta?.content;
               if (delta) yield { type: "text", content: delta };
             }
+            if (aborted || controller.signal.aborted) return;
             yield { type: "done" };
           } catch (err) {
-            yield { type: "error", content: err instanceof Error ? err.message : String(err) };
+            if (isAbortError(err) || aborted || controller.signal.aborted) return;
+            const message = err instanceof Error ? err.message : String(err);
+            yield adapterErrorChunk(message, { cause: err });
           }
         },
         abort: () => {
-          aborted = true;
+          softAbort();
         }
       };
     }
@@ -1443,22 +2006,57 @@ function createRouter(options) {
       }
       if (typeof policy === "function") {
         const maybe = policy({ request, candidates: pool });
-        if (maybe instanceof Promise) {
+        if (typeof maybe !== "string") {
+          const controller = new AbortController();
+          let child;
           return {
             abort: () => {
+              controller.abort();
+              child?.abort();
             },
             stream: async function* () {
-              const id = await maybe;
+              let id;
+              try {
+                id = await raceAbort(maybe, controller.signal);
+              } catch (err) {
+                if (isAbortError(err)) return;
+                const error = err instanceof Error ? err : new Error(String(err));
+                yield {
+                  type: "error",
+                  content: error.message,
+                  metadata: { error }
+                };
+                return;
+              }
               const c3 = pool.find((x) => x.id === id);
               if (!c3) {
-                throw new core.ConfigError({
+                const error = new core.ConfigError({
                   code: core.ErrorCodes.AK_CONFIG_INVALID,
                   message: `policy returned unknown id: ${id}`,
                   hint: "Custom policy functions must return one of the candidate ids."
                 });
+                yield {
+                  type: "error",
+                  content: error.message,
+                  metadata: { error }
+                };
+                return;
+              }
+              try {
+                options.onRoute?.({ id: c3.id, reason: pickedBy ?? "custom policy", request });
+                child = c3.adapter.createSource(request);
+                for await (const chunk of child.stream()) {
+                  yield chunk;
+                }
+              } catch (err) {
+                if (controller.signal.aborted || isAbortError(err)) return;
+                const error = err instanceof Error ? err : new Error(String(err));
+                yield {
+                  type: "error",
+                  content: error.message,
+                  metadata: { error }
+                };
               }
-              options.onRoute?.({ id: c3.id, reason: pickedBy ?? "custom policy", request });
-              for await (const chunk of c3.adapter.createSource(request).stream()) yield chunk;
             }
           };
         }
@@ -1546,9 +2144,17 @@ async function drain(source, timeoutMs) {
     for await (const chunk of source.stream()) {
       chunks.push(chunk);
       if (chunk.type === "text" && typeof chunk.content === "string") text += chunk.content;
+      if (chunk.type === "error") {
+        const metaErr = chunk.metadata?.error;
+        error = metaErr instanceof Error ? metaErr : new Error(chunk.content ?? "stream error");
+      }
     }
   } catch (err) {
-    error = err instanceof Error ? err : new Error(String(err));
+    if (!isAbortError(err)) {
+      error = err instanceof Error ? err : new Error(String(err));
+    } else if (!timedOut) {
+      error = err instanceof Error ? err : new Error(String(err));
+    }
   } finally {
     if (timer) clearTimeout(timer);
   }
@@ -1587,10 +2193,19 @@ function createEnsembleAdapter(options) {
       const sources = [];
       const run = async () => {
         const tasks = options.candidates.map(async (c, i) => {
-          const source = c.adapter.createSource(request);
-          sources[i] = source;
-          const { chunks, text, error } = await drain(source, options.timeoutMs);
-          return { id: c.id, chunks, text, error };
+          try {
+            const source = c.adapter.createSource(request);
+            sources[i] = source;
+            if (aborted) {
+              source.abort();
+              return { id: c.id, chunks: [], text: "", error: new Error("aborted") };
+            }
+            const { chunks, text, error } = await drain(source, options.timeoutMs);
+            return { id: c.id, chunks, text, error };
+          } catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            return { id: c.id, chunks: [], text: "", error };
+          }
         });
         return Promise.all(tasks);
       };
@@ -1613,22 +2228,51 @@ function createEnsembleAdapter(options) {
           for (const s of sources) s?.abort();
         },
         stream: async function* () {
+          if (aborted) return;
           const branches = await run();
           options.onBranches?.(branches);
-          if (aborted) return;
-          const text = await finalText(branches);
-          if (!text && branches.every((b) => b.error)) {
-            const summary = branches.map((b) => `${b.id}: ${b.error?.message ?? "unknown"}`).join("; ");
-            const err = new core.AdapterError({
-              code: core.ErrorCodes.AK_ADAPTER_STREAM_FAILED,
-              message: `all ensemble branches failed (${summary})`,
-              hint: "Inspect each branch error via options.onBranches or the err.branchErrors field."
-            });
-            err.branchErrors = branches.map((b) => ({ id: b.id, error: b.error }));
-            throw err;
+          if (aborted) {
+            for (const s of sources) s?.abort();
+            return;
+          }
+          try {
+            const text = await finalText(branches);
+            if (!text && branches.every((b) => b.error)) {
+              const summary = branches.map((b) => `${b.id}: ${b.error?.message ?? "unknown"}`).join("; ");
+              const err = new core.AdapterError({
+                code: core.ErrorCodes.AK_ADAPTER_STREAM_FAILED,
+                message: `all ensemble branches failed (${summary})`,
+                hint: "Inspect each branch error via options.onBranches or the err.branchErrors field."
+              });
+              err.branchErrors = branches.map((b) => ({ id: b.id, error: b.error }));
+              yield {
+                type: "error",
+                content: err.message,
+                metadata: { error: err }
+              };
+              return;
+            }
+            yield {
+              type: "text",
+              content: text,
+              metadata: {
+                ensemble: branches.map((b) => ({
+                  id: b.id,
+                  bytes: b.text.length,
+                  error: b.error?.message
+                }))
+              }
+            };
+            yield { type: "done" };
+          } catch (err) {
+            if (aborted || isAbortError(err)) return;
+            const error = err instanceof Error ? err : new Error(String(err));
+            yield {
+              type: "error",
+              content: error.message,
+              metadata: { error }
+            };
           }
-          yield { type: "text", content: text, metadata: { ensemble: branches.map((b) => ({ id: b.id, bytes: b.text.length, error: b.error?.message })) } };
-          yield { type: "done" };
         }
       };
     }
@@ -1659,57 +2303,119 @@ function createFallbackAdapter(candidates, options = {}) {
             let source;
             try {
               source = candidate.adapter.createSource(request);
-            } catch (err) {
-              const error = err instanceof Error ? err : new Error(String(err));
+            } catch (err2) {
+              const error = err2 instanceof Error ? err2 : new Error(String(err2));
               errors.push({ id: candidate.id, error });
               options.onFallback?.({ id: candidate.id, index: i, error });
-              if (options.shouldRetry && !options.shouldRetry(error, i)) throw error;
+              if (options.shouldRetry && !options.shouldRetry(error, i)) {
+                yield {
+                  type: "error",
+                  content: error.message,
+                  metadata: { error }
+                };
+                return;
+              }
               continue;
             }
             active = source;
             const iter = source.stream()[Symbol.asyncIterator]();
             let firstReal;
             let branchError;
+            const leadingUsage = [];
             try {
               while (true) {
+                if (aborted) {
+                  source.abort();
+                  return;
+                }
                 const r = await iter.next();
                 if (r.done) {
                   branchError = new Error(`candidate ${candidate.id} emitted no chunks`);
                   break;
                 }
                 if (r.value.type === "error") {
-                  branchError = new Error(
+                  const metaErr = r.value.metadata?.error;
+                  branchError = metaErr instanceof Error ? metaErr : new Error(
                     `candidate ${candidate.id}: ${r.value.content ?? "stream error"}`
                   );
                   break;
                 }
+                if (r.value.type === "usage") {
+                  leadingUsage.push(r.value);
+                  continue;
+                }
                 firstReal = r.value;
                 break;
               }
-            } catch (err) {
-              branchError = err instanceof Error ? err : new Error(String(err));
+            } catch (err2) {
+              if (isAbortError(err2) || aborted) {
+                source.abort();
+                return;
+              }
+              branchError = err2 instanceof Error ? err2 : new Error(String(err2));
             }
             if (branchError || !firstReal) {
               const error = branchError ?? new Error(`candidate ${candidate.id} emitted no chunks`);
               errors.push({ id: candidate.id, error });
               options.onFallback?.({ id: candidate.id, index: i, error });
-              if (options.shouldRetry && !options.shouldRetry(error, i)) throw error;
+              try {
+                source.abort();
+              } catch {
+              }
+              if (typeof iter.return === "function") {
+                try {
+                  await iter.return(void 0);
+                } catch {
+                }
+              }
+              if (options.shouldRetry && !options.shouldRetry(error, i)) {
+                yield {
+                  type: "error",
+                  content: error.message,
+                  metadata: { error }
+                };
+                return;
+              }
               active = void 0;
               continue;
             }
+            for (const chunk of leadingUsage) yield chunk;
             yield firstReal;
             while (true) {
-              const next = await iter.next();
-              if (next.done) return;
-              yield next.value;
+              if (aborted) {
+                source.abort();
+                return;
+              }
+              try {
+                const next = await iter.next();
+                if (next.done) return;
+                yield next.value;
+              } catch (err2) {
+                if (isAbortError(err2) || aborted) {
+                  source.abort();
+                  return;
+                }
+                const error = err2 instanceof Error ? err2 : new Error(String(err2));
+                yield {
+                  type: "error",
+                  content: error.message,
+                  metadata: { error }
+                };
+                return;
+              }
             }
           }
           const summary = errors.map((e) => `${e.id}: ${e.error.message}`).join("; ");
-          throw new core.AdapterError({
+          const err = new core.AdapterError({
             code: core.ErrorCodes.AK_ADAPTER_STREAM_FAILED,
             message: `all fallback candidates failed (${summary})`,
             hint: "Check each candidate adapter's configuration and provider keys."
           });
+          yield {
+            type: "error",
+            content: err.message,
+            metadata: { error: err }
+          };
         }
       };
     }
@@ -1727,25 +2433,48 @@ function mockAdapter(options) {
       usage: true
     },
     createSource: (request) => {
-      history?.push(request);
-      const myCall = callIndex++;
+      const controller = new AbortController();
+      let myCall;
       let cancelled = false;
       return {
         stream: async function* () {
-          const chunks = resolve(response, myCall, request);
-          let endedExplicitly = false;
-          for (const chunk of chunks) {
-            if (cancelled) return;
-            if (delayMs > 0) await new Promise((r) => setTimeout(r, delayMs));
-            yield chunk;
-            if (chunk.type === "done" || chunk.type === "error") {
-              endedExplicitly = true;
+          if (cancelled || controller.signal.aborted) return;
+          try {
+            if (myCall === void 0) {
+              myCall = callIndex++;
+              history?.push(request);
+            }
+            const chunks = resolve(response, myCall, request);
+            for (const chunk of chunks) {
+              if (cancelled || controller.signal.aborted) return;
+              if (delayMs > 0) {
+                await abortableSleep(delayMs, controller.signal, (ms) => new Promise((resolveTimer) => setTimeout(resolveTimer, ms)));
+              }
+              if (cancelled || controller.signal.aborted) return;
+              if (chunk.type === "error" && !(chunk.metadata?.error instanceof Error)) {
+                const normalized = adapterErrorChunk(
+                  chunk.content ?? "Mock adapter error",
+                  { cause: chunk.metadata?.error }
+                );
+                yield {
+                  ...chunk,
+                  metadata: { ...chunk.metadata, ...normalized.metadata }
+                };
+                return;
+              }
+              yield chunk;
+              if (chunk.type === "done" || chunk.type === "error") return;
             }
+            yield { type: "done" };
+          } catch (error) {
+            if (cancelled || controller.signal.aborted || isAbortError(error)) return;
+            const message = error instanceof Error ? error.message : String(error);
+            yield adapterErrorChunk(message, { cause: error });
           }
-          if (!endedExplicitly) yield { type: "done" };
         },
         abort: () => {
           cancelled = true;
+          controller.abort();
         }
       };
     }
@@ -1768,22 +2497,43 @@ function resolve(response, callIndex, request) {
 }
 function recordingAdapter(inner, sink) {
   return {
+    capabilities: inner.capabilities,
     createSource: (request) => {
-      const innerSource = inner.createSource(request);
+      let innerSource;
       const captured = [];
-      const recordedAt = (/* @__PURE__ */ new Date()).toISOString();
+      let aborted = false;
       return {
         stream: async function* () {
+          if (aborted) return;
+          const recordedAt = (/* @__PURE__ */ new Date()).toISOString();
           try {
+            innerSource = inner.createSource(request);
             for await (const chunk of innerSource.stream()) {
+              if (aborted) return;
               captured.push(chunk);
               yield chunk;
+              if (chunk.type === "done" || chunk.type === "error") return;
             }
+            const errorChunk = adapterErrorChunk("Recorded adapter ended without a terminal chunk");
+            captured.push(errorChunk);
+            yield errorChunk;
+          } catch (error) {
+            if (aborted || isAbortError(error)) return;
+            const message = error instanceof Error ? error.message : String(error);
+            const errorChunk = adapterErrorChunk(message, { cause: error });
+            captured.push(errorChunk);
+            yield errorChunk;
           } finally {
-            await sink.push({ recordedAt, request, chunks: captured });
+            try {
+              await sink.push({ recordedAt, request, chunks: captured });
+            } catch {
+            }
           }
         },
-        abort: () => innerSource.abort()
+        abort: () => {
+          aborted = true;
+          innerSource?.abort();
+        }
       };
     }
   };
@@ -1809,15 +2559,40 @@ function replayAdapter(fixture) {
     response: fixture.map((turn) => turn.chunks)
   });
 }
-
-// src/embedders/shared.ts
-var ERROR_BODY_PREVIEW_CHARS = 200;
-async function throwIfNotOk(response, label, url) {
+async function throwIfNotOk(response, label, _url) {
   if (response.ok) return;
-  const body = await response.text().catch(() => "");
-  throw new Error(
-    `HTTP ${response.status} from ${label} ${url}: ${body.slice(0, ERROR_BODY_PREVIEW_CHARS)}`
-  );
+  void response.body?.cancel().catch(() => {
+  });
+  throw embeddingError(label, `HTTP ${response.status}`);
+}
+function embeddingError(label, detail, cause) {
+  return new core.AdapterError({
+    code: core.ErrorCodes.AK_ADAPTER_STREAM_FAILED,
+    message: `${label} embedding failed: ${detail}`,
+    cause
+  });
+}
+function requireEmbeddingVector(value, label) {
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new core.AdapterError({
+      code: core.ErrorCodes.AK_ADAPTER_STREAM_FAILED,
+      message: `${label} returned an empty or missing embedding vector`,
+      hint: "The provider responded 2xx but the embedding payload was empty or malformed."
+    });
+  }
+  const vector = [];
+  for (let i = 0; i < value.length; i++) {
+    const n = value[i];
+    if (typeof n !== "number" || !Number.isFinite(n)) {
+      throw new core.AdapterError({
+        code: core.ErrorCodes.AK_ADAPTER_STREAM_FAILED,
+        message: `${label} returned a non-finite embedding value at index ${i}`,
+        hint: "Embedding vectors must be finite numbers only."
+      });
+    }
+    vector.push(n);
+  }
+  return vector;
 }
 
 // src/embedders/openai.ts
@@ -1826,7 +2601,7 @@ async function fetchAvailableModels(baseUrl, apiKey) {
   const response = await fetch(url, {
     headers: { "Authorization": `Bearer ${apiKey}` }
   });
-  await throwIfNotOk(response, "openai", url);
+  await throwIfNotOk(response, "openai");
   const data = await response.json();
   return data.data.map((m) => m.id).filter((id) => id.includes("embed")).sort();
 }
@@ -1834,13 +2609,9 @@ async function buildModelError(baseUrl, apiKey, originalError) {
   try {
     const models = await fetchAvailableModels(baseUrl, apiKey);
     const list = models.length > 0 ? models.join(", ") : "none found";
-    return new Error(
-      `OpenAI embedding failed: ${originalError}. Available embedding models: ${list}`
-    );
+    return embeddingError("OpenAI", `${originalError}. Available embedding models: ${list}`);
   } catch (fetchError) {
-    return new Error(
-      `OpenAI embedding failed: ${originalError}. Could not fetch available models: ${fetchError.message}`
-    );
+    return embeddingError("OpenAI", `${originalError}. Could not fetch available models`, fetchError);
   }
 }
 function openaiEmbedder(config) {
@@ -1855,20 +2626,24 @@ function openaiEmbedder(config) {
       body: JSON.stringify({ model, input: text })
     });
     if (!response.ok) {
-      const errorBody = await response.json().catch(() => ({}));
-      const message = errorBody.error?.message ?? `HTTP ${response.status}`;
+      void response.body?.cancel().catch(() => {
+      });
+      const message = `HTTP ${response.status}`;
       throw await buildModelError(baseUrl, apiKey, message);
     }
     const data = await response.json();
-    return data.data[0].embedding;
+    const embedding = data.data?.[0]?.embedding;
+    return requireEmbeddingVector(embedding, "OpenAI");
   };
 }
 
 // src/embedders/gemini.ts
 async function fetchAvailableModels2(baseUrl, apiKey) {
-  const url = `${baseUrl}/v1beta/models?key=${apiKey}`;
-  const response = await fetch(url);
-  await throwIfNotOk(response, "gemini", `${baseUrl}/v1beta/models`);
+  const url = `${baseUrl}/v1beta/models`;
+  const response = await fetch(url, {
+    headers: { "x-goog-api-key": apiKey }
+  });
+  await throwIfNotOk(response, "gemini");
   const data = await response.json();
   return data.models.filter((m) => m.supportedGenerationMethods.includes("embedContent")).map((m) => m.name.replace("models/", "")).sort();
 }
@@ -1876,13 +2651,9 @@ async function buildModelError2(baseUrl, apiKey, originalError) {
   try {
     const models = await fetchAvailableModels2(baseUrl, apiKey);
     const list = models.length > 0 ? models.join(", ") : "none found";
-    return new Error(
-      `Gemini embedding failed: ${originalError}. Available embedding models: ${list}`
-    );
+    return embeddingError("Gemini", `${originalError}. Available embedding models: ${list}`);
   } catch (fetchError) {
-    return new Error(
-      `Gemini embedding failed: ${originalError}. Could not fetch available models: ${fetchError.message}`
-    );
+    return embeddingError("Gemini", `${originalError}. Could not fetch available models`, fetchError);
   }
 }
 function geminiEmbedder(config) {
@@ -1893,10 +2664,13 @@ function geminiEmbedder(config) {
   } = config;
   return async (text) => {
     const response = await fetch(
-      `${baseUrl}/v1beta/models/${model}:embedContent?key=${apiKey}`,
+      `${baseUrl}/v1beta/models/${model}:embedContent`,
       {
         method: "POST",
-        headers: { "Content-Type": "application/json" },
+        headers: {
+          "Content-Type": "application/json",
+          "x-goog-api-key": apiKey
+        },
         body: JSON.stringify({
           model: `models/${model}`,
           content: { parts: [{ text }] }
@@ -1904,12 +2678,13 @@ function geminiEmbedder(config) {
       }
     );
     if (!response.ok) {
-      const errorBody = await response.json().catch(() => ({}));
-      const message = errorBody.error?.message ?? `HTTP ${response.status}`;
+      void response.body?.cancel().catch(() => {
+      });
+      const message = `HTTP ${response.status}`;
       throw await buildModelError2(baseUrl, apiKey, message);
     }
     const data = await response.json();
-    return data.embedding.values;
+    return requireEmbeddingVector(data.embedding?.values, "Gemini");
   };
 }
 
@@ -1917,7 +2692,7 @@ function geminiEmbedder(config) {
 async function fetchAvailableModels3(baseUrl) {
   const url = `${baseUrl}/api/tags`;
   const response = await fetch(url);
-  await throwIfNotOk(response, "ollama", url);
+  await throwIfNotOk(response, "ollama");
   const data = await response.json();
   return data.models.map((m) => m.name).filter((name) => name.includes("embed")).sort();
 }
@@ -1925,13 +2700,9 @@ async function buildModelError3(baseUrl, originalError) {
   try {
     const models = await fetchAvailableModels3(baseUrl);
     const list = models.length > 0 ? models.join(", ") : "none found";
-    return new Error(
-      `Ollama embedding failed: ${originalError}. Available embedding models: ${list}`
-    );
+    return embeddingError("Ollama", `${originalError}. Available embedding models: ${list}`);
   } catch (fetchError) {
-    return new Error(
-      `Ollama embedding failed: ${originalError}. Could not fetch available models: ${fetchError.message}`
-    );
+    return embeddingError("Ollama", `${originalError}. Could not fetch available models`, fetchError);
   }
 }
 function ollamaEmbedder(config) {
@@ -1943,12 +2714,14 @@ function ollamaEmbedder(config) {
       body: JSON.stringify({ model, input: text })
     });
     if (!response.ok) {
-      const errorBody = await response.json().catch(() => ({}));
-      const message = errorBody.error ?? `HTTP ${response.status}`;
+      void response.body?.cancel().catch(() => {
+      });
+      const message = `HTTP ${response.status}`;
       throw await buildModelError3(baseUrl, message);
     }
     const data = await response.json();
-    return data.embeddings[0];
+    const first = Array.isArray(data.embeddings) ? data.embeddings[0] : void 0;
+    return requireEmbeddingVector(first, "Ollama");
   };
 }
 async function fetchAvailableModels4(provider, baseUrl, apiKey) {
@@ -1956,7 +2729,7 @@ async function fetchAvailableModels4(provider, baseUrl, apiKey) {
   const response = await fetch(url, {
     headers: { "Authorization": `Bearer ${apiKey}` }
   });
-  await throwIfNotOk(response, provider, url);
+  await throwIfNotOk(response, provider);
   const data = await response.json();
   return data.data.map((m) => m.id).filter((id) => id.includes("embed")).sort();
 }
@@ -1964,13 +2737,9 @@ async function buildModelError4(provider, baseUrl, apiKey, originalError) {
   try {
     const models = await fetchAvailableModels4(provider, baseUrl, apiKey);
     const list = models.length > 0 ? models.join(", ") : "none found";
-    return new Error(
-      `${provider} embedding failed: ${originalError}. Available embedding models: ${list}`
-    );
+    return embeddingError(provider, `${originalError}. Available embedding models: ${list}`);
   } catch (fetchError) {
-    return new Error(
-      `${provider} embedding failed: ${originalError}. Could not fetch available models: ${fetchError.message}`
-    );
+    return embeddingError(provider, `${originalError}. Could not fetch available models`, fetchError);
   }
 }
 function createOpenAICompatibleEmbedder(provider, defaultBaseUrl) {
@@ -1993,12 +2762,14 @@ function createOpenAICompatibleEmbedder(provider, defaultBaseUrl) {
         body: JSON.stringify({ model, input: text })
       });
       if (!response.ok) {
-        const errorBody = await response.json().catch(() => ({}));
-        const message = errorBody.error?.message ?? `HTTP ${response.status}`;
+        void response.body?.cancel().catch(() => {
+        });
+        const message = `HTTP ${response.status}`;
         throw await buildModelError4(provider, baseUrl, apiKey, message);
       }
       const data = await response.json();
-      return data.data[0].embedding;
+      const embedding = data.data?.[0]?.embedding;
+      return requireEmbeddingVector(embedding, provider);
     };
   };
 }