@agent-native/core 0.209.1 → 0.209.2-nightly-20261015213030

package/dist/agent/actions/list-model-providers.js

@@ -6,6 +6,7 @@ import { secretKeyNames } from "../../secrets/key-aliases.js";
 import { readAppSecrets, } from "../../secrets/storage.js";
 import { readProviderCredentialRejections } from "../../server/credential-provider.js";
 import { isPersonalProviderKeyUseRestricted, readOrgMemberRole, } from "../../server/personal-provider-key-policy.js";
+import { getRequestContext } from "../../server/request-context.js";
 import { readDefaultAgentEngineSettingDetailed, resolveDefaultAgentEngineAuthority, } from "../default-agent-engine.js";
 import { registerBuiltinEngines } from "../engine/builtin.js";
 import { getAgentEngineEntry, isDeploymentEngineUsableForRequest, } from "../engine/registry.js";
@@ -130,8 +131,20 @@ export default defineAction({
             orgId
                 ? isPersonalProviderKeyUseRestricted({ email, orgId, role })
                 : Promise.resolve(false),
-            readDefaultAgentEngineSettingDetailed({ userEmail: email, orgId }),
-            resolveDefaultAgentEngineAuthority({ userEmail: email, orgId }),
+            readDefaultAgentEngineSettingDetailed({
+                userEmail: email,
+                orgId,
+                ...(getRequestContext()?.orgScope === "personal"
+                    ? { orgScope: "personal" }
+                    : {}),
+            }),
+            resolveDefaultAgentEngineAuthority({
+                userEmail: email,
+                orgId,
+                ...(getRequestContext()?.orgScope === "personal"
+                    ? { orgScope: "personal" }
+                    : {}),
+            }),
             Promise.all(AGENT_PROVIDER_CATALOG.map(async (option) => {
                 const engine = getAgentEngineEntry(option.engine);
                 return [

package/dist/agent/app-model-defaults.d.ts

@@ -7,6 +7,11 @@ export interface AgentAppModelDefaultSelection {
     updatedAt?: number;
     updatedBy?: string;
 }
+export interface AgentAppModelDefaultContext {
+    userEmail?: string | null;
+    orgId?: string | null;
+    orgScope?: "personal";
+}
 export interface AgentAppModelDefaultSettings {
     appId: string;
     engine: string | null;
@@ -16,21 +21,12 @@ export interface AgentAppModelDefaultSettings {
 }
 export declare function normalizeAgentAppModelDefaultAppId(appId: string | null | undefined): string | null;
 export declare function agentAppModelDefaultSettingsKey(appId: string): string;
-export declare function readAgentAppModelDefaultSettings(ctx: {
-    userEmail?: string | null;
-    orgId?: string | null;
-}, appIdInput: string | null | undefined): Promise<AgentAppModelDefaultSettings>;
-export declare function writeAgentAppModelDefaultSettings(ctx: {
-    userEmail?: string | null;
-    orgId?: string | null;
-}, appIdInput: string | null | undefined, selection: {
+export declare function readAgentAppModelDefaultSettings(ctx: AgentAppModelDefaultContext, appIdInput: string | null | undefined): Promise<AgentAppModelDefaultSettings>;
+export declare function writeAgentAppModelDefaultSettings(ctx: AgentAppModelDefaultContext, appIdInput: string | null | undefined, selection: {
     engine: string;
     model: string;
     updatedBy?: string | null;
 }): Promise<AgentAppModelDefaultSettings>;
-export declare function resetAgentAppModelDefaultSettings(ctx: {
-    userEmail?: string | null;
-    orgId?: string | null;
-}, appIdInput: string | null | undefined): Promise<AgentAppModelDefaultSettings>;
-export declare function canUpdateAgentAppModelDefaultSettings(userEmail: string | null | undefined, orgId: string | null | undefined): Promise<boolean>;
+export declare function resetAgentAppModelDefaultSettings(ctx: AgentAppModelDefaultContext, appIdInput: string | null | undefined): Promise<AgentAppModelDefaultSettings>;
+export declare function canUpdateAgentAppModelDefaultSettings(userEmail: string | null | undefined, orgId: string | null | undefined, orgScope?: "personal"): Promise<boolean>;
 export declare function getAgentAppModelDefaultForCurrentRequest(appIdInput: string | null | undefined): Promise<AgentAppModelDefaultSelection | null>;

package/dist/agent/app-model-defaults.js

@@ -1,5 +1,5 @@
 import { getDbExec } from "../db/client.js";
-import { getRequestOrgId, getRequestUserEmail, } from "../server/request-context.js";
+import { getRequestContext, getRequestOrgId, getRequestUserEmail, } from "../server/request-context.js";
 import { deleteOrgSetting, deleteUserSetting, getOrgSetting, getUserSetting, putOrgSetting, putUserSetting, } from "../settings/index.js";
 export const AGENT_APP_MODEL_DEFAULT_KEY_PREFIX = "agent-app-model-default";
 export function normalizeAgentAppModelDefaultAppId(appId) {
@@ -50,12 +50,15 @@ export async function readAgentAppModelDefaultSettings(ctx, appIdInput) {
             ? { appId, ...stored, scope: "org", source: "org" }
             : emptySettings(appId, "org");
     }
-    if (ctx.userEmail) {
+    if (ctx.userEmail && ctx.orgScope === "personal") {
         const stored = parseSelection(await getUserSetting(ctx.userEmail, key));
         return stored
             ? { appId, ...stored, scope: "user", source: "user" }
             : emptySettings(appId, "user");
     }
+    if (ctx.userEmail) {
+        throw new Error("Organization scope could not be resolved.");
+    }
     return emptySettings(appId, "default");
 }
 export async function writeAgentAppModelDefaultSettings(ctx, appIdInput, selection) {
@@ -83,6 +86,9 @@ export async function writeAgentAppModelDefaultSettings(ctx, appIdInput, selecti
     if (!ctx.userEmail) {
         throw new Error("Authentication required to update model defaults.");
     }
+    if (ctx.orgScope !== "personal") {
+        throw new Error("Organization scope could not be resolved.");
+    }
     await putUserSetting(ctx.userEmail, key, value);
     return readAgentAppModelDefaultSettings(ctx, appId);
 }
@@ -98,14 +104,17 @@ export async function resetAgentAppModelDefaultSettings(ctx, appIdInput) {
     if (!ctx.userEmail) {
         throw new Error("Authentication required to reset model defaults.");
     }
+    if (ctx.orgScope !== "personal") {
+        throw new Error("Organization scope could not be resolved.");
+    }
     await deleteUserSetting(ctx.userEmail, key);
     return readAgentAppModelDefaultSettings(ctx, appId);
 }
-export async function canUpdateAgentAppModelDefaultSettings(userEmail, orgId) {
+export async function canUpdateAgentAppModelDefaultSettings(userEmail, orgId, orgScope) {
     if (!userEmail)
         return false;
     if (!orgId)
-        return true;
+        return orgScope === "personal";
     try {
         const exec = getDbExec();
         const { rows } = await exec.execute({
@@ -126,9 +135,18 @@ export async function getAgentAppModelDefaultForCurrentRequest(appIdInput) {
     const appId = normalizeAgentAppModelDefaultAppId(appIdInput);
     if (!appId)
         return null;
+    const requestContext = getRequestContext();
     const userEmail = getRequestUserEmail();
     const orgId = getRequestOrgId();
-    const settings = await readAgentAppModelDefaultSettings({ userEmail, orgId }, appId).catch(() => null);
+    if (!orgId && requestContext?.orgScope !== "personal")
+        return null;
+    const settings = await readAgentAppModelDefaultSettings({
+        userEmail,
+        orgId,
+        ...(requestContext?.orgScope === "personal"
+            ? { orgScope: "personal" }
+            : {}),
+    }, appId).catch(() => null);
     if (!settings?.engine || !settings.model)
         return null;
     return {

package/dist/agent/default-agent-engine.d.ts

@@ -20,6 +20,8 @@ export type DefaultAgentEngineSource = DefaultAgentEngineScope | "legacy" | "non
 export interface DefaultAgentEngineContext {
     userEmail?: string | null;
     orgId?: string | null;
+    orgScope?: "personal";
+    defaultAgentEngineScope?: "deployment";
 }
 export interface DefaultAgentEngineRead {
     /** The stored `{ engine, model }` row, or null when no default applies. */
@@ -37,7 +39,7 @@ export type DefaultAgentEngineAuthority = {
     userEmail: string;
 } | {
     allowed: false;
-    reason: "unauthenticated" | "not-admin";
+    reason: "unauthenticated" | "not-admin" | "scope-unavailable";
     message: string;
 };
 export interface DefaultAgentEngineChangeMeta {
@@ -54,8 +56,8 @@ export interface DefaultAgentEngineSelection {
 }
 /**
  * Read the default that applies to `ctx` (the current request when omitted):
- * the organization's row, else a no-org user's own row, else the legacy
- * deployment-wide row.
+ * the organization's row, else an explicitly personal user's own row, else
+ * the legacy deployment-wide row. An unresolved scope throws before fallback.
  *
  * A scoped row with no engine is an explicit "cleared" marker. It answers for
  * that scope instead of falling through to the legacy row, so clearing the

package/dist/agent/default-agent-engine.js

@@ -7,7 +7,7 @@
  * goes through this module so the scope rules live in one place.
  */
 import { recordOrgAdminAuditEvent } from "../audit/org-admin.js";
-import { getRequestOrgId, getRequestUserEmail, } from "../server/request-context.js";
+import { getRequestContext, getRequestOrgId, getRequestUserEmail, } from "../server/request-context.js";
 import { getOrgSetting, putOrgSetting } from "../settings/org-settings.js";
 import { getSetting } from "../settings/store.js";
 import { getUserSetting, putUserSetting } from "../settings/user-settings.js";
@@ -17,7 +17,15 @@ export const DEFAULT_AGENT_ENGINE_SETTING_KEY = "agent-engine";
 /** Audit target type for default-model changes and refused attempts. */
 export const DEFAULT_AGENT_ENGINE_AUDIT_TARGET_TYPE = "agent-default-model";
 function requestContext() {
-    return { userEmail: getRequestUserEmail(), orgId: getRequestOrgId() };
+    const context = getRequestContext();
+    return {
+        userEmail: getRequestUserEmail(),
+        orgId: getRequestOrgId(),
+        ...(context?.orgScope === "personal" ? { orgScope: "personal" } : {}),
+        ...(context?.defaultAgentEngineScope === "deployment"
+            ? { defaultAgentEngineScope: "deployment" }
+            : {}),
+    };
 }
 function normalizedContext(ctx) {
     return {
@@ -30,8 +38,8 @@ function hasEngine(value) {
 }
 /**
  * Read the default that applies to `ctx` (the current request when omitted):
- * the organization's row, else a no-org user's own row, else the legacy
- * deployment-wide row.
+ * the organization's row, else an explicitly personal user's own row, else
+ * the legacy deployment-wide row. An unresolved scope throws before fallback.
  *
  * A scoped row with no engine is an explicit "cleared" marker. It answers for
  * that scope instead of falling through to the legacy row, so clearing the
@@ -39,13 +47,18 @@ function hasEngine(value) {
  */
 export async function readDefaultAgentEngineSettingDetailed(ctx = requestContext()) {
     const { userEmail, orgId } = normalizedContext(ctx);
+    if (!orgId &&
+        ctx.orgScope !== "personal" &&
+        ctx.defaultAgentEngineScope !== "deployment") {
+        throw new Error("Organization scope could not be resolved.");
+    }
     if (orgId) {
         const scoped = await getOrgSetting(orgId, DEFAULT_AGENT_ENGINE_SETTING_KEY);
         if (scoped) {
             return { value: hasEngine(scoped) ? scoped : null, source: "org" };
         }
     }
-    else if (userEmail) {
+    else if (userEmail && ctx.orgScope === "personal") {
         const scoped = await getUserSetting(userEmail, DEFAULT_AGENT_ENGINE_SETTING_KEY);
         if (scoped) {
             return { value: hasEngine(scoped) ? scoped : null, source: "user" };
@@ -76,9 +89,16 @@ export async function resolveDefaultAgentEngineAuthority(ctx = requestContext())
             message: "Sign in to change the default model.",
         };
     }
+    if (!orgId && ctx.orgScope !== "personal") {
+        return {
+            allowed: false,
+            reason: "scope-unavailable",
+            message: "Organization scope could not be resolved.",
+        };
+    }
     if (!orgId)
         return { allowed: true, scope: "user", userEmail };
-    if (await canUpdateAgentAppModelDefaultSettings(userEmail, orgId)) {
+    if (await canUpdateAgentAppModelDefaultSettings(userEmail, orgId, ctx.orgScope)) {
         return { allowed: true, scope: "org", orgId, userEmail };
     }
     return {
@@ -99,7 +119,12 @@ async function writeScopedRow(authority, value) {
  * stores only that scope and records the change.
  */
 export async function writeDefaultAgentEngineSelection(authority, selection, meta) {
-    const previous = await readDefaultAgentEngineSettingDetailed(authority);
+    const previous = await readDefaultAgentEngineSettingDetailed({
+        userEmail: authority.userEmail,
+        ...(authority.scope === "org"
+            ? { orgId: authority.orgId }
+            : { orgScope: "personal" }),
+    });
     await writeScopedRow(authority, {
         engine: selection.engine,
         model: selection.model,
@@ -132,7 +157,12 @@ export async function writeDefaultAgentEngineSelection(authority, selection, met
  * than deleting the row; see {@link readDefaultAgentEngineSettingDetailed}.
  */
 export async function clearDefaultAgentEngineSelection(authority, meta) {
-    const previous = await readDefaultAgentEngineSettingDetailed(authority);
+    const previous = await readDefaultAgentEngineSettingDetailed({
+        userEmail: authority.userEmail,
+        ...(authority.scope === "org"
+            ? { orgId: authority.orgId }
+            : { orgScope: "personal" }),
+    });
     await writeScopedRow(authority, {
         cleared: true,
         updatedAt: Date.now(),

package/dist/agent/durable-background.d.ts

@@ -54,6 +54,8 @@ export declare const AGENT_CHAT_DURABLE_BACKGROUND_ENV = "AGENT_CHAT_DURABLE_BAC
 export declare const AGENT_CHAT_BACKGROUND_RUN_FIELD = "__backgroundRun";
 /** Analytics-only source context captured before the run leaves its browser request. */
 export declare const AGENT_CHAT_BROWSER_SESSION_ID_FIELD = "__agentNativeBrowserSessionId";
+/** Captured turn origin; durable workers do not restore loopback trust from this payload. */
+export declare const AGENT_CHAT_REQUEST_CONTEXT_FIELD = "__agentChatRequestContext";
 export declare function isHostedRuntimeForDurableBackground(): boolean;
 export declare function isNetlifyHostedRuntimeForDurableBackground(): boolean;
 export declare function isInBackgroundFunctionRuntime(): boolean;

package/dist/agent/durable-background.js

@@ -134,6 +134,8 @@ export const AGENT_CHAT_DURABLE_BACKGROUND_ENV = "AGENT_CHAT_DURABLE_BACKGROUND"
 export const AGENT_CHAT_BACKGROUND_RUN_FIELD = "__backgroundRun";
 /** Analytics-only source context captured before the run leaves its browser request. */
 export const AGENT_CHAT_BROWSER_SESSION_ID_FIELD = "__agentNativeBrowserSessionId";
+/** Captured turn origin; durable workers do not restore loopback trust from this payload. */
+export const AGENT_CHAT_REQUEST_CONTEXT_FIELD = "__agentChatRequestContext";
 export function isHostedRuntimeForDurableBackground() {
     if (process.env.NETLIFY_LOCAL === "true")
         return false;

package/dist/agent/engine/registry.js

@@ -617,6 +617,8 @@ function identityUserEmail(identity) {
     return getRequestUserEmail()?.trim() || undefined;
 }
 async function chatGPTSubscriptionUsableForRequest(identity) {
+    if (identity?.orgId || getRequestOrgId())
+        return false;
     const email = identityUserEmail(identity);
     if (!email)
         return false;
@@ -908,6 +910,10 @@ export async function resolveEngine(config) {
     if (engineOption &&
         typeof engineOption === "object" &&
         "stream" in engineOption) {
+        if (engineOption.name === CHATGPT_SUBSCRIPTION_ENGINE_NAME &&
+            !(await chatGPTSubscriptionUsableForRequest(credentialIdentity))) {
+            throw new Error("Connect a ChatGPT account with direct model access before using this engine.");
+        }
         return engineOption;
     }
     if (engineOption &&

package/dist/agent/production-agent.js

@@ -58,7 +58,7 @@ import { CONTINUE_UNAVAILABLE_CODE, } from "./auto-continue.js";
 import { clipHead } from "./clip-text.js";
 import { connectionRequiredMessage, priorConnectionContextNote, resolvePriorConnectionNote, } from "./connection-required-note.js";
 import { buildSystemManifestSections, readContextXraySystemSections, } from "./context-xray/manifest.js";
-import { AGENT_CHAT_BROWSER_SESSION_ID_FIELD, AGENT_CHAT_BACKGROUND_RUN_FIELD, AGENT_CHAT_PROCESS_RUN_PATH, AGENT_CHAT_RECOVERY_OF_RUN_FIELD, backgroundRuntimeDiagnosticDetail, dispatchPathTargetsNetlifyBackgroundFunction, isAgentChatDurableBackgroundEnabled, isAgentChatForegroundSelfChainEnabled, isInBackgroundFunctionRuntime, resolveAgentChatProcessRunDispatchPath, shouldUseBackgroundFunctionTimeoutForWorker, } from "./durable-background.js";
+import { AGENT_CHAT_BROWSER_SESSION_ID_FIELD, AGENT_CHAT_REQUEST_CONTEXT_FIELD, AGENT_CHAT_BACKGROUND_RUN_FIELD, AGENT_CHAT_PROCESS_RUN_PATH, AGENT_CHAT_RECOVERY_OF_RUN_FIELD, backgroundRuntimeDiagnosticDetail, dispatchPathTargetsNetlifyBackgroundFunction, isAgentChatDurableBackgroundEnabled, isAgentChatForegroundSelfChainEnabled, isInBackgroundFunctionRuntime, resolveAgentChatProcessRunDispatchPath, shouldUseBackgroundFunctionTimeoutForWorker, } from "./durable-background.js";
 import { applyContextXrayTransformForIteration } from "./engine/context-directives-transform.js";
 import { attemptContinuationDispatch } from "./engine/continuation-dispatch-retry.js";
 import { formatLlmCredentialErrorMessage, LLM_MISSING_CREDENTIALS_ERROR_CODE, LLM_MISSING_CREDENTIALS_MESSAGE, userFacingLlmCredentialError, } from "./engine/credential-errors.js";
@@ -488,6 +488,12 @@ export async function getOwnerActiveApiKey(ownerEmail) {
         const engineSetting = await readDefaultAgentEngineSetting({
             userEmail: ownerEmail ?? getRequestUserEmail(),
             orgId: getRequestOrgId(),
+            ...(getRequestContext()?.orgScope === "personal"
+                ? { orgScope: "personal" }
+                : {}),
+            ...(getRequestContext()?.defaultAgentEngineScope === "deployment"
+                ? { defaultAgentEngineScope: "deployment" }
+                : {}),
         });
         const activeEngine = engineSetting?.engine ?? "anthropic";
         return (await getOwnerApiKeyForEngine(activeEngine, ownerEmail)).apiKey;
@@ -523,8 +529,8 @@ export async function resolveOwnerEngineApiKey(input) {
     }
     else {
         try {
-            const { getSetting } = await import("../settings/store.js");
-            const engineSetting = await getSetting("agent-engine");
+            const { readDefaultAgentEngineSetting } = await import("./default-agent-engine.js");
+            const engineSetting = await readDefaultAgentEngineSetting();
             activeEngineSetting = {
                 status: "available",
                 engine: engineSetting?.engine ?? "anthropic",
@@ -8101,6 +8107,13 @@ export function createProductionAgentHandler(options) {
             // A client can submit this private field, so overwrite it at the boundary.
             mutableBody[AGENT_CHAT_BROWSER_SESSION_ID_FIELD] =
                 getRequestContext()?.browserSessionId ?? null;
+            const requestContext = getRequestContext();
+            mutableBody[AGENT_CHAT_REQUEST_CONTEXT_FIELD] = {
+                requestOrigin: requestContext?.requestOrigin ?? null,
+                isLoopbackRequest: !dispatchToBackground && requestContext?.isLoopbackRequest === true,
+                isDirectLoopbackRequest: !dispatchToBackground &&
+                    requestContext?.isDirectLoopbackRequest === true,
+            };
             delete mutableBody[ANALYTICS_CLIENT_PLATFORM_BODY_FIELD];
         }
         if (dispatchToBackground) {
@@ -10286,12 +10299,32 @@ export function createProductionAgentHandler(options) {
                     return;
                 }
                 if (exactApprovedToolCall && approvedToolCallsForExecution) {
+                    let pausedResult;
+                    if (!isBackgroundWorker) {
+                        const pausedResults = agentLoopOpts.messages.flatMap((message) => message.content.filter((part) => part.type === "tool-result" &&
+                            part.toolCallId === exactApprovedToolCall.callId &&
+                            part.approvalPause === true));
+                        if (pausedResults.length !== 1) {
+                            send({
+                                type: "error",
+                                error: "The agent run failed.",
+                                errorCode: "approved_tool_call_result_missing",
+                                recoverable: false,
+                            });
+                            return;
+                        }
+                        const [candidate] = pausedResults;
+                        if (candidate?.type !== "tool-result") {
+                            throw new Error("Approved tool result changed unexpectedly.");
+                        }
+                        pausedResult = candidate;
+                    }
                     send({
                         type: "activity",
                         label: `Running approved ${exactApprovedToolCall.name} action`,
                         tool: exactApprovedToolCall.name,
                     });
-                    await executeAgentToolCall({
+                    const approvedExecution = await executeAgentToolCall({
                         actions: requestActions,
                         name: exactApprovedToolCall.name,
                         input: exactApprovedToolCall.input,
@@ -10313,7 +10346,27 @@ export function createProductionAgentHandler(options) {
                         isToolAlwaysAllowed: approvalHooks.isToolAlwaysAllowed,
                         send,
                     });
-                    return;
+                    if (approvedExecution.status === "approval_required" ||
+                        (approvedExecution.status === "failed" &&
+                            approvedExecution.terminalError)) {
+                        return;
+                    }
+                    if (isBackgroundWorker)
+                        return;
+                    if (!pausedResult) {
+                        throw new Error("Approved tool result was not validated.");
+                    }
+                    pausedResult.content = approvedExecution.output;
+                    if (approvedExecution.status === "failed") {
+                        pausedResult.isError = true;
+                    }
+                    else {
+                        delete pausedResult.isError;
+                    }
+                    delete pausedResult.approvalPause;
+                    delete pausedResult.approvalAskId;
+                    delete agentLoopOpts.approvedToolCalls;
+                    delete agentLoopOpts.approvedToolCallAskId;
                 }
                 try {
                     const { getObservabilityConfig, instrumentAgentLoop } = await import("../observability/traces.js");

package/dist/automations/service.d.ts

@@ -72,6 +72,8 @@ export declare function deleteAutomation(actorInput: AutomationActor, scope: Aut
 export interface AutomationExecutionIdentity {
     userEmail: string;
     orgId?: string;
+    orgScope?: "personal";
+    defaultAgentEngineScope?: "deployment";
     eventOwner: string;
 }
 /**

package/dist/automations/service.js

@@ -473,7 +473,10 @@ export async function resolveAutomationExecutionIdentity(resourceOwner, meta) {
                 code: "config_invalid",
             };
         }
-        return { ok: true, identity: { userEmail, eventOwner: userEmail } };
+        return {
+            ok: true,
+            identity: { userEmail, orgScope: "personal", eventOwner: userEmail },
+        };
     }
     const userEmail = meta.createdBy?.trim().toLowerCase();
     if (!userEmail) {

package/dist/client/analytics.js

@@ -19,6 +19,7 @@ import { scheduleAfterPaint } from "./use-after-paint.js";
 export { clearAnalyticsSessionId, setAnalyticsSessionId, } from "./analytics-session.js";
 import { fetchAgentEngineStatus, fetchAuthSessionStatus, } from "./client-status-requests.js";
 import { firstPartyHosts, installErrorCapture, } from "./error-capture.js";
+import { buildRecorderReport, recorderSentryEnabled, } from "./recorder.js";
 import { currentRouteTemplate } from "./route-template.js";
 import { scrubUrl } from "./url-scrub.js";
 import { installWebVitals, } from "./web-vitals.js";
@@ -815,6 +816,51 @@ function shouldDropBrowserSentryNoise(event) {
         firstPartyHosts: firstPartyHosts(),
     }).drop;
 }
+// Sentry keeps 100 breadcrumbs by default; the attachment carries the whole report.
+const SENTRY_RECORDER_BREADCRUMBS = 100;
+function recorderBreadcrumb(recorded) {
+    const { t: _t, at, type, name, data: _data, ...outcome } = recorded;
+    return {
+        category: `recorder.${type}`,
+        message: [
+            name,
+            outcome.ok === undefined ? undefined : outcome.ok ? "ok" : "failed",
+            outcome.status,
+            outcome.errorCode,
+            outcome.ms === undefined ? undefined : `${outcome.ms}ms`,
+        ]
+            .filter((part) => part !== undefined)
+            .join(" "),
+        level: type === "error" || (type === "toast" && name === "error")
+            ? "error"
+            : type === "toast" || outcome.ok === false
+                ? "warning"
+                : "info",
+        timestamp: at / 1000,
+        data: outcome,
+    };
+}
+function addRecorderContext(event, hint) {
+    if (!recorderSentryEnabled())
+        return;
+    const report = buildRecorderReport("error");
+    if (report.events.length > 0) {
+        event.breadcrumbs = [
+            ...(event.breadcrumbs ?? []),
+            ...report.events
+                .slice(-SENTRY_RECORDER_BREADCRUMBS)
+                .map(recorderBreadcrumb),
+        ].sort((a, b) => (a.timestamp ?? 0) - (b.timestamp ?? 0));
+    }
+    hint.attachments = [
+        ...(hint.attachments ?? []),
+        {
+            filename: "recorder.json",
+            data: JSON.stringify(report),
+            contentType: "application/json",
+        },
+    ];
+}
 function firstNonEmpty(...values) {
     for (const value of values) {
         const trimmed = value?.trim();
@@ -895,7 +941,7 @@ function ensureSentry(loadWithoutDsn = false) {
             dsn,
             environment: resolveClientDeploymentEnvironment(),
             release: resolveClientRelease(),
-            beforeSend(event) {
+            beforeSend(event, hint = {}) {
                 if (isSyntheticBrowserTraffic())
                     return null;
                 event.tags = {
@@ -924,6 +970,7 @@ function ensureSentry(loadWithoutDsn = false) {
                         }
                     }
                 }
+                addRecorderContext(event, hint);
                 return event;
             },
         });

package/dist/client/application-state.js

@@ -1,6 +1,7 @@
 import { agentNativePath } from "./api-path.js";
 import { assertAgentNativeApiEnabled } from "./api-surface.js";
 import { getBrowserTabId } from "./browser-tab-id.js";
+import { recordStateWrite } from "./recorder.js";
 const APP_STATE_KEY_PATTERN = /^[a-zA-Z0-9_:-]+$/;
 const pendingMutations = new Map();
 const mutationRevisions = new Map();
@@ -200,7 +201,7 @@ export async function readClientAppState(key, options = {}) {
 }
 export async function writeClientAppState(key, value, options = {}) {
     assertAgentNativeApiEnabled(`write application state "${key}"`);
-    return runClientAppStateMutation(key, async () => {
+    const write = runClientAppStateMutation(key, async () => {
         const response = await fetch(appStateUrl(key), {
             method: "PUT",
             headers: buildHeaders(options.requestSource),
@@ -210,6 +211,8 @@ export async function writeClientAppState(key, value, options = {}) {
         });
         return parseAppStateResponse(response, `Write application state "${key}"`);
     });
+    recordStateWrite(key, value, write, options.signal);
+    return write;
 }
 export async function compareAndSetClientAppState(key, expected, next, options = {}) {
     assertAgentNativeApiEnabled(`compare application state \"${key}\"`);
@@ -230,7 +233,7 @@ export async function compareAndSetClientAppState(key, expected, next, options =
 }
 export async function deleteClientAppState(key, options = {}) {
     assertAgentNativeApiEnabled(`delete application state "${key}"`);
-    await runClientAppStateMutation(key, async () => {
+    const deletion = runClientAppStateMutation(key, async () => {
         const response = await fetch(appStateUrl(key), {
             method: "DELETE",
             headers: {
@@ -245,6 +248,8 @@ export async function deleteClientAppState(key, options = {}) {
         });
         return parseAppStateResponse(response, `Delete application state "${key}"`);
     });
+    recordStateWrite(key, undefined, deletion, options.signal);
+    await deletion;
 }
 export async function setClientAppState(key, value, options = {}) {
     if (value === null || value === undefined) {

package/dist/client/chat/agentkit-protocol.js

@@ -3232,9 +3232,18 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                     activeMessageCompleted: run.activeMessageCompleted,
                     pendingWidgets: new Map(run.pendingWidgets),
                     actions: new Map(run.actions),
-                    activeTools: new Map(run.activeTools),
-                    pendingToolMessageAssociations: new Map(run.pendingToolMessageAssociations),
-                    activeActivities: new Map(run.activeActivities),
+                    activeTools: new Map([...run.activeTools].map(([id, tool]) => [
+                        id,
+                        { ...tool, runId: nextRunId },
+                    ])),
+                    pendingToolMessageAssociations: new Map([...run.pendingToolMessageAssociations].map(([id, tool]) => [
+                        id,
+                        { ...tool, runId: nextRunId },
+                    ])),
+                    activeActivities: new Map([...run.activeActivities].map(([id, activity]) => [
+                        id,
+                        { ...activity, runId: nextRunId },
+                    ])),
                     terminalAppendDepth: 0,
                     pumpPromise: null,
                     continuationPromise: null,

package/dist/client/client-bootstrap.js

@@ -1,6 +1,8 @@
 import { ensureEmbedAuthFetchInterceptor } from "./embed-auth.js";
+import { startRecorder } from "./recorder.js";
 import { installRouteChunkRecovery } from "./route-chunk-recovery.js";
 export function initializeAgentNativeClient() {
     ensureEmbedAuthFetchInterceptor();
     installRouteChunkRecovery();
+    startRecorder();
 }

package/dist/client/problem-report.d.ts

@@ -0,0 +1,11 @@
+import type { RecorderReport } from "./recorder.js";
+export { countRecorderEventsByType, formatProblemReportSummary, formatRecorderEvent, isFailedRecorderEvent, } from "../problem-report/format.js";
+export type ProblemReportUpload = {
+    status: "ok";
+    ref: string;
+} | {
+    status: "failed";
+    errorCode?: string;
+    message?: string;
+};
+export declare function uploadProblemReport(report: RecorderReport): Promise<ProblemReportUpload>;

package/dist/client/problem-report.js

@@ -0,0 +1,19 @@
+import { actionErrorMessage, callAction } from "./use-action.js";
+export { countRecorderEventsByType, formatProblemReportSummary, formatRecorderEvent, isFailedRecorderEvent, } from "../problem-report/format.js";
+export async function uploadProblemReport(report) {
+    try {
+        const { ref } = await callAction("save-problem-report", {
+            report,
+        });
+        return { status: "ok", ref };
+    }
+    catch (error) {
+        const errorCode = error.errorCode;
+        const message = actionErrorMessage(error);
+        return {
+            status: "failed",
+            ...(typeof errorCode === "string" ? { errorCode } : {}),
+            ...(message ? { message } : {}),
+        };
+    }
+}