@agentskit/adapters 0.7.0 → 0.9.1

package/dist/index.js

@@ -775,6 +775,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;
@@ -1061,6 +1329,6 @@ var grokEmbedder = createOpenAICompatibleEmbedder("Grok", "https://api.x.ai");
 // src/embedders/kimi.ts
 var kimiEmbedder = createOpenAICompatibleEmbedder("Kimi", "https://api.moonshot.ai");
 
-export { anthropic, chunkText, createAdapter, createOpenAICompatibleEmbedder, deepseek, deepseekEmbedder, fetchWithRetry, gemini, geminiEmbedder, generic, grok, grokEmbedder, inMemorySink, kimi, kimiEmbedder, langchain, langgraph, mockAdapter, ollama, ollamaEmbedder, openai, openaiEmbedder, recordingAdapter, replayAdapter, simulateStream, vercelAI };
+export { anthropic, chunkText, cohere, createAdapter, createEnsembleAdapter, createFallbackAdapter, createOpenAICompatibleEmbedder, createRouter, deepseek, deepseekEmbedder, fetchWithRetry, fireworks, gemini, geminiEmbedder, generic, grok, grokEmbedder, groq, huggingface, inMemorySink, kimi, kimiEmbedder, langchain, langgraph, llamacpp, lmstudio, mistral, mockAdapter, ollama, ollamaEmbedder, openai, openaiEmbedder, openrouter, recordingAdapter, replayAdapter, simulateStream, together, vercelAI, vllm };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map