@agentskit/adapters 0.17.3 → 0.18.0

package/README.md

@@ -258,6 +258,8 @@ const agent = createAgent({ model, tools: [add] })
 ## Stream guarantees
 
 - A stream terminates exactly once with `done` or `error`; terminal errors carry an `Error` in `metadata.error`.
+- Fetch retries use `@agentskit/net` backoff and `Retry-After` parsing; the `fetchWithRetry` and adapter `retry` options keep their 3-attempt defaults. `readSSELines` remains as a deprecated compatibility wrapper; new parsers should consume `parseSSE` events directly.
+- SSE event data preserves whitespace and joins multiple `data:` fields with newlines. NDJSON readers flush a final UTF-8 chunk and accept a last record without a newline.
 - Provider streams that close before their native completion marker are treated as truncated, not successful.
 - `abort(reason)` propagates to active fetch readers and SDK requests and terminates with the same error semantics.
 - Native tool histories preserve call/result correlation. Parallel tool results are encoded in a single provider turn where required.

package/dist/catalog/index.cjs

@@ -1,5 +1,6 @@
 'use strict';
 
+var net = require('@agentskit/net');
 var core = require('@agentskit/core');
 
 // src/catalog/schema.ts
@@ -297135,29 +297136,6 @@ function applyOverrides(snapshot, overrides) {
   const providers = snapshot.providers.map((p) => applyToProvider(p, overrides)).filter((p) => p !== void 0);
   return { ...snapshot, providers };
 }
-
-// src/stream-lines.ts
-async function* readSSELines(stream) {
-  const reader = stream.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  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("data: ")) continue;
-        const data = line.slice(6).trim();
-        if (data) yield data;
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-}
 function isAbortError(err) {
   if (err instanceof DOMException && err.name === "AbortError") return true;
   if (err instanceof Error && err.name === "AbortError") return true;
@@ -297233,7 +297211,78 @@ async function cancelBody(body) {
   }
 }
 
-// src/openai-stream.ts
+// src/retry.ts
+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 (isAbortError(error)) return false;
+    return true;
+  }
+};
+var RetryableResponse = class extends Error {
+  constructor(response, retryAfterMs) {
+    super(`HTTP ${response.status}`);
+    this.response = response;
+    this.retryAfterMs = retryAfterMs;
+  }
+};
+async function fetchWithRetry(doFetch, signal, retryOpt = {}) {
+  const opts = { ...DEFAULT_RETRY, ...retryOpt };
+  const maxAttempts = Math.floor(opts.maxAttempts);
+  if (!Number.isFinite(maxAttempts) || maxAttempts < 1) {
+    throw new core.AdapterError({
+      code: core.ErrorCodes.AK_CONFIG_INVALID,
+      message: "Retry maxAttempts must be finite and at least 1 after flooring"
+    });
+  }
+  if (signal.aborted) throw new DOMException("Aborted", "AbortError");
+  try {
+    return await net.retry(async ({ attempt }) => {
+      let response;
+      try {
+        response = await doFetch(signal);
+      } catch (error) {
+        if (signal.aborted) throw new DOMException("Aborted", "AbortError");
+        throw error;
+      }
+      if (response.ok || attempt >= maxAttempts || !opts.retryOn({ response, attempt })) return response;
+      const retryAfter = net.parseRetryAfter(response.headers.get("retry-after"));
+      await cancelBody(response.body);
+      throw new RetryableResponse(
+        response,
+        retryAfter === void 0 ? void 0 : Math.min(retryAfter, opts.maxDelayMs)
+      );
+    }, {
+      retries: maxAttempts - 1,
+      minDelayMs: opts.baseDelayMs,
+      maxDelayMs: opts.maxDelayMs,
+      jitter: opts.jitter ? "full" : "none",
+      shouldRetry: (error, attempt) => {
+        if (error instanceof RetryableResponse) return true;
+        if (isAbortError(error)) return false;
+        return opts.retryOn({ error, attempt });
+      },
+      delayFor: (error) => error instanceof RetryableResponse ? error.retryAfterMs : void 0,
+      onRetry: ({ error, attempt, delayMs }) => {
+        retryOpt.onRetry?.({
+          attempt,
+          delayMs,
+          reason: error instanceof Error ? error.message : String(error)
+        });
+      },
+      sleep: retryOpt.sleep ? (ms, retrySignal) => abortableSleep(ms, retrySignal ?? signal, retryOpt.sleep) : net.sleep,
+      signal
+    });
+  } catch (error) {
+    if (signal.aborted) throw new DOMException("Aborted", "AbortError");
+    if (error instanceof RetryableResponse) return error.response;
+    throw error;
+  }
+}
 var SUCCESS_FINISH_REASONS = /* @__PURE__ */ new Set(["stop", "tool_calls", "function_call"]);
 async function* parseOpenAIStream(stream) {
   const pendingToolCalls = /* @__PURE__ */ new Map();
@@ -297265,7 +297314,7 @@ async function* parseOpenAIStream(stream) {
     pendingToolCalls.clear();
     return true;
   };
-  for await (const data of readSSELines(stream)) {
+  for await (const { data } of net.parseSSE(stream)) {
     if (data === "[DONE]") {
       if (finishReason !== void 0 && !SUCCESS_FINISH_REASONS.has(finishReason)) {
         pendingToolCalls.clear();
@@ -297368,80 +297417,16 @@ function toProviderMessages(messages) {
   }
   return output;
 }
-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 (isAbortError(error)) return false;
-    return true;
-  }
-};
-function defaultSleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, 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, maxDelayMs) {
-  if (!value) return void 0;
-  const n = Number(value);
-  if (Number.isFinite(n) && n >= 0) return Math.min(n * 1e3, maxDelayMs);
-  const date = Date.parse(value);
-  if (!Number.isNaN(date)) return Math.min(maxDelayMs, 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"), opts.maxDelayMs);
-      const delay = retryAfterMs ?? computeDelay(attempt, opts);
-      retryOpt.onRetry?.({ attempt, delayMs: delay, reason: `HTTP ${response.status}` });
-      await cancelBody(response.body);
-      await abortableSleep(delay, signal, sleep);
-    } catch (err) {
-      lastError = err;
-      if (isAbortError(err)) 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 instanceof Error ? err.message : String(err)
-      });
-      await abortableSleep(delay, signal, sleep);
-    }
-  }
-  throw lastError ?? new Error("fetchWithRetry: exhausted attempts");
-}
 
 // src/stream-source.ts
-function createStreamSource(doFetch, parse, errorLabel, retry) {
+function createStreamSource(doFetch, parse, errorLabel, retry2) {
   let abortController = new AbortController();
   return {
     stream: async function* () {
       const controller = abortController;
       if (!controller) return;
       try {
-        const response = await fetchWithRetry(doFetch, controller.signal, retry ?? {});
+        const response = await fetchWithRetry(doFetch, controller.signal, retry2 ?? {});
         if (!response.ok) {
           await cancelBody(response.body);
           yield adapterErrorChunk(`${errorLabel} error: ${response.status}`);
@@ -297470,7 +297455,7 @@ function createStreamSource(doFetch, parse, errorLabel, retry) {
 
 // src/openai.ts
 function openai(config) {
-  const { apiKey, model, baseUrl = "https://api.openai.com", retry } = config;
+  const { apiKey, model, baseUrl = "https://api.openai.com", retry: retry2 } = config;
   const apiRoot = baseUrl.replace(/\/v1\/?$/, "");
   const isCanonicalOpenAI = (() => {
     try {
@@ -297520,7 +297505,7 @@ function openai(config) {
         }),
         parseOpenAIStream,
         "OpenAI API",
-        retry
+        retry2
       );
     }
   };