@agentskit/adapters 0.4.0 → 0.4.2

package/README.md

@@ -0,0 +1,63 @@
+# @agentskit/adapters
+
+Connect to any LLM provider — and swap between them — without touching your app code.
+
+## Why
+
+- **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`
+- **Embedder functions built in** — the same adapter pattern covers text embeddings, so you can reuse provider config for both chat and RAG
+
+## Install
+
+```bash
+npm install @agentskit/adapters
+```
+
+## Quick example
+
+```ts
+import { anthropic, openai, ollama } from '@agentskit/adapters'
+import { createRuntime } from '@agentskit/runtime'
+
+// Switch provider by swapping one import
+const adapter = anthropic({ apiKey: process.env.ANTHROPIC_API_KEY, model: 'claude-sonnet-4-6' })
+// const adapter = openai({ apiKey: process.env.OPENAI_API_KEY, model: 'gpt-4o' })
+// const adapter = ollama({ model: 'llama3.1' })
+
+const runtime = createRuntime({ adapter })
+const result = await runtime.run('Summarize the latest AI news')
+console.log(result.content)
+```
+
+## Embeddings (for RAG)
+
+Use the same package for vector embeddings — wire `openaiEmbedder`, `geminiEmbedder`, or `ollamaEmbedder` into [`@agentskit/rag`](https://www.npmjs.com/package/@agentskit/rag):
+
+```ts
+import { openaiEmbedder } from '@agentskit/adapters'
+import { createRAG } from '@agentskit/rag'
+import { fileVectorMemory } from '@agentskit/memory'
+
+const rag = createRAG({
+  embed: openaiEmbedder({ apiKey: process.env.OPENAI_API_KEY! }),
+  store: fileVectorMemory({ path: './vectors' }),
+})
+```
+
+## Next steps
+
+- Pair adapters with [`@agentskit/runtime`](https://www.npmjs.com/package/@agentskit/runtime), [`@agentskit/react`](https://www.npmjs.com/package/@agentskit/react), or [`@agentskit/ink`](https://www.npmjs.com/package/@agentskit/ink) — the adapter instance is the only provider-specific piece
+
+## Ecosystem
+
+| Package | Role |
+|---------|------|
+| [@agentskit/core](https://www.npmjs.com/package/@agentskit/core) | `Adapter`, `EmbedFn`, types |
+| [@agentskit/runtime](https://www.npmjs.com/package/@agentskit/runtime) | Headless `createRuntime` |
+| [@agentskit/rag](https://www.npmjs.com/package/@agentskit/rag) | `createRAG` + embedders |
+| [@agentskit/memory](https://www.npmjs.com/package/@agentskit/memory) | Vector + chat memory backends |
+
+## Docs
+
+[Full documentation](https://emersonbraun.github.io/agentskit/)

package/dist/index.cjs

@@ -107,8 +107,13 @@ async function* readNDJSONLines(stream) {
   }
 }
 async function* parseOpenAIStream(stream) {
+  const pendingToolCalls = /* @__PURE__ */ new Map();
   for await (const data of readSSELines(stream)) {
     if (data === "[DONE]") {
+      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;
     }
@@ -117,56 +122,104 @@ async function* parseOpenAIStream(stream) {
       const delta = event.choices?.[0]?.delta;
       if (typeof delta?.content === "string") {
         yield { type: "text", content: delta.content };
-      } else if (Array.isArray(delta?.tool_calls)) {
+      }
+      if (Array.isArray(delta?.tool_calls)) {
         for (const toolCall of delta.tool_calls) {
+          const index = toolCall.index ?? 0;
+          const existing = pendingToolCalls.get(index);
           if (toolCall?.function?.name) {
-            yield {
-              type: "tool_call",
-              toolCall: {
-                id: toolCall.id ?? `${toolCall.function.name}-${Date.now()}`,
-                name: toolCall.function.name,
-                args: toolCall.function.arguments ?? "{}"
-              }
-            };
+            pendingToolCalls.set(index, {
+              id: toolCall.id ?? existing?.id ?? `tool-${index}-${Date.now()}`,
+              name: toolCall.function.name,
+              args: (existing?.args ?? "") + (toolCall.function.arguments ?? "")
+            });
+          } else if (existing && toolCall?.function?.arguments) {
+            existing.args += toolCall.function.arguments;
           }
         }
       }
     } catch {
     }
   }
+  for (const [, tc] of pendingToolCalls) {
+    yield { type: "tool_call", toolCall: { id: tc.id, name: tc.name, args: tc.args || "{}" } };
+  }
+  pendingToolCalls.clear();
   yield { type: "done" };
 }
 async function* parseAnthropicStream(stream) {
+  const pendingToolCalls = /* @__PURE__ */ new Map();
   for await (const data of readSSELines(stream)) {
     if (data === "[DONE]") continue;
     try {
       const event = JSON.parse(data);
-      if (event.type === "content_block_delta" && event.delta?.text) {
+      if (event.type === "content_block_delta" && event.delta?.type === "text_delta" && event.delta?.text) {
         yield { type: "text", content: event.delta.text };
+      } else if (event.type === "content_block_delta" && event.delta?.type === "input_json_delta") {
+        const index = event.index ?? 0;
+        const existing = pendingToolCalls.get(index);
+        if (existing) {
+          existing.args += event.delta.partial_json ?? "";
+        }
       } else if (event.type === "content_block_start" && event.content_block?.type === "tool_use") {
-        yield {
-          type: "tool_call",
-          toolCall: {
-            id: event.content_block.id,
-            name: event.content_block.name,
-            args: JSON.stringify(event.content_block.input ?? {})
-          }
-        };
+        const index = event.index ?? 0;
+        pendingToolCalls.set(index, {
+          id: event.content_block.id,
+          name: event.content_block.name,
+          args: ""
+        });
+      } else if (event.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 (event.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;
       }
     } catch {
     }
   }
+  for (const [, tc] of pendingToolCalls) {
+    yield { type: "tool_call", toolCall: { id: tc.id, name: tc.name, args: tc.args || "{}" } };
+  }
+  pendingToolCalls.clear();
   yield { type: "done" };
 }
 async function* parseGeminiStream(stream) {
   for await (const data of readSSELines(stream)) {
     try {
       const event = JSON.parse(data);
-      const text = event.candidates?.[0]?.content?.parts?.map((part) => part.text ?? "").join("");
-      if (text) yield { type: "text", content: text };
+      const parts = event.candidates?.[0]?.content?.parts;
+      if (!Array.isArray(parts)) continue;
+      for (const part of parts) {
+        if (typeof part.text === "string" && part.text) {
+          yield { type: "text", content: part.text };
+        } else if (part.functionCall) {
+          const fc = part.functionCall;
+          yield {
+            type: "tool_call",
+            toolCall: {
+              id: fc.id ?? `${fc.name}-${Date.now()}`,
+              name: fc.name,
+              args: JSON.stringify(fc.args ?? {})
+            }
+          };
+        }
+      }
     } catch {
     }
   }
@@ -179,6 +232,20 @@ async function* parseOllamaStream(stream) {
       if (event.message?.content) {
         yield { type: "text", content: event.message.content };
       }
+      if (Array.isArray(event.message?.tool_calls)) {
+        for (const tc of event.message.tool_calls) {
+          if (tc?.function?.name) {
+            yield {
+              type: "tool_call",
+              toolCall: {
+                id: tc.id ?? `${tc.function.name}-${Date.now()}`,
+                name: tc.function.name,
+                args: typeof tc.function.arguments === "string" ? tc.function.arguments : JSON.stringify(tc.function.arguments ?? {})
+              }
+            };
+          }
+        }
+      }
       if (event.done) {
         yield { type: "done" };
         return;
@@ -471,17 +538,218 @@ function vercelAI(config) {
   };
 }
 
+// src/embedders/openai.ts
+async function fetchAvailableModels(baseUrl, apiKey) {
+  const response = await fetch(`${baseUrl}/v1/models`, {
+    headers: { "Authorization": `Bearer ${apiKey}` }
+  });
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}`);
+  }
+  const data = await response.json();
+  return data.data.map((m) => m.id).filter((id) => id.includes("embed")).sort();
+}
+async function buildModelError(baseUrl, apiKey, originalError) {
+  try {
+    const models = await fetchAvailableModels(baseUrl, apiKey);
+    const list = models.length > 0 ? models.join(", ") : "none found";
+    return new Error(
+      `OpenAI embedding failed: ${originalError}. Available embedding models: ${list}`
+    );
+  } catch (fetchError) {
+    return new Error(
+      `OpenAI embedding failed: ${originalError}. Could not fetch available models: ${fetchError.message}`
+    );
+  }
+}
+function openaiEmbedder(config) {
+  const { apiKey, model = "text-embedding-3-small", baseUrl = "https://api.openai.com" } = config;
+  return async (text) => {
+    const response = await fetch(`${baseUrl}/v1/embeddings`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({ model, input: text })
+    });
+    if (!response.ok) {
+      const errorBody = await response.json().catch(() => ({}));
+      const message = errorBody.error?.message ?? `HTTP ${response.status}`;
+      throw await buildModelError(baseUrl, apiKey, message);
+    }
+    const data = await response.json();
+    return data.data[0].embedding;
+  };
+}
+
+// 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 data = await response.json();
+  return data.models.filter((m) => m.supportedGenerationMethods.includes("embedContent")).map((m) => m.name.replace("models/", "")).sort();
+}
+async function buildModelError2(baseUrl, apiKey, originalError) {
+  try {
+    const models = await fetchAvailableModels2(baseUrl, apiKey);
+    const list = models.length > 0 ? models.join(", ") : "none found";
+    return new Error(
+      `Gemini embedding failed: ${originalError}. Available embedding models: ${list}`
+    );
+  } catch (fetchError) {
+    return new Error(
+      `Gemini embedding failed: ${originalError}. Could not fetch available models: ${fetchError.message}`
+    );
+  }
+}
+function geminiEmbedder(config) {
+  const {
+    apiKey,
+    model = "text-embedding-004",
+    baseUrl = "https://generativelanguage.googleapis.com"
+  } = config;
+  return async (text) => {
+    const response = await fetch(
+      `${baseUrl}/v1beta/models/${model}:embedContent?key=${apiKey}`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          model: `models/${model}`,
+          content: { parts: [{ text }] }
+        })
+      }
+    );
+    if (!response.ok) {
+      const errorBody = await response.json().catch(() => ({}));
+      const message = errorBody.error?.message ?? `HTTP ${response.status}`;
+      throw await buildModelError2(baseUrl, apiKey, message);
+    }
+    const data = await response.json();
+    return data.embedding.values;
+  };
+}
+
+// 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 data = await response.json();
+  return data.models.map((m) => m.name).filter((name) => name.includes("embed")).sort();
+}
+async function buildModelError3(baseUrl, originalError) {
+  try {
+    const models = await fetchAvailableModels3(baseUrl);
+    const list = models.length > 0 ? models.join(", ") : "none found";
+    return new Error(
+      `Ollama embedding failed: ${originalError}. Available embedding models: ${list}`
+    );
+  } catch (fetchError) {
+    return new Error(
+      `Ollama embedding failed: ${originalError}. Could not fetch available models: ${fetchError.message}`
+    );
+  }
+}
+function ollamaEmbedder(config) {
+  const { model = "nomic-embed-text", baseUrl = "http://localhost:11434" } = config;
+  return async (text) => {
+    const response = await fetch(`${baseUrl}/api/embed`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ model, input: text })
+    });
+    if (!response.ok) {
+      const errorBody = await response.json().catch(() => ({}));
+      const message = errorBody.error ?? `HTTP ${response.status}`;
+      throw await buildModelError3(baseUrl, message);
+    }
+    const data = await response.json();
+    return data.embeddings[0];
+  };
+}
+
+// src/embedders/openai-compatible.ts
+async function fetchAvailableModels4(baseUrl, apiKey) {
+  const response = await fetch(`${baseUrl}/v1/models`, {
+    headers: { "Authorization": `Bearer ${apiKey}` }
+  });
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}`);
+  }
+  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 list = models.length > 0 ? models.join(", ") : "none found";
+    return new Error(
+      `${provider} embedding failed: ${originalError}. Available embedding models: ${list}`
+    );
+  } catch (fetchError) {
+    return new Error(
+      `${provider} embedding failed: ${originalError}. Could not fetch available models: ${fetchError.message}`
+    );
+  }
+}
+function createOpenAICompatibleEmbedder(provider, defaultBaseUrl) {
+  return function embedder(config) {
+    if (!config.model) {
+      throw new Error(`Model is required for ${provider}. Pass { model: "<model-name>" }.`);
+    }
+    const { apiKey, model, baseUrl = defaultBaseUrl } = config;
+    return async (text) => {
+      const response = await fetch(`${baseUrl}/v1/embeddings`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${apiKey}`
+        },
+        body: JSON.stringify({ model, input: text })
+      });
+      if (!response.ok) {
+        const errorBody = await response.json().catch(() => ({}));
+        const message = errorBody.error?.message ?? `HTTP ${response.status}`;
+        throw await buildModelError4(provider, baseUrl, apiKey, message);
+      }
+      const data = await response.json();
+      return data.data[0].embedding;
+    };
+  };
+}
+
+// src/embedders/deepseek.ts
+var deepseekEmbedder = createOpenAICompatibleEmbedder("DeepSeek", "https://api.deepseek.com");
+
+// src/embedders/grok.ts
+var grokEmbedder = createOpenAICompatibleEmbedder("Grok", "https://api.x.ai");
+
+// src/embedders/kimi.ts
+var kimiEmbedder = createOpenAICompatibleEmbedder("Kimi", "https://api.moonshot.ai");
+
 exports.anthropic = anthropic;
 exports.createAdapter = createAdapter;
+exports.createOpenAICompatibleEmbedder = createOpenAICompatibleEmbedder;
 exports.deepseek = deepseek;
+exports.deepseekEmbedder = deepseekEmbedder;
 exports.gemini = gemini;
+exports.geminiEmbedder = geminiEmbedder;
 exports.generic = generic;
 exports.grok = grok;
+exports.grokEmbedder = grokEmbedder;
 exports.kimi = kimi;
+exports.kimiEmbedder = kimiEmbedder;
 exports.langchain = langchain;
 exports.langgraph = langgraph;
 exports.ollama = ollama;
+exports.ollamaEmbedder = ollamaEmbedder;
 exports.openai = openai;
+exports.openaiEmbedder = openaiEmbedder;
 exports.vercelAI = vercelAI;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map