@agentskit/adapters 0.13.12 → 0.13.16

package/dist/index.js

@@ -1,43 +1,206 @@
-export { createAdapter } from './chunk-6FPLWOVE.js';
-import { createStreamSource, parseAnthropicStream, parseGeminiStream, parseOllamaStream, toProviderMessages, parseOpenAIStream, openai } from './chunk-77QS3QRT.js';
-export { chunkText, fetchWithRetry, openai, simulateStream } from './chunk-77QS3QRT.js';
+export { createAdapter } from './chunk-627FHZZY.js';
+import { createStreamSource, parseAnthropicStream, parseGeminiStream, parseOllamaStream, toProviderMessages, parseOpenAIStream, openai, readSSELines } from './chunk-4KZTWGRB.js';
+export { chunkText, fetchWithRetry, openai, simulateStream } from './chunk-4KZTWGRB.js';
+import { raceAbort, isAbortError, adapterErrorChunk, abortableSleep, parseCompleteToolArgs } from './chunk-6CIB2QCH.js';
 import { ConfigError, ErrorCodes, AdapterError } from '@agentskit/core';
 
 // src/generic.ts
 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/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;
@@ -53,7 +216,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,
@@ -94,18 +257,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
           }
@@ -180,56 +350,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) {
@@ -240,7 +425,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 {
@@ -255,6 +441,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 {
@@ -428,6 +656,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();
@@ -445,10 +674,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;
         }
       }
@@ -456,6 +686,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) {
@@ -488,17 +722,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, {
@@ -507,7 +741,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)) {
@@ -515,8 +749,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: () => {
@@ -566,10 +801,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) => ({
@@ -625,7 +857,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,
@@ -644,6 +876,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;
@@ -673,7 +918,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") {
@@ -700,18 +948,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;
@@ -746,9 +994,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,
@@ -757,17 +1006,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: () => {
@@ -818,26 +1069,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();
         }
       };
     }
@@ -937,22 +1224,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 ConfigError({
+                const error = new ConfigError({
                   code: 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;
             }
           };
         }
@@ -1040,9 +1362,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);
   }
@@ -1081,10 +1411,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);
       };
@@ -1107,22 +1446,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 AdapterError({
-              code: 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 AdapterError({
+                code: 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" };
         }
       };
     }
@@ -1153,57 +1521,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 AdapterError({
+          const err = new AdapterError({
             code: 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 }
+          };
         }
       };
     }
@@ -1221,25 +1651,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();
         }
       };
     }
@@ -1262,22 +1715,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();
+        }
       };
     }
   };
@@ -1303,15 +1777,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 AdapterError({
+    code: ErrorCodes.AK_ADAPTER_STREAM_FAILED,
+    message: `${label} embedding failed: ${detail}`,
+    cause
+  });
+}
+function requireEmbeddingVector(value, label) {
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new AdapterError({
+      code: 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 AdapterError({
+        code: 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
@@ -1320,7 +1819,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();
 }
@@ -1328,13 +1827,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) {
@@ -1349,20 +1844,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();
 }
@@ -1370,13 +1869,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) {
@@ -1387,10 +1882,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 }] }
@@ -1398,12 +1896,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");
   };
 }
 
@@ -1411,7 +1910,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();
 }
@@ -1419,13 +1918,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) {
@@ -1437,12 +1932,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) {
@@ -1450,7 +1947,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();
 }
@@ -1458,13 +1955,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) {
@@ -1487,12 +1980,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);
     };
   };
 }