@agentskit/adapters 0.7.1 → 0.10.0

package/dist/index.cjs

@@ -777,6 +777,741 @@ function vercelAI(config) {
   };
 }
 
+// src/mistral.ts
+var mistral = createOpenAICompatibleAdapter("https://api.mistral.ai/v1");
+
+// src/cohere.ts
+var COHERE_BASE_URL = "https://api.cohere.com/compatibility/v1";
+var DEFAULT_MODEL = "command-r-plus";
+var baseFactory = createOpenAICompatibleAdapter(COHERE_BASE_URL);
+function cohere(config) {
+  const factory = baseFactory({
+    model: DEFAULT_MODEL,
+    ...config
+  });
+  return {
+    ...factory,
+    capabilities: {
+      streaming: true,
+      tools: true,
+      usage: true
+    }
+  };
+}
+var cohereAdapter = cohere;
+
+// src/together.ts
+var together = createOpenAICompatibleAdapter("https://api.together.xyz/v1");
+
+// src/groq.ts
+var GROQ_BASE_URL = "https://api.groq.com/openai/v1";
+var DEFAULT_MODEL2 = "llama-3.3-70b-versatile";
+var baseFactory2 = createOpenAICompatibleAdapter(GROQ_BASE_URL);
+function groq(config) {
+  const factory = baseFactory2({
+    model: DEFAULT_MODEL2,
+    ...config
+  });
+  return {
+    ...factory,
+    capabilities: {
+      streaming: true,
+      tools: true,
+      usage: true
+    }
+  };
+}
+var groqAdapter = groq;
+
+// 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/cerebras.ts
+var CEREBRAS_BASE_URL = "https://api.cerebras.ai/v1";
+var DEFAULT_MODEL3 = "llama-3.3-70b";
+var baseFactory3 = createOpenAICompatibleAdapter(CEREBRAS_BASE_URL);
+function cerebras(config) {
+  const factory = baseFactory3({
+    model: DEFAULT_MODEL3,
+    ...config
+  });
+  return {
+    ...factory,
+    capabilities: {
+      streaming: true,
+      tools: true,
+      usage: true
+    }
+  };
+}
+var cerebrasAdapter = cerebras;
+
+// src/azure-openai.ts
+var DEFAULT_API_VERSION = "2024-10-21";
+function azureOpenAI(config) {
+  const { apiKey, endpoint, deployment, apiVersion = DEFAULT_API_VERSION, retry } = config;
+  const includeUsage = config.includeUsage ?? true;
+  const url = `${endpoint.replace(/\/$/, "")}/openai/deployments/${encodeURIComponent(deployment)}/chat/completions?api-version=${encodeURIComponent(apiVersion)}`;
+  return {
+    capabilities: {
+      streaming: true,
+      tools: true,
+      usage: true
+    },
+    createSource: (request) => {
+      const body = {
+        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(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "api-key": apiKey
+          },
+          body: JSON.stringify(body),
+          signal
+        }),
+        parseOpenAIStream,
+        "Azure OpenAI API",
+        retry
+      );
+    }
+  };
+}
+var azureOpenAIAdapter = azureOpenAI;
+
+// src/replicate.ts
+var DEFAULT_BASE_URL = "https://api.replicate.com";
+function defaultPrompt(request) {
+  return request.messages.map((m) => {
+    if (m.role === "system") return `[SYSTEM] ${m.content}`;
+    if (m.role === "assistant") return `[ASSISTANT] ${m.content}`;
+    return `[USER] ${m.content}`;
+  }).join("\n\n") + "\n\n[ASSISTANT] ";
+}
+async function* parseReplicateStream(stream) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let currentEvent = "";
+  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("event: ")) {
+          currentEvent = line.slice(7).trim();
+          continue;
+        }
+        if (!line.startsWith("data: ")) continue;
+        const data = line.slice(6);
+        if (currentEvent === "output" && data) {
+          yield { type: "text", content: data };
+        } else if (currentEvent === "done") {
+          yield { type: "done" };
+          return;
+        } else if (currentEvent === "error") {
+          yield { type: "error", content: data || "replicate stream error" };
+          return;
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  yield { type: "done" };
+}
+function replicate(config) {
+  const { apiKey, model, version, baseUrl = DEFAULT_BASE_URL, toInput = (r) => ({ prompt: defaultPrompt(r) }) } = config;
+  const predictionUrl = version ? `${baseUrl}/v1/predictions` : `${baseUrl}/v1/models/${model}/predictions`;
+  return {
+    capabilities: {
+      streaming: true,
+      tools: false
+    },
+    createSource: (request) => {
+      const controller = new AbortController();
+      let aborted = false;
+      return {
+        stream: async function* () {
+          if (aborted) return;
+          try {
+            const body = {
+              input: toInput(request),
+              stream: true
+            };
+            if (version) body.version = version;
+            const response = await fetch(predictionUrl, {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/json",
+                "Authorization": `Bearer ${apiKey}`
+              },
+              body: JSON.stringify(body),
+              signal: controller.signal
+            });
+            if (!response.ok) {
+              yield { type: "error", content: `Replicate API error: ${response.status}` };
+              return;
+            }
+            const prediction = await response.json();
+            if (prediction.error) {
+              yield { type: "error", content: prediction.error };
+              return;
+            }
+            const streamUrl = prediction.urls?.stream;
+            if (!streamUrl) {
+              yield { type: "error", content: "Replicate prediction has no stream URL" };
+              return;
+            }
+            const streamResponse = await fetch(streamUrl, {
+              method: "GET",
+              headers: { Accept: "text/event-stream" },
+              signal: controller.signal
+            });
+            if (!streamResponse.ok || !streamResponse.body) {
+              yield { type: "error", content: `Replicate stream error: ${streamResponse.status}` };
+              return;
+            }
+            for await (const chunk of parseReplicateStream(streamResponse.body)) {
+              if (aborted) return;
+              yield chunk;
+            }
+          } catch (err) {
+            if (err instanceof DOMException && err.name === "AbortError") return;
+            yield { type: "error", content: err instanceof Error ? err.message : String(err) };
+          }
+        },
+        abort: () => {
+          aborted = true;
+          controller.abort();
+        }
+      };
+    }
+  };
+}
+var replicateAdapter = replicate;
+
+// src/bail.ts
+var BAIL_BASE_URL = "https://dashscope.aliyuncs.com/compatible-mode/v1";
+var DEFAULT_MODEL4 = "qwen-max";
+var baseFactory4 = createOpenAICompatibleAdapter(BAIL_BASE_URL);
+function bail(config) {
+  const factory = baseFactory4({
+    model: DEFAULT_MODEL4,
+    ...config
+  });
+  return {
+    ...factory,
+    capabilities: {
+      streaming: true,
+      tools: true,
+      multiModal: true,
+      usage: true
+    }
+  };
+}
+var bailAdapter = bail;
+var qwen = bail;
+
+// src/vertex.ts
+function vertex(config) {
+  const { project, region, model, accessToken, publisher = "google", retry } = config;
+  const url = `https://${region}-aiplatform.googleapis.com/v1/projects/${project}/locations/${region}/publishers/${publisher}/models/${model}:streamGenerateContent?alt=sse`;
+  return {
+    capabilities: {
+      streaming: true,
+      tools: true,
+      multiModal: true,
+      usage: true,
+      reasoning: model.includes("pro")
+    },
+    createSource: (request) => {
+      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,
+        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(
+        async (signal) => {
+          const token = typeof accessToken === "string" ? accessToken : await accessToken();
+          return fetch(url, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "Authorization": `Bearer ${token}`
+            },
+            body: JSON.stringify(body),
+            signal
+          });
+        },
+        parseGeminiStream,
+        "Vertex AI",
+        retry
+      );
+    }
+  };
+}
+var vertexAdapter = vertex;
+
+// src/bedrock.ts
+var cachedSdk = null;
+async function loadSdk() {
+  if (!cachedSdk) {
+    cachedSdk = (async () => {
+      try {
+        const moduleId = "@aws-sdk/client-bedrock-runtime";
+        return await import(
+          /* @vite-ignore */
+          moduleId
+        );
+      } catch {
+        throw new Error(
+          "Install @aws-sdk/client-bedrock-runtime to use the bedrock adapter: npm install @aws-sdk/client-bedrock-runtime"
+        );
+      }
+    })();
+  }
+  return cachedSdk;
+}
+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 system = request.messages.find((m) => m.role === "system")?.content;
+  const tools = request.context?.tools?.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    input_schema: tool.schema
+  }));
+  const body = {
+    anthropic_version: "bedrock-2023-05-31",
+    max_tokens: request.context?.maxTokens ?? maxTokens,
+    messages
+  };
+  if (system) body.system = system;
+  if (tools && tools.length > 0) body.tools = tools;
+  return JSON.stringify(body);
+}
+async function* parseAnthropicBedrockEvents(events) {
+  const decoder = new TextDecoder();
+  const pendingToolCalls = /* @__PURE__ */ new Map();
+  for await (const item of events) {
+    const bytes = item.chunk?.bytes;
+    if (!bytes) continue;
+    let event;
+    try {
+      event = JSON.parse(decoder.decode(bytes));
+    } catch {
+      continue;
+    }
+    const type = event.type;
+    if (type === "content_block_delta") {
+      const delta = event.delta;
+      if (delta?.type === "text_delta" && delta.text) {
+        yield { type: "text", content: delta.text };
+      } else if (delta?.type === "input_json_delta") {
+        const index = event.index ?? 0;
+        const existing = pendingToolCalls.get(index);
+        if (existing) existing.args += delta.partial_json ?? "";
+      }
+    } else if (type === "content_block_start") {
+      const index = event.index ?? 0;
+      const block = event.content_block;
+      if (block?.type === "tool_use" && block.id && block.name) {
+        pendingToolCalls.set(index, { id: block.id, name: block.name, args: "" });
+      }
+    } else if (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 (type === "message_delta") {
+      const usage = event.usage;
+      if (usage) {
+        const promptTokens = usage.input_tokens ?? 0;
+        const completionTokens = usage.output_tokens ?? 0;
+        yield {
+          type: "usage",
+          usage: { promptTokens, completionTokens, totalTokens: promptTokens + completionTokens }
+        };
+      }
+    } else if (type === "message_start") {
+      const usage = event.message?.usage;
+      if (usage) {
+        yield {
+          type: "usage",
+          usage: {
+            promptTokens: usage.input_tokens ?? 0,
+            completionTokens: 0,
+            totalTokens: usage.input_tokens ?? 0
+          }
+        };
+      }
+    } else if (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;
+    }
+  }
+  for (const [, tc] of pendingToolCalls) {
+    yield { type: "tool_call", toolCall: { id: tc.id, name: tc.name, args: tc.args || "{}" } };
+  }
+  pendingToolCalls.clear();
+  yield { type: "done" };
+}
+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.`
+    );
+  }
+  let clientPromise = null;
+  const getClient = async () => {
+    if (config.client) return config.client;
+    if (!clientPromise) {
+      clientPromise = (async () => {
+        const sdk = await loadSdk();
+        return new sdk.BedrockRuntimeClient({ region });
+      })();
+    }
+    return clientPromise;
+  };
+  return {
+    capabilities: {
+      streaming: true,
+      tools: true,
+      reasoning: model.includes("sonnet") || model.includes("opus"),
+      multiModal: true,
+      usage: true
+    },
+    createSource: (request) => {
+      const controller = new AbortController();
+      let aborted = false;
+      return {
+        stream: async function* () {
+          if (aborted) return;
+          try {
+            const client = await getClient();
+            const sdk = config.client ? null : await loadSdk();
+            const input = {
+              modelId: model,
+              contentType: "application/json",
+              accept: "application/json",
+              body: buildAnthropicBody(request, maxTokens)
+            };
+            const command = sdk ? new sdk.InvokeModelWithResponseStreamCommand(input) : { input };
+            const response = await client.send(command);
+            if (!response.body) {
+              yield { type: "error", content: "Bedrock: empty response body" };
+              return;
+            }
+            for await (const chunk of parseAnthropicBedrockEvents(response.body)) {
+              if (aborted) return;
+              yield chunk;
+            }
+          } catch (err) {
+            yield { type: "error", content: err instanceof Error ? err.message : String(err) };
+          }
+        },
+        abort: () => {
+          aborted = true;
+          controller.abort();
+        }
+      };
+    }
+  };
+}
+var bedrockAdapter = bedrock;
+
+// 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;
@@ -1064,30 +1799,58 @@ var grokEmbedder = createOpenAICompatibleEmbedder("Grok", "https://api.x.ai");
 var kimiEmbedder = createOpenAICompatibleEmbedder("Kimi", "https://api.moonshot.ai");
 
 exports.anthropic = anthropic;
+exports.azureOpenAI = azureOpenAI;
+exports.azureOpenAIAdapter = azureOpenAIAdapter;
+exports.bail = bail;
+exports.bailAdapter = bailAdapter;
+exports.bedrock = bedrock;
+exports.bedrockAdapter = bedrockAdapter;
+exports.cerebras = cerebras;
+exports.cerebrasAdapter = cerebrasAdapter;
 exports.chunkText = chunkText;
+exports.cohere = cohere;
+exports.cohereAdapter = cohereAdapter;
 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.groqAdapter = groqAdapter;
+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.qwen = qwen;
 exports.recordingAdapter = recordingAdapter;
 exports.replayAdapter = replayAdapter;
+exports.replicate = replicate;
+exports.replicateAdapter = replicateAdapter;
 exports.simulateStream = simulateStream;
+exports.together = together;
 exports.vercelAI = vercelAI;
+exports.vertex = vertex;
+exports.vertexAdapter = vertexAdapter;
+exports.vllm = vllm;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map