@agent-native/core 0.219.0 → 0.220.0-nightly-20261023212848

package/dist/client/use-chat-threads.js

@@ -122,6 +122,8 @@ async function requestChatThreadListPage(request) {
         params.set("includeExternal", "1");
     if (request.includeArchived)
         params.set("includeArchived", "1");
+    if (request.includeHidden)
+        params.set("includeHidden", "1");
     appendChatThreadScopeParams(params, request.scope);
     const search = params.toString();
     const res = await fetch(`${apiUrl}/threads${search ? `?${search}` : ""}`);
@@ -155,7 +157,27 @@ export async function fetchChatThreadListPage(request = {}) {
         hasMore: page.hasMore,
     };
 }
-async function fetchThreadListPage(apiUrl, offset, includeExternal, scope, ownership) {
+export class ChatThreadMutationError extends Error {
+    status;
+    constructor(status) {
+        super(`Chat thread mutation failed (HTTP ${status}).`);
+        this.status = status;
+        this.name = "ChatThreadMutationError";
+    }
+}
+export async function hideChatThread(threadId, hidden, options = {}) {
+    const apiUrl = options.apiUrl ?? agentNativePath("/_agent-native/agent-chat");
+    const response = await fetch(withChatThreadScope(`${apiUrl}/threads/${encodeURIComponent(threadId)}/hide`, options.scope), {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ hidden }),
+    });
+    if (!response.ok)
+        throw new ChatThreadMutationError(response.status);
+    notifyChatThreadsUpdated();
+    return true;
+}
+async function fetchThreadListPage(apiUrl, offset, includeExternal, scope, ownership, includeHidden = false) {
     // The lifecycle list keeps optimistic local drafts beside server rows, so it
     // tolerates summaries without ownership metadata; the ownership-aware lists
     // go through `fetchChatThreadListPage`, which requires it.
@@ -166,6 +188,7 @@ async function fetchThreadListPage(apiUrl, offset, includeExternal, scope, owner
             includeExternal,
             scope,
             ownership,
+            includeHidden,
         });
         return page.threads;
     }
@@ -355,6 +378,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
     const autoCreate = options?.autoCreate !== false;
     const restoreActiveThread = options?.restoreActiveThread !== false;
     const includeExternal = options?.includeExternal === true;
+    const includeHidden = options?.includeHidden === true;
     const ownership = options?.ownership;
     const isolateHistoryByScope = options?.isolateHistoryByScope === true;
     const browserTabId = options?.browserTabId ??
@@ -774,7 +798,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
         let loadedThreads;
         try {
             const offset = options?.append ? nextThreadsOffsetRef.current : 0;
-            const loaded = await fetchThreadListPage(apiUrl, offset, includeExternal, historyScope, ownership);
+            const loaded = await fetchThreadListPage(apiUrl, offset, includeExternal, historyScope, ownership, includeHidden);
             if (requestId !== latestFetchRequestRef.current)
                 return undefined;
             if (!loaded) {
@@ -958,6 +982,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
         historyScope,
         historyScopeKey,
         includeExternal,
+        includeHidden,
         isolateHistory,
         ownership,
         routeControlsActiveThread,
@@ -1232,6 +1257,25 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
             return false;
         }
     }, [apiUrl, fetchThreads, historyScope]);
+    const hideThread = useCallback(async (threadId, hidden) => {
+        const previous = threadsRef.current.find((thread) => thread.id === threadId);
+        setThreads((threads) => threads.map((thread) => thread.id === threadId
+            ? { ...thread, hiddenAt: hidden ? Date.now() : null }
+            : thread));
+        try {
+            return await hideChatThread(threadId, hidden, {
+                apiUrl,
+                scope: historyScope,
+            });
+        }
+        catch (error) {
+            if (previous)
+                setThreads((threads) => threads.map((thread) => thread.id === threadId
+                    ? { ...thread, hiddenAt: previous.hiddenAt }
+                    : thread));
+            throw error;
+        }
+    }, [apiUrl, historyScope]);
     const archiveThread = useCallback(async (threadId) => {
         const previousArchivedAt = threadsRef.current.find((t) => t.id === threadId)?.archivedAt ?? null;
         const previousUpdatedAt = threadsRef.current.find((t) => t.id === threadId)?.updatedAt ?? null;
@@ -1642,6 +1686,8 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
             const params = new URLSearchParams({ q: query });
             if (includeExternal)
                 params.set("includeExternal", "1");
+            if (includeHidden)
+                params.set("includeHidden", "1");
             if (ownership && ownership !== "all") {
                 params.set("ownership", ownership);
             }
@@ -1656,7 +1702,14 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
         catch {
             return [];
         }
-    }, [apiUrl, historyScope, includeExternal, isolateHistory, ownership]);
+    }, [
+        apiUrl,
+        historyScope,
+        includeExternal,
+        includeHidden,
+        isolateHistory,
+        ownership,
+    ]);
     const getThreadShareState = useCallback(async (threadId) => {
         try {
             const res = await fetch(withChatThreadScope(`${apiUrl}/threads/${encodeURIComponent(threadId)}/share`, historyScope));
@@ -1698,8 +1751,9 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
     const refreshThreads = useCallback(() => {
         void fetchThreads();
     }, [fetchThreads]);
+    const visibleThreads = useMemo(() => includeHidden ? threads : threads.filter((thread) => !thread.hiddenAt), [includeHidden, threads]);
     return {
-        threads,
+        threads: visibleThreads,
         activeThreadId,
         isLoading,
         createThread,
@@ -1708,6 +1762,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
         deleteThread: removeThread,
         detachThread,
         pinThread,
+        hideThread,
         archiveThread,
         renameThread,
         forkThread,

package/dist/collab/routes.d.ts

@@ -13,12 +13,12 @@ export declare const getCollabState: import("h3").EventHandlerWithFetch<import("
     };
 }>>;
 export declare const postCollabUpdate: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
+    error?: undefined;
     liveCopy: "derived" | "not_derived" | "unchanged";
     liveCopyReason?: string;
-    error?: undefined;
     ok: boolean;
 } | {
     error?: undefined;

package/dist/db/client.d.ts

@@ -165,6 +165,7 @@ export declare function createDbExec(config?: DbExecConfig): Promise<DbExec>;
 export declare function annotateMissingTable(err: unknown, sql: unknown): unknown;
 export declare function withDbExec<T>(exec: DbExec, run: () => T): T;
 export declare function getScopedDbExec(): DbExec | undefined;
+export declare function getScopedTransactionDbExec(): DbExec | undefined;
 /**
  * True while a `getDbExec().transaction()` callback runs. That callback leaves
  * `getScopedDbExec()` unset, so code that must not run inside a caller's

package/dist/db/client.js

@@ -1722,11 +1722,23 @@ export function annotateMissingTable(err, sql) {
 const scopedDbExec = new AsyncLocalStorage();
 const transactionCallbacks = new AsyncLocalStorage();
 export function withDbExec(exec, run) {
-    return scopedDbExec.run(guardSchemaMutations(exec), run);
+    const guarded = guardSchemaMutations(exec);
+    const callback = transactionCallbacks.getStore();
+    if (callback?.active && callback.executors.has(exec)) {
+        callback.executors.add(guarded);
+    }
+    return scopedDbExec.run(guarded, run);
 }
 export function getScopedDbExec() {
     return scopedDbExec.getStore();
 }
+export function getScopedTransactionDbExec() {
+    const scoped = getScopedDbExec();
+    const callback = transactionCallbacks.getStore();
+    return scoped && callback?.active && callback.executors.has(scoped)
+        ? scoped
+        : undefined;
+}
 /**
  * True while a `getDbExec().transaction()` callback runs. That callback leaves
  * `getScopedDbExec()` unset, so code that must not run inside a caller's
@@ -1735,8 +1747,8 @@ export function getScopedDbExec() {
 export function insideDbTransactionCallback() {
     return transactionCallbacks.getStore()?.active === true;
 }
-async function inTransactionCallback(run) {
-    const callback = { active: true };
+async function inTransactionCallback(exec, run) {
+    const callback = { active: true, executors: new WeakSet([exec]) };
     try {
         return await transactionCallbacks.run(callback, run);
     }
@@ -1804,17 +1816,21 @@ export function getDbExec() {
                     if (!currentExec.transaction) {
                         throw new Error("This database does not support transactions.");
                     }
-                    return currentExec.transaction((tx) => inTransactionCallback(() => fn({
-                        execute: (s) => {
-                            assertSchemaMutationAllowed(s);
-                            return tx.execute(sanitize(s));
-                        },
-                        transaction: tx.transaction?.bind(tx),
-                    })));
+                    return currentExec.transaction((tx) => runTransactionCallback(tx, fn));
                 }
                 : undefined,
         };
     }
+    function runTransactionCallback(tx, fn) {
+        const exec = {
+            execute: (s) => {
+                assertSchemaMutationAllowed(s);
+                return tx.execute(sanitize(s));
+            },
+            transaction: tx.transaction?.bind(tx),
+        };
+        return inTransactionCallback(exec, () => fn(exec));
+    }
     const proxy = {
         async execute(sql) {
             assertSchemaMutationAllowed(sql);
@@ -1826,19 +1842,13 @@ export function getDbExec() {
             const exec = await initializeProxy();
             Object.assign(proxy, createInitializedProxy(exec));
             if (exec.transaction) {
-                return exec.transaction((tx) => inTransactionCallback(() => fn({
-                    execute: (s) => {
-                        assertSchemaMutationAllowed(s);
-                        return tx.execute(sanitize(s));
-                    },
-                    transaction: tx.transaction?.bind(tx),
-                })));
+                return exec.transaction((tx) => runTransactionCallback(tx, fn));
             }
             if (exec.atomicBatch) {
                 throw new Error("This database supports atomic batches, not interactive transactions.");
             }
             const wrapper = createInitializedProxy(exec);
-            return explicitTransaction(wrapper.execute.bind(wrapper))((tx) => inTransactionCallback(() => fn(tx)));
+            return explicitTransaction(wrapper.execute.bind(wrapper))((tx) => inTransactionCallback(tx, () => fn(tx)));
         },
         async atomicBatch(statements) {
             for (const statement of statements) {

package/dist/db/schema-snapshot.generated.js

@@ -73,6 +73,7 @@ export const SCHEMA_SNAPSHOT = {
         'CREATE TABLE "automation_trigger_event_queue_sweep_state" (\n  "scope_key" text NOT NULL,\n  "last_trigger_id" text,\n  "purge_after" bigint DEFAULT 0 NOT NULL,\n  "updated_at" bigint NOT NULL\n);',
         'CREATE TABLE "automation_webhook_tokens" (\n  "token_hash" text NOT NULL,\n  "automation_id" text NOT NULL,\n  "owner" text NOT NULL,\n  "path" text NOT NULL,\n  "secret_scope" text NOT NULL,\n  "secret_scope_id" text NOT NULL,\n  "secret_key" text NOT NULL,\n  "created_at" bigint NOT NULL,\n  "updated_at" bigint NOT NULL\n);',
         'CREATE TABLE "chat_thread_shares" (\n  "id" text NOT NULL,\n  "resource_id" text NOT NULL,\n  "principal_type" text NOT NULL,\n  "principal_id" text NOT NULL,\n  "role" text DEFAULT \'viewer\'::text NOT NULL,\n  "created_by" text NOT NULL,\n  "created_at" text DEFAULT now() NOT NULL,\n  "notified_at" text\n);',
+        'CREATE TABLE "chat_thread_viewer_state" (\n  "thread_id" text NOT NULL,\n  "user_email" text NOT NULL,\n  "pinned_at" bigint,\n  "hidden_at" bigint,\n  "updated_at" bigint NOT NULL\n);',
         'CREATE TABLE "chat_threads" (\n  "id" text NOT NULL,\n  "owner_email" text NOT NULL,\n  "title" text DEFAULT \'\'::text NOT NULL,\n  "preview" text DEFAULT \'\'::text NOT NULL,\n  "thread_data" text DEFAULT \'{}\'::text NOT NULL,\n  "message_count" bigint DEFAULT 0 NOT NULL,\n  "created_at" bigint NOT NULL,\n  "updated_at" bigint NOT NULL,\n  "scope_type" text,\n  "scope_id" text,\n  "scope_label" text,\n  "pinned_at" bigint,\n  "archived_at" bigint,\n  "share_token_hash" text,\n  "source_platform" text,\n  "source_app_id" text,\n  "source_url" text,\n  "org_id" text,\n  "visibility" text DEFAULT \'private\'::text NOT NULL\n);',
         'CREATE TABLE "context_directives" (\n  "id" text NOT NULL,\n  "thread_id" text NOT NULL,\n  "segment_id" text NOT NULL,\n  "action" text NOT NULL,\n  "summary_text" text,\n  "created_by" text DEFAULT \'user\'::text NOT NULL,\n  "active" integer DEFAULT 1 NOT NULL,\n  "origin_turn" text,\n  "created_at" integer NOT NULL,\n  "updated_at" integer NOT NULL,\n  "owner_email" text DEFAULT \'local@localhost\'::text NOT NULL,\n  "org_id" text,\n  "visibility" text DEFAULT \'private\'::text NOT NULL\n);',
         'CREATE TABLE "custom_api_providers" (\n  "id" text NOT NULL,\n  "scope" text NOT NULL,\n  "scope_id" text NOT NULL,\n  "label" text NOT NULL,\n  "base_url" text NOT NULL,\n  "auth_json" text NOT NULL,\n  "docs_urls_json" text NOT NULL,\n  "allowed_host_suffixes_json" text NOT NULL,\n  "default_headers_json" text NOT NULL,\n  "notes" text DEFAULT \'\'::text NOT NULL,\n  "created_at" bigint NOT NULL,\n  "updated_at" bigint NOT NULL\n);',
@@ -251,6 +252,7 @@ export const SCHEMA_SNAPSHOT = {
         'ALTER TABLE "automation_webhook_tokens" ADD CONSTRAINT "automation_webhook_tokens_automation_id_key" UNIQUE (automation_id);',
         'ALTER TABLE "automation_webhook_tokens" ADD CONSTRAINT "automation_webhook_tokens_pkey" PRIMARY KEY (token_hash);',
         'ALTER TABLE "chat_thread_shares" ADD CONSTRAINT "chat_thread_shares_pkey" PRIMARY KEY (id);',
+        'ALTER TABLE "chat_thread_viewer_state" ADD CONSTRAINT "chat_thread_viewer_state_pkey" PRIMARY KEY (thread_id, user_email);',
         'ALTER TABLE "chat_threads" ADD CONSTRAINT "chat_threads_pkey" PRIMARY KEY (id);',
         'ALTER TABLE "context_directives" ADD CONSTRAINT "context_directives_pkey" PRIMARY KEY (id);',
         'ALTER TABLE "custom_api_providers" ADD CONSTRAINT "custom_api_providers_pkey" PRIMARY KEY (scope, scope_id, id);',
@@ -377,6 +379,7 @@ export const SCHEMA_SNAPSHOT = {
         'ALTER TABLE "workspace_connection_grants" ADD CONSTRAINT "workspace_connection_grants_pkey" PRIMARY KEY (id);',
         'ALTER TABLE "workspace_connections" ADD CONSTRAINT "workspace_connections_pkey" PRIMARY KEY (id);',
         'ALTER TABLE "workspace_user_groups" ADD CONSTRAINT "workspace_user_groups_pkey" PRIMARY KEY (id);',
+        'ALTER TABLE "chat_thread_viewer_state" ADD CONSTRAINT "chat_thread_viewer_state_thread_id_fkey" FOREIGN KEY (thread_id) REFERENCES chat_threads(id) ON DELETE CASCADE;',
         "CREATE UNIQUE INDEX idx_a2a_tasks_org_scope_idempotency ON public.a2a_tasks USING btree (owner_scope, idempotency_key) WHERE ((owner_email IS NULL) AND (idempotency_key IS NOT NULL));",
         "CREATE UNIQUE INDEX idx_a2a_tasks_owner_scope_idempotency ON public.a2a_tasks USING btree (owner_email, owner_scope, idempotency_key);",
         "CREATE INDEX idx_a2a_tasks_recovery_created ON public.a2a_tasks USING btree (created_at) WHERE (status_state = ANY (ARRAY['submitted'::text, 'working'::text, 'processing'::text]));",
@@ -696,6 +699,7 @@ export const SCHEMA_SNAPSHOT = {
         "automation_trigger_event_queue_sweep_state",
         "automation_webhook_tokens",
         "chat_thread_shares",
+        "chat_thread_viewer_state",
         "chat_threads",
         "context_directives",
         "custom_api_providers",
@@ -974,6 +978,7 @@ export const SCHEMA_SNAPSHOT = {
             "76d071b18224f89b",
         ],
         ["chat_threads", "indexes", null],
+        ["chat_threads", "viewer-state", "12d60e0fc4587fc5"],
         ["chat_threads", "widen-bigint", null],
         ["checkpoints", "baseline", null],
         ["collab_awareness", "baseline", null],

package/dist/identity/rekey.d.ts

@@ -10,6 +10,8 @@ export type IdentityColumn = {
     mode?: "email" | "user-scope" | "secret-scope" | "user-share" | "group-json" | "state-session" | "email-user-id" | "viewer-consent" | "owner" | "typed-scope" | "custom-scope" | "scope-key" | "unsupported-oauth";
     /** Email-change behavior. Omitted means rewrite the value to the new address. */
     emailChange?: IdentityEmailChange;
+    /** The other key columns. An email change refuses when the new address already holds the same key. */
+    uniqueWith?: readonly string[];
     /** Offboarding behavior. Omitted means offboard.ts derives it from `mode`. */
     offboard?: IdentityOffboard;
     /** How an organization-scoped offboard finds this organization's rows. Omitted means an `org_id` column. */

package/dist/identity/rekey.js

@@ -53,6 +53,17 @@ export const IDENTITY_REKEY_COLUMNS = [
     },
     { table: "agent_turn_initiators", column: "principal_email" },
     { table: "chat_threads", column: "owner_email" },
+    {
+        table: "chat_thread_viewer_state",
+        column: "user_email",
+        emailChange: "rekey",
+        uniqueWith: ["thread_id"],
+        offboard: "delete",
+        orgScope: {
+            column: "thread_id",
+            references: { table: "chat_threads", column: "id", orgColumn: "org_id" },
+        },
+    },
     { table: "chat_thread_shares", column: "principal_id", mode: "user-share" },
     { table: "chat_thread_shares", column: "created_by" },
     { table: "data_programs", column: "owner_email" },
@@ -1016,6 +1027,14 @@ export async function rekeyIdentity(db, oldEmailInput, newEmailInput, options =
                 await db.unsafe(`UPDATE ${quote(entry.table)} SET ${quote(entry.column)} = CASE WHEN LOWER(${quote(entry.column)}) = LOWER($1) THEN $3 ELSE 'user:' || $3 END WHERE ${where}`, [...args, newEmail]);
         }
         else {
+            if (entry.uniqueWith?.length) {
+                const sameKey = entry.uniqueWith
+                    .map((column) => `target.${quote(column)} = source.${quote(column)}`)
+                    .join(" AND ");
+                const collisionRows = await db.unsafe(`SELECT 1 FROM ${quote(entry.table)} source JOIN ${quote(entry.table)} target ON ${sameKey} AND LOWER(target.${quote(entry.column)}) = LOWER($2) WHERE LOWER(source.${quote(entry.column)}) = LOWER($1) LIMIT 1`, [oldEmail, newEmail]);
+                if (collisionRows.length)
+                    throw new Error(`${entry.table} key collision detected; no identity data was changed.`);
+            }
             if (!options.dryRun) {
                 const update = await db.unsafe(`UPDATE ${quote(entry.table)} SET ${quote(entry.column)} = $${args.length + 1} WHERE ${where}`, [...args, newEmail]);
                 counts[`${entry.table}.${entry.column}`] = update.count ?? count;

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export * from "./config.js";
 export * from "./authorization/index.js";
 export { createProductionAgentHandler, type ActionEntry, type ScriptEntry, type ProductionAgentOptions, type AgentActionSurface, type DefaultAgentActionSurface, type AgentActionSurfaceResolution, type AgentActionSurfaceDetails, type ActionTool, type ScriptTool, type AgentMessage, type AgentChatRequest, type AgentChatEvent, type AgentChatAttachment, DEFAULT_MODEL, TripWire, type Processor, type ProcessorState, type ProcessorAbort, } from "./agent/index.js";
-export { defineAction, fail, type FailOptions, ActionContractError, isActionContractError, type ActionContractErrorOptions, ActionOutputContractError, isActionOutputContractError, type ActionOutputContractErrorOptions, type ActionOutputEffect, type ActionMcpOutputContract, AgentActionStopError, isAgentActionStopError, type ActionDefinition, type ActionHttpConfig, type AgentActionStopOptions, type PublicAgentActionConfig, type ActionDeepLink, type ActionLinkBuilder, MCP_APP_EXTENSION_ID, MCP_APP_MIME_TYPE, MCP_APP_RESOURCE_URI_META_KEY, type ActionMcpAppConfig, type ActionMcpAppCsp, type ActionMcpAppCspBuilder, type ActionMcpAppHtmlBuilder, type ActionMcpAppPermissions, type ActionMcpAppResourceConfig, type ActionMcpAppResourceMeta, } from "./action.js";
+export { defineAction, fail, type FailOptions, ActionContractError, isActionContractError, type ActionContractErrorOptions, NoWriteError, isNoWriteError, ActionOutputContractError, isActionOutputContractError, type ActionOutputContractErrorOptions, type ActionOutputEffect, type ActionMcpOutputContract, AgentActionStopError, isAgentActionStopError, type ActionDefinition, type ActionHttpConfig, type AgentActionStopOptions, type PublicAgentActionConfig, type ActionDeepLink, type ActionLinkBuilder, MCP_APP_EXTENSION_ID, MCP_APP_MIME_TYPE, MCP_APP_RESOURCE_URI_META_KEY, type ActionMcpAppConfig, type ActionMcpAppCsp, type ActionMcpAppCspBuilder, type ActionMcpAppHtmlBuilder, type ActionMcpAppPermissions, type ActionMcpAppResourceConfig, type ActionMcpAppResourceMeta, } from "./action.js";
 export * from "./user-profile/index.js";
 export { embedApp, MCP_APP_REQUEST_ORIGIN_CSP_SOURCE, type EmbedAppOptions, } from "./mcp/embed-app.js";
 export { embedRoute, type EmbedRouteContext, type EmbedRouteOptions, type EmbedRoutePathBuilder, type EmbedRouteResult, } from "./mcp/embed-route.js";

package/dist/index.js

@@ -1,7 +1,7 @@
 export * from "./config.js";
 export * from "./authorization/index.js";
 export { createProductionAgentHandler, DEFAULT_MODEL, TripWire, } from "./agent/index.js";
-export { defineAction, fail, ActionContractError, isActionContractError, ActionOutputContractError, isActionOutputContractError, AgentActionStopError, isAgentActionStopError, MCP_APP_EXTENSION_ID, MCP_APP_MIME_TYPE, MCP_APP_RESOURCE_URI_META_KEY, } from "./action.js";
+export { defineAction, fail, ActionContractError, isActionContractError, NoWriteError, isNoWriteError, ActionOutputContractError, isActionOutputContractError, AgentActionStopError, isAgentActionStopError, MCP_APP_EXTENSION_ID, MCP_APP_MIME_TYPE, MCP_APP_RESOURCE_URI_META_KEY, } from "./action.js";
 export * from "./user-profile/index.js";
 export { embedApp, MCP_APP_REQUEST_ORIGIN_CSP_SOURCE, } from "./mcp/embed-app.js";
 export { embedRoute, } from "./mcp/embed-route.js";

package/dist/mcp/agent-connected.d.ts

@@ -4,6 +4,11 @@ export declare function connectionApp(origin: string, appId?: string): string;
  * Any other device client value, such as "Example, Inc.", is one name.
  */
 export declare function deviceFlowClients(client: string | null): string | string[] | null;
+/**
+ * The client key `agent_connected` reports. OAuth funnel events carry the same
+ * key, so a client's starts and finished connections join on it.
+ */
+export declare function connectionClientKey(name: string): string;
 export declare function trackAgentConnected(input: {
     email: string;
     origin: string;

package/dist/mcp/agent-connected.js

@@ -18,6 +18,15 @@ export function deviceFlowClients(client) {
     const ids = client?.split(",");
     return ids?.every((id) => CLIENTS.includes(id)) ? ids : client;
 }
+/**
+ * The client key `agent_connected` reports. OAuth funnel events carry the same
+ * key, so a client's starts and finished connections join on it.
+ */
+export function connectionClientKey(name) {
+    return (resolveMcpConnectHostId(name) ??
+        detectVendorClient(name) ??
+        (name.trim().toLowerCase().slice(0, 120) || "unknown"));
+}
 export async function trackAgentConnected(input) {
     // Everything runs inside the try: the connection is already committed, so a
     // tracking or configuration failure must not turn it into a failed response.
@@ -30,9 +39,7 @@ export async function trackAgentConnected(input) {
             return "disabled";
         const app = connectionApp(input.origin, input.appId);
         const raw = input.client;
-        const clients = new Set((typeof raw === "string" ? [raw] : (raw ?? ["unknown"])).map((name) => resolveMcpConnectHostId(name) ??
-            detectVendorClient(name) ??
-            (name.trim().toLowerCase().slice(0, 120) || "unknown")));
+        const clients = new Set((typeof raw === "string" ? [raw] : (raw ?? ["unknown"])).map((name) => connectionClientKey(name)));
         let emitted = false;
         for (const client of clients) {
             const email = input.email.trim().toLowerCase();

package/dist/mcp/analytics.d.ts

@@ -4,15 +4,19 @@ export declare const MCP_ANALYTICS_EVENTS: {
     readonly toolCall: "$mcp_tool_call";
     readonly resourcesList: "$mcp_resources_list";
     readonly resourceRead: "$mcp_resource_read";
+    readonly oauthAuthorizeOpened: "$mcp_oauth_authorize_opened";
+    readonly oauthLoginWallShown: "$mcp_oauth_login_wall_shown";
 };
 export interface McpAnalyticsContext {
     source: "http" | "stdio";
     serverName: string;
-    serverVersion: string;
+    serverVersion?: string;
     appId?: string;
     clientName?: string;
     clientVersion?: string;
     clientUserAgent?: string;
+    clientKey?: string;
+    redirectHost?: string;
     protocolVersion?: string;
     userId?: string;
     sessionId?: string;
@@ -24,6 +28,7 @@ interface McpRequestLike {
     _meta?: Record<string, unknown> | undefined;
 }
 export declare function detectVendorClient(...candidates: Array<string | undefined>): string | undefined;
+export declare function vendorForRedirectHost(host: string | undefined): string | undefined;
 export declare function readClientInfoFromRequest(request: McpRequestLike | undefined): {
     clientName?: string;
     clientVersion?: string;
@@ -56,6 +61,14 @@ export declare function trackMcpResourceRead(ctx: McpAnalyticsContext, args: {
     errorType?: string;
     errorMessage?: string;
 }): void;
+export type McpOAuthRoute = "directory" | "mcp";
+export declare function trackMcpOAuthAuthorizeOpened(ctx: McpAnalyticsContext, args: {
+    route: McpOAuthRoute;
+    signedIn: boolean;
+}): void;
+export declare function trackMcpOAuthLoginWallShown(ctx: McpAnalyticsContext, args: {
+    route: McpOAuthRoute;
+}): void;
 export declare function describeMcpError(err: unknown): {
     errorType: string;
     errorMessage: string;

package/dist/mcp/analytics.js

@@ -9,6 +9,8 @@ export const MCP_ANALYTICS_EVENTS = {
     toolCall: "$mcp_tool_call",
     resourcesList: "$mcp_resources_list",
     resourceRead: "$mcp_resource_read",
+    oauthAuthorizeOpened: "$mcp_oauth_authorize_opened",
+    oauthLoginWallShown: "$mcp_oauth_login_wall_shown",
 };
 const VENDOR_CLIENT_PATTERNS = [
     [/claude[\s._-]?code/, "claude-code"],
@@ -41,6 +43,22 @@ export function detectVendorClient(...candidates) {
     }
     return undefined;
 }
+// A known redirect host labels a vendor when the client's name does not (a
+// client that points its callback at a domain it does not control cannot use
+// the code). It is still the client's own registration, so it does not prove
+// who the client is. Match the host itself or a subdomain, never a substring:
+// that would credit `openai.evil.example`.
+const REDIRECT_HOST_VENDORS = [
+    ["chatgpt.com", "openai"],
+    ["openai.com", "openai"],
+    ["claude.ai", "claude"],
+];
+export function vendorForRedirectHost(host) {
+    const name = host?.toLowerCase();
+    if (!name)
+        return undefined;
+    return REDIRECT_HOST_VENDORS.find(([domain]) => name === domain || name.endsWith(`.${domain}`))?.[1];
+}
 export function readClientInfoFromRequest(request) {
     const meta = request?.params?._meta ?? request?._meta;
     if (!meta || typeof meta !== "object")
@@ -65,18 +83,31 @@ function captureParameters() {
     return getAppConfig().observability.mcpCaptureParameters;
 }
 function contextProperties(ctx) {
-    const vendor = detectVendorClient(ctx.clientName, ctx.clientUserAgent);
+    // The client's name or user agent labels the vendor as it does on every other
+    // MCP event, so the dimension stays consistent; a known redirect host labels
+    // it only when they do not. On OAuth events (the ones with a redirect host)
+    // `$mcp_vendor_source` says whether the host gave the same label. Neither
+    // proves who the client is.
+    const hostVendor = vendorForRedirectHost(ctx.redirectHost);
+    const vendor = detectVendorClient(ctx.clientName, ctx.clientUserAgent) ?? hostVendor;
     return {
         $mcp_source: ctx.source,
         $mcp_server_name: ctx.serverName,
-        $mcp_server_version: ctx.serverVersion,
+        ...(ctx.serverVersion ? { $mcp_server_version: ctx.serverVersion } : {}),
         ...(ctx.appId ? { $mcp_app_id: ctx.appId } : {}),
         ...(ctx.clientName ? { $mcp_client_name: ctx.clientName } : {}),
         ...(ctx.clientVersion ? { $mcp_client_version: ctx.clientVersion } : {}),
         ...(ctx.clientUserAgent
             ? { $mcp_client_user_agent: ctx.clientUserAgent }
             : {}),
+        ...(ctx.clientKey ? { $mcp_client_key: ctx.clientKey } : {}),
+        ...(ctx.redirectHost ? { $mcp_redirect_host: ctx.redirectHost } : {}),
         ...(vendor ? { $mcp_vendor_client: vendor } : {}),
+        ...(vendor && ctx.redirectHost
+            ? {
+                $mcp_vendor_source: hostVendor === vendor ? "redirect_host" : "client_name",
+            }
+            : {}),
         ...(ctx.protocolVersion
             ? { $mcp_protocol_version: ctx.protocolVersion }
             : {}),
@@ -142,6 +173,27 @@ export function trackMcpResourceRead(ctx, args) {
         ...(args.errorMessage ? { $mcp_error_message: args.errorMessage } : {}),
     });
 }
+// A new user's attempt serves two pages: the sign-in page (signedIn false, with
+// a login wall) and, after sign-in, the consent page (signedIn true). A
+// returning signed-in user sees only the consent page. So signedIn false counts
+// signed-out arrivals and signedIn true counts everyone who reached consent,
+// new and returning together; neither is "starts" on its own, and adding them
+// double-counts new users.
+export function trackMcpOAuthAuthorizeOpened(ctx, args) {
+    if (!analyticsEnabled())
+        return;
+    emit(MCP_ANALYTICS_EVENTS.oauthAuthorizeOpened, ctx, {
+        $mcp_oauth_route: args.route,
+        $mcp_oauth_signed_in: args.signedIn,
+    });
+}
+export function trackMcpOAuthLoginWallShown(ctx, args) {
+    if (!analyticsEnabled())
+        return;
+    emit(MCP_ANALYTICS_EVENTS.oauthLoginWallShown, ctx, {
+        $mcp_oauth_route: args.route,
+    });
+}
 export function describeMcpError(err) {
     if (err && typeof err === "object") {
         const record = err;

package/dist/mcp/embed-app.js

@@ -1,5 +1,6 @@
 import { MCP_APP_CHAT_BRIDGE_QUERY_PARAM } from "../shared/embed-auth.js";
 import { MCP_APP_HOST_FILL_ATTRIBUTE, MCP_APP_PANE_FILL_MAX_HEIGHT, } from "../shared/mcp-app-display.js";
+import { EXTERNAL_EMBED_WINDOW_KEY } from "../shared/route-chunk-recovery-bootstrap.js";
 const MCP_APP_IMPORT = "https://esm.sh/@modelcontextprotocol/ext-apps@1.7.5/app-with-deps";
 export const MCP_APP_REQUEST_ORIGIN_CSP_SOURCE = "$requestOrigin";
 const MCP_APP_WRAPPER_CHROME_HEIGHT = 44;
@@ -714,7 +715,7 @@ export function embedApp(options = {}) {
     }
 
     function installExternalEmbedRuntime(config) {
-      window.__AGENT_NATIVE_EXTERNAL_EMBED = config;
+      window[${JSON.stringify(EXTERNAL_EMBED_WINDOW_KEY)}] = config;
       installReactRefreshPreambleFallback();
       try {
         if (config.target) {

package/dist/mcp/oauth-route.js

@@ -8,7 +8,8 @@ import { getAuthSecret } from "../server/better-auth-instance.js";
 import { CREDENTIAL_MEMBERSHIP_UNAVAILABLE_MESSAGE } from "../server/credential-membership-unavailable.js";
 import { getOrigin } from "../server/google-oauth.js";
 import { readBody } from "../server/h3-helpers.js";
-import { trackAgentConnected } from "./agent-connected.js";
+import { connectionApp, connectionClientKey, trackAgentConnected, } from "./agent-connected.js";
+import { trackMcpOAuthAuthorizeOpened, trackMcpOAuthLoginWallShown, } from "./analytics.js";
 import { McpCredentialIssuanceError, withMcpCredentialIssuance, } from "./credential-issuance.js";
 import { applicationTypeForRedirectUris, isAllowedOAuthRedirectUri, isUrlBasedOAuthClientId, matchesRegisteredRedirectUri, resolveOAuthClientMetadataDocument, } from "./oauth-client-metadata.js";
 import { createOAuthCode, createOAuthRefreshToken, consumeOAuthCode, ensureOAuthTables, generateOpaqueToken, getOAuthClient, getOAuthCode, getOAuthRefreshToken, registerOAuthClient, revokeOAuthRefreshToken, touchOAuthRefreshToken, } from "./oauth-store.js";
@@ -595,6 +596,41 @@ async function readOAuthParams(event) {
     }
     return {};
 }
+function trackAuthorizeStage(stage, input) {
+    // The authorize page is the only way into a connection, so a tracking fault
+    // must not turn a sign-in into a failure.
+    try {
+        const ctx = {
+            source: "http",
+            serverName: input.options.appName || input.options.appId || "Agent-Native",
+            appId: connectionApp(input.issuer, input.options.appId),
+            ...(input.clientName ? { clientName: input.clientName } : {}),
+            // The key agent_connected reports, so a client's starts and finished
+            // connections join on it.
+            clientKey: connectionClientKey(input.clientName ?? "unknown"),
+            // Host only: the redirect URI's path and query can carry per-attempt values.
+            ...(URL.canParse(input.redirectUri)
+                ? { redirectHost: new URL(input.redirectUri).hostname }
+                : {}),
+            ...(input.userId ? { userId: input.userId } : {}),
+        };
+        const route = input.resource.endsWith(MCP_DIRECTORY_ROUTE_PREFIX)
+            ? "directory"
+            : "mcp";
+        if (stage === "opened") {
+            trackMcpOAuthAuthorizeOpened(ctx, {
+                route,
+                signedIn: Boolean(input.userId),
+            });
+        }
+        else {
+            trackMcpOAuthLoginWallShown(ctx, { route });
+        }
+    }
+    catch (error) {
+        console.error("[mcp-oauth-analytics] Failed to record authorize:", error);
+    }
+}
 async function handleAuthorize(event, options) {
     const method = getMethod(event);
     if (method !== "GET" && method !== "POST") {
@@ -634,6 +670,13 @@ async function handleAuthorize(event, options) {
         return oauthError("invalid_client", "Unknown client or redirect_uri");
     }
     const session = await getSession(event);
+    const analyticsInput = {
+        issuer,
+        options,
+        clientName: client.clientName,
+        redirectUri,
+        resource,
+    };
     if (!session?.email) {
         if (params.prompt === "none") {
             return redirectWithOAuthError({
@@ -644,6 +687,14 @@ async function handleAuthorize(event, options) {
             });
         }
         const loginPage = getConfiguredLoginHtml(event);
+        // Only the real sign-in page (200) is a login wall; 503 is the deploy's
+        // setup-required page. The consent POST is the same visit continuing, not
+        // a second open.
+        if (loginPage?.status === 200) {
+            if (method === "GET")
+                trackAuthorizeStage("opened", analyticsInput);
+            trackAuthorizeStage("login_wall", analyticsInput);
+        }
         return loginPage
             ? html(loginPage.html, loginPage.status)
             : oauthError("login_required", "Sign in required", 401);
@@ -661,6 +712,10 @@ async function handleAuthorize(event, options) {
         ? params.organization_id || null
         : undefined);
     if (method === "GET") {
+        trackAuthorizeStage("opened", {
+            ...analyticsInput,
+            userId: session.email,
+        });
         return html(renderConsentPage({
             appName: options.appName || options.appId || "Agent-Native",
             email: session.email,