@agent-native/core 0.98.0 → 0.98.2

package/corpus/core/src/client/AssistantChat.tsx

@@ -170,6 +170,7 @@ import {
   GuidedQuestionFlow,
   useGuidedQuestionFlow,
 } from "./guided-questions.js";
+import { useT } from "./i18n.js";
 import {
   AgentAutoContinueSignal,
   type ContentPart,
@@ -388,6 +389,63 @@ function isAssistantUiDuplicateMessageIdError(error: unknown): boolean {
   );
 }
 
+type AssistantUiMessageRepository = {
+  addOrUpdateMessage: (parentId: unknown, message: unknown) => unknown;
+  __agentNativePatched?: boolean;
+  head?: { current?: { id?: string } } | null;
+};
+
+type AssistantUiThreadBinding = {
+  getState?: () => { repository?: AssistantUiMessageRepository };
+  outerSubscribe?: (callback: () => void) => void | (() => void);
+};
+
+/**
+ * Keep the assistant-ui repository race recovery installed across runtime-core
+ * replacements. The public ThreadRuntime object stays stable when its binding
+ * swaps to another local runtime (thread activation, reconnect, history load),
+ * but each core owns a different MessageRepository instance.
+ */
+export function installAssistantUiMessageRepositoryRecovery(
+  threadRuntime: unknown,
+): () => void {
+  const binding = (
+    threadRuntime as {
+      __internal_threadBinding?: AssistantUiThreadBinding;
+    }
+  )?.__internal_threadBinding;
+  if (!binding?.getState) return () => {};
+
+  const patchCurrentRepository = () => {
+    const repo = binding.getState?.()?.repository;
+    if (!repo || typeof repo.addOrUpdateMessage !== "function") return;
+    if (repo.__agentNativePatched) return;
+    repo.__agentNativePatched = true;
+    const original = repo.addOrUpdateMessage.bind(repo);
+    repo.addOrUpdateMessage = function (parentId: unknown, message: unknown) {
+      try {
+        return original(parentId, message);
+      } catch (error) {
+        const errorMessage =
+          error instanceof Error ? error.message : String(error);
+        if (parentId && errorMessage.includes("Parent message not found")) {
+          const fallbackParent = this.head?.current?.id ?? null;
+          if (fallbackParent && fallbackParent !== parentId) {
+            return original(fallbackParent, message);
+          }
+          return original(null, message);
+        }
+        if (errorMessage.includes("same id already exists")) return;
+        throw error;
+      }
+    };
+  };
+
+  patchCurrentRepository();
+  const unsubscribe = binding.outerSubscribe?.(patchCurrentRepository);
+  return typeof unsubscribe === "function" ? unsubscribe : () => {};
+}
+
 function cloneContentParts(content: ContentPart[]): ContentPart[] {
   return content.map((part) =>
     part.type === "text" || part.type === "reasoning"
@@ -1885,6 +1943,7 @@ const AssistantChatInner = forwardRef<
 ) {
   const thread = useThread();
   const threadRuntime = useThreadRuntime();
+  const t = useT();
   const composerRuntime = useComposerRuntime();
   const isRuntimeRunning = thread.isRunning;
   // Latest-value ref so long-lived async closures (the reconnect reader, its
@@ -1993,41 +2052,19 @@ const AssistantChatInner = forwardRef<
   // assets.agent-native.com prompt composer (AGENT-NATIVE-BROWSER-18). Fix
   // it by relinking to the current head whenever the requested parent has
   // gone missing instead of throwing.
-  useEffect(() => {
-    const repo = (threadRuntime as any)?.__internal_threadBinding?.getState?.()
-      ?.repository as
-      | { addOrUpdateMessage?: (parentId: any, message: any) => void }
-      | undefined;
-    if (!repo || typeof repo.addOrUpdateMessage !== "function") return;
-    const patched = repo as any;
-    if (patched.__agentNativePatched) return;
-    patched.__agentNativePatched = true;
-    const original = repo.addOrUpdateMessage.bind(repo);
-    repo.addOrUpdateMessage = function (parentId: any, message: any) {
-      try {
-        return original(parentId, message);
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        if (parentId && msg.includes("Parent message not found")) {
-          const fallbackParent = (this as any).head?.current?.id ?? null;
-          if (fallbackParent && fallbackParent !== parentId) {
-            return original(fallbackParent, message);
-          }
-          return original(null, message);
-        }
-        if (msg.includes("same id already exists")) {
-          return;
-        }
-        throw err;
-      }
-    };
-  }, [threadRuntime]);
+  useEffect(
+    () => installAssistantUiMessageRepositoryRecovery(threadRuntime),
+    [threadRuntime],
+  );
   const agentEngineConfigured = useAgentEngineConfigured(
     providerStatusChecksEnabled,
     { tabId, threadId },
   );
   const missingApiKey = agentEngineConfigured.missing;
-  const isComposerDisabled = missingApiKey || composerDisabled;
+  const isProviderStatusChecking =
+    providerStatusChecksEnabled && agentEngineConfigured.state === "unknown";
+  const isComposerDisabled =
+    missingApiKey || isProviderStatusChecking || composerDisabled;
   const [missingKeySetupOpen, setMissingKeySetupOpen] = useState(false);
   const requestMissingKeySetup = useCallback(() => {
     setMissingKeySetupOpen(true);
@@ -2043,7 +2080,12 @@ const AssistantChatInner = forwardRef<
         : await fetchAgentEngineConfiguredState(providerStatusChecksEnabled, {
             timeoutMs: SUBMIT_ENGINE_STATUS_TIMEOUT_MS,
           });
-    if (state !== "missing") return true;
+    if (state === "configured") return true;
+
+    // Unknown means the readiness endpoint is unavailable or still resolving.
+    // Do not start a run optimistically: that recreates the long failure path
+    // this preflight exists to prevent. The mounted hook retries automatically.
+    if (state === "unknown") return false;
 
     requestMissingKeySetup();
     if (typeof window !== "undefined") {
@@ -5150,14 +5192,16 @@ const AssistantChatInner = forwardRef<
                             placeholder={
                               missingApiKey
                                 ? "Connect AI to start chatting..."
-                                : composerDisabled
-                                  ? (composerDisabledPlaceholder ??
-                                    "Open Desktop to use this chat.")
-                                  : isRunning
-                                    ? queuedMessages.length > 0
-                                      ? `${queuedMessages.length} queued — send a follow-up...`
-                                      : "Send a follow-up..."
-                                    : composerPlaceholder
+                                : isProviderStatusChecking
+                                  ? t("agentPanel.checkingAiConnection")
+                                  : composerDisabled
+                                    ? (composerDisabledPlaceholder ??
+                                      "Open Desktop to use this chat.")
+                                    : isRunning
+                                      ? queuedMessages.length > 0
+                                        ? `${queuedMessages.length} queued — send a follow-up...`
+                                        : "Send a follow-up..."
+                                      : composerPlaceholder
                             }
                             onSubmit={
                               isRunning || composerContextItems.length > 0

package/corpus/core/src/client/analytics.ts

@@ -89,6 +89,13 @@ export type ConfigureTrackingOptions = {
   /** First-party analytics track endpoint. */
   endpoint?: string;
   getDefaultProps?: GetDefaultProps;
+  /**
+   * Disable content-capturing analytics such as interaction autocapture and
+   * session replay while retaining pageviews, explicit events, and Sentry.
+   */
+  contentCapture?: boolean;
+  /** Resolve content capture synchronously for each browser pathname. */
+  contentCaptureForPath?: (pathname: string) => boolean;
   sessionReplay?: boolean | SessionReplayOptions;
   /**
    * First-party, Sentry-style error capture. Auto-captures uncaught errors
@@ -132,6 +139,8 @@ let _errorCaptureDisposer: (() => void) | null = null;
 let _sessionReplayModuleForCapture:
   | typeof import("./session-replay.js")
   | null = null;
+let _trackingContentCaptureEnabled = true;
+let _contentCaptureForPath: ((pathname: string) => boolean) | null = null;
 // Buffer for setSentryUser calls made before Sentry has initialized.
 // `undefined` means "no pending update"; `null` means "pending clear".
 let _pendingSentryUser: SentryUser | null | undefined = undefined;
@@ -575,7 +584,10 @@ function ensureAmplitude(): boolean {
   const key = (import.meta.env as Record<string, string | undefined>)
     ?.VITE_AMPLITUDE_API_KEY;
   if (!key) return false;
-  amplitude.init(key, { autocapture: true });
+  // Standard pageviews and explicit events are emitted below. Keep SDK-level
+  // DOM/network autocapture off so rendered user content is never collected as
+  // an implicit analytics side effect.
+  amplitude.init(key, { autocapture: false });
   _amplitudeInitialized = true;
   return true;
 }
@@ -618,12 +630,41 @@ function isAgentNativeDocsUrl(url: string): boolean {
   }
 }
 
+function isSessionReplayUrl(url: string): boolean {
+  if (!url) return false;
+  try {
+    const parsed = new URL(url);
+    return /^\/sessions\/[^/]+\/?$/.test(parsed.pathname);
+  } catch {
+    return false;
+  }
+}
+
 function shouldDropBrowserSentryNoise(event: Sentry.Event): boolean {
   const exceptionValues = event.exception?.values ?? [];
   const taggedUrl =
     typeof event.tags?.url === "string" ? event.tags.url : undefined;
   const requestUrl = (event.request?.url ?? taggedUrl ?? "").toLowerCase();
   const isDocsPage = isAgentNativeDocsUrl(requestUrl);
+  // rrweb 2.1.0 replays recorded media interactions with `void media.play()`.
+  // Browsers may reject that promise when the recorded media was unmuted and
+  // no user activation is still active, which becomes a source-less unhandled
+  // rejection even though the replay player keeps working. Keep this scoped to
+  // the replay detail route and the exact browser autoplay-policy message.
+  if (
+    isSessionReplayUrl(requestUrl) &&
+    exceptionValues.some((value) => {
+      const exceptionValue = String(value.value ?? "")
+        .trim()
+        .toLowerCase();
+      return (
+        exceptionValue.includes("notallowederror: play() failed") &&
+        exceptionValue.includes("user didn't interact with the document first")
+      );
+    })
+  ) {
+    return true;
+  }
   // AgentAutoContinueSignal is a control-flow sentinel thrown to bubble
   // out of the SSE stream parser when the agent run needs to be
   // auto-continued. It's caught by the chat adapter and is never a real
@@ -867,7 +908,11 @@ export function setSentryUser(
     clearTrackingIdentity();
   }
   _trackingIdentityResolved = true;
-  if (shouldRetryReplay && _sessionReplayOptions?.requireSignedInUser) {
+  if (
+    shouldRetryReplay &&
+    _trackingContentCaptureEnabled &&
+    _sessionReplayOptions?.requireSignedInUser
+  ) {
     void startConfiguredSessionReplay(_sessionReplayOptions);
   }
   if (_sentryInitialized) {
@@ -975,6 +1020,11 @@ export function configureTracking(options: ConfigureTrackingOptions): void {
   if (options.getDefaultProps) {
     _getDefaultProps = options.getDefaultProps;
   }
+  _contentCaptureForPath = options.contentCaptureForPath ?? null;
+  _trackingContentCaptureEnabled =
+    _contentCaptureForPath && typeof window !== "undefined"
+      ? _contentCaptureForPath(window.location.pathname)
+      : options.contentCapture !== false;
   if (typeof window !== "undefined") {
     ensureSentry();
     ensureAmplitude();
@@ -982,14 +1032,37 @@ export function configureTracking(options: ConfigureTrackingOptions): void {
     installLlmConnectionRefresh();
     installTrackingAuthSessionRefresh();
     installPageviewTracking();
-    maybeInstallSessionReplay(options.sessionReplay, {
-      endpoint: options.endpoint,
-      publicKey,
-    });
+    maybeInstallSessionReplay(
+      options.sessionReplay,
+      {
+        endpoint: options.endpoint,
+        publicKey,
+      },
+      _trackingContentCaptureEnabled,
+    );
     maybeInstallErrorCapture(options.errorCapture);
   }
 }
 
+export function setTrackingContentCaptureEnabled(enabled: boolean): void {
+  if (_trackingContentCaptureEnabled === enabled) return;
+  _trackingContentCaptureEnabled = enabled;
+  if (enabled) {
+    if (_sessionReplayOptions) {
+      void startConfiguredSessionReplay(_sessionReplayOptions);
+    }
+  } else {
+    void stopSessionReplay("content-capture-disabled");
+  }
+}
+
+function syncTrackingContentCaptureForLocation(): void {
+  if (!_contentCaptureForPath) return;
+  setTrackingContentCaptureEnabled(
+    _contentCaptureForPath(window.location.pathname),
+  );
+}
+
 /**
  * Lazily load the session-replay module so error capture can read the active
  * replay id and surface manual captures on the replay timeline without a
@@ -1225,11 +1298,12 @@ function replayEndpointFromTrackingEndpoint(value: string): string | undefined {
 function maybeInstallSessionReplay(
   config: boolean | SessionReplayOptions | undefined,
   tracking?: { endpoint?: string; publicKey?: string },
+  start = true,
 ): void {
   if (typeof window === "undefined") return;
   const options = configuredSessionReplayOptions(config, tracking);
-  if (!options) return;
   _sessionReplayOptions = options;
+  if (!options || !start) return;
   void startConfiguredSessionReplay(options);
 }
 
@@ -1255,11 +1329,24 @@ async function startConfiguredSessionReplay(
 ): Promise<SessionReplayStartResult | null> {
   if (_sessionReplayStartPromise) return _sessionReplayStartPromise;
   _sessionReplayStartPromise = (async () => {
+    if (!_trackingContentCaptureEnabled) {
+      return { started: false, reason: "disabled" as const };
+    }
     if (!(await waitForSessionReplayAuthIfRequired(options))) {
       return { started: false, reason: "missing-user-id" as const };
     }
+    if (!_trackingContentCaptureEnabled) {
+      return { started: false, reason: "disabled" as const };
+    }
     const mod = await import("./session-replay.js");
-    return mod.startSessionReplay(options);
+    if (!_trackingContentCaptureEnabled) {
+      return { started: false, reason: "disabled" as const };
+    }
+    return mod.startSessionReplay({
+      ...options,
+      shouldStart: () =>
+        _trackingContentCaptureEnabled && (options.shouldStart?.() ?? true),
+    });
   })()
     .catch(() => ({ started: false, reason: "import-failed" as const }))
     .finally(() => {
@@ -1271,23 +1358,37 @@ async function startConfiguredSessionReplay(
 export async function startSessionReplay(
   options: SessionReplayOptions = {},
 ): Promise<SessionReplayStartResult> {
+  if (!_trackingContentCaptureEnabled) {
+    return { started: false, reason: "disabled" };
+  }
   const configured = configuredSessionReplayOptions(options) ?? options;
   if (!(await waitForSessionReplayAuthIfRequired(configured))) {
     return { started: false, reason: "missing-user-id" };
   }
   const mod = await import("./session-replay.js");
-  return mod.startSessionReplay(configured);
+  return mod.startSessionReplay({
+    ...configured,
+    shouldStart: () =>
+      _trackingContentCaptureEnabled && (configured.shouldStart?.() ?? true),
+  });
 }
 
 export async function maybeStartSessionReplay(
   options: SessionReplayOptions = {},
 ): Promise<SessionReplayStartResult> {
+  if (!_trackingContentCaptureEnabled) {
+    return { started: false, reason: "disabled" };
+  }
   const configured = configuredSessionReplayOptions(options) ?? options;
   if (!(await waitForSessionReplayAuthIfRequired(configured))) {
     return { started: false, reason: "missing-user-id" };
   }
   const mod = await import("./session-replay.js");
-  return mod.maybeStartSessionReplay(configured);
+  return mod.maybeStartSessionReplay({
+    ...configured,
+    shouldStart: () =>
+      _trackingContentCaptureEnabled && (configured.shouldStart?.() ?? true),
+  });
 }
 
 export async function stopSessionReplay(reason = "manual"): Promise<void> {
@@ -1342,15 +1443,17 @@ function pageviewKey(): string {
 
 function pageviewProperties(reason: string): Record<string, unknown> {
   const properties: Record<string, unknown> = {
-    url: scrubUrl(window.location.href),
+    url: !_trackingContentCaptureEnabled
+      ? window.location.origin + window.location.pathname
+      : scrubUrl(window.location.href),
     path: window.location.pathname,
     hostname: window.location.hostname,
     navigation_type: reason,
   };
-  if (window.location.search) {
+  if (_trackingContentCaptureEnabled && window.location.search) {
     properties.search = scrubUrl(window.location.search);
   }
-  if (typeof document !== "undefined") {
+  if (_trackingContentCaptureEnabled && typeof document !== "undefined") {
     if (document.referrer) {
       properties.referrer = scrubUrl(document.referrer);
     }
@@ -1371,6 +1474,9 @@ function emitPageview(reason: string): void {
 }
 
 function schedulePageview(reason: string): void {
+  if (!_trackingContentCaptureEnabled) {
+    void stopSessionReplay("local-plan-privacy");
+  }
   const run = () => emitPageview(reason);
   const pendingStartupContext: Array<Promise<void>> = [];
   if (_llmConnectionRefresh && !_llmConnectionStatus) {
@@ -1407,17 +1513,22 @@ function installPageviewTracking(): void {
 
   window.history.pushState = function pushState(...args) {
     const result = originalPushState.apply(this, args);
+    syncTrackingContentCaptureForLocation();
     schedulePageview("pushState");
     return result;
   };
 
   window.history.replaceState = function replaceState(...args) {
     const result = originalReplaceState.apply(this, args);
+    syncTrackingContentCaptureForLocation();
     schedulePageview("replaceState");
     return result;
   };
 
-  window.addEventListener("popstate", () => schedulePageview("popstate"));
+  window.addEventListener("popstate", () => {
+    syncTrackingContentCaptureForLocation();
+    schedulePageview("popstate");
+  });
 }
 
 function sendAgentNativeAnalytics(

package/corpus/core/src/client/blocks/library/wireframe-kit.tsx

@@ -1511,6 +1511,20 @@ function roundedRectPath(
   ].join(" ");
 }
 
+/** Rough.js cannot safely render paths whose inset consumes the whole box. */
+export function hasDrawableRoughBounds(
+  width: number,
+  height: number,
+  inset: number,
+): boolean {
+  return (
+    Number.isFinite(width) &&
+    Number.isFinite(height) &&
+    width > inset * 2 &&
+    height > inset * 2
+  );
+}
+
 function elementStroke(node: Element, fallback: string): string {
   const explicit = readVar(node, "--rough-stroke");
   if (explicit) return explicit;
@@ -1623,7 +1637,7 @@ function build(
     preserveVertices: true,
   });
 
-  if (opts.drawFrame) {
+  if (opts.drawFrame && hasDrawableRoughBounds(layoutW, layoutH, 2)) {
     const sw = 2;
     push(
       gen.path(
@@ -1647,7 +1661,7 @@ function build(
     const y = (r.top - base.top) / zoom;
     const w = r.width / zoom;
     const h = r.height / zoom;
-    if (w < 2 || h < 2) return;
+    if (!hasDrawableRoughBounds(w, h, 1)) return;
     const kind = inferRoughKind(node);
     const rawStroke = elementStroke(node, sketch);
     const stroke =

package/corpus/core/src/client/chat-model-groups.ts

@@ -21,6 +21,12 @@ export interface BuildChatModelGroupsOptions {
   currentModel?: string;
 }
 
+const HIDDEN_CHAT_MODEL_ENGINES = new Set([
+  "ai-sdk:groq",
+  "ai-sdk:mistral",
+  "ai-sdk:cohere",
+]);
+
 function addCurrentModel(
   models: readonly string[],
   engineName: string,
@@ -93,6 +99,15 @@ function shouldShowDirectEngine(
   engine: ChatModelEngineEntry,
   currentEngineName?: string,
 ): boolean {
+  // Keep a persisted selection usable after an engine is hidden from the
+  // picker; users can choose a supported replacement instead of landing on a
+  // model that no longer has a rendered group.
+  if (
+    HIDDEN_CHAT_MODEL_ENGINES.has(engine.name) &&
+    engine.name !== currentEngineName
+  ) {
+    return false;
+  }
   if (engine.name === currentEngineName) return true;
   if (engine.name === "builder") return false;
   if (engine.name === "ai-sdk:anthropic") return false;
@@ -100,6 +115,18 @@ function shouldShowDirectEngine(
   return true;
 }
 
+function putOpenRouterLast(
+  a: ChatModelEngineEntry,
+  b: ChatModelEngineEntry,
+): number {
+  const aIsOpenRouter = a.name === "ai-sdk:openrouter";
+  const bIsOpenRouter = b.name === "ai-sdk:openrouter";
+  if (aIsOpenRouter === bIsOpenRouter) return 0;
+  if (aIsOpenRouter) return 1;
+  if (bIsOpenRouter) return -1;
+  return 0;
+}
+
 export function buildChatModelGroups({
   engines,
   configuredKeys,
@@ -123,6 +150,7 @@ export function buildChatModelGroups({
   return engines
     .filter((engine) => engine.packageInstalled !== false)
     .filter((engine) => shouldShowDirectEngine(engine, currentEngineName))
+    .sort(putOpenRouterLast)
     .map((engine) => {
       const requiredEnvVars = engine.requiredEnvVars ?? [];
       return {