@agent-native/core 0.141.7 → 0.144.0

package/dist/scripts/call-agent.js

@@ -90,6 +90,23 @@ function terminalTaskError(value) {
             : {}),
     };
 }
+/**
+ * A delegated failure must be an error at the caller's tool boundary. Returning
+ * an `Error: ...` string makes the production agent treat the failed call as a
+ * successful tool result, so it can spend the rest of its turn retrying or
+ * changing arguments while the real failure remains invisible to the loop
+ * breaker.
+ */
+class A2AInvocationError extends Error {
+    taskId;
+    errorCode;
+    constructor(message, options = {}) {
+        super(message);
+        this.name = "A2AInvocationError";
+        this.taskId = options.taskId;
+        this.errorCode = options.errorCode;
+    }
+}
 function buildMessageIdempotencyKey(originatingTurnId, target, exactMessage) {
     if (!originatingTurnId)
         return undefined;
@@ -698,6 +715,12 @@ export async function run(args, context, selfAppId) {
                     ? { terminalCode: invocationTerminalCode }
                     : {}),
             });
+            if (terminalStatus === "error") {
+                throw new A2AInvocationError(responseText || `Error: The ${agent.name} agent returned no result.`, {
+                    taskId: invocationTaskId,
+                    errorCode: invocationTerminalCode,
+                });
+            }
             return (responseText || `Error: The ${agent.name} agent returned no result.`);
         }
         // No context — use the async + poll call so we don't get cut off at the
@@ -745,6 +768,8 @@ export async function run(args, context, selfAppId) {
         return expanded;
     }
     catch (err) {
+        if (err instanceof A2AInvocationError)
+            throw err;
         const msg = err?.message ?? String(err);
         const credentialMessage = formatDownstreamLlmCredentialFailure(agent.name, err);
         if (credentialMessage)
@@ -760,10 +785,13 @@ export async function run(args, context, selfAppId) {
             invocationStatus = "error";
             invocationTaskId = terminal.taskId;
             invocationTerminalCode = terminal.errorCode ?? terminal.state;
-            return (`Error calling ${agent.name}: remote task ${terminal.state}` +
+            throw new A2AInvocationError(`Error calling ${agent.name}: remote task ${terminal.state}` +
                 (terminal.errorCode ? ` (${terminal.errorCode})` : "") +
                 (terminal.taskId ? ` [taskId: ${terminal.taskId}]` : "") +
-                (terminal.responseText ? `: ${terminal.responseText}` : ""));
+                (terminal.responseText ? `: ${terminal.responseText}` : ""), {
+                taskId: terminal.taskId,
+                errorCode: terminal.errorCode ?? terminal.state,
+            });
         }
         const timeoutTaskId = getA2ATaskTimeoutTaskId(err);
         if (timeoutTaskId) {
@@ -777,11 +805,13 @@ export async function run(args, context, selfAppId) {
         if (/timeout|did not complete|Inactivity|504/i.test(msg)) {
             invocationStatus = "error";
             invocationTerminalCode = "timeout_without_task";
-            return `Error calling ${agent.name}: the remote request timed out before a task id could be recovered.`;
+            throw new A2AInvocationError(`Error calling ${agent.name}: the remote request timed out before a task id could be recovered.`, { errorCode: "timeout_without_task" });
         }
         invocationStatus = "error";
         invocationTerminalCode = "call_failed";
-        return `Error calling ${agent.name}: ${msg}`;
+        throw new A2AInvocationError(`Error calling ${agent.name}: ${msg}`, {
+            errorCode: "call_failed",
+        });
     }
     finally {
         trackA2AInvocation({

package/dist/secrets/routes.d.ts

@@ -34,37 +34,37 @@ export declare function createListSecretsHandler(): import("h3").EventHandlerWit
 /** POST /_agent-native/secrets/:key — write a secret. */
 export declare function createWriteSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: string;
-    status?: undefined;
     ok?: undefined;
+    status?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     status: string;
-    error?: undefined;
 } | {
+    ok?: undefined;
     error: string;
     removed?: undefined;
-    ok?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     removed: boolean;
-    error?: undefined;
 }>>;
 /**
  * POST /_agent-native/secrets/:key/test — validate an optional candidate value
  * or the current stored value without changing anything.
  */
 export declare function createTestSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
+    ok?: undefined;
     error: string;
     note?: undefined;
-    ok?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     note?: undefined;
-    error?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     note: string;
-    error?: undefined;
 } | {
     note?: undefined;
     ok: boolean;
@@ -95,11 +95,11 @@ export interface AdHocSecretPayload {
 export declare function createAdHocSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<AdHocSecretPayload[] | {
     error: string;
 } | {
+    error?: undefined;
     ok: boolean;
     key: string;
-    error?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     removed: boolean;
-    error?: undefined;
 }>>;

package/dist/server/agent-chat/action-filters-a2a.d.ts

@@ -75,7 +75,7 @@ type A2AAgentLoopRunner = typeof runAgentLoopDirectWithSoftTimeout;
 export declare const DEFAULT_DELEGATED_MAX_ITERATIONS = 80;
 export declare const DEFAULT_DELEGATED_MAX_RUN_INPUT_TOKENS = 750000;
 export declare const DEFAULT_DELEGATED_MAX_TOOL_RESULT_CHARS = 20000;
-export declare const DELEGATED_AGENT_EXECUTION_CONTRACT = "\n<delegated-agent-contract>\nThis request was delegated by another app. You are the specialist owner of the work.\n- Interpret the caller's natural-language objective using your own instructions, skills, data dictionary, credentials, and tools. Choose providers, schemas, queries, and joins here; never ask the caller to invent SQL or source-specific implementation details for you.\n- Finish the objective autonomously in this delegated turn whenever a safe, reasonable default exists. Do not bounce the work back with UI-navigation requests, implementation questions, or intermediate status. Ask for input only when authorization, missing credentials, or a consequential user choice truly blocks progress.\n- When evidence is incomplete, return the best grounded partial answer with explicit coverage gaps instead of refusing or asking the caller to choose your source, filter, dashboard, or workflow.\n- Minimize round trips. Filter, join, aggregate, paginate, stage, and reduce large datasets inside your own tools rather than returning raw records or transcripts.\n- Return a concise caller-ready result with the answer, source and coverage details, relevant counts or IDs, caveats/partial gaps, and exact artifact URLs. Do not return tool transcripts or large raw payloads.\n</delegated-agent-contract>";
+export declare const DELEGATED_AGENT_EXECUTION_CONTRACT = "\n<delegated-agent-contract>\nThis request was delegated by another app. You are the specialist owner of the work.\n- Interpret the caller's natural-language objective using your own instructions, skills, data dictionary, credentials, and tools. Choose providers, schemas, queries, and joins here; never ask the caller to invent SQL or source-specific implementation details for you.\n- Finish the objective autonomously in this delegated turn whenever a safe, reasonable default exists. Do not bounce the work back with UI-navigation requests, implementation questions, or intermediate status. Ask for input only when authorization, missing credentials, or a consequential user choice truly blocks progress.\n- When evidence is incomplete, return the best grounded partial answer with explicit coverage gaps instead of refusing or asking the caller to choose your source, filter, dashboard, or workflow.\n- Reach for your own registered actions first and by name. They are the same actions this app's interactive chat uses and are almost always the shortest path to the answer. Do not rediscover your own capabilities by exploring, and never use a shell, filesystem, or code-execution tool to do what one of your actions already does \u2014 that is the difference between answering in seconds and answering in minutes.\n- Minimize round trips. Filter, join, aggregate, paginate, stage, and reduce large datasets inside your own tools rather than returning raw records or transcripts.\n- Return a concise caller-ready result with the answer, source and coverage details, relevant counts or IDs, caveats/partial gaps, and exact artifact URLs. Do not return tool transcripts or large raw payloads.\n</delegated-agent-contract>";
 export interface DelegatedAgentLoopTelemetry {
     runId: string;
     threadId: string | null;

package/dist/server/agent-chat/action-filters-a2a.js

@@ -4,6 +4,7 @@ import { collectFinalResponseTextFromAgentEvents } from "../../a2a/response-text
 import { resolveMainChatMaxOutputTokens } from "../../agent/engine/output-tokens.js";
 import { filterInitialEngineTools, resolveAgentRequestReasoningEffort, } from "../../agent/production-agent.js";
 import { runAgentLoopDirectWithSoftTimeout } from "../../agent/run-loop-with-resume.js";
+import { resolveRunSoftTimeoutMs } from "../../agent/run-manager.js";
 import { isAuthenticatedReadAction, isAutoReadExcludedActionName, } from "../../mcp/build-server.js";
 import { withConfiguredAppBasePath } from "../app-base-path.js";
 // ---------------------------------------------------------------------------
@@ -255,12 +256,44 @@ function formatA2ATerminalError(event) {
 export const DEFAULT_DELEGATED_MAX_ITERATIONS = 80;
 export const DEFAULT_DELEGATED_MAX_RUN_INPUT_TOKENS = 750_000;
 export const DEFAULT_DELEGATED_MAX_TOOL_RESULT_CHARS = 20_000;
+/**
+ * A sentence naming the wall clock this delegated step actually gets, or "" when
+ * there is no enforced budget (local dev returns 0 from the resolver).
+ *
+ * "I ran out of time before finishing this step" was 39% of all failed inbound
+ * A2A tasks in one measured week, clustered at 35-46s against a 40s foreground
+ * serverless wall. The callee was never told that wall exists: it is handed a
+ * nominal 80 iterations and 750k tokens and plans accordingly, while production
+ * iterations measure ~34s each — so a foreground chunk affords roughly one.
+ *
+ * The clock is already enforced correctly; a second, cruder cap on iterations
+ * would only waste budget. What was missing is that the agent could not see it.
+ * An agent that knows it has forty seconds scopes to forty seconds.
+ */
+function delegatedTimeBudgetNote(runSoftTimeoutMs, backgroundFunction) {
+    const softTimeoutMs = resolveRunSoftTimeoutMs(runSoftTimeoutMs, {
+        useHostedDefault: true,
+        backgroundFunction,
+    });
+    if (!Number.isFinite(softTimeoutMs) || softTimeoutMs <= 0)
+        return "";
+    const seconds = Math.max(1, Math.round(softTimeoutMs / 1000));
+    return (`\n<delegated-time-budget>\n` +
+        `This step is cut off after about ${seconds} seconds. Scope the work to fit it. ` +
+        `Prefer one decisive action over exploring, and note that a single tool call plus a model ` +
+        `response commonly takes tens of seconds — so plan on completing very few steps, not many. ` +
+        `If the objective cannot be finished in that window, return the best grounded partial answer ` +
+        `and say what is missing. Do not begin work you cannot finish, and do not treat this budget ` +
+        `as a reason to skip verifying what you do report.\n` +
+        `</delegated-time-budget>`);
+}
 export const DELEGATED_AGENT_EXECUTION_CONTRACT = `
 <delegated-agent-contract>
 This request was delegated by another app. You are the specialist owner of the work.
 - Interpret the caller's natural-language objective using your own instructions, skills, data dictionary, credentials, and tools. Choose providers, schemas, queries, and joins here; never ask the caller to invent SQL or source-specific implementation details for you.
 - Finish the objective autonomously in this delegated turn whenever a safe, reasonable default exists. Do not bounce the work back with UI-navigation requests, implementation questions, or intermediate status. Ask for input only when authorization, missing credentials, or a consequential user choice truly blocks progress.
 - When evidence is incomplete, return the best grounded partial answer with explicit coverage gaps instead of refusing or asking the caller to choose your source, filter, dashboard, or workflow.
+- Reach for your own registered actions first and by name. They are the same actions this app's interactive chat uses and are almost always the shortest path to the answer. Do not rediscover your own capabilities by exploring, and never use a shell, filesystem, or code-execution tool to do what one of your actions already does — that is the difference between answering in seconds and answering in minutes.
 - Minimize round trips. Filter, join, aggregate, paginate, stage, and reduce large datasets inside your own tools rather than returning raw records or transcripts.
 - Return a concise caller-ready result with the answer, source and coverage details, relevant counts or IDs, caveats/partial gaps, and exact artifact URLs. Do not return tool transcripts or large raw payloads.
 </delegated-agent-contract>`;
@@ -271,7 +304,9 @@ async function runDelegatedAgentLoop(runOptions, pluginOptions, timeoutOptions,
     const delegatedHardToolResultCap = policy?.maxToolResultChars ?? DEFAULT_DELEGATED_MAX_TOOL_RESULT_CHARS;
     const resolvedRunOptions = {
         ...runOptions,
-        systemPrompt: runOptions.systemPrompt + DELEGATED_AGENT_EXECUTION_CONTRACT,
+        systemPrompt: runOptions.systemPrompt +
+            DELEGATED_AGENT_EXECUTION_CONTRACT +
+            delegatedTimeBudgetNote(pluginOptions.runSoftTimeoutMs, timeoutOptions?.backgroundFunction === true),
         // Delegated runs resolve their own model and do not pass through the
         // interactive request handler's output-token setup. Use the same
         // model-aware headroom here so reasoning models (notably GPT-5.x) do

package/dist/server/agent-chat-plugin.js

@@ -1237,17 +1237,38 @@ export function createAgentChatPlugin(options) {
                         ? ""
                         : await buildSchemaBlock(owner, databaseToolsMode);
                     const extra = await resolveExtraContext(context.event, owner);
+                    const a2aStoredModel = await getStoredModelForEngine(a2aEngine, {
+                        appId: options?.appId,
+                    });
+                    // Preference only, and last before the default: an app that pinned
+                    // a model keeps it. Read separately from the correlation sanitizer
+                    // below so it stays out of every identity/access path.
+                    const a2aCallerModelHint = sanitizeA2ACorrelationMetadata(context.metadata).callerModel;
                     const model = resolveDelegatedRunModel(a2aEngine, {
                         explicitModel: options?.model,
-                        storedModel: await getStoredModelForEngine(a2aEngine, {
-                            appId: options?.appId,
-                        }),
-                        // Preference only, and last before the default: an app that pinned
-                        // a model keeps it. Read separately from the correlation sanitizer
-                        // below so it stays out of every identity/access path.
-                        callerModelHint: sanitizeA2ACorrelationMetadata(context.metadata)
-                            .callerModel,
+                        storedModel: a2aStoredModel,
+                        callerModelHint: a2aCallerModelHint,
                     });
+                    // The interactive path logs its model AND where the model came from;
+                    // this path logged neither, so "the same app answers me in 27s but
+                    // takes 5 minutes when another app asks" had no way to be checked.
+                    // The usual answer is right here: the chat model picker is a
+                    // browser-local preference, so it reaches an interactive turn as the
+                    // highest-precedence request model and never reaches this path at
+                    // all — a delegated turn falls through to the app's stored model or
+                    // the engine default, which can be a different, weaker model.
+                    console.log(`[a2a] resolved engine=${a2aEngine.name} model=${model} ` +
+                        // A hint the callee's engine does not offer is dropped, so the
+                        // label is derived from what actually won — reporting
+                        // "caller-hint" for a rejected hint would send the next person
+                        // debugging this in exactly the wrong direction.
+                        `modelSource=${options?.model
+                            ? "configured"
+                            : a2aStoredModel
+                                ? "stored"
+                                : a2aCallerModelHint && model === a2aCallerModelHint
+                                    ? "caller-hint"
+                                    : "default"} callerHint=${a2aCallerModelHint ?? "(none)"} appId=${options?.appId ?? "(none)"}`);
                     if (a2aRunContext) {
                         a2aRunContext.engine = a2aEngine;
                         a2aRunContext.model = model;

package/dist/server/agent-engine-api-key-route.d.ts

@@ -27,10 +27,10 @@ export declare function resolveAgentEngineApiKeyWriteTarget(event: H3Event, scop
 export declare function createAgentEngineApiKeyHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: any;
 } | {
+    error?: undefined;
     ok: boolean;
     key: string;
     baseUrlKey?: string;
     scope: AgentEngineApiKeyScope;
-    error?: undefined;
 }>>;
 export {};

package/dist/server/auth.js

@@ -48,11 +48,13 @@ import { readBody } from "../server/h3-helpers.js";
 import { putSetting } from "../settings/store.js";
 import { resolveSsrCacheHeaders } from "../shared/cache-control.js";
 import { extractOAuthStateAppId } from "../shared/oauth-state.js";
-import { SIGN_IN_CONTINUATION_PARAM, SIGN_IN_ENTRY_PATH, SIGN_IN_LEGACY_ENTRY_PATH, SIGN_IN_LEGACY_RETURN_PARAM, normalizeAppPath, signInJourney, } from "../shared/sign-in-journey.js";
+import { PASSWORD_MIN_LENGTH, PASSWORD_MIN_LENGTH_MESSAGE, } from "../shared/password-policy.js";
+import { SIGN_IN_CONTINUATION_PARAM, SIGN_IN_ENTRY_PATH, SIGN_IN_LEGACY_ENTRY_PATH, SIGN_IN_LEGACY_RETURN_PARAM, decodeContinuation, normalizeAppPath, signInJourney, } from "../shared/sign-in-journey.js";
 import { AGENT_NATIVE_SOCIAL_IMAGE_ALT, AGENT_NATIVE_SOCIAL_IMAGE_HEIGHT, AGENT_NATIVE_SOCIAL_IMAGE_PATH, AGENT_NATIVE_SOCIAL_IMAGE_TYPE, AGENT_NATIVE_SOCIAL_IMAGE_WIDTH, withAgentNativeSocialImageCacheBuster, } from "../shared/social-meta.js";
 import { normalizeWorkspaceAppAudience, workspaceAppAudienceFromEnv, workspaceAppRouteAccessFromEnv, } from "../shared/workspace-app-audience.js";
 import { isValidWorkspaceAppIdFormat } from "../shared/workspace-app-id.js";
 import { injectAnalyticsIntoHtml } from "./analytics.js";
+import { getConfiguredAppBasePath } from "./app-base-path.js";
 import { readAnalyticsAnonymousId, signupAttributionFromCookieHeader, } from "./attribution.js";
 import { getAuthLoginMode } from "./auth-login-mode.js";
 import { ensureGoogleAuthIdentity, getBetterAuth, getBetterAuthSync, } from "./better-auth-instance.js";
@@ -792,6 +794,35 @@ function getRequestHost(event) {
         getHeader(event, "host") ??
         undefined);
 }
+function parseRequestUrl(rawUrl) {
+    if (!rawUrl)
+        return null;
+    try {
+        return new URL(rawUrl, "http://an.invalid");
+    }
+    catch {
+        // coercion-ok: an invalid request URL has no query context to classify.
+        return null;
+    }
+}
+function hasInitialPromptQuery(rawUrl) {
+    return !!parseRequestUrl(rawUrl)?.searchParams.get("initialPrompt")?.trim();
+}
+function requestHasInitialPrompt(event) {
+    const rawUrl = event.node?.req?.url ?? event.path ?? "/";
+    if (hasInitialPromptQuery(rawUrl))
+        return true;
+    const requestUrl = parseRequestUrl(rawUrl);
+    if (!requestUrl)
+        return false;
+    const continuation = requestUrl.searchParams.get(SIGN_IN_CONTINUATION_PARAM);
+    if (continuation &&
+        hasInitialPromptQuery(decodeContinuation(continuation, getConfiguredAppBasePath()) ?? undefined)) {
+        return true;
+    }
+    const legacyReturn = requestUrl.searchParams.get(SIGN_IN_LEGACY_RETURN_PARAM);
+    return legacyReturn ? hasInitialPromptQuery(legacyReturn) : false;
+}
 function getOnboardingHtmlOptions(options, event, rawPath, authMode) {
     return {
         authMode,
@@ -803,6 +834,7 @@ function getOnboardingHtmlOptions(options, event, rawPath, authMode) {
         requestHost: event ? getRequestHost(event) : undefined,
         requestPath: rawPath,
         requestOrigin: event ? getOrigin(event) : undefined,
+        initialPrompt: event ? requestHasInitialPrompt(event) : false,
     };
 }
 function getAuthOnboardingHtml(options, event, rawPath, authMode) {
@@ -1453,12 +1485,12 @@ function createAuthGuardFn() {
             return;
         if (p === "/_agent-native/speculation-rules.json")
             return;
-        // Liveness probe: always public so uptime monitors and the keep-warm cron
-        // can reach the DB-warmup route without a session. It exposes no per-user
-        // data (just ok/db/ms) and runs a trivial `SELECT 1`. Without this bypass
-        // the gate below 401s anonymous /_agent-native/* requests before any DB
-        // query, so the database would never get warmed.
-        if (p === "/_agent-native/health")
+        // Liveness probes: always public so uptime monitors and the keep-warm cron
+        // can reach them without a session. Ping exposes only a static message;
+        // health exposes only aggregate readiness and a trivial `SELECT 1`.
+        // Without this bypass the gate below 401s anonymous /_agent-native/*
+        // requests before either probe can run.
+        if (p === "/_agent-native/ping" || p === "/_agent-native/health")
             return;
         if (getMethod(event) === "GET" && p.startsWith("/_agent-native/avatar/")) {
             return;
@@ -2805,9 +2837,11 @@ async function mountBetterAuthRoutes(app, options) {
             setResponseStatus(event, 400);
             return { error: VALID_AUTH_EMAIL_MESSAGE };
         }
-        if (!password || typeof password !== "string" || password.length < 8) {
+        if (!password ||
+            typeof password !== "string" ||
+            password.length < PASSWORD_MIN_LENGTH) {
             setResponseStatus(event, 400);
-            return { error: "Password must be at least 8 characters" };
+            return { error: PASSWORD_MIN_LENGTH_MESSAGE };
         }
         if (await isGoogleSignInRequiredForEmail(email)) {
             setResponseStatus(event, 403);
@@ -3049,9 +3083,11 @@ function mountAuthFallbackRoutes(app) {
             setResponseStatus(event, 400);
             return { error: VALID_AUTH_EMAIL_MESSAGE };
         }
-        if (!password || typeof password !== "string" || password.length < 8) {
+        if (!password ||
+            typeof password !== "string" ||
+            password.length < PASSWORD_MIN_LENGTH) {
             setResponseStatus(event, 400);
-            return { error: "Password must be at least 8 characters" };
+            return { error: PASSWORD_MIN_LENGTH_MESSAGE };
         }
         if (await isGoogleSignInRequiredForEmail(email)) {
             setResponseStatus(event, 403);

package/dist/server/better-auth-instance.js

@@ -16,13 +16,14 @@ import { pgTable, text as pgText, timestamp as pgTimestamp, boolean as pgBoolean
 import { sqliteTable, text as sqliteText, integer as sqliteInteger, } from "drizzle-orm/sqlite-core";
 import { TEMPLATES } from "../cli/templates-meta.js";
 import { getDbExec, isPostgres } from "../db/client.js";
-import { getDialect, getDatabaseUrl, getDatabaseAuthToken, closePgliteClients, getPgliteClient, isPgliteUrl, loadPgliteDrizzle, pgPoolOptions, neonPoolMax, attachNeonPoolErrorLogger, sharedDbPool, onSharedDbPoolsClosed, onSharedDbPoolReplaced, } from "../db/client.js";
+import { getDialect, getDatabaseUrl, getDatabaseAuthToken, closePgliteClients, getPgliteClient, isPgliteUrl, loadPgliteDrizzle, pgPoolOptions, neonPoolOptions, attachNeonPoolErrorLogger, sharedDbPool, onSharedDbPoolsClosed, onSharedDbPoolReplaced, } from "../db/client.js";
 import { ensureTableExists } from "../db/ddl-guard.js";
 import { CORE_RESET_PASSWORD_EMAIL_ID, CORE_VERIFY_SIGNUP_EMAIL_ID, } from "../email-catalog/system-emails.js";
 import { saveOAuthTokens } from "../oauth-tokens/store.js";
 import { acceptPendingInvitationsForEmail } from "../org/accept-pending.js";
 import { getAuthEmailForUserId, getRequiredAuthProviderForEmail, } from "../org/auth-policy.js";
 import { autoJoinDomainMatchingOrgs } from "../org/auto-join-domain.js";
+import { PASSWORD_MAX_LENGTH, PASSWORD_MIN_LENGTH, } from "../shared/password-policy.js";
 import { flushTracking, identify, track } from "../tracking/index.js";
 import { getAppProductionUrl } from "./app-url.js";
 import { readAnalyticsAnonymousId, signupAttributionFromCookieHeader, } from "./attribution.js";
@@ -903,7 +904,8 @@ async function createBetterAuthInstance(config) {
         emailAndPassword: {
             enabled: true,
             disableSignUp,
-            minPasswordLength: 8,
+            minPasswordLength: PASSWORD_MIN_LENGTH,
+            maxPasswordLength: PASSWORD_MAX_LENGTH,
             // Hosted deployments always require a working email provider before
             // password signup can create a session. Local dev/test retain the fast
             // path; hosted deployments without a provider disable password signup.
@@ -1195,7 +1197,7 @@ async function buildDatabaseConfig(dialect) {
             // un-capped pool here is a primary contributor to "Max client
             // connections reached" across concurrent serverless instances.
             resetAuthOnPoolClose("neon", url);
-            _neonAuthPool = sharedDbPool("neon", url, () => new Pool({ connectionString: url, max: neonPoolMax() }));
+            _neonAuthPool = sharedDbPool("neon", url, () => new Pool({ connectionString: url, ...neonPoolOptions() }));
             attachNeonPoolErrorLogger(_neonAuthPool, "db/neon-auth");
             const { drizzle } = await import("drizzle-orm/neon-serverless");
             const db = drizzle(buildResilientNeonPool(_neonAuthPool), {

package/dist/server/core-routes-plugin.d.ts

@@ -62,7 +62,6 @@ export declare function resolveAgentEngineStatus<E extends AgentEngineStatusEntr
 export declare function shareAgentEngineStatusLookup(identityKey: string, compute: () => Promise<AgentEngineStatusResult>): Promise<AgentEngineStatusResult>;
 export declare function agentEngineStatusIdentityKey(userEmail: string | undefined, orgId: string | undefined): string;
 export declare function getFrameworkEnvKeys(): EnvKeyConfig[];
-/** Result of the `/_agent-native/health` liveness + DB-warmup probe. */
 export interface DbHealthProbeResult {
     /** The serverless function is live and served the request. */
     ok: true;
@@ -70,6 +69,14 @@ export interface DbHealthProbeResult {
     ready: boolean;
     /** A trivial `SELECT 1` reached the database (false = no DB or unreachable). */
     db: boolean;
+    /**
+     * The probe hit its deadline instead of answering. Reported SEPARATELY from
+     * `db: false`, because "the database said no" and "the database never
+     * replied" are different failures and folding them together is exactly the
+     * coercion this repo bans — a monitor cannot tell an app with no database
+     * from one whose database is hanging.
+     */
+    dbTimedOut?: boolean;
     /** Round-trip time of the probe in milliseconds. */
     ms: number;
     /** Redacted database routing details useful for deploy/runtime checks. */

package/dist/server/core-routes-plugin.js

@@ -242,6 +242,13 @@ export function getFrameworkEnvKeys() {
         })),
     ];
 }
+/** Result of the `/_agent-native/health` liveness + DB-warmup probe. */
+/**
+ * Deliberately generous: a genuinely cold Neon compute can take seconds to
+ * accept its first connection, and reporting a slow-but-working database as
+ * timed out would flap. This is a ceiling on hanging, not a latency budget.
+ */
+const DB_HEALTH_PROBE_DEADLINE_MS = 5_000;
 /**
  * Run a trivial `SELECT 1` to confirm the database is reachable and, as a side
  * effect, keep a scale-to-zero serverless database (e.g. Neon) warm. Touching
@@ -257,12 +264,29 @@ export async function runDbHealthProbe(exec = getDbExec, options = {}) {
     let db = false;
     let schema;
     const dbExec = exec();
+    let dbTimedOut = false;
     try {
-        await dbExec.execute("SELECT 1");
-        db = true;
+        // An UNBOUNDED await here is what took the docs site down: the health route
+        // hung for 20-40s until the CDN returned 502, the keep-warm cron failed
+        // every minute, and the function stayed permanently cold — a ~10x penalty
+        // on every cache miss. This function's own contract says "Always
+        // resolves"; without a deadline it did not.
+        let timer;
+        const deadline = new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error("db probe deadline")), DB_HEALTH_PROBE_DEADLINE_MS);
+        });
+        try {
+            await Promise.race([dbExec.execute("SELECT 1"), deadline]);
+            db = true;
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
     }
-    catch {
+    catch (err) {
         // Live even when the DB is unreachable or the app has no database.
+        dbTimedOut = err?.message === "db probe deadline";
     }
     if (db && options.schema) {
         schema = await runDatabaseSchemaHealthCheck({
@@ -274,6 +298,7 @@ export async function runDbHealthProbe(exec = getDbExec, options = {}) {
         ok: true,
         ready: db && (!schema || schema.ok),
         db,
+        ...(dbTimedOut ? { dbTimedOut: true } : {}),
         ms: Date.now() - startedAt,
         database: {
             configured: database.configured,

package/dist/server/credential-provider.d.ts

@@ -308,9 +308,9 @@ export declare function deleteBuilderCredentials(email: string, options?: {
 export declare function prefetchSecrets(keys: readonly string[]): Promise<void>;
 /**
  * Resolve a request-scoped secret. Reads from `app_secrets` first (current
- * user override, active org, workspace row for that org, then the solo
- * workspace row); falls back to `process.env` only when the deploy fallback
- * policy allows it.
+ * user override, active org, workspace row for that org, the solo workspace
+ * row, then the explicitly designated workspace vault organization); falls
+ * back to `process.env` only when the deploy fallback policy allows it.
  *
  * Resolving several keys in one request? Call `prefetchSecrets` first.
  */

package/dist/server/credential-provider.js

@@ -19,8 +19,56 @@
  */
 import { createHash } from "node:crypto";
 import { CREDENTIAL_STORE_UNAVAILABLE_ERROR_CODE } from "../agent/engine/credential-errors.js";
-import { isLocalDatabase, isTransientDatabaseError } from "../db/client.js";
+import { getDbExec, isLocalDatabase, isTransientDatabaseError, } from "../db/client.js";
+import { getOrgSetting } from "../settings/org-settings.js";
 import { getRequestUserEmail, getRequestOrgId } from "./request-context.js";
+const DISPATCH_VAULT_ACCESS_SETTINGS_KEY = "dispatch-vault-access-settings";
+/**
+ * The designated vault fallback is an all-apps compatibility path. Manual
+ * mode must use the per-app sync path instead, or a known key name would be
+ * enough to read the whole vault from an ungranted workspace app.
+ */
+async function canReadDesignatedVaultFallback(vaultOrgId, credentialKey) {
+    const access = await getOrgSetting(vaultOrgId, DISPATCH_VAULT_ACCESS_SETTINGS_KEY);
+    if (access?.mode !== "manual")
+        return { status: "allowed" };
+    // Manual mode is still usable across a Dispatch vault org and a separate
+    // app org, but only for this app's explicit active grant. The app identity
+    // comes from deployment configuration, never from request input.
+    const appId = [
+        process.env.AGENT_NATIVE_WORKSPACE_APP_ID,
+        process.env.VITE_AGENT_NATIVE_WORKSPACE_APP_ID,
+        process.env.AGENT_NATIVE_APP_ID,
+        process.env.APP_NAME,
+    ]
+        .find((value) => value?.trim())
+        ?.trim();
+    if (!appId) {
+        return { status: "denied", reason: "missing-app-id" };
+    }
+    try {
+        const result = await getDbExec().execute({
+            sql: `SELECT 1
+        FROM vault_grants AS grants
+        INNER JOIN vault_secrets AS secrets ON secrets.id = grants.secret_id
+        WHERE grants.org_id = ?
+          AND grants.app_id = ?
+          AND grants.status = 'active'
+          AND secrets.org_id = grants.org_id
+          AND secrets.credential_key = ?
+        LIMIT 1`,
+            args: [vaultOrgId, appId, credentialKey],
+        });
+        return result.rows.length > 0
+            ? { status: "allowed" }
+            : { status: "denied", reason: "no-active-grant" };
+    }
+    catch (cause) {
+        // A missing/unreadable grant table must fail closed. The app can still
+        // resolve a locally scoped credential or retry after the store recovers.
+        return { status: "unavailable", cause };
+    }
+}
 /**
  * Decide which `app_secrets` scope a Builder/credential write should use.
  *
@@ -998,9 +1046,9 @@ export async function prefetchSecrets(keys) {
 }
 /**
  * Resolve a request-scoped secret. Reads from `app_secrets` first (current
- * user override, active org, workspace row for that org, then the solo
- * workspace row); falls back to `process.env` only when the deploy fallback
- * policy allows it.
+ * user override, active org, workspace row for that org, the solo workspace
+ * row, then the explicitly designated workspace vault organization); falls
+ * back to `process.env` only when the deploy fallback policy allows it.
  *
  * Resolving several keys in one request? Call `prefetchSecrets` first.
  */
@@ -1100,6 +1148,44 @@ export async function resolveSecretDetailed(key) {
                 }
                 return { value: soloWorkspaceSecret.value, lookupFailed: false };
             }
+            // Dispatch's workspace vault is stored under the organization that
+            // performed the sync. AGENT_VAULT_ORG_ID is an explicit single-workspace
+            // deployment assertion; without it, never guess which other tenant owns
+            // a shared key. This fallback keeps workspace apps from requiring every
+            // builder to copy a vault key into app-local settings.
+            const vaultOrgId = process.env.AGENT_VAULT_ORG_ID?.trim();
+            if (vaultOrgId && vaultOrgId !== orgId) {
+                const designatedVaultAccess = await canReadDesignatedVaultFallback(vaultOrgId, key);
+                if (designatedVaultAccess.status === "unavailable") {
+                    lookupFailed = true;
+                    cause = designatedVaultAccess.cause;
+                }
+                if (designatedVaultAccess.status === "allowed") {
+                    const [vaultOrgRead, vaultWorkspaceRead] = await Promise.allSettled([
+                        readAppSecret({ key, scope: "org", scopeId: vaultOrgId }),
+                        readAppSecret({ key, scope: "workspace", scopeId: vaultOrgId }),
+                    ]);
+                    const unwrap = (settled) => {
+                        if (settled.status === "rejected")
+                            throw settled.reason;
+                        return settled.value;
+                    };
+                    const vaultOrgSecret = unwrap(vaultOrgRead);
+                    if (vaultOrgSecret?.value) {
+                        if (traceLookup) {
+                            console.log(`[resolve-secret] key=${key} email=${email} vaultOrgId=${vaultOrgId} scope=org-vault hit=true`);
+                        }
+                        return { value: vaultOrgSecret.value, lookupFailed: false };
+                    }
+                    const vaultWorkspaceSecret = unwrap(vaultWorkspaceRead);
+                    if (vaultWorkspaceSecret?.value) {
+                        if (traceLookup) {
+                            console.log(`[resolve-secret] key=${key} email=${email} vaultOrgId=${vaultOrgId} scope=workspace-vault hit=true`);
+                        }
+                        return { value: vaultWorkspaceSecret.value, lookupFailed: false };
+                    }
+                }
+            }
         }
         catch (err) {
             if (traceLookup) {

package/dist/server/onboarding-html.d.ts

@@ -25,6 +25,8 @@ export interface OnboardingHtmlOptions {
     googleOnly?: boolean;
     /** Authentication surface to render. Defaults to the existing password flow. */
     authMode?: "magic-link" | "password";
+    /** Render the quiet, centered auth surface used when the app has an initial prompt. */
+    initialPrompt?: boolean;
     /**
      * Product marketing content shown alongside the sign-in form.
      * When provided, the page uses a split layout: marketing on the left,