@agent-native/core 0.113.0 → 0.114.0

package/src/client/agent-chat.ts

@@ -0,0 +1,1233 @@
+/**
+ * Agent Chat Bridge (browser)
+ *
+ * Sends structured messages to the agent chat from UI interactions.
+ * Messages are sent via postMessage to the parent window (or self if top-level).
+ * Builder frames are special: code requests go to Builder, but content prompts
+ * stay inside the embedded app so its own AgentSidebar can receive them.
+ */
+
+import type { ReasoningEffort } from "../shared/reasoning-effort.js";
+import { agentNativePath } from "./api-path.js";
+import {
+  isInBuilderFrame,
+  isTrustedBuilderMessage,
+  sendToBuilderChat,
+} from "./builder-frame.js";
+import {
+  isEmbedAuthActive,
+  isEmbedMcpChatBridgeActive,
+  markEmbedMcpChatBridgeActive,
+  readEmbedMcpChatBridgeFlagFromUrl,
+} from "./embed-auth.js";
+import {
+  getFramePostMessageTargetOrigin,
+  isTrustedFrameMessage,
+} from "./frame.js";
+import { sendMcpAppHostMessage } from "./mcp-app-host.js";
+
+export type AgentChatRequestMode = "act" | "plan";
+
+export interface AgentChatMessage {
+  /** The visible prompt message sent to the chat */
+  message: string;
+  /** Hidden context appended to the message (not shown in chat UI) */
+  context?: string;
+  /** true = auto-submit, false = prefill only, omit = use project setting */
+  submit?: boolean;
+  /** Optional project slug for structured context */
+  projectSlug?: string;
+  /** Optional preset name for downstream consumers */
+  preset?: string;
+  /** Optional reference image paths */
+  referenceImagePaths?: string[];
+  /** Optional uploaded reference images */
+  uploadedReferenceImages?: string[];
+  /** Optional image data URLs to include in the submitted chat message */
+  images?: string[];
+  /** Stable tab identifier — auto-generated if omitted */
+  tabId?: string;
+  /**
+   * Message routing type:
+   * - "content" (default): stays in the embedded app agent for content/data operations
+   * - "code": routes to the code editing frame (Agent Native Desktop or Builder.io)
+   *
+   * When type is "code" and no frame is connected, a dialog is shown.
+   * `requiresCode: true` is treated as `type: "code"` for backward compatibility.
+   */
+  type?: "content" | "code";
+  /** @deprecated Use `type: "code"` instead. If true, treated as `type: "code"`. */
+  requiresCode?: boolean;
+  /** Model preference for this sub-agent (e.g. "claude-haiku-4-5"). Uses default if omitted */
+  model?: string;
+  /** Engine preference paired with model for cross-provider switches. */
+  engine?: string;
+  /** Reasoning effort preference paired with model. */
+  effort?: ReasoningEffort;
+  /**
+   * Execution mode for this submitted turn. When omitted, sendToAgentChat
+   * snapshots the current AgentPanel mode from localStorage when available.
+   */
+  mode?: AgentChatRequestMode;
+  /** @deprecated Use `mode` instead. */
+  requestMode?: AgentChatRequestMode;
+  /** Scoped system prompt additions for this sub-agent */
+  instructions?: string;
+  /**
+   * Message delivery target. Auto-submitted MCP App messages normally relay to
+   * the host chat; use "local" when a control explicitly targets this app's
+   * own AgentSidebar.
+   */
+  chatTarget?: "auto" | "local";
+  /**
+   * Whether to open the agent sidebar if it's currently hidden.
+   * Defaults to true — submitting a chat should make the response visible.
+   * Pass `false` for background/silent sends that shouldn't pop the UI open.
+   */
+  openSidebar?: boolean;
+  /**
+   * When true, opens a new chat tab before sending the message.
+   * Use for creation requests (create tool, dashboard, etc.) that deserve
+   * their own isolated thread rather than cluttering an existing conversation.
+   */
+  newTab?: boolean;
+  /**
+   * When true with newTab, creates the tab in the background without
+   * focusing it or opening the sidebar. The message runs silently.
+   */
+  background?: boolean;
+  /**
+   * Stable id used to deduplicate a submit and correlate it with
+   * {@link AGENT_CHAT_SUBMIT_RESULT_EVENT}. Auto-generated if omitted.
+   */
+  submitMessageId?: string;
+}
+
+export interface AgentChatContextItem {
+  /** Stable key used to replace an existing context nugget. */
+  key: string;
+  /** Short label shown in the composer context chip. */
+  title: string;
+  /** Hidden context included with the next submitted prompt. */
+  context: string;
+}
+
+export interface AgentChatContextSetOptions extends AgentChatContextItem {
+  /**
+   * Whether to open the agent sidebar if it's currently hidden.
+   * Defaults to true so the user can see the staged context.
+   */
+  openSidebar?: boolean;
+  /**
+   * Whether to move keyboard focus into the composer when staging the item.
+   * Defaults to true. Pass `false` for context that mirrors ambient UI state
+   * (e.g. a canvas element selection) so staging never steals focus from an
+   * unrelated editor — such as an inline text editor in a design canvas.
+   */
+  focus?: boolean;
+}
+
+/** @deprecated Use `AgentChatContextSetOptions` instead. */
+export type AgentChatContextMessage = AgentChatContextSetOptions;
+
+export interface AgentChatContextState {
+  items: AgentChatContextItem[];
+  updatedAt: number;
+}
+
+export interface AgentChatOpenThreadRequest {
+  threadId: string;
+  newThread?: boolean;
+  /**
+   * Open only while this thread is still active (or no thread is active).
+   * This lets transient surfaces restore their own chat without stealing a
+   * thread the user selected in the meantime.
+   */
+  onlyIfActiveThreadId?: string;
+  openRequestId?: string;
+}
+
+export interface AgentChatOpenTaskRequest {
+  threadId: string;
+  parentThreadId?: string;
+  description?: string;
+  name?: string;
+  openRequestId?: string;
+}
+
+export type BufferedAgentChatOpenRequest = {
+  id: string;
+  eventType: "agent-chat:open-thread" | "agent-task-open";
+  detail: AgentChatOpenThreadRequest | AgentChatOpenTaskRequest;
+};
+
+export interface AgentComposerReference {
+  label: string;
+  icon?: string;
+  source?: string;
+  refType: string;
+  refId?: string | null;
+  refPath?: string | null;
+  /** Stable composer slot this reference occupies. Slot references replace older values. */
+  slotKey?: string;
+  /** Short label shown before the selected value in the composer chip. */
+  slotLabel?: string;
+  /** Additional app-defined data used by the client for filtering and grouping. */
+  metadata?: Record<string, unknown>;
+  /** Slots to remove when this reference is inserted or removed. */
+  clearsSlots?: string[];
+  /** Additional references to insert before this one. */
+  relatedReferences?: AgentComposerReference[];
+}
+
+export interface AgentComposerReferenceInsertOptions {
+  /**
+   * Whether to open the agent sidebar before inserting the reference.
+   * Defaults to false so contextual auto-tags can stay quiet.
+   */
+  openSidebar?: boolean;
+}
+
+export interface AgentComposerReferenceInsertPayload extends AgentComposerReference {
+  insertMessageId: string;
+}
+
+export interface AgentChatContextMutationOptions {
+  /**
+   * Whether to open the agent sidebar if it's currently hidden.
+   * Defaults to true for set/add and false for remove/clear.
+   */
+  openSidebar?: boolean;
+}
+
+export interface AgentChatContextRemoveOptions extends AgentChatContextMutationOptions {
+  /** Stable key of the staged context nugget to remove. */
+  key: string;
+}
+
+const AGENT_CHAT_MESSAGE_TYPE = "agentNative.submitChat";
+const AGENT_CHAT_CONTEXT_STATE_KEY = "agent-chat-context";
+const AGENT_CHAT_EXEC_MODE_KEY = "agent-native-exec-mode";
+export const AGENT_CHAT_CONTEXT_CHANGED_EVENT =
+  "agentNative.chatContextChanged";
+export const AGENT_CHAT_SET_CONTEXT_MESSAGE_TYPE = "agentNative.setChatContext";
+export const AGENT_CHAT_REMOVE_CONTEXT_MESSAGE_TYPE =
+  "agentNative.removeChatContext";
+export const AGENT_CHAT_CLEAR_CONTEXT_MESSAGE_TYPE =
+  "agentNative.clearChatContext";
+export const AGENT_CHAT_INSERT_REFERENCE_MESSAGE_TYPE =
+  "agentNative.insertComposerReference";
+export const AGENT_CHAT_INSERT_REFERENCE_EVENT =
+  "agentNative:insert-composer-reference";
+const AGENT_PANEL_PREPARE_EVENT = "agent-panel:prepare";
+
+/**
+ * Fired once a submitted turn's fate is known: `delivered: true` once the
+ * receiving AssistantChat has actually committed the turn (added it to the
+ * visible thread, independent of whether the agent's response later
+ * succeeds), or `delivered: false` when it was rejected before ever
+ * appearing — e.g. no LLM/agent engine configured. Callers that must know
+ * whether their submit truly landed (rather than fire-and-forget) should use
+ * {@link sendToAgentChatAndConfirm} instead of listening for this directly.
+ */
+export const AGENT_CHAT_SUBMIT_RESULT_EVENT = "agentNative.chatSubmitResult";
+
+export interface AgentChatSubmitResult {
+  submitMessageId: string;
+  delivered: boolean;
+  reason?: string;
+}
+
+/** Report a submit's definitive outcome so `sendToAgentChatAndConfirm` (or any
+ * other correlated listener) can resolve. No-ops without a submitMessageId or
+ * a window (SSR). */
+export function reportAgentChatSubmitResult(
+  submitMessageId: string | undefined,
+  delivered: boolean,
+  reason?: string,
+): void {
+  if (
+    !submitMessageId ||
+    cancelledSubmitIds.has(submitMessageId) ||
+    typeof window === "undefined"
+  ) {
+    return;
+  }
+  window.dispatchEvent(
+    new CustomEvent<AgentChatSubmitResult>(AGENT_CHAT_SUBMIT_RESULT_EVENT, {
+      detail: { submitMessageId, delivered, reason },
+    }),
+  );
+}
+
+let agentChatContextState: AgentChatContextState = {
+  items: [],
+  updatedAt: 0,
+};
+const agentChatContextListeners = new Set<() => void>();
+let agentChatContextNotifyQueued = false;
+
+/**
+ * Listen for chatRunning messages from the frame (postMessage)
+ * and re-dispatch as a CustomEvent so hooks like useAgentChatGenerating() work.
+ */
+if (typeof window !== "undefined") {
+  window.addEventListener("message", (event) => {
+    if (!isTrustedFrameMessage(event) && !isTrustedBuilderMessage(event)) {
+      return;
+    }
+    if (
+      event.data?.type === "agentNative.chatRunning" ||
+      event.data?.type === "builder.chatRunning"
+    ) {
+      window.dispatchEvent(
+        new CustomEvent("agentNative.chatRunning", {
+          detail: event.data.detail ?? event.data.data,
+        }),
+      );
+    }
+  });
+}
+
+/** Generate a unique tab ID */
+export function generateTabId(): string {
+  return `chat-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+
+/** Unique id for one submitted message, used to dedup live + replayed sends. */
+function generateSubmitMessageId(): string {
+  return `submit-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+
+// Self-submit buffer: same-window sends post to `window` itself, but the
+// receiver is lazy-loaded and may not be listening yet. Buffer each submit so
+// the panel can replay it on mount; claimAgentChatSubmit dedups by id so a
+// submit received both live and replayed is delivered exactly once.
+interface BufferedSelfSubmit {
+  id: string;
+  data: Record<string, unknown>;
+  at: number;
+}
+
+const SELF_SUBMIT_BUFFER_TTL_MS = 8000;
+const bufferedSelfSubmits: BufferedSelfSubmit[] = [];
+const claimedSubmitIds = new Set<string>();
+const cancelledSubmitIds = new Set<string>();
+
+interface BufferedOpenRequest extends BufferedAgentChatOpenRequest {
+  at: number;
+}
+
+const OPEN_REQUEST_BUFFER_TTL_MS = 8000;
+const bufferedOpenRequests: BufferedOpenRequest[] = [];
+const claimedOpenRequestIds = new Set<string>();
+
+function pruneSelfSubmitBuffer(now: number): void {
+  for (let i = bufferedSelfSubmits.length - 1; i >= 0; i -= 1) {
+    if (now - bufferedSelfSubmits[i].at > SELF_SUBMIT_BUFFER_TTL_MS) {
+      const [removed] = bufferedSelfSubmits.splice(i, 1);
+      if (removed) claimedSubmitIds.delete(removed.id);
+    }
+  }
+}
+
+function bufferSelfSubmit(data: Record<string, unknown>): void {
+  const id =
+    typeof data.submitMessageId === "string" ? data.submitMessageId : undefined;
+  if (!id) return;
+  const now = Date.now();
+  pruneSelfSubmitBuffer(now);
+  bufferedSelfSubmits.push({ id, data, at: now });
+}
+
+/**
+ * Permanently tombstone a submit for this page lifetime and remove its
+ * cold-start replay. A confirmation timeout must be terminal: callers may
+ * retry while preserving their own state, so the original submit cannot be
+ * allowed to appear later when a lazy panel or thread ref finally mounts.
+ */
+export function cancelAgentChatSubmit(id: string | undefined): void {
+  if (!id) return;
+  cancelledSubmitIds.add(id);
+  claimedSubmitIds.add(id);
+  for (let index = bufferedSelfSubmits.length - 1; index >= 0; index -= 1) {
+    if (bufferedSelfSubmits[index]?.id === id) {
+      bufferedSelfSubmits.splice(index, 1);
+    }
+  }
+}
+
+/** Whether a confirmed-submit timeout has made this delivery terminal. */
+export function isAgentChatSubmitCancelled(id: string | undefined): boolean {
+  return Boolean(id && cancelledSubmitIds.has(id));
+}
+
+function pruneOpenRequestBuffer(now: number): void {
+  for (let i = bufferedOpenRequests.length - 1; i >= 0; i -= 1) {
+    if (now - bufferedOpenRequests[i].at > OPEN_REQUEST_BUFFER_TTL_MS) {
+      const [removed] = bufferedOpenRequests.splice(i, 1);
+      if (removed) claimedOpenRequestIds.delete(removed.id);
+    }
+  }
+}
+
+function bufferOpenRequest(
+  eventType: BufferedAgentChatOpenRequest["eventType"],
+  detail: AgentChatOpenThreadRequest | AgentChatOpenTaskRequest,
+): BufferedOpenRequest {
+  const now = Date.now();
+  pruneOpenRequestBuffer(now);
+  const id = `open-${now}-${Math.random().toString(36).slice(2, 8)}`;
+  const entry: BufferedOpenRequest = {
+    id,
+    eventType,
+    detail: { ...detail, openRequestId: id },
+    at: now,
+  };
+  bufferedOpenRequests.push(entry);
+  return entry;
+}
+
+/** Unclaimed self-submit payloads, for the panel to replay once it mounts. */
+export function drainBufferedAgentChatSubmits(): Array<
+  Record<string, unknown>
+> {
+  pruneSelfSubmitBuffer(Date.now());
+  return bufferedSelfSubmits
+    .filter((entry) => !claimedSubmitIds.has(entry.id))
+    .map((entry) => entry.data);
+}
+
+/** Claim a submit; false if already handled. Idless submits always pass. */
+export function claimAgentChatSubmit(id: string | undefined): boolean {
+  if (!id) return true;
+  if (cancelledSubmitIds.has(id)) return false;
+  if (claimedSubmitIds.has(id)) return false;
+  claimedSubmitIds.add(id);
+  return true;
+}
+
+/** Unclaimed open-thread/task requests, for the panel to replay once it mounts. */
+export function drainBufferedAgentChatOpenRequests(): BufferedAgentChatOpenRequest[] {
+  pruneOpenRequestBuffer(Date.now());
+  return bufferedOpenRequests
+    .filter((entry) => !claimedOpenRequestIds.has(entry.id))
+    .map(({ id, eventType, detail }) => ({ id, eventType, detail }));
+}
+
+/** Claim an open-thread/task request; false if already handled. Idless events pass. */
+export function claimAgentChatOpenRequest(id: unknown): boolean {
+  if (typeof id !== "string" || !id) return true;
+  if (claimedOpenRequestIds.has(id)) return false;
+  claimedOpenRequestIds.add(id);
+  return true;
+}
+
+/** Test-only: reset the self-submit buffer and claim set. */
+export function _resetAgentChatSubmitBufferForTests(): void {
+  bufferedSelfSubmits.length = 0;
+  claimedSubmitIds.clear();
+  cancelledSubmitIds.clear();
+  bufferedOpenRequests.length = 0;
+  claimedOpenRequestIds.clear();
+}
+
+export function normalizeAgentChatContextItem(
+  item: unknown,
+): AgentChatContextItem | null {
+  if (typeof item !== "object" || item === null) return null;
+  const candidate = item as Partial<AgentChatContextItem>;
+  if (
+    typeof candidate.key !== "string" ||
+    typeof candidate.context !== "string" ||
+    typeof candidate.title !== "string"
+  ) {
+    return null;
+  }
+  const key = candidate.key.trim();
+  const context = candidate.context.trim();
+  if (!key || !context) return null;
+  return {
+    key,
+    title: candidate.title.trim() || key,
+    context,
+  };
+}
+
+export function normalizeAgentChatContextItems(
+  items: unknown,
+): AgentChatContextItem[] {
+  if (!Array.isArray(items)) return [];
+  const deduped = new Map<string, AgentChatContextItem>();
+  for (const rawItem of items) {
+    const item = normalizeAgentChatContextItem(rawItem);
+    if (!item) continue;
+    deduped.set(item.key, item);
+  }
+  return [...deduped.values()];
+}
+
+function normalizeAgentChatContextState(
+  value: unknown,
+): AgentChatContextState | null {
+  if (!value || typeof value !== "object") return null;
+  const raw = value as {
+    value?: unknown;
+    items?: unknown;
+    updatedAt?: unknown;
+  };
+  const candidate =
+    raw.value && typeof raw.value === "object"
+      ? (raw.value as { items?: unknown; updatedAt?: unknown })
+      : raw;
+  const items = normalizeAgentChatContextItems(candidate.items);
+  return {
+    items,
+    updatedAt:
+      typeof candidate.updatedAt === "number" ? candidate.updatedAt : 0,
+  };
+}
+
+function withReplacedAgentChatContextItem(
+  items: readonly AgentChatContextItem[],
+  item: AgentChatContextItem,
+): AgentChatContextItem[] {
+  const index = items.findIndex((current) => current.key === item.key);
+  if (index === -1) return [...items, item];
+  return items.map((current, currentIndex) =>
+    currentIndex === index ? item : current,
+  );
+}
+
+function notifyAgentChatContextListeners(): void {
+  if (agentChatContextNotifyQueued) return;
+  agentChatContextNotifyQueued = true;
+  const notify = () => {
+    agentChatContextNotifyQueued = false;
+    for (const listener of Array.from(agentChatContextListeners)) listener();
+  };
+  if (typeof queueMicrotask === "function") {
+    queueMicrotask(notify);
+  } else {
+    setTimeout(notify, 0);
+  }
+}
+
+function persistAgentChatContextState(state: AgentChatContextState): void {
+  if (typeof window === "undefined" || typeof fetch !== "function") return;
+  fetch(
+    agentNativePath(
+      `/_agent-native/application-state/${AGENT_CHAT_CONTEXT_STATE_KEY}`,
+    ),
+    {
+      method: "PUT",
+      keepalive: true,
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(state),
+    },
+  ).catch(() => {});
+}
+
+export function publishAgentChatContextItems(
+  items: readonly AgentChatContextItem[],
+  options?: { persist?: boolean; updatedAt?: number },
+): AgentChatContextState {
+  const next: AgentChatContextState = {
+    items: normalizeAgentChatContextItems([...items]),
+    updatedAt: options?.updatedAt ?? Date.now(),
+  };
+  if (next.updatedAt < agentChatContextState.updatedAt) {
+    return agentChatContextState;
+  }
+  agentChatContextState = next;
+  notifyAgentChatContextListeners();
+  if (typeof window !== "undefined") {
+    window.dispatchEvent(
+      new CustomEvent(AGENT_CHAT_CONTEXT_CHANGED_EVENT, {
+        detail: next,
+      }),
+    );
+  }
+  if (options?.persist !== false) {
+    persistAgentChatContextState(next);
+  }
+  return next;
+}
+
+export function getAgentChatContextState(): AgentChatContextState {
+  return agentChatContextState;
+}
+
+export function listAgentChatContext(): AgentChatContextItem[] {
+  return [...agentChatContextState.items];
+}
+
+export function subscribeAgentChatContext(listener: () => void): () => void {
+  agentChatContextListeners.add(listener);
+  return () => {
+    agentChatContextListeners.delete(listener);
+  };
+}
+
+export async function refreshAgentChatContext(): Promise<AgentChatContextState> {
+  if (typeof window === "undefined" || typeof fetch !== "function") {
+    return agentChatContextState;
+  }
+  try {
+    const res = await fetch(
+      agentNativePath(
+        `/_agent-native/application-state/${AGENT_CHAT_CONTEXT_STATE_KEY}`,
+      ),
+    );
+    if (!res.ok || res.status === 204) return agentChatContextState;
+    const text = await res.text();
+    if (!text) return agentChatContextState;
+    const state = normalizeAgentChatContextState(JSON.parse(text));
+    if (!state) return agentChatContextState;
+    return publishAgentChatContextItems(state.items, {
+      persist: false,
+      updatedAt: state.updatedAt,
+    });
+  } catch {
+    return agentChatContextState;
+  }
+}
+
+export function formatAgentChatContextItemsForPrompt(
+  items: readonly AgentChatContextItem[],
+): string {
+  return items
+    .map(normalizeAgentChatContextItem)
+    .filter((item): item is AgentChatContextItem => item !== null)
+    .map((item) => [`## ${item.title}`, item.context].join("\n"))
+    .join("\n\n");
+}
+
+export function appendAgentChatContextToMessage(
+  message: string,
+  context: string,
+): string {
+  const trimmedContext = context.trim();
+  if (!trimmedContext) return message;
+  return `${message.trim()}\n\n<context>\n${trimmedContext}\n</context>`;
+}
+
+function normalizeStringArray(value: unknown): string[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+  const normalized = value
+    .filter((item): item is string => typeof item === "string")
+    .map((item) => item.trim())
+    .filter(Boolean);
+  return normalized.length > 0 ? normalized : undefined;
+}
+
+function normalizeMetadata(
+  value: unknown,
+): Record<string, unknown> | undefined {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return undefined;
+  }
+  return value as Record<string, unknown>;
+}
+
+function normalizeAgentComposerReferenceInternal(
+  value: unknown,
+  depth: number,
+): AgentComposerReference | null {
+  if (typeof value !== "object" || value === null) return null;
+  const candidate = value as Partial<AgentComposerReference>;
+  const label =
+    typeof candidate.label === "string" ? candidate.label.trim() : "";
+  const refType =
+    typeof candidate.refType === "string" ? candidate.refType.trim() : "";
+  if (!label || !refType) return null;
+  const normalized: AgentComposerReference = {
+    label,
+    icon:
+      typeof candidate.icon === "string" && candidate.icon.trim()
+        ? candidate.icon.trim()
+        : undefined,
+    source:
+      typeof candidate.source === "string" && candidate.source.trim()
+        ? candidate.source.trim()
+        : undefined,
+    refType,
+    refId:
+      typeof candidate.refId === "string" && candidate.refId.trim()
+        ? candidate.refId.trim()
+        : null,
+    refPath:
+      typeof candidate.refPath === "string" && candidate.refPath.trim()
+        ? candidate.refPath.trim()
+        : null,
+  };
+  const slotKey =
+    typeof candidate.slotKey === "string" ? candidate.slotKey.trim() : "";
+  if (slotKey) normalized.slotKey = slotKey;
+  const slotLabel =
+    typeof candidate.slotLabel === "string" ? candidate.slotLabel.trim() : "";
+  if (slotLabel) normalized.slotLabel = slotLabel;
+  const metadata = normalizeMetadata(candidate.metadata);
+  if (metadata) normalized.metadata = metadata;
+  const clearsSlots = normalizeStringArray(candidate.clearsSlots);
+  if (clearsSlots) normalized.clearsSlots = clearsSlots;
+  if (depth < 3 && Array.isArray(candidate.relatedReferences)) {
+    const relatedReferences = candidate.relatedReferences
+      .map((item) => normalizeAgentComposerReferenceInternal(item, depth + 1))
+      .filter((item): item is AgentComposerReference => item !== null);
+    if (relatedReferences.length > 0) {
+      normalized.relatedReferences = relatedReferences;
+    }
+  }
+  return normalized;
+}
+
+export function normalizeAgentComposerReference(
+  value: unknown,
+): AgentComposerReference | null {
+  return normalizeAgentComposerReferenceInternal(value, 0);
+}
+
+function postAgentChatContextMessage(
+  type:
+    | typeof AGENT_CHAT_SET_CONTEXT_MESSAGE_TYPE
+    | typeof AGENT_CHAT_REMOVE_CONTEXT_MESSAGE_TYPE
+    | typeof AGENT_CHAT_CLEAR_CONTEXT_MESSAGE_TYPE,
+  data: unknown,
+  options: { openSidebar: boolean },
+): void {
+  if (typeof window === "undefined") return;
+
+  const shouldForwardOpenSidebar =
+    (type === AGENT_CHAT_SET_CONTEXT_MESSAGE_TYPE &&
+      options.openSidebar === false) ||
+    (type !== AGENT_CHAT_SET_CONTEXT_MESSAGE_TYPE &&
+      options.openSidebar === true);
+  const payloadData =
+    shouldForwardOpenSidebar && typeof data === "object" && data !== null
+      ? {
+          ...(data as Record<string, unknown>),
+          openSidebar: options.openSidebar,
+        }
+      : data;
+  const payload = { type, data: payloadData };
+  const targetSelf = isInBuilderFrame() || isDirectMcpAppEmbedSession();
+  const target = targetSelf
+    ? window
+    : window.parent !== window
+      ? window.parent
+      : window;
+  const targetOrigin = targetSelf
+    ? window.location.origin
+    : getFramePostMessageTargetOrigin() || window.location.origin;
+
+  if (options.openSidebar) {
+    window.dispatchEvent(
+      new CustomEvent("agent-panel:set-mode", {
+        detail: { mode: "chat" },
+      }),
+    );
+    window.dispatchEvent(new CustomEvent("agent-panel:open"));
+  } else {
+    window.dispatchEvent(new CustomEvent(AGENT_PANEL_PREPARE_EVENT));
+  }
+
+  const postToTarget = () => target.postMessage(payload, targetOrigin);
+  if (target === window) {
+    setTimeout(postToTarget, 0);
+  } else {
+    postToTarget();
+  }
+}
+
+function postAgentChatReferenceMessage(
+  payload: AgentComposerReferenceInsertPayload,
+  options: { openSidebar: boolean },
+): void {
+  if (typeof window === "undefined") return;
+
+  const message = {
+    type: AGENT_CHAT_INSERT_REFERENCE_MESSAGE_TYPE,
+    data: payload,
+  };
+  const targetSelf = isInBuilderFrame() || isDirectMcpAppEmbedSession();
+  const target = targetSelf
+    ? window
+    : window.parent !== window
+      ? window.parent
+      : window;
+  const targetOrigin = targetSelf
+    ? window.location.origin
+    : getFramePostMessageTargetOrigin() || window.location.origin;
+
+  if (options.openSidebar) {
+    window.dispatchEvent(
+      new CustomEvent("agent-panel:set-mode", {
+        detail: { mode: "chat" },
+      }),
+    );
+    window.dispatchEvent(new CustomEvent("agent-panel:open"));
+  } else {
+    window.dispatchEvent(new CustomEvent(AGENT_PANEL_PREPARE_EVENT));
+  }
+
+  window.dispatchEvent(
+    new CustomEvent(AGENT_CHAT_INSERT_REFERENCE_EVENT, {
+      detail: payload,
+    }),
+  );
+
+  const postToTarget = () => target.postMessage(message, targetOrigin);
+  if (target === window) {
+    setTimeout(postToTarget, 0);
+  } else {
+    postToTarget();
+  }
+}
+
+function openAgentPanelForChat(): void {
+  if (typeof window === "undefined") return;
+  window.dispatchEvent(
+    new CustomEvent("agent-panel:set-mode", {
+      detail: { mode: "chat" },
+    }),
+  );
+  window.dispatchEvent(new CustomEvent("agent-panel:open"));
+}
+
+function dispatchBufferedOpenRequest(entry: BufferedOpenRequest): void {
+  if (typeof window === "undefined") return;
+  const dispatch = () => {
+    window.dispatchEvent(
+      new CustomEvent(entry.eventType, { detail: entry.detail }),
+    );
+  };
+  setTimeout(dispatch, 0);
+}
+
+export function requestAgentChatThreadOpen(
+  detail: AgentChatOpenThreadRequest,
+): void {
+  if (typeof window === "undefined" || !detail.threadId.trim()) return;
+  openAgentPanelForChat();
+  dispatchBufferedOpenRequest(
+    bufferOpenRequest("agent-chat:open-thread", {
+      ...detail,
+      threadId: detail.threadId.trim(),
+    }),
+  );
+}
+
+export function requestAgentTaskOpen(detail: AgentChatOpenTaskRequest): void {
+  if (typeof window === "undefined" || !detail.threadId.trim()) return;
+  openAgentPanelForChat();
+  const parentThreadId = detail.parentThreadId?.trim();
+  dispatchBufferedOpenRequest(
+    bufferOpenRequest("agent-task-open", {
+      ...detail,
+      threadId: detail.threadId.trim(),
+      ...(parentThreadId ? { parentThreadId } : {}),
+    }),
+  );
+}
+
+function isMcpAppChatBridgeEnabled(): boolean {
+  if (typeof window === "undefined" || window.parent === window) return false;
+  if (readEmbedMcpChatBridgeFlagFromUrl()) markEmbedMcpChatBridgeActive();
+  return isEmbedMcpChatBridgeActive() && isEmbedAuthActive();
+}
+
+function isDirectMcpAppEmbedSession(): boolean {
+  if (typeof window === "undefined" || window.parent === window) return false;
+  if (readEmbedMcpChatBridgeFlagFromUrl()) markEmbedMcpChatBridgeActive();
+  return isEmbedAuthActive() && !isEmbedMcpChatBridgeActive();
+}
+
+function dispatchAgentChatRunning(isRunning: boolean): void {
+  if (typeof window === "undefined") return;
+  window.dispatchEvent(
+    new CustomEvent("agentNative.chatRunning", {
+      detail: { isRunning },
+    }),
+  );
+}
+
+function normalizeAgentChatRequestMode(
+  value: unknown,
+): AgentChatRequestMode | undefined {
+  return value === "act" || value === "plan" ? value : undefined;
+}
+
+/** A normalized `agentNative.submitChat` payload — decode via {@link parseSubmitChatMessage}. */
+export interface ParsedSubmitChat {
+  /** Visible prompt text (non-empty). */
+  message: string;
+  context?: string;
+  /** Submit (true) or prefill only (false); defaults to true. */
+  submit: boolean;
+  openSidebar?: boolean;
+  model?: string;
+  /** Raw effort hint; the receiver validates it against the model. */
+  effort?: unknown;
+  newTab?: boolean;
+  background?: boolean;
+  tabId?: string;
+  images?: string[];
+  /** Mode as sent; the receiver falls back to its exec mode when undefined. */
+  requestMode?: AgentChatRequestMode;
+  /** Id used to dedup the live post against a cold-start replay. */
+  submitMessageId?: string;
+}
+
+/** Decode a `message` event into a submit payload, or null if it isn't one / has no text. */
+export function parseSubmitChatMessage(
+  event: MessageEvent,
+): ParsedSubmitChat | null {
+  const envelope =
+    event.data && typeof event.data === "object"
+      ? (event.data as { type?: unknown; data?: unknown })
+      : null;
+  if (!envelope || envelope.type !== AGENT_CHAT_MESSAGE_TYPE) return null;
+  const raw =
+    envelope.data && typeof envelope.data === "object"
+      ? (envelope.data as Record<string, unknown>)
+      : null;
+  if (!raw) return null;
+  const message = typeof raw.message === "string" ? raw.message : "";
+  if (!message) return null;
+  const images = Array.isArray(raw.images)
+    ? raw.images.filter(
+        (image): image is string =>
+          typeof image === "string" && image.length > 0,
+      )
+    : undefined;
+  return {
+    message,
+    context: typeof raw.context === "string" ? raw.context : undefined,
+    submit: raw.submit !== false,
+    openSidebar:
+      typeof raw.openSidebar === "boolean" ? raw.openSidebar : undefined,
+    model: typeof raw.model === "string" ? raw.model : undefined,
+    effort: raw.effort,
+    newTab: typeof raw.newTab === "boolean" ? raw.newTab : undefined,
+    background:
+      typeof raw.background === "boolean" ? raw.background : undefined,
+    tabId: typeof raw.tabId === "string" ? raw.tabId : undefined,
+    images,
+    requestMode: normalizeAgentChatRequestMode(raw.requestMode ?? raw.mode),
+    submitMessageId:
+      typeof raw.submitMessageId === "string" ? raw.submitMessageId : undefined,
+  };
+}
+
+function normalizeStoredAgentChatExecMode(
+  value: string | null,
+): AgentChatRequestMode | undefined {
+  if (value === "plan") return "plan";
+  if (value === "build" || value === "act") return "act";
+  return undefined;
+}
+
+function readStoredAgentChatRequestMode(): AgentChatRequestMode | undefined {
+  if (typeof window === "undefined") return undefined;
+  try {
+    const storage = window.localStorage;
+    const saved = normalizeStoredAgentChatExecMode(
+      storage.getItem(AGENT_CHAT_EXEC_MODE_KEY),
+    );
+    if (saved) return saved;
+    const scopedModes: AgentChatRequestMode[] = [];
+    for (let index = 0; index < storage.length; index += 1) {
+      const key = storage.key(index);
+      if (!key?.startsWith(`${AGENT_CHAT_EXEC_MODE_KEY}:`)) continue;
+      const scopedSaved = normalizeStoredAgentChatExecMode(
+        storage.getItem(key),
+      );
+      if (scopedSaved) scopedModes.push(scopedSaved);
+    }
+    if (scopedModes.length === 1) return scopedModes[0];
+  } catch {}
+  return undefined;
+}
+
+/**
+ * Send a message to the agent chat via postMessage.
+ * Returns the stable tabId for tracking this chat run.
+ */
+export function sendToAgentChat(opts: AgentChatMessage): string {
+  const tabId = opts.tabId ?? generateTabId();
+  const isCodeRequest = opts.type === "code" || opts.requiresCode === true;
+  const localChatTarget = opts.chatTarget === "local";
+  const requestMode =
+    normalizeAgentChatRequestMode(opts.requestMode ?? opts.mode) ??
+    readStoredAgentChatRequestMode();
+  if (isCodeRequest && isInBuilderFrame()) {
+    sendToBuilderChat({
+      message: opts.message,
+      context: opts.context,
+      submit: opts.submit,
+      ...(requestMode ? { mode: requestMode, requestMode } : {}),
+    });
+    return tabId;
+  }
+
+  const submitMessageId = opts.submitMessageId ?? generateSubmitMessageId();
+  const payload = {
+    type: AGENT_CHAT_MESSAGE_TYPE,
+    data: {
+      ...opts,
+      tabId,
+      submitMessageId,
+      ...(requestMode ? { mode: requestMode, requestMode } : {}),
+    },
+  };
+
+  if (
+    opts.submit !== false &&
+    !localChatTarget &&
+    isMcpAppChatBridgeEnabled()
+  ) {
+    const directHostMessage = sendMcpAppHostMessage({
+      message: opts.message,
+      context: opts.context,
+      ...(requestMode ? { mode: requestMode, requestMode } : {}),
+    });
+    if (directHostMessage) {
+      void Promise.resolve(directHostMessage)
+        .then((ok) => {
+          if (!ok) {
+            window.parent.postMessage(
+              payload,
+              getFramePostMessageTargetOrigin() || "*",
+            );
+          }
+        })
+        .finally(() => {
+          dispatchAgentChatRunning(false);
+        });
+      return tabId;
+    }
+    window.parent.postMessage(
+      payload,
+      getFramePostMessageTargetOrigin() || "*",
+    );
+    return tabId;
+  }
+
+  const shouldOpenSidebar = opts.openSidebar !== false && !opts.background;
+
+  const targetSelf =
+    !isCodeRequest &&
+    (localChatTarget || isInBuilderFrame() || isDirectMcpAppEmbedSession());
+  const target = targetSelf
+    ? window
+    : window.parent !== window
+      ? window.parent
+      : window;
+  const targetOrigin = targetSelf
+    ? window.location.origin
+    : getFramePostMessageTargetOrigin() || window.location.origin;
+  if (shouldOpenSidebar) {
+    window.dispatchEvent(
+      new CustomEvent("agent-panel:set-mode", {
+        detail: { mode: "chat" },
+      }),
+    );
+    window.dispatchEvent(new CustomEvent("agent-panel:open"));
+  } else if (!isCodeRequest) {
+    window.dispatchEvent(new CustomEvent(AGENT_PANEL_PREPARE_EVENT));
+  }
+
+  const postToTarget = () => target.postMessage(payload, targetOrigin);
+
+  // Same-window: defer one tick so a sidebar mounting now can attach its
+  // listener, and buffer the submit so the lazy panel can replay it if it
+  // mounts later. The live post and the replay dedup by submitMessageId.
+  if (!isCodeRequest && target === window) {
+    bufferSelfSubmit(payload.data);
+    setTimeout(postToTarget, 0);
+  } else {
+    postToTarget();
+  }
+  return tabId;
+}
+
+// Must exceed SELF_SUBMIT_BUFFER_TTL_MS. Otherwise confirmation can time out
+// while its replay is still eligible to mount and deliver later.
+const DEFAULT_SUBMIT_CONFIRM_TIMEOUT_MS = SELF_SUBMIT_BUFFER_TTL_MS + 2000;
+
+export interface SendToAgentChatAndConfirmResult {
+  tabId: string;
+  /** True once the message actually became a visible turn in the chat. */
+  delivered: boolean;
+  /** Set when `delivered` is false: "missing-engine", "timeout", etc. */
+  reason?: string;
+}
+
+/**
+ * Like {@link sendToAgentChat}, but resolves once the submit's fate is known
+ * instead of firing and forgetting. Use this whenever the caller must decide
+ * whether to keep/restore its own state on failure (e.g. a draw/annotate
+ * overlay that should not discard the user's work unless the message actually
+ * reached the chat) — see the `AGENT_CHAT_SUBMIT_RESULT_EVENT` contract.
+ * This acknowledgement is intentionally limited to submitted, non-code
+ * messages with `chatTarget: "local"`; parent-frame and MCP host chats use
+ * different delivery protocols and return `unsupported-target` here.
+ *
+ * Resolves `delivered: false` if the receiving chat explicitly rejects the
+ * submit (e.g. no LLM/agent engine configured) OR if no result arrives within
+ * `timeoutMs` — a silently-stuck submit (panel never mounts, thread never
+ * gets a ref, message type not handled by this build) must fail the same way
+ * an explicit rejection does, since the caller cannot otherwise tell the
+ * difference between "still in flight" and "dropped."
+ */
+export function sendToAgentChatAndConfirm(
+  opts: Omit<AgentChatMessage, "submitMessageId">,
+  options?: { timeoutMs?: number },
+): Promise<SendToAgentChatAndConfirmResult> {
+  const tabId = opts.tabId ?? generateTabId();
+  if (typeof window === "undefined") {
+    return Promise.resolve({ tabId, delivered: false, reason: "no-window" });
+  }
+  // Confirmation is deliberately a same-window/local-chat contract. Parent
+  // frames, Builder code chat, and MCP host relays have independent protocols
+  // and cannot answer this window-local CustomEvent acknowledgement.
+  if (
+    opts.chatTarget !== "local" ||
+    opts.type === "code" ||
+    opts.requiresCode === true ||
+    opts.submit === false
+  ) {
+    return Promise.resolve({
+      tabId,
+      delivered: false,
+      reason: "unsupported-target",
+    });
+  }
+
+  const submitMessageId = generateSubmitMessageId();
+  const timeoutMs = Math.max(
+    0,
+    options?.timeoutMs ?? DEFAULT_SUBMIT_CONFIRM_TIMEOUT_MS,
+  );
+
+  return new Promise<SendToAgentChatAndConfirmResult>((resolve) => {
+    let settled = false;
+    let timer: number | undefined;
+    const cleanup = () => {
+      window.removeEventListener(
+        AGENT_CHAT_SUBMIT_RESULT_EVENT,
+        onResult as EventListener,
+      );
+      if (timer !== undefined) window.clearTimeout(timer);
+    };
+    const finish = (delivered: boolean, reason?: string, cancel = false) => {
+      if (settled) return;
+      settled = true;
+      if (cancel) cancelAgentChatSubmit(submitMessageId);
+      cleanup();
+      resolve({ tabId, delivered, reason });
+    };
+    const onResult = (event: Event) => {
+      const detail = (event as CustomEvent<AgentChatSubmitResult>).detail;
+      if (!detail || detail.submitMessageId !== submitMessageId) return;
+      finish(detail.delivered, detail.reason);
+    };
+
+    window.addEventListener(
+      AGENT_CHAT_SUBMIT_RESULT_EVENT,
+      onResult as EventListener,
+    );
+    timer = window.setTimeout(() => finish(false, "timeout", true), timeoutMs);
+    try {
+      sendToAgentChat({ ...opts, tabId, submitMessageId });
+    } catch {
+      finish(false, "send-failed", true);
+    }
+  });
+}
+
+/**
+ * Add or replace a keyed context nugget in the active agent chat composer.
+ * The context is not submitted until the user sends the prompt.
+ */
+export function setAgentChatContextItem(
+  opts: AgentChatContextSetOptions,
+): void {
+  const item = normalizeAgentChatContextItem(opts);
+  if (!item || typeof window === "undefined") return;
+
+  publishAgentChatContextItems(
+    withReplacedAgentChatContextItem(agentChatContextState.items, item),
+  );
+  // Forward an explicit `focus: false` so the receiving composer can stage the
+  // chip without stealing focus. Focus stays enabled by default (field omitted)
+  // for every existing caller.
+  const messageData = opts.focus === false ? { ...item, focus: false } : item;
+  postAgentChatContextMessage(
+    AGENT_CHAT_SET_CONTEXT_MESSAGE_TYPE,
+    messageData,
+    {
+      openSidebar: opts.openSidebar !== false,
+    },
+  );
+}
+
+/** @deprecated Use `setAgentChatContextItem` instead. */
+export const setContextToAgentChat = setAgentChatContextItem;
+
+/** @deprecated Use `setAgentChatContextItem` instead. */
+export const addContextToAgentChat = setAgentChatContextItem;
+
+export function insertAgentComposerReference(
+  ref: AgentComposerReference,
+  options: AgentComposerReferenceInsertOptions = {},
+): void {
+  const normalized = normalizeAgentComposerReference(ref);
+  if (!normalized || typeof window === "undefined") return;
+  postAgentChatReferenceMessage(
+    {
+      ...normalized,
+      insertMessageId: `reference-${Date.now()}-${Math.random()
+        .toString(36)
+        .slice(2, 8)}`,
+    },
+    { openSidebar: options.openSidebar === true },
+  );
+}
+
+export function removeAgentChatContextItem(
+  keyOrOpts: string | AgentChatContextRemoveOptions,
+): void {
+  const key =
+    typeof keyOrOpts === "string" ? keyOrOpts.trim() : keyOrOpts.key.trim();
+  if (!key || typeof window === "undefined") return;
+  const openSidebar =
+    typeof keyOrOpts === "string" ? false : keyOrOpts.openSidebar === true;
+
+  publishAgentChatContextItems(
+    agentChatContextState.items.filter((item) => item.key !== key),
+  );
+  postAgentChatContextMessage(
+    AGENT_CHAT_REMOVE_CONTEXT_MESSAGE_TYPE,
+    { key },
+    { openSidebar },
+  );
+}
+
+export function clearAgentChatContext(
+  opts: AgentChatContextMutationOptions = {},
+): void {
+  if (typeof window === "undefined") return;
+  publishAgentChatContextItems([]);
+  postAgentChatContextMessage(
+    AGENT_CHAT_CLEAR_CONTEXT_MESSAGE_TYPE,
+    {},
+    { openSidebar: opts.openSidebar === true },
+  );
+}
+
+export function _resetAgentChatContextForTests(): void {
+  agentChatContextState = { items: [], updatedAt: 0 };
+  notifyAgentChatContextListeners();
+}