@agentskit/adapters 0.4.0 → 0.5.0

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;
@@ -188,12 +255,73 @@ async function* parseOllamaStream(stream) {
   }
   yield { type: "done" };
 }
-function createStreamSource(doFetch, parse, errorLabel) {
+var DEFAULT_RETRY = {
+  maxAttempts: 3,
+  baseDelayMs: 500,
+  maxDelayMs: 8e3,
+  jitter: true,
+  retryOn: ({ error, response }) => {
+    if (response) {
+      return [408, 429, 500, 502, 503, 504].includes(response.status);
+    }
+    if (error instanceof DOMException && error.name === "AbortError") return false;
+    return true;
+  }
+};
+function defaultSleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+function computeDelay(attempt, opts) {
+  const exp = Math.min(opts.maxDelayMs, opts.baseDelayMs * Math.pow(2, attempt - 1));
+  if (!opts.jitter) return exp;
+  return Math.floor(Math.random() * exp);
+}
+function parseRetryAfter(value) {
+  if (!value) return void 0;
+  const n = Number(value);
+  if (!Number.isNaN(n)) return n * 1e3;
+  const date = Date.parse(value);
+  if (!Number.isNaN(date)) return Math.max(0, date - Date.now());
+  return void 0;
+}
+async function fetchWithRetry(doFetch, signal, retryOpt = {}) {
+  const opts = {
+    ...DEFAULT_RETRY,
+    ...retryOpt
+  };
+  const sleep = retryOpt.sleep ?? defaultSleep;
+  let lastError;
+  for (let attempt = 1; attempt <= opts.maxAttempts; attempt++) {
+    if (signal.aborted) throw new DOMException("Aborted", "AbortError");
+    try {
+      const response = await doFetch(signal);
+      if (response.ok) return response;
+      if (attempt >= opts.maxAttempts || !opts.retryOn({ response, attempt })) {
+        return response;
+      }
+      const retryAfterMs = parseRetryAfter(response.headers.get("retry-after"));
+      const delay = retryAfterMs ?? computeDelay(attempt, opts);
+      retryOpt.onRetry?.({ attempt, delayMs: delay, reason: `HTTP ${response.status}` });
+      await sleep(delay);
+      response.body?.cancel().catch(() => {
+      });
+    } catch (err) {
+      lastError = err;
+      if (err instanceof DOMException && err.name === "AbortError") throw err;
+      if (attempt >= opts.maxAttempts || !opts.retryOn({ error: err, attempt })) throw err;
+      const delay = computeDelay(attempt, opts);
+      retryOpt.onRetry?.({ attempt, delayMs: delay, reason: err.message });
+      await sleep(delay);
+    }
+  }
+  throw lastError ?? new Error("fetchWithRetry: exhausted attempts");
+}
+function createStreamSource(doFetch, parse, errorLabel, retry) {
   let abortController = new AbortController();
   return {
     stream: async function* () {
       try {
-        const response = await doFetch(abortController.signal);
+        const response = await fetchWithRetry(doFetch, abortController.signal, retry ?? {});
         if (!response.ok || !response.body) {
           yield { type: "error", content: `${errorLabel} error: ${response.status}` };
           return;
@@ -213,11 +341,78 @@ function createStreamSource(doFetch, parse, errorLabel) {
     }
   };
 }
+function chunkText(text, targetSize = 32) {
+  if (text.length <= targetSize) return [text];
+  const out = [];
+  let i = 0;
+  while (i < text.length) {
+    let end = Math.min(text.length, i + targetSize);
+    if (end < text.length) {
+      const nextSpace = text.indexOf(" ", end);
+      if (nextSpace !== -1 && nextSpace - end <= 8) end = nextSpace + 1;
+    }
+    out.push(text.slice(i, end));
+    i = end;
+  }
+  return out;
+}
+function simulateStream(doFetch, extractText, errorLabel, options = {}) {
+  const { chunkSize = 32, delayMs = 8, retry } = options;
+  let abortController = new AbortController();
+  return {
+    stream: async function* () {
+      try {
+        const response = await fetchWithRetry(doFetch, abortController.signal, retry ?? {});
+        if (!response.ok) {
+          yield { type: "error", content: `${errorLabel} error: ${response.status}` };
+          return;
+        }
+        const text = await extractText(response);
+        const chunks = chunkText(text, chunkSize);
+        for (const chunk of chunks) {
+          if (abortController === null) return;
+          if (delayMs > 0) {
+            await new Promise((resolve2, reject) => {
+              const timer = setTimeout(resolve2, delayMs);
+              abortController?.signal.addEventListener(
+                "abort",
+                () => {
+                  clearTimeout(timer);
+                  reject(new DOMException("Aborted", "AbortError"));
+                },
+                { once: true }
+              );
+            });
+          }
+          yield { type: "text", content: chunk };
+        }
+        yield { type: "done" };
+      } catch (err) {
+        if (err instanceof DOMException && err.name === "AbortError") return;
+        yield {
+          type: "error",
+          content: err instanceof Error ? err.message : String(err)
+        };
+      }
+    },
+    abort: () => {
+      abortController?.abort();
+      abortController = null;
+    }
+  };
+}
 
 // src/anthropic.ts
 function anthropic(config) {
-  const { apiKey, model, baseUrl = "https://api.anthropic.com", maxTokens = 4096 } = config;
+  const { apiKey, model, baseUrl = "https://api.anthropic.com", maxTokens = 4096, retry } = config;
   return {
+    capabilities: {
+      streaming: true,
+      tools: true,
+      reasoning: model.includes("sonnet") || model.includes("opus"),
+      multiModal: true,
+      usage: true
+    },
     createSource: (request) => {
       const body = {
         model,
@@ -243,7 +438,8 @@ function anthropic(config) {
           signal
         }),
         parseAnthropicStream,
-        "Anthropic API"
+        "Anthropic API",
+        retry
       );
     }
   };
@@ -251,8 +447,17 @@ function anthropic(config) {
 
 // src/openai.ts
 function openai(config) {
-  const { apiKey, model, baseUrl = "https://api.openai.com" } = config;
+  const { apiKey, model, baseUrl = "https://api.openai.com", retry } = config;
   return {
+    capabilities: {
+      streaming: true,
+      tools: true,
+      // o1 / o3 models emit reasoning; older models don't. Accurate per-model
+      // detection would need a model registry; 'true' is the safer default here.
+      reasoning: model.startsWith("o1") || model.startsWith("o3"),
+      multiModal: model.startsWith("gpt-4") || model.startsWith("o"),
+      usage: true
+    },
     createSource: (request) => {
       const body = {
         model,
@@ -280,7 +485,8 @@ function openai(config) {
           signal
         }),
         parseOpenAIStream,
-        "OpenAI API"
+        "OpenAI API",
+        retry
       );
     }
   };
@@ -288,8 +494,14 @@ function openai(config) {
 
 // src/gemini.ts
 function gemini(config) {
-  const { apiKey, model, baseUrl = "https://generativelanguage.googleapis.com" } = config;
+  const { apiKey, model, baseUrl = "https://generativelanguage.googleapis.com", retry } = config;
   return {
+    capabilities: {
+      streaming: true,
+      tools: true,
+      multiModal: true,
+      usage: true
+    },
     createSource: (request) => {
       const body = {
         contents: request.messages.filter((message) => message.role !== "system").map((message) => ({
@@ -312,7 +524,8 @@ function gemini(config) {
           }
         ),
         parseGeminiStream,
-        "Gemini API"
+        "Gemini API",
+        retry
       );
     }
   };
@@ -333,8 +546,14 @@ var grok = createOpenAICompatibleAdapter("https://api.x.ai");
 
 // src/ollama.ts
 function ollama(config) {
-  const { model, baseUrl = "http://localhost:11434" } = config;
+  const { model, baseUrl = "http://localhost:11434", retry } = config;
   return {
+    capabilities: {
+      streaming: true,
+      tools: false,
+      // varies by model; default 'false' — enable via capabilities.extensions if your model supports it
+      multiModal: model.includes("llava") || model.includes("vision")
+    },
     createSource: (request) => {
       const body = {
         model,
@@ -352,7 +571,8 @@ function ollama(config) {
           signal
         }),
         parseOllamaStream,
-        "Ollama API"
+        "Ollama API",
+        retry
       );
     }
   };
@@ -449,8 +669,12 @@ async function* parseVercelStream(stream) {
   yield { type: "done" };
 }
 function vercelAI(config) {
-  const { api, headers = {} } = config;
+  const { api, headers = {}, retry } = config;
   return {
+    capabilities: {
+      // Vercel AI routes can do any of these — whether they do depends on
+      // your route handler. Omit the field instead of lying.
+    },
     createSource: (request) => {
       const body = {
         messages: request.messages.map((message) => ({ role: message.role, content: message.content })),
@@ -465,23 +689,324 @@ function vercelAI(config) {
           signal
         }),
         parseVercelStream,
-        "API"
+        "API",
+        retry
       );
     }
   };
 }
 
+// src/mock.ts
+function mockAdapter(options) {
+  const { response, delayMs = 0, history } = options;
+  let callIndex = 0;
+  return {
+    capabilities: {
+      streaming: true,
+      tools: true,
+      reasoning: true,
+      multiModal: true,
+      usage: true
+    },
+    createSource: (request) => {
+      history?.push(request);
+      const myCall = callIndex++;
+      let cancelled = false;
+      return {
+        stream: async function* () {
+          const chunks = resolve(response, myCall, request);
+          let endedExplicitly = false;
+          for (const chunk of chunks) {
+            if (cancelled) return;
+            if (delayMs > 0) await new Promise((r) => setTimeout(r, delayMs));
+            yield chunk;
+            if (chunk.type === "done" || chunk.type === "error") {
+              endedExplicitly = true;
+            }
+          }
+          if (!endedExplicitly) yield { type: "done" };
+        },
+        abort: () => {
+          cancelled = true;
+        }
+      };
+    }
+  };
+}
+function resolve(response, callIndex, request) {
+  if (Array.isArray(response) && response.length > 0 && Array.isArray(response[0])) {
+    const sequence = response;
+    const item = sequence[callIndex % sequence.length];
+    return item;
+  }
+  if (Array.isArray(response) && response.length > 0 && typeof response[0] === "function") {
+    const sequence = response;
+    return sequence[callIndex % sequence.length](request);
+  }
+  if (typeof response === "function") {
+    return response(request);
+  }
+  return response;
+}
+function recordingAdapter(inner, sink) {
+  return {
+    createSource: (request) => {
+      const innerSource = inner.createSource(request);
+      const captured = [];
+      const recordedAt = (/* @__PURE__ */ new Date()).toISOString();
+      return {
+        stream: async function* () {
+          try {
+            for await (const chunk of innerSource.stream()) {
+              captured.push(chunk);
+              yield chunk;
+            }
+          } finally {
+            await sink.push({ recordedAt, request, chunks: captured });
+          }
+        },
+        abort: () => innerSource.abort()
+      };
+    }
+  };
+}
+function inMemorySink() {
+  const fixture = [];
+  return {
+    fixture,
+    push(turn) {
+      fixture.push(turn);
+    }
+  };
+}
+function replayAdapter(fixture) {
+  if (fixture.length === 0) {
+    throw new Error("replayAdapter: fixture is empty");
+  }
+  return mockAdapter({
+    response: fixture.map((turn) => turn.chunks)
+  });
+}
+
+// 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.chunkText = chunkText;
 exports.createAdapter = createAdapter;
+exports.createOpenAICompatibleEmbedder = createOpenAICompatibleEmbedder;
 exports.deepseek = deepseek;
+exports.deepseekEmbedder = deepseekEmbedder;
+exports.fetchWithRetry = fetchWithRetry;
 exports.gemini = gemini;
+exports.geminiEmbedder = geminiEmbedder;
 exports.generic = generic;
 exports.grok = grok;
+exports.grokEmbedder = grokEmbedder;
+exports.inMemorySink = inMemorySink;
 exports.kimi = kimi;
+exports.kimiEmbedder = kimiEmbedder;
 exports.langchain = langchain;
 exports.langgraph = langgraph;
+exports.mockAdapter = mockAdapter;
 exports.ollama = ollama;
+exports.ollamaEmbedder = ollamaEmbedder;
 exports.openai = openai;
+exports.openaiEmbedder = openaiEmbedder;
+exports.recordingAdapter = recordingAdapter;
+exports.replayAdapter = replayAdapter;
+exports.simulateStream = simulateStream;
 exports.vercelAI = vercelAI;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map