@juspay/neurolink 9.81.1 → 9.81.3

package/dist/types/generate.d.ts

@@ -602,13 +602,17 @@ export type AdditionalMemoryUser = {
  *
  * - `completed` — the model finished on its own (text answer or final_result)
  * - `step-cap` — the `maxSteps` budget ran out while the model still wanted tools
+ * - `context-cap` — the in-loop context guard stopped the tool loop because the
+ *   accumulated conversation approached the model's context window (and the
+ *   terminal synthesis could not produce an answer); without the guard these
+ *   turns died mid-loop on a provider 400 "prompt is too long"
  * - `time-limit` — the `turnTimeoutMs` wall-clock deadline passed
  * - `stalled` — no progress (no chunk, no tool start/finish) for `stallTimeoutMs`
  * - `aborted` — the caller's `abortSignal` ended the turn
  * - `provider-error` — the provider/model failed the turn (e.g. persistent
  *   MALFORMED_FUNCTION_CALL after retry); usually worth a caller-side retry
  */
-export type GenerateStopReason = "completed" | "step-cap" | "time-limit" | "stalled" | "aborted" | "provider-error";
+export type GenerateStopReason = "completed" | "step-cap" | "context-cap" | "time-limit" | "stalled" | "aborted" | "provider-error";
 /**
  * Generate function result type - Primary output format
  * Future-ready for multi-modal outputs while maintaining text focus

package/dist/utils/async/index.d.ts

@@ -20,4 +20,4 @@
  */
 export { delay, sleep } from "./delay.js";
 export { calculateBackoff, createRetry, DEFAULT_RETRY_OPTIONS, RetryExhaustedError, retry, } from "./retry.js";
-export { TimeoutError, withTimeout, withTimeoutFn } from "./withTimeout.js";
+export { TimeoutError, raceWithAbort, withTimeout, withTimeoutFn, } from "./withTimeout.js";

package/dist/utils/async/index.js

@@ -20,4 +20,4 @@
  */
 export { delay, sleep } from "./delay.js";
 export { calculateBackoff, createRetry, DEFAULT_RETRY_OPTIONS, RetryExhaustedError, retry, } from "./retry.js";
-export { TimeoutError, withTimeout, withTimeoutFn } from "./withTimeout.js";
+export { TimeoutError, raceWithAbort, withTimeout, withTimeoutFn, } from "./withTimeout.js";

package/dist/utils/async/withTimeout.d.ts

@@ -49,6 +49,18 @@ export declare class TimeoutError extends Error {
  * ```
  */
 export declare function withTimeout<T>(promise: Promise<T>, ms: number, message?: string): Promise<T>;
+/**
+ * Race a promise against an AbortSignal so the caller observes an abort
+ * IMMEDIATELY instead of waiting for the operation to settle (or for a
+ * separate timeout to expire). Rejects with an abort-shaped error
+ * (`name === "AbortError"`) so provider loops route it to their existing
+ * cancellation handling.
+ *
+ * The underlying operation is NOT cancelled — it continues as a bounded
+ * ghost (the same tradeoff as {@link withTimeout}); its eventual settlement
+ * is swallowed so it can never surface as an unhandled rejection.
+ */
+export declare function raceWithAbort<T>(promise: Promise<T>, signal: AbortSignal | undefined): Promise<T>;
 /**
  * Execute a function with timeout protection.
  *

package/dist/utils/async/withTimeout.js

@@ -72,6 +72,51 @@ export async function withTimeout(promise, ms, message) {
         }
     }
 }
+/**
+ * Race a promise against an AbortSignal so the caller observes an abort
+ * IMMEDIATELY instead of waiting for the operation to settle (or for a
+ * separate timeout to expire). Rejects with an abort-shaped error
+ * (`name === "AbortError"`) so provider loops route it to their existing
+ * cancellation handling.
+ *
+ * The underlying operation is NOT cancelled — it continues as a bounded
+ * ghost (the same tradeoff as {@link withTimeout}); its eventual settlement
+ * is swallowed so it can never surface as an unhandled rejection.
+ */
+export async function raceWithAbort(promise, signal) {
+    if (!signal || typeof signal.addEventListener !== "function") {
+        return promise;
+    }
+    const makeAbortError = () => {
+        const e = new Error("Operation aborted");
+        e.name = "AbortError";
+        return e;
+    };
+    if (signal.aborted) {
+        promise.catch(() => {
+            // Swallow the abandoned settlement — it must never surface as an
+            // unhandled rejection after the race has already been decided.
+        });
+        return Promise.reject(makeAbortError());
+    }
+    return new Promise((resolve, reject) => {
+        const onAbort = () => {
+            promise.catch(() => {
+                // Swallow the abandoned settlement — it must never surface as an
+                // unhandled rejection after the race has already been decided.
+            });
+            reject(makeAbortError());
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        promise.then((value) => {
+            signal.removeEventListener("abort", onAbort);
+            resolve(value);
+        }, (error) => {
+            signal.removeEventListener("abort", onAbort);
+            reject(error);
+        });
+    });
+}
 /**
  * Execute a function with timeout protection.
  *

package/dist/utils/mcpErrorText.d.ts

@@ -24,3 +24,14 @@ export declare function extractMcpErrorText(raw: unknown): string;
  * but no readable text is present, falls back to a generic message.
  */
 export declare function extractMcpToolErrorMessage(result: unknown): string | undefined;
+/**
+ * Detect a tool result that REPORTS failure without throwing, for the native
+ * loops' consecutive-failure breaker. Covers the two shapes NeuroLink itself
+ * produces or forwards:
+ * - MCP CallToolResult with `isError: true` (e.g. proxy-blocked tools) —
+ *   delegated to {@link extractMcpToolErrorMessage}
+ * - our own `{ error: "..." }` payloads
+ * Plain strings are never classified (too false-positive-prone).
+ * Returns the error text, or null when the result looks like a success.
+ */
+export declare function extractToolFailureText(result: unknown): string | null;

package/dist/utils/mcpErrorText.js

@@ -69,3 +69,26 @@ export function extractMcpToolErrorMessage(result) {
         ? `MCP tool returned isError: ${text}`
         : "MCP tool returned isError: true";
 }
+/**
+ * Detect a tool result that REPORTS failure without throwing, for the native
+ * loops' consecutive-failure breaker. Covers the two shapes NeuroLink itself
+ * produces or forwards:
+ * - MCP CallToolResult with `isError: true` (e.g. proxy-blocked tools) —
+ *   delegated to {@link extractMcpToolErrorMessage}
+ * - our own `{ error: "..." }` payloads
+ * Plain strings are never classified (too false-positive-prone).
+ * Returns the error text, or null when the result looks like a success.
+ */
+export function extractToolFailureText(result) {
+    const mcpError = extractMcpToolErrorMessage(result);
+    if (mcpError) {
+        return mcpError;
+    }
+    if (result !== null &&
+        typeof result === "object" &&
+        typeof result.error === "string" &&
+        result.error.length > 0) {
+        return result.error;
+    }
+    return null;
+}