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

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 } : {}),
+        };
+    }
+}

package/dist/client/recorder.d.ts

@@ -0,0 +1,88 @@
+export type RecorderEventType = "action" | "state" | "nav" | "error" | "toast" | "log";
+export type RecorderReportReason = "user" | "error" | "test" | "manual";
+export interface RecorderEvent {
+    /** Seconds before the report was made (negative). */
+    t: number;
+    /** Epoch ms, the same clock as Clips diagnostics `timestampMs`. */
+    at: number;
+    type: RecorderEventType;
+    name?: string;
+    ok?: boolean;
+    status?: number;
+    errorCode?: string;
+    ms?: number;
+    requestId?: string;
+    /** Redacted and bounded: strings ≤ 200 characters, the event ≤ about 2 KB. */
+    data?: Record<string, unknown>;
+}
+export interface RecorderPendingWork {
+    type: "action" | "state" | string;
+    name: string;
+    ageMs: number;
+}
+export interface RecorderReport {
+    app: string;
+    build: string;
+    /** The route path, with every query value redacted. */
+    url: string;
+    at: string;
+    reason: RecorderReportReason;
+    windowSeconds: number;
+    events: RecorderEvent[];
+    watched: Record<string, unknown>;
+    pending: RecorderPendingWork[];
+    /** Events lost to the caps since the last clear. */
+    dropped: number;
+}
+export interface RecorderReportOptions {
+    seconds?: number;
+    reason?: RecorderReportReason;
+}
+/** @internal Called when an action starts; call the result when it settles. */
+export declare function recordActionStart(name: string, method: string): (outcome: {
+    error: unknown;
+    response: Response | undefined;
+    signal: AbortSignal | undefined;
+}) => void;
+/** @internal An `application_state` write, or a delete when `value` is undefined. */
+export declare function recordStateWrite(key: string, value: unknown, write: Promise<unknown>, signal: AbortSignal | undefined): void;
+/** @internal */
+export declare function recordNav(): void;
+/** @internal The report without notifying `onReport` listeners, for core's own destinations. */
+export declare function buildRecorderReport(reason: RecorderReportReason, seconds?: number): RecorderReport;
+declare function report(options?: RecorderReportOptions): RecorderReport;
+declare function pending(): RecorderPendingWork[];
+export declare const recorder: {
+    /** Synchronous. Listeners hear about every report except a `"manual"` one. */
+    report: typeof report;
+    log(name: string, data?: unknown): void;
+    /** Adds `getValue()` to every report. Returns a function that stops it. */
+    watch(name: string, getValue: () => unknown): () => void;
+    onReport(listener: (report: RecorderReport) => void): () => void;
+    /** Field names (`"body"`), or dotted paths that start with the event's name (`"compose.body"`, `"payment.*"`). */
+    redact(...keys: string[]): void;
+    pending: typeof pending;
+    disable(): void;
+};
+declare global {
+    interface Window {
+        __agentNativeRecorder?: {
+            report: typeof report;
+        };
+    }
+}
+export declare function configureRecorder(options: {
+    windowSeconds?: number;
+    maxEvents?: number;
+    sentry?: boolean;
+    enabled?: boolean;
+}): void;
+/** @internal Whether `ensureSentry()` should attach recorder events. */
+export declare function recorderSentryEnabled(): boolean;
+/** @internal Forgets everything recorded, e.g. on sign-out. */
+export declare function clearRecorder(): void;
+/** @internal Called once from client bootstrap. */
+export declare function startRecorder(): void;
+/** @internal */
+export declare function resetRecorderForTests(): void;
+export {};