@agent-native/core 0.132.1 → 0.133.0

package/dist/agent/production-agent.js

@@ -26,6 +26,7 @@ import { AGENT_CHAT_BACKGROUND_RUN_FIELD, AGENT_CHAT_PROCESS_RUN_PATH, backgroun
 import { applyContextXrayTransformForIteration } from "./engine/context-directives-transform.js";
 import { attemptContinuationDispatch } from "./engine/continuation-dispatch-retry.js";
 import { LLM_MISSING_CREDENTIALS_ERROR_CODE, LLM_MISSING_CREDENTIALS_MESSAGE, userFacingLlmCredentialError, } from "./engine/credential-errors.js";
+import { isProviderConnectionErrorMessage } from "./engine/error-detail.js";
 import { resolveEngine, registerBuiltinEngines, getStoredModelForEngine, normalizeModelForEngine, isResolvedEngineUsableForRequest, } from "./engine/index.js";
 import { resolveEmptyResponseRetryMaxOutputTokens, resolveMainChatMaxOutputTokens, resolveMaxOutputTokensForEngine, } from "./engine/output-tokens.js";
 import { PROVIDER_TO_ENV } from "./engine/provider-env-vars.js";
@@ -775,21 +776,13 @@ export function isRetryableError(err) {
         msg.includes("gateway error") ||
         msg.includes("socket hang up") ||
         msg.includes("connection reset") ||
-        hasProviderConnectionErrorMessage(msg) ||
+        isProviderConnectionErrorMessage(msg) ||
         msg.includes("too many requests") ||
         msg.includes("timeout") ||
         msg.includes("gateway timeout") ||
         msg.includes("inactivity timeout") ||
         msg.includes("too much time has passed without sending any data"));
 }
-function hasProviderConnectionErrorMessage(message) {
-    const normalized = message.toLowerCase();
-    // Anthropic's APIConnectionError uses "Connection error."; AI SDK wraps
-    // OpenAI TLS failures as "Cannot connect to API". Both can cross a worker
-    // boundary without their structured EngineError metadata.
-    return (normalized.includes("connection error") ||
-        normalized.includes("cannot connect to api"));
-}
 // ---------------------------------------------------------------------------
 // Context-window overflow recovery
 // ---------------------------------------------------------------------------
@@ -1453,7 +1446,7 @@ export function isResumableEngineError(err) {
         text.includes("econnaborted") ||
         text.includes("fetch failed") ||
         text.includes("network error") ||
-        hasProviderConnectionErrorMessage(text) ||
+        isProviderConnectionErrorMessage(text) ||
         text.includes("connection reset") ||
         text.includes("connection closed") ||
         text.includes("stream closed") ||
@@ -4626,7 +4619,7 @@ function isRecoverableContinuationError(event) {
         code === "http_529" ||
         code === "run_timeout" ||
         message.includes("timeout") ||
-        hasProviderConnectionErrorMessage(message) ||
+        isProviderConnectionErrorMessage(message) ||
         message.includes("temporarily unavailable"));
 }
 function endsAtInternalContinuationBoundary(run) {
@@ -4859,7 +4852,7 @@ export async function runAgentLoopWithMainChatInternalContinuations(opts) {
             type: "error",
             error: RUN_BUDGET_EXHAUSTED_MESSAGE,
             errorCode: RUN_BUDGET_EXHAUSTED_ERROR_CODE,
-            recoverable: true,
+            recoverable: false,
         });
     }
     return usage;
@@ -4985,9 +4978,9 @@ export async function claimBackgroundWorkerRunEarly(opts) {
     ]
         .filter(Boolean)
         .join(" ")).catch(() => { });
-    // A failed durable abort read is fail-closed: never let a worker execute
-    // after cancellation just because the database was temporarily unreadable.
-    if (await turnAborted(threadId, turnId).catch(() => true)) {
+    // A failed durable abort read must surface as infrastructure failure. It is
+    // not evidence that the user stopped the turn.
+    if (await turnAborted(threadId, turnId)) {
         await abortRun(opts.runId, "user").catch(() => { });
         return { claimed: false, skipped: "turn-aborted" };
     }
@@ -4996,7 +4989,7 @@ export async function claimBackgroundWorkerRunEarly(opts) {
             dispatchMode: "background",
         }).catch(() => { });
     }
-    if (await turnAborted(threadId, turnId).catch(() => true)) {
+    if (await turnAborted(threadId, turnId)) {
         await abortRun(opts.runId, "user").catch(() => { });
         return { claimed: false, skipped: "turn-aborted" };
     }
@@ -5007,7 +5000,7 @@ export async function claimBackgroundWorkerRunEarly(opts) {
     }
     await record(opts.runId, RUN_DIAG_STAGE.workerClaimed).catch(() => { });
     await heartbeat(opts.runId).catch(() => { });
-    if (await turnAborted(threadId, turnId).catch(() => true)) {
+    if (await turnAborted(threadId, turnId)) {
         await abortRun(opts.runId, "user").catch(() => { });
         return { claimed: false, skipped: "turn-aborted" };
     }
@@ -5348,9 +5341,7 @@ export async function chainServerDrivenContinuation(opts) {
     };
     delete continuationBody[AGENT_CHAT_BACKGROUND_RUN_FIELD];
     try {
-        if (await d
-            .isTurnAborted(effectiveThreadId, effectiveTurnId)
-            .catch(() => true)) {
+        if (await d.isTurnAborted(effectiveThreadId, effectiveTurnId)) {
             await d.markRunAborted(runId, "user").catch(() => { });
             return;
         }
@@ -5387,9 +5378,7 @@ export async function chainServerDrivenContinuation(opts) {
                 .catch(() => { });
             console.error("[agent-chat] continuation insertRun failed; dispatching with inline body:", insertErr instanceof Error ? insertErr.message : insertErr);
         }
-        if (await d
-            .isTurnAborted(effectiveThreadId, effectiveTurnId)
-            .catch(() => true)) {
+        if (await d.isTurnAborted(effectiveThreadId, effectiveTurnId)) {
             if (nextRowInserted)
                 await d.markRunAborted(nextRunId, "user").catch(() => { });
             await d.markRunAborted(runId, "user").catch(() => { });
@@ -6334,7 +6323,7 @@ export function createProductionAgentHandler(options) {
                 ? requestTurnId.trim()
                 : runId;
         if (isBackgroundWorker &&
-            (await isTurnAborted(effectiveThreadId, effectiveTurnId).catch(() => true))) {
+            (await isTurnAborted(effectiveThreadId, effectiveTurnId))) {
             await markRunAborted(runId, "user").catch(() => { });
             return { ok: true, stopped: true };
         }