@agentskit/adapters 0.9.1 → 0.11.0

package/dist/index.cjs

@@ -781,13 +781,47 @@ function vercelAI(config) {
 var mistral = createOpenAICompatibleAdapter("https://api.mistral.ai/v1");
 
 // src/cohere.ts
-var cohere = createOpenAICompatibleAdapter("https://api.cohere.com/compatibility/v1");
+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 = createOpenAICompatibleAdapter("https://api.groq.com/openai/v1");
+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");
@@ -807,6 +841,502 @@ 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/webllm.ts
+var cachedSdk2 = null;
+async function loadSdk2() {
+  if (!cachedSdk2) {
+    cachedSdk2 = (async () => {
+      try {
+        const moduleId = "@mlc-ai/web-llm";
+        return await import(
+          /* @vite-ignore */
+          moduleId
+        );
+      } catch {
+        throw new Error("Install @mlc-ai/web-llm to use the webllm adapter: npm install @mlc-ai/web-llm");
+      }
+    })();
+  }
+  return cachedSdk2;
+}
+function webllm(config) {
+  let enginePromise = null;
+  const getEngine = () => {
+    if (config.engine) return Promise.resolve(config.engine);
+    if (!enginePromise) {
+      enginePromise = (async () => {
+        const sdk = await loadSdk2();
+        return sdk.CreateMLCEngine(config.model, { initProgressCallback: config.onProgress });
+      })();
+    }
+    return enginePromise;
+  };
+  return {
+    capabilities: {
+      streaming: true,
+      tools: false
+    },
+    createSource: (request) => {
+      let aborted = false;
+      return {
+        stream: async function* () {
+          if (aborted) return;
+          try {
+            const engine = await getEngine();
+            const messages = request.messages.map((m) => ({ role: m.role, content: m.content }));
+            const completion = await engine.chat.completions.create({ messages, stream: true });
+            for await (const chunk of completion) {
+              if (aborted) return;
+              const delta = chunk.choices[0]?.delta?.content;
+              if (delta) yield { type: "text", content: delta };
+            }
+            yield { type: "done" };
+          } catch (err) {
+            yield { type: "error", content: err instanceof Error ? err.message : String(err) };
+          }
+        },
+        abort: () => {
+          aborted = true;
+        }
+      };
+    }
+  };
+}
+var webllmAdapter = webllm;
+
 // src/router.ts
 function requireCapabilities(request) {
   const needs = {};
@@ -1332,8 +1862,17 @@ 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;
@@ -1349,6 +1888,7 @@ exports.generic = generic;
 exports.grok = grok;
 exports.grokEmbedder = grokEmbedder;
 exports.groq = groq;
+exports.groqAdapter = groqAdapter;
 exports.huggingface = huggingface;
 exports.inMemorySink = inMemorySink;
 exports.kimi = kimi;
@@ -1364,11 +1904,18 @@ 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;
+exports.webllm = webllm;
+exports.webllmAdapter = webllmAdapter;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map