@agent-native/core 0.207.0 → 0.207.1-nightly-20261011212936

package/dist/client/chat/agentkit-agent-native.js

@@ -1,5 +1,5 @@
 import { AgentKitRunSlotBusyError } from "@agent-native/agentkit/client";
-import { isAgentKitProtocolVersion, parseAgentQueuedMessage, parseAgentRunOptions, parseAgentThreadSnapshot, persistableFilePart, } from "@agent-native/agentkit/protocol";
+import { agentEventSequenceEnd, isAgentKitProtocolVersion, parseAgentQueuedMessage, parseAgentRunOptions, parseAgentThreadSnapshot, persistableFilePart, } from "@agent-native/agentkit/protocol";
 import { projectRootAssistantMessages } from "../../agent/thread-message-projection.js";
 import { RUN_NOT_STARTED_METADATA_KEY, retryContextFromRequest, } from "../../shared/agent-chat-run-not-started.js";
 import { assertNoInlineImageBytes, stripInlineBytes, } from "../../shared/inline-bytes.js";
@@ -1135,77 +1135,162 @@ function persistedRetryRequestAttachments(value) {
         ];
     });
 }
+const MAX_PERSISTED_EVENT_OMISSION_RANGE = 256;
+const MAX_PERSISTED_EVENT_PREFIX_RANGES = 4_096;
 function persistedHistoryEvents(events = []) {
-    const sequenceByRun = new Map();
-    return events.flatMap((event) => {
+    const persisted = [];
+    const seenRuns = new Set();
+    let generatedPrefixRanges = 0;
+    const lastOmissionByRun = new Map();
+    for (const event of events) {
+        if (!seenRuns.has(event.runId)) {
+            seenRuns.add(event.runId);
+            const prefixRangeCount = Math.ceil(Math.max(0, event.sequence - 1) / MAX_PERSISTED_EVENT_OMISSION_RANGE);
+            if (generatedPrefixRanges + prefixRangeCount >
+                MAX_PERSISTED_EVENT_PREFIX_RANGES) {
+                throw new RangeError("Agent chat retained history prefix exceeds the supported omission range count.");
+            }
+            generatedPrefixRanges += prefixRangeCount;
+            for (let firstSequence = 1; firstSequence < event.sequence; firstSequence += MAX_PERSISTED_EVENT_OMISSION_RANGE) {
+                const lastSequence = Math.min(event.sequence - 1, firstSequence + MAX_PERSISTED_EVENT_OMISSION_RANGE - 1);
+                const index = persisted.length;
+                persisted.push({
+                    id: `persisted-history-prefix:${event.runId}:${firstSequence}`,
+                    threadId: event.threadId,
+                    runId: event.runId,
+                    sequence: firstSequence,
+                    occurredAt: event.occurredAt,
+                    type: "x-agent-native.persisted-event-omission-range",
+                    payload: {
+                        lastSequence,
+                        sourceType: "runtime_history_prefix",
+                    },
+                });
+                lastOmissionByRun.set(event.runId, {
+                    index,
+                    firstSequence,
+                    lastSequence,
+                });
+            }
+        }
         const base = () => {
-            const sequence = (sequenceByRun.get(event.runId) ?? 0) + 1;
-            sequenceByRun.set(event.runId, sequence);
             return {
                 id: event.id,
                 threadId: event.threadId,
                 runId: event.runId,
-                sequence,
+                sequence: event.sequence,
                 occurredAt: event.occurredAt,
             };
         };
         if (event.type === "run.started") {
-            return [{ ...base(), type: event.type }];
+            persisted.push({ ...base(), type: event.type });
+            lastOmissionByRun.delete(event.runId);
+            continue;
         }
         if (event.type === "run.completed" || event.type === "run.cancelled") {
-            return [{ ...base(), type: event.type }];
+            persisted.push({ ...base(), type: event.type });
+            lastOmissionByRun.delete(event.runId);
+            continue;
         }
         if (event.type === "run.failed") {
-            return [
-                { ...base(), type: event.type, error: persistedError(event.error) },
-            ];
+            persisted.push({
+                ...base(),
+                type: event.type,
+                error: persistedError(event.error),
+            });
+            lastOmissionByRun.delete(event.runId);
+            continue;
         }
         if (event.type === "run.status") {
-            return [{ ...base(), type: event.type, status: event.status }];
+            persisted.push({ ...base(), type: event.type, status: event.status });
+            lastOmissionByRun.delete(event.runId);
+            continue;
+        }
+        if (event.type === "x-agent-native.persisted-event-omission" ||
+            event.type === "x-agent-native.persisted-event-omission-range") {
+            const index = persisted.length;
+            persisted.push(event);
+            lastOmissionByRun.set(event.runId, {
+                index,
+                firstSequence: event.sequence,
+                lastSequence: agentEventSequenceEnd(event),
+            });
+            continue;
         }
         if (event.type === "activity.started" ||
             event.type === "activity.updated" ||
             event.type === "activity.completed") {
             const activity = event.activity;
-            return [
-                {
-                    ...base(),
-                    type: event.type,
-                    activity: {
-                        id: activity.id,
-                        kind: activity.kind,
-                        label: activity.label,
-                        status: activity.status,
-                        ...(activity.runId ? { runId: activity.runId } : {}),
-                        ...(activity.agentId ? { agentId: activity.agentId } : {}),
-                        ...(activity.startedAt ? { startedAt: activity.startedAt } : {}),
-                        ...(activity.completedAt
-                            ? { completedAt: activity.completedAt }
-                            : {}),
-                    },
+            persisted.push({
+                ...base(),
+                type: event.type,
+                activity: {
+                    id: activity.id,
+                    kind: activity.kind,
+                    label: activity.label,
+                    status: activity.status,
+                    ...(activity.runId ? { runId: activity.runId } : {}),
+                    ...(activity.agentId ? { agentId: activity.agentId } : {}),
+                    ...(activity.startedAt ? { startedAt: activity.startedAt } : {}),
+                    ...(activity.completedAt
+                        ? { completedAt: activity.completedAt }
+                        : {}),
                 },
-            ];
+            });
+            lastOmissionByRun.delete(event.runId);
+            continue;
         }
         if (event.type === "message.completed" &&
             event.message.role === "assistant") {
-            return [
-                {
-                    ...base(),
-                    type: event.type,
-                    message: {
-                        id: event.message.id,
-                        role: event.message.role,
-                        parts: event.message.parts.filter((part) => part.type === "text"),
-                        ...(event.message.createdAt
-                            ? { createdAt: event.message.createdAt }
-                            : {}),
-                        ...(event.message.status ? { status: event.message.status } : {}),
-                    },
+            persisted.push({
+                ...base(),
+                type: event.type,
+                message: {
+                    id: event.message.id,
+                    role: event.message.role,
+                    parts: event.message.parts.filter((part) => part.type === "text"),
+                    ...(event.message.createdAt
+                        ? { createdAt: event.message.createdAt }
+                        : {}),
+                    ...(event.message.status ? { status: event.message.status } : {}),
                 },
-            ];
+            });
+            lastOmissionByRun.delete(event.runId);
+            continue;
         }
-        return [];
-    });
+        const previous = lastOmissionByRun.get(event.runId);
+        if (previous &&
+            event.sequence === previous.lastSequence + 1 &&
+            event.sequence - previous.firstSequence + 1 <=
+                MAX_PERSISTED_EVENT_OMISSION_RANGE) {
+            const omitted = persisted[previous.index];
+            if (omitted) {
+                persisted[previous.index] = {
+                    ...omitted,
+                    type: "x-agent-native.persisted-event-omission-range",
+                    payload: {
+                        ...(asRecord("payload" in omitted ? omitted.payload : undefined) ??
+                            {}),
+                        lastSequence: event.sequence,
+                    },
+                };
+            }
+            previous.lastSequence = event.sequence;
+            continue;
+        }
+        const index = persisted.length;
+        persisted.push({
+            ...base(),
+            type: "x-agent-native.persisted-event-omission",
+            payload: { sourceType: event.type },
+        });
+        lastOmissionByRun.set(event.runId, {
+            index,
+            firstSequence: event.sequence,
+            lastSequence: event.sequence,
+        });
+    }
+    return persisted;
 }
 function persistedMessages(messages) {
     return messages.map((message) => ({
@@ -2339,17 +2424,11 @@ export function createAgentNativeAgentKitTransport(options = {}) {
         }
         const changedEvents = compactEvents.filter((event) => changedEventRunIds.has(event.runId));
         const eventRunLastSequenceById = new Map();
-        for (const run of input.snapshot.runs ?? []) {
-            if (typeof run.id === "string" &&
-                Number.isSafeInteger(run.lastSequence) &&
-                run.lastSequence >= 0) {
-                eventRunLastSequenceById.set(run.id, run.lastSequence);
-            }
-        }
         for (const event of input.snapshot.events ?? []) {
             const previousSequence = eventRunLastSequenceById.get(event.runId) ?? 0;
-            if (Number.isSafeInteger(event.sequence)) {
-                eventRunLastSequenceById.set(event.runId, Math.max(previousSequence, event.sequence));
+            const sequenceEnd = agentEventSequenceEnd(event);
+            if (Number.isSafeInteger(sequenceEnd)) {
+                eventRunLastSequenceById.set(event.runId, Math.max(previousSequence, sequenceEnd));
             }
         }
         const changedEventsByRun = new Map();

package/dist/client/chat/runtime.js

@@ -770,6 +770,53 @@ function isSyntheticToolHistoryOmissionMessage(message) {
         (message.id === AGENTKIT_TOOL_HISTORY_OMISSION_MESSAGE_ID_PREFIX ||
             /^agentkit-tool-history-omission-\d+$/.test(message.id)));
 }
+function equivalentRuntimeContent(left, right) {
+    let remaining = 4096;
+    const leftAncestors = new WeakSet();
+    const rightAncestors = new WeakSet();
+    const compare = (a, b, depth) => {
+        if (--remaining < 0 || depth > 64)
+            return false;
+        if (Object.is(a, b))
+            return true;
+        if (!a || !b || typeof a !== "object" || typeof b !== "object")
+            return false;
+        const prototype = Object.getPrototypeOf(a);
+        if (prototype !== Object.getPrototypeOf(b) ||
+            (prototype !== Object.prototype &&
+                prototype !== Array.prototype &&
+                prototype !== null) ||
+            leftAncestors.has(a) ||
+            rightAncestors.has(b))
+            return false;
+        if (Array.isArray(a) !== Array.isArray(b))
+            return false;
+        if (Array.isArray(a) && (!Array.isArray(b) || a.length !== b.length))
+            return false;
+        const keys = Object.keys(a);
+        if (keys.length > remaining || keys.length !== Object.keys(b).length)
+            return false;
+        leftAncestors.add(a);
+        rightAncestors.add(b);
+        try {
+            return keys.every((key) => {
+                const leftValue = Object.getOwnPropertyDescriptor(a, key);
+                const rightValue = Object.getOwnPropertyDescriptor(b, key);
+                return Boolean(leftValue &&
+                    rightValue &&
+                    rightValue.enumerable &&
+                    "value" in leftValue &&
+                    "value" in rightValue &&
+                    compare(leftValue.value, rightValue.value, depth + 1));
+            });
+        }
+        finally {
+            leftAncestors.delete(a);
+            rightAncestors.delete(b);
+        }
+    };
+    return compare(left, right, 0);
+}
 function priorNativeHistoryMessages(messages, currentPrompt) {
     const source = messages ?? [];
     let currentPromptMessageIndex;
@@ -2864,6 +2911,18 @@ export function createAgentNativeChatRuntime(options = {}) {
             const latestUserMessage = [...(turn.messages ?? [])]
                 .reverse()
                 .find((message) => message.role === "user");
+            const latestUserMessageIndex = latestUserMessage
+                ? (turn.messages?.lastIndexOf(latestUserMessage) ?? -1)
+                : -1;
+            const messagesForHistory = latestUserMessage &&
+                typeof latestUserMessage.id === "string" &&
+                latestUserMessage.id.trim().length > 0 &&
+                latestUserMessageIndex >= 0
+                ? turn.messages.filter((message, index) => message.role !== "user" ||
+                    message.id !== latestUserMessage.id ||
+                    !equivalentRuntimeContent(message.content, latestUserMessage.content) ||
+                    index === latestUserMessageIndex)
+                : turn.messages;
             const prompt = turn.prompt ??
                 latestUserMessage?.content
                     .map((part) => (part.type === "text" ? part.text : ""))
@@ -2884,12 +2943,12 @@ export function createAgentNativeChatRuntime(options = {}) {
                 ? turnEngine
                 : options.engine;
             const currentAttachmentUrlSet = currentTurnAttachmentUrls(turn.attachments);
-            const history = nativeHistoryFromMessages(turn.messages, prompt, currentAttachmentUrlSet);
+            const history = nativeHistoryFromMessages(messagesForHistory, prompt, currentAttachmentUrlSet);
             const loadedSkillSlugs = loadedSkillSlugsFromMessages(turn.messages);
             const pendingApprovalHistory = approvedToolCalls && continuationMessageState
                 ? pendingApprovalRuntimeMessages(continuationMessageState)
                 : { messages: [], omitted: false, toolHistoryOmitted: false };
-            const structuredHistory = nativeStructuredHistoryFromMessages(turn.messages, prompt, currentAttachmentUrlSet, pendingApprovalHistory.messages, pendingApprovalHistory.omitted, pendingApprovalHistory.toolHistoryOmitted);
+            const structuredHistory = nativeStructuredHistoryFromMessages(messagesForHistory, prompt, currentAttachmentUrlSet, pendingApprovalHistory.messages, pendingApprovalHistory.omitted, pendingApprovalHistory.toolHistoryOmitted);
             return {
                 message: prompt,
                 ...(latestUserMessage?.id

package/dist/client/onboarding/first-run-status.js

@@ -55,10 +55,6 @@ async function requestFirstRunOnboardingStatus() {
         dispatchFirstRunOnboardingStatus(firstRun);
         return firstRun;
     }
-    catch (error) {
-        dispatchFirstRunOnboardingStatus(false);
-        throw error;
-    }
     finally {
         if (timeoutId !== undefined)
             clearTimeout(timeoutId);

package/dist/collab/routes.d.ts

@@ -13,8 +13,8 @@ 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;
     ok: boolean;

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

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

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;
-    error?: undefined;
     configured?: undefined;
+    error?: undefined;
 } | {
     url?: undefined;
     id?: undefined;

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

@@ -0,0 +1,13 @@
+export declare function connectionApp(origin: string, appId?: string): string;
+/**
+ * The connect CLI sends the clients it sets up as comma-joined client ids.
+ * Any other device client value, such as "Example, Inc.", is one name.
+ */
+export declare function deviceFlowClients(client: string | null): string | string[] | null;
+export declare function trackAgentConnected(input: {
+    email: string;
+    origin: string;
+    appId?: string;
+    client: string | readonly string[] | null;
+    method: "mcp" | "oauth";
+}): Promise<"emitted" | "duplicate" | "disabled" | "failed">;

package/dist/mcp/agent-connected.js

@@ -0,0 +1,63 @@
+import { createHash, randomUUID } from "node:crypto";
+import { CLIENTS } from "../cli/mcp-config-writers.js";
+import { mutateSetting } from "../settings/store.js";
+import { normalizeTrackingDimension } from "../shared/analytics-events.js";
+import { resolveMcpConnectHostId } from "../shared/mcp-connect-content.js";
+import { isTrackingSuppressed, listTrackingProviders, track, } from "../tracking/registry.js";
+import { detectVendorClient } from "./analytics.js";
+import { connectAppLabel, connectEnvironment } from "./connect-app-label.js";
+export function connectionApp(origin, appId) {
+    return normalizeTrackingDimension(connectAppLabel(origin, { appId }, connectEnvironment()));
+}
+/**
+ * The connect CLI sends the clients it sets up as comma-joined client ids.
+ * Any other device client value, such as "Example, Inc.", is one name.
+ */
+export function deviceFlowClients(client) {
+    const ids = client?.split(",");
+    return ids?.every((id) => CLIENTS.includes(id)) ? ids : client;
+}
+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.
+    try {
+        if (listTrackingProviders().length === 0 ||
+            isTrackingSuppressed(input.email))
+            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")));
+        let emitted = false;
+        for (const client of clients) {
+            const email = input.email.trim().toLowerCase();
+            const key = createHash("sha256")
+                .update(JSON.stringify([email, app, client]))
+                .digest("hex");
+            const claimId = randomUUID();
+            // Both success paths share a durable CAS claim; process-local state
+            // cannot suppress reconnects across serverless invocations.
+            const claim = await mutateSetting(`agent-connected:${key}`, (current) => {
+                if (current && typeof current.claim_id !== "string") {
+                    throw new Error("Invalid agent connection claim");
+                }
+                return current ?? { claim_id: claimId };
+            });
+            if (claim.claim_id !== claimId)
+                continue;
+            track("agent_connected", {
+                email,
+                app,
+                client,
+                connection_method: input.method,
+            }, { userId: email });
+            emitted = true;
+        }
+        return emitted ? "emitted" : "duplicate";
+    }
+    catch (error) {
+        console.error("[agent-connected] Failed to record connection:", error);
+        return "failed";
+    }
+}

package/dist/mcp/connect-app-label.d.ts

@@ -0,0 +1,11 @@
+import type { McpConnectEnvironment } from "../shared/mcp-connect-content.js";
+export declare function connectEnvironment(): McpConnectEnvironment;
+/**
+ * The app a connection belongs to. The connect identity names its MCP server
+ * from this and the `agent_connected` event reports it, so the two cannot
+ * disagree about which app a client connected to.
+ */
+export declare function connectAppLabel(origin: string, options: {
+    appId?: string;
+    appName?: string;
+}, environment: McpConnectEnvironment): string;

package/dist/mcp/connect-app-label.js

@@ -0,0 +1,33 @@
+import { getAppConfig } from "../app-config/index.js";
+import { isAgentNativeDeploymentEnvironment } from "../config.js";
+import { resolveDeployEnvironment } from "../server/deploy-environment.js";
+export function connectEnvironment() {
+    const environment = resolveDeployEnvironment();
+    if (!isAgentNativeDeploymentEnvironment(environment)) {
+        throw new Error(`Unknown deployment environment "${environment}"`);
+    }
+    return environment;
+}
+/**
+ * The app a connection belongs to. The connect identity names its MCP server
+ * from this and the `agent_connected` event reports it, so the two cannot
+ * disagree about which app a client connected to.
+ */
+export function connectAppLabel(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 host = new URL(origin).hostname;
+        const h = environment === "beta" ? host.replace(/^beta\./, "") : host;
+        return h.split(".")[0] || h;
+    }
+    catch {
+        return options.appName || "app";
+    }
+}

package/dist/mcp/connect-route.js

@@ -1,7 +1,5 @@
 import { randomUUID } from "node:crypto";
 import { getMethod, getHeader } from "h3";
-import { getAppConfig } from "../app-config/index.js";
-import { isAgentNativeDeploymentEnvironment } from "../config.js";
 import { mcpSettingsMessagesForLocale } from "../localization/mcp-settings-messages.js";
 import { resolveLocaleFromRequest } from "../localization/server.js";
 import { localeDirection, normalizeLocaleCode, } from "../localization/shared.js";
@@ -10,11 +8,12 @@ import { getConfiguredAppBasePath } from "../server/app-base-path.js";
 import { getSession, getConfiguredLoginHtml, isLoopbackRequest, } from "../server/auth.js";
 import { CREDENTIAL_MEMBERSHIP_UNAVAILABLE_MESSAGE } from "../server/credential-membership-unavailable.js";
 import { readDeployCredentialEnv } from "../server/credential-provider.js";
-import { resolveDeployEnvironment } from "../server/deploy-environment.js";
 import { publicFrameworkPath } from "../server/framework-route-prefix.js";
 import { readBody } from "../server/h3-helpers.js";
 import { FRAMEWORK_INTERNAL_ROUTE_PREFIX } from "../shared/framework-route-prefix.js";
 import { buildMcpInstallLink, derivedMcpServerBaseName, getMcpConnectGuides, getMcpStaticTokenFallback, interpolateMcpConnectTemplate, mcpConnectServerName, resolveMcpConnectGuideId, } from "../shared/mcp-connect-content.js";
+import { deviceFlowClients, trackAgentConnected } from "./agent-connected.js";
+import { connectAppLabel, connectEnvironment } from "./connect-app-label.js";
 import { ensureConnectTables, recordMintedToken, listTokens, revokeToken, normalizeServiceName, serviceIdentityEmail, createDeviceCode, getDeviceCode, getDeviceCodeByUserCode, approveDeviceCode, consumeDeviceCode, claimDeviceCodeForMint, finishDeviceCodeMint, expireDeviceCode, MCP_CONNECT_OAUTH_CLIENT_ID, DEFAULT_TOKEN_TTL_DAYS, MIN_TOKEN_TTL_DAYS, MAX_TOKEN_TTL_DAYS, MAX_SERVICE_TOKEN_TTL_DAYS, DEVICE_CODE_TTL_MS, } from "./connect-store.js";
 import { McpCredentialIssuanceError, withMcpCredentialIssuance, } from "./credential-issuance.js";
 import { getMcpOAuthIssuer, resolveMcpOAuthIssuer } from "./oauth-route.js";
@@ -78,31 +77,6 @@ function joinAppPath(basePath, path) {
         return basePath;
     return `${basePath}${path.startsWith("/") ? path : `/${path}`}`;
 }
-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 host = new URL(origin).hostname;
-        const h = environment === "beta" ? host.replace(/^beta\./, "") : host;
-        return h.split(".")[0] || h;
-    }
-    catch {
-        return options.appName || "app";
-    }
-}
-function connectEnvironment() {
-    const environment = resolveDeployEnvironment();
-    if (!isAgentNativeDeploymentEnvironment(environment)) {
-        throw new Error(`Unknown deployment environment "${environment}"`);
-    }
-    return environment;
-}
 /**
  * The one name and URL every connect surface hands to an MCP client: this
  * page, the device-flow payload, the settings tab, share dialogs (through the
@@ -111,10 +85,10 @@ function connectEnvironment() {
 export function resolveMcpConnectIdentity(appUrl, options) {
     const environment = connectEnvironment();
     const baseName = options.serverName?.trim() ||
-        derivedMcpServerBaseName(appLabel(appUrl, options, environment), environment);
+        derivedMcpServerBaseName(connectAppLabel(appUrl, options, environment), environment);
     return {
         serverName: mcpConnectServerName(baseName, environment),
-        appName: options.appName || appLabel(appUrl, options, environment),
+        appName: options.appName || connectAppLabel(appUrl, options, environment),
         appUrl,
         mcpUrl: mcpResourceUrl(appUrl),
         environment,
@@ -1217,7 +1191,8 @@ function renderConnectPage(params) {
         var ttlEl = document.getElementById("ttl");
         var label = labelEl ? labelEl.value || undefined : undefined;
         var ttlDays = ttlEl ? parseInt(ttlEl.value, 10) || undefined : undefined;
-        var m = await postJson("/token", { label: label, ttlDays: ttlDays });
+        var activeGuide = document.querySelector('[data-tab].is-active');
+        var m = await postJson("/token", { label: label, ttlDays: ttlDays, client: activeGuide ? activeGuide.getAttribute("data-tab") : undefined });
         if (!m.ok) {
           resetButtonLoading(btn);
           showMsg(COPY.couldNotCreate);
@@ -1350,6 +1325,13 @@ export async function handleMcpConnect(event, subpath, options = {}) {
                 requestOrigin: origin,
                 ...(catalogScope ? { catalogScope } : {}),
             });
+            await trackAgentConnected({
+                email: session.email,
+                origin: issuer,
+                appId: options.appId,
+                client: typeof body.client === "string" ? body.client : null,
+                method: "mcp",
+            });
             return json(mcpResultPayload(identity, { token }));
         }
         catch (err) {
@@ -1378,7 +1360,21 @@ export async function handleMcpConnect(event, subpath, options = {}) {
                 typeof body.fullCatalog !== "boolean") {
                 return json({ error: "fullCatalog must be a boolean." }, 400);
             }
-            const row = await createDeviceCode(body.fullCatalog === true ? "full" : null);
+            if (body.client !== undefined &&
+                (typeof body.client !== "string" || body.client.length > 500)) {
+                return json({ error: "Invalid request body." }, 400);
+            }
+            if (body.purpose !== undefined &&
+                body.purpose !== "agent" &&
+                body.purpose !== "credential") {
+                return json({ error: "Invalid request body." }, 400);
+            }
+            const row = await createDeviceCode(body.fullCatalog === true ? "full" : null, {
+                ...(typeof body.client === "string" ? { client: body.client } : {}),
+                ...(body.purpose === "agent" || body.purpose === "credential"
+                    ? { purpose: body.purpose }
+                    : {}),
+            });
             const verificationUri = `${issuer}${MCP_PUBLIC_ROUTE_PREFIX}/connect`;
             return json({
                 device_code: row.deviceCode,
@@ -1468,7 +1464,8 @@ export async function handleMcpConnect(event, subpath, options = {}) {
                 canUseDevOpenConnect(event);
             const orgDomain = await resolveOrgDomain(row.orgId ?? undefined);
             await prepareConnectIssuance();
-            return await withMcpCredentialIssuance({
+            let connected = false;
+            const response = await withMcpCredentialIssuance({
                 email: row.ownerEmail,
                 orgId: row.orgId,
                 requestOrigin: origin,
@@ -1519,11 +1516,22 @@ export async function handleMcpConnect(event, subpath, options = {}) {
                 if (!(await finishDeviceCodeMint(deviceCode, jti, tx))) {
                     throw new McpCredentialIssuanceError("unavailable");
                 }
+                connected = true;
                 return json({
                     status: "approved",
                     ...mcpResultPayload(identity, { token }),
                 });
             });
+            if (connected && row.purpose !== "credential") {
+                await trackAgentConnected({
+                    email: row.ownerEmail,
+                    origin: issuer,
+                    appId: options.appId,
+                    client: deviceFlowClients(row.client ?? null),
+                    method: "mcp",
+                });
+            }
+            return response;
         }
         catch (err) {
             if (err instanceof McpCredentialIssuanceError)

package/dist/mcp/connect-store.d.ts

@@ -109,11 +109,16 @@ export interface DeviceCodeRow {
     status: "pending" | "approved" | "minting" | "consumed" | "expired";
     tokenJti: string | null;
     catalogScope: "full" | null;
+    client?: string | null;
+    purpose?: "agent" | "credential" | null;
     createdAt: number | null;
     expiresAt: number | null;
     consumedAt: number | null;
 }
-export declare function createDeviceCode(catalogScope?: "full" | null): Promise<DeviceCodeRow>;
+export declare function createDeviceCode(catalogScope?: "full" | null, connection?: {
+    client?: string;
+    purpose?: "agent" | "credential";
+}): Promise<DeviceCodeRow>;
 export declare function getDeviceCode(deviceCode: string, exec?: DbExec): Promise<DeviceCodeRow | null>;
 export declare function getDeviceCodeByUserCode(userCode: string, exec?: DbExec): Promise<DeviceCodeRow | null>;
 export declare function approveDeviceCode(userCode: string, ownerEmail: string, orgId: string | null, exec?: DbExec): Promise<DeviceCodeRow | "not_found" | "expired" | "already">;