@agent-native/core 0.72.2 → 0.72.4

package/corpus/core/src/client/mcp-apps/McpAppRenderer.tsx

@@ -1,4 +1,11 @@
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import {
+  useCallback,
+  useEffect,
+  useLayoutEffect,
+  useMemo,
+  useRef,
+  useState,
+} from "react";
 import {
   AppBridge,
   PostMessageTransport,
@@ -8,8 +15,14 @@ import {
 } from "@modelcontextprotocol/ext-apps/app-bridge";
 import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { IconAlertTriangle, IconLoader2 } from "@tabler/icons-react";
+import {
+  AGENT_NATIVE_EMBED_MESSAGE_TYPES,
+  AGENT_NATIVE_EMBED_PROTOCOL,
+  AGENT_NATIVE_EMBED_VERSION,
+} from "../../embedding/protocol.js";
 import type { AgentMcpAppPayload } from "../../mcp-client/app-result.js";
 import { agentNativePath } from "../api-path.js";
+import { sendToAgentChat, type AgentChatRequestMode } from "../agent-chat.js";
 import { cn } from "../utils.js";
 
 export const DEFAULT_MCP_APP_IFRAME_HEIGHT = 650;
@@ -17,6 +30,8 @@ export const MCP_APP_INITIALIZE_TIMEOUT_MS = 8000;
 const MIN_IFRAME_HEIGHT = 220;
 const VIEWPORT_MARGIN = 16;
 const SANDBOX_FLAGS = "allow-scripts allow-forms allow-popups";
+const useBrowserLayoutEffect =
+  typeof window === "undefined" ? useEffect : useLayoutEffect;
 
 export interface McpAppRendererProps {
   app: AgentMcpAppPayload;
@@ -29,10 +44,24 @@ type ResourceUiMeta = {
   prefersBorder?: boolean;
 };
 
+type McpContentPart = {
+  type?: unknown;
+  text?: unknown;
+  data?: unknown;
+  mimeType?: unknown;
+  url?: unknown;
+};
+
+type McpAppModelContext = {
+  content?: unknown;
+  structuredContent?: unknown;
+};
+
 export function McpAppRenderer({ app, className }: McpAppRendererProps) {
   const iframeRef = useRef<HTMLIFrameElement | null>(null);
   const desiredHeightRef = useRef(DEFAULT_MCP_APP_IFRAME_HEIGHT);
-  const [loadedSrcDoc, setLoadedSrcDoc] = useState<string | null>(null);
+  const modelContextRef = useRef<McpAppModelContext | null>(null);
+  const readyRef = useRef(false);
   const [height, setHeight] = useState(DEFAULT_MCP_APP_IFRAME_HEIGHT);
   const [error, setError] = useState<string | null>(null);
   const [ready, setReady] = useState(false);
@@ -49,6 +78,23 @@ export function McpAppRenderer({ app, className }: McpAppRendererProps) {
   );
   const externalOpenUrl = useMemo(() => openUrlFromMcpApp(app), [app]);
 
+  // Keep the latest payload/permissions/csp reachable from the bridge effect
+  // without making them effect dependencies. The embedded resource identity is
+  // fully captured by `srcDoc`. The bridge effect must NOT re-run when a benign
+  // parent re-render hands us a new `app` object reference with identical
+  // content (common during chat streaming/polling): re-running tears down a
+  // live, already-initialized MCP App (teardownResource) and re-arms the
+  // initialize watchdog against a fresh host AppBridge that the embed shell
+  // will never re-handshake (its connect promise is memoized), surfacing a
+  // false "MCP App did not finish initializing." error after the app is
+  // visibly working.
+  const appRef = useRef(app);
+  const supportedPermissionsRef = useRef(supportedPermissions);
+  const uiCspRef = useRef(uiMeta.csp);
+  appRef.current = app;
+  supportedPermissionsRef.current = supportedPermissions;
+  uiCspRef.current = uiMeta.csp;
+
   useEffect(() => {
     desiredHeightRef.current = DEFAULT_MCP_APP_IFRAME_HEIGHT;
     setHeight(
@@ -57,11 +103,18 @@ export function McpAppRenderer({ app, className }: McpAppRendererProps) {
         availableMcpAppHeight(iframeRef.current),
       ),
     );
-    setLoadedSrcDoc(null);
+    readyRef.current = false;
     setReady(false);
     setError(null);
+    modelContextRef.current = null;
   }, [srcDoc]);
 
+  const markReady = useCallback(() => {
+    readyRef.current = true;
+    setReady(true);
+    setError(null);
+  }, []);
+
   const applyHeight = useCallback((desiredHeight?: number) => {
     if (
       typeof desiredHeight === "number" &&
@@ -114,11 +167,26 @@ export function McpAppRenderer({ app, className }: McpAppRendererProps) {
 
   useEffect(() => {
     const iframe = iframeRef.current;
-    if (!iframe?.contentWindow || !srcDoc || loadedSrcDoc !== srcDoc) return;
+    if (!iframe?.contentWindow || !srcDoc) return;
+    const frameWindow = iframe.contentWindow;
+    const listener = (event: MessageEvent) => {
+      if (event.source !== frameWindow) return;
+      if (isMcpAppReadyMessage(event.data)) {
+        markReady();
+      }
+    };
+    window.addEventListener("message", listener);
+    return () => window.removeEventListener("message", listener);
+  }, [markReady, srcDoc]);
+
+  useBrowserLayoutEffect(() => {
+    const iframe = iframeRef.current;
+    if (!iframe?.contentWindow || !srcDoc) return;
 
+    const currentApp = appRef.current;
     let closed = false;
     const initializeTimer = window.setTimeout(() => {
-      if (closed) return;
+      if (closed || readyRef.current) return;
       setReady(false);
       setError("MCP App did not finish initializing.");
     }, MCP_APP_INITIALIZE_TIMEOUT_MS);
@@ -131,13 +199,13 @@ export function McpAppRenderer({ app, className }: McpAppRendererProps) {
         serverResources: {},
         logging: {},
         sandbox: {
-          permissions: supportedPermissions,
-          csp: uiMeta.csp ?? {},
+          permissions: supportedPermissionsRef.current,
+          csp: uiCspRef.current ?? {},
         },
       },
       {
         hostContext: buildHostContext(
-          app,
+          currentApp,
           availableMcpAppHeight(iframe),
         ) as any,
       },
@@ -152,12 +220,9 @@ export function McpAppRenderer({ app, className }: McpAppRendererProps) {
     bridge.addEventListener("initialized", () => {
       if (closed) return;
       clearTimeout(initializeTimer);
-      setReady(true);
-      // Clear any error the initialize timeout may have set before a slow app
-      // finished — otherwise the error overlay stays stuck over a working app.
-      setError(null);
-      void bridge.sendToolInput({ arguments: app.toolInput });
-      void bridge.sendToolResult(app.toolResult as CallToolResult);
+      markReady();
+      void bridge.sendToolInput({ arguments: appRef.current.toolInput });
+      void bridge.sendToolResult(appRef.current.toolResult as CallToolResult);
     });
     bridge.addEventListener("loggingmessage", ({ level, data }) => {
       if (level === "error" || level === "critical" || level === "alert") {
@@ -170,13 +235,16 @@ export function McpAppRenderer({ app, className }: McpAppRendererProps) {
       return {};
     };
     bridge.oncalltool = async ({ name, arguments: toolArguments }) => {
-      const toolName = normalizeSameServerToolName(app.serverId, name);
+      const toolName = normalizeSameServerToolName(
+        appRef.current.serverId,
+        name,
+      );
       if (!toolName) {
         return errorToolResult("Cross-server MCP App tool calls are blocked.");
       }
       try {
         return await postMcpAppEndpoint<CallToolResult>("call-tool", {
-          serverId: app.serverId,
+          serverId: appRef.current.serverId,
           toolName,
           arguments:
             toolArguments && typeof toolArguments === "object"
@@ -188,22 +256,40 @@ export function McpAppRenderer({ app, className }: McpAppRendererProps) {
       }
     };
     (bridge as any).onlisttools = async () =>
-      postMcpAppEndpoint("list-tools", { serverId: app.serverId });
+      postMcpAppEndpoint("list-tools", { serverId: appRef.current.serverId });
     bridge.onreadresource = async ({ uri }) =>
-      postMcpAppEndpoint("read-resource", { serverId: app.serverId, uri });
+      postMcpAppEndpoint("read-resource", {
+        serverId: appRef.current.serverId,
+        uri,
+      });
     bridge.onlistresources = async () => ({ resources: [] });
     bridge.onlistresourcetemplates = async () => ({ resourceTemplates: [] });
     bridge.ondownloadfile = async () => ({ isError: true });
-    bridge.onmessage = async () => ({ isError: true });
-    bridge.onupdatemodelcontext = async () => ({});
+    bridge.onmessage = async (params) => {
+      const message = messageTextFromMcpUiMessage(params);
+      if (!message.trim()) return { isError: true };
+      const mode = requestModeFromMcpUiMessage(params);
+      sendToAgentChat({
+        message,
+        context: contextTextFromMcpModelContext(modelContextRef.current),
+        images: imageDataUrlsFromMcpContent(params.content),
+        submit: true,
+        openSidebar: true,
+        ...(mode ? { mode } : {}),
+      });
+      return {};
+    };
+    bridge.onupdatemodelcontext = async (params) => {
+      modelContextRef.current = params as McpAppModelContext;
+      return {};
+    };
 
     const transport = new PostMessageTransport(
       iframe.contentWindow,
       iframe.contentWindow,
     );
-    setReady(false);
     setError(null);
-    bridge.connect(transport).catch((err: any) => {
+    void bridge.connect(transport).catch((err: any) => {
       if (!closed) {
         clearTimeout(initializeTimer);
         setError(err?.message ?? "Failed to initialize MCP App.");
@@ -212,8 +298,8 @@ export function McpAppRenderer({ app, className }: McpAppRendererProps) {
 
     return () => {
       closed = true;
+      modelContextRef.current = null;
       clearTimeout(initializeTimer);
-      setReady(false);
       void bridge
         .teardownResource({}, { timeout: 500 })
         .catch(() => undefined)
@@ -221,14 +307,10 @@ export function McpAppRenderer({ app, className }: McpAppRendererProps) {
           void (bridge as any).close?.().catch?.(() => undefined);
         });
     };
-  }, [
-    app,
-    applyHeight,
-    loadedSrcDoc,
-    srcDoc,
-    supportedPermissions,
-    uiMeta.csp,
-  ]);
+    // The embedded resource identity is captured by `srcDoc`; `app`,
+    // `supportedPermissions`, and `uiMeta.csp` are read via refs so a
+    // new-but-equal `app` object reference does not tear down a live bridge.
+  }, [applyHeight, markReady, srcDoc]);
 
   if (!resourceHtml) {
     return (
@@ -277,12 +359,83 @@ export function McpAppRenderer({ app, className }: McpAppRendererProps) {
         sandbox={SANDBOX_FLAGS}
         allow={buildAllowAttribute(supportedPermissions)}
         style={{ height }}
-        onLoad={() => setLoadedSrcDoc(srcDoc)}
       />
     </div>
   );
 }
 
+function messageTextFromMcpUiMessage(params: { content?: unknown }): string {
+  return textPartsFromMcpContent(params.content).join("\n\n").trim();
+}
+
+function requestModeFromMcpUiMessage(
+  params: unknown,
+): AgentChatRequestMode | undefined {
+  const record =
+    params && typeof params === "object" && !Array.isArray(params)
+      ? (params as { mode?: unknown; requestMode?: unknown })
+      : {};
+  const mode = record.requestMode ?? record.mode;
+  return mode === "act" || mode === "plan" ? mode : undefined;
+}
+
+function contextTextFromMcpModelContext(
+  context: McpAppModelContext | null,
+): string | undefined {
+  if (!context) return undefined;
+  const parts = textPartsFromMcpContent(context.content);
+  if (context.structuredContent !== undefined) {
+    parts.push(JSON.stringify(context.structuredContent, null, 2));
+  }
+  const text = parts.join("\n\n").trim();
+  return text || undefined;
+}
+
+function textPartsFromMcpContent(content: unknown): string[] {
+  if (!Array.isArray(content)) return [];
+  return content
+    .map((part): string | null => {
+      const record = contentPartRecord(part);
+      if (
+        !record ||
+        record.type !== "text" ||
+        typeof record.text !== "string"
+      ) {
+        return null;
+      }
+      const text = record.text.trim();
+      return text || null;
+    })
+    .filter((text): text is string => Boolean(text));
+}
+
+function imageDataUrlsFromMcpContent(content: unknown): string[] | undefined {
+  if (!Array.isArray(content)) return undefined;
+  const images = content
+    .map((part): string | null => {
+      const record = contentPartRecord(part);
+      if (!record || record.type !== "image") return null;
+      if (typeof record.url === "string" && record.url.trim()) {
+        return record.url;
+      }
+      if (typeof record.data !== "string" || !record.data.trim()) return null;
+      const mimeType =
+        typeof record.mimeType === "string" &&
+        record.mimeType.startsWith("image/")
+          ? record.mimeType
+          : "image/png";
+      return `data:${mimeType};base64,${record.data}`;
+    })
+    .filter((image): image is string => Boolean(image));
+  return images.length ? images : undefined;
+}
+
+function contentPartRecord(part: unknown): McpContentPart | null {
+  return part && typeof part === "object" && !Array.isArray(part)
+    ? (part as McpContentPart)
+    : null;
+}
+
 function resourceUiMeta(app: AgentMcpAppPayload): ResourceUiMeta {
   const meta = app.resource?._meta;
   const ui =
@@ -341,8 +494,31 @@ export function supportedMcpAppPermissions(
   return permissions?.clipboardWrite ? { clipboardWrite: {} } : {};
 }
 
+export function isMcpAppReadyMessage(data: unknown): boolean {
+  if (!data || typeof data !== "object" || Array.isArray(data)) return false;
+  const record = data as {
+    protocol?: unknown;
+    version?: unknown;
+    type?: unknown;
+  };
+  if (
+    record.protocol === AGENT_NATIVE_EMBED_PROTOCOL &&
+    record.version === AGENT_NATIVE_EMBED_VERSION &&
+    record.type === AGENT_NATIVE_EMBED_MESSAGE_TYPES.READY
+  ) {
+    return true;
+  }
+  const type = record.type;
+  return (
+    type === "agentNative.embeddedAppReady" ||
+    type === "agentNative.frameOrigin"
+  );
+}
+
 export function buildMcpAppCsp(csp: McpUiResourceCsp | undefined): string {
-  const connect = sanitizeCspSources(csp?.connectDomains);
+  const connect = withLocalWebSocketSources(
+    sanitizeCspSources(csp?.connectDomains),
+  );
   const resources = sanitizeCspSources(csp?.resourceDomains);
   const frames = sanitizeCspSources(csp?.frameDomains);
   const base = sanitizeCspSources(csp?.baseUriDomains);
@@ -369,6 +545,24 @@ function sanitizeCspSources(values: string[] | undefined): string[] {
   return [...new Set(out)];
 }
 
+function withLocalWebSocketSources(sources: string[]): string[] {
+  const out = [...sources];
+  for (const source of sources) {
+    try {
+      const url = new URL(source);
+      if (
+        url.protocol === "http:" &&
+        ["localhost", "127.0.0.1", "::1"].includes(url.hostname)
+      ) {
+        out.push(`ws://${url.host}`);
+      }
+    } catch {
+      // Ignore non-URL CSP source expressions.
+    }
+  }
+  return [...new Set(out)];
+}
+
 function sanitizeCspSource(value: string): string | null {
   const source = value.trim();
   if (!source || source.includes("'") || /[\s;]/.test(source)) return null;

package/corpus/core/src/client/resources/use-mcp-servers.ts

@@ -20,6 +20,7 @@ export interface McpServer {
   url: string;
   headers?: Record<string, { set: true }>;
   description?: string;
+  firstParty?: boolean;
   createdAt: number;
   mergedId: string;
   status:

package/corpus/core/src/client/settings/DemoModeSection.tsx

@@ -33,7 +33,9 @@ export function DemoModeSection() {
   const { data } = useQuery({
     queryKey: ["agent-native", "demo-mode"],
     queryFn: async () => {
-      const res = await fetch(DEMO_STATUS_URL, { credentials: "include" });
+      const res = await fetch(DEMO_STATUS_URL, {
+        credentials: "same-origin",
+      });
       if (!res.ok) return null;
       return (await res.json()) as DemoStatus | null;
     },

package/corpus/core/src/client/use-agent-chat-home-handoff.ts

@@ -1,4 +1,4 @@
-import { useEffect, useState } from "react";
+import { useEffect, useRef, useState } from "react";
 import { useLocation, useNavigate } from "react-router";
 import { appBasePath } from "./api-path.js";
 import {
@@ -21,6 +21,12 @@ export interface UseAgentChatHomeHandoffLinksOptions {
   storageKey?: string | null;
   /** Router-local path for the full-page chat route. Defaults to "/". */
   chatPath?: string;
+  /**
+   * Matches every router-local pathname owned by the full-page chat surface.
+   * Defaults to an exact match against `chatPath`. Pass this to cover deep
+   * links such as `/chat/:threadId`.
+   */
+  isChatPath?: (pathname: string) => boolean;
   /** Disable link interception without changing hook call order. */
   enabled?: boolean;
 }
@@ -120,13 +126,19 @@ export function useAgentChatHomeHandoff({
 export function useAgentChatHomeHandoffLinks({
   storageKey,
   chatPath = "/",
+  isChatPath,
   enabled = true,
 }: UseAgentChatHomeHandoffLinksOptions): void {
   const location = useLocation();
   const navigate = useNavigate();
+  const matchesChatPathRef = useRef<(pathname: string) => boolean>(() => false);
+  matchesChatPathRef.current =
+    isChatPath ?? ((pathname: string) => pathname === chatPath);
 
   useEffect(() => {
-    if (!enabled || stripBasePath(location.pathname) !== chatPath) return;
+    const matchesChatPath = (pathname: string) =>
+      matchesChatPathRef.current(pathname);
+    if (!enabled || !matchesChatPath(stripBasePath(location.pathname))) return;
     if (typeof document === "undefined") return;
 
     function handleClick(event: MouseEvent) {
@@ -141,7 +153,7 @@ export function useAgentChatHomeHandoffLinks({
       const pathname = path ? pathnameFromLocalPath(path) : "";
       if (
         !path ||
-        pathname === chatPath ||
+        matchesChatPath(pathname) ||
         isFrameworkOrApiPath(pathname) ||
         isStaticAssetPath(pathname)
       ) {
@@ -155,5 +167,5 @@ export function useAgentChatHomeHandoffLinks({
 
     document.addEventListener("click", handleClick, true);
     return () => document.removeEventListener("click", handleClick, true);
-  }, [chatPath, enabled, location.pathname, navigate, storageKey]);
+  }, [enabled, location.pathname, navigate, storageKey]);
 }

package/corpus/core/src/client/use-chat-threads.ts

@@ -63,6 +63,12 @@ export interface UseChatThreadsOptions {
   autoCreate?: boolean;
   /** Restore the active thread from localStorage. Defaults to true. */
   restoreActiveThread?: boolean;
+  /**
+   * Route-owned active thread. `undefined` preserves the legacy localStorage
+   * source of truth; a string opens that thread; `null` means the URL is in
+   * create/new-chat mode.
+   */
+  routeThreadId?: string | null;
 }
 
 const ACTIVE_THREAD_KEY = "agent-chat-active-thread";
@@ -114,6 +120,12 @@ function createLocalThreadId(): string {
   return `thread-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
 }
 
+function normalizeThreadId(value: string | null | undefined): string | null {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed || null;
+}
+
 function scopesMatch(
   a?: ChatThreadScope | null,
   b?: ChatThreadScope | null,
@@ -155,6 +167,8 @@ export function useChatThreads(
 ) {
   const autoCreate = options?.autoCreate !== false;
   const restoreActiveThread = options?.restoreActiveThread !== false;
+  const routeControlsActiveThread = options?.routeThreadId !== undefined;
+  const routeThreadId = normalizeThreadId(options?.routeThreadId);
   // Each (storageKey, scope) pair gets its own active-thread localStorage key
   // for chats that belong to a resource. General chats keep using the unscoped
   // key even while the user is looking at a resource, so clicking into a deck,
@@ -180,10 +194,16 @@ export function useChatThreads(
     let id: string | null = null;
     let isNew = false;
     if (typeof window !== "undefined") {
-      try {
-        id = restoreActiveThread ? localStorage.getItem(activeThreadKey) : null;
-      } catch {
-        id = null;
+      if (routeControlsActiveThread) {
+        id = routeThreadId;
+      } else {
+        try {
+          id = restoreActiveThread
+            ? localStorage.getItem(activeThreadKey)
+            : null;
+        } catch {
+          id = null;
+        }
       }
       if (!id && autoCreate) {
         id = createLocalThreadId();
@@ -323,6 +343,10 @@ export function useChatThreads(
   const persistedKeyRef = useRef(activeThreadKey);
   useEffect(() => {
     if (persistedKeyRef.current !== activeThreadKey) {
+      if (routeControlsActiveThread) {
+        persistedKeyRef.current = activeThreadKey;
+        return;
+      }
       const currentId = activeThreadIdRef.current;
       if (currentId) {
         const currentThreadScope = readKnownThreadScope(currentId);
@@ -357,6 +381,11 @@ export function useChatThreads(
       return;
     }
     try {
+      if (routeControlsActiveThread && !routeThreadId) {
+        localStorage.removeItem(activeThreadKey);
+        localStorage.removeItem(activeThreadSeenKey);
+        return;
+      }
       if (activeThreadId) {
         const threadScope = readKnownThreadScope(activeThreadId);
         if (threadScope === undefined) return;
@@ -378,6 +407,8 @@ export function useChatThreads(
     addOptimisticThread,
     autoCreate,
     readKnownThreadScope,
+    routeControlsActiveThread,
+    routeThreadId,
     storageKey,
     threads,
   ]);
@@ -484,6 +515,10 @@ export function useChatThreads(
       const loadedHasSavedId = Boolean(
         savedId && loadedThreads.some((t) => t.id === savedId),
       );
+      const savedIdCameFromRoute =
+        Boolean(savedId) &&
+        routeControlsActiveThread &&
+        routeThreadId === savedId;
 
       if (
         savedId &&
@@ -491,6 +526,11 @@ export function useChatThreads(
         !loadedHasSavedId
       ) {
         addOptimisticThread(savedId, scopeRef.current ?? null);
+      } else if (savedId && savedIdCameFromRoute && !loadedHasSavedId) {
+        // A deep link may point to a thread that is not in the current list
+        // response. Keep it route-owned so AssistantChat can restore it via
+        // /threads/:id instead of reclassifying it as a new empty tab.
+        setActiveThreadId(savedId);
       } else if (
         savedId &&
         !newlyCreatedRef.current.has(savedId) &&
@@ -526,7 +566,13 @@ export function useChatThreads(
       }
       setIsLoading(false);
     })();
-  }, [fetchThreads, addOptimisticThread, autoCreate]);
+  }, [
+    fetchThreads,
+    addOptimisticThread,
+    autoCreate,
+    routeControlsActiveThread,
+    routeThreadId,
+  ]);
 
   const createThread = useCallback(
     (preferredId?: string): Promise<string | null> => {
@@ -543,6 +589,41 @@ export function useChatThreads(
     [addOptimisticThread],
   );
 
+  useEffect(() => {
+    if (!routeControlsActiveThread) return;
+    if (routeThreadId) {
+      if (activeThreadIdRef.current !== routeThreadId) {
+        setActiveThreadId(routeThreadId);
+      }
+      return;
+    }
+
+    const currentId = activeThreadIdRef.current;
+    const currentThread = currentId
+      ? threadsRef.current.find((thread) => thread.id === currentId)
+      : undefined;
+    const currentIsUnsavedNewThread =
+      currentId !== null &&
+      newlyCreatedRef.current.has(currentId) &&
+      (currentThread?.messageCount ?? 0) === 0;
+    if (currentIsUnsavedNewThread) return;
+
+    if (!autoCreate) {
+      if (currentId !== null) setActiveThreadId(null);
+      return;
+    }
+
+    const id = createLocalThreadId();
+    newlyCreatedRef.current.add(id);
+    addOptimisticThread(id, scopeRef.current ?? null);
+    setActiveThreadId(id);
+  }, [
+    addOptimisticThread,
+    autoCreate,
+    routeControlsActiveThread,
+    routeThreadId,
+  ]);
+
   // Drop a thread's scope so it becomes a general (cross-resource) chat.
   // This is the "Detach from <deck>" escape hatch in the UI. The PUT
   // also bumps the thread's updatedAt so it surfaces in the All Chats

package/corpus/core/src/demo/fetch-interceptor.ts

@@ -91,7 +91,7 @@ function methodOf(input: RequestInfo | URL, init?: RequestInit): string {
 async function refreshDemoFlag(): Promise<void> {
   const f = originalFetch ?? fetch;
   try {
-    const res = await f(STATUS_PATH, { credentials: "include" });
+    const res = await f(STATUS_PATH, { credentials: "same-origin" });
     if (!res.ok) return;
     const json = (await res.json()) as {
       enabled?: boolean;

package/corpus/core/src/embedding/agent.ts

@@ -1,4 +1,9 @@
-import { A2AClient, callAgent, type Message, type Task } from "../a2a/index.js";
+import {
+  A2AClient,
+  callAgent,
+  type Message,
+  type Task,
+} from "@agent-native/core/a2a";
 
 export interface AgentEndpointOptions {
   /**