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

package/dist/cli/connect.d.ts

@@ -57,6 +57,7 @@ export interface ConnectDeps {
 }
 export declare function runDeviceFlow(baseUrl: string, appSlug: string, clientArg: string, deps?: ConnectDeps, options?: {
     fullCatalog?: boolean;
+    purpose?: "agent" | "credential";
 }): Promise<{
     token?: string;
     mcpUrl: string;

package/dist/cli/connect.js

@@ -329,7 +329,7 @@ async function resolveHostedAppsFromPrompt(deps) {
     return apps.filter((app) => selected.has(app.name));
 }
 function clientArgForDeviceFlow(clients) {
-    return clients.length === 1 ? clients[0] : "all";
+    return clients.join(",");
 }
 export function supportsRemoteMcpOAuth(client) {
     return REMOTE_MCP_OAUTH_CLIENTS.has(client);
@@ -616,6 +616,7 @@ export async function runDeviceFlow(baseUrl, appSlug, clientArg, deps = {}, opti
                 client: clientArg,
                 app: appSlug,
                 ...(options.fullCatalog ? { fullCatalog: true } : {}),
+                ...(options.purpose ? { purpose: options.purpose } : {}),
             });
             if (status >= 200 && status < 300 && json?.device_code) {
                 start = json;
@@ -1637,7 +1638,9 @@ async function connectOne(rawUrl, parsed, clients, deps) {
         try {
             logOut("");
             logOut(`  Minting a publish token for the local Plans server (device flow)…`);
-            const grant = await runDeviceFlow(baseUrl, appSlug, "codex", deps);
+            const grant = await runDeviceFlow(baseUrl, appSlug, "codex", deps, {
+                purpose: "credential",
+            });
             if (grant?.token) {
                 publishToken = grant.token;
             }
@@ -1781,7 +1784,9 @@ export async function runServiceTokenMint(parsed, deps = {}) {
     logOut("");
     logOut(`  Creating org service token "${serviceName}" on ${baseUrl}`);
     logOut("  First, verify it's you (the token will belong to your org)…");
-    const grant = await runDeviceFlow(baseUrl, appSlug, "codex", deps);
+    const grant = await runDeviceFlow(baseUrl, appSlug, "codex", deps, {
+        purpose: "credential",
+    });
     if (!grant?.token) {
         logErr("  Could not authenticate (the server returned no bearer token).");
         logErr("  Org service tokens require a deployed app with auth configured.");

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

@@ -1,6 +1,6 @@
 import { AgentKitRunSlotBusyError } from "@agent-native/agentkit/client";
-import { isAgentKitProtocolVersion, parseAgentQueuedMessage, parseAgentRunOptions, parseAgentThreadSnapshot, persistableFilePart, } from "@agent-native/agentkit/protocol";
-import { projectRootAssistantMessages } from "../../agent/thread-message-projection.js";
+import { agentEventSequenceEnd, isAgentKitProtocolVersion, parseAgentQueuedMessage, parseAgentRunOptions, parseAgentThreadSnapshot, persistableFilePart, } from "@agent-native/agentkit/protocol";
+import { failedRunIdsWithError, isRenderedRunNotStartedNotice, 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";
 import { agentEngineStatusUrlForChatApi, requireAgentEngineConfiguredForDispatch, } from "../agent-engine-readiness.js";
@@ -278,18 +278,6 @@ function storedMessages(value, now, fallbackTextFormat) {
         ];
     });
 }
-/**
- * The server answers a turn it refused before any run started with a durable
- * notice and a failed run. The run renders as the recovery card, so showing the
- * notice too would print the same failure twice.
- */
-function isRenderedRunNotStartedNotice(message, failedRunIds) {
-    const metadata = asRecord(message.metadata);
-    return (message.role === "assistant" &&
-        asRecord(metadata?.custom)?.[RUN_NOT_STARTED_METADATA_KEY] === true &&
-        typeof metadata?.runId === "string" &&
-        failedRunIds.has(metadata.runId));
-}
 function sameUserPrompt(left, right) {
     if (left.role !== "user" ||
         right.role !== "user" ||
@@ -667,8 +655,15 @@ function reconcileDurableMessages(messages, durable, events, runs, toolCalls) {
     });
     const representedDurableAssistantIds = rootAssistantProjection.representedRootMessageIds;
     const snapshotRunIdsByMessageId = rootAssistantProjection.snapshotRunIdsByMessageId;
+    const supersededSnapshotMessageIds = rootAssistantProjection.supersededSnapshotMessageIds;
     const rootMessageIdsBySnapshotMessageId = new Map([...rootAssistantProjection.snapshotMessageIdsByRootMessageId].map(([rootId, snapshotId]) => [snapshotId, rootId]));
-    const deduplicatedMessages = messages.filter((message) => !representedDurableAssistantIds.has(message.id) &&
+    const snapshotUserIds = new Set(messages.flatMap((message) => message.role === "user" ? [message.id] : []));
+    const representedDurableUserIds = new Set([...submittedUsersByAgentKitMessageId].flatMap(([snapshotId, stored]) => stored && snapshotId !== stored.id && snapshotUserIds.has(snapshotId)
+        ? [stored.id]
+        : []));
+    const deduplicatedMessages = messages.filter((message) => !(message.role === "user" && representedDurableUserIds.has(message.id)) &&
+        !representedDurableAssistantIds.has(message.id) &&
+        !supersededSnapshotMessageIds.has(message.id) &&
         !supersededCompletedAssistantIds.has(message.id));
     const representedSubmittedUserIds = new Set();
     const storedUserBySnapshotId = new Map();
@@ -830,6 +825,13 @@ function reconcileDurableMessages(messages, durable, events, runs, toolCalls) {
             }
         }
         const runId = snapshotRunId(message);
+        const sameRunRoot = runId ? durableByRun.get(runId) : undefined;
+        if (sameRunRoot &&
+            rootAssistantProjection.snapshotMessageIdsByRootMessageId.has(sameRunRoot.id) &&
+            rootAssistantProjection.snapshotMessageIdsByRootMessageId.get(sameRunRoot.id) !== message.id &&
+            !durableById.has(message.id)) {
+            return message;
+        }
         const matched = durableById.get(message.id) ??
             (runId ? durableByRun.get(runId) : undefined);
         // An earlier run of a folded reply is completed with the continuation text
@@ -1135,77 +1137,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) => ({
@@ -1807,14 +1894,7 @@ export function createAgentNativeAgentKitTransport(options = {}) {
         const updatedAt = timestamp(stored.updatedAt, createdAt);
         const repository = storedRepository(stored);
         const agentKit = asRecord(repository.agentKit);
-        const failedRunIds = new Set((Array.isArray(agentKit?.runs) ? agentKit.runs : []).flatMap((value) => {
-            const run = asRecord(value);
-            return run?.status === "failed" &&
-                asRecord(run.error) &&
-                typeof run.id === "string"
-                ? [run.id]
-                : [];
-        }));
+        const failedRunIds = failedRunIdsWithError(agentKit?.runs);
         const storedMessageProjection = storedMessages(repository.messages, now, options.adapter?.textFormat).filter((message) => !isRenderedRunNotStartedNotice(message, failedRunIds));
         const queuedMessages = storedQueue(repository.queuedMessages, threadId, updatedAt);
         const agentKitMessages = Array.isArray(agentKit?.messages)
@@ -2184,7 +2264,7 @@ export function createAgentNativeAgentKitTransport(options = {}) {
                     .filter((run) => ["awaiting_approval", "awaiting_input"].includes(run.status))
                     .map((run) => run.id)
                 : [];
-        const failedRunIds = new Set(runs.flatMap((run) => run.status === "failed" && run.error ? [run.id] : []));
+        const failedRunIds = failedRunIdsWithError(runs);
         const messages = reconcileDurableMessages(thread.messages, durableMessages.filter((message) => !isRenderedRunNotStartedNotice(message, failedRunIds)), thread.events, runs, thread.toolCalls);
         const replayFromStart = [
             "running",
@@ -2339,17 +2419,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/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/jobs/actions/manage-recurring-job.d.ts

@@ -11,9 +11,9 @@ declare const _default: import("../../action.js").ActionDefinition<{
     enabled?: undefined;
     nextRun?: undefined;
 } | {
-    deleted?: undefined;
     name: string;
     enabled: boolean;
     nextRun: string;
+    deleted?: undefined;
 }>;
 export default _default;

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";
+    }
+}