@agent-native/core 0.78.8 → 0.79.0

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

@@ -59,6 +59,13 @@ type SentryUser = {
   username?: string;
 };
 
+type TrackingIdentity = {
+  userId?: string;
+  userEmail?: string;
+  userName?: string;
+  orgId?: string | null;
+};
+
 let _getDefaultProps: GetDefaultProps | null = null;
 let _agentNativeAnalyticsPublicKey: string | null = null;
 let _agentNativeAnalyticsEndpoint: string | null = null;
@@ -67,6 +74,10 @@ let _sentryInitialized = false;
 let _llmConnectionStatus: LlmConnectionStatus | null = null;
 let _llmConnectionRefresh: Promise<void> | null = null;
 let _llmConnectionRefreshInstalled = false;
+let _trackingIdentity: TrackingIdentity | null = null;
+let _trackingIdentityResolved = false;
+let _trackingSessionRefresh: Promise<void> | null = null;
+let _trackingSessionRefreshInstalled = false;
 // Buffer for setSentryUser calls made before Sentry has initialized.
 // `undefined` means "no pending update"; `null` means "pending clear".
 let _pendingSentryUser: SentryUser | null | undefined = undefined;
@@ -249,6 +260,83 @@ function installLlmConnectionRefresh(): void {
   });
 }
 
+function readTrackingString(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function setTrackingIdentityFromSession(data: unknown): void {
+  const session = data as Record<string, unknown> | null;
+  if (!session || typeof session !== "object" || session.error) {
+    _trackingIdentity = null;
+    return;
+  }
+  const email = readTrackingString(session.email);
+  const authUserId = readTrackingString(session.userId);
+  const userId = email || authUserId;
+  if (!userId) {
+    _trackingIdentity = null;
+    return;
+  }
+  const userName = readTrackingString(session.name);
+  _trackingIdentity = {
+    userId,
+    ...(email ? { userEmail: email } : {}),
+    ...(userName ? { userName } : {}),
+    orgId: readTrackingString(session.orgId) ?? null,
+  };
+}
+
+function refreshTrackingAuthSession(): Promise<void> {
+  if (typeof window === "undefined" || typeof fetch !== "function") {
+    _trackingIdentityResolved = true;
+    return Promise.resolve();
+  }
+  if (_trackingSessionRefresh) return _trackingSessionRefresh;
+  _trackingSessionRefresh = fetch(
+    agentNativePath("/_agent-native/auth/session"),
+  )
+    .then((res) => (res.ok ? res.json() : null))
+    .then((data) => {
+      setTrackingIdentityFromSession(data);
+    })
+    .catch(() => {
+      _trackingIdentity = null;
+    })
+    .finally(() => {
+      _trackingIdentityResolved = true;
+      _trackingSessionRefresh = null;
+    });
+  return _trackingSessionRefresh;
+}
+
+function installTrackingAuthSessionRefresh(): void {
+  if (typeof window === "undefined" || _trackingSessionRefreshInstalled) return;
+  _trackingSessionRefreshInstalled = true;
+  void refreshTrackingAuthSession();
+  window.addEventListener("focus", () => {
+    void refreshTrackingAuthSession();
+  });
+}
+
+function applyTrackingIdentity(
+  properties: Record<string, unknown>,
+): Record<string, unknown> {
+  const identity = _trackingIdentity;
+  if (!identity) return properties;
+  let next = properties;
+  const assign = (key: string, value: unknown) => {
+    if (value !== undefined && value !== null && next[key] === undefined) {
+      if (next === properties) next = { ...properties };
+      next[key] = value;
+    }
+  };
+  assign("userId", identity.userId);
+  assign("userEmail", identity.userEmail);
+  assign("userName", identity.userName);
+  assign("orgId", identity.orgId);
+  return next;
+}
+
 function getOrCreateAnonymousId(): string | undefined {
   if (typeof window === "undefined") return undefined;
   let id = safeStorageGet(ANONYMOUS_ID_STORAGE_KEY);
@@ -665,6 +753,20 @@ export function setSentryUser(
   user: SentryUser | null,
   orgId?: string | null,
 ): void {
+  if (user) {
+    const userId = user.email || user.id;
+    _trackingIdentity = userId
+      ? {
+          userId,
+          ...(user.email ? { userEmail: user.email } : {}),
+          ...(user.username ? { userName: user.username } : {}),
+          orgId: orgId ?? null,
+        }
+      : null;
+  } else {
+    _trackingIdentity = null;
+  }
+  _trackingIdentityResolved = true;
   if (_sentryInitialized) {
     Sentry.setUser(user);
     if (orgId !== undefined) {
@@ -775,6 +877,7 @@ export function configureTracking(options: ConfigureTrackingOptions): void {
     ensureAmplitude();
     captureFirstTouchAttribution();
     installLlmConnectionRefresh();
+    installTrackingAuthSessionRefresh();
     installPageviewTracking();
     maybeInstallSessionReplay(options.sessionReplay, {
       endpoint: options.endpoint,
@@ -791,6 +894,14 @@ function sessionReplayEnabledFromEnv(): boolean {
   return /^(1|true|yes|on)$/i.test((value ?? "").trim());
 }
 
+function sessionReplayRequiresSignedInUserFromEnv(): boolean {
+  const env = (import.meta.env as Record<string, string | undefined>) ?? {};
+  const value =
+    env.VITE_AGENT_NATIVE_SESSION_REPLAY_REQUIRE_AUTH ||
+    env.VITE_SESSION_REPLAY_REQUIRE_AUTH;
+  return /^(1|true|yes|on)$/i.test((value ?? "").trim());
+}
+
 function configuredSessionReplayOptions(
   config: boolean | SessionReplayOptions | undefined,
   tracking: { endpoint?: string; publicKey?: string } = {},
@@ -802,12 +913,22 @@ function configuredSessionReplayOptions(
     : undefined;
   const withTrackingDefaults = (
     options: SessionReplayOptions,
-  ): SessionReplayOptions => ({
-    ...(publicKey && !options.publicKey ? { publicKey } : {}),
-    ...(endpoint && !options.endpoint ? { endpoint } : {}),
-    ...options,
-  });
+  ): SessionReplayOptions => {
+    const extraProperties = replayExtraPropertiesWithDefaults(
+      options.extraProperties,
+    );
+    return {
+      ...(publicKey && !options.publicKey ? { publicKey } : {}),
+      ...(endpoint && !options.endpoint ? { endpoint } : {}),
+      ...options,
+      requireSignedInUser:
+        options.requireSignedInUser ??
+        sessionReplayRequiresSignedInUserFromEnv(),
+      ...(extraProperties ? { extraProperties } : {}),
+    };
+  };
 
+  if (config === false) return null;
   if (config === true) return withTrackingDefaults({});
   if (config && typeof config === "object") {
     if (config.enabled === false) return null;
@@ -816,6 +937,22 @@ function configuredSessionReplayOptions(
   return sessionReplayEnabledFromEnv() ? withTrackingDefaults({}) : null;
 }
 
+function replayExtraPropertiesWithDefaults(
+  source: SessionReplayOptions["extraProperties"],
+): SessionReplayOptions["extraProperties"] {
+  return () => {
+    const rawProps =
+      typeof source === "function"
+        ? source()
+        : source && typeof source === "object"
+          ? source
+          : {};
+    const props = rawProps && typeof rawProps === "object" ? rawProps : {};
+    const withDefaults = _getDefaultProps?.("session_replay", props) ?? props;
+    return applyTrackingIdentity(withDefaults);
+  };
+}
+
 function replayEndpointFromTrackingEndpoint(value: string): string | undefined {
   try {
     const url = new URL(value);
@@ -849,23 +986,60 @@ function maybeInstallSessionReplay(
   if (typeof window === "undefined") return;
   const options = configuredSessionReplayOptions(config, tracking);
   if (!options) return;
-  import("./session-replay.js")
-    .then((mod) => mod.startSessionReplay(options))
-    .catch(() => {});
+  void startConfiguredSessionReplay(options);
+}
+
+async function waitForSessionReplayAuthIfRequired(
+  options: SessionReplayOptions,
+): Promise<boolean> {
+  if (!options.requireSignedInUser) return true;
+  if (_trackingIdentity?.userId) return true;
+  try {
+    if (_trackingSessionRefresh) {
+      await _trackingSessionRefresh;
+    } else if (!_trackingIdentityResolved) {
+      await refreshTrackingAuthSession();
+    }
+  } catch {
+    // best-effort; missing identity below keeps replay off
+  }
+  return !!_trackingIdentity?.userId;
+}
+
+async function startConfiguredSessionReplay(
+  options: SessionReplayOptions,
+): Promise<SessionReplayStartResult | null> {
+  if (!(await waitForSessionReplayAuthIfRequired(options))) {
+    return { started: false, reason: "missing-user-id" };
+  }
+  try {
+    const mod = await import("./session-replay.js");
+    return mod.startSessionReplay(options);
+  } catch {
+    return { started: false, reason: "import-failed" };
+  }
 }
 
 export async function startSessionReplay(
   options: SessionReplayOptions = {},
 ): Promise<SessionReplayStartResult> {
+  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(options);
+  return mod.startSessionReplay(configured);
 }
 
 export async function maybeStartSessionReplay(
   options: SessionReplayOptions = {},
 ): Promise<SessionReplayStartResult> {
+  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(options);
+  return mod.maybeStartSessionReplay(configured);
 }
 
 export async function stopSessionReplay(reason = "manual"): Promise<void> {
@@ -911,7 +1085,7 @@ function resolveProps(
   for (const [key, value] of Object.entries(llmProps)) {
     if (enriched[key] === undefined) enriched[key] = value;
   }
-  return enriched;
+  return applyTrackingIdentity(enriched);
 }
 
 function pageviewKey(): string {
@@ -950,11 +1124,20 @@ function emitPageview(reason: string): void {
 
 function schedulePageview(reason: string): void {
   const run = () => emitPageview(reason);
+  const pendingStartupContext: Array<Promise<void>> = [];
   if (_llmConnectionRefresh && !_llmConnectionStatus) {
+    pendingStartupContext.push(_llmConnectionRefresh);
+  }
+  if (_trackingSessionRefresh && !_trackingIdentityResolved) {
+    pendingStartupContext.push(_trackingSessionRefresh);
+  }
+  if (pendingStartupContext.length > 0) {
     const timeout = new Promise<void>((resolve) =>
       window.setTimeout(resolve, 250),
     );
-    Promise.race([_llmConnectionRefresh, timeout]).finally(run);
+    Promise.race([Promise.allSettled(pendingStartupContext), timeout]).finally(
+      run,
+    );
     return;
   }
   if (typeof queueMicrotask === "function") {

package/corpus/core/src/client/chat/index.ts

@@ -91,6 +91,7 @@ export {
   ACTION_CHAT_UI_DATA_INSIGHTS_RENDERER,
   ACTION_CHAT_UI_DATA_TABLE_RENDERER,
   ACTION_CHAT_UI_DATA_WIDGET_RENDERER,
+  ACTION_CHAT_UI_INLINE_EXTENSION_RENDERER,
   type ActionChatUIConfig,
 } from "../../action-ui.js";
 export {

package/corpus/core/src/client/chat/tool-call-display.tsx

@@ -727,19 +727,22 @@ export function ReconnectStreamMessage({
   content: ContentPart[];
 }) {
   const chatRunning = React.useContext(ChatRunningContext);
+  const streamingTextPartIndex =
+    content.at(-1)?.type === "text" ? content.length - 1 : -1;
 
   return (
     <div className="flex justify-start">
       <div className="max-w-[95%] text-sm leading-relaxed text-foreground space-y-1">
         {content.map((part, i) => {
           if (part.type === "text") {
+            const partStreaming = chatRunning && i === streamingTextPartIndex;
             return (
               <SmoothMarkdownText
                 key={`reconnect-text-${i}`}
                 text={part.text}
-                streaming={chatRunning}
+                streaming={partStreaming}
                 resetKey={`reconnect-text-${i}`}
-                statusType={chatRunning ? "running" : "complete"}
+                statusType={partStreaming ? "running" : "complete"}
               />
             );
           }

package/corpus/core/src/client/chat/widgets/InlineExtensionWidget.tsx

@@ -0,0 +1,139 @@
+import { IconExternalLink, IconSparkles } from "@tabler/icons-react";
+
+import { extensionPath } from "../../../extensions/path.js";
+import { appPath } from "../../api-path.js";
+import { InlineExtensionFrame } from "../../extensions/InlineExtensionFrame.js";
+import type { ToolRendererContext } from "../tool-render-registry.js";
+
+export interface InlineExtensionToolResult {
+  mode: "transient" | "persisted";
+  id: string;
+  name: string;
+  description?: string;
+  content?: string;
+  path?: string;
+  updatedAt?: string;
+  context?: Record<string, unknown>;
+  initialHeight?: number;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+function stringValue(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function recordValue(value: unknown): Record<string, unknown> | undefined {
+  return isRecord(value) ? value : undefined;
+}
+
+function initialHeightValue(value: unknown): number | undefined {
+  const height = Number(value);
+  if (!Number.isFinite(height) || height <= 0) return undefined;
+  return Math.min(Math.max(Math.round(height), 120), 1000);
+}
+
+function normalizeInlineExtension(
+  value: unknown,
+): InlineExtensionToolResult | null {
+  if (!isRecord(value)) return null;
+  const id = stringValue(value.id);
+  const name = stringValue(value.name);
+  if (!id || !name) return null;
+  const mode = value.mode === "transient" ? "transient" : "persisted";
+  const content = stringValue(value.content);
+  if (mode === "transient" && !content) return null;
+  return {
+    mode,
+    id,
+    name,
+    description: stringValue(value.description),
+    content,
+    path: stringValue(value.path),
+    updatedAt: stringValue(value.updatedAt),
+    context: recordValue(value.context),
+    initialHeight: initialHeightValue(value.initialHeight),
+  };
+}
+
+export function normalizeInlineExtensionToolResult(
+  context: ToolRendererContext,
+): InlineExtensionToolResult | null {
+  const result = context.resultJson;
+  if (!isRecord(result)) return null;
+
+  const inline = normalizeInlineExtension(result.inlineExtension);
+  if (inline) return inline;
+
+  if (isRecord(result.extension)) {
+    const id = stringValue(result.extension.id);
+    const name = stringValue(result.extension.name);
+    if (!id || !name) return null;
+    return {
+      mode: "persisted",
+      id,
+      name,
+      description: stringValue(result.extension.description),
+      path:
+        stringValue(result.extension.path) ??
+        stringValue(result.path) ??
+        extensionPath(id, name),
+      updatedAt: stringValue(result.extension.updatedAt),
+      context: recordValue(result.context),
+      initialHeight: initialHeightValue(result.initialHeight),
+    };
+  }
+
+  return null;
+}
+
+export function InlineExtensionWidget({
+  context,
+}: {
+  context: ToolRendererContext;
+}) {
+  const result = normalizeInlineExtensionToolResult(context);
+  if (!result) return null;
+
+  const href = result.path ? appPath(result.path) : undefined;
+
+  return (
+    <div className="my-1.5 overflow-hidden rounded-lg border border-border bg-background text-foreground shadow-sm">
+      <div className="flex items-center gap-2 border-b border-border px-3 py-2">
+        <IconSparkles className="h-4 w-4 shrink-0 text-muted-foreground" />
+        <div className="min-w-0 flex-1">
+          <div className="truncate text-sm font-medium">{result.name}</div>
+          {result.description ? (
+            <div className="truncate text-[11px] text-muted-foreground">
+              {result.description}
+            </div>
+          ) : null}
+        </div>
+        {href ? (
+          <a
+            href={href}
+            className="inline-flex h-8 w-8 shrink-0 items-center justify-center rounded-md text-muted-foreground hover:bg-accent hover:text-accent-foreground"
+            aria-label="Open extension"
+          >
+            <IconExternalLink className="h-4 w-4" />
+          </a>
+        ) : null}
+      </div>
+      <InlineExtensionFrame
+        extensionId={result.mode === "persisted" ? result.id : undefined}
+        extension={{
+          id: result.id,
+          name: result.name,
+          description: result.description,
+          content: result.mode === "transient" ? result.content : undefined,
+          updatedAt: result.updatedAt,
+          mode: result.mode,
+        }}
+        context={result.context}
+        initialHeight={result.initialHeight ?? 260}
+      />
+    </div>
+  );
+}

package/corpus/core/src/client/chat/widgets/builtin-tool-renderers.tsx

@@ -3,6 +3,7 @@ import {
   ACTION_CHAT_UI_DATA_INSIGHTS_RENDERER,
   ACTION_CHAT_UI_DATA_TABLE_RENDERER,
   ACTION_CHAT_UI_DATA_WIDGET_RENDERER,
+  ACTION_CHAT_UI_INLINE_EXTENSION_RENDERER,
 } from "../../../action-ui.js";
 import {
   registerReservedActionChatRenderer,
@@ -21,6 +22,10 @@ import {
 import { DataChartWidget } from "./DataChartWidget.js";
 import { DataInsightsWidget } from "./DataInsightsWidget.js";
 import { DataTableWidget } from "./DataTableWidget.js";
+import {
+  InlineExtensionWidget,
+  normalizeInlineExtensionToolResult,
+} from "./InlineExtensionWidget.js";
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return !!value && typeof value === "object" && !Array.isArray(value);
@@ -101,6 +106,11 @@ function renderDataWidget(context: ToolRendererContext) {
 const BuiltinDataWidgetRenderer: ToolRendererComponent = ({ context }) =>
   renderDataWidget(context);
 
+const BuiltinInlineExtensionRenderer: ToolRendererComponent = ({ context }) =>
+  normalizeInlineExtensionToolResult(context) ? (
+    <InlineExtensionWidget context={context} />
+  ) : null;
+
 export function isBuiltinDataWidgetActionRenderer(
   context: ToolRendererContext,
 ): boolean {
@@ -116,6 +126,12 @@ export function isBuiltinDataWidgetActionRenderer(
 export function resolveBuiltinActionChatRenderer(
   context: ToolRendererContext,
 ): ToolRendererComponent | null {
+  if (
+    context.chatUI?.renderer === ACTION_CHAT_UI_INLINE_EXTENSION_RENDERER &&
+    normalizeInlineExtensionToolResult(context)
+  ) {
+    return BuiltinInlineExtensionRenderer;
+  }
   if (
     isBuiltinDataWidgetActionRenderer(context) &&
     normalizeActionDataWidgetResult(context)
@@ -128,6 +144,12 @@ export function resolveBuiltinActionChatRenderer(
 export function resolveBuiltinFallbackToolRenderer(
   context: ToolRendererContext,
 ): ToolRendererComponent | null {
+  if (
+    context.chatUI?.renderer === ACTION_CHAT_UI_INLINE_EXTENSION_RENDERER &&
+    normalizeInlineExtensionToolResult(context)
+  ) {
+    return BuiltinInlineExtensionRenderer;
+  }
   return normalizeActionDataWidgetResult(context) !== null
     ? BuiltinDataWidgetRenderer
     : null;
@@ -138,11 +160,15 @@ for (const [id, renderer] of [
   ["core.data-chart", ACTION_CHAT_UI_DATA_CHART_RENDERER],
   ["core.data-insights", ACTION_CHAT_UI_DATA_INSIGHTS_RENDERER],
   ["core.data-widget", ACTION_CHAT_UI_DATA_WIDGET_RENDERER],
+  ["core.inline-extension", ACTION_CHAT_UI_INLINE_EXTENSION_RENDERER],
 ] as const) {
   registerReservedActionChatRenderer({
     id,
     renderer,
-    Component: BuiltinDataWidgetRenderer,
+    Component:
+      renderer === ACTION_CHAT_UI_INLINE_EXTENSION_RENDERER
+        ? BuiltinInlineExtensionRenderer
+        : BuiltinDataWidgetRenderer,
   });
 }
 

package/corpus/core/src/client/conversation/AgentConversation.tsx

@@ -13,6 +13,11 @@ import React from "react";
 import ReactMarkdown, { defaultUrlTransform } from "react-markdown";
 import remarkGfm from "remark-gfm";
 
+import { resolveToolRenderer } from "../chat/tool-render-registry.js";
+import {
+  resolveBuiltinActionChatRenderer,
+  resolveBuiltinFallbackToolRenderer,
+} from "../chat/widgets/builtin-tool-renderers.js";
 import { HighlightedCodeBlock as SharedHighlightedCodeBlock } from "../HighlightedCodeBlock.js";
 import { McpAppRenderer } from "../mcp-apps/McpAppRenderer.js";
 import { humanizeToolName } from "../tool-display.js";
@@ -356,7 +361,40 @@ function openMarkdownLink(
   window.open(url.href, "_blank", "noopener,noreferrer");
 }
 
+function parseJsonText(value: string | undefined): unknown {
+  if (!value) return null;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+
+function parseJsonObject(value: string | undefined): Record<string, unknown> {
+  const parsed = parseJsonText(value);
+  return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+    ? (parsed as Record<string, unknown>)
+    : {};
+}
+
 function ConversationToolCall({ tool }: { tool: AgentConversationToolCall }) {
+  const resultJson = parseJsonText(tool.result);
+  const nativeToolContext = {
+    toolName: tool.name,
+    args: tool.args ?? parseJsonObject(tool.input),
+    resultText: tool.result,
+    resultJson: tool.resultJson ?? resultJson,
+    isRunning: tool.state === "running" || tool.state === "activity",
+    chatUI: tool.chatUI,
+  };
+  const NativeToolRenderer =
+    resolveBuiltinActionChatRenderer(nativeToolContext) ??
+    resolveToolRenderer(nativeToolContext) ??
+    resolveBuiltinFallbackToolRenderer(nativeToolContext);
+  if (NativeToolRenderer) {
+    return <NativeToolRenderer context={nativeToolContext} />;
+  }
+
   const hasDetails = Boolean(tool.input || tool.result || tool.mcpApp);
   const icon =
     tool.state === "running" || tool.state === "activity" ? (

package/corpus/core/src/client/conversation/code-agent-transcript.ts

@@ -175,9 +175,12 @@ function toConversationTool(
         : item.state === "activity"
           ? "activity"
           : "running",
+    args: recordValue(item.input),
     input: preview(item.input),
+    resultJson: item.result,
     result: preview(item.result),
     ...(item.mcpApp ? { mcpApp: item.mcpApp } : {}),
+    ...(item.chatUI ? { chatUI: item.chatUI } : {}),
     summary:
       item.state === "completed"
         ? "finished"
@@ -229,6 +232,12 @@ function toConversationArtifact(
   };
 }
 
+function recordValue(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+
 function preview(value: unknown): string | undefined {
   if (value === undefined || value === null) return undefined;
   const text =

package/corpus/core/src/client/conversation/types.ts

@@ -1,5 +1,6 @@
 import type { ReactNode } from "react";
 
+import type { ActionChatUIConfig } from "../../action-ui.js";
 import type { AgentMcpAppPayload } from "../../mcp-client/app-result.js";
 
 export interface AgentConversationAttachment {
@@ -23,8 +24,11 @@ export interface AgentConversationToolCall {
   name: string;
   state: AgentConversationToolState;
   input?: string;
+  args?: Record<string, unknown>;
   result?: string;
+  resultJson?: unknown;
   mcpApp?: AgentMcpAppPayload;
+  chatUI?: ActionChatUIConfig;
   summary?: string;
 }