@agentskit/adapters 0.7.1 → 0.9.1

package/README.md

@@ -4,8 +4,8 @@ Connect to any LLM provider — and swap between them — without touching your
 
 [![npm version](https://img.shields.io/npm/v/@agentskit/adapters?color=blue)](https://www.npmjs.com/package/@agentskit/adapters)
 [![npm downloads](https://img.shields.io/npm/dm/@agentskit/adapters)](https://www.npmjs.com/package/@agentskit/adapters)
-[![bundle size](https://img.shields.io/bundlephobia/minzip/@agentskit/adapters)](https://bundlephobia.com/package/@agentskit/adapters)
-[![license](https://img.shields.io/npm/l/@agentskit/adapters)](../../LICENSE)
+[![bundle size](https://img.shields.io/bundlejs/size/@agentskit/adapters?label=bundle)](https://bundlejs.com/?q=@agentskit/adapters)
+[![license](https://img.shields.io/badge/license-MIT-blue.svg)](../../LICENSE)
 [![stability](https://img.shields.io/badge/stability-stable-brightgreen)](../../docs/STABILITY.md)
 [![GitHub stars](https://img.shields.io/github/stars/AgentsKit-io/agentskit?style=social)](https://github.com/AgentsKit-io/agentskit)
 
@@ -14,7 +14,7 @@ Connect to any LLM provider — and swap between them — without touching your
 ## Why adapters
 
 - **Vendor independence** — switch from OpenAI to Anthropic to a local Ollama model by changing one line; your hooks, runtime, and tools stay untouched
-- **10+ providers included** — Anthropic, OpenAI, Gemini, Ollama, DeepSeek, Grok, Kimi, LangChain, Vercel AI SDK, and any raw `ReadableStream`
+- **20+ providers included** — Anthropic, OpenAI, Gemini, Ollama, DeepSeek, Grok, Kimi, Mistral, Cohere, Together, Groq, Fireworks, OpenRouter, Hugging Face, LM Studio, vLLM, llama.cpp, LangChain, Vercel AI SDK, and any raw `ReadableStream`
 - **Embedder functions built in** — the same adapter pattern covers text embeddings, so you can reuse provider config for both chat and RAG
 - **One-line local AI** — `ollama({ model: 'llama3.1' })` for fully offline agents with no API key required
 
@@ -57,10 +57,28 @@ const rag = createRAG({
 
 ## Features
 
-- Providers: Anthropic, OpenAI, Gemini, Ollama, DeepSeek, Grok, Kimi, LangChain, LangGraph, Vercel AI SDK, generic `ReadableStream`
-- Embedders: `openaiEmbedder`, `geminiEmbedder`, `ollamaEmbedder`
+- Providers: Anthropic, OpenAI, Gemini, Ollama, DeepSeek, Grok, Kimi, Mistral, Cohere, Together, Groq, Fireworks, OpenRouter, Hugging Face, LM Studio, vLLM, llama.cpp, LangChain, LangGraph, Vercel AI SDK, generic `ReadableStream`
+- Embedders: `openaiEmbedder`, `geminiEmbedder`, `ollamaEmbedder`, `deepseekEmbedder`, `grokEmbedder`, `kimiEmbedder`, `createOpenAICompatibleEmbedder`
 - All adapters satisfy `Adapter` contract v1 (ADR 0001) — substitutable anywhere in the ecosystem
 - Custom adapter authoring via `createAdapter()`
+- Higher-order adapters: `createRouter` (cost/latency/classifier), `createEnsembleAdapter` (fan-out + merge), `createFallbackAdapter` (ordered try-next)
+
+## Higher-order adapters
+
+```ts
+import { createRouter, anthropic, openai } from '@agentskit/adapters'
+
+// Auto-pick cheapest capable candidate per request.
+const router = createRouter({
+  candidates: [
+    { id: 'haiku', adapter: anthropic({ model: 'claude-haiku-4-5' }), cost: 0.25 },
+    { id: 'sonnet', adapter: anthropic({ model: 'claude-sonnet-4-6' }), cost: 3 },
+    { id: 'gpt-mini', adapter: openai({ model: 'gpt-4o-mini' }), cost: 0.15 },
+  ],
+})
+```
+
+See [Adapter router](https://www.agentskit.io/docs/recipes/adapter-router), [Ensemble](https://www.agentskit.io/docs/recipes/adapter-ensemble), and [Fallback chain](https://www.agentskit.io/docs/recipes/fallback-chain).
 
 ## Ecosystem
 

package/dist/index.cjs

@@ -777,6 +777,274 @@ function vercelAI(config) {
   };
 }
 
+// src/mistral.ts
+var mistral = createOpenAICompatibleAdapter("https://api.mistral.ai/v1");
+
+// src/cohere.ts
+var cohere = createOpenAICompatibleAdapter("https://api.cohere.com/compatibility/v1");
+
+// src/together.ts
+var together = createOpenAICompatibleAdapter("https://api.together.xyz/v1");
+
+// src/groq.ts
+var groq = createOpenAICompatibleAdapter("https://api.groq.com/openai/v1");
+
+// src/fireworks.ts
+var fireworks = createOpenAICompatibleAdapter("https://api.fireworks.ai/inference/v1");
+
+// src/openrouter.ts
+var openrouter = createOpenAICompatibleAdapter("https://openrouter.ai/api/v1");
+
+// src/huggingface.ts
+var huggingface = createOpenAICompatibleAdapter("https://router.huggingface.co/v1");
+
+// src/lmstudio.ts
+var lmstudio = createOpenAICompatibleAdapter("http://localhost:1234/v1");
+
+// src/vllm.ts
+var vllm = createOpenAICompatibleAdapter("http://localhost:8000/v1");
+
+// src/llamacpp.ts
+var llamacpp = createOpenAICompatibleAdapter("http://localhost:8080/v1");
+
+// src/router.ts
+function requireCapabilities(request) {
+  const needs = {};
+  if (request.context?.tools && request.context.tools.length > 0) needs.tools = true;
+  return needs;
+}
+function matchesCapabilities(need, have) {
+  if (!have) return true;
+  for (const key of Object.keys(need)) {
+    if (key === "extensions") continue;
+    if (need[key] && have[key] === false) return false;
+  }
+  return true;
+}
+function pickSyncPolicy(pool, policy) {
+  if (policy === "cheapest") {
+    const c = pool.reduce((best, x) => (x.cost ?? Infinity) < (best.cost ?? Infinity) ? x : best, pool[0]);
+    return { c, reason: "cheapest" };
+  }
+  if (policy === "fastest") {
+    const c = pool.reduce((best, x) => (x.latencyMs ?? Infinity) < (best.latencyMs ?? Infinity) ? x : best, pool[0]);
+    return { c, reason: "fastest" };
+  }
+  return { c: pool[0], reason: "capability-match" };
+}
+function createRouter(options) {
+  const { candidates } = options;
+  if (candidates.length === 0) throw new Error("createRouter requires at least one candidate");
+  const policy = options.policy ?? "cheapest";
+  return {
+    createSource: (request) => {
+      const need = requireCapabilities(request);
+      const capable = candidates.filter((c2) => matchesCapabilities(need, c2.capabilities ?? c2.adapter.capabilities));
+      const classified = options.classify?.(request);
+      if (typeof classified === "string") {
+        const c2 = capable.find((x) => x.id === classified);
+        if (c2) {
+          options.onRoute?.({ id: c2.id, reason: "classify:id", request });
+          return c2.adapter.createSource(request);
+        }
+      }
+      let pool = capable;
+      let pickedBy;
+      if (Array.isArray(classified) && classified.length > 0) {
+        const filtered = capable.filter((c2) => c2.tags && classified.every((t) => c2.tags.includes(t)));
+        if (filtered.length > 0) {
+          pool = filtered;
+          pickedBy = "classify:tags";
+        }
+      }
+      if (pool.length === 0) throw new Error("no candidate satisfies the request");
+      if (typeof policy === "function") {
+        const maybe = policy({ request, candidates: pool });
+        if (maybe instanceof Promise) {
+          return {
+            abort: () => {
+            },
+            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}`);
+              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}`);
+        options.onRoute?.({ id: c2.id, reason: pickedBy ?? "custom policy", request });
+        return c2.adapter.createSource(request);
+      }
+      const { c, reason } = pickSyncPolicy(pool, policy);
+      options.onRoute?.({ id: c.id, reason: pickedBy ?? reason, request });
+      return c.adapter.createSource(request);
+    }
+  };
+}
+
+// src/ensemble.ts
+async function drain(source, timeoutMs) {
+  const chunks = [];
+  let text = "";
+  let timer;
+  let timedOut = false;
+  let error;
+  if (timeoutMs !== void 0) {
+    timer = setTimeout(() => {
+      timedOut = true;
+      source.abort();
+    }, timeoutMs);
+  }
+  try {
+    for await (const chunk of source.stream()) {
+      chunks.push(chunk);
+      if (chunk.type === "text" && typeof chunk.content === "string") text += chunk.content;
+    }
+  } catch (err) {
+    error = err instanceof Error ? err : new Error(String(err));
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+  if (timedOut) error = new Error(`timeout after ${timeoutMs}ms`);
+  return { chunks, text, error };
+}
+function majorityVote(branches, candidates) {
+  const counts = /* @__PURE__ */ new Map();
+  const weightById = new Map(candidates.map((c) => [c.id, c.weight ?? 1]));
+  for (const b of branches) {
+    if (b.error) continue;
+    counts.set(b.text, (counts.get(b.text) ?? 0) + (weightById.get(b.id) ?? 1));
+  }
+  let best = "";
+  let bestScore = -1;
+  for (const [text, score] of counts) {
+    if (score > bestScore) {
+      bestScore = score;
+      best = text;
+    }
+  }
+  return best;
+}
+function createEnsembleAdapter(options) {
+  if (options.candidates.length === 0) {
+    throw new Error("createEnsembleAdapter requires at least one candidate");
+  }
+  const aggregate = options.aggregate ?? "majority-vote";
+  return {
+    createSource: (request) => {
+      let aborted = false;
+      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 };
+        });
+        return Promise.all(tasks);
+      };
+      const finalText = async (branches) => {
+        if (typeof aggregate === "function") return aggregate(branches);
+        if (aggregate === "concat") {
+          return branches.filter((b) => !b.error).map((b) => b.text).join("\n---\n");
+        }
+        if (aggregate === "longest") {
+          return branches.filter((b) => !b.error).reduce(
+            (best, b) => b.text.length > best.length ? b.text : best,
+            ""
+          );
+        }
+        return majorityVote(branches, options.candidates);
+      };
+      return {
+        abort: () => {
+          aborted = true;
+          for (const s of sources) s?.abort();
+        },
+        stream: async function* () {
+          const branches = await run();
+          options.onBranches?.(branches);
+          if (aborted) return;
+          const text = await finalText(branches);
+          if (!text && branches.every((b) => b.error)) {
+            throw new Error("all ensemble branches failed");
+          }
+          yield { type: "text", content: text, metadata: { ensemble: branches.map((b) => ({ id: b.id, bytes: b.text.length, error: b.error?.message })) } };
+          yield { type: "done" };
+        }
+      };
+    }
+  };
+}
+
+// src/fallback.ts
+function createFallbackAdapter(candidates, options = {}) {
+  if (candidates.length === 0) {
+    throw new Error("createFallbackAdapter requires at least one candidate");
+  }
+  return {
+    createSource: (request) => {
+      let active;
+      let aborted = false;
+      return {
+        abort: () => {
+          aborted = true;
+          active?.abort();
+        },
+        stream: async function* () {
+          const errors = [];
+          for (let i = 0; i < candidates.length; i++) {
+            if (aborted) return;
+            const candidate = candidates[i];
+            let source;
+            try {
+              source = candidate.adapter.createSource(request);
+            } 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;
+              continue;
+            }
+            active = source;
+            const iter = source.stream()[Symbol.asyncIterator]();
+            let first;
+            try {
+              first = await iter.next();
+            } 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;
+            }
+            if (first.done) {
+              const error = 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;
+            while (true) {
+              const next = await iter.next();
+              if (next.done) return;
+              yield next.value;
+            }
+          }
+          const summary = errors.map((e) => `${e.id}: ${e.error.message}`).join("; ");
+          throw new Error(`all fallback candidates failed (${summary})`);
+        }
+      };
+    }
+  };
+}
+
 // src/mock.ts
 function mockAdapter(options) {
   const { response, delayMs = 0, history } = options;
@@ -1065,29 +1333,42 @@ var kimiEmbedder = createOpenAICompatibleEmbedder("Kimi", "https://api.moonshot.
 
 exports.anthropic = anthropic;
 exports.chunkText = chunkText;
+exports.cohere = cohere;
 exports.createAdapter = createAdapter;
+exports.createEnsembleAdapter = createEnsembleAdapter;
+exports.createFallbackAdapter = createFallbackAdapter;
 exports.createOpenAICompatibleEmbedder = createOpenAICompatibleEmbedder;
+exports.createRouter = createRouter;
 exports.deepseek = deepseek;
 exports.deepseekEmbedder = deepseekEmbedder;
 exports.fetchWithRetry = fetchWithRetry;
+exports.fireworks = fireworks;
 exports.gemini = gemini;
 exports.geminiEmbedder = geminiEmbedder;
 exports.generic = generic;
 exports.grok = grok;
 exports.grokEmbedder = grokEmbedder;
+exports.groq = groq;
+exports.huggingface = huggingface;
 exports.inMemorySink = inMemorySink;
 exports.kimi = kimi;
 exports.kimiEmbedder = kimiEmbedder;
 exports.langchain = langchain;
 exports.langgraph = langgraph;
+exports.llamacpp = llamacpp;
+exports.lmstudio = lmstudio;
+exports.mistral = mistral;
 exports.mockAdapter = mockAdapter;
 exports.ollama = ollama;
 exports.ollamaEmbedder = ollamaEmbedder;
 exports.openai = openai;
 exports.openaiEmbedder = openaiEmbedder;
+exports.openrouter = openrouter;
 exports.recordingAdapter = recordingAdapter;
 exports.replayAdapter = replayAdapter;
 exports.simulateStream = simulateStream;
+exports.together = together;
 exports.vercelAI = vercelAI;
+exports.vllm = vllm;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map