@agent-native/core 0.159.5 → 0.160.0

package/dist/agent/production-agent.js

@@ -14,7 +14,7 @@ import { isMcpToolAllowedForRequest } from "../mcp-client/visibility.js";
 import { shouldInferSentimentForTurn } from "../observability/sentiment.js";
 import { completeRun as completeProgressRun, startRun as startProgressRun, updateRunProgress, } from "../progress/registry.js";
 import { isRuntimeVisibleScope, parseSkillFrontmatter, } from "../server/agent-chat/skill-frontmatter.js";
-import { canUseDeployCredentialFallbackForRequest, getProviderCredentialAuthFailure, readDeployCredentialEnv, } from "../server/credential-provider.js";
+import { canUseDeployCredentialFallbackForRequest, getProviderCredentialAuthFailure, isBuilderGatewayDeployConfigured, readDeployCredentialEnv, } from "../server/credential-provider.js";
 import { readBody } from "../server/h3-helpers.js";
 import { resolveHostedHarnessPolicy } from "../server/hosted-harness-policy.js";
 import { assertRequestActionSurfaceIsolation, getRequestRunContext, ensureRequestRunContext, getRequestContext, getRequestOrgId, getRequestUserEmail, runWithRequestContext, } from "../server/request-context.js";
@@ -27,8 +27,8 @@ import { buildSystemManifestSections, readContextXraySystemSections, } from "./c
 import { AGENT_CHAT_BACKGROUND_RUN_FIELD, AGENT_CHAT_PROCESS_RUN_PATH, backgroundRuntimeDiagnosticDetail, dispatchPathTargetsNetlifyBackgroundFunction, isAgentChatDurableBackgroundEnabled, isAgentChatForegroundSelfChainEnabled, isInBackgroundFunctionRuntime, resolveAgentChatProcessRunDispatchPath, shouldUseBackgroundFunctionTimeoutForWorker, } from "./durable-background.js";
 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 { formatLlmCredentialErrorMessage, LLM_MISSING_CREDENTIALS_ERROR_CODE, LLM_MISSING_CREDENTIALS_MESSAGE, userFacingLlmCredentialError, } from "./engine/credential-errors.js";
+import { isContextOverflowCode, isContextOverflowMessage, isProviderConnectionErrorMessage, } from "./engine/error-detail.js";
 import { resolveEngine, explicitEngineName, 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";
@@ -840,20 +840,17 @@ function toolInputActivityLabel(toolName) {
 export function isContextTooLongError(err) {
     if (!(err instanceof Error))
         return false;
-    const msg = err.message.toLowerCase();
-    if (msg.includes("context_length_exceeded") ||
-        msg.includes("input_too_long") ||
-        msg.includes("too many tokens") ||
-        msg.includes("prompt is too long") ||
-        msg.includes("reduce the length") ||
-        // Gemini phrasing
-        msg.includes("input token count exceeds") ||
-        msg.includes("request too large"))
+    // The engine's structural verdict comes first: it was read off the provider's
+    // own reply, which is not always the message delivered here — a
+    // Builder-credits deployment answers every gateway rejection with one visitor
+    // line, and the gateway reports an overflow as a plain `invalid_request_error`
+    // whose prose was the only signal.
+    if (err instanceof EngineError && err.contextOverflow === true)
+        return true;
+    if (isContextOverflowMessage(err.message))
+        return true;
+    if (err instanceof EngineError && isContextOverflowCode(err.errorCode)) {
         return true;
-    if (err instanceof EngineError) {
-        const code = (err.errorCode ?? "").toLowerCase();
-        if (code.includes("context_length") || code.includes("input_too_long"))
-            return true;
     }
     return false;
 }
@@ -1425,8 +1422,10 @@ export async function callConnectedAgentReference(input) {
             orgSecret: callerAuth.orgSecret,
             onUpdate: relay.observePollUpdate,
         });
-        const responseText = userFacingLlmCredentialError(response, { agentName: input.agent }) ??
-            response;
+        const responseText = userFacingLlmCredentialError(response, {
+            agentName: input.agent,
+            visitorFacing: isBuilderGatewayDeployConfigured(),
+        }) ?? response;
         relay.emitResponseText(responseText);
         relay.finish("done");
         return responseText;
@@ -1564,6 +1563,11 @@ export function isResumableEngineError(err) {
     const code = err instanceof EngineError ? (err.errorCode ?? "").toLowerCase() : "";
     if (code === "builder_gateway_timeout" ||
         code === "builder_gateway_network_error" ||
+        // A gateway stream that stopped mid-turn. It reached here as
+        // `builder_gateway_network_error` until the engine named it, and a
+        // continuation is precisely its recovery: the partial turn is preserved and
+        // the agent is nudged to finish it, where an in-call retry would `clear` it.
+        code === "builder_gateway_stream_ended" ||
         code === "provider_network_error") {
         return true;
     }
@@ -1626,6 +1630,13 @@ export function continuationReasonForResumableError(err) {
     const code = err instanceof EngineError ? (err.errorCode ?? "").toLowerCase() : "";
     if (code === "builder_gateway_timeout")
         return "gateway_timeout";
+    // A gateway/proxy timeout status, read structurally. The prose below says the
+    // same thing on most lanes, but not on a Builder-credits deployment, where the
+    // message is one visitor line.
+    if (err instanceof EngineError &&
+        (err.statusCode === 408 || err.statusCode === 504)) {
+        return "gateway_timeout";
+    }
     const text = err instanceof Error ? err.message.toLowerCase() : "";
     if (text.includes("gateway timeout") ||
         text.includes("upstream timeout") ||
@@ -3737,6 +3748,7 @@ export async function runAgentLoop(opts) {
                                     upgradeUrl: event.upgradeUrl,
                                     statusCode: event.statusCode,
                                     providerRetryable: event.providerRetryable,
+                                    contextOverflow: event.contextOverflow,
                                 });
                             }
                         }
@@ -5132,7 +5144,8 @@ function backgroundChatProgressRunId(turnId) {
         .slice(0, 160);
     return `agent-chat-${normalized || "turn"}`;
 }
-function isRecoverableContinuationError(event) {
+/** @internal exported for unit tests only */
+export function isRecoverableContinuationError(event) {
     const code = String(event.errorCode ?? "").toLowerCase();
     const message = event.error.toLowerCase();
     if (code === "builder_gateway_error")
@@ -5147,12 +5160,26 @@ function isRecoverableContinuationError(event) {
     return (event.recoverable === true ||
         code === "builder_gateway_timeout" ||
         code === "builder_gateway_network_error" ||
+        // Server-driven background continuation for a truncated stream. The message
+        // used to carry this ("stream ended without a stop event", classified into
+        // `builder_gateway_network_error` above); the code carries it now, and on a
+        // Builder-credits deployment the code is all that is left.
+        code === "builder_gateway_stream_ended" ||
         code === "provider_network_error" ||
         code === "stale_run" ||
         code === "timeout" ||
         code === "timeout_error" ||
         code === "http_408" ||
         code === "http_429" ||
+        // The 5xx family the message clauses below used to reach by prose alone
+        // ("temporarily unavailable", "gateway timeout"). The client's own
+        // continuation list (sse-event-processor) has always carried these codes;
+        // the server read the sentence instead, which a Builder-credits deployment
+        // replaces with one visitor line.
+        code === "http_500" ||
+        code === "http_502" ||
+        code === "http_503" ||
+        code === "http_504" ||
         code === "http_529" ||
         code === "run_timeout" ||
         message.includes("timeout") ||
@@ -6514,11 +6541,20 @@ export function createProductionAgentHandler(options) {
             setResponseHeader(event, "Cache-Control", "no-cache");
             setResponseHeader(event, "Connection", "keep-alive");
             const encoder = new TextEncoder();
+            // A Builder-credits deployment serves this chat to visitors with no
+            // account, so the owner-facing "connect a provider" copy is unactionable
+            // for them. It is also what they see most of the time once a gateway auth
+            // failure arms the 15-minute marker: the credits lane stops resolving,
+            // engine selection falls back to the anthropic default, and this branch —
+            // not the engine's own error — is what answers the turn.
+            const missingCredentialsError = formatLlmCredentialErrorMessage({
+                visitorFacing: isBuilderGatewayDeployConfigured(),
+            });
             return new ReadableStream({
                 start(controller) {
                     controller.enqueue(encoder.encode(`data: ${JSON.stringify({
                         type: "error",
-                        error: LLM_MISSING_CREDENTIALS_MESSAGE,
+                        error: missingCredentialsError,
                         errorCode: LLM_MISSING_CREDENTIALS_ERROR_CODE,
                     })}\n\n`));
                     controller.close();
@@ -7630,6 +7666,7 @@ export function createProductionAgentHandler(options) {
                         });
                         const message = userFacingLlmCredentialError(err, {
                             agentName: ref.name,
+                            visitorFacing: isBuilderGatewayDeployConfigured(),
                         }) ?? `Failed to run ${ref.name}: ${err?.message}`;
                         return `<agent-response name="${ref.name}" id="${ref.refId}" type="custom-agent" error="true">\n${message}\n</agent-response>`;
                     }
@@ -7670,6 +7707,7 @@ export function createProductionAgentHandler(options) {
                     catch (err) {
                         const message = userFacingLlmCredentialError(err, {
                             agentName: ref.name,
+                            visitorFacing: isBuilderGatewayDeployConfigured(),
                         }) ?? `Failed to reach ${ref.name}: ${err?.message}`;
                         return `<agent-response name="${ref.name}" id="${ref.refId}" error="true">\n${message}\n</agent-response>`;
                     }

package/dist/agent/run-manager.js

@@ -323,6 +323,10 @@ function shouldCaptureRunError(err) {
     const normalizedCode = errorCode.toLowerCase();
     return (!normalizedCode.startsWith("credits-limit") &&
         normalizedCode !== "builder_gateway_network_error" &&
+        // A truncated gateway stream, which the client continues. It arrived here as
+        // `builder_gateway_network_error` until the engine gave it its own code, so
+        // omitting it would turn a routine recovered interruption into Sentry noise.
+        normalizedCode !== "builder_gateway_stream_ended" &&
         normalizedCode !== PROVIDER_NETWORK_ERROR_CODE &&
         normalizedCode !== "provider_rate_limited" &&
         normalizedCode !== "rate_limit_exceeded");
@@ -1173,6 +1177,32 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
             ...(err instanceof EngineError && err.upgradeUrl
                 ? { upgradeUrl: err.upgradeUrl }
                 : {}),
+            // The engine's own retry verdict, carried structurally. The client
+            // decides auto-continue from this, `recoverable` and the error code, and
+            // a deployment whose visitor copy replaces the message (Builder credits)
+            // leaves it nothing else to read: without this a provider throttle the
+            // engine marked retryable ends the turn on those sites only.
+            //
+            // NOT `recoverable`. That field is the server's own "this run stopped at
+            // an internal continuation boundary" signal, read by
+            // `isInternalContinuationError` (thread-data-builder) to drop the error
+            // from the persisted turn and by `isRecoverableContinuationError`
+            // (production-agent) to self-chain the next background chunk. Neither
+            // lists `rate_limited` or `too_many_concurrent_requests` today, so
+            // feeding them from the engine verdict would newly chain up to
+            // MAX_BACKGROUND_RUN_CONTINUATIONS invocations into a live throttle — on
+            // every lane, not just Builder credits.
+            ...(err instanceof EngineError && err.providerRetryable === true
+                ? { providerRetryable: true }
+                : {}),
+            // Same reasoning as `providerRetryable`: on the credits lane the message
+            // is the visitor line and the code is `invalid_request_error`, so this
+            // flag is the only thing left that says "trim and retry once". Dropping
+            // it here turns a recoverable overflow into a terminal failure on exactly
+            // the sites that cannot read the real reason.
+            ...(err instanceof EngineError && err.contextOverflow === true
+                ? { contextOverflow: true }
+                : {}),
         });
     })
         .finally(async () => {

package/dist/agent/thread-data-builder.js

@@ -10,6 +10,10 @@ function isInternalContinuationError(event) {
         return false;
     return (event.recoverable === true ||
         code === "builder_gateway_timeout" ||
+        // Carries what `msg.includes("stream ended")` below used to: a
+        // Builder-credits deployment replaces that sentence with one visitor line,
+        // and the code is the only thing left that says the turn was truncated.
+        code === "builder_gateway_stream_ended" ||
         code === "stale_run" ||
         code === "timeout" ||
         code === "timeout_error" ||

package/dist/agent/types.d.ts

@@ -375,6 +375,15 @@ export type AgentChatEvent = {
     details?: string;
     /** True when the user can reasonably continue/retry from partial work. */
     recoverable?: boolean;
+    /**
+     * The engine's own verdict that another attempt at the same request may
+     * succeed (`EngineError.providerRetryable`). Distinct from `recoverable`,
+     * which the server's continuation classifiers read as "this run ended at
+     * an internal boundary, fold it and chain the next chunk". A provider
+     * throttle is retryable without being a boundary — conflating them makes
+     * a rate limit self-chain background continuations.
+     */
+    providerRetryable?: boolean;
 }
 /**
  * Legacy SSE terminal event. New streams emit

package/dist/client/agent-chat-adapter.js

@@ -1,6 +1,6 @@
 import { unwrapAttachmentEnvelope } from "@agent-native/toolkit/composer/pasted-text";
 import { actionPreparationContinuationNote } from "../agent/action-continuation-guidance.js";
-import { LLM_MISSING_CREDENTIALS_ERROR_CODE, LLM_MISSING_CREDENTIALS_MESSAGE, } from "../agent/engine/credential-errors.js";
+import { formatLlmCredentialErrorMessage, isLlmCredentialError, LLM_MISSING_CREDENTIALS_ERROR_CODE, LLM_MISSING_CREDENTIALS_MESSAGE, } from "../agent/engine/credential-errors.js";
 import { ANALYTICS_CLIENT_PLATFORM_HEADER } from "../shared/analytics-platform.js";
 import { clearPendingTurnIfMatches, getActiveRun, setActiveRun, updateActiveRunSeq, clearActiveRun, clearActiveRunIfMatches, setPendingTurn, } from "./active-run-state.js";
 import { getAnalyticsClientPlatform } from "./analytics-platform.js";
@@ -199,6 +199,25 @@ const BACKGROUND_TERMINAL_REASON_MESSAGES = {
     missing_credentials: LLM_MISSING_CREDENTIALS_MESSAGE,
     turn_continuation_budget_exhausted: "This request needed more automatic continuations than allowed and was stopped. Try breaking it into smaller steps.",
 };
+/**
+ * Re-decide the mapped copy for whoever is reading it.
+ *
+ * The map above is client-authored copy for a server-produced code, and for the
+ * credential reasons that duplicates a decision the server already makes with
+ * `formatLlmCredentialErrorMessage({ visitorFacing })` — without the one input
+ * the decision needs. Earlier notes called this an unfixable residual gap on the
+ * grounds that the client cannot know the lane; the framing was wrong, because
+ * the lane is a fact about the deployment that the run snapshot can carry
+ * (`deploymentPaysForAi` on `/runs/active`). Everything else in the map is
+ * background-handoff copy that reads the same to either party.
+ */
+function laneAwareTerminalReasonMessage(mapped, terminalReason, deploymentPaysForAi) {
+    if (!mapped || !isLlmCredentialError(mapped, terminalReason))
+        return mapped;
+    return formatLlmCredentialErrorMessage({
+        visitorFacing: deploymentPaysForAi,
+    });
+}
 /**
  * `agent_runs.terminal_reason` values that mark a CHUNK boundary, not the end
  * of the turn — `markBackgroundContinuationChunkTerminal` (production-agent.ts)
@@ -2280,38 +2299,50 @@ export function createAgentChatAdapter(options) {
                     const hasErrorTerminalReason = rawTerminalReason.startsWith("error:");
                     const terminalReason = rawTerminalReason.replace(/^error:/, "");
                     const mappedMessage = terminalReason
-                        ? BACKGROUND_TERMINAL_REASON_MESSAGES[terminalReason]
+                        ? laneAwareTerminalReasonMessage(BACKGROUND_TERMINAL_REASON_MESSAGES[terminalReason], terminalReason, lastKnown?.deploymentPaysForAi === true)
                         : undefined;
                     const mappedErrorCode = terminalReason === "missing_api_key" ||
                         terminalReason === LLM_MISSING_CREDENTIALS_ERROR_CODE
                         ? LLM_MISSING_CREDENTIALS_ERROR_CODE
                         : terminalReason;
-                    if (mappedMessage) {
-                        yield* emitBackgroundTerminalError({
-                            message: mappedMessage,
-                            errorCode: mappedErrorCode,
-                            details: `terminal_reason: ${rawTerminalReason}`,
-                        });
-                        return;
-                    }
                     if (hasErrorTerminalReason) {
-                        if (lastRecoverableRunError) {
+                        // Never REPLACE the wording the server chose for this failure: a
+                        // deployment that pays for its own AI answers whoever is chatting
+                        // with one visitor line, and the map only knows the owner copy.
+                        // Only the captured error whose code IS the terminal reason is that
+                        // wording — an earlier auto-recoverable error in the same run is
+                        // stale (the cursor reset only clears it when the followed run
+                        // changes), and letting it outrank the terminal reason reports a
+                        // transient blip for a run that died of something else.
+                        const serverChosenError = lastRecoverableRunError?.errorCode === terminalReason
+                            ? lastRecoverableRunError
+                            : null;
+                        if (serverChosenError) {
                             yield* emitBackgroundTerminalError({
-                                message: lastRecoverableRunError.message,
-                                errorCode: lastRecoverableRunError.errorCode ||
+                                message: serverChosenError.message,
+                                errorCode: serverChosenError.errorCode ||
                                     mappedErrorCode ||
                                     "background_run_failed",
-                                details: lastRecoverableRunError.details,
+                                details: serverChosenError.details,
                             });
                             return;
                         }
                         yield* emitBackgroundTerminalError({
-                            message: "The agent's background run failed before its final response could be recovered. You can retry from the preserved chat context.",
+                            message: mappedMessage ??
+                                "The agent's background run failed before its final response could be recovered. You can retry from the preserved chat context.",
                             errorCode: mappedErrorCode || "background_run_failed",
                             details: `terminal_reason: ${rawTerminalReason}`,
                         });
                         return;
                     }
+                    if (mappedMessage) {
+                        yield* emitBackgroundTerminalError({
+                            message: mappedMessage,
+                            errorCode: mappedErrorCode,
+                            details: `terminal_reason: ${rawTerminalReason}`,
+                        });
+                        return;
+                    }
                     if (status === "completed") {
                         // The turn finished server-side; the events we managed to fold are
                         // the durable transcript. Never turn a terminal tool-only chunk

package/dist/client/error-format.js

@@ -1,3 +1,4 @@
+import { GATEWAY_UNAVAILABLE_VISITOR_MESSAGE } from "../agent/engine/credential-errors.js";
 /**
  * Append a Builder CTA markdown link to gateway errors that users can fix
  * outside the app. Used by both
@@ -33,8 +34,9 @@ function isSafeUpgradeUrl(url) {
 }
 export function formatChatErrorText(errorMessage, upgradeUrl, errorCode) {
     const normalized = normalizeChatError(errorMessage, errorCode);
-    if (errorCode === "gateway_not_enabled" ||
-        /space has not enabled the LLM gateway/i.test(normalized.message)) {
+    if (!isServerChosenVisitorMessage(normalized.message) &&
+        (errorCode === "gateway_not_enabled" ||
+            /space has not enabled the LLM gateway/i.test(normalized.message))) {
         return `Error: ${normalized.message}\n\n[${OPEN_BUILDER_SPACE_SETTINGS_LABEL}](${BUILDER_SPACE_SETTINGS_URL})`;
     }
     if (errorCode === "builder_gateway_error") {
@@ -49,6 +51,22 @@ export function formatChatErrorText(errorMessage, upgradeUrl, errorCode) {
     }
     return `Error: ${normalized.message}\n\n[${UPGRADE_AT_BUILDER_LABEL}](${upgradeUrl})`;
 }
+/**
+ * True when the server already decided what this reader may be told.
+ *
+ * A Builder-credits deployment answers every gateway rejection with one visitor
+ * line and keeps the real reason on `errorCode` for its owner. Every mapping
+ * below is keyed on that code, so re-deriving copy from it hands the visitor
+ * back the owner instruction the server just removed — "reconnect Builder in
+ * Settings" to someone with no account. This is an identity check against the
+ * exported constant, not a keyword match: the rewrite is the whole message.
+ *
+ * Deliberately not a `KNOWN_CHAT_ERROR_KEYS` entry: that map localizes copy,
+ * while this returns before any mapping runs at all.
+ */
+function isServerChosenVisitorMessage(text) {
+    return text === GATEWAY_UNAVAILABLE_VISITOR_MESSAGE;
+}
 const KNOWN_CHAT_ERROR_KEYS = new Map([
     [
         "No LLM provider is connected. Open this app's Manage agent > LLM, then connect Builder.io or add a provider key.",
@@ -200,6 +218,11 @@ export function normalizeChatError(errorMessage, errorCode) {
     const looksHtml = /<html[\s>]|<body[\s>]|<head[\s>]/i.test(raw);
     const text = looksHtml ? htmlToText(raw) : raw.trim();
     const providerPayload = looksHtml ? null : parseProviderErrorPayload(text);
+    // Ahead of every mapping below, including the provider-payload fallback: the
+    // server already chose this reader's message, and any re-derivation from a
+    // code hands a visitor the owner instruction it deliberately removed.
+    if (isServerChosenVisitorMessage(text))
+        return { message: text };
     const code = normalizeErrorCode(errorCode ?? providerPayload?.errorCode);
     const providerMessage = providerPayload?.errorCode === "overloaded_error"
         ? "The model provider is overloaded right now. Wait a moment, then retry."

package/dist/client/sse-event-processor.d.ts

@@ -91,6 +91,8 @@ export interface SSEEvent {
     upgradeUrl?: string;
     details?: string;
     recoverable?: boolean;
+    /** The engine said another attempt may succeed — see `AgentChatEvent`. */
+    providerRetryable?: boolean;
     maxIterations?: number;
 }
 export type AgentAutoContinueReason = "run_timeout" | "loop_limit" | "no_progress" | "stream_ended" | "stale_run";

package/dist/client/sse-event-processor.js

@@ -534,7 +534,12 @@ function isAutoRecoverableError(ev, errMsg) {
         code === "http_504" ||
         code === "rate_limited" ||
         code === "too_many_concurrent_requests" ||
-        code === "overloaded_error") {
+        code === "overloaded_error" ||
+        // A gateway stream that ended without a stop event. The partial turn is
+        // real, so this continues rather than retrying: the code carries what the
+        // message used to (`msg.includes("stream ended")` below), which a
+        // Builder-credits deployment replaces with its one visitor line.
+        code === "builder_gateway_stream_ended") {
         return true;
     }
     if (ev.recoverable === true)
@@ -548,6 +553,12 @@ function isAutoRecoverableError(ev, errMsg) {
         return false;
     if (msg.includes("daily gateway request cap"))
         return false;
+    // The engine's structural verdict, checked after every terminal code above so
+    // it can never revive a quota or auth rejection. It is the only retry signal
+    // left once the message is one visitor line: an upstream "Overloaded" carries
+    // no code, and its text is what the rewrite removed.
+    if (ev.providerRetryable === true)
+        return true;
     // "gateway error" intentionally absent — that's the no-detail Builder
     // gateway fallback and the production-agent already retries it
     // synchronously up to MAX_RETRIES before the error escapes here. Treating

package/dist/collab/awareness.d.ts

@@ -62,11 +62,11 @@ export declare const postAwareness: import("h3").EventHandlerWithFetch<import("h
     error: string;
     states?: undefined;
 } | {
-    error?: undefined;
     states: {
         clientId: number;
         state: string;
     }[];
+    error?: undefined;
 }>>;
 /**
  * GET /_agent-native/collab/:docId/users
@@ -77,9 +77,9 @@ export declare const getActiveUsers: import("h3").EventHandlerWithFetch<import("
     error: string;
     users?: undefined;
 } | {
-    error?: undefined;
     users: {
         clientId: number;
         lastSeen: number;
     }[];
+    error?: undefined;
 }>>;

package/dist/collab/struct-routes.d.ts

@@ -13,8 +13,8 @@
  * Body: { json: any, fieldName?: string, type?: "map"|"array", requestSource?: string }
  */
 export declare const postCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/file-upload/actions/upload-image.d.ts

@@ -17,11 +17,11 @@ declare const _default: import("../../action.js").ActionDefinition<{
     id?: undefined;
     provider?: undefined;
 } | {
+    error?: undefined;
     configured?: undefined;
     connectPath?: undefined;
     url: string;
     id: string;
     provider: string;
-    error?: undefined;
 }>;
 export default _default;

package/dist/jobs/background-automation-runner.js

@@ -1,5 +1,4 @@
 import { collectFinalResponseTextFromAgentEvents } from "../a2a/response-text.js";
-import { createBuilderEngine } from "../agent/engine/builder-engine.js";
 import { getStoredModelForEngine, normalizeModelForEngine, resolveEngine, } from "../agent/engine/index.js";
 import { actionsToEngineTools, filterInitialEngineTools, getOwnerActiveApiKey, } from "../agent/production-agent.js";
 import { runAgentLoopDirectWithSoftTimeout } from "../agent/run-loop-with-resume.js";
@@ -10,7 +9,6 @@ import { resolveAutomationExecutionIdentity, } from "../automations/service.js";
 import { createThread } from "../chat-threads/store.js";
 import { queryOrgMembers } from "../org/context.js";
 import { organizationIdFromResourceOwner, organizationResourceOwner, } from "../resources/store.js";
-import { resolveBuilderCredentialsDetailed } from "../server/credential-provider.js";
 import { runWithRequestContext, } from "../server/request-context.js";
 import { attachAutomationRunThread, finishAutomationRun, startAutomationRun, } from "./run-history.js";
 const BACKGROUND_RUN_STUCK_MS = 10 * 60_000;
@@ -238,23 +236,19 @@ async function executeBackgroundAutomation(options, deps, historyId) {
         const availableTools = actionsToEngineTools(actions);
         const tools = filterInitialEngineTools(availableTools, initialToolNames);
         const userApiKey = await getOwnerActiveApiKey(ownerEmail);
-        const resolvedEngine = deps.engine ??
+        // The run manager invokes its detached callback after the scheduler's
+        // setup stack has yielded, so the engine's credentials must be captured
+        // now, while the owner/org identity is explicit. Passing
+        // `credentialIdentity` is what makes resolveEngine capture them, on the
+        // same gateway lane the interactive path uses — a Builder-credits site has
+        // no per-user connection to find, so resolving that lane by hand here once
+        // left every scheduled automation dead while chat still worked.
+        const engine = deps.engine ??
             (await resolveEngine({
                 apiKey: userApiKey ?? deps.apiKey,
                 appId: deps.appId,
+                credentialIdentity: { userEmail: ownerEmail, orgId },
             }));
-        // The run manager invokes its detached callback after the scheduler's
-        // setup stack has yielded. Capture the verified Builder pair while the
-        // owner/org identity is explicit, then keep it on the engine so a
-        // concurrent serverless run cannot make this call look unauthenticated.
-        const engine = !deps.engine && resolvedEngine.name === "builder"
-            ? createBuilderEngine({
-                credentials: await resolveBuilderCredentialsDetailed({
-                    userEmail: ownerEmail,
-                    orgId,
-                }),
-            })
-            : resolvedEngine;
         const modelCandidate = automation.meta.model ??
             deps.model ??
             (await getStoredModelForEngine(engine, { appId: deps.appId })) ??

package/dist/mcp/screen-memory-stdio.d.ts

@@ -137,13 +137,13 @@ export declare function screenMemoryMcpToolDefinitions(): ({
     inputSchema: {
         type: string;
         properties: {
+            count?: undefined;
             query?: undefined;
             minutes?: undefined;
             limit?: undefined;
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
-            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;
@@ -159,6 +159,7 @@ export declare function screenMemoryMcpToolDefinitions(): ({
     inputSchema: {
         type: string;
         properties: {
+            count?: undefined;
             query: {
                 type: string;
                 description: string;
@@ -174,7 +175,6 @@ export declare function screenMemoryMcpToolDefinitions(): ({
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
-            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;
@@ -190,6 +190,7 @@ export declare function screenMemoryMcpToolDefinitions(): ({
     inputSchema: {
         type: string;
         properties: {
+            count?: undefined;
             minutes: {
                 type: string;
                 description: string;
@@ -199,7 +200,6 @@ export declare function screenMemoryMcpToolDefinitions(): ({
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
-            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;
@@ -216,6 +216,7 @@ export declare function screenMemoryMcpToolDefinitions(): ({
         type: string;
         required: string[];
         properties: {
+            count?: undefined;
             query: {
                 type: string;
                 description: string;
@@ -234,7 +235,6 @@ export declare function screenMemoryMcpToolDefinitions(): ({
             };
             timestamp?: undefined;
             chapterId?: undefined;
-            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;
@@ -250,6 +250,7 @@ export declare function screenMemoryMcpToolDefinitions(): ({
         type: string;
         required: string[];
         properties: {
+            count?: undefined;
             query?: undefined;
             minutes?: undefined;
             limit?: undefined;
@@ -263,7 +264,6 @@ export declare function screenMemoryMcpToolDefinitions(): ({
                 description: string;
             };
             chapterId?: undefined;
-            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             includeMicrophone?: undefined;
@@ -314,13 +314,13 @@ export declare function screenMemoryMcpToolDefinitions(): ({
         type: string;
         required: string[];
         properties: {
+            count?: undefined;
             query?: undefined;
             minutes?: undefined;
             limit?: undefined;
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
-            count?: undefined;
             startAt: {
                 type: string;
                 description: string;
@@ -349,13 +349,13 @@ export declare function screenMemoryMcpToolDefinitions(): ({
         type: string;
         required: string[];
         properties: {
+            count?: undefined;
             query?: undefined;
             minutes?: undefined;
             limit?: undefined;
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
-            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;