@agent-native/core 0.207.0-nightly-20261011124220 → 0.207.0

package/dist/agent/production-agent.js

@@ -8846,6 +8846,16 @@ export function createProductionAgentHandler(options) {
         const isReaperSuccessor = isBackgroundWorker &&
             typeof mutableBody[AGENT_CHAT_RECOVERY_OF_RUN_FIELD] === "string" &&
             Boolean(mutableBody[AGENT_CHAT_RECOVERY_OF_RUN_FIELD]);
+        const isClientTurnContinuation = !isBackgroundWorker &&
+            internalContinuation === true &&
+            !continueOf &&
+            !requestedApprovedToolCalls?.length &&
+            typeof message === "string" &&
+            message.startsWith(AGENT_INTERNAL_CONTINUE_PROMPT) &&
+            typeof threadId === "string" &&
+            threadId.trim().length > 0 &&
+            typeof requestTurnId === "string" &&
+            requestTurnId.trim().length > 0;
         const runId = backgroundRunMarker?.runId ?? generateRunId();
         const effectiveThreadId = threadId ?? runId;
         const effectiveTurnId = typeof backgroundRunMarker?.turnId === "string" &&
@@ -9008,7 +9018,10 @@ export function createProductionAgentHandler(options) {
         // A server successor and a continuation, automatic or chosen, resume the
         // same turn the same way: the thread's tool calls and results, plus the turn's
         // journal of finished steps, so nothing already done is sent again.
-        if ((isChainedBackgroundContinuation || isReaperSuccessor || continueOf) &&
+        if ((isChainedBackgroundContinuation ||
+            isReaperSuccessor ||
+            continueOf ||
+            isClientTurnContinuation) &&
             effectiveThreadId) {
             try {
                 const { getThread } = await import("../chat-threads/store.js");
@@ -9022,12 +9035,14 @@ export function createProductionAgentHandler(options) {
                 // A continuation always follows a stopped run, so a thread without
                 // that turn's prompt means its history was lost, not that there was
                 // none. A successor stays best-effort and resumes from what is there.
-                if (continueOf && !foundTurnPrompt) {
+                if ((continueOf || isClientTurnContinuation) && !foundTurnPrompt) {
                     throw new Error(`thread ${effectiveThreadId} has no turn prompt`);
                 }
                 // Resuming takes the thread's newest prompt, so a newer one, even one
                 // whose run never started, would run under this turn's journal.
-                const promptTurnId = continueOf && threadData ? latestPromptTurnId(threadData) : undefined;
+                const promptTurnId = (continueOf || isClientTurnContinuation) && threadData
+                    ? latestPromptTurnId(threadData)
+                    : undefined;
                 if (promptTurnId && promptTurnId !== effectiveTurnId) {
                     if (await updateRunStatusIfRunning(runId, "errored")) {
                         await setRunTerminalReason(runId, CONTINUE_UNAVAILABLE_CODE);
@@ -9044,9 +9059,11 @@ export function createProductionAgentHandler(options) {
                         ? backgroundRunMarker.continuationReason
                         : isReaperSuccessor
                             ? "network_interrupted"
-                            : "run_timeout";
+                            : isClientTurnContinuation
+                                ? "stream_ended"
+                                : "run_timeout";
                     const journalRead = await loadPriorTurnToolCallJournal(effectiveThreadId, effectiveTurnId);
-                    if ((continueOf || isReaperSuccessor) &&
+                    if ((continueOf || isReaperSuccessor || isClientTurnContinuation) &&
                         journalRead.status === "unreadable") {
                         throw new Error(journalRead.error);
                     }
@@ -9073,7 +9090,7 @@ export function createProductionAgentHandler(options) {
                 }
             }
             catch (error) {
-                if (continueOf || isReaperSuccessor) {
+                if (continueOf || isReaperSuccessor || isClientTurnContinuation) {
                     // The browser's history lacks the stopped run's tool results, so
                     // continuing from it could repeat a step that already finished.
                     console.warn(`[agent-chat] auto-continue history unreadable for thread ${effectiveThreadId}:`, error);

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

@@ -1587,7 +1587,8 @@ export function foldThreadRunSuggestions(repo, run) {
         oldRun.lastSequence >= 0
         ? oldRun.lastSequence
         : 0;
-    const lastSequence = run.events.reduce((maximum, { seq }) => Number.isSafeInteger(seq) && seq >= 0 ? Math.max(maximum, seq) : maximum, previousSequence);
+    // Runtime event sequence numbers and AgentKit protocol cursors are separate.
+    const lastSequence = previousSequence;
     const snapshot = {
         ...oldRun,
         id: run.runId,
@@ -2287,9 +2288,11 @@ function mergeAgentKitHistory(existing, incoming, promptRunIds, onAnnotationConf
         if (Array.isArray(merged.suggestions)) {
             merged.suggestions = merged.suggestions.filter((suggestion) => suggestion?.runId === latest?.id);
         }
-        if (Array.isArray(merged.activeRunIds)) {
-            merged.activeRunIds = merged.activeRunIds.filter((id) => !["completed", "failed", "cancelled"].includes(runs.get(id)?.status ?? ""));
-        }
+        const activeRunIds = new Set([
+            ...(Array.isArray(previous.activeRunIds) ? previous.activeRunIds : []),
+            ...(Array.isArray(next.activeRunIds) ? next.activeRunIds : []),
+        ]);
+        merged.activeRunIds = [...activeRunIds].filter((id) => !["completed", "failed", "cancelled"].includes(runs.get(id)?.status ?? ""));
     }
     const existingMessageRunIds = snapshotMessageRunIds(previous);
     const incomingMessageRunIds = snapshotMessageRunIds(next);

package/dist/cli/eval.js

@@ -382,11 +382,27 @@ async function runPromote(args) {
     process.exit(0);
 }
 async function readReviewFile(filePath) {
-    const contents = await fs.readFile(path.resolve(filePath), "utf8");
-    if (Buffer.byteLength(contents, "utf8") > MAX_REVIEW_FILE_BYTES) {
-        throw new Error("Reviewed input file exceeds the 64 KiB limit.");
+    const handle = await fs.open(path.resolve(filePath), "r");
+    try {
+        if ((await handle.stat()).size > MAX_REVIEW_FILE_BYTES) {
+            throw new Error("Reviewed input file exceeds the 64 KiB limit.");
+        }
+        const buffer = Buffer.alloc(MAX_REVIEW_FILE_BYTES + 1);
+        let bytesRead = 0;
+        while (bytesRead < buffer.length) {
+            const result = await handle.read(buffer, bytesRead, buffer.length - bytesRead, bytesRead);
+            if (result.bytesRead === 0)
+                break;
+            bytesRead += result.bytesRead;
+        }
+        if (bytesRead > MAX_REVIEW_FILE_BYTES) {
+            throw new Error("Reviewed input file exceeds the 64 KiB limit.");
+        }
+        return buffer.subarray(0, bytesRead).toString("utf8");
+    }
+    finally {
+        await handle.close();
     }
-    return contents;
 }
 async function readReviewedPromptFile(filePath, maxLength) {
     const prompt = await readReviewFile(filePath);

package/dist/client/analytics/index.d.ts

@@ -1,2 +1,2 @@
-export { AGENT_NATIVE_EXCEPTION_EVENT_NAME, addErrorBreadcrumb, captureAttribution, captureClientException, captureError, captureException, captureMessage, clearAnalyticsSessionId, configureTracking, getAnalyticsAnonymousId, getAnalyticsSessionId, getFirstTouchAttribution, getLastTouchAttribution, getSessionReplayContext, getSessionReplayUrl, isErrorCaptureInstalled, maybeStartSessionReplay, setAnalyticsSessionId, setSentryUser, setTrackingContentCaptureEnabled, setTrackingIdentity, startSessionReplay, stopSessionReplay, trackAgentChatLifecycle, trackAnonymousEvent, trackEvent, trackLifecycleEvent, trackSessionStatus, type AgentChatLifecycleEvent, type CaptureExceptionContext, type CapturedExceptionEvent, type ClientCaptureContext, type ConfigureTrackingOptions, type ErrorCaptureConfigOptions, type ExceptionBreadcrumb, type ExceptionLevel, type FirstTouchAttribution, type LastTouchAttribution, type SessionReplayContext, type SessionReplayLinkOptions, type SessionReplayOptions, type SessionReplayStartResult, type SessionReplayUrlMatcher, type TrackingIdentityUser, } from "../analytics.js";
+export { AGENT_NATIVE_EXCEPTION_EVENT_NAME, addErrorBreadcrumb, captureAttribution, captureClientException, captureError, captureException, captureMessage, clearAnalyticsSessionId, configureTracking, getAnalyticsAnonymousId, getAnalyticsSessionId, getFirstTouchAttribution, getLastTouchAttribution, getSessionReplayContext, getSessionReplayUrl, isErrorCaptureInstalled, maybeStartSessionReplay, setAnalyticsSessionId, setSentryUser, setTrackingContentCaptureEnabled, setTrackingIdentity, startSessionReplay, stopSessionReplay, trackAgentChatLifecycle, trackAnonymousEvent, trackEvent, trackLifecycleEvent, trackSessionStatus, type AgentChatLifecycleEvent, type CaptureAttributionOptions, type CaptureExceptionContext, type CapturedExceptionEvent, type ClientCaptureContext, type ConfigureTrackingOptions, type ErrorCaptureConfigOptions, type ExceptionBreadcrumb, type ExceptionLevel, type FirstTouchAttribution, type LastTouchAttribution, type SessionReplayContext, type SessionReplayLinkOptions, type SessionReplayOptions, type SessionReplayStartResult, type SessionReplayUrlMatcher, type TrackingIdentityUser, } from "../analytics.js";
 export { track } from "../track.js";

package/dist/client/analytics.d.ts

@@ -113,12 +113,21 @@ export declare function getAnalyticsAnonymousId(): string | undefined;
 export declare function getAnalyticsSessionId(): string | undefined;
 export declare function getFirstTouchAttribution(): FirstTouchAttribution | null;
 export declare function getLastTouchAttribution(): LastTouchAttribution | null;
+export interface CaptureAttributionOptions {
+    /**
+     * The app path this visit entered, when the page isn't it. The sign-in page
+     * stands in front of the path the visitor asked for, and `landing_path`
+     * must name that path, not the sign-in page.
+     */
+    landingPath?: string;
+}
 /**
  * Store the visitor's first and last touch now instead of in
- * `configureTracking()`, for a page that reads them before tracking starts.
- * It runs once per page load, so tracking's own capture is then a no-op.
+ * `configureTracking()`, for a page that reads them before tracking starts,
+ * or that never starts tracking, like the sign-in page. It runs once per page
+ * load, so tracking's own capture is then a no-op.
  */
-export declare function captureAttribution(): void;
+export declare function captureAttribution(options?: CaptureAttributionOptions): void;
 export declare function setSentryUser(user: TrackingIdentityUser | null, orgId?: string | null): void;
 export declare function setTrackingIdentity(user: TrackingIdentityUser | null, orgId?: string | null): void;
 export interface ClientCaptureContext {

package/dist/client/analytics.js

@@ -1,7 +1,7 @@
 import { recordTrackingEvent } from "../observability/tracing.js";
 import { AGENT_NATIVE_LIFECYCLE_EVENTS, AGENT_SIGNALS_PAGEVIEW_PROPERTY, AGENT_SIGNALS_VERSION, canonicalTrackingEvent, legacyLifecycleEvent, normalizeTrackingDimension, PAGE_LOAD_PAGEVIEW_PROPERTY, isWaitedActionResponse, SLOW_ACTION_RESPONSE_MS, TRACKING_EVENT_ALIAS_ID_PROPERTY, withCanonicalTrackingProperties, } from "../shared/analytics-events.js";
 import { ANALYTICS_CLIENT_PLATFORM_PROPERTY, } from "../shared/analytics-platform.js";
-import { hasAttributionSource } from "../shared/attribution-source.js";
+import { hasAttributionSource, } from "../shared/attribution-source.js";
 import { resolveLaneEndpoint } from "../shared/environment-lanes.js";
 import { classifyErrorNoise, } from "../shared/error-noise.js";
 import { llmConnectionTrackingProperties, } from "../shared/llm-connection.js";
@@ -444,7 +444,7 @@ function scrubReferrerHost(referrer) {
         return "";
     }
 }
-function buildFirstTouchAttribution() {
+function buildFirstTouchAttribution(landingPathname) {
     const attribution = {};
     let params = null;
     try {
@@ -460,7 +460,7 @@ function buildFirstTouchAttribution() {
                 attribution[field] = value;
         }
     }
-    const landingPath = truncateFirstTouchField(window.location.pathname);
+    const landingPath = truncateFirstTouchField(landingPathname);
     if (landingPath)
         attribution.landing_path = landingPath;
     const landingReferrer = typeof document !== "undefined" ? scrubReferrerHost(document.referrer) : "";
@@ -574,14 +574,14 @@ function backfillAttributionCookie(storageKey, spec) {
  * from replaces it. Without that, an untagged first visit would hide every
  * tagged visit after it.
  */
-function captureFirstTouchAttribution() {
+function captureFirstTouchAttribution(options = {}) {
     if (_firstTouchCaptured)
         return;
     _firstTouchCaptured = true;
     if (typeof window === "undefined")
         return;
     try {
-        const current = buildFirstTouchAttribution();
+        const current = buildFirstTouchAttribution(options.landingPath ?? window.location.pathname);
         const existing = getFirstTouchAttribution();
         if (existing &&
             (hasAttributionSource(existing) || !hasAttributionSource(current))) {
@@ -650,38 +650,72 @@ function readForwardedLastTouch() {
     }
     return hasAttributionSource(forwarded) ? forwarded : null;
 }
-function readStoredAttribution(storageKey) {
-    if (typeof window === "undefined")
+function parseAttribution(raw) {
+    if (!raw)
         return null;
     try {
-        const raw = safeStorageGet(storageKey);
-        if (!raw)
-            return null;
         const parsed = JSON.parse(raw);
         if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
             return null;
         }
-        return parsed;
+        // Every field is a string; a corrupted non-string one would make source
+        // detection throw, so it is dropped like any unreadable value.
+        const touch = {};
+        for (const [field, value] of Object.entries(parsed)) {
+            if (typeof value === "string")
+                touch[field] = value;
+        }
+        return touch;
+    }
+    catch {
+        // coercion-ok: an unparseable value holds no touch; the caller tries the
+        // next source.
+        return null;
+    }
+}
+function readAttributionCookieValue(cookieName) {
+    const cookie = readAttributionCookie(cookieName);
+    if (!cookie)
+        return null;
+    try {
+        return parseAttribution(decodeURIComponent(cookie));
     }
     catch {
+        // coercion-ok: a malformed cookie encoding holds no touch.
         return null;
     }
 }
+/**
+ * The stored touch, unless only its cookie says where the visitor came from:
+ * storage can be blocked, cleared, or hold an unreadable or empty value. The
+ * cookie is what signup reads, so a source that survives only there still
+ * counts, and capture must not overwrite it as if this were a first visit.
+ */
+function readStoredAttribution(storageKey, cookieName) {
+    if (typeof window === "undefined")
+        return null;
+    const stored = parseAttribution(safeStorageGet(storageKey));
+    if (hasAttributionSource(stored))
+        return stored;
+    const cookie = readAttributionCookieValue(cookieName);
+    return hasAttributionSource(cookie) ? cookie : (stored ?? cookie);
+}
 export function getFirstTouchAttribution() {
-    return readStoredAttribution(FIRST_TOUCH_STORAGE_KEY);
+    return readStoredAttribution(FIRST_TOUCH_STORAGE_KEY, FIRST_TOUCH_COOKIE_NAME);
 }
 export function getLastTouchAttribution() {
-    return readStoredAttribution(LAST_TOUCH_STORAGE_KEY);
+    return readStoredAttribution(LAST_TOUCH_STORAGE_KEY, LAST_TOUCH_COOKIE_NAME);
 }
 /**
  * Store the visitor's first and last touch now instead of in
- * `configureTracking()`, for a page that reads them before tracking starts.
- * It runs once per page load, so tracking's own capture is then a no-op.
+ * `configureTracking()`, for a page that reads them before tracking starts,
+ * or that never starts tracking, like the sign-in page. It runs once per page
+ * load, so tracking's own capture is then a no-op.
  */
-export function captureAttribution() {
+export function captureAttribution(options = {}) {
     if (isSyntheticBrowserTraffic())
         return;
-    captureFirstTouchAttribution();
+    captureFirstTouchAttribution(options);
 }
 function isLocalAnalyticsHostname(hostname) {
     const h = (hostname || "").toLowerCase();

package/dist/client/onboarding/use-onboarding.d.ts

@@ -18,6 +18,7 @@ export interface UseOnboardingResult {
     profile: OnboardingAppProfile | null;
     loading: boolean;
     error: string | null;
+    summaryKnown: boolean;
     currentStepId: string | null;
     completeCount: number;
     totalCount: number;

package/dist/client/onboarding/use-onboarding.js

@@ -583,6 +583,7 @@ export function useOnboarding(options = {}) {
     const [profile, setProfile] = useState(null);
     const [loading, setLoading] = useState(true);
     const [error, setError] = useState(null);
+    const [summaryKnown, setSummaryKnown] = useState(false);
     const [dismissed, setDismissed] = useState(false);
     const [firstRun, setFirstRun] = useState(preview || initialFirstRun);
     const [completeFirstRunError, setCompleteFirstRunError] = useState(null);
@@ -606,10 +607,8 @@ export function useOnboarding(options = {}) {
                 : initialFirstRun
                     ? Promise.resolve(true)
                     : fetchFirstRunOnboardingStatus();
-            const [summary, firstRunRes] = await Promise.all([
-                readOnboardingSummary(summaryUrl, reuseSharedRead !== true),
-                firstRunPromise,
-            ]);
+            const firstRunResultPromise = firstRunPromise.then((value) => ({ status: "fulfilled", value }), (reason) => ({ status: "rejected", reason }));
+            const summary = await readOnboardingSummary(summaryUrl, reuseSharedRead !== true);
             if (!mountedRef.current ||
                 fetchGeneration !== fetchGenerationRef.current) {
                 return;
@@ -630,13 +629,23 @@ export function useOnboarding(options = {}) {
             stepsRef.current = summary.steps;
             setSteps(summary.steps);
             setProfile(summary.profile);
+            setDismissed(!!summary.dismissed);
+            setSummaryKnown(true);
+            setError(null);
+            const firstRunResult = await firstRunResultPromise;
+            if (!mountedRef.current ||
+                fetchGeneration !== fetchGenerationRef.current) {
+                return;
+            }
+            if (firstRunResult.status === "rejected") {
+                throw firstRunResult.reason;
+            }
             if (preview) {
                 setFirstRun(true);
             }
             else if (!initialFirstRun) {
-                setFirstRun(firstRunRes === true);
+                setFirstRun(firstRunResult.value === true);
             }
-            setDismissed(!!summary.dismissed);
             setError(null);
         }
         catch (e) {
@@ -710,6 +719,9 @@ export function useOnboarding(options = {}) {
             flow: "checklist",
             step_id: id,
         });
+        const updatedSteps = stepsRef.current.map((step) => step.id === id ? { ...step, complete: true } : step);
+        stepsRef.current = updatedSteps;
+        setSteps(updatedSteps);
         await fetchAll();
     }, [fetchAll]);
     const dismiss = useCallback(async () => {
@@ -802,6 +814,7 @@ export function useOnboarding(options = {}) {
         profile,
         loading,
         error,
+        summaryKnown,
         currentStepId,
         completeCount,
         totalCount,

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

@@ -1,6 +1,6 @@
 export declare const postCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/eval/agent-runner.js

@@ -41,11 +41,24 @@ export async function createAgentRunner(config) {
             Object.values(actions).some((action) => action.readOnly !== true))) {
         throw new Error("Production chat evals require the real final response guard and a read-only adapter action registry.");
     }
-    const engine = config.engine ?? (await resolveEngine({ engineOption: undefined }));
-    const modelCandidate = config.model ??
-        (await getStoredModelForEngine(engine)) ??
-        engine.defaultModel;
-    const model = normalizeModelForEngine(engine, modelCandidate);
+    const resolveRuntimeModel = async () => {
+        const engine = config.engine ??
+            (await resolveEngine({ appId: productionContext?.appId }));
+        const modelCandidate = config.model ??
+            (await getStoredModelForEngine(engine, {
+                appId: productionContext?.appId,
+            })) ??
+            engine.defaultModel;
+        return { engine, model: normalizeModelForEngine(engine, modelCandidate) };
+    };
+    const runtimeModel = productionContext
+        ? await runWithRequestContext({
+            userEmail: productionContext.ownerEmail,
+            orgId: productionContext.orgId ?? undefined,
+            isSyntheticTraffic: true,
+        }, resolveRuntimeModel)
+        : await resolveRuntimeModel();
+    const { engine, model } = runtimeModel;
     const timeoutMs = config.timeoutMs ?? DEFAULT_AGENT_TIMEOUT_MS;
     const initialToolNames = productionContext?.initialToolNames
         ? new Set(productionContext.initialToolNames)
@@ -359,9 +372,6 @@ function validateProductionPathRun(result, context, actionAllowlist) {
         !["ok", "empty", "timed_out", "failed"].includes(receipt.prefetchStatus)) {
         return "Production chat eval adapter returned an incomplete setup receipt.";
     }
-    if (receipt.prefetchStatus !== "ok" && receipt.prefetchStatus !== "empty") {
-        return `Production chat eval adapter reported unsuccessful prefetch status "${receipt.prefetchStatus}".`;
-    }
     if (receipt.ownerEmail.trim().toLowerCase() !==
         context.ownerEmail.trim().toLowerCase() ||
         receipt.orgId !== context.orgId) {

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

@@ -42,8 +42,8 @@ declare const _default: import("../../action.js").ActionDefinition<{
     url: string;
     id: string;
     provider: string;
-    configured?: undefined;
     error?: undefined;
+    configured?: undefined;
 } | {
     url?: undefined;
     id?: undefined;

package/dist/mcp/connect-route.js

@@ -78,13 +78,18 @@ function joinAppPath(basePath, path) {
         return basePath;
     return `${basePath}${path.startsWith("/") ? path : `/${path}`}`;
 }
-function appLabel(origin, options) {
+function appLabel(origin, options, environment) {
     const app = getAppConfig().app;
     const declared = options.appId ?? app.id ?? app.template ?? app.slug;
     if (declared)
         return declared;
+    // Deployed functions run without npm's `npm_package_name`, so first-party
+    // apps usually land here. A beta lane is `beta.<app>.agent-native.com`: its
+    // leading label names the lane, and every beta app would share it. Only a
+    // beta deployment drops it, so no production name changes.
     try {
-        const h = new URL(origin).hostname;
+        const host = new URL(origin).hostname;
+        const h = environment === "beta" ? host.replace(/^beta\./, "") : host;
         return h.split(".")[0] || h;
     }
     catch {
@@ -106,10 +111,10 @@ function connectEnvironment() {
 export function resolveMcpConnectIdentity(appUrl, options) {
     const environment = connectEnvironment();
     const baseName = options.serverName?.trim() ||
-        derivedMcpServerBaseName(appLabel(appUrl, options), environment);
+        derivedMcpServerBaseName(appLabel(appUrl, options, environment), environment);
     return {
         serverName: mcpConnectServerName(baseName, environment),
-        appName: options.appName || appLabel(appUrl, options),
+        appName: options.appName || appLabel(appUrl, options, environment),
         appUrl,
         mcpUrl: mcpResourceUrl(appUrl),
         environment,

package/dist/observability/routes.d.ts

@@ -27,43 +27,43 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
     thumbsUpRate: number;
     avgEvalScore: number;
 } | {
+    ok?: undefined;
     error: string;
     message: string;
     summary?: undefined;
     spans?: undefined;
-    ok?: undefined;
 } | {
+    error?: undefined;
+    ok?: undefined;
     message?: undefined;
     summary: import("./types.js").TraceSummary;
     spans: import("./types.js").TraceSpan[];
+} | {
     error?: undefined;
     ok?: undefined;
-} | {
     message?: undefined;
     summary?: undefined;
     spans?: undefined;
     traceMissing: true;
     id: string;
+} | {
     error?: undefined;
     ok?: undefined;
-} | {
     message?: undefined;
     summary?: undefined;
     spans?: undefined;
     traceMissing?: undefined;
     id: string;
-    error?: undefined;
-    ok?: undefined;
 } | {
+    ok?: undefined;
     message?: undefined;
     summary?: undefined;
     spans?: undefined;
     error: any;
-    ok?: undefined;
 } | {
+    error?: undefined;
     message?: undefined;
     summary?: undefined;
     spans?: undefined;
-    error?: undefined;
     ok: boolean;
 }>>;

package/dist/onboarding/plugin.js

@@ -3,7 +3,6 @@ import { getAppConfig } from "../app-config/index.js";
 import { appStateGet, appStatePut } from "../application-state/store.js";
 import { getOrgContext } from "../org/context.js";
 import { readBrowserSessionIdHeader } from "../server/agent-run-context.js";
-import { CredentialStoreUnavailableError } from "../server/credential-provider.js";
 import { awaitBootstrap, getH3App, markDefaultPluginProvided, } from "../server/framework-request-handler.js";
 import { runWithRequestContext } from "../server/request-context.js";
 import { FIRST_RUN_ONBOARDING_COMPLETED_KEY, FIRST_RUN_ONBOARDING_COOKIE, FIRST_RUN_ONBOARDING_ELIGIBLE_KEY, } from "../shared/first-run-onboarding.js";
@@ -29,13 +28,8 @@ async function resolveOnboardingContext(event) {
     };
 }
 async function hasOverride(sessionId, stepId) {
-    try {
-        const val = await appStateGet(sessionId, `${OVERRIDE_KEY_PREFIX}${stepId}`);
-        return !!(val && val.complete);
-    }
-    catch {
-        return false;
-    }
+    const val = await appStateGet(sessionId, `${OVERRIDE_KEY_PREFIX}${stepId}`);
+    return !!(val && val.complete);
 }
 async function serializeSteps(context, options = {}) {
     const steps = listOnboardingSteps();
@@ -46,12 +40,7 @@ async function serializeSteps(context, options = {}) {
         }
         let complete = false;
         if (!options.preview) {
-            try {
-                complete = (await step.isComplete(context)) === true;
-            }
-            catch {
-                complete = false;
-            }
+            complete = (await step.isComplete(context)) === true;
             if (!complete) {
                 complete = await hasOverride(context.sessionId, step.id);
             }
@@ -78,19 +67,8 @@ function allRequiredComplete(statuses) {
     return statuses.filter((s) => s.required).every((s) => s.complete);
 }
 async function readDismissedFlag(sessionId) {
-    // The dismissed flag is optional UX state; a transient DB failure reading it
-    // must not take down a read whose steps and profile are still usable (the
-    // pre-summary client already assumed "not dismissed" when this read
-    // failed). A credential-store outage is not transient, so it still throws.
-    try {
-        const value = await appStateGet(sessionId, DISMISSED_KEY);
-        return !!(value && value.dismissed);
-    }
-    catch (error) {
-        if (error instanceof CredentialStoreUnavailableError)
-            throw error;
-        return false;
-    }
+    const value = await appStateGet(sessionId, DISMISSED_KEY);
+    return !!(value && value.dismissed);
 }
 async function resolveSharedCompletionEnabled() {
     if (!getAppConfig().onboarding.sharedCompletion.enabled)
@@ -164,24 +142,16 @@ export function createOnboardingPlugin(options = {}) {
                 return { error: "Method not allowed" };
             }
             const context = await resolveOnboardingContext(event);
-            try {
-                return await withOnboardingRequestContext(context, async () => {
-                    const [value, statuses] = await Promise.all([
-                        appStateGet(context.sessionId, DISMISSED_KEY),
-                        serializeSteps(context),
-                    ]);
-                    const dismissed = !!(value && value.dismissed);
-                    return {
-                        dismissed,
-                        allComplete: allRequiredComplete(statuses),
-                    };
-                });
-            }
-            catch (error) {
-                if (error instanceof CredentialStoreUnavailableError)
-                    throw error;
-                return { dismissed: false, allComplete: false };
-            }
+            return withOnboardingRequestContext(context, async () => {
+                const [statuses, value] = await Promise.all([
+                    serializeSteps(context),
+                    appStateGet(context.sessionId, DISMISSED_KEY),
+                ]);
+                return {
+                    dismissed: !!(value && value.dismissed),
+                    allComplete: allRequiredComplete(statuses),
+                };
+            });
         }));
         getH3App(nitroApp).use(`${ONBOARDING_PREFIX}/profile`, defineEventHandler(async (event) => {
             if (getMethod(event) !== "GET") {

package/dist/progress/routes.d.ts

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