@mcp-b/react-components 0.46.7 → 0.47.0

package/dist/{CodeBlock-CcteqDvA.js → CodeBlock-DMHZiw86.js}

@@ -1,6 +1,6 @@
 import { t as cx } from "./class-names-BiMDVpUo.js";
+import { t as CopyButton } from "./copy-button-CSDuDfdP.js";
 import { Select } from "./components/foundations/Select.js";
-import { t as CopyButton } from "./copy-button-BABPlsc-.js";
 import * as React from "react";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { createHighlighter } from "shiki";

package/dist/{FileTree-jtP9471I.js → FileTree-BHebfvkK.js}

@@ -1,5 +1,5 @@
 import { t as cx } from "./class-names-BiMDVpUo.js";
-import { C as FolderIcon, S as FileIcon, p as ChevronRightIcon, w as FolderOpenIcon } from "./icons-BC4HZqSK.js";
+import { C as FolderIcon, S as FileIcon, p as ChevronRightIcon, w as FolderOpenIcon } from "./icons-cuEtsgj9.js";
 import { t as NavigationLink } from "./navigation-link-kqMa81v5.js";
 import * as React from "react";
 import { jsx, jsxs } from "react/jsx-runtime";

package/dist/{SetupChecklist-BXwSSorj.js → SetupChecklist-CwRjIDH4.js}

@@ -1,5 +1,5 @@
 import { n as mergeBaseClassName } from "./class-names-BiMDVpUo.js";
-import { $ as WarningIcon, B as PlusIcon, d as CheckIcon, f as ChevronDownIcon } from "./icons-BC4HZqSK.js";
+import { B as PlusIcon, d as CheckIcon, et as WarningIcon, f as ChevronDownIcon } from "./icons-cuEtsgj9.js";
 import { Button } from "./components/foundations/Button.js";
 import { Menu } from "./components/foundations/Menu.js";
 import * as React from "react";

package/dist/ThinkChat-CwMdEum8.d.ts

@@ -0,0 +1,185 @@
+import { i as AgentMessageRenderPartContext } from "./AgentMessageParts-C7L-Mv9U.js";
+import { K as PromptInputMessage } from "./PromptInput-DtJHyp0S.js";
+import { r as AgentChatProps } from "./AgentChat-BLmQghkt.js";
+import { n as AgentToolEventsValue } from "./AgentToolRunsContext-jtmveaRE.js";
+import { o as UseSessionCompactionResult } from "./SessionCompaction-CmTJFpzj.js";
+import { o as createThinkChatActivityRenderer, r as ThinkChatActivityRendererOptions, t as ThinkChatActivity } from "./ThinkChatActivity-B3lGVS-6.js";
+import { i as ThinkChatValue } from "./ThinkChatContext-COIgzkYp.js";
+import { t as ThinkRecoveryNotice } from "./ThinkRecoveryNotice-DGWr94rk.js";
+import { n as WorkspaceFileRenderer } from "./WorkspaceMessageResponse-kJYU8Onj.js";
+import * as React from "react";
+import { UIMessage } from "ai";
+import { UseAgentOptions } from "agents/react";
+import { DataTag, UndefinedInitialDataOptions } from "@tanstack/react-query";
+import { PendingApproval, Think } from "@cloudflare/think";
+import { AgentStub } from "agents/client";
+
+//#region src/components/agents-sdk/ThinkChat.d.ts
+type ThinkPendingExecutionApprovalsQueryKey = readonly ["think", sourceKey: string, "pending-approvals"];
+type ThinkPendingExecutionApprovalsQueryOptions = UndefinedInitialDataOptions<readonly PendingApproval[], Error, readonly PendingApproval[], ThinkPendingExecutionApprovalsQueryKey> & {
+  queryKey: DataTag<ThinkPendingExecutionApprovalsQueryKey, readonly PendingApproval[], Error>;
+};
+interface ThinkChatProviderProps<State = unknown, MessageT extends UIMessage = UIMessage> {
+  /** The `useAgentChat` value from `@cloudflare/think/react` that descendants read. */
+  chat: ThinkChatValue<State, MessageT>;
+  /** Optional whole `useAgentToolEvents` result when the app owns the parent connection. */
+  agentTools?: AgentToolEventsValue<MessageT["parts"][number]>;
+  children: React.ReactNode;
+}
+interface ThinkChatRootProps<State = unknown> {
+  /** Agent to connect to: a kebab-case class name, or full `useAgent` options. */
+  agent: string | UseAgentOptions<State>;
+  /** Disable durable pending-approval discovery. Also disable it on `ThinkChat.Messages`. */
+  approvalsEnabled?: boolean;
+  /** Instance name (e.g. a session or room id). Wins over `agent.name`. */
+  name?: string;
+  /**
+   * Stable, non-secret identity for the remote Think agent. Include endpoint,
+   * account or tenant scope, and agent path so sources cannot share cached data.
+   */
+  sourceKey: string;
+  children: React.ReactNode;
+}
+/**
+ * The first-turn surface with no conversation behind it. Supply this instead of
+ * a chat provider when the composer's submission is what creates the
+ * conversation: connecting early is what leaves empty threads behind.
+ */
+interface ThinkChatDraft<MessageT extends UIMessage = UIMessage> {
+  /** Client-only transcript rows, such as a locally rendered guide. */
+  messages?: readonly MessageT[];
+  /** Receives the first message, normalized the same way a live thread's is. */
+  onSubmit: (message: {
+    text: string;
+    files: PromptInputMessage["files"];
+  }) => void | Promise<void>;
+  /** Set while the app is creating the conversation, so the composer reads busy. */
+  status?: AgentChatProps<MessageT>["status"];
+}
+type ThinkChatManagedAgentChatProp = "messages" | "onApprovalResponse" | "onRegenerate" | "onStop" | "onSubmit" | "status";
+/**
+ * The AgentChat composition surface, minus the live values ThinkChat supplies
+ * from `useAgentChat`. Think-specific activity and draft/session inputs extend
+ * that owner instead of mirroring every AgentChat prop here.
+ */
+type ThinkChatMessagesProps<MessageT extends UIMessage = UIMessage> = Omit<AgentChatProps<MessageT>, ThinkChatManagedAgentChatProp> & ThinkChatActivityRendererOptions<MessageT> & {
+  /**
+   * Renders without a chat provider, for the first turn of a conversation
+   * that does not exist yet.
+   */
+  draft?: ThinkChatDraft<MessageT>; /** Whole `useSessionCompaction` result for built-in progress and error notices. */
+  sessionCompaction?: UseSessionCompactionResult;
+  /**
+   * Promotes one standalone assistant workspace file link through a host
+   * callback. Return a node to replace the link, or `null` to keep it.
+   */
+  renderWorkspaceFile?: WorkspaceFileRenderer;
+};
+/** Shared pending-approval options for components and TanStack Router loaders. */
+declare function thinkPendingExecutionApprovalsQueryOptions(stub: AgentStub<Think>, sourceKey: string): ThinkPendingExecutionApprovalsQueryOptions;
+declare function useThinkPendingExecutionApprovals(stub: AgentStub<Think>, sourceKey: string, refreshSignal?: unknown, enabled?: boolean): {
+  pendingApprovals: readonly PendingApproval[];
+  refreshPendingApprovals: () => Promise<void>;
+};
+/**
+ * Chat UI for Cloudflare Think agents. Provide a `useAgentChat` value (or let
+ * `ThinkChat.Root` create one) and `ThinkChat.Messages` renders the message
+ * stream with agent work folded into collapsed Activity blocks.
+ */
+declare function ThinkChatProvider<State = unknown, MessageT extends UIMessage = UIMessage>({
+  agentTools,
+  chat,
+  children
+}: ThinkChatProviderProps<State, MessageT>): React.JSX.Element;
+/**
+ * Batteries-included root: connects to the named Think agent (upstream's
+ * `useAgent` + `useAgentChat`) and provides the live chat to everything
+ * inside. Render it beneath the app's `QueryClientProvider`. If the app
+ * already owns the chat hook, use `ThinkChat.Provider`.
+ *
+ * @example
+ * ```tsx
+ * <QueryClientProvider client={queryClient}>
+ *   <ThinkChat.Root
+ *     agent="my-agent"
+ *     name="session-1"
+ *     sourceKey="api.example.com:account:acme:agent:session-1"
+ *   >
+ *     <ThinkChat.Messages />
+ *   </ThinkChat.Root>
+ * </QueryClientProvider>
+ * ```
+ */
+declare function ThinkChatRoot<State = unknown, MessageT extends UIMessage = UIMessage>({
+  agent: agentOption,
+  approvalsEnabled,
+  name,
+  sourceKey,
+  children
+}: ThinkChatRootProps<State>): React.JSX.Element;
+/**
+ * The full conversation surface — message list plus composer — with the
+ * activity renderer as the default `renderPart`: runs of reasoning/tool parts
+ * fold into one collapsed Activity block with derived labels and per-tool
+ * panels. Session-generated context/load/search tools are recognized from
+ * their upstream runtime schemas and keep their recorded inputs and outputs
+ * inspectable. Extend for app-specific tools with `toolRenderers` (label/panel
+ * inside the log) or `excludeTools` + your own `renderPart` (standalone
+ * card) — see README "App-specific tools" and the Custom Tool Panel story.
+ */
+declare function ThinkChatMessages<State = unknown, MessageT extends UIMessage = UIMessage>({
+  draft,
+  loading,
+  renderPart,
+  excludeTools,
+  renderAgentToolRunLink,
+  renderWorkspaceFile,
+  toolRenderers,
+  thinkStub,
+  onExecutionSettled,
+  pendingApprovals,
+  notice,
+  sessionCompaction,
+  ...props
+}: ThinkChatMessagesProps<MessageT>): React.JSX.Element;
+/**
+ * The ambient chat value from `ThinkChat.Root`/`Provider` — for custom tool
+ * panels, cards, or composer actions that need `messages`, `status`, or
+ * `sendMessage`. Throws outside a provider.
+ */
+declare function useThinkChat<State = unknown, MessageT extends UIMessage = UIMessage>(): Omit<import("@ai-sdk/react").UseChatHelpers<MessageT>, "addToolOutput"> & {
+  clearHistory: () => void;
+  addToolOutput: (opts: {
+    toolCallId: string;
+    toolName?: string;
+    output?: unknown;
+    state?: "output-available" | "output-error";
+    errorText?: string;
+  }) => void;
+  isServerStreaming: boolean;
+  isStreaming: boolean;
+  isRecovering: boolean;
+  isToolContinuation: boolean;
+  connectionError: (Error & {
+    code: number;
+    reason: string;
+    wasClean: boolean;
+  }) | null;
+};
+/**
+ * Namespace entry point. `Root` + `Messages` is the standard surface;
+ * `Provider` + `useThinkChat` when the app owns the chat hook; `Activity`,
+ * `renderActivityPart`, and `createActivityRenderer` for custom layouts and
+ * app-specific tools.
+ */
+declare const ThinkChat: {
+  Provider: typeof ThinkChatProvider;
+  Root: typeof ThinkChatRoot;
+  Messages: typeof ThinkChatMessages;
+  Activity: typeof ThinkChatActivity;
+  RecoveryNotice: typeof ThinkRecoveryNotice;
+  renderActivityPart: (context: AgentMessageRenderPartContext<UIMessage<unknown, import("ai").UIDataTypes, import("ai").UITools>>) => React.ReactNode | undefined;
+  createActivityRenderer: typeof createThinkChatActivityRenderer;
+};
+//#endregion
+export { ThinkChatProvider as a, ThinkChatRootProps as c, thinkPendingExecutionApprovalsQueryOptions as d, useThinkChat as f, ThinkChatMessagesProps as i, ThinkPendingExecutionApprovalsQueryKey as l, ThinkChatDraft as n, ThinkChatProviderProps as o, useThinkPendingExecutionApprovals as p, ThinkChatMessages as r, ThinkChatRoot as s, ThinkChat as t, ThinkPendingExecutionApprovalsQueryOptions as u };

package/dist/{ThinkChat-qztQ6Clo.js → ThinkChat-DLDta57t.js}

@@ -1,16 +1,16 @@
 import { composerDraftToPrompt, parseComposerLinks } from "./utils/composer-link.js";
-import { TransitionSurface } from "./components/foundations/TransitionSurface.js";
 import { AgentToolRunsProvider, useSourceScopedAgentToolEvents } from "./components/agents-sdk/AgentToolRunsContext.js";
+import { TransitionSurface } from "./components/foundations/TransitionSurface.js";
 import { AgentChat, compactingNotice } from "./components/agents-sdk/AgentChat.js";
 import { ThinkChatContext, ThinkChatLiveContext, useOptionalThinkChatContext, useThinkChatContext } from "./components/agents-sdk/ThinkChatContext.js";
 import { ThinkChatActivity, createThinkChatActivityRenderer, renderThinkChatActivityPart } from "./components/agents-sdk/ThinkChatActivity.js";
 import { ThinkRecoveryNotice } from "./components/agents-sdk/ThinkRecoveryNotice.js";
-import { t as WorkspaceMessageResponse } from "./WorkspaceMessageResponse-CJCmGvTx.js";
+import { n as WorkspaceMessageResponse, t as WorkspaceFileRendererProvider } from "./WorkspaceMessageResponse-Dg_aNpoj.js";
 import * as React from "react";
 import { jsx, jsxs } from "react/jsx-runtime";
 import { isTextUIPart } from "ai";
-import { useAgentChat } from "@cloudflare/think/react";
 import { useAgent } from "agents/react";
+import { useAgentChat } from "@cloudflare/think/react";
 import { queryOptions, useQuery, useQueryClient } from "@tanstack/react-query";
 //#region src/components/_internal/think-approvals.ts
 /**
@@ -195,7 +195,7 @@ const ThinkChatApprovalsContext = React.createContext(null);
 * inside the log) or `excludeTools` + your own `renderPart` (standalone
 * card) — see README "App-specific tools" and the Custom Tool Panel story.
 */
-function ThinkChatMessages({ draft, loading, renderPart, excludeTools, renderAgentToolRunLink, renderWorkspaceHtmlArtifact, toolRenderers, thinkStub, onExecutionSettled, pendingApprovals, notice, sessionCompaction, ...props }) {
+function ThinkChatMessages({ draft, loading, renderPart, excludeTools, renderAgentToolRunLink, renderWorkspaceFile, toolRenderers, thinkStub, onExecutionSettled, pendingApprovals, notice, sessionCompaction, ...props }) {
 	const chat = useOptionalThinkChatContext();
 	const approvals = React.useContext(ThinkChatApprovalsContext);
 	const resolvedApprovals = resolveThinkApprovalProps({
@@ -223,14 +223,10 @@ function ThinkChatMessages({ draft, loading, renderPart, excludeTools, renderAge
 		return isTextUIPart(context.part) && context.part.text ? /* @__PURE__ */ jsx(WorkspaceMessageResponse, {
 			animated: STREAMED_TEXT_ANIMATION,
 			isAnimating: context.message.role === "assistant" && context.message.id === streamingMessageId && context.part.state === "streaming",
-			renderWorkspaceHtmlArtifact: context.message.role === "assistant" ? renderWorkspaceHtmlArtifact : void 0,
+			promoteWorkspaceFiles: context.message.role === "assistant",
 			children: context.part.text
 		}) : void 0;
-	}, [
-		activityRenderPart,
-		renderWorkspaceHtmlArtifact,
-		streamingMessageId
-	]);
+	}, [activityRenderPart, streamingMessageId]);
 	const resolvedRenderPart = React.useMemo(() => renderPart ? (context) => {
 		const renderBuiltIn = () => {
 			const builtIn = defaultRenderPart(context);
@@ -269,7 +265,11 @@ function ThinkChatMessages({ draft, loading, renderPart, excludeTools, renderAge
 			files
 		});
 	};
-	if (loading) return /* @__PURE__ */ jsx(AgentChat, {
+	const withWorkspaceFileRenderer = (lane) => /* @__PURE__ */ jsx(WorkspaceFileRendererProvider, {
+		renderWorkspaceFile,
+		children: lane
+	});
+	if (loading) return withWorkspaceFileRenderer(/* @__PURE__ */ jsx(AgentChat, {
 		showComposer: true,
 		...props,
 		renderPart: resolvedRenderPart,
@@ -277,19 +277,19 @@ function ThinkChatMessages({ draft, loading, renderPart, excludeTools, renderAge
 		status: "ready",
 		notice,
 		loading: true
-	});
+	}));
 	if (!chat) {
 		if (!draft) throw new Error("ThinkChat.Messages must be used inside <ThinkChat.Provider> or <ThinkChat.Root>, or given a `draft`, or set `loading` while one hydrates.");
-		return /* @__PURE__ */ jsx(AgentChat, {
+		return withWorkspaceFileRenderer(/* @__PURE__ */ jsx(AgentChat, {
 			...props,
 			renderPart: resolvedRenderPart,
 			messages: draft.messages ?? EMPTY_DRAFT_MESSAGES,
 			status: draft.status ?? "ready",
 			notice: notice ?? sessionCompactionNotice,
 			onSubmit: (message) => submit(message, draft.onSubmit)
-		});
+		}));
 	}
-	return /* @__PURE__ */ jsx(AgentChat, {
+	return withWorkspaceFileRenderer(/* @__PURE__ */ jsx(AgentChat, {
 		...props,
 		renderPart: resolvedRenderPart,
 		messages: chat.messages,
@@ -302,7 +302,7 @@ function ThinkChatMessages({ draft, loading, renderPart, excludeTools, renderAge
 		notice: notice ?? (recoveryActive ? defaultNotice : sessionCompactionNotice),
 		onRegenerate: (messageId) => void chat.regenerate({ messageId }),
 		onSubmit: (message) => submit(message, chat.sendMessage)
-	});
+	}));
 }
 const EMPTY_DRAFT_MESSAGES = [];
 /**

package/dist/ThinkThreadPicker-yFz4vvIf.d.ts

@@ -0,0 +1,91 @@
+import * as React from "react";
+
+//#region src/components/agents-sdk/ThinkThreadPicker.d.ts
+interface ThinkThreadItem {
+  /** Stable child-agent/thread id used by the app-authored link's route params. */
+  id: string;
+  /** Human-readable thread title, usually generated by the parent Think agent. */
+  title: string;
+  /** Optional parent-owned preview for apps that render their own richer sidebar. */
+  lastMessagePreview?: string;
+  /** Timestamp from the parent registry or metadata row. `updatedAt` wins over `createdAt`. */
+  createdAt?: Date | number;
+  /** Timestamp from parent-owned thread metadata when available. */
+  updatedAt?: Date | number;
+  /** Preformatted timestamp label when the app already has one, such as "14m". */
+  updatedAtLabel?: string;
+  /** Optional upstream/app status string. The picker only displays it; it does not derive it. */
+  status?: string;
+  /** Human label for `status` when the raw upstream value is not user-facing. */
+  statusLabel?: string;
+}
+interface ThinkThreadStatusSummary {
+  /** Threads currently processing a turn. */
+  running: number;
+  /** Completed or interrupted background threads that have not been reviewed. */
+  attention: number;
+  /** Threads whose latest turn failed. */
+  failed: number;
+}
+interface ThinkThreadStatusIndicatorsProps {
+  summary: ThinkThreadStatusSummary;
+  className?: string;
+}
+interface ThinkThreadPickerProps extends Omit<React.HTMLAttributes<HTMLElement>, "onSelect" | "title"> {
+  /** Threads from the parent agent, already sorted in the order the app wants to show. */
+  threads: readonly ThinkThreadItem[];
+  /**
+   * Renders the application-owned TanStack Router Link for a thread.
+   *
+   * Put `to`, `params`, `search`, and active state on this element so they stay
+   * inferred from the consuming application's registered route tree.
+   */
+  renderThreadLink: (thread: ThinkThreadItem) => React.ReactElement;
+  /**
+   * App-authored TanStack Router Link to the new-thread screen. A thread
+   * created on click is an empty thread until someone writes in it.
+   */
+  createThreadLink?: React.ReactElement;
+  /**
+   * Notified on unmodified primary activation. The link still navigates — the
+   * route is the selection — so this is for side effects such as closing a
+   * compact drawer, never for performing the selection itself.
+   */
+  onSelect?: (thread: ThinkThreadItem) => void;
+  /** Optional parent-agent delete action, usually `parent.stub.deleteThread(thread.id)`. */
+  onDelete?: (thread: ThinkThreadItem) => void | Promise<void>;
+  /** Visible heading for the roster. */
+  title?: React.ReactNode;
+  /** Accessible label for the list navigation. */
+  "aria-label"?: string;
+}
+declare function summarizeThinkThreads(threads: readonly Pick<ThinkThreadItem, "status">[]): ThinkThreadStatusSummary;
+declare function ThinkThreadStatusIndicators({
+  summary,
+  className
+}: ThinkThreadStatusIndicatorsProps): React.JSX.Element | null;
+/**
+ * Thread roster UI for sub-agent chat apps.
+ *
+ * This component does not call Think or Cloudflare RPC methods directly. Feed
+ * it from the parent agent's roster method, then render app-owned route links
+ * that select the child `useAgent({ sub: [...] })` name. Keep backend contract
+ * notes beside the parent Think agent because
+ * `listThreads()`/`createThread()`/`deleteThread()` are app-owned.
+ */
+declare function ThinkThreadPicker({
+  threads,
+  renderThreadLink,
+  createThreadLink,
+  onSelect,
+  onDelete,
+  className,
+  title,
+  "aria-label": ariaLabel,
+  ref,
+  ...props
+}: ThinkThreadPickerProps & {
+  ref?: React.Ref<HTMLElement>;
+}): React.JSX.Element;
+//#endregion
+export { ThinkThreadStatusIndicatorsProps as a, ThinkThreadStatusIndicators as i, ThinkThreadPicker as n, ThinkThreadStatusSummary as o, ThinkThreadPickerProps as r, summarizeThinkThreads as s, ThinkThreadItem as t };

package/dist/{Workspace-DZusrEeP.d.ts → Workspace-C_zHq9KZ.d.ts}

@@ -136,4 +136,4 @@ declare function useWorkspace({
   maxInlineAssetBytes
 }: UseWorkspaceOptions): WorkspaceState;
 //#endregion
-export { workspaceQueryKey as A, workspaceBinaryFileQueryOptions as C, workspaceFileAssetQueryOptions as D, workspaceDirectoryQueryPrefix as E, workspaceFileStatQueryOptions as O, useWorkspace as S, workspaceDirectoryQueryOptions as T, WorkspaceResolvedAsset as _, WorkspaceDirectoryQueryOptions as a, WorkspaceTextFileQueryKey as b, WorkspaceFileQueryKey as c, WorkspaceFileStatQueryOptions as d, WorkspaceFileVersion as f, WorkspaceQueryKey as g, WorkspaceInfoQueryOptions as h, WorkspaceDirectoryQueryKey as i, workspaceTextFileQueryOptions as j, workspaceInfoQueryOptions as k, WorkspaceFileReadTarget as l, WorkspaceInfoQueryKey as m, WorkspaceBinaryFileQueryKey as n, WorkspaceFileAssetQueryKey as o, WorkspaceInfo as p, WorkspaceBinaryFileQueryOptions as r, WorkspaceFileAssetQueryOptions as s, UseWorkspaceOptions as t, WorkspaceFileStatQueryKey as u, WorkspaceSource as v, workspaceDirectoryQueryKey as w, WorkspaceTextFileQueryOptions as x, WorkspaceState as y };
+export { workspaceInfoQueryOptions as A, useWorkspace as C, workspaceDirectoryQueryPrefix as D, workspaceDirectoryQueryOptions as E, workspaceTextFileQueryOptions as M, workspaceFileAssetQueryOptions as O, WorkspaceTextFileQueryOptions as S, workspaceDirectoryQueryKey as T, WorkspaceQueryOptions as _, WorkspaceDirectoryQueryOptions as a, WorkspaceState as b, WorkspaceFileQueryKey as c, WorkspaceFileStatQueryOptions as d, WorkspaceFileVersion as f, WorkspaceQueryKey as g, WorkspaceInfoQueryOptions as h, WorkspaceDirectoryQueryKey as i, workspaceQueryKey as j, workspaceFileStatQueryOptions as k, WorkspaceFileReadTarget as l, WorkspaceInfoQueryKey as m, WorkspaceBinaryFileQueryKey as n, WorkspaceFileAssetQueryKey as o, WorkspaceInfo as p, WorkspaceBinaryFileQueryOptions as r, WorkspaceFileAssetQueryOptions as s, UseWorkspaceOptions as t, WorkspaceFileStatQueryKey as u, WorkspaceResolvedAsset as v, workspaceBinaryFileQueryOptions as w, WorkspaceTextFileQueryKey as x, WorkspaceSource as y };

package/dist/{WorkspaceFileView-D0HyoUV8.js → WorkspaceFileView-ChIJz-fl.js}

@@ -1,10 +1,10 @@
-import { $ as WarningIcon, b as EyeIcon, d as CheckIcon, k as MaximizeIcon, m as CodeIcon, r as ArrowLeftIcon, v as DownloadIcon } from "./icons-BC4HZqSK.js";
+import { b as EyeIcon, d as CheckIcon, et as WarningIcon, k as MaximizeIcon, m as CodeIcon, r as ArrowLeftIcon, v as DownloadIcon } from "./icons-cuEtsgj9.js";
 import { i as formatClock } from "./format-COCyV98Z.js";
-import { a as CodeBlockCopyButton, i as CodeBlockContent, r as CodeBlockContainer, t as CodeBlock } from "./CodeBlock-CcteqDvA.js";
 import { AppTopBar } from "./components/general-purpose/AppTopBar.js";
+import { a as CodeBlockCopyButton, i as CodeBlockContent, r as CodeBlockContainer, t as CodeBlock } from "./CodeBlock-DMHZiw86.js";
 import { inferWorkspaceLanguage, inferWorkspaceMedia, isWorkspaceMarkdownPath, isWorkspaceSkillPath, parseWorkspaceSkill } from "./components/agents-sdk/WorkspaceFile.js";
-import { c as useWorkspaceNavigationContext, s as useWorkspaceNavigationRestoration } from "./WorkspaceLink-DtH66bAY.js";
-import { n as createWorkspaceRehypePlugins, t as WorkspaceMessageResponse } from "./WorkspaceMessageResponse-CJCmGvTx.js";
+import { c as useWorkspaceNavigationContext, s as useWorkspaceNavigationRestoration } from "./WorkspaceLink-B1d2GIGl.js";
+import { n as WorkspaceMessageResponse, r as createWorkspaceRehypePlugins } from "./WorkspaceMessageResponse-Dg_aNpoj.js";
 import { WorkspaceHeader } from "./components/agents-sdk/WorkspaceHeader.js";
 import * as React from "react";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";

package/dist/{WorkspaceLink-DtH66bAY.js → WorkspaceLink-B1d2GIGl.js}

@@ -198,13 +198,18 @@ function resolveWorkspaceLink({ href, root, base }) {
 	};
 }
 function WorkspaceNavigationProvider({ children, root, base, navigation }) {
+	const { kind: baseKind, path: basePath } = base;
 	return /* @__PURE__ */ jsx(WorkspaceNavigationContext, {
 		value: React.useMemo(() => ({
 			root,
-			base,
+			base: {
+				kind: baseKind,
+				path: basePath
+			},
 			navigation
 		}), [
-			base,
+			baseKind,
+			basePath,
 			navigation,
 			root
 		]),

package/dist/WorkspaceLive-DLGhtIly.d.ts

@@ -0,0 +1,49 @@
+import { QueryClient } from "@tanstack/react-query";
+
+//#region src/components/agents-sdk/WorkspaceLive.d.ts
+type WorkspaceChange = {
+  type: "changed";
+  path: string;
+  movedFrom?: string;
+} | {
+  type: "unknown";
+};
+/** Host adapter for a native workspace observer. */
+interface WorkspaceChangeSource {
+  start?(): void | Promise<void>;
+  subscribe(listener: (change: WorkspaceChange) => void): () => void;
+}
+declare function invalidateWorkspaceDirectories(queryClient: QueryClient, sourceKey: string, directories: Iterable<string>, root: string): void;
+interface UseWorkspaceLiveQueriesOptions {
+  /** Native observer adapter. Omit for hosts without workspace observation. */
+  changes?: WorkspaceChangeSource;
+  sourceKey: string | undefined;
+  /**
+   * The host's workspace boundary. Required, and the same value the concept
+   * options were built with: invalidation is prefix-matched on it, so a root
+   * that disagrees with the queries silently invalidates nothing.
+   */
+  root: string;
+  /**
+   * Disposable freshness tick for hosts without native observation — for
+   * example a serialization of settled-turn state. Every change of a defined
+   * value invalidates the source's concept queries. It never enters query
+   * identity, so data, mutation state, and form drafts survive the refresh.
+   */
+  revision?: string;
+}
+/**
+ * Synchronize external workspace freshness with the design system's Query
+ * resources. This is the one external-system effect: native observer events
+ * and host revision ticks both land here as targeted invalidation against
+ * stable query keys. Hosts only supply events; neither layer adds another
+ * watcher.
+ */
+declare function useWorkspaceLiveQueries({
+  changes,
+  sourceKey,
+  root,
+  revision
+}: UseWorkspaceLiveQueriesOptions): void;
+//#endregion
+export { useWorkspaceLiveQueries as a, invalidateWorkspaceDirectories as i, WorkspaceChange as n, WorkspaceChangeSource as r, UseWorkspaceLiveQueriesOptions as t };

package/dist/{WorkspaceMessageResponse-CJCmGvTx.js → WorkspaceMessageResponse-Dg_aNpoj.js}

@@ -1,7 +1,7 @@
 import { MessageResponse } from "./components/ai-sdk/Message.js";
-import { c as useWorkspaceNavigationContext, r as resolveWorkspaceLink, t as WorkspaceFileLink } from "./WorkspaceLink-DtH66bAY.js";
+import { c as useWorkspaceNavigationContext, r as resolveWorkspaceLink, t as WorkspaceFileLink } from "./WorkspaceLink-B1d2GIGl.js";
 import * as React from "react";
-import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { jsx, jsxs } from "react/jsx-runtime";
 import { defaultRehypePlugins } from "streamdown";
 import { visit } from "unist-util-visit";
 //#region src/components/_internal/workspace-markdown.ts
@@ -79,49 +79,85 @@ function createWorkspaceRehypePlugins(root, base) {
 }
 //#endregion
 //#region src/components/agents-sdk/WorkspaceMessageResponse.tsx
+const WorkspaceFileRendererContext = React.createContext(null);
+/**
+* Ambient workspace-file renderer for every `WorkspaceMessageResponse` below,
+* and the only way to supply one. The value is read inside the promoted
+* paragraph, not by the response component, so a host handing down a fresh
+* callback every render re-renders only the paragraphs — the memoized Markdown
+* pipeline is untouched and promoted cards keep their state.
+* `ThinkChat.Messages` provides it from its `renderWorkspaceFile` prop; hosts
+* composing `WorkspaceMessageResponse` directly provide it once at their
+* conversation root.
+*/
+function WorkspaceFileRendererProvider({ children, renderWorkspaceFile }) {
+	return /* @__PURE__ */ jsx(WorkspaceFileRendererContext.Provider, {
+		value: renderWorkspaceFile ?? null,
+		children
+	});
+}
+/**
+* The paragraph the promoted one falls back to — the caller's `components.p`
+* where it gave one, otherwise a plain `<p>`. It travels by context so the
+* promoted paragraph can be a module-scope component with a constant identity:
+* defining it inside a memo made every context change a new element type, and
+* React remounted every promoted card, discarding its draft and sent latch.
+*/
+const FallbackParagraphContext = React.createContext("p");
 const workspaceComponents = {
 	img: "img",
 	a: WorkspaceFileLink
 };
+function WorkspaceFileParagraph({ node, children, ...paragraphProps }) {
+	const workspace = useWorkspaceNavigationContext();
+	const renderFile = React.useContext(WorkspaceFileRendererContext);
+	const FallbackParagraph = React.useContext(FallbackParagraphContext);
+	const renderFallbackParagraph = (content) => React.createElement(FallbackParagraph, typeof FallbackParagraph === "string" ? paragraphProps : {
+		node,
+		...paragraphProps
+	}, content);
+	if (!workspace || !renderFile) return renderFallbackParagraph(children);
+	const file = getStandaloneWorkspaceFileParagraph(node, workspace.root, workspace.base);
+	if (!file) return renderFallbackParagraph(children);
+	const promoted = renderFile({
+		label: file.label,
+		path: file.path,
+		sourceLink: /* @__PURE__ */ jsx(WorkspaceFileLink, { href: file.path })
+	});
+	if (promoted == null) return renderFallbackParagraph(children);
+	const remainingChildren = React.Children.toArray(children).filter((_child, index) => index !== file.childIndex);
+	return /* @__PURE__ */ jsxs(React.Fragment, { children: [file.showRemainingChildren ? renderFallbackParagraph(remainingChildren) : null, promoted] }, file.path);
+}
 /** Adds workspace-aware Markdown links when rendered inside a workspace provider. */
-const WorkspaceMessageResponse = React.memo(function WorkspaceMessageResponse({ components, rehypePlugins, renderWorkspaceHtmlArtifact, ...props }) {
+const WorkspaceMessageResponse = React.memo(function WorkspaceMessageResponse({ components, rehypePlugins, promoteWorkspaceFiles = true, ...props }) {
 	const workspace = useWorkspaceNavigationContext();
-	const resolvedRehypePlugins = React.useMemo(() => rehypePlugins ?? (workspace ? createWorkspaceRehypePlugins(workspace.root, workspace.base) : void 0), [rehypePlugins, workspace]);
-	return /* @__PURE__ */ jsx(MessageResponse, {
-		components: React.useMemo(() => {
-			const merged = components ? {
-				...workspaceComponents,
-				...components
-			} : workspaceComponents;
-			if (!workspace || !renderWorkspaceHtmlArtifact) return merged;
-			const FallbackParagraph = components?.p ?? "p";
-			return {
-				...merged,
-				p: function WorkspaceHtmlArtifactParagraph({ node, children, ...paragraphProps }) {
-					const renderFallbackParagraph = (content) => React.createElement(FallbackParagraph, typeof FallbackParagraph === "string" ? paragraphProps : {
-						node,
-						...paragraphProps
-					}, content);
-					const artifact = getWorkspaceHtmlArtifactParagraph(node, workspace.root, workspace.base);
-					if (!artifact) return renderFallbackParagraph(children);
-					const remainingChildren = React.Children.toArray(children).filter((_child, index) => index !== artifact.childIndex);
-					return /* @__PURE__ */ jsxs(Fragment, { children: [artifact.showRemainingChildren ? renderFallbackParagraph(remainingChildren) : null, renderWorkspaceHtmlArtifact({
-						label: artifact.label,
-						path: artifact.path,
-						sourceLink: /* @__PURE__ */ jsx(WorkspaceFileLink, { href: artifact.path })
-					})] });
-				}
-			};
-		}, [
-			components,
-			renderWorkspaceHtmlArtifact,
-			workspace
-		]),
-		rehypePlugins: resolvedRehypePlugins,
-		...props
+	const workspaceRoot = workspace?.root;
+	const workspaceBase = workspace?.base;
+	const resolvedRehypePlugins = React.useMemo(() => rehypePlugins ?? (workspaceRoot !== void 0 && workspaceBase !== void 0 ? createWorkspaceRehypePlugins(workspaceRoot, workspaceBase) : void 0), [
+		rehypePlugins,
+		workspaceBase,
+		workspaceRoot
+	]);
+	const resolvedComponents = React.useMemo(() => {
+		const merged = components ? {
+			...workspaceComponents,
+			...components
+		} : workspaceComponents;
+		return promoteWorkspaceFiles ? {
+			...merged,
+			p: WorkspaceFileParagraph
+		} : merged;
+	}, [components, promoteWorkspaceFiles]);
+	return /* @__PURE__ */ jsx(FallbackParagraphContext, {
+		value: components?.p ?? "p",
+		children: /* @__PURE__ */ jsx(MessageResponse, {
+			components: resolvedComponents,
+			rehypePlugins: resolvedRehypePlugins,
+			...props
+		})
 	});
 });
-function getWorkspaceHtmlArtifactParagraph(node, root, base) {
+function getStandaloneWorkspaceFileParagraph(node, root, base) {
 	if (!node || node.tagName !== "p") return null;
 	const children = node.children;
 	const matches = children.flatMap((child, childIndex) => {
@@ -133,7 +169,7 @@ function getWorkspaceHtmlArtifactParagraph(node, root, base) {
 			root,
 			base
 		});
-		if (destination.kind !== "file" || destination.fragment !== null || !destination.path.toLowerCase().endsWith(".html")) return [];
+		if (destination.kind !== "file" || destination.fragment !== null) return [];
 		return [{
 			anchor: child,
 			childIndex,
@@ -145,7 +181,7 @@ function getWorkspaceHtmlArtifactParagraph(node, root, base) {
 	return {
 		childIndex,
 		path,
-		label: markdownText(anchor).trim() || path.split("/").at(-1) || "Interactive UI",
+		label: markdownText(anchor).trim() || path.split("/").at(-1) || "Workspace file",
 		showRemainingChildren: children.some((child, index) => index !== childIndex && (child.type !== "text" || child.value.trim()))
 	};
 }
@@ -154,4 +190,4 @@ function markdownText(node) {
 	return node.type === "element" ? node.children.map(markdownText).join("") : "";
 }
 //#endregion
-export { createWorkspaceRehypePlugins as n, WorkspaceMessageResponse as t };
+export { WorkspaceMessageResponse as n, createWorkspaceRehypePlugins as r, WorkspaceFileRendererProvider as t };