@agent-native/core 0.222.1-nightly-20261029063606 → 0.222.1

package/dist/observability/tracing.d.ts

@@ -35,6 +35,7 @@ export interface TrackingEventScope {
     pending: Set<Promise<void>>;
 }
 export declare function createTrackingEventScope(): TrackingEventScope;
+export declare function registerTrackingWork(pending: Promise<void>, scope?: TrackingEventScope): void;
 export declare function recordTrackingEvent(name: string, properties?: Record<string, unknown>, origin?: TrackingEventOrigin): Promise<void>;
 export declare function queueTrackingEvent(name: string, properties?: Record<string, unknown>, origin?: TrackingEventOrigin, scope?: TrackingEventScope): void;
 export declare function flushTrackingEvents(scope?: TrackingEventScope): Promise<void>;

package/dist/observability/tracing.js

@@ -59,6 +59,11 @@ const pendingTrackingEvents = new Set();
 export function createTrackingEventScope() {
     return { pending: new Set() };
 }
+export function registerTrackingWork(pending, scope) {
+    const pendingEvents = scope?.pending ?? pendingTrackingEvents;
+    pendingEvents.add(pending);
+    void pending.then(() => pendingEvents.delete(pending), () => pendingEvents.delete(pending));
+}
 function numericDuration(properties) {
     const duration = properties.duration_ms;
     return typeof duration === "number" &&
@@ -194,12 +199,17 @@ export async function recordTrackingEvent(name, properties = {}, origin) {
 }
 export function queueTrackingEvent(name, properties = {}, origin = "server", scope) {
     const pending = recordTrackingEvent(name, properties, origin);
-    const pendingEvents = scope?.pending ?? pendingTrackingEvents;
-    pendingEvents.add(pending);
-    void pending.then(() => pendingEvents.delete(pending), () => pendingEvents.delete(pending));
+    registerTrackingWork(pending, scope);
 }
 export async function flushTrackingEvents(scope) {
-    await Promise.allSettled([...(scope?.pending ?? pendingTrackingEvents)]);
+    const pendingEvents = scope?.pending ?? pendingTrackingEvents;
+    if (!scope) {
+        await Promise.allSettled([...pendingEvents]);
+        return;
+    }
+    while (pendingEvents.size > 0) {
+        await Promise.allSettled([...pendingEvents]);
+    }
 }
 export async function startAgentSpan(name, attributes = {}, parentSpan = null, startTime) {
     const runtime = await resolveRuntime();

package/dist/org/index.d.ts

@@ -180,10 +180,10 @@ export declare const getMyOrgHandler: import("h3").EventHandlerWithFetch<import(
     soloDeploymentAdmin: boolean | undefined;
 }>>;
 export declare const createOrgHandler: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    id?: undefined;
     name?: undefined;
     success: boolean;
     role?: undefined;
+    id?: undefined;
 } | {
     success?: undefined;
     id: string;

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

@@ -76,9 +76,9 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
     }>>;
 }, z.core.$strip>>, {
     id?: undefined;
+    provider?: undefined;
     deleted?: undefined;
     message?: undefined;
-    found?: undefined;
     providers: {
         id: string;
         label: string;
@@ -89,7 +89,7 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
         updatedAt: number;
     }[];
     count: number;
-    provider?: undefined;
+    found?: undefined;
     registered?: undefined;
     label?: undefined;
 } | {
@@ -103,31 +103,31 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
     registered?: undefined;
     label?: undefined;
 } | {
+    provider?: undefined;
     count?: undefined;
     deleted?: undefined;
     message?: undefined;
     providers?: undefined;
-    provider?: undefined;
     found: boolean;
     id: string;
     registered?: undefined;
     label?: undefined;
 } | {
+    provider?: undefined;
     count?: undefined;
     message?: undefined;
-    found?: undefined;
     providers?: undefined;
-    provider?: undefined;
+    found?: undefined;
     deleted: boolean;
     id: string;
     registered?: undefined;
     label?: undefined;
 } | {
+    provider?: undefined;
     count?: undefined;
     deleted?: undefined;
-    found?: undefined;
     providers?: undefined;
-    provider?: undefined;
+    found?: undefined;
     registered: boolean;
     id: string;
     label: string;

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

@@ -316,9 +316,9 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         notes?: string | undefined;
         scope?: "org" | "user" | undefined;
     }, {
+        provider?: undefined;
         id?: undefined;
         message?: undefined;
-        found?: undefined;
         providers: {
             id: string;
             label: string;
@@ -329,7 +329,7 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
             updatedAt: number;
         }[];
         count: number;
-        provider?: undefined;
+        found?: undefined;
         deleted?: undefined;
         registered?: undefined;
         label?: undefined;
@@ -344,30 +344,30 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         registered?: undefined;
         label?: undefined;
     } | {
+        provider?: undefined;
         count?: undefined;
         message?: undefined;
         providers?: undefined;
-        provider?: undefined;
         found: boolean;
         id: string;
         deleted?: undefined;
         registered?: undefined;
         label?: undefined;
     } | {
+        provider?: undefined;
         count?: undefined;
         message?: undefined;
-        found?: undefined;
         providers?: undefined;
-        provider?: undefined;
+        found?: undefined;
         deleted: boolean;
         id: string;
         registered?: undefined;
         label?: undefined;
     } | {
+        provider?: undefined;
         count?: undefined;
-        found?: undefined;
         providers?: undefined;
-        provider?: undefined;
+        found?: undefined;
         deleted?: undefined;
         registered: boolean;
         id: string;

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

@@ -54,21 +54,21 @@ export declare function resolveAgentEngineApiKeyWriteTarget(event: H3Event, scop
     error: string;
 }>;
 export declare function createAgentEngineApiKeyHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
+    error: string;
     errorCode?: undefined;
     code?: undefined;
-    error: string;
 } | {
-    code?: undefined;
     error: string;
     errorCode: string;
+    code?: undefined;
 } | {
     errorCode?: undefined;
     error: string;
     code: ProviderKeyCheckCode;
 } | {
+    error?: undefined;
     errorCode?: undefined;
     code?: undefined;
-    error?: undefined;
     ok: boolean;
     key: string;
     baseUrlKey?: string | undefined;

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

@@ -26,6 +26,7 @@ import { CORE_CHANGE_EMAIL_CONFIRMATION_EMAIL_ID, CORE_CHANGE_EMAIL_VERIFICATION
 import { renderTransactionalEmail } from "../email-catalog/templates.js";
 import { executeIdentityRekey, rekeyIdentity, resumePendingIdentityRekeys, verifiedEmailChangeFromToken, } from "../identity/rekey.js";
 import { saveOAuthTokens } from "../oauth-tokens/store.js";
+import { assignQuestionIntakeExperimentOnSignup } from "../observability/question-intake-experiment.js";
 import { acceptPendingInvitationsForEmail } from "../org/accept-pending.js";
 import { getAuthEmailForUserId, getRequiredAuthProviderForEmail, } from "../org/auth-policy.js";
 import { autoJoinDomainMatchingOrgs } from "../org/auto-join-domain.js";
@@ -1849,6 +1850,48 @@ async function createBetterAuthInstance(config) {
                         if (!email)
                             return;
                         await emitSignupEventForCreatedUser(user, context);
+                        const actingUserId = context?.context?.session?.user?.id;
+                        if (user.id && (!actingUserId || actingUserId === user.id)) {
+                            let experimentId;
+                            try {
+                                const questionIntakeConfig = getAppConfig().agent.questionIntake;
+                                experimentId = questionIntakeConfig?.experimentId;
+                                // raw-sql-ok: the assignment store binds the authenticated user ID as a query argument.
+                                await assignQuestionIntakeExperimentOnSignup(questionIntakeConfig, user.id);
+                            }
+                            catch (error) {
+                                console.error("[auth] question-intake assignment failed after retry", {
+                                    code: "question_intake_assignment_failed",
+                                    experimentId,
+                                });
+                                if (experimentId) {
+                                    try {
+                                        track("agent_experiment_assignment_failed", {
+                                            experiment_id: experimentId,
+                                            failure_stage: "signup",
+                                            error_code: "question_intake_assignment_failed",
+                                        }, { authUserId: user.id, userId: email });
+                                    }
+                                    catch {
+                                        console.error("[auth] failed to track question-intake assignment failure", { code: "question_intake_assignment_tracking_failed" });
+                                    }
+                                }
+                                try {
+                                    const { captureError } = await import("./capture-error.js");
+                                    captureError(error, {
+                                        route: "auth.signup",
+                                        tags: {
+                                            failureClass: "question-intake-assignment",
+                                            errorCode: "question_intake_assignment_failed",
+                                        },
+                                        extra: { experimentId },
+                                    });
+                                }
+                                catch {
+                                    console.error("[auth] failed to report question-intake assignment failure", { code: "question_intake_assignment_reporting_failed" });
+                                }
+                            }
+                        }
                         if (user.emailVerified !== true)
                             return;
                         try {

package/dist/server/builder-branch-files.d.ts

@@ -1,6 +1,8 @@
+export type BuilderBranchReadbackStage = "status_request" | "status_shape" | "status_binding" | "status_currentness" | "post_read_status_request" | "post_read_status_shape" | "post_read_status_binding" | "post_read_status_currentness" | "download_url_request" | "download_url_shape" | "download_url_binding" | "bundle_download" | "bundle_read" | "bundle_digest" | "bundle_parse" | "target_subtree_missing" | "post_read_currentness";
 export declare class BuilderBranchFilesError extends Error {
     readonly code: "invalid_request" | "not_connected" | "forbidden" | "unavailable" | "unverified" | "integrity_failed";
-    constructor(code: "invalid_request" | "not_connected" | "forbidden" | "unavailable" | "unverified" | "integrity_failed", message: string);
+    readonly readbackStage?: BuilderBranchReadbackStage | undefined;
+    constructor(code: "invalid_request" | "not_connected" | "forbidden" | "unavailable" | "unverified" | "integrity_failed", message: string, readbackStage?: BuilderBranchReadbackStage | undefined);
 }
 type BranchRef = {
     projectId: string;

package/dist/server/builder-branch-files.js

@@ -10,9 +10,11 @@ const MAX_BUNDLE_BYTES = 32 * 1024 * 1024;
 const API_TIMEOUT_MS = 30_000;
 export class BuilderBranchFilesError extends Error {
     code;
-    constructor(code, message) {
+    readbackStage;
+    constructor(code, message, readbackStage) {
         super(message);
         this.code = code;
+        this.readbackStage = readbackStage;
         this.name = "BuilderBranchFilesError";
     }
 }
@@ -56,6 +58,20 @@ const downloadSchema = z.object({
     partial: z.literal(false),
     expiresAt: z.string(),
 });
+const statusFailureStages = {
+    before_read: {
+        request: "status_request",
+        shape: "status_shape",
+        binding: "status_binding",
+        currentness: "status_currentness",
+    },
+    after_read: {
+        request: "post_read_status_request",
+        shape: "post_read_status_shape",
+        binding: "post_read_status_binding",
+        currentness: "post_read_status_currentness",
+    },
+};
 function backupIdentityFingerprint(backup) {
     return JSON.stringify([
         backup.projectId,
@@ -67,10 +83,10 @@ function backupIdentityFingerprint(backup) {
         backup.size,
     ]);
 }
-function unverified() {
-    throw new BuilderBranchFilesError("unverified", "Builder has no complete, current, identity-bound branch backup to verify.");
+function unverified(stage) {
+    throw new BuilderBranchFilesError("unverified", "Builder has no complete, current, identity-bound branch backup to verify.", stage);
 }
-function primaryCommit(snapshot) {
+function primaryCommit(snapshot, failureStage) {
     if (SHA.test(snapshot))
         return snapshot;
     const pairs = snapshot.split(",");
@@ -78,25 +94,25 @@ function primaryCommit(snapshot) {
     for (const pair of pairs) {
         const separator = pair.indexOf(":");
         if (separator < 1)
-            unverified();
+            unverified(failureStage);
         let folder;
         try {
             folder = decodeURIComponent(pair.slice(0, separator));
         }
         catch {
-            return unverified();
+            return unverified(failureStage);
         }
         const commit = pair.slice(separator + 1);
         if (!SHA.test(commit))
-            unverified();
+            unverified(failureStage);
         if (folder === "code")
             entries.push(commit);
     }
     return entries.length === 1 ? entries[0] : undefined;
 }
-async function readBytes(response, maxBytes) {
+async function readBytes(response, maxBytes, stage) {
     if (!response.body) {
-        throw new BuilderBranchFilesError("unavailable", "Builder response has no body.");
+        throw new BuilderBranchFilesError("unavailable", "Builder response has no body.", stage);
     }
     const reader = response.body.getReader();
     const chunks = [];
@@ -108,7 +124,7 @@ async function readBytes(response, maxBytes) {
                 break;
             size += part.value.byteLength;
             if (size > maxBytes) {
-                throw new BuilderBranchFilesError("integrity_failed", "Builder readback exceeds its byte limit.");
+                throw new BuilderBranchFilesError("integrity_failed", "Builder readback exceeds its byte limit.", stage);
             }
             chunks.push(part.value);
         }
@@ -116,7 +132,7 @@ async function readBytes(response, maxBytes) {
     catch (error) {
         if (error instanceof BuilderBranchFilesError)
             throw error;
-        throw new BuilderBranchFilesError("unavailable", "Builder response could not be read completely.");
+        throw new BuilderBranchFilesError("unavailable", "Builder response could not be read completely.", stage);
     }
     finally {
         await reader.cancel().catch(() => { });
@@ -190,31 +206,54 @@ export async function readBuilderBranchFiles(input) {
             throw new BuilderBranchFilesError("unavailable", "Builder returned an invalid readback response.");
         }
     }
-    async function readStatus() {
-        const result = statusSchema.safeParse(await request("/projects/branch/status"));
+    async function readStatus(phase) {
+        let rawStatus;
+        try {
+            rawStatus = await request("/projects/branch/status");
+        }
+        catch (error) {
+            if (error instanceof BuilderBranchFilesError) {
+                throw new BuilderBranchFilesError(error.code, error.message, statusFailureStages[phase].request);
+            }
+            throw error;
+        }
+        const result = statusSchema.safeParse(rawStatus);
         if (!result.success)
-            return unverified();
+            return unverified(statusFailureStages[phase].shape);
         const { branch, backupStatuses } = result.data;
         const backup = backupStatuses.code.backup;
         if (branch.projectId !== input.projectId ||
             branch.name !== input.branchName ||
             backup.projectId !== input.projectId ||
             backup.branchName !== input.branchName ||
-            branch.ownerId !== backup.ownerId ||
-            backup.at < branch.lastActivityAt ||
-            primaryCommit(branch.lastCommitHash) !== backup.lastCommitHash)
-            return unverified();
+            branch.ownerId !== backup.ownerId) {
+            return unverified(statusFailureStages[phase].binding);
+        }
+        const branchCommit = primaryCommit(branch.lastCommitHash, statusFailureStages[phase].currentness);
+        if (backup.at < branch.lastActivityAt ||
+            branchCommit !== backup.lastCommitHash)
+            return unverified(statusFailureStages[phase].currentness);
         return backup;
     }
     // Export can fall back to an older backup after a refresh error. Only accept
     // the bytes whose digest and commit still match the branch's recorded state.
-    const download = downloadSchema.safeParse(await request("/projects/branch/bundle-download-url", {
-        projectId: input.projectId,
-        branchName: input.branchName,
-    }));
+    let rawDownload;
+    try {
+        rawDownload = await request("/projects/branch/bundle-download-url", {
+            projectId: input.projectId,
+            branchName: input.branchName,
+        });
+    }
+    catch (error) {
+        if (error instanceof BuilderBranchFilesError) {
+            throw new BuilderBranchFilesError(error.code, error.message, "download_url_request");
+        }
+        throw error;
+    }
+    const download = downloadSchema.safeParse(rawDownload);
     if (!download.success)
-        return unverified();
-    const before = await readStatus();
+        return unverified("download_url_shape");
+    const before = await readStatus("before_read");
     const beforeFingerprint = backupIdentityFingerprint(before);
     const filePath = before.ownerId +
         "/" +
@@ -229,7 +268,7 @@ export async function readBuilderBranchFiles(input) {
         storagePath = decodeURIComponent(url.pathname);
     }
     catch {
-        return unverified();
+        return unverified("download_url_binding");
     }
     if (download.data.filePath !== filePath ||
         url.origin !== "https://storage.googleapis.com" ||
@@ -240,7 +279,7 @@ export async function readBuilderBranchFiles(input) {
         !Number.isFinite(expiresAt) ||
         expiresAt <= Date.now() ||
         expiresAt > Date.now() + 25 * 60 * 60 * 1000)
-        return unverified();
+        return unverified("download_url_binding");
     let response;
     try {
         response = await ssrfSafeFetch(url.toString(), { signal: AbortSignal.timeout(API_TIMEOUT_MS) }, {
@@ -254,16 +293,16 @@ export async function readBuilderBranchFiles(input) {
         });
     }
     catch {
-        throw new BuilderBranchFilesError("unavailable", "Builder branch bundle could not be downloaded.");
+        throw new BuilderBranchFilesError("unavailable", "Builder branch bundle could not be downloaded.", "bundle_download");
     }
     if (!response.ok) {
         await response.body?.cancel().catch(() => { });
-        throw new BuilderBranchFilesError("unavailable", "Builder branch bundle is unavailable.");
+        throw new BuilderBranchFilesError("unavailable", "Builder branch bundle is unavailable.", "bundle_download");
     }
-    const bundle = await readBytes(response, MAX_BUNDLE_BYTES);
+    const bundle = await readBytes(response, MAX_BUNDLE_BYTES, "bundle_read");
     if (bundle.byteLength !== before.size ||
         createHash("md5").update(bundle).digest("base64") !== before.contentMd5) {
-        throw new BuilderBranchFilesError("integrity_failed", "Builder branch bundle failed its recorded byte integrity check.");
+        throw new BuilderBranchFilesError("integrity_failed", "Builder branch bundle failed its recorded byte integrity check.", "bundle_digest");
     }
     let snapshot;
     try {
@@ -276,11 +315,13 @@ export async function readBuilderBranchFiles(input) {
     catch (error) {
         throw new BuilderBranchFilesError(error instanceof BuilderGitBundleError && error.code === "unavailable"
             ? "unavailable"
-            : "integrity_failed", "Builder branch files could not be verified from the bundle.");
+            : "integrity_failed", "Builder branch files could not be verified from the bundle.", error instanceof BuilderGitBundleError && error.code === "target_missing"
+            ? "target_subtree_missing"
+            : "bundle_parse");
     }
-    const after = await readStatus();
+    const after = await readStatus("after_read");
     if (backupIdentityFingerprint(after) !== beforeFingerprint)
-        return unverified();
+        return unverified("post_read_currentness");
     return {
         projectId: input.projectId,
         branchName: input.branchName,

package/dist/server/builder-branch-git.d.ts

@@ -1,4 +1,4 @@
-export type BuilderGitBundleErrorCode = "invalid_request" | "integrity_failed" | "unavailable";
+export type BuilderGitBundleErrorCode = "invalid_request" | "integrity_failed" | "target_missing" | "unavailable";
 export declare class BuilderGitBundleError extends Error {
     readonly code: BuilderGitBundleErrorCode;
     constructor(code: BuilderGitBundleErrorCode);

package/dist/server/builder-branch-git.js

@@ -100,6 +100,8 @@ async function findTargetTree(gitApi, root, gitdir, rootTreeOid, appPath, cache)
         const current = await readTree(gitApi, root, gitdir, treeOid, MAX_TREE_ENTRIES - traversedEntries, cache);
         traversedEntries += current.entryCount;
         const matching = current.tree.tree.filter((entry) => entry.path === segment);
+        if (matching.length === 0)
+            fail("target_missing");
         if (matching.length !== 1)
             fail("integrity_failed");
         const entry = matching.at(0);

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

@@ -45,6 +45,7 @@ import { getUserSetting, putUserSetting, deleteUserSetting, } from "../settings/
 import { ANALYTICS_CLIENT_PLATFORM_PROPERTY } from "../shared/analytics-platform.js";
 import { EMPTY_SPECULATION_RULES, resolveSsrCacheHeaders, } from "../shared/cache-control.js";
 import { EMBED_TARGET_HEADER } from "../shared/embed-auth.js";
+import { FIRST_RUN_ONBOARDING_EXPERIMENT_EVENT_NAMES } from "../shared/first-run-builder-credits-experiment.js";
 import { isGoogleProfileImageUrl } from "../shared/google-profile-image.js";
 import { llmConnectionTrackingProperties } from "../shared/llm-connection.js";
 import { EMBED_TRANSPLANT_HEADER, isMcpEmbedCorsOrigin, MCP_EMBED_CORS_ALLOW_HEADERS, shouldAllowMcpEmbedCredentials, } from "../shared/mcp-embed-headers.js";
@@ -4313,15 +4314,41 @@ export function createCoreRoutesPlugin(options = {}) {
                 };
                 if (orgId)
                     properties.org_id = orgId;
+                // The browser cannot supply experiment attribution. Restore an
+                // exposed first-run arm from server storage before tracking onboarding
+                // events so the registry can replace, rather than trust, client tags.
+                const isFirstRunOnboardingEvent = FIRST_RUN_ONBOARDING_EXPERIMENT_EVENT_NAMES.has(validation.name) && validation.properties?.flow === "first_run";
                 // Best-effort — server `track()` swallows provider errors. We still
                 // guard here so an unexpected throw can't surface to the browser.
                 try {
-                    track(validation.name, properties, {
+                    const browserSessionId = readBrowserSessionIdHeader(event);
+                    const trackingSource = {
                         userId: userEmail,
-                        authUserId: session.authUserId,
-                        sessionId: readBrowserSessionIdHeader(event),
+                        ...(session.authUserId ? { authUserId: session.authUserId } : {}),
+                        ...(browserSessionId ? { sessionId: browserSessionId } : {}),
                         telemetryOrigin: "client",
-                    });
+                    };
+                    const trackClientEvent = () => track(validation.name, properties, trackingSource);
+                    if (isFirstRunOnboardingEvent) {
+                        await runWithRequestContext({
+                            userEmail,
+                            ...(session.authUserId
+                                ? { authUserId: session.authUserId }
+                                : {}),
+                        }, async () => {
+                            try {
+                                const { loadFirstRunBuilderCreditsV2Assignment } = await import("../onboarding/first-run-builder-credits-experiment.js");
+                                await loadFirstRunBuilderCreditsV2Assignment();
+                            }
+                            catch {
+                                console.error("[tracking] first-run onboarding assignment lookup failed", { eventName: validation.name });
+                            }
+                            trackClientEvent();
+                        });
+                    }
+                    else {
+                        trackClientEvent();
+                    }
                 }
                 catch {
                     // best-effort

package/dist/server/request-context.d.ts

@@ -64,6 +64,14 @@ export interface RequestRunContext {
         totalTools: number;
         resultNames: string[];
     }>;
+    /** Signup-time question-intake assignment loaded for this authenticated run. */
+    questionIntakeExperimentAssignment?: {
+        authUserId: string;
+        experimentId: string;
+        variantId: "control" | "no_questions";
+    };
+    /** Tools unavailable to the current agent run and its tool-search surface. */
+    excludedActionNames?: readonly string[];
 }
 export interface RequestContext {
     /**

package/dist/server/transcribe-voice.d.ts

@@ -17,8 +17,8 @@
  * typed JSON-in / JSON-out).
  */
 export declare function createTranscribeVoiceHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    text?: undefined;
     error: string;
+    text?: undefined;
 } | {
     error?: undefined;
     text: string;

package/dist/shared/first-run-builder-credits-experiment.d.ts

@@ -1,6 +1,7 @@
 export declare const FIRST_RUN_BUILDER_CREDITS_V2_EXPERIMENT_ID = "first_run_builder_credits_v2";
 export declare const FIRST_RUN_BUILDER_CREDITS_V2_FLAG_KEY = "clips-first-run-credits-v2";
 export declare const FIRST_RUN_BUILDER_CREDITS_V2_VARIANTS: readonly ["control", "credits"];
+export declare const FIRST_RUN_ONBOARDING_EXPERIMENT_EVENT_NAMES: Set<string>;
 export type FirstRunBuilderCreditsV2Variant = (typeof FIRST_RUN_BUILDER_CREDITS_V2_VARIANTS)[number];
 export interface FirstRunBuilderCreditsV2Assignment {
     experiment_id: typeof FIRST_RUN_BUILDER_CREDITS_V2_EXPERIMENT_ID;

package/dist/shared/first-run-builder-credits-experiment.js

@@ -4,6 +4,25 @@ export const FIRST_RUN_BUILDER_CREDITS_V2_VARIANTS = [
     "control",
     "credits",
 ];
+export const FIRST_RUN_ONBOARDING_EXPERIMENT_EVENT_NAMES = new Set([
+    "onboarding_app_entered",
+    "onboarding_started",
+    "onboarding_experiment_exposed",
+    "onboarding_step_viewed",
+    "onboarding_step_completed",
+    "onboarding_step_skipped",
+    "onboarding_method_clicked",
+    "onboarding_method_started",
+    "onboarding_method_outcome",
+    "onboarding_abandoned",
+    "onboarding_correlation_unavailable",
+    "onboarding_role_save_started",
+    "onboarding_more_info_opened",
+    "onboarding_role_option_selected",
+    "onboarding_dismissed",
+    "onboarding_reopened",
+    "onboarding_completed",
+]);
 /** A stable, account-scoped arm that is the same in the browser and on server events. */
 export function assignFirstRunBuilderCreditsV2(authUserId) {
     const userId = authUserId?.trim();

package/dist/tracking/index.d.ts

@@ -1,4 +1,4 @@
-export { track, identify, flushTracking, registerTrackingProvider, unregisterTrackingProvider, listTrackingProviders, type TrackingMeta, type TrackingSource, } from "./registry.js";
+export { track, trackQuestionIntakeExposure, identify, flushTracking, registerTrackingProvider, unregisterTrackingProvider, listTrackingProviders, type TrackingMeta, type TrackingSource, } from "./registry.js";
 export { registerBuiltinProviders } from "./providers.js";
 export { readAnalyticsAnonymousId } from "../server/attribution.js";
 export { AGENT_NATIVE_ACTION_EVENTS, AGENT_NATIVE_LIFECYCLE_EVENTS, trackActionEvent, trackLifecycleEvent, type AgentNativeActionEventName, type AgentNativeLifecycleEventName, } from "./lifecycle.js";

package/dist/tracking/index.js

@@ -1,4 +1,4 @@
-export { track, identify, flushTracking, registerTrackingProvider, unregisterTrackingProvider, listTrackingProviders, } from "./registry.js";
+export { track, trackQuestionIntakeExposure, identify, flushTracking, registerTrackingProvider, unregisterTrackingProvider, listTrackingProviders, } from "./registry.js";
 export { registerBuiltinProviders } from "./providers.js";
 export { readAnalyticsAnonymousId } from "../server/attribution.js";
 export { AGENT_NATIVE_ACTION_EVENTS, AGENT_NATIVE_LIFECYCLE_EVENTS, trackActionEvent, trackLifecycleEvent, } from "./lifecycle.js";

package/dist/tracking/registry.d.ts

@@ -1,4 +1,5 @@
 import type { ActionRunContext } from "../action.js";
+import { type QuestionIntakeExperimentAssignment } from "../observability/question-intake-experiment.js";
 import { type TrackingEventOrigin } from "../observability/tracing.js";
 import type { TrackingProvider } from "./types.js";
 export { isQaTestEmail } from "../shared/qa-test-email.js";
@@ -17,5 +18,11 @@ export interface TrackingMeta {
 }
 export type TrackingSource = TrackingMeta | (ActionRunContext & Pick<TrackingMeta, "sessionId">);
 export declare function track(name: string, properties?: Record<string, unknown>, source?: TrackingSource): void;
+export declare function trackQuestionIntakeExposure(assignment: QuestionIntakeExperimentAssignment, context: {
+    appId: string;
+    threadId?: string;
+    turnId: string;
+    userId?: string;
+}): void;
 export declare function identify(userId: string, traits?: Record<string, unknown>): void;
 export declare function flushTracking(): Promise<void[]>;