@agentskit/adapters 0.12.0 → 0.13.0

package/dist/createAdapter.d.cts

@@ -0,0 +1,2 @@
+import '@agentskit/core';
+export { c as createAdapter } from './createAdapter-Dfnf3Iio.cjs';

package/dist/createAdapter.d.ts

@@ -0,0 +1,2 @@
+import '@agentskit/core';
+export { c as createAdapter } from './createAdapter-Dfnf3Iio.js';

package/dist/createAdapter.js

@@ -0,0 +1,3 @@
+export { createAdapter } from './chunk-6FPLWOVE.js';
+//# sourceMappingURL=createAdapter.js.map
+//# sourceMappingURL=createAdapter.js.map

package/dist/createAdapter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"createAdapter.js"}

package/dist/index.cjs

@@ -1,5 +1,7 @@
 'use strict';
 
+var core = require('@agentskit/core');
+
 // src/createAdapter.ts
 function createAdapter(config) {
   return {
@@ -399,8 +401,10 @@ 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, abortController.signal, retry ?? {});
+        const response = await fetchWithRetry(doFetch, controller.signal, retry ?? {});
         if (!response.ok || !response.body) {
           yield { type: "error", content: `${errorLabel} error: ${response.status}` };
           return;
@@ -440,8 +444,10 @@ function simulateStream(doFetch, extractText, errorLabel, options = {}) {
   let abortController = new AbortController();
   return {
     stream: async function* () {
+      const controller = abortController;
+      if (!controller) return;
       try {
-        const response = await fetchWithRetry(doFetch, abortController.signal, retry ?? {});
+        const response = await fetchWithRetry(doFetch, controller.signal, retry ?? {});
         if (!response.ok) {
           yield { type: "error", content: `${errorLabel} error: ${response.status}` };
           return;
@@ -453,7 +459,7 @@ function simulateStream(doFetch, extractText, errorLabel, options = {}) {
           if (delayMs > 0) {
             await new Promise((resolve2, reject) => {
               const timer = setTimeout(resolve2, delayMs);
-              abortController?.signal.addEventListener(
+              controller.signal.addEventListener(
                 "abort",
                 () => {
                   clearTimeout(timer);
@@ -527,7 +533,14 @@ 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");
+  const isCanonicalOpenAI = (() => {
+    try {
+      return new URL(baseUrl).host === "api.openai.com";
+    } catch {
+      return false;
+    }
+  })();
+  const includeUsage = config.includeUsage ?? isCanonicalOpenAI;
   return {
     capabilities: {
       streaming: true,
@@ -584,15 +597,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 +1069,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,
@@ -1096,8 +1105,6 @@ function vertex(config) {
   };
 }
 var vertexAdapter = vertex;
-
-// src/bedrock.ts
 var cachedSdk = null;
 async function loadSdk() {
   if (!cachedSdk) {
@@ -1109,9 +1116,11 @@ async function loadSdk() {
           moduleId
         );
       } catch {
-        throw new Error(
-          "Install @aws-sdk/client-bedrock-runtime to use the bedrock adapter: npm install @aws-sdk/client-bedrock-runtime"
-        );
+        throw new core.AdapterError({
+          code: core.ErrorCodes.AK_ADAPTER_MISSING,
+          message: "Install @aws-sdk/client-bedrock-runtime to use the bedrock adapter: npm install @aws-sdk/client-bedrock-runtime",
+          hint: "bedrock depends on the optional peer @aws-sdk/client-bedrock-runtime."
+        });
       }
     })();
   }
@@ -1212,9 +1221,11 @@ async function* parseAnthropicBedrockEvents(events) {
 function bedrock(config) {
   const { model, region, maxTokens = 4096 } = config;
   if (!isAnthropicModel(model)) {
-    throw new Error(
-      `bedrock: model "${model}" is not supported in v1. Only anthropic.* models are wired up; Titan + others are tracked as a follow-up.`
-    );
+    throw new core.ConfigError({
+      code: core.ErrorCodes.AK_CONFIG_INVALID,
+      message: `bedrock: model "${model}" is not supported in v1. Only anthropic.* models are wired up; Titan + others are tracked as a follow-up.`,
+      hint: 'Pass an anthropic.* model id like "anthropic.claude-3-5-sonnet-20241022-v2:0".'
+    });
   }
   let clientPromise = null;
   const getClient = async () => {
@@ -1273,8 +1284,6 @@ function bedrock(config) {
   };
 }
 var bedrockAdapter = bedrock;
-
-// src/webllm.ts
 var cachedSdk2 = null;
 async function loadSdk2() {
   if (!cachedSdk2) {
@@ -1286,7 +1295,11 @@ async function loadSdk2() {
           moduleId
         );
       } catch {
-        throw new Error("Install @mlc-ai/web-llm to use the webllm adapter: npm install @mlc-ai/web-llm");
+        throw new core.AdapterError({
+          code: core.ErrorCodes.AK_ADAPTER_MISSING,
+          message: "Install @mlc-ai/web-llm to use the webllm adapter: npm install @mlc-ai/web-llm",
+          hint: "webllm is browser-only and depends on the optional peer @mlc-ai/web-llm."
+        });
       }
     })();
   }
@@ -1336,8 +1349,6 @@ function webllm(config) {
   };
 }
 var webllmAdapter = webllm;
-
-// src/router.ts
 function requireCapabilities(request) {
   const needs = {};
   if (request.context?.tools && request.context.tools.length > 0) needs.tools = true;
@@ -1360,34 +1371,75 @@ 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) throw new Error("createRouter requires at least one candidate");
+  if (candidates.length === 0) {
+    throw new core.ConfigError({
+      code: core.ErrorCodes.AK_CONFIG_INVALID,
+      message: "createRouter requires at least one candidate",
+      hint: "Pass at least one candidate, e.g. createRouter({ candidates: [{ id, adapter, capabilities }] })."
+    });
+  }
   const policy = options.policy ?? "cheapest";
   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 core.ConfigError({
+          code: core.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) throw new Error("no candidate satisfies the request");
+      if (pool.length === 0) {
+        throw new core.AdapterError({
+          code: core.ErrorCodes.AK_ADAPTER_STREAM_FAILED,
+          message: "no candidate satisfies the request",
+          hint: "Ensure at least one candidate declares the required capabilities (tools, json, etc.)."
+        });
+      }
       if (typeof policy === "function") {
         const maybe = policy({ request, candidates: pool });
         if (maybe instanceof Promise) {
@@ -1397,14 +1449,26 @@ function createRouter(options) {
             stream: async function* () {
               const id = await maybe;
               const c3 = pool.find((x) => x.id === id);
-              if (!c3) throw new Error(`policy returned unknown id: ${id}`);
+              if (!c3) {
+                throw 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."
+                });
+              }
               options.onRoute?.({ id: c3.id, reason: pickedBy ?? "custom policy", request });
               for await (const chunk of c3.adapter.createSource(request).stream()) yield chunk;
             }
           };
         }
         const c2 = pool.find((x) => x.id === maybe);
-        if (!c2) throw new Error(`policy returned unknown id: ${maybe}`);
+        if (!c2) {
+          throw new core.ConfigError({
+            code: core.ErrorCodes.AK_CONFIG_INVALID,
+            message: `policy returned unknown id: ${maybe}`,
+            hint: "Custom policy functions must return one of the candidate ids."
+          });
+        }
         options.onRoute?.({ id: c2.id, reason: pickedBy ?? "custom policy", request });
         return c2.adapter.createSource(request);
       }
@@ -1415,7 +1479,56 @@ function createRouter(options) {
   };
 }
 
-// src/ensemble.ts
+// 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 = "";
@@ -1460,7 +1573,11 @@ function majorityVote(branches, candidates) {
 }
 function createEnsembleAdapter(options) {
   if (options.candidates.length === 0) {
-    throw new Error("createEnsembleAdapter requires at least one candidate");
+    throw new core.ConfigError({
+      code: core.ErrorCodes.AK_CONFIG_INVALID,
+      message: "createEnsembleAdapter requires at least one candidate",
+      hint: "Pass at least one candidate, e.g. createEnsembleAdapter({ candidates: [{ id, adapter }] })."
+    });
   }
   const aggregate = options.aggregate ?? "majority-vote";
   return {
@@ -1500,7 +1617,14 @@ function createEnsembleAdapter(options) {
           if (aborted) return;
           const text = await finalText(branches);
           if (!text && branches.every((b) => b.error)) {
-            throw new Error("all ensemble branches failed");
+            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;
           }
           yield { type: "text", content: text, metadata: { ensemble: branches.map((b) => ({ id: b.id, bytes: b.text.length, error: b.error?.message })) } };
           yield { type: "done" };
@@ -1509,11 +1633,13 @@ function createEnsembleAdapter(options) {
     }
   };
 }
-
-// src/fallback.ts
 function createFallbackAdapter(candidates, options = {}) {
   if (candidates.length === 0) {
-    throw new Error("createFallbackAdapter requires at least one candidate");
+    throw new core.ConfigError({
+      code: core.ErrorCodes.AK_CONFIG_INVALID,
+      message: "createFallbackAdapter requires at least one candidate",
+      hint: 'Pass at least one candidate, e.g. createFallbackAdapter([{ id: "primary", adapter }]).'
+    });
   }
   return {
     createSource: (request) => {
@@ -1568,14 +1694,16 @@ function createFallbackAdapter(candidates, options = {}) {
             }
           }
           const summary = errors.map((e) => `${e.id}: ${e.error.message}`).join("; ");
-          throw new Error(`all fallback candidates failed (${summary})`);
+          throw 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."
+          });
         }
       };
     }
   };
 }
-
-// src/mock.ts
 function mockAdapter(options) {
   const { response, delayMs = 0, history } = options;
   let callIndex = 0;
@@ -1660,21 +1788,34 @@ function inMemorySink() {
 }
 function replayAdapter(fixture) {
   if (fixture.length === 0) {
-    throw new Error("replayAdapter: fixture is empty");
+    throw new core.ConfigError({
+      code: core.ErrorCodes.AK_CONFIG_INVALID,
+      message: "replayAdapter: fixture is empty",
+      hint: "Pass a non-empty fixture; record one with recordingAdapter() first."
+    });
   }
   return mockAdapter({
     response: fixture.map((turn) => turn.chunks)
   });
 }
 
+// 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 response = await fetch(`${baseUrl}/v1/models`, {
+  const url = `${baseUrl}/v1/models`;
+  const response = await fetch(url, {
     headers: { "Authorization": `Bearer ${apiKey}` }
   });
-  if (!response.ok) {
-    throw new Error(`HTTP ${response.status}`);
-  }
+  await throwIfNotOk(response, "openai", url);
   const data = await response.json();
   return data.data.map((m) => m.id).filter((id) => id.includes("embed")).sort();
 }
@@ -1714,10 +1855,9 @@ function openaiEmbedder(config) {
 
 // src/embedders/gemini.ts
 async function fetchAvailableModels2(baseUrl, apiKey) {
-  const response = await fetch(`${baseUrl}/v1beta/models?key=${apiKey}`);
-  if (!response.ok) {
-    throw new Error(`HTTP ${response.status}`);
-  }
+  const url = `${baseUrl}/v1beta/models?key=${apiKey}`;
+  const response = await fetch(url);
+  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();
 }
@@ -1764,10 +1904,9 @@ function geminiEmbedder(config) {
 
 // src/embedders/ollama.ts
 async function fetchAvailableModels3(baseUrl) {
-  const response = await fetch(`${baseUrl}/api/tags`);
-  if (!response.ok) {
-    throw new Error(`HTTP ${response.status}`);
-  }
+  const url = `${baseUrl}/api/tags`;
+  const response = await fetch(url);
+  await throwIfNotOk(response, "ollama", url);
   const data = await response.json();
   return data.models.map((m) => m.name).filter((name) => name.includes("embed")).sort();
 }
@@ -1801,21 +1940,18 @@ function ollamaEmbedder(config) {
     return data.embeddings[0];
   };
 }
-
-// src/embedders/openai-compatible.ts
-async function fetchAvailableModels4(baseUrl, apiKey) {
-  const response = await fetch(`${baseUrl}/v1/models`, {
+async function fetchAvailableModels4(provider, baseUrl, apiKey) {
+  const url = `${baseUrl}/v1/models`;
+  const response = await fetch(url, {
     headers: { "Authorization": `Bearer ${apiKey}` }
   });
-  if (!response.ok) {
-    throw new Error(`HTTP ${response.status}`);
-  }
+  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}`
@@ -1829,7 +1965,11 @@ async function buildModelError4(provider, baseUrl, apiKey, originalError) {
 function createOpenAICompatibleEmbedder(provider, defaultBaseUrl) {
   return function embedder(config) {
     if (!config.model) {
-      throw new Error(`Model is required for ${provider}. Pass { model: "<model-name>" }.`);
+      throw new core.ConfigError({
+        code: core.ErrorCodes.AK_CONFIG_INVALID,
+        message: `Model is required for ${provider}. Pass { model: "<model-name>" }.`,
+        hint: `${provider} does not infer a default; pick a recent embedding model and pass it explicitly.`
+      });
     }
     const { apiKey, model, baseUrl = defaultBaseUrl } = config;
     return async (text) => {
@@ -1860,8 +2000,95 @@ 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 core.ConfigError({
+        code: core.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 core.ConfigError({
+          code: core.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;
+}
 
+exports.DEFAULT_CARBON_TABLE = DEFAULT_CARBON_TABLE;
+exports.DEFAULT_DEPRECATION_TABLE = DEFAULT_DEPRECATION_TABLE;
 exports.anthropic = anthropic;
+exports.applyCarbonTable = applyCarbonTable;
 exports.azureOpenAI = azureOpenAI;
 exports.azureOpenAIAdapter = azureOpenAIAdapter;
 exports.bail = bail;
@@ -1877,9 +2104,11 @@ exports.createAdapter = createAdapter;
 exports.createEnsembleAdapter = createEnsembleAdapter;
 exports.createFallbackAdapter = createFallbackAdapter;
 exports.createOpenAICompatibleEmbedder = createOpenAICompatibleEmbedder;
+exports.createRotatingCredentials = createRotatingCredentials;
 exports.createRouter = createRouter;
 exports.deepseek = deepseek;
 exports.deepseekEmbedder = deepseekEmbedder;
+exports.estimateCO2Grams = estimateCO2Grams;
 exports.fetchWithRetry = fetchWithRetry;
 exports.fireworks = fireworks;
 exports.gemini = gemini;
@@ -1906,9 +2135,11 @@ exports.openaiEmbedder = openaiEmbedder;
 exports.openrouter = openrouter;
 exports.qwen = qwen;
 exports.recordingAdapter = recordingAdapter;
+exports.refreshCredentials = refreshCredentials;
 exports.replayAdapter = replayAdapter;
 exports.replicate = replicate;
 exports.replicateAdapter = replicateAdapter;
+exports.resolveModel = resolveModel;
 exports.simulateStream = simulateStream;
 exports.together = together;
 exports.vercelAI = vercelAI;
@@ -1917,5 +2148,6 @@ exports.vertexAdapter = vertexAdapter;
 exports.vllm = vllm;
 exports.webllm = webllm;
 exports.webllmAdapter = webllmAdapter;
+exports.withDeprecationPolicy = withDeprecationPolicy;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map