@agent-native/core 0.146.5 → 0.146.6

package/dist/mcp-client/routes.js

@@ -24,6 +24,7 @@ import { getSession } from "../server/auth.js";
 import { getH3App } from "../server/framework-request-handler.js";
 import { readBody } from "../server/h3-helpers.js";
 import { runWithRequestContext } from "../server/request-context.js";
+import { shouldDisableInProcessSweeps } from "../server/sweep-runtime.js";
 import { getAllSettings, getSettingsEmitter } from "../settings/store.js";
 import { areBuiltinMcpCapabilitiesSupported, BUILTIN_MCP_CAPABILITIES, getBuiltinMcpCapability, isBuiltinMcpCapabilityAvailable, listSupportedBuiltinMcpCapabilities, normalizeBuiltinMcpCapabilityIds, toBuiltinMcpServerConfig, } from "./builtin-capabilities.js";
 import { builtinMcpCapabilitiesSettingsKey, listEnabledBuiltinMcpCapabilities, setBuiltinMcpCapabilityEnabled, setEnabledBuiltinMcpCapabilities, } from "./builtin-store.js";
@@ -36,6 +37,21 @@ import { addRemoteServer, listRemoteServers, mergedConfigKey, removeRemoteServer
 import { isMcpToolAllowedForRequest } from "./visibility.js";
 import { loadWorkspaceMcpServers } from "./workspace-servers.js";
 export { formatMcpConnectError } from "./errors.js";
+/**
+ * The settings table backing remote/built-in MCP servers could not be read.
+ *
+ * Distinct from `buildMergedConfig()` returning `null`, which means the app is
+ * genuinely configured with zero MCP servers. Coercing an unreachable database
+ * into an empty settings map made every caller report "no MCP servers
+ * configured" while the real answer was "could not read the configuration".
+ */
+export class McpConfigUnreadableError extends Error {
+    constructor(cause) {
+        super(`Could not read MCP configuration from settings: ${cause?.message ?? cause}`);
+        this.name = "McpConfigUnreadableError";
+        this.cause = cause;
+    }
+}
 /** Redact obvious auth header values before sending to the client. */
 function redactHeaders(headers) {
     if (!headers)
@@ -114,7 +130,10 @@ export function builtinMergedConfigKey(scope, capability, ownerId) {
 export async function buildMergedConfig() {
     const base = loadMcpConfig() ?? autoDetectMcpConfig();
     const servers = { ...(base?.servers ?? {}) };
-    const all = await getAllSettings().catch(() => ({}));
+    const all = await getAllSettings().catch((err) => {
+        console.warn(`[mcp-client] settings read failed: ${err?.message ?? err}`);
+        throw new McpConfigUnreadableError(err);
+    });
     for (const [fullKey, value] of Object.entries(all)) {
         const userMatch = /^u:([^:]+):mcp-servers-remote$/.exec(fullKey);
         const orgMatch = /^o:([^:]+):mcp-servers-remote$/.exec(fullKey);
@@ -222,6 +241,12 @@ export function startMcpConfigRefresh(manager) {
     const intervalMs = mcpConfigRefreshIntervalMs();
     if (intervalMs <= 0 || typeof setInterval !== "function")
         return null;
+    // Billed per warm container on serverless, and the first tick always runs a
+    // full settings scan because `settingsDirty` starts true. Request-driven
+    // reconfigures (`waitUntilReady` on the MCP routes, `refreshGlobalMcpManager`)
+    // already cover config changes there, and a fresh container re-reads config.
+    if (shouldDisableInProcessSweeps())
+        return null;
     let currentSignature = sortedConfigSignature(manager.getConfig());
     let refreshing = false;
     // `buildMergedConfig` reads the entire settings table just to diff a

package/dist/notifications/routes.d.ts

@@ -28,6 +28,6 @@ export declare function createNotificationsHandler(): import("h3").EventHandlerW
 } | {
     count?: undefined;
     updated?: undefined;
-    error?: undefined;
     ok: boolean;
+    error?: undefined;
 }>>;

package/dist/progress/routes.d.ts

@@ -15,6 +15,6 @@ export declare function createProgressHandler(): import("h3").EventHandlerWithFe
     error: string;
     ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
+    error?: undefined;
 }>>;

package/dist/provider-api/actions/custom-provider-registration.d.ts

@@ -75,8 +75,8 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
         user: "user";
     }>>;
 }, z.core.$strip>>, {
-    id?: undefined;
     deleted?: undefined;
+    id?: undefined;
     providers: {
         id: string;
         label: string;
@@ -93,10 +93,10 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
     label?: undefined;
     message?: undefined;
 } | {
-    id?: undefined;
     deleted?: undefined;
-    providers?: undefined;
     count?: undefined;
+    id?: undefined;
+    providers?: undefined;
     found: boolean;
     provider: import("../custom-registry.js").CustomProviderConfig;
     registered?: undefined;
@@ -104,8 +104,8 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
     message?: undefined;
 } | {
     deleted?: undefined;
-    providers?: undefined;
     count?: undefined;
+    providers?: undefined;
     provider?: undefined;
     found: boolean;
     id: string;
@@ -113,8 +113,8 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
     label?: undefined;
     message?: undefined;
 } | {
-    providers?: undefined;
     count?: undefined;
+    providers?: undefined;
     provider?: undefined;
     found?: undefined;
     deleted: boolean;
@@ -124,8 +124,8 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
     message?: undefined;
 } | {
     deleted?: undefined;
-    providers?: undefined;
     count?: undefined;
+    providers?: undefined;
     provider?: undefined;
     found?: undefined;
     registered: boolean;

package/dist/provider-api/actions/provider-api.d.ts

@@ -311,10 +311,10 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         notes?: string | undefined;
         scope?: "org" | "user" | undefined;
     }, {
+        message?: undefined;
         id?: undefined;
         provider?: undefined;
         deleted?: undefined;
-        message?: undefined;
         providers: {
             id: string;
             label: string;
@@ -329,29 +329,29 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         registered?: undefined;
         label?: undefined;
     } | {
-        id?: undefined;
+        message?: undefined;
         count?: undefined;
+        id?: undefined;
         deleted?: undefined;
-        message?: undefined;
         providers?: undefined;
         found: boolean;
         provider: import("../custom-registry.js").CustomProviderConfig;
         registered?: undefined;
         label?: undefined;
     } | {
+        message?: undefined;
         count?: undefined;
         provider?: undefined;
         deleted?: undefined;
-        message?: undefined;
         providers?: undefined;
         found: boolean;
         id: string;
         registered?: undefined;
         label?: undefined;
     } | {
+        message?: undefined;
         count?: undefined;
         provider?: undefined;
-        message?: undefined;
         providers?: undefined;
         found?: undefined;
         deleted: boolean;

package/dist/provider-api/corpus-jobs.d.ts

@@ -73,6 +73,7 @@ export declare function createProviderCorpusJobAction(options: CreateProviderCor
     offset?: unknown;
     limit?: unknown;
 }, {
+    deleted?: undefined;
     jobs: {
         id: string;
         name: string;
@@ -83,7 +84,6 @@ export declare function createProviderCorpusJobAction(options: CreateProviderCor
         updatedAt: string;
     }[];
     total: number;
-    deleted?: undefined;
     jobId?: undefined;
 } | {
     jobs?: undefined;
@@ -91,9 +91,9 @@ export declare function createProviderCorpusJobAction(options: CreateProviderCor
     deleted: boolean;
     jobId: string;
 } | {
+    deleted?: undefined;
     jobs?: undefined;
     total?: undefined;
-    deleted?: undefined;
     jobId?: undefined;
     hits: Record<string, unknown>[];
     offset: number;

package/dist/secrets/routes.d.ts

@@ -37,17 +37,17 @@ export declare function createWriteSecretHandler(): import("h3").EventHandlerWit
     ok?: undefined;
     status?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
     status: string;
+    error?: undefined;
 } | {
     ok?: undefined;
     error: string;
     removed?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
     removed: boolean;
+    error?: undefined;
 }>>;
 /**
  * POST /_agent-native/secrets/:key/test — validate an optional candidate value
@@ -58,13 +58,13 @@ export declare function createTestSecretHandler(): import("h3").EventHandlerWith
     error: string;
     note?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
     note?: 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;
+} | {
     ok: boolean;
     removed: boolean;
+    error?: undefined;
 }>>;

package/dist/server/agent-chat/mcp-glue.js

@@ -1,5 +1,5 @@
 import { defineEventHandler, getMethod, setResponseHeader, setResponseStatus, } from "h3";
-import { buildMergedConfig, getHubStatus, } from "../../mcp-client/index.js";
+import { buildMergedConfig, getHubStatus, McpConfigUnreadableError, } from "../../mcp-client/index.js";
 import { getH3App } from "../framework-request-handler.js";
 // ---------------------------------------------------------------------------
 // MCP client glue — a shared manager reference + a /_agent-native/mcp/status
@@ -18,8 +18,17 @@ export async function refreshGlobalMcpManager() {
     const manager = getGlobalMcpManager();
     if (!manager)
         return false;
-    await manager.reconfigure(await buildMergedConfig());
-    return true;
+    try {
+        await manager.reconfigure(await buildMergedConfig());
+        return true;
+    }
+    catch (err) {
+        if (err instanceof McpConfigUnreadableError) {
+            console.warn(`[mcp-client] global refresh skipped: ${err.message}`);
+            return false;
+        }
+        throw err;
+    }
 }
 export function mountMcpHubStatusRoute(nitroApp) {
     const mountedApps = (globalThis.__agentNativeMcpHubStatusMountedApps ??= new WeakSet());

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

@@ -24,11 +24,11 @@ import { runChatThreadDataMigrations } from "../chat-threads/migrations.js";
 import { adoptThreadScopeIfUnscoped, createThread, forkThread, getThread, registerChatThreadsShareable, resolveRunThreadScope, resolveThreadAccess, listThreads, searchThreads, renameThread, createThreadShareLink, getThreadByShareToken, getThreadShareState, revokeThreadShareLink, setThreadArchived, setThreadPinned, setThreadScope, updateThreadData, withThreadDataLock, deleteThread, setThreadQueuedMessages, setThreadSourceIfMissing, } from "../chat-threads/store.js";
 import { isCheckpointRestorePath } from "../checkpoints/route-match.js";
 import { createDbAdminAgentTools } from "../db-admin/agent-tools.js";
-import { isTransientDatabaseError } from "../db/client.js";
+import { isProductionServerlessFunctionRuntime, isTransientDatabaseError, } from "../db/client.js";
 import { filterFrameworkToolGroups, resolveFrameworkTools, } from "../framework-tools.js";
 import { verifyInternalToken, extractBearerToken, } from "../integrations/internal-token.js";
 import { RECURRING_JOBS_SWEEP_PATH, RECURRING_JOBS_SWEEP_TOKEN_SUBJECT, } from "../jobs/scheduler-dispatch.js";
-import { McpClientManager, loadMcpConfig, autoDetectMcpConfig, mcpToolsToActionEntries, syncMcpActionEntries, mountMcpServersRoutes, mountMcpHubRoutes, buildMergedConfig, startMcpConfigRefresh, getHubStatus, isHubServeEnabled, } from "../mcp-client/index.js";
+import { McpClientManager, mcpToolsToActionEntries, syncMcpActionEntries, mountMcpServersRoutes, mountMcpHubRoutes, buildMergedConfig, startMcpConfigRefresh, getHubStatus, isHubServeEnabled, } from "../mcp-client/index.js";
 import { setProgressPreListHook } from "../progress/store.js";
 import { getSkillNameFromPath } from "../resources/metadata.js";
 import { resourceList, resourceListAccessible, resourceGet, ensurePersonalDefaults, SHARED_OWNER, WORKSPACE_OWNER, } from "../resources/store.js";
@@ -309,36 +309,43 @@ export function createAgentChatPlugin(options) {
             const mcpActionEntries = {};
             let mcpInitializationPromise = null;
             const initializeMcpManager = async () => {
-                let mcpConfig = await buildMergedConfig().catch((err) => {
-                    console.warn(`[mcp-client] buildMergedConfig failed: ${err?.message ?? err}`);
-                    return null;
-                });
-                if (!mcpConfig) {
-                    mcpConfig = loadMcpConfig() ?? autoDetectMcpConfig();
-                    if (mcpConfig?.source) {
-                        console.log(`[mcp-client] loaded config from ${mcpConfig.source} (${Object.keys(mcpConfig.servers).length} server(s))`);
-                    }
-                    else if (process.env.DEBUG) {
-                        console.log("[mcp-client] no configured MCP servers — skipping MCP tools");
-                    }
-                }
-                else if (mcpConfig.source) {
+                const mcpConfig = await buildMergedConfig();
+                if (mcpConfig?.source) {
                     console.log(`[mcp-client] merged config (${Object.keys(mcpConfig.servers).length} server(s), source: ${mcpConfig.source})`);
                 }
-                try {
-                    await mcpManager.reconfigure(mcpConfig);
+                else if (process.env.DEBUG) {
+                    console.log("[mcp-client] no configured MCP servers — skipping MCP tools");
                 }
-                catch (err) {
-                    console.warn(`[mcp-client] initialization failed: ${err?.message ?? err}. Continuing without MCP tools.`);
-                }
-                finally {
-                    startMcpConfigRefresh(mcpManager);
+                await mcpManager.reconfigure(mcpConfig);
+                startMcpConfigRefresh(mcpManager);
+            };
+            /**
+             * Start MCP initialization at most once, and return the run in flight.
+             *
+             * On a serverless function nothing kicks this off at boot (see the
+             * `isProductionServerlessFunctionRuntime` gate below), so every surface
+             * that actually consumes MCP tools must await this or the manager stays
+             * empty for the life of the container.
+             */
+            const ensureMcpInitialized = () => {
+                if (!mcpInitializationPromise) {
+                    mcpInitializationPromise = initializeMcpManager().catch((err) => {
+                        // Do not cache a settings outage as a successful empty manager;
+                        // the next MCP-consuming request must retry the configuration read.
+                        mcpInitializationPromise = null;
+                        throw err;
+                    });
                 }
+                return mcpInitializationPromise;
             };
-            const getJobMcpActionEntries = (job) => {
+            const getJobMcpActionEntries = async (job) => {
                 const requested = job?.meta.mcpTools ?? [];
                 if (requested.length === 0)
                     return {};
+                // Background action suppliers may be async so event-triggered and
+                // scheduled runs can await lazy MCP hydration on serverless cold
+                // starts. Runs without requested MCP tools still skip this work.
+                await ensureMcpInitialized();
                 const entries = mcpToolsToActionEntries(mcpManager, {
                     toolNames: requested,
                 });
@@ -354,7 +361,7 @@ export function createAgentChatPlugin(options) {
             mountMcpServersRoutes(nitroApp, mcpManager, {
                 // Serialize an unusually early settings mutation behind the initial
                 // config snapshot so stale startup data cannot overwrite the write.
-                waitUntilReady: () => mcpInitializationPromise ?? Promise.resolve(),
+                waitUntilReady: ensureMcpInitialized,
             });
             // Hub-serve: expose org-scope servers to other agent-native apps in the
             // workspace when `AGENT_NATIVE_MCP_HUB_TOKEN` is set (dispatch, by
@@ -825,25 +832,28 @@ export function createAgentChatPlugin(options) {
             // background surface. Interactive-only tools stay out of it, while
             // shared capabilities such as call-agent and core-send-email cannot
             // drift independently between the two background entry points.
-            const getBackgroundActionEntries = (automation) => ({
-                ...templateScripts,
-                ...resourceScripts,
-                ...docsScripts,
-                ...(lazyContext ? frameworkContextTool : {}),
-                ...urlTools,
-                ...chatScripts,
-                ...callAgentScript,
-                ...jobTools,
-                ...automationTools,
-                ...notificationTools,
-                ...progressTools,
-                ...fetchTool,
-                ...webSearchTool,
-                ...toolActions,
-                ...backgroundCoreEmailTools,
-                ...coreAttachmentTools,
-                ...getJobMcpActionEntries(automation),
-            });
+            const getBackgroundActionEntries = async (automation) => {
+                const mcpActions = await getJobMcpActionEntries(automation);
+                return {
+                    ...templateScripts,
+                    ...resourceScripts,
+                    ...docsScripts,
+                    ...(lazyContext ? frameworkContextTool : {}),
+                    ...urlTools,
+                    ...chatScripts,
+                    ...callAgentScript,
+                    ...jobTools,
+                    ...automationTools,
+                    ...notificationTools,
+                    ...progressTools,
+                    ...fetchTool,
+                    ...webSearchTool,
+                    ...toolActions,
+                    ...backgroundCoreEmailTools,
+                    ...coreAttachmentTools,
+                    ...mcpActions,
+                };
+            };
             // -----------------------------------------------------------------------
             // Production code-execution mode resolution.
             //
@@ -4514,6 +4524,10 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
             // the background worker), so both go through identical context + handler
             // selection.
             const invokeAgentChatHandler = async (event) => {
+                // Chat is the main MCP consumer, and on serverless nothing hydrated the
+                // manager at boot. Awaiting here trades first-chat latency for tools
+                // that are actually present instead of a silently MCP-less run.
+                await ensureMcpInitialized();
                 // Resolve per-request auth context.
                 const ownerContext = await resolveOwnerContext(event);
                 return runWithAgentRunContext({
@@ -4851,6 +4865,10 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                         };
                     }
                     try {
+                        // Jobs may request MCP tools, and `getActions` is synchronous —
+                        // hydrate before the sweep so a serverless container that never
+                        // eagerly initialized still resolves them.
+                        await ensureMcpInitialized();
                         await processRecurringJobs(schedulerDeps);
                         return { ok: true };
                     }
@@ -4913,10 +4931,17 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                     setInterval(() => void sweep(), 30_000);
                 })();
             }
-            mcpInitializationPromise = initializeMcpManager().catch((err) => {
-                console.warn(`[mcp-client] deferred initialization failed: ${err?.message ?? err}`);
-            });
-            void mcpInitializationPromise;
+            // Long-lived runtimes hydrate MCP once at boot. Serverless functions must
+            // not: nothing awaits this, so a settings scan plus third-party MCP
+            // handshakes run on EVERY cold start of every app — including requests
+            // that never touch MCP — and outlive the response on a runtime that
+            // freezes after responding. There, `ensureMcpInitialized()` is driven by
+            // the surfaces that consume MCP tools instead.
+            if (!isProductionServerlessFunctionRuntime()) {
+                void ensureMcpInitialized().catch((err) => {
+                    console.warn(`[mcp-client] eager initialization failed: ${err?.message ?? err}`);
+                });
+            }
             // ─── Agent Teams orphan sweep ─────────────────────────────────────
             // Re-fires stuck/queued dispatches when the browser is closed and the
             // RunsTray's per-user reconciliation never triggers. Runs every 2 minutes

package/dist/server/http-response-telemetry.js

@@ -13,10 +13,21 @@ const TRACKING_INGEST_PATHS = new Set([
     "/api/events/track",
     "/_agent-native/track",
 ]);
+const SLOW_REQUEST_MS = 1_000;
+const SLOW_REQUEST_LOG_EVENT = "agent-native.slow_request";
 const PROCESS_STATE_KEY = Symbol.for("@agent-native/core/http-response-telemetry.process-state");
 const globalRef = globalThis;
+// Process start → this module being evaluated. On a serverless cold start that
+// span is the platform's container boot plus server-bundle evaluation, which
+// happens entirely before any request handler runs and is therefore invisible
+// to every in-handler measurement. Recorded here because module scope is the
+// earliest point our own code can observe. Stored on globalThis so the
+// earliest-evaluated copy wins if the bundle loads this module twice.
 const processState = globalRef[PROCESS_STATE_KEY] ??
-    (globalRef[PROCESS_STATE_KEY] = { requestSequence: 0 });
+    (globalRef[PROCESS_STATE_KEY] = {
+        requestSequence: 0,
+        moduleEvalUptimeMs: Math.max(0, Math.round(process.uptime() * 1_000)),
+    });
 const REQUEST_TELEMETRY_KEY = Symbol.for("@agent-native/core/http-response-telemetry.request");
 const installedApps = new WeakSet();
 function envValue(key) {
@@ -118,7 +129,7 @@ function shouldTrack(pathname, statusCode, state) {
         return true;
     if (state.startupDb)
         return true;
-    if (Date.now() - state.startedAt >= 1_000)
+    if (Date.now() - state.startedAt >= SLOW_REQUEST_MS)
         return true;
     if (state.db.errorCount > 0 || state.db.timeoutCount > 0) {
         return true;
@@ -151,6 +162,10 @@ function runtimeProvider() {
         return "cloudflare-pages";
     return "node";
 }
+/** Module evaluation → this request starting, i.e. idle boot the app paid for. */
+function moduleToRequestMs(state) {
+    return Math.max(0, state.processAgeAtStartMs - processState.moduleEvalUptimeMs);
+}
 function emitTelemetry(event, state, response) {
     const statusCode = responseStatusCode(event, response);
     const pathname = requestPath(event);
@@ -175,6 +190,8 @@ function emitTelemetry(event, state, response) {
             cold_start: state.requestSequence === 1,
             request_sequence: state.requestSequence,
             process_age_ms: state.processAgeAtStartMs,
+            boot_to_module_ms: processState.moduleEvalUptimeMs,
+            module_to_request_ms: moduleToRequestMs(state),
             framework_ready_wait_ms: state.frameworkReadyWaitMs,
             runtime_provider: runtimeProvider(),
             function_name: envValue("AWS_LAMBDA_FUNCTION_NAME"),
@@ -238,20 +255,99 @@ function requestTelemetryState(event) {
 export function getHttpRequestTelemetryId(event) {
     return requestTelemetryState(event)?.requestId;
 }
-function appendServerTiming(response, event, name, durationMs) {
+function appendServerTiming(response, event, name, durationMs, desc) {
     const duration = Math.max(0, Math.round(durationMs));
+    const suffix = desc ? `;desc=${JSON.stringify(desc)}` : "";
     try {
-        response.headers.append("server-timing", `${name};dur=${duration}`);
+        response.headers.append("server-timing", `${name};dur=${duration}${suffix}`);
     }
     catch {
         try {
-            setServerTiming(event, name, { dur: duration });
+            setServerTiming(event, name, desc ? { dur: duration, desc } : { dur: duration });
         }
         catch {
             // Some adapters finalize headers eagerly. Tracking still runs.
         }
     }
 }
+/**
+ * Does this response get stored in a shared (CDN) cache and replayed?
+ *
+ * SSR HTML and React Router `.data` are one impersonal shell hard-cached for
+ * every visitor, so their headers are written ONCE by the origin render and
+ * then handed unchanged to everyone who hits the cache afterwards.
+ */
+function isSharedCacheable(response) {
+    const cacheControl = response.headers.get("cache-control")?.toLowerCase() ?? "";
+    if (!cacheControl)
+        return false;
+    if (/\b(?:no-store|no-cache|private)\b/.test(cacheControl))
+        return false;
+    return (/\bpublic\b/.test(cacheControl) || /\bs-maxage=[1-9]/.test(cacheControl));
+}
+/**
+ * Per-phase `server-timing` entries do NOT belong on a shared-cacheable
+ * response. `app;dur=2159` on a cached shell describes one origin render from
+ * an arbitrary point in the past, yet every later visitor reads it as the cost
+ * of their own request — a stale number wearing a live number's name.
+ *
+ * So a cacheable response gets exactly one entry, `origin`, whose description
+ * leads with the absolute wall-clock time of the render that produced it. Two
+ * visitors comparing notes see the identical timestamp, which is what a replay
+ * is. The live per-invocation breakdown goes to the slow-request log line and
+ * to tracking instead; neither is ever cached.
+ */
+function originSnapshotDesc(state) {
+    const parts = [new Date(state.startedAt).toISOString()];
+    if (state.requestSequence === 1) {
+        parts.push("cold", `boot=${processState.moduleEvalUptimeMs}`, `init=${moduleToRequestMs(state)}`);
+    }
+    if (state.frameworkReadyWaitMs > 0) {
+        parts.push(`startup=${Math.round(state.frameworkReadyWaitMs)}`);
+    }
+    if (state.db.operationCount > 0) {
+        parts.push(`db=${Math.round(state.db.operationWallMs)}`, `dbops=${state.db.operationCount}`);
+    }
+    return parts.join(" ");
+}
+/**
+ * One structured line per cold or slow request, straight to stdout.
+ *
+ * Function logs are the only timing surface readable without a deploy, and
+ * `track()` silently no-ops when no tracking provider is registered — which is
+ * the common case. Deliberately NOT wrapped in a catch: a swallowed emit would
+ * leave a slow request indistinguishable from a fast one.
+ */
+function logSlowRequest(event, state, response, durationMs, pathname) {
+    const coldStart = state.requestSequence === 1;
+    if (!coldStart && durationMs < SLOW_REQUEST_MS)
+        return;
+    console.log(JSON.stringify({
+        event: SLOW_REQUEST_LOG_EVENT,
+        app: getAppName(),
+        method: getMethod(event),
+        path: normalizeHttpTelemetryPath(pathname),
+        status: responseStatusCode(event, response),
+        duration_ms: Math.round(durationMs),
+        cold_start: coldStart,
+        request_sequence: state.requestSequence,
+        boot_to_module_ms: processState.moduleEvalUptimeMs,
+        module_to_request_ms: moduleToRequestMs(state),
+        process_age_ms: state.processAgeAtStartMs,
+        framework_ready_wait_ms: Math.round(state.frameworkReadyWaitMs),
+        db_ms: Math.round(state.db.operationWallMs),
+        db_connect_ms: Math.round(state.db.connectTotalMs),
+        db_operation_count: state.db.operationCount,
+        db_error_count: state.db.errorCount,
+        db_timeout_count: state.db.timeoutCount,
+        startup_db_ms: state.startupDb
+            ? Math.round(state.startupDb.operationWallMs)
+            : undefined,
+        shared_cacheable: response ? isSharedCacheable(response) : undefined,
+        runtime_provider: runtimeProvider(),
+        request_id: state.requestId,
+    }));
+}
 export function recordFrameworkReadyWait(event, durationMs) {
     const state = requestTelemetryState(event);
     if (state) {
@@ -295,7 +391,17 @@ export function installHttpResponseTelemetryHooks(nitroApp) {
                 // Some adapters finalize headers eagerly. Tracking still has the id.
             }
         }
+        if (isSharedCacheable(response)) {
+            appendServerTiming(response, event, "origin", durationMs, originSnapshotDesc(state));
+            logSlowRequest(event, state, response, durationMs, requestPath(event));
+            emitTelemetry(event, state, response);
+            return;
+        }
         appendServerTiming(response, event, "app", durationMs);
+        if (state.requestSequence === 1) {
+            appendServerTiming(response, event, "boot", processState.moduleEvalUptimeMs);
+            appendServerTiming(response, event, "init", moduleToRequestMs(state));
+        }
         if (state.frameworkReadyWaitMs > 0) {
             appendServerTiming(response, event, "startup", state.frameworkReadyWaitMs);
         }
@@ -309,6 +415,7 @@ export function installHttpResponseTelemetryHooks(nitroApp) {
             appendServerTiming(response, event, "startup-db", state.startupDb.operationWallMs);
             appendServerTiming(response, event, "startup-db-connect", state.startupDb.connectTotalMs);
         }
+        logSlowRequest(event, state, response, durationMs, requestPath(event));
         emitTelemetry(event, state, response);
     });
 }

package/dist/server/realtime-token.d.ts

@@ -26,8 +26,8 @@ export declare function createRealtimeTokenHandler(): import("h3").EventHandlerW
     expiresAt?: undefined;
     ttlSeconds?: undefined;
 } | {
-    error?: undefined;
     token: string;
     expiresAt: string;
     ttlSeconds: number;
+    error?: undefined;
 }>>;

package/dist/server/release-migrations.js

@@ -2,6 +2,7 @@ import { CONTEXT_XRAY_MIGRATIONS } from "../agent/context-xray/migrations.js";
 import { OBSERVATIONAL_MEMORY_MIGRATIONS } from "../agent/observational-memory/migrations.js";
 import { runMigrations } from "../db/migrations.js";
 import { runAutomationRunMigrations } from "../jobs/run-history.js";
+import { runAutomationSchedulerHealthMigrations } from "../jobs/scheduler-health.js";
 import { ORG_MIGRATIONS } from "../org/migrations.js";
 import { runBetterAuthMigrations } from "./better-auth-migrations.js";
 /**
@@ -21,4 +22,5 @@ export async function runFrameworkReleaseMigrations(nitroApp) {
         table: "_observational_memory_migrations",
     })(nitroApp);
     await runAutomationRunMigrations(nitroApp);
+    await runAutomationSchedulerHealthMigrations(nitroApp);
 }