@agentskit/adapters 0.4.2 → 0.5.0

package/README.md

@@ -1,5 +1,7 @@
 # @agentskit/adapters
 
+![stability: stable](https://img.shields.io/badge/stability-stable-brightgreen)
+
 Connect to any LLM provider — and swap between them — without touching your app code.
 
 ## Why

package/dist/index.cjs

@@ -255,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;
@@ -280,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,
@@ -310,7 +438,8 @@ function anthropic(config) {
           signal
         }),
         parseAnthropicStream,
-        "Anthropic API"
+        "Anthropic API",
+        retry
       );
     }
   };
@@ -318,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,
@@ -347,7 +485,8 @@ function openai(config) {
           signal
         }),
         parseOpenAIStream,
-        "OpenAI API"
+        "OpenAI API",
+        retry
       );
     }
   };
@@ -355,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) => ({
@@ -379,7 +524,8 @@ function gemini(config) {
           }
         ),
         parseGeminiStream,
-        "Gemini API"
+        "Gemini API",
+        retry
       );
     }
   };
@@ -400,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,
@@ -419,7 +571,8 @@ function ollama(config) {
           signal
         }),
         parseOllamaStream,
-        "Ollama API"
+        "Ollama API",
+        retry
       );
     }
   };
@@ -516,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 })),
@@ -532,12 +689,105 @@ 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`, {
@@ -733,23 +983,30 @@ var grokEmbedder = createOpenAICompatibleEmbedder("Grok", "https://api.x.ai");
 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