@agent-native/core 0.78.9 → 0.79.0

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

@@ -573,6 +573,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/session-replay.ts

@@ -38,7 +38,8 @@ interface SessionReplayState {
   active: boolean;
   replayId: string | null;
   sequence: number;
-  queue: ReplayEvent[];
+  /** Pre-serialized + scrubbed event JSON strings, ready to splice at flush. */
+  queue: string[];
   queuedBytes: number;
   flushTimer: number | null;
   maxDurationTimer: number | null;
@@ -55,10 +56,14 @@ interface StoredReplaySession {
   sequence?: number;
 }
 
+/** rrweb `sampling` shape (mousemove/scroll/media throttles, input strategy). */
+export type ReplayEventSampling = Record<string, unknown>;
+
 export interface SessionReplayOptions {
   enabled?: boolean;
   publicKey?: string;
   endpoint?: string;
+  requireSignedInUser?: boolean;
   sampleRate?: number;
   samplingSalt?: string;
   allowUrls?: SessionReplayUrlMatcher[];
@@ -78,6 +83,13 @@ export interface SessionReplayOptions {
   recordCrossOriginIframes?: boolean;
   collectFonts?: boolean;
   inlineImages?: boolean;
+  /**
+   * rrweb per-event throttling (distinct from `sampleRate`, which decides
+   * whether a whole session records). Throttles high-frequency event types
+   * (mousemove/scroll/input) to keep the recorded page responsive and the
+   * payloads small. Passed straight through to `rrweb.record({ sampling })`.
+   */
+  eventSampling?: ReplayEventSampling;
   extraProperties?:
     | Record<string, unknown>
     | (() => Record<string, unknown> | undefined);
@@ -90,6 +102,7 @@ export interface SessionReplayStartResult {
     | "not-browser"
     | "missing-public-key"
     | "missing-session-id"
+    | "missing-user-id"
     | "sampled-out"
     | "url-blocked"
     | "already-active"
@@ -103,6 +116,7 @@ export interface SessionReplayStartResult {
 interface NormalizedSessionReplayOptions {
   publicKey: string;
   endpoint: string;
+  requireSignedInUser: boolean;
   sampleRate: number;
   samplingSalt: string;
   allowUrls: SessionReplayUrlMatcher[];
@@ -122,11 +136,25 @@ interface NormalizedSessionReplayOptions {
   recordCrossOriginIframes: boolean;
   collectFonts: boolean;
   inlineImages: boolean;
+  eventSampling: ReplayEventSampling;
   extraProperties?: SessionReplayOptions["extraProperties"];
 }
 
 const DEFAULT_REPLAY_PATH = "/api/analytics/replay";
 const DEFAULT_SAMPLING_SALT = "agent-native-session-replay";
+
+/**
+ * Default rrweb event throttling. Without this, rrweb captures every
+ * mousemove/scroll which dominates event volume and main-thread cost on
+ * interactive pages. These caps keep replays faithful while staying light.
+ */
+const DEFAULT_EVENT_SAMPLING: ReplayEventSampling = {
+  mousemove: 50,
+  mouseInteraction: true,
+  scroll: 100,
+  media: 800,
+  input: "last",
+};
 const SESSION_REPLAY_STATE_KEY = Symbol.for(
   "agent-native.client.sessionReplay",
 );
@@ -278,6 +306,14 @@ function readEnvNumber(key: string): number | undefined {
   return Number.isFinite(value) ? value : undefined;
 }
 
+function readEnvBoolean(key: string): boolean | undefined {
+  const raw = readEnvString(key);
+  if (!raw) return undefined;
+  if (/^(1|true|yes|on)$/i.test(raw)) return true;
+  if (/^(0|false|no|off)$/i.test(raw)) return false;
+  return undefined;
+}
+
 function readFirstEnvString(keys: string[]): string | undefined {
   for (const key of keys) {
     const value = readEnvString(key);
@@ -399,6 +435,11 @@ function normalizeOptions(
   return {
     publicKey,
     endpoint,
+    requireSignedInUser:
+      options.requireSignedInUser ??
+      readEnvBoolean("VITE_AGENT_NATIVE_SESSION_REPLAY_REQUIRE_AUTH") ??
+      readEnvBoolean("VITE_SESSION_REPLAY_REQUIRE_AUTH") ??
+      false,
     sampleRate: clampSamplingRate(
       options.sampleRate ??
         readFirstEnvNumber([
@@ -451,6 +492,7 @@ function normalizeOptions(
     recordCrossOriginIframes: options.recordCrossOriginIframes ?? false,
     collectFonts: options.collectFonts ?? false,
     inlineImages: options.inlineImages ?? false,
+    eventSampling: options.eventSampling ?? DEFAULT_EVENT_SAMPLING,
     extraProperties: options.extraProperties,
   };
 }
@@ -490,15 +532,25 @@ function scrubReplayValue(
   return out;
 }
 
-function scrubReplayEvent(event: ReplayEvent): ReplayEvent {
-  return scrubReplayValue(event) as ReplayEvent;
+/**
+ * JSON.stringify replacer that scrubs URL-like string values inline. Folding
+ * the scrub into the single serialization pass avoids a separate deep-clone of
+ * every emitted event (FullSnapshots are large DOM trees) on the hot path.
+ */
+function scrubReplayReplacer(key: string, value: unknown): unknown {
+  return typeof value === "string" ? scrubStringValue(key, value) : value;
 }
 
-function estimateJsonBytes(value: unknown): number {
+/**
+ * Serialize + scrub one event in a single pass. The resulting string is stored
+ * directly on the queue and reused verbatim at flush, so each event is
+ * stringified exactly once (was: deep-clone + size-stringify + flush-stringify).
+ */
+function serializeReplayEvent(event: ReplayEvent): string {
   try {
-    return JSON.stringify(value).length;
+    return JSON.stringify(event, scrubReplayReplacer);
   } catch {
-    return 0;
+    return "";
   }
 }
 
@@ -507,15 +559,16 @@ function enqueueReplayEvent(
   event: ReplayEvent,
 ): void {
   if (!state.options) return;
-  const sanitized = scrubReplayEvent(event);
-  const estimatedBytes = estimateJsonBytes(sanitized);
+  const serialized = serializeReplayEvent(event);
+  if (!serialized) return;
+  const estimatedBytes = serialized.length;
   if (
     state.queue.length > 0 &&
     state.queuedBytes + estimatedBytes > state.options.maxBatchBytes
   ) {
     void flushSessionReplay("max-bytes");
   }
-  state.queue.push(sanitized);
+  state.queue.push(serialized);
   state.queuedBytes += estimatedBytes;
   if (state.queue.length >= state.options.maxEventsPerBatch) {
     void flushSessionReplay("max-events");
@@ -536,20 +589,27 @@ function replayExtraProperties(
   }
 }
 
+function replayString(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim() ? value : undefined;
+}
+
 function buildReplayBody(
   state: SessionReplayState,
   reason: string,
-  events: ReplayEvent[],
+  eventJsonParts: string[],
 ): string | null {
   const options = state.options;
   if (!options || !state.replayId) return null;
   const sessionId = getAnalyticsSessionId();
   if (!sessionId) return null;
-  const body = {
+  const properties = replayExtraProperties(options);
+  const userId = replayString(properties?.userId ?? properties?.user_id);
+  const envelope = {
     publicKey: options.publicKey,
     type: "session_replay",
     replayId: state.replayId,
     sessionId,
+    ...(userId ? { userId } : {}),
     anonymousId: getAnalyticsAnonymousId(),
     sequence: state.sequence,
     reason,
@@ -560,12 +620,14 @@ function buildReplayBody(
         ? scrubUrl(window.location.href)
         : undefined,
     timestamp: new Date().toISOString(),
-    properties: replayExtraProperties(options),
-    events,
+    properties,
   };
   state.sequence += 1;
   persistReplaySequence(sessionId, state.replayId, state.sequence);
-  return JSON.stringify(body);
+  // Events are already serialized+scrubbed JSON strings; splice them into the
+  // envelope without re-serializing the (potentially large) events array.
+  const envelopeJson = JSON.stringify(envelope);
+  return `${envelopeJson.slice(0, -1)},"events":[${eventJsonParts.join(",")}]}`;
 }
 
 function isFinalFlushReason(reason: string): boolean {
@@ -673,6 +735,18 @@ export async function startSessionReplay(
   if (!sampled) {
     return { started: false, reason: "sampled-out", sessionId, sampled };
   }
+  if (normalized.requireSignedInUser) {
+    const properties = replayExtraProperties(normalized);
+    const userId = replayString(properties?.userId ?? properties?.user_id);
+    if (!userId) {
+      return {
+        started: false,
+        reason: "missing-user-id",
+        sessionId,
+        sampled,
+      };
+    }
+  }
   if (!isUrlRecordable(window.location.href, normalized)) {
     return { started: false, reason: "url-blocked", sessionId, sampled };
   }
@@ -707,6 +781,7 @@ export async function startSessionReplay(
   try {
     const stopRecorder = rrweb.record({
       emit: (event) => enqueueReplayEvent(state, event),
+      sampling: normalized.eventSampling,
       checkoutEveryNth: normalized.checkoutEveryNth,
       checkoutEveryNms: normalized.checkoutEveryNms,
       blockSelector: normalized.blockSelector,

package/corpus/core/src/code-agents/transcript-normalizer.ts

@@ -1,3 +1,7 @@
+import {
+  normalizeActionChatUIConfig,
+  type ActionChatUIConfig,
+} from "../action-ui.js";
 import type { CodeAgentTranscriptEvent } from "../cli/code-agent-runs.js";
 import type { AgentMcpAppPayload } from "../mcp-client/app-result.js";
 
@@ -47,6 +51,7 @@ export interface NormalizedCodeAgentToolEvent extends NormalizedCodeAgentTranscr
   input?: unknown;
   result?: unknown;
   mcpApp?: AgentMcpAppPayload;
+  chatUI?: ActionChatUIConfig;
   activities: string[];
   startedAt?: string;
   completedAt?: string;
@@ -297,6 +302,8 @@ function appendToolEvent(
   }
   const mcpApp = mcpAppMetadata(event.metadata);
   if (mcpApp) item.mcpApp = mcpApp;
+  const chatUI = chatUIMetadata(event.metadata);
+  if (chatUI) item.chatUI = chatUI;
   const doneMeta = structuredMetadata(event.metadata);
   if (doneMeta) item.structuredMeta = doneMeta;
 }
@@ -322,6 +329,7 @@ function createToolEvent(
     input: hasMetadataKey(metadata, "input") ? metadata?.input : undefined,
     result: hasMetadataKey(metadata, "result") ? metadata?.result : undefined,
     mcpApp: mcpAppMetadata(metadata),
+    chatUI: chatUIMetadata(metadata),
     activities: toolType === "activity" ? [event.message] : [],
     startedAt: toolType === "tool_start" ? event.createdAt : undefined,
     completedAt: toolType === "tool_done" ? event.createdAt : undefined,
@@ -627,3 +635,9 @@ function mcpAppMetadata(
   }
   return candidate as AgentMcpAppPayload;
 }
+
+function chatUIMetadata(
+  metadata: Record<string, unknown> | undefined,
+): ActionChatUIConfig | undefined {
+  return normalizeActionChatUIConfig(metadata?.chatUI);
+}

package/corpus/core/src/extensions/actions.ts

@@ -1,3 +1,4 @@
+import { ACTION_CHAT_UI_INLINE_EXTENSION_RENDERER } from "../action-ui.js";
 import type { ActionRunContext } from "../action.js";
 import type { ActionEntry } from "../agent/production-agent.js";
 import type { AgentChatAttachment } from "../agent/types.js";
@@ -256,10 +257,196 @@ export function createExtensionActionEntries(): Record<string, ActionEntry> {
       readOnly: true,
     },
 
+    "render-inline-extension": {
+      tool: {
+        description:
+          "Render a one-time, transient sandboxed Alpine.js mini-app directly inside the chat. Use this for generated UI that should answer the current turn inline without saving anything to the Extensions view: calculators, adjustable controls, knobs, pickers, visualizers, temporary dashboards, and interactive results. The content must be a self-contained Alpine.js HTML body snippet that can use appAction(), appFetch(), dbQuery(), dbExec(), extensionFetch(), extensionData, agentNative.ui.output(value, opts?), and agentNative.chat.send()/sendToAgentChat(). Use agentNative.ui.output for passive current values from knobs, sliders, and selections; it writes application state at inline-ui:<inline extension id>:output, which the agent can read later with readAppState when the user says to use that value. Use agentNative.chat.send for visible submit/apply actions. For transient UIs, extensionData is browser-local throwaway state; use application_state/appFetch, appAction, ui.output, or chat.send for anything the agent or app must observe. Use semantic Tailwind colors (bg-background, text-foreground, bg-primary, etc.) so it inherits the parent app theme. Use create-extension instead when the user wants the UI saved or reusable.",
+        parameters: {
+          type: "object",
+          properties: {
+            name: {
+              type: "string",
+              description: "Short display name for the inline UI.",
+            },
+            description: {
+              type: "string",
+              description: "One-sentence summary of what the inline UI does.",
+            },
+            content: {
+              type: "string",
+              description:
+                "Self-contained Alpine.js HTML body snippet. Do not include a full app build, React code, or source files. Required unless contentFromAttachment is set.",
+            },
+            contentFromAttachment: {
+              type: "string",
+              description:
+                'Render a pasted/attached HTML file verbatim without re-typing it. Set to an attachment name or "latest".',
+            },
+            context: {
+              type: "string",
+              description:
+                "Optional JSON object passed to the iframe as slotContext for initial inputs from chat.",
+            },
+            initialHeight: {
+              type: "number",
+              description:
+                "Optional initial iframe height in pixels before auto-resize reports. Defaults to 260.",
+            },
+          },
+          required: ["name"],
+        },
+      },
+      chatUI: {
+        renderer: ACTION_CHAT_UI_INLINE_EXTENSION_RENDERER,
+        title: "Inline extension",
+      },
+      maxResultChars: 220_000,
+      readOnly: true,
+      run: async (args, ctx) => {
+        const name = String(args?.name ?? "").trim();
+        if (!name) return "Error: name is required.";
+        const resolved = resolveExtensionContent(args, ctx);
+        if ("error" in resolved) return resolved.error;
+        const content = resolved.content.trim();
+        if (!content) return "Error: content is required.";
+        const description = String(args?.description ?? "").trim();
+        const id = `inline-${Date.now().toString(36)}-${Math.random()
+          .toString(36)
+          .slice(2, 8)}`;
+        return {
+          ok: true,
+          inlineExtension: {
+            mode: "transient",
+            id,
+            name,
+            description,
+            content,
+            context: parseInlineContext(args?.context),
+            initialHeight: coerceInlineHeight(args?.initialHeight),
+          },
+          next: "Rendered inline in chat only. It is not saved in the Extensions view.",
+        };
+      },
+    },
+
+    "show-extension-inline": {
+      tool: {
+        description:
+          "Render an existing saved extension inline in the chat. Use this when the user asks to load, reopen, reuse, or show a saved extension/widget/dashboard/calculator/mini-app in the conversation. Inline extensions can expose passive current values through agentNative.ui.output(value, opts?), which writes application state at inline-ui:<extension id>:output for the agent to read later with readAppState. Pass id when known; otherwise pass a search string and the action will use the best visible extension match.",
+        parameters: {
+          type: "object",
+          properties: {
+            id: {
+              type: "string",
+              description: "Extension id to render inline.",
+            },
+            search: {
+              type: "string",
+              description:
+                "Fallback search matched against id, name, description, and owner email when id is unknown.",
+            },
+            context: {
+              type: "string",
+              description:
+                "Optional JSON object passed to the iframe as slotContext for chat-provided inputs.",
+            },
+            initialHeight: {
+              type: "number",
+              description:
+                "Optional initial iframe height in pixels before auto-resize reports. Defaults to 260.",
+            },
+          },
+        },
+      },
+      chatUI: {
+        renderer: ACTION_CHAT_UI_INLINE_EXTENSION_RENDERER,
+        title: "Inline extension",
+      },
+      readOnly: true,
+      run: async (args) => {
+        let id = String(args?.id ?? "").trim();
+        const search = String(args?.search ?? "")
+          .trim()
+          .toLowerCase();
+
+        if (!id && search) {
+          const hiddenIds = await getHiddenExtensionIdsForCurrentUser();
+          const rows: Array<ExtensionRow | LocalExtensionRow> = [
+            ...(await listExtensions({
+              includeHidden: false,
+              includeGloballyHidden: false,
+            })),
+            ...(await listLocalExtensions()),
+          ];
+          const match = rows.find((row) =>
+            [row.id, row.name, row.description, row.ownerEmail]
+              .join("\n")
+              .toLowerCase()
+              .includes(search),
+          );
+          if (match) {
+            id = match.id;
+          } else {
+            return {
+              ok: false,
+              error: `No extension matched "${args?.search}".`,
+              available: await Promise.all(
+                rows
+                  .slice(0, 10)
+                  .map((row) => summarizeExtension(row, hiddenIds, false)),
+              ),
+            };
+          }
+        }
+
+        if (!id) return "Error: provide id or search.";
+
+        const localExtension = await getLocalExtension(id);
+        const hiddenIds = await getHiddenExtensionIdsForCurrentUser();
+        if (localExtension) {
+          const summary = await summarizeExtension(
+            localExtension,
+            hiddenIds,
+            false,
+          );
+          return {
+            ok: true,
+            inlineExtension: {
+              mode: "persisted",
+              id: summary.id,
+              name: summary.name,
+              description: summary.description,
+              path: summary.path,
+              updatedAt: summary.updatedAt,
+              context: parseInlineContext(args?.context),
+              initialHeight: coerceInlineHeight(args?.initialHeight),
+            },
+          };
+        }
+
+        const extension = await getExtension(id);
+        if (!extension) return `Error: extension not found: ${id}`;
+        const summary = await summarizeExtension(extension, hiddenIds, false);
+        return {
+          ok: true,
+          inlineExtension: {
+            mode: "persisted",
+            id: summary.id,
+            name: summary.name,
+            description: summary.description,
+            path: summary.path,
+            updatedAt: summary.updatedAt,
+            context: parseInlineContext(args?.context),
+            initialHeight: coerceInlineHeight(args?.initialHeight),
+          },
+        };
+      },
+    },
+
     "create-extension": {
       tool: {
         description:
-          'Create a sandboxed Alpine.js mini-app extension. Use this when the user asks to create, build, or make an extension/widget/dashboard/calculator. Call this action exactly once per requested extension. The content must be a self-contained Alpine.js HTML body snippet that can use appAction(), appFetch(), dbQuery(), dbExec(), extensionFetch(), and extensionData. IMPORTANT — hosting a pasted file: if the user pasted a large HTML/Alpine file (it appears in your context as an <attachment name="pasted-text-…"> block) and asked you to host it as-is, do NOT copy that file into `content`. Instead leave `content` empty and pass `contentFromAttachment` set to that attachment\'s name (or the literal "latest" for the most recent pasted block) — the server reads the file verbatim. Re-emitting a large pasted file as `content` regularly gets cut off mid-stream and stalls the turn. Prefer appAction(name, params) for app data and actions, including read actions mounted as GET; do not call template /api/* routes from appFetch because the extension bridge only allows framework /_agent-native/* paths. Parse JSON string action results before aggregating; use dbQuery()/dbExec() only for known existing SQL tables. Keep the initial create-extension payload compact and working; for complex extensions, create a useful v1 first, then use focused update-extension edits for refinements rather than assembling one enormous tool input. For any non-trivial component (more than a couple of state fields, any methods, any string formatting, any branching) put the component in a <script> block via Alpine.data(\'name\', () => ({...})) and reference it with x-data="name" — do NOT cram methods, template literals, or branching logic into an inline x-data="{...}" attribute (HTML parser pitfalls cause ReferenceError failures). Define every variable referenced from x-text/x-show/x-if/x-for on the data object\'s initial state. If the extension\'s value depends on an LLM call, require a real key via \\${keys.OPENAI_API_KEY}/\\${keys.ANTHROPIC_API_KEY} (and tell the user to add it in the Dispatch Vault, or in app Settings → API Keys & Connections for standalone apps, if missing) or route the AI work to the agent chat — never ship a stubbed analysis step that renders a placeholder/boolean as the result.',
+          'Create a persisted sandboxed Alpine.js mini-app extension and render it inline in the chat. Use this when the user wants generated UI that should be saved, reusable, or visible in the Extensions view: extensions, widgets, dashboards, calculators, mini-apps, and reusable interactive utilities. For one-time chat-only UI, use render-inline-extension instead. The content must be a self-contained Alpine.js HTML body snippet that can use appAction(), appFetch(), dbQuery(), dbExec(), extensionFetch(), extensionData, agentNative.ui.output(value, opts?), and agentNative.chat.send()/sendToAgentChat(). Use agentNative.ui.output for passive current values from knobs, sliders, and selections; it writes application state at inline-ui:<extension id>:output, which the agent can read later with readAppState when the user says to use that value. Use agentNative.chat.send for visible submit/apply actions. Persist reusable user-edited state with extensionData: if the extension has checkboxes, todos, notes, filters, preferences, or any control whose value should survive reload/reopen, load that state on init and save changes with extensionData, usually at user scope, instead of keeping it only in Alpine state. IMPORTANT — hosting a pasted file: if the user pasted a large HTML/Alpine file (it appears in your context as an <attachment name="pasted-text-…"> block) and asked you to host it as-is, do NOT copy that file into `content`. Instead leave `content` empty and pass `contentFromAttachment` set to that attachment\'s name (or the literal "latest" for the most recent pasted block) — the server reads the file verbatim. Re-emitting a large pasted file as `content` regularly gets cut off mid-stream and stalls the turn. Prefer appAction(name, params) for app data and actions, including read actions mounted as GET; do not call template /api/* routes from appFetch because the extension bridge only allows framework /_agent-native/* paths. Parse JSON string action results before aggregating; use dbQuery()/dbExec() only for known existing SQL tables. Keep the initial create-extension payload compact and working; for complex extensions, create a useful v1 first, then use focused update-extension edits for refinements rather than assembling one enormous initial tool input. For any non-trivial component (more than a couple of state fields, any methods, any string formatting, any branching) put the component in a <script> block via Alpine.data(\'name\', () => ({...})) and reference it with x-data="name" — do NOT cram methods, template literals, or branching logic into an inline x-data="{...}" attribute (HTML parser pitfalls cause ReferenceError failures). Define every variable referenced from x-text/x-show/x-if/x-for on the data object\'s initial state. If the extension\'s value depends on an LLM call, require a real key via \\${keys.OPENAI_API_KEY}/\\${keys.ANTHROPIC_API_KEY} (and tell the user to add it in the Dispatch Vault, or in app Settings → API Keys & Connections for standalone apps, if missing) or route the AI work to the agent chat — never ship a stubbed analysis step that renders a placeholder/boolean as the result.',
         parameters: {
           type: "object",
           properties: {
@@ -290,6 +477,10 @@ export function createExtensionActionEntries(): Record<string, ActionEntry> {
           required: ["name"],
         },
       },
+      chatUI: {
+        renderer: ACTION_CHAT_UI_INLINE_EXTENSION_RENDERER,
+        title: "Extension",
+      },
       run: async (args, ctx) => {
         const name = String(args?.name ?? "").trim();
         if (!name) return "Error: name is required.";
@@ -1010,6 +1201,32 @@ function coerceBoolean(value: unknown): boolean {
   return value === true || value === "true";
 }
 
+function parseInlineContext(
+  value: unknown,
+): Record<string, unknown> | undefined {
+  if (value === undefined || value === null || value === "") return undefined;
+  const parsed =
+    typeof value === "string"
+      ? (() => {
+          try {
+            return JSON.parse(value);
+          } catch {
+            return undefined;
+          }
+        })()
+      : value;
+  return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+    ? (parsed as Record<string, unknown>)
+    : undefined;
+}
+
+function coerceInlineHeight(value: unknown): number | undefined {
+  if (value === undefined || value === null || value === "") return undefined;
+  const height = Number(value);
+  if (!Number.isFinite(height) || height <= 0) return undefined;
+  return Math.min(Math.max(Math.round(height), 120), 1000);
+}
+
 function coerceLimit(value: unknown): number {
   const limit = Number(value ?? 100);
   if (!Number.isFinite(limit)) return 100;

package/corpus/core/src/extensions/html-shell.ts

@@ -425,6 +425,53 @@ export function buildExtensionHtml(
 	      return res.body;
 	    }
 
+	    function sendToChat(message, options) {
+	      options = options || {};
+	      var text = typeof message === 'string' ? message : JSON.stringify(message);
+	      window.parent.postMessage({
+	        type: 'agent-native-send-to-chat',
+	        message: text,
+	        context: options.context,
+	        submit: options.submit !== false,
+	        openSidebar: options.openSidebar !== false,
+	      }, '*');
+	      return { ok: true };
+	    }
+
+	    function inlineUiOutputKey() {
+	      var safeId = String(_extensionId || 'unknown').replace(/[^A-Za-z0-9_:-]/g, '') || 'unknown';
+	      return 'inline-ui:' + safeId + ':output';
+	    }
+
+	    async function outputToUi(value, options) {
+	      options = options || {};
+	      var key = inlineUiOutputKey();
+	      var payload = {
+	        value: value,
+	        updatedAt: new Date().toISOString(),
+	        extensionId: _extensionId,
+	        source: 'inline-ui',
+	      };
+	      if (options.label !== undefined) payload.label = options.label;
+	      if (options.context !== undefined) payload.context = options.context;
+	      if (options.meta !== undefined) payload.meta = options.meta;
+	      var output = await appFetch('/_agent-native/application-state/' + key, {
+	        method: 'PUT',
+	        headers: { 'X-Request-Source': 'inline-ui' },
+	        body: JSON.stringify(payload),
+	      });
+	      try {
+	        window.parent.postMessage({
+	          type: 'agent-native-ui-output',
+	          extensionId: _extensionId,
+	          key: key,
+	          value: value,
+	          output: output,
+	        }, '*');
+	      } catch (_) {}
+	      return { ok: true, key: key, output: output };
+	    }
+
     async function dbQuery(sql, args) {
       var body = { sql: sql };
       if (args) body.args = args;
@@ -519,6 +566,25 @@ export function buildExtensionHtml(
 	    var toolFetch = extensionFetch;
 	    var toolData = extensionData;
 	    var _toolId = _extensionId;
+	    window.agentNative = Object.assign(window.agentNative || {}, {
+	      extensionId: _extensionId,
+	      extensionBinding: _extensionBinding,
+	      appAction: appAction,
+	      appFetch: appFetch,
+	      dbQuery: dbQuery,
+	      dbExec: dbExec,
+	      extensionFetch: extensionFetch,
+	      extensionData: extensionData,
+	      data: extensionData,
+	      sendToChat: sendToChat,
+	      chat: Object.assign({}, (window.agentNative && window.agentNative.chat) || {}, {
+	        send: sendToChat,
+	      }),
+	      ui: Object.assign({}, (window.agentNative && window.agentNative.ui) || {}, {
+	        output: outputToUi,
+	      }),
+	    });
+	    window.sendToAgentChat = sendToChat;
 	  </script>
 	  <style>
 	    #__extension-error-toast {
@@ -572,9 +638,10 @@ export function buildExtensionHtml(
 	      });
 	    });
 
-	    // Auto-resize the iframe to its content when running in slot mode. The
-	    // host listens for agent-native-extension-resize and adjusts the iframe height.
-	    if (new URLSearchParams(location.search).get('slot')) {
+	    // Auto-resize iframe renders. Persisted extension slots include ?slot=;
+	    // transient inline chat UI uses srcdoc, so detect that by parent frame.
+	    // The host listens for agent-native-extension-resize and adjusts height.
+	    if (new URLSearchParams(location.search).get('slot') || window.parent !== window) {
 	      var _lastH = 0;
 	      var _reportHeight = function() {
 	        var h = Math.max(

package/corpus/core/src/extensions/routes.ts

@@ -85,7 +85,11 @@ export function createExtensionsHandler() {
     }
 
     const orgCtx = await getOrgContext(event).catch(() => null);
-    const userEmail = session.email;
+    const userEmail = normalizeExtensionUserEmail(session.email);
+    if (!userEmail) {
+      setResponseStatus(event, 401);
+      return { error: "Authentication required" };
+    }
     const orgId = orgCtx?.orgId ?? session.orgId ?? undefined;
 
     try {
@@ -103,6 +107,10 @@ export function createExtensionsHandler() {
   });
 }
 
+function normalizeExtensionUserEmail(email: string): string {
+  return email.trim().toLowerCase();
+}
+
 async function dispatch(
   event: H3Event,
   method: string,
@@ -499,7 +507,7 @@ async function handleExtensionDataList(
       sql: `SELECT COALESCE(item_id, id) AS id, tool_id, collection, data, owner_email, scope, org_id, created_at, updated_at
         FROM tool_data
         WHERE tool_id = ? AND collection = ?
-          AND ((scope = 'user' AND owner_email = ?) OR (scope = 'org' AND org_id = ?))
+          AND ((scope = 'user' AND lower(owner_email) = ?) OR (scope = 'org' AND org_id = ?))
         ORDER BY created_at DESC
         LIMIT ?`,
       args: [extensionId, collection, userEmail, orgId ?? "", limit],
@@ -510,7 +518,7 @@ async function handleExtensionDataList(
   const result = await client.execute({
     sql: `SELECT COALESCE(item_id, id) AS id, tool_id, collection, data, owner_email, scope, org_id, created_at, updated_at
       FROM tool_data
-      WHERE tool_id = ? AND collection = ? AND scope = 'user' AND owner_email = ?
+      WHERE tool_id = ? AND collection = ? AND scope = 'user' AND lower(owner_email) = ?
       ORDER BY updated_at DESC
       LIMIT ?`,
     args: [extensionId, collection, userEmail, limit],
@@ -614,7 +622,7 @@ async function handleExtensionDataDelete(
   }
 
   await client.execute({
-    sql: `DELETE FROM tool_data WHERE COALESCE(item_id, id) = ? AND tool_id = ? AND collection = ? AND scope = 'user' AND owner_email = ?`,
+    sql: `DELETE FROM tool_data WHERE COALESCE(item_id, id) = ? AND tool_id = ? AND collection = ? AND scope = 'user' AND lower(owner_email) = ?`,
     args: [itemId, extensionId, collection, userEmail],
   });
   return { ok: true };