@agentskit/adapters 0.12.2 → 0.13.2

package/dist/index.js

@@ -1,28 +1,8 @@
+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';
 import { ConfigError, ErrorCodes, AdapterError } from '@agentskit/core';
 
-// src/createAdapter.ts
-function createAdapter(config) {
-  return {
-    createSource: (request) => ({
-      stream: async function* () {
-        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)
-          };
-        }
-      },
-      abort: () => {
-        config.abort?.();
-      }
-    })
-  };
-}
-
 // src/generic.ts
 function generic(config) {
   return {
@@ -58,429 +38,6 @@ function generic(config) {
   };
 }
 
-// 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* readSSELines(stream) {
-  const reader = stream.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() ?? "";
-      for (const line of lines) {
-        if (!line.startsWith("data: ")) continue;
-        const data = line.slice(6).trim();
-        if (data) yield data;
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-}
-async function* readNDJSONLines(stream) {
-  const reader = stream.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() ?? "";
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (trimmed) yield trimmed;
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-}
-async function* parseOpenAIStream(stream) {
-  const pendingToolCalls = /* @__PURE__ */ new Map();
-  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 || "{}" } };
-      }
-      pendingToolCalls.clear();
-      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 };
-      }
-      if (Array.isArray(delta?.tool_calls)) {
-        for (const toolCall of delta.tool_calls) {
-          const index = toolCall.index ?? 0;
-          const existing = pendingToolCalls.get(index);
-          if (toolCall?.function?.name) {
-            pendingToolCalls.set(index, {
-              id: toolCall.id ?? existing?.id ?? `tool-${index}-${Date.now()}`,
-              name: toolCall.function.name,
-              args: (existing?.args ?? "") + (toolCall.function.arguments ?? "")
-            });
-          } else if (existing && toolCall?.function?.arguments) {
-            existing.args += toolCall.function.arguments;
-          }
-        }
-      }
-      if (event.usage) {
-        yield {
-          type: "usage",
-          usage: {
-            promptTokens: event.usage.prompt_tokens ?? 0,
-            completionTokens: event.usage.completion_tokens ?? 0,
-            totalTokens: event.usage.total_tokens ?? 0
-          }
-        };
-      }
-    } catch {
-    }
-  }
-  for (const [, tc] of pendingToolCalls) {
-    yield { type: "tool_call", toolCall: { id: tc.id, name: tc.name, args: tc.args || "{}" } };
-  }
-  pendingToolCalls.clear();
-  yield { type: "done" };
-}
-async function* parseAnthropicStream(stream) {
-  const pendingToolCalls = /* @__PURE__ */ new Map();
-  for await (const data of readSSELines(stream)) {
-    if (data === "[DONE]") continue;
-    try {
-      const event = JSON.parse(data);
-      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") {
-        const index = event.index ?? 0;
-        const existing = pendingToolCalls.get(index);
-        if (existing) {
-          existing.args += event.delta.partial_json ?? "";
-        }
-      } 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,
-          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 || "{}"
-            }
-          };
-          pendingToolCalls.delete(index);
-        }
-      } else if (event.type === "message_delta" && event.usage) {
-        yield {
-          type: "usage",
-          usage: {
-            promptTokens: event.usage.input_tokens ?? 0,
-            completionTokens: event.usage.output_tokens ?? 0,
-            totalTokens: (event.usage.input_tokens ?? 0) + (event.usage.output_tokens ?? 0)
-          }
-        };
-      } else if (event.type === "message_start" && event.message?.usage) {
-        yield {
-          type: "usage",
-          usage: {
-            promptTokens: event.message.usage.input_tokens ?? 0,
-            completionTokens: 0,
-            totalTokens: event.message.usage.input_tokens ?? 0
-          }
-        };
-      } else if (event.type === "message_stop") {
-        for (const [, tc] of pendingToolCalls) {
-          yield { type: "tool_call", toolCall: { id: tc.id, name: tc.name, args: tc.args || "{}" } };
-        }
-        pendingToolCalls.clear();
-        yield { type: "done" };
-        return;
-      }
-    } catch {
-    }
-  }
-  for (const [, tc] of pendingToolCalls) {
-    yield { type: "tool_call", toolCall: { id: tc.id, name: tc.name, args: tc.args || "{}" } };
-  }
-  pendingToolCalls.clear();
-  yield { type: "done" };
-}
-async function* parseGeminiStream(stream) {
-  for await (const data of readSSELines(stream)) {
-    try {
-      const event = JSON.parse(data);
-      if (event.usageMetadata) {
-        yield {
-          type: "usage",
-          usage: {
-            promptTokens: event.usageMetadata.promptTokenCount ?? 0,
-            completionTokens: event.usageMetadata.candidatesTokenCount ?? 0,
-            totalTokens: event.usageMetadata.totalTokenCount ?? 0
-          }
-        };
-      }
-      const parts = event.candidates?.[0]?.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;
-          yield {
-            type: "tool_call",
-            toolCall: {
-              id: fc.id ?? `${fc.name}-${Date.now()}`,
-              name: fc.name,
-              args: JSON.stringify(fc.args ?? {})
-            }
-          };
-        }
-      }
-    } catch {
-    }
-  }
-  yield { type: "done" };
-}
-async function* parseOllamaStream(stream) {
-  for await (const data of readNDJSONLines(stream)) {
-    try {
-      const event = JSON.parse(data);
-      if (event.message?.content) {
-        yield { type: "text", content: event.message.content };
-      }
-      if (Array.isArray(event.message?.tool_calls)) {
-        for (const tc of event.message.tool_calls) {
-          if (tc?.function?.name) {
-            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 ?? {})
-              }
-            };
-          }
-        }
-      }
-      if (event.done) {
-        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;
-          yield {
-            type: "usage",
-            usage: {
-              promptTokens,
-              completionTokens,
-              totalTokens: promptTokens + completionTokens
-            }
-          };
-        }
-        yield { type: "done" };
-        return;
-      }
-    } catch {
-    }
-  }
-  yield { type: "done" };
-}
-var DEFAULT_RETRY = {
-  maxAttempts: 3,
-  baseDelayMs: 500,
-  maxDelayMs: 8e3,
-  jitter: true,
-  retryOn: ({ error, response }) => {
-    if (response) {
-      return [408, 429, 500, 502, 503, 504].includes(response.status);
-    }
-    if (error instanceof DOMException && error.name === "AbortError") return false;
-    return true;
-  }
-};
-function defaultSleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
-}
-function computeDelay(attempt, opts) {
-  const exp = Math.min(opts.maxDelayMs, opts.baseDelayMs * Math.pow(2, attempt - 1));
-  if (!opts.jitter) return exp;
-  return Math.floor(Math.random() * exp);
-}
-function parseRetryAfter(value) {
-  if (!value) return void 0;
-  const n = Number(value);
-  if (!Number.isNaN(n)) return n * 1e3;
-  const date = Date.parse(value);
-  if (!Number.isNaN(date)) return Math.max(0, date - Date.now());
-  return void 0;
-}
-async function fetchWithRetry(doFetch, signal, retryOpt = {}) {
-  const opts = {
-    ...DEFAULT_RETRY,
-    ...retryOpt
-  };
-  const sleep = retryOpt.sleep ?? defaultSleep;
-  let lastError;
-  for (let attempt = 1; attempt <= opts.maxAttempts; attempt++) {
-    if (signal.aborted) throw new DOMException("Aborted", "AbortError");
-    try {
-      const response = await doFetch(signal);
-      if (response.ok) return response;
-      if (attempt >= opts.maxAttempts || !opts.retryOn({ response, attempt })) {
-        return response;
-      }
-      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(() => {
-      });
-    } catch (err) {
-      lastError = err;
-      if (err instanceof DOMException && err.name === "AbortError") 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);
-    }
-  }
-  throw lastError ?? new Error("fetchWithRetry: exhausted attempts");
-}
-function createStreamSource(doFetch, parse, errorLabel, retry) {
-  let abortController = new AbortController();
-  return {
-    stream: async function* () {
-      try {
-        const response = await fetchWithRetry(doFetch, abortController.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 = [];
-  let i = 0;
-  while (i < text.length) {
-    let end = Math.min(text.length, i + targetSize);
-    if (end < text.length) {
-      const nextSpace = text.indexOf(" ", end);
-      if (nextSpace !== -1 && nextSpace - end <= 8) end = nextSpace + 1;
-    }
-    out.push(text.slice(i, end));
-    i = end;
-  }
-  return out;
-}
-function simulateStream(doFetch, extractText, errorLabel, options = {}) {
-  const { chunkSize = 32, delayMs = 8, retry } = options;
-  let abortController = new AbortController();
-  return {
-    stream: async function* () {
-      try {
-        const response = await fetchWithRetry(doFetch, abortController.signal, retry ?? {});
-        if (!response.ok) {
-          yield { type: "error", content: `${errorLabel} error: ${response.status}` };
-          return;
-        }
-        const text = await extractText(response);
-        const chunks = chunkText(text, chunkSize);
-        for (const chunk of chunks) {
-          if (abortController === null) return;
-          if (delayMs > 0) {
-            await new Promise((resolve2, reject) => {
-              const timer = setTimeout(resolve2, delayMs);
-              abortController?.signal.addEventListener(
-                "abort",
-                () => {
-                  clearTimeout(timer);
-                  reject(new DOMException("Aborted", "AbortError"));
-                },
-                { once: true }
-              );
-            });
-          }
-          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)
-        };
-      }
-    },
-    abort: () => {
-      abortController?.abort();
-      abortController = null;
-    }
-  };
-}
-
 // src/anthropic.ts
 function anthropic(config) {
   const { apiKey, model, baseUrl = "https://api.anthropic.com", maxTokens = 4096, retry } = config;
@@ -524,55 +81,6 @@ function anthropic(config) {
   };
 }
 
-// src/openai.ts
-function openai(config) {
-  const { apiKey, model, baseUrl = "https://api.openai.com", retry } = config;
-  const includeUsage = config.includeUsage ?? baseUrl.startsWith("https://api.openai.com");
-  return {
-    capabilities: {
-      streaming: true,
-      tools: true,
-      // o1 / o3 models emit reasoning; older models don't. Accurate per-model
-      // detection would need a model registry; 'true' is the safer default here.
-      reasoning: model.startsWith("o1") || model.startsWith("o3"),
-      multiModal: model.startsWith("gpt-4") || model.startsWith("o"),
-      usage: true
-    },
-    createSource: (request) => {
-      const body = {
-        model,
-        messages: toProviderMessages(request.messages),
-        tools: request.context?.tools?.map((tool) => ({
-          type: "function",
-          function: {
-            name: tool.name,
-            description: tool.description,
-            parameters: tool.schema
-          }
-        })),
-        temperature: request.context?.temperature,
-        max_tokens: request.context?.maxTokens,
-        stream: true
-      };
-      if (includeUsage) body.stream_options = { include_usage: true };
-      return createStreamSource(
-        (signal) => fetch(`${baseUrl}/v1/chat/completions`, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            "Authorization": `Bearer ${apiKey}`
-          },
-          body: JSON.stringify(body),
-          signal
-        }),
-        parseOpenAIStream,
-        "OpenAI API",
-        retry
-      );
-    }
-  };
-}
-
 // src/gemini.ts
 function gemini(config) {
   const { apiKey, model, baseUrl = "https://generativelanguage.googleapis.com", retry } = config;
@@ -584,15 +92,13 @@ function gemini(config) {
       usage: true
     },
     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: request.messages.find((message) => message.role === "system") ? {
-          role: "system",
-          parts: [{ text: request.messages.find((message) => message.role === "system").content }]
-        } : void 0
+        systemInstruction: systemMessage ? { role: "system", parts: [{ text: systemMessage.content }] } : void 0
       };
       return createStreamSource(
         (signal) => fetch(
@@ -1058,15 +564,13 @@ function vertex(config) {
       reasoning: model.includes("pro")
     },
     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: request.messages.find((message) => message.role === "system") ? {
-          role: "system",
-          parts: [{ text: request.messages.find((message) => message.role === "system").content }]
-        } : void 0,
+        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,
@@ -1362,8 +866,28 @@ function pickSyncPolicy(pool, policy) {
     const c = pool.reduce((best, x) => (x.latencyMs ?? Infinity) < (best.latencyMs ?? Infinity) ? x : best, pool[0]);
     return { c, reason: "fastest" };
   }
+  if (policy === "greenest") {
+    const c = pool.reduce((best, x) => (x.gCO2PerKtok ?? Infinity) < (best.gCO2PerKtok ?? Infinity) ? x : best, pool[0]);
+    return { c, reason: "greenest" };
+  }
+  if (policy === "green-cost") {
+    const carbonValues = pool.map((p) => p.gCO2PerKtok).filter((v) => v != null);
+    const costValues = pool.map((p) => p.cost).filter((v) => v != null);
+    const maxC = Math.max(1, ...carbonValues);
+    const maxCost = Math.max(1, ...costValues);
+    const score = (x) => {
+      const carbon = (x.gCO2PerKtok ?? maxC / 2) / maxC;
+      const cost = (x.cost ?? maxCost / 2) / maxCost;
+      return carbon + cost;
+    };
+    const c = pool.reduce((best, x) => score(x) < score(best) ? x : best, pool[0]);
+    return { c, reason: "green-cost" };
+  }
   return { c: pool[0], reason: "capability-match" };
 }
+function matchesRegion(candidate, region) {
+  return region === void 0 || candidate.region === region;
+}
 function createRouter(options) {
   const { candidates } = options;
   if (candidates.length === 0) {
@@ -1377,22 +901,31 @@ function createRouter(options) {
   return {
     createSource: (request) => {
       const need = requireCapabilities(request);
+      const region = options.regionOf?.(request) ?? options.region;
       const capable = candidates.filter((c2) => matchesCapabilities(need, c2.capabilities ?? c2.adapter.capabilities));
+      const eligible = capable.filter((c2) => matchesRegion(c2, region));
+      if (capable.length > 0 && eligible.length === 0 && region !== void 0) {
+        throw new ConfigError({
+          code: ErrorCodes.AK_CONFIG_INVALID,
+          message: `no candidate satisfies required region: ${region}`,
+          hint: "Set candidate.region to the requested data-residency region, or remove the router region requirement."
+        });
+      }
       const classified = options.classify?.(request);
       if (typeof classified === "string") {
-        const c2 = capable.find((x) => x.id === classified);
+        const c2 = eligible.find((x) => x.id === classified);
         if (c2) {
-          options.onRoute?.({ id: c2.id, reason: "classify:id", request });
+          options.onRoute?.({ id: c2.id, reason: region ? `classify:id:${region}` : "classify:id", request });
           return c2.adapter.createSource(request);
         }
       }
-      let pool = capable;
+      let pool = eligible;
       let pickedBy;
       if (Array.isArray(classified) && classified.length > 0) {
-        const filtered = capable.filter((c2) => c2.tags && classified.every((t) => c2.tags.includes(t)));
+        const filtered = eligible.filter((c2) => c2.tags && classified.every((t) => c2.tags.includes(t)));
         if (filtered.length > 0) {
           pool = filtered;
-          pickedBy = "classify:tags";
+          pickedBy = region ? `classify:tags:${region}` : "classify:tags";
         }
       }
       if (pool.length === 0) {
@@ -1440,6 +973,57 @@ function createRouter(options) {
     }
   };
 }
+
+// src/carbon.ts
+var DEFAULT_CARBON_TABLE = {
+  // Anthropic — primarily AWS us-east-* / eu-west-* via Bedrock-style fronts.
+  "anthropic:us-east-1": 0.42,
+  "anthropic:us-west-2": 0.18,
+  "anthropic:eu-central-1": 0.32,
+  "anthropic:eu-west-1": 0.27,
+  // OpenAI — Azure East US / West Europe / Sweden Central.
+  "openai:eastus": 0.4,
+  "openai:westus3": 0.19,
+  "openai:swedencentral": 0.04,
+  "openai:westeurope": 0.28,
+  // Google (Vertex / Gemini) — typically reports lowest PUE.
+  "google:us-central1": 0.34,
+  "google:us-west1": 0.16,
+  "google:europe-west1": 0.21,
+  "google:europe-north1": 0.05,
+  // AWS Bedrock direct.
+  "aws:us-east-1": 0.42,
+  "aws:us-west-2": 0.18,
+  "aws:eu-west-1": 0.27,
+  // Local / on-device — only the device's grid matters.
+  "ollama:local": 0.3,
+  "webllm:browser": 0.3,
+  "lmstudio:local": 0.3,
+  // Self-hosted / community.
+  "groq:us-east-1": 0.4,
+  "fireworks:us-west-2": 0.18,
+  "together:us-east-1": 0.42,
+  "cerebras:us-west-2": 0.18
+};
+function defaultKey(candidate) {
+  if (!candidate.region) return void 0;
+  const provider = candidate.id.split(/[-:]/)[0];
+  return `${provider}:${candidate.region}`;
+}
+function applyCarbonTable(candidates, options = {}) {
+  const table = options.table ?? DEFAULT_CARBON_TABLE;
+  const keyFor = options.keyFor ?? defaultKey;
+  return candidates.map((c) => {
+    if (c.gCO2PerKtok != null) return c;
+    const key = keyFor(c);
+    const value = key ? table[key] : void 0;
+    return { ...c, gCO2PerKtok: value ?? options.fallback };
+  });
+}
+function estimateCO2Grams(gCO2PerKtok, tokens) {
+  if (gCO2PerKtok == null) return 0;
+  return tokens / 1e3 * gCO2PerKtok;
+}
 async function drain(source, timeoutMs) {
   const chunks = [];
   let text = "";
@@ -1578,26 +1162,36 @@ function createFallbackAdapter(candidates, options = {}) {
             }
             active = source;
             const iter = source.stream()[Symbol.asyncIterator]();
-            let first;
+            let firstReal;
+            let branchError;
             try {
-              first = await iter.next();
+              while (true) {
+                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(
+                    `candidate ${candidate.id}: ${r.value.content ?? "stream error"}`
+                  );
+                  break;
+                }
+                firstReal = r.value;
+                break;
+              }
             } catch (err) {
-              const error = err instanceof Error ? err : new Error(String(err));
-              errors.push({ id: candidate.id, error });
-              options.onFallback?.({ id: candidate.id, index: i, error });
-              if (options.shouldRetry && !options.shouldRetry(error, i)) throw error;
-              active = void 0;
-              continue;
+              branchError = err instanceof Error ? err : new Error(String(err));
             }
-            if (first.done) {
-              const error = new Error(`candidate ${candidate.id} emitted no chunks`);
+            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;
               active = void 0;
               continue;
             }
-            yield first.value;
+            yield firstReal;
             while (true) {
               const next = await iter.next();
               if (next.done) return;
@@ -1710,16 +1304,23 @@ function replayAdapter(fixture) {
   });
 }
 
+// src/embedders/shared.ts
+var ERROR_BODY_PREVIEW_CHARS = 200;
+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)}`
+  );
+}
+
 // src/embedders/openai.ts
 async function fetchAvailableModels(baseUrl, apiKey) {
   const url = `${baseUrl}/v1/models`;
   const response = await fetch(url, {
     headers: { "Authorization": `Bearer ${apiKey}` }
   });
-  if (!response.ok) {
-    const body = await response.text().catch(() => "");
-    throw new Error(`HTTP ${response.status} from ${url}: ${body.slice(0, 200)}`);
-  }
+  await throwIfNotOk(response, "openai", url);
   const data = await response.json();
   return data.data.map((m) => m.id).filter((id) => id.includes("embed")).sort();
 }
@@ -1761,10 +1362,7 @@ function openaiEmbedder(config) {
 async function fetchAvailableModels2(baseUrl, apiKey) {
   const url = `${baseUrl}/v1beta/models?key=${apiKey}`;
   const response = await fetch(url);
-  if (!response.ok) {
-    const body = await response.text().catch(() => "");
-    throw new Error(`HTTP ${response.status} from gemini ${baseUrl}/v1beta/models: ${body.slice(0, 200)}`);
-  }
+  await throwIfNotOk(response, "gemini", `${baseUrl}/v1beta/models`);
   const data = await response.json();
   return data.models.filter((m) => m.supportedGenerationMethods.includes("embedContent")).map((m) => m.name.replace("models/", "")).sort();
 }
@@ -1813,10 +1411,7 @@ function geminiEmbedder(config) {
 async function fetchAvailableModels3(baseUrl) {
   const url = `${baseUrl}/api/tags`;
   const response = await fetch(url);
-  if (!response.ok) {
-    const body = await response.text().catch(() => "");
-    throw new Error(`HTTP ${response.status} from ollama ${url}: ${body.slice(0, 200)}`);
-  }
+  await throwIfNotOk(response, "ollama", url);
   const data = await response.json();
   return data.models.map((m) => m.name).filter((name) => name.includes("embed")).sort();
 }
@@ -1850,21 +1445,18 @@ function ollamaEmbedder(config) {
     return data.embeddings[0];
   };
 }
-async function fetchAvailableModels4(baseUrl, apiKey) {
+async function fetchAvailableModels4(provider, baseUrl, apiKey) {
   const url = `${baseUrl}/v1/models`;
   const response = await fetch(url, {
     headers: { "Authorization": `Bearer ${apiKey}` }
   });
-  if (!response.ok) {
-    const body = await response.text().catch(() => "");
-    throw new Error(`HTTP ${response.status} from ${url}: ${body.slice(0, 200)}`);
-  }
+  await throwIfNotOk(response, provider, url);
   const data = await response.json();
   return data.data.map((m) => m.id).filter((id) => id.includes("embed")).sort();
 }
 async function buildModelError4(provider, baseUrl, apiKey, originalError) {
   try {
-    const models = await fetchAvailableModels4(baseUrl, apiKey);
+    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}`
@@ -1913,7 +1505,91 @@ var grokEmbedder = createOpenAICompatibleEmbedder("Grok", "https://api.x.ai");
 
 // src/embedders/kimi.ts
 var kimiEmbedder = createOpenAICompatibleEmbedder("Kimi", "https://api.moonshot.ai");
+var DEFAULT_DEPRECATION_TABLE = [
+  // OpenAI
+  { provider: "openai", model: "gpt-3.5-turbo-0301", successor: "gpt-4o-mini", sunsetOn: "2024-09-13" },
+  { provider: "openai", model: "gpt-3.5-turbo-0613", successor: "gpt-4o-mini", sunsetOn: "2024-09-13" },
+  { provider: "openai", model: "gpt-4-0314", successor: "gpt-4o", sunsetOn: "2024-06-13" },
+  { provider: "openai", model: "gpt-4-32k", successor: "gpt-4o", sunsetOn: "2024-06-06" },
+  { provider: "openai", model: "text-davinci-003", successor: "gpt-4o-mini", sunsetOn: "2024-01-04" },
+  // Anthropic
+  { provider: "anthropic", model: "claude-2.0", successor: "claude-3-5-sonnet-latest", sunsetOn: "2025-07-21" },
+  { provider: "anthropic", model: "claude-2.1", successor: "claude-3-5-sonnet-latest", sunsetOn: "2025-07-21" },
+  { provider: "anthropic", model: "claude-instant-1.2", successor: "claude-3-5-haiku-latest", sunsetOn: "2024-07-22" },
+  { provider: "anthropic", model: "claude-3-sonnet-20240229", successor: "claude-3-5-sonnet-latest", sunsetOn: "2025-07-21" },
+  // Google
+  { provider: "google", model: "gemini-1.0-pro", successor: "gemini-1.5-pro", sunsetOn: "2025-02-15" },
+  { provider: "google", model: "gemini-pro-vision", successor: "gemini-1.5-pro", sunsetOn: "2024-07-12" }
+];
+function resolveModel(input, policy) {
+  const table = policy.table ?? DEFAULT_DEPRECATION_TABLE;
+  const hit = table.find((d) => d.provider === input.provider && d.model === input.model);
+  if (!hit) return { model: input.model, remapped: false };
+  const log = policy.logger ?? ((msg) => console.warn(msg));
+  const sunset = hit.sunsetOn ? ` (sunset ${hit.sunsetOn})` : "";
+  const successor = hit.successor ? ` Suggested successor: ${hit.successor}.` : "";
+  const base = `[agentskit] Model "${input.provider}:${input.model}" is deprecated${sunset}.${successor}`;
+  switch (policy.onDeprecation) {
+    case "fail":
+      throw new ConfigError({
+        code: ErrorCodes.AK_CONFIG_INVALID,
+        message: base,
+        hint: hit.successor ? `Set model to "${hit.successor}".` : "Pick a supported model from the provider."
+      });
+    case "remap": {
+      if (!hit.successor) {
+        throw new ConfigError({
+          code: ErrorCodes.AK_CONFIG_INVALID,
+          message: `${base} No successor available \u2014 cannot remap.`
+        });
+      }
+      log(`${base} Auto-remapping to "${hit.successor}".`);
+      return { model: hit.successor, remapped: true, deprecation: hit };
+    }
+    case "warn":
+    default:
+      log(base);
+      return { model: input.model, remapped: false, deprecation: hit };
+  }
+}
+function withDeprecationPolicy(factory, options) {
+  resolveModel({ provider: options.provider, model: options.model }, options);
+  return factory;
+}
+
+// src/credential-rotation.ts
+function createRotatingCredentials(initial, options) {
+  let value = initial;
+  const handlers = /* @__PURE__ */ new Set();
+  return {
+    current: () => value,
+    rotate: async (next) => {
+      value = next;
+      const event = {
+        rotatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        id: options.id,
+        fingerprint: next.slice(-4)
+      };
+      for (const h of handlers) h(event);
+      return next;
+    },
+    onRotate: (handler) => {
+      handlers.add(handler);
+      return () => handlers.delete(handler);
+    }
+  };
+}
+async function refreshCredentials(adapter, next, options) {
+  const log = options?.logger ?? ((msg) => console.log(msg));
+  if (adapter && typeof adapter === "object" && "refreshCredentials" in adapter && typeof adapter.refreshCredentials === "function") {
+    await adapter.refreshCredentials(next);
+    log(`[agentskit] credentials refreshed${options?.id ? ` (${options.id})` : ""}`);
+    return true;
+  }
+  log(`[agentskit] adapter does not support credential rotation; restart required${options?.id ? ` (${options.id})` : ""}`);
+  return false;
+}
 
-export { anthropic, azureOpenAI, azureOpenAIAdapter, bail, bailAdapter, bedrock, bedrockAdapter, cerebras, cerebrasAdapter, chunkText, cohere, cohereAdapter, createAdapter, createEnsembleAdapter, createFallbackAdapter, createOpenAICompatibleEmbedder, createRouter, deepseek, deepseekEmbedder, fetchWithRetry, fireworks, gemini, geminiEmbedder, generic, grok, grokEmbedder, groq, groqAdapter, huggingface, inMemorySink, kimi, kimiEmbedder, langchain, langgraph, llamacpp, lmstudio, mistral, mockAdapter, ollama, ollamaEmbedder, openai, openaiEmbedder, openrouter, qwen, recordingAdapter, replayAdapter, replicate, replicateAdapter, simulateStream, together, vercelAI, vertex, vertexAdapter, vllm, webllm, webllmAdapter };
+export { DEFAULT_CARBON_TABLE, DEFAULT_DEPRECATION_TABLE, anthropic, applyCarbonTable, azureOpenAI, azureOpenAIAdapter, bail, bailAdapter, bedrock, bedrockAdapter, cerebras, cerebrasAdapter, cohere, cohereAdapter, createEnsembleAdapter, createFallbackAdapter, createOpenAICompatibleEmbedder, createRotatingCredentials, createRouter, deepseek, deepseekEmbedder, estimateCO2Grams, fireworks, gemini, geminiEmbedder, generic, grok, grokEmbedder, groq, groqAdapter, huggingface, inMemorySink, kimi, kimiEmbedder, langchain, langgraph, llamacpp, lmstudio, mistral, mockAdapter, ollama, ollamaEmbedder, openaiEmbedder, openrouter, qwen, recordingAdapter, refreshCredentials, replayAdapter, replicate, replicateAdapter, resolveModel, together, vercelAI, vertex, vertexAdapter, vllm, webllm, webllmAdapter, withDeprecationPolicy };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map