@agent-native/core 0.227.0 → 0.228.0-nightly-20261111004142

package/dist/localization/default-messages.js

@@ -136,6 +136,41 @@ const messages = {
         mcpClientSetup: "Connect an AI host",
         mcpClientSetupDescription: "Choose a host for step-by-step setup, or paste the URL into any MCP-compatible client.",
         mcpChooseAssistant: "Choose your AI assistant",
+        mcpCopyAndOpen: "Copy URL and open {{host}}",
+        mcpManualSetup: "Manual setup",
+        mcpTryPrompt: "Try it in {{host}}",
+        mcpHelpConnecting: "Need help connecting?",
+        mcpLocalAddressHint: "Local address: {{host}} needs a publicly reachable HTTPS server URL.",
+        mcpAuthentication: "Authentication",
+        mcpTestPrompt: "What tools are available from the {{app}} connector?",
+        mcpSetupIntro: "Use Claude, ChatGPT, or another AI app to read and update data in {{app}}.",
+        mcpStageOpen: "Open {{host}}",
+        mcpStageAdd: "Add a custom connector",
+        mcpStageDetails: "Enter connection details",
+        mcpStageAuthorize: "Authorize and test in {{host}}",
+        mcpStageEnable: "Enable and test in {{host}}",
+        mcpNameLabel: "Name",
+        mcpHostBenefit: "Use your Agent-Native tools directly in {{host}}.",
+        mcpManualBenefit: "Use your Agent-Native tools in any MCP-compatible app.",
+        mcpStageOpenSettings: "Open connector settings",
+        mcpReadyToTry: "Test the connection",
+        mcpTestUnavailable: "Available once connected.",
+        mcpCopyTestPrompt: "Copy prompt",
+        mcpConnectionDocs: "Setup guide",
+        mcpServerUrl: "Server URL",
+        mcpCopyUrl: "Copy URL",
+        mcpStageAddServer: "Add the MCP server",
+        mcpSetupSteps: "Setup",
+        mcpOpensNewTab: "Opens in a new tab",
+        mcpOpensDesktopApp: "Opens the desktop app",
+        mcpConnected: "Connected",
+        mcpNotConnected: "Not connected",
+        mcpConnectionUnavailable: "Status unavailable",
+        mcpStatusCheckFailed: "Couldn't check MCP connections.",
+        mcpLastUsedLabel: "Last used",
+        mcpLastUsed: "Last used {{time}}",
+        mcpNoActivity: "No activity recorded",
+        mcpLegacyStatusUnknown: "Older credentials do not include enough information to verify their current status.",
         mcpCommand: "Command",
         mcpConfig: "MCP config",
         mcpCopy: "Copy",

package/dist/localization/mcp-settings-messages.d.ts

@@ -69,6 +69,41 @@ export interface McpSettingsMessages {
     mcpClientSetup: string;
     mcpClientSetupDescription: string;
     mcpChooseAssistant: string;
+    mcpCopyAndOpen: string;
+    mcpManualSetup: string;
+    mcpTryPrompt: string;
+    mcpHelpConnecting: string;
+    mcpLocalAddressHint: string;
+    mcpAuthentication: string;
+    mcpTestPrompt: string;
+    mcpSetupIntro: string;
+    mcpStageOpen: string;
+    mcpStageAdd: string;
+    mcpStageDetails: string;
+    mcpStageAuthorize: string;
+    mcpStageEnable: string;
+    mcpNameLabel: string;
+    mcpHostBenefit: string;
+    mcpManualBenefit: string;
+    mcpStageOpenSettings: string;
+    mcpReadyToTry: string;
+    mcpTestUnavailable: string;
+    mcpCopyTestPrompt: string;
+    mcpConnectionDocs: string;
+    mcpServerUrl: string;
+    mcpCopyUrl: string;
+    mcpStageAddServer: string;
+    mcpSetupSteps: string;
+    mcpOpensNewTab: string;
+    mcpOpensDesktopApp: string;
+    mcpConnected: string;
+    mcpNotConnected: string;
+    mcpConnectionUnavailable: string;
+    mcpStatusCheckFailed: string;
+    mcpLastUsedLabel: string;
+    mcpLastUsed: string;
+    mcpNoActivity: string;
+    mcpLegacyStatusUnknown: string;
     mcpCommand: string;
     mcpConfig: string;
     mcpCopy: string;

package/dist/mcp/actions/list-mcp-client-connections.d.ts

@@ -0,0 +1,8 @@
+declare const _default: import("../../action.js").ActionDefinition<Record<string, never>, {
+    connections: {
+        client: "chatgpt" | "claude" | "claude-code" | "codex" | "cursor" | "grok" | "other" | "vscode";
+        status: "connected" | "disconnected" | "unknown";
+        lastUsedAt: number | null;
+    }[];
+}>;
+export default _default;

package/dist/mcp/actions/list-mcp-client-connections.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { defineAction, defineActionErrors } from "../../action.js";
+import { getRequestContext } from "../../server/request-context.js";
+import { mcpClientConnectionsSchema } from "../../shared/mcp-client-connections.js";
+import { listMcpClientConnections } from "../client-connections.js";
+import { resolveMcpOAuthIssuer } from "../oauth-route.js";
+const errors = defineActionErrors("unauthorized", "mcp_connections_unavailable");
+export default defineAction({
+    description: "List the current user's external MCP client authorizations for this app and active organization. Returns per-client connected, disconnected, or unknown status and the last server-recorded activity timestamp. Connected means authorization remains valid, not that the client is currently online. Never returns tokens. Unknown means older credentials lack enough metadata to verify their current validity.",
+    schema: z.object({}),
+    outputSchema: mcpClientConnectionsSchema,
+    errors,
+    requiresAuth: true,
+    readOnly: true,
+    parallelSafe: true,
+    persistInBrowser: false,
+    http: { method: "GET" },
+    run: async (_args, ctx) => {
+        const email = ctx?.userEmail?.trim().toLowerCase();
+        if (!email)
+            return errors.fail("Sign in to view MCP connections.", "unauthorized", {
+                statusCode: 401,
+            });
+        const issuer = resolveMcpOAuthIssuer(getRequestContext()?.requestOrigin);
+        if (!issuer)
+            return errors.fail("Unable to resolve this app's MCP resource.", "mcp_connections_unavailable", { statusCode: 503 });
+        try {
+            return await listMcpClientConnections({
+                email,
+                orgId: ctx?.orgId ?? null,
+                issuer,
+            });
+        }
+        catch (error) {
+            console.error("[mcp-connections] Status lookup failed", error);
+            return errors.fail("MCP connection status is unavailable. Try again.", "mcp_connections_unavailable", { statusCode: 503 });
+        }
+    },
+});

package/dist/mcp/browser-tab-target.d.ts

@@ -0,0 +1,16 @@
+import { type BrowserTabTarget, type BrowserTabTargetSlot } from "../server/request-context.js";
+/**
+ * An MCP tool call comes from no browser tab, so tab-scoped app state
+ * (navigation, navigate commands, selection) would otherwise fall back to
+ * account-wide rows no tab keeps current. This slot points the call at the
+ * tab of this app the user used last. The lookup runs only when the call
+ * first reads or writes tab-scoped state.
+ */
+export declare function createBrowserTabTargetSlot(): BrowserTabTargetSlot;
+/**
+ * Tells the calling agent which tab a call's tab-scoped reads and writes
+ * reached, since nothing in the call itself says so.
+ */
+export declare function browserTabTargetNote(target: BrowserTabTarget, now?: number): string;
+/** Adds the tab note to a successful tool result that used tab-scoped state. */
+export declare function withBrowserTabTargetNote<T>(result: T, slot: BrowserTabTargetSlot | undefined): T;

package/dist/mcp/browser-tab-target.js

@@ -0,0 +1,58 @@
+import { findLastUsedBrowserTab, LAST_USED_BROWSER_TAB_MAX_AGE_MS, } from "../application-state/last-used-tab.js";
+import { getRequestUserEmail, } from "../server/request-context.js";
+/**
+ * An MCP tool call comes from no browser tab, so tab-scoped app state
+ * (navigation, navigate commands, selection) would otherwise fall back to
+ * account-wide rows no tab keeps current. This slot points the call at the
+ * tab of this app the user used last. The lookup runs only when the call
+ * first reads or writes tab-scoped state.
+ */
+export function createBrowserTabTargetSlot() {
+    let pending;
+    const slot = {
+        resolve() {
+            pending ??= (async () => {
+                const userEmail = getRequestUserEmail();
+                const target = userEmail
+                    ? await findLastUsedBrowserTab(userEmail)
+                    : { kind: "unavailable" };
+                slot.resolved = target;
+                return target;
+            })();
+            return pending;
+        },
+    };
+    return slot;
+}
+function usedAgo(usedAt, now) {
+    const minutes = Math.floor(Math.max(0, now - usedAt) / 60_000);
+    if (minutes < 1)
+        return "less than a minute ago";
+    if (minutes < 60)
+        return `${minutes} min ago`;
+    return `${Math.floor(minutes / 60)} h ago`;
+}
+/**
+ * Tells the calling agent which tab a call's tab-scoped reads and writes
+ * reached, since nothing in the call itself says so.
+ */
+export function browserTabTargetNote(target, now = Date.now()) {
+    if (target.kind === "last-used") {
+        return `Browser tab: this call used the user's most recently used tab of this app (last used ${usedAgo(target.usedAt, now)}). A navigate command reaches that tab only while it stays open, and this result doesn't confirm that it moved.`;
+    }
+    const hours = Math.round(LAST_USED_BROWSER_TAB_MAX_AGE_MS / 3_600_000);
+    return `Browser tab: no tab of this app was used in the last ${hours} hours, so there was no on-screen state to read and a navigate command won't move any tab. Ask the user to open the app in a browser tab, then retry.`;
+}
+/** Adds the tab note to a successful tool result that used tab-scoped state. */
+export function withBrowserTabTargetNote(result, slot) {
+    const target = slot?.resolved;
+    if (!target || !result || typeof result !== "object")
+        return result;
+    const { content, isError } = result;
+    if (isError === true || !Array.isArray(content))
+        return result;
+    return {
+        ...result,
+        content: [...content, { type: "text", text: browserTabTargetNote(target) }],
+    };
+}

package/dist/mcp/build-server.d.ts

@@ -367,6 +367,7 @@ export type VerifyAuthResult = {
  */
 export declare function verifyAuth(authHeader: string | undefined, ownerEmailHeader?: string, options?: {
     allowDevOpen?: boolean;
+    allowLocalOwnerHint?: boolean;
     resourceUrl?: string | string[];
     event?: unknown;
     /** This app's public origin; federated orgs need it for the membership check. */

package/dist/mcp/build-server.js

@@ -24,6 +24,7 @@ import { mcpApprovalPrompt, mcpApprovalRelativeLinkNote, mcpApprovalReviewUrl, }
 import { mcpApprovalAppId } from "./approval-store.js";
 export { isAutoReadExcludedActionName } from "./action-eligibility.js";
 import { isMcpAppsInlineEnabled } from "./app-cards-lab.js";
+import { createBrowserTabTargetSlot, withBrowserTabTargetNote, } from "./browser-tab-target.js";
 import { getBuiltinCrossAppTools } from "./builtin-tools.js";
 import { MCP_CONNECT_OAUTH_CLIENT_ID, MCP_CONNECT_SCOPE, } from "./connect-store.js";
 import { createDirectActionCall } from "./direct-action-call.js";
@@ -2159,7 +2160,7 @@ export async function createMCPServerForRequest(config, identity, requestMeta) {
         callerAuthUserId ??= import("../server/better-auth-instance.js").then(({ findBetterAuthUserIdForEmail }) => findBetterAuthUserIdForEmail(email));
         return callerAuthUserId;
     }
-    async function withCallerContext(fn, mcpRequestId, authUserId) {
+    async function withCallerContext(fn, mcpRequestId, authUserId, run) {
         const orgId = await orgIdPromise;
         return runWithRequestContext({
             userEmail: effectiveIdentity?.userEmail,
@@ -2178,10 +2179,16 @@ export async function createMCPServerForRequest(config, identity, requestMeta) {
                 : {}),
             ...(mcpRequestId ? { mcpRequestId } : {}),
             mcpCredentialIssuedAtMs: effectiveIdentity?.mcpCredentialIssuedAtMs ?? null,
+            ...(run ? { run } : {}),
         }, fn);
     }
     async function withToolCallContext(fn, mcpRequestId) {
-        return withCallerContext(fn, mcpRequestId, await resolveCallerAuthUserId());
+        // Only a signed-in person has browser tabs for a call to act on.
+        const browserTabTarget = hasVerifiedMcpUserIdentity(effectiveIdentity)
+            ? createBrowserTabTargetSlot()
+            : undefined;
+        const result = await withCallerContext(fn, mcpRequestId, await resolveCallerAuthUserId(), browserTabTarget ? { browserTabTarget } : undefined);
+        return withBrowserTabTargetNote(result, browserTabTarget);
     }
     const actionCallContext = {
         appId: config.appId,
@@ -3063,6 +3070,7 @@ async function verifyIssuedMcpCredential(token, resourceUrl) {
             : {}),
         oauthScopes: oauth.scopes,
         oauthClientId: oauth.clientId,
+        oauthResource: oauth.resource,
         ...(oauth.catalogScope ? { catalogScope: oauth.catalogScope } : {}),
         ...(oauth.grantCreatedAtMs !== undefined
             ? { grantCreatedAtMs: oauth.grantCreatedAtMs }
@@ -3137,6 +3145,23 @@ async function admitIssuedMcpCredential(credential, requestOrigin) {
     if (admitted.authed && credential.connect) {
         await markConnectTokenUsed(credential.connect.jti);
     }
+    else if (admitted.authed &&
+        credential.oauthClientId &&
+        credential.oauthResource) {
+        try {
+            const { recordOAuthClientActivity } = await import("./oauth-store.js");
+            await recordOAuthClientActivity({
+                clientId: credential.oauthClientId,
+                email: credential.userEmail,
+                orgId: orgId ?? null,
+                resource: credential.oauthResource,
+            });
+        }
+        catch (error) {
+            // Activity metadata must not turn a successfully admitted request into an authentication failure.
+            console.warn("[mcp] Could not record client activity", error);
+        }
+    }
     return admitted;
 }
 /**
@@ -3241,6 +3266,9 @@ async function checkIssuedCredential(result, requestOrigin, storedConnectToken,
  */
 export async function verifyAuth(authHeader, ownerEmailHeader, options = {}) {
     const accessTokens = getAccessTokens();
+    const trustedOwnerHeader = options.allowLocalOwnerHint
+        ? ownerEmailHeader
+        : undefined;
     const hasA2ASecret = !!readDeployCredentialEnv("A2A_SECRET")?.trim();
     const token = getBearerToken(authHeader);
     const orgMemberDelegation = token
@@ -3250,7 +3278,7 @@ export async function verifyAuth(authHeader, ownerEmailHeader, options = {}) {
         if (!orgMemberDelegation) {
             const issued = await verifyIssuedMcpCredential(token, options.resourceUrl);
             if (issued === "unverified") {
-                return ((await matchStaticAccessToken(token, accessTokens, ownerEmailHeader)) ?? {
+                return ((await matchStaticAccessToken(token, accessTokens, trustedOwnerHeader)) ?? {
                     authed: false,
                     refusal: "invalid",
                 });
@@ -3265,8 +3293,8 @@ export async function verifyAuth(authHeader, ownerEmailHeader, options = {}) {
         }
         return {
             authed: true,
-            identity: deriveStaticTokenIdentity(ownerEmailHeader),
-            fullSurface: !!(ownerEmailHeader && ownerEmailHeader.trim()),
+            identity: deriveStaticTokenIdentity(trustedOwnerHeader),
+            fullSurface: !!(trustedOwnerHeader && trustedOwnerHeader.trim()),
         };
     }
     if (!token)
@@ -3332,7 +3360,7 @@ export async function verifyAuth(authHeader, ownerEmailHeader, options = {}) {
     }
     // A supplied bearer that failed JWT verification must not fall through to
     // dev-open auth or reuse a forwarded owner-email hint.
-    return ((await matchStaticAccessToken(token, accessTokens, ownerEmailHeader)) ?? {
+    return ((await matchStaticAccessToken(token, accessTokens, trustedOwnerHeader)) ?? {
         authed: false,
         refusal: "invalid",
     });
@@ -3357,9 +3385,12 @@ async function matchStaticAccessToken(token, accessTokens, ownerEmailHeader) {
     });
     if (!matched)
         return null;
+    const identity = deriveStaticTokenIdentity(ownerEmailHeader);
+    if (!identity)
+        return { authed: false, refusal: "invalid" };
     return {
         authed: true,
-        identity: deriveStaticTokenIdentity(ownerEmailHeader),
+        identity,
         fullSurface: true,
     };
 }

package/dist/mcp/call-attribution.d.ts

@@ -5,10 +5,13 @@ export interface McpCallAttributionInput {
     /** `ctx.mcpReq.envelope`: the reserved `_meta` keys the SDK lifted out. */
     envelope: unknown;
     oauthClientId: string | undefined;
+    /** The request's User-Agent header. */
+    userAgent?: string | undefined;
 }
 /**
  * The client facts the audit trail records for one MCP `tools/call`. Only
  * `oauthClientId` comes from a credential this server issued. The name and
- * version are whatever the client sent as `clientInfo`.
+ * version are whatever the client sent as `clientInfo`, and the User-Agent
+ * whatever it sent as that header.
  */
 export declare function mcpCallAttribution(input: McpCallAttributionInput): Pick<ActionRunContext, "mcpClient">;

package/dist/mcp/call-attribution.js

@@ -2,7 +2,8 @@ import { readClientInfoFromRequest } from "./analytics.js";
 /**
  * The client facts the audit trail records for one MCP `tools/call`. Only
  * `oauthClientId` comes from a credential this server issued. The name and
- * version are whatever the client sent as `clientInfo`.
+ * version are whatever the client sent as `clientInfo`, and the User-Agent
+ * whatever it sent as that header.
  */
 export function mcpCallAttribution(input) {
     // 2026-07-28 requests carry clientInfo in the envelope, which the SDK
@@ -18,6 +19,7 @@ export function mcpCallAttribution(input) {
     const mcpClient = {
         ...(info.clientName ? { name: info.clientName } : {}),
         ...(info.clientVersion ? { version: info.clientVersion } : {}),
+        ...(input.userAgent ? { userAgent: input.userAgent } : {}),
         ...(input.oauthClientId ? { oauthClientId: input.oauthClientId } : {}),
     };
     return Object.keys(mcpClient).length > 0 ? { mcpClient } : {};

package/dist/mcp/client-connections.d.ts

@@ -0,0 +1,6 @@
+import type { McpClientConnections } from "../shared/mcp-client-connections.js";
+export declare function listMcpClientConnections({ email, orgId, issuer, }: {
+    email: string;
+    orgId: string | null;
+    issuer: string;
+}): Promise<McpClientConnections>;

package/dist/mcp/client-connections.js

@@ -0,0 +1,91 @@
+import { z } from "zod";
+import { getDbExec } from "../db/client.js";
+import { MCP_CONNECT_GUIDES, resolveMcpConnectGuideId, } from "../shared/mcp-connect-content.js";
+import { ensureConnectTables } from "./connect-store.js";
+import { ensureOAuthTables } from "./oauth-store.js";
+import { MCP_DIRECTORY_ROUTE_PREFIX, MCP_LEGACY_ROUTE_PREFIX, MCP_PUBLIC_ROUTE_PREFIX, } from "./route-paths.js";
+const timestamp = z.coerce.number().int().nonnegative().safe().nullable();
+const oauthRow = z.object({
+    client_name: z.string().nullable(),
+    active: z.boolean(),
+    unknown: z.boolean(),
+    last_used_at: timestamp,
+});
+const tokenRow = z.object({
+    client_name: z.string().nullable(),
+    active: z.boolean(),
+    unknown: z.boolean(),
+    last_used_at: timestamp,
+});
+const MAX_CONNECTIONS = 200;
+export async function listMcpClientConnections({ email, orgId, issuer, }) {
+    await Promise.all([ensureConnectTables(), ensureOAuthTables()]);
+    const owner = email.trim().toLowerCase();
+    const now = Date.now();
+    const resources = [
+        MCP_PUBLIC_ROUTE_PREFIX,
+        MCP_LEGACY_ROUTE_PREFIX,
+        MCP_DIRECTORY_ROUTE_PREFIX,
+    ].map((path) => `${issuer.replace(/\/+$/, "")}${path}`);
+    const db = getDbExec();
+    const [oauth, tokens] = await Promise.all([
+        db.execute({
+            sql: `SELECT c.client_name,
+        BOOL_OR(r.revoked_at IS NULL AND (r.expires_at IS NULL OR r.expires_at > ?)
+          AND COALESCE(LOWER(r.issued_for_email) = ?, FALSE)) AS active,
+        BOOL_OR(r.revoked_at IS NULL AND (r.expires_at IS NULL OR r.expires_at > ?)
+          AND r.issued_for_email IS NULL) AS unknown,
+        MAX(r.last_used_at) AS last_used_at
+      FROM mcp_oauth_refresh_tokens r LEFT JOIN mcp_oauth_clients c ON c.client_id = r.client_id
+      WHERE LOWER(r.owner_email) = ? AND r.org_id IS NOT DISTINCT FROM ?
+        AND r.resource IN (?, ?, ?)
+      GROUP BY r.client_id, c.client_name
+      ORDER BY r.client_id LIMIT ?`,
+            args: [now, owner, now, owner, orgId, ...resources, MAX_CONNECTIONS + 1],
+        }),
+        db.execute({
+            sql: `SELECT client_name,
+        COALESCE(BOOL_OR(revoked_at IS NULL AND expires_at > ? AND resource IS NOT NULL), FALSE) AS active,
+        COALESCE(BOOL_OR(revoked_at IS NULL AND (expires_at IS NULL OR expires_at > ?)
+          AND (expires_at IS NULL OR resource IS NULL)), FALSE) AS unknown,
+        MAX(last_used_at) AS last_used_at
+      FROM mcp_connect_tokens
+      WHERE LOWER(owner_email) = ? AND org_id IS NOT DISTINCT FROM ? AND kind = 'personal'
+        AND (resource IN (?, ?, ?) OR resource IS NULL)
+      GROUP BY client_name ORDER BY client_name LIMIT ?`,
+            args: [now, now, owner, orgId, ...resources, MAX_CONNECTIONS + 1],
+        }),
+    ]);
+    if (oauth.rows.length > MAX_CONNECTIONS ||
+        tokens.rows.length > MAX_CONNECTIONS)
+        throw new Error("MCP connection metadata exceeds the supported result limit.");
+    const summaries = new Map(MCP_CONNECT_GUIDES.map((guide) => [
+        guide.id,
+        {
+            client: guide.id,
+            status: "disconnected",
+            lastUsedAt: null,
+        },
+    ]));
+    const add = (name, status, lastUsedAt) => {
+        const client = resolveMcpConnectGuideId(name || "other");
+        const summary = summaries.get(client);
+        if (!summary)
+            throw new Error("Unknown MCP client group.");
+        if (status === "connected" ||
+            (status === "unknown" && summary.status !== "connected"))
+            summary.status = status;
+        if (lastUsedAt !== null &&
+            (summary.lastUsedAt === null || lastUsedAt > summary.lastUsedAt))
+            summary.lastUsedAt = lastUsedAt;
+    };
+    for (const raw of oauth.rows) {
+        const row = oauthRow.parse(raw);
+        add(row.client_name, row.active ? "connected" : row.unknown ? "unknown" : "disconnected", row.last_used_at);
+    }
+    for (const raw of tokens.rows) {
+        const row = tokenRow.parse(raw);
+        add(row.client_name, row.active ? "connected" : row.unknown ? "unknown" : "disconnected", row.last_used_at);
+    }
+    return { connections: [...summaries.values()] };
+}

package/dist/mcp/connect-route.js

@@ -144,12 +144,13 @@ async function mintConnectToken(params) {
         requestOrigin: params.requestOrigin,
     }, async (tx) => {
         const jti = randomUUID();
+        const expiresAt = (Math.floor(Date.now() / 1000) + params.ttlDays * 86_400) * 1000;
         const token = await signConnectToken({
             ownerEmail: params.email,
             orgId: params.orgId,
             orgDomain,
             issuer: params.issuer,
-            expiresIn: `${params.ttlDays}d`,
+            expiresIn: expiresAt / 1000,
             jti,
             ...(params.catalogScope === "full" ? { catalogScope: "full" } : {}),
         });
@@ -158,6 +159,9 @@ async function mintConnectToken(params) {
             ownerEmail: params.email,
             orgId: params.orgId ?? null,
             label: params.label,
+            clientName: params.clientName,
+            resource: mcpResourceUrl(params.issuer),
+            expiresAt,
         }, tx);
         return { token, jti };
     });
@@ -1321,6 +1325,7 @@ export async function handleMcpConnect(event, subpath, options = {}) {
                 orgId: defaultOrganizationId,
                 label,
                 ttlDays,
+                clientName: typeof body.client === "string" ? body.client.slice(0, 120) : null,
                 issuer,
                 requestOrigin: origin,
                 ...(catalogScope ? { catalogScope } : {}),
@@ -1496,12 +1501,14 @@ export async function handleMcpConnect(event, subpath, options = {}) {
                         }),
                     });
                 }
+                const expiresAt = (Math.floor(Date.now() / 1000) + DEFAULT_TOKEN_TTL_DAYS * 86_400) *
+                    1000;
                 const token = await signConnectToken({
                     ownerEmail: claimed.ownerEmail,
                     orgId: claimed.orgId,
                     orgDomain,
                     issuer,
-                    expiresIn: `${DEFAULT_TOKEN_TTL_DAYS}d`,
+                    expiresIn: expiresAt / 1000,
                     jti,
                     ...(claimed.catalogScope
                         ? { catalogScope: claimed.catalogScope }
@@ -1512,6 +1519,9 @@ export async function handleMcpConnect(event, subpath, options = {}) {
                     ownerEmail: claimed.ownerEmail,
                     orgId: claimed.orgId,
                     label: "Device connection",
+                    clientName: claimed.client,
+                    resource: mcpResourceUrl(issuer),
+                    expiresAt,
                 }, tx);
                 if (!(await finishDeviceCodeMint(deviceCode, jti, tx))) {
                     throw new McpCredentialIssuanceError("unavailable");

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

@@ -54,6 +54,9 @@ export declare function recordMintedToken(params: {
     ownerEmail: string;
     orgId?: string | null;
     label?: string | null;
+    clientName?: string | null;
+    resource?: string | null;
+    expiresAt?: number | null;
     kind?: "personal" | "service";
     serviceName?: string | null;
     createdBy?: string | null;

package/dist/mcp/connect-store.js

@@ -74,6 +74,12 @@ export const mcpConnectStore = defineStore({
                 await ensureColumnExists("mcp_device_codes", "purpose", `ALTER TABLE mcp_device_codes ADD COLUMN IF NOT EXISTS purpose TEXT`);
             },
         },
+        {
+            name: "client-connection-metadata",
+            sql: `ALTER TABLE mcp_connect_tokens ADD COLUMN IF NOT EXISTS client_name TEXT,
+        ADD COLUMN IF NOT EXISTS resource TEXT,
+        ADD COLUMN IF NOT EXISTS expires_at BIGINT`,
+        },
     ],
 });
 export function ensureTable() {
@@ -111,7 +117,7 @@ export async function recordMintedToken(params, exec) {
     const client = exec ?? getDbExec();
     const id = randomUUID();
     const result = await client.execute({
-        sql: `INSERT INTO mcp_connect_tokens (id, jti, owner_email, org_id, label, kind, service_name, created_by, created_at, last_used_at, revoked_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        sql: `INSERT INTO mcp_connect_tokens (id, jti, owner_email, org_id, label, kind, service_name, created_by, created_at, last_used_at, revoked_at, client_name, resource, expires_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
         args: [
             id,
             params.jti,
@@ -124,6 +130,9 @@ export async function recordMintedToken(params, exec) {
             Date.now(),
             null,
             null,
+            params.clientName ?? null,
+            params.resource ?? null,
+            params.expiresAt ?? null,
         ],
     });
     if (result.rowsAffected !== 1) {

package/dist/mcp/direct-action-call.js

@@ -122,6 +122,7 @@ export function createDirectActionCall(scope) {
                 request,
                 envelope: ctx.mcpReq.envelope,
                 oauthClientId: effectiveIdentity?.oauthClientId,
+                userAgent: requestMeta?.clientName,
             }),
             approval: {
                 state: () => ctx.mcpReq.requestState() ?? undefined,

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

@@ -118,3 +118,9 @@ export declare function touchOAuthRefreshToken(refreshToken: string, expectedOwn
  * Idempotent: an already-revoked token keeps its first timestamp.
  */
 export declare function revokeOAuthRefreshToken(refreshToken: string, expectedOwnerEmail?: string): Promise<void>;
+export declare function recordOAuthClientActivity(params: {
+    clientId: string;
+    email: string;
+    orgId: string | null;
+    resource: string;
+}): Promise<void>;

package/dist/mcp/oauth-store.js

@@ -115,6 +115,10 @@ export const mcpOauthStore = defineStore({
                 await ensureColumnExists("mcp_oauth_refresh_tokens", "issued_for_email", `ALTER TABLE mcp_oauth_refresh_tokens ADD COLUMN IF NOT EXISTS issued_for_email TEXT`);
             },
         },
+        {
+            name: "client-activity-lookup-index",
+            sql: `CREATE INDEX IF NOT EXISTS mcp_oauth_refresh_activity_idx ON mcp_oauth_refresh_tokens (client_id, LOWER(owner_email), LOWER(issued_for_email), org_id, resource) WHERE revoked_at IS NULL`,
+        },
     ],
 });
 export function ensureTable() {
@@ -571,3 +575,22 @@ export async function revokeOAuthRefreshToken(refreshToken, expectedOwnerEmail)
     if (result.rowsAffected !== 0 && result.rowsAffected !== 1)
         throw new Error("Refresh-token revocation returned an invalid row count");
 }
+export async function recordOAuthClientActivity(params) {
+    await ensureTable();
+    const now = Date.now();
+    await getDbExec().execute({
+        sql: `UPDATE mcp_oauth_refresh_tokens SET last_used_at = ?
+    WHERE client_id = ? AND LOWER(owner_email) = ? AND LOWER(issued_for_email) = ?
+      AND org_id IS NOT DISTINCT FROM ? AND resource = ?
+      AND revoked_at IS NULL AND (expires_at IS NULL OR expires_at > ?)`,
+        args: [
+            now,
+            params.clientId,
+            params.email.toLowerCase(),
+            params.email.toLowerCase(),
+            params.orgId,
+            params.resource,
+            now,
+        ],
+    });
+}

package/dist/mcp/oauth-token.d.ts

@@ -47,6 +47,7 @@ export declare function signMcpOAuthAccessToken(params: {
 }): Promise<string>;
 export declare function verifyMcpOAuthAccessToken(token: string, resource: string | string[] | undefined): Promise<{
     userEmail: string;
+    resource: string;
     orgId?: string | null;
     orgDomain?: string;
     scopes: string[];

package/dist/mcp/oauth-token.js

@@ -173,6 +173,7 @@ export async function verifyMcpOAuthAccessToken(token, resource) {
         }
         return {
             userEmail: payload.sub,
+            resource: embeddedResource,
             orgId: orgIdClaim.orgId,
             orgDomain: typeof payload.org_domain === "string" ? payload.org_domain : undefined,
             scopes,