@tangle-network/agent-runtime 0.14.0 → 0.14.1

package/dist/index.d.ts

@@ -59,6 +59,14 @@ interface BackendRetryPolicy {
     jitter?: number;
     /** Status codes that trigger a retry. Default: 408, 425, 429, 500, 502, 503, 504. */
     retryStatuses?: ReadonlyArray<number>;
+    /**
+     * Per-attempt wall-clock deadline in ms. If a single fetch attempt does
+     * not return headers within this window the attempt is aborted and
+     * retried. Default 120000 (2 min). Without this a hung upstream blocks
+     * the attempt indefinitely — observed in production as a 15-minute
+     * `fetch failed` that burned an entire eval persona. Set to 0 to disable.
+     */
+    requestTimeoutMs?: number;
 }
 declare function createOpenAICompatibleBackend<TInput extends AgentBackendInput = AgentBackendInput>(options: {
     apiKey: string;

package/dist/index.js

@@ -113,6 +113,32 @@ function pickRetryDelayMs(attempt, policy) {
   const jitter = capped * policy.jitter * (Math.random() * 2 - 1);
   return Math.max(0, Math.round(capped + jitter));
 }
+function withTimeout(callerSignal, timeoutMs) {
+  if (timeoutMs <= 0) {
+    return { signal: callerSignal ?? new AbortController().signal, dispose: () => void 0 };
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(
+    () => controller.abort(new Error(`request timed out after ${timeoutMs}ms`)),
+    timeoutMs
+  );
+  if (typeof timer.unref === "function") {
+    ;
+    timer.unref();
+  }
+  const onCallerAbort = () => controller.abort(callerSignal?.reason ?? new Error("aborted"));
+  if (callerSignal) {
+    if (callerSignal.aborted) onCallerAbort();
+    else callerSignal.addEventListener("abort", onCallerAbort, { once: true });
+  }
+  return {
+    signal: controller.signal,
+    dispose: () => {
+      clearTimeout(timer);
+      callerSignal?.removeEventListener("abort", onCallerAbort);
+    }
+  };
+}
 function sleep(ms, signal) {
   return new Promise((resolve, reject) => {
     if (signal?.aborted) {
@@ -138,7 +164,8 @@ function createOpenAICompatibleBackend(options) {
     initialBackoffMs: options.retry?.initialBackoffMs ?? 1e3,
     maxBackoffMs: options.retry?.maxBackoffMs ?? 3e4,
     jitter: options.retry?.jitter ?? 0.25,
-    retryStatuses: options.retry?.retryStatuses ?? DEFAULT_RETRY_STATUSES
+    retryStatuses: options.retry?.retryStatuses ?? DEFAULT_RETRY_STATUSES,
+    requestTimeoutMs: options.retry?.requestTimeoutMs ?? 12e4
   };
   return {
     kind,
@@ -146,24 +173,40 @@ function createOpenAICompatibleBackend(options) {
       return newRuntimeSession(kind, context.requestedSessionId);
     },
     async *stream(input, context) {
+      const url = `${options.baseUrl.replace(/\/$/, "")}/chat/completions`;
+      const requestBody = JSON.stringify({
+        model: options.model,
+        stream: true,
+        messages: input.messages ?? [
+          { role: "user", content: input.message ?? context.task.intent }
+        ]
+      });
       let response;
       let lastStatus = 0;
+      let lastThrown;
       for (let attempt = 1; attempt <= retryPolicy.maxAttempts; attempt++) {
-        response = await fetcher(`${options.baseUrl.replace(/\/$/, "")}/chat/completions`, {
-          method: "POST",
-          headers: {
-            Authorization: `Bearer ${options.apiKey}`,
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify({
-            model: options.model,
-            stream: true,
-            messages: input.messages ?? [
-              { role: "user", content: input.message ?? context.task.intent }
-            ]
-          }),
-          signal: context.signal
-        });
+        lastThrown = void 0;
+        const attemptSignal = withTimeout(context.signal, retryPolicy.requestTimeoutMs);
+        try {
+          response = await fetcher(url, {
+            method: "POST",
+            headers: {
+              Authorization: `Bearer ${options.apiKey}`,
+              "Content-Type": "application/json"
+            },
+            body: requestBody,
+            signal: attemptSignal.signal
+          });
+        } catch (err) {
+          attemptSignal.dispose();
+          if (context.signal?.aborted) throw err;
+          lastThrown = err;
+          response = void 0;
+          if (attempt === retryPolicy.maxAttempts) break;
+          await sleep(pickRetryDelayMs(attempt, retryPolicy), context.signal);
+          continue;
+        }
+        attemptSignal.dispose();
         if (response.ok) break;
         lastStatus = response.status;
         if (!retryPolicy.retryStatuses.includes(response.status)) break;
@@ -175,7 +218,15 @@ function createOpenAICompatibleBackend(options) {
         const delayMs = pickRetryDelayMs(attempt, retryPolicy);
         await sleep(delayMs, context.signal);
       }
-      if (!response || !response.ok) {
+      if (!response) {
+        const reason = lastThrown instanceof Error ? lastThrown.message : String(lastThrown);
+        throw new BackendTransportError(
+          kind,
+          `chat backend unreachable after ${retryPolicy.maxAttempts} attempts: ${reason}`,
+          { status: 0 }
+        );
+      }
+      if (!response.ok) {
         throw new BackendTransportError(kind, `chat backend returned ${lastStatus || "unknown"}`, {
           status: lastStatus || 0
         });