@dxos/plugin-assistant 0.10.0 → 0.11.1

package/dist/lib/components.mjs

@@ -0,0 +1,2616 @@
+import { n as AiUsageQuotaError } from "./chunk-processor.mjs";
+import { n as useChatContext, t as ChatContextProvider } from "./chunk-context.mjs";
+import { t as TracePanel } from "./chunk-TracePanel.mjs";
+import { Operation, Process, Project, Trigger } from "@dxos/compute";
+import { PublicKey, URI } from "@dxos/keys";
+import { Unit, isNonNullable, keyToFallback, safeParseJson } from "@dxos/util";
+import { McpServer } from "@dxos/assistant-toolkit";
+import { Feed, Filter, Obj, Query, Ref, Type } from "@dxos/echo";
+import { meta } from "#meta";
+import { Atom } from "@effect-atom/atom";
+import { FeedAnnotation } from "@dxos/schema";
+import { Message, Outline } from "@dxos/types";
+import { Assistant, ChatSurface, ServiceType } from "#types";
+import * as Option from "effect/Option";
+import React, { Fragment, forwardRef, useCallback, useContext, useEffect, useId, useMemo, useRef, useState } from "react";
+import { useObject, useQuery } from "@dxos/echo-react";
+import { Button, DropdownMenu, Icon, IconBlock, IconButton, Input, Message as Message$1, MicButton, Popover, ScrollArea, Select, Tag, Toast, Tooltip, composable, composableProps, setRef, toLocalizedString, useDynamicRef, useTranslation } from "@dxos/react-ui";
+import { Form } from "@dxos/react-ui-form";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import { RegistryContext, useAtomValue } from "@effect-atom/atom-react";
+import { Event } from "@dxos/async";
+import { useIdentity } from "@dxos/halo-react";
+import { log } from "@dxos/log";
+import { Matrix, Minimap, NumericTabs, TextCrawl, TogglePanel } from "@dxos/react-ui-components";
+import { Menu, useGraphMenuActions } from "@dxos/react-ui-menu";
+import { useActiveSkills, useChatKeymapExtensions, useChatToolbarActions, useContextObjects, useDebug, useFilteredTypes, useSkillHandlers, useSkills } from "#hooks";
+import { Surface, useCapabilities, useOptionalAtomCapabilityState, useOptionalCapabilities } from "@dxos/app-framework/ui";
+import { TranscriptionCapabilities } from "@dxos/plugin-transcription";
+import { getStyles, mx } from "@dxos/ui-theme";
+import { Listbox, TREEGRID_PATH_SEPARATOR, Treegrid } from "@dxos/react-ui-list";
+import { SearchList, useSearchListResults } from "@dxos/react-ui-search";
+import { Tabs } from "@dxos/react-ui-tabs";
+import { ChatEditor, ChatStatus, ChatStatusIndicator, commands, formatElapsed } from "@dxos/react-ui-chat";
+import { AnchorWidget, PendingTextStreamer, cancelPendingText, editorPendingTextSink, getXmlTextChild, pendingText, pendingTextState } from "@dxos/ui-editor";
+import { TranscriptionCapabilities as TranscriptionCapabilities$1 } from "@dxos/plugin-transcription/types";
+import { useAudioTrack, useTranscriber } from "@dxos/react-ui-transcription";
+import { MarkdownStream } from "@dxos/react-ui-markdown";
+import { JsonHighlighter } from "@dxos/react-ui-syntax-highlighter";
+import { WidgetType } from "@codemirror/view";
+import { Domino, mx as mx$1 } from "@dxos/ui";
+import * as Array$1 from "effect/Array";
+import { CONNECTOR_AUTH_GROUP_ID, Connection, Connector, connectorAuthActions } from "@dxos/plugin-connector";
+import { Graph } from "@dxos/plugin-graph";
+import { useActionRunner } from "@dxos/plugin-graph/hooks";
+import * as Match from "effect/Match";
+//#region src/components/AgentProperties/AgentProperties.tsx
+/** Mirrors the foreign keys stamped by the agent-wizard automation compiler (`sync-automation`). */
+var AGENT_TRIGGER_EXTENSION_KEY = "org.dxos.extension.AgentTrigger";
+var AGENT_TRIGGER_TARGET_EXTENSION_KEY = "org.dxos.extension.AgentTriggerTarget";
+var AgentProperties = ({ agent, onSubscriptionsChanged }) => {
+	const { t } = useTranslation(meta.profile.key);
+	const db = Obj.getDatabase(agent);
+	const subscribedObjects = useQuery(db, useMemo(() => {
+		if (!db) return Filter.nothing();
+		const feedSchemas = db.graph.registry.list().filter(Type.isType).filter((type) => {
+			const annotation = FeedAnnotation.get(Type.getSchema(type));
+			return Option.isSome(annotation) && annotation.value === true;
+		});
+		return feedSchemas.length === 0 ? Filter.nothing() : Filter.or(...feedSchemas.map((schema) => Filter.type(schema)));
+	}, [db]));
+	const triggers = useQuery(db, Filter.foreignKeys(Trigger.Trigger, [{
+		source: AGENT_TRIGGER_EXTENSION_KEY,
+		id: agent.id
+	}]));
+	const subscribedUris = useMemo(() => new Set(triggers.map((trigger) => Obj.getMeta(trigger).keys.find((key) => key.source === AGENT_TRIGGER_TARGET_EXTENSION_KEY)?.id).filter((id) => id !== void 0 && !id.startsWith("timer:"))), [triggers]);
+	const handleSubscriptionChange = useCallback((object, checked) => {
+		const next = new Set(subscribedUris);
+		const uri = Obj.getURI(object);
+		if (checked) next.add(uri);
+		else next.delete(uri);
+		onSubscriptionsChanged?.([...next].map((subscription) => Ref.fromURI(URI.make(subscription))));
+	}, [subscribedUris, onSubscriptionsChanged]);
+	if (subscribedObjects.length === 0) return null;
+	return /* @__PURE__ */ jsxs(Form.Section, { children: [/* @__PURE__ */ jsx(Input.Root, { children: /* @__PURE__ */ jsx(Input.Label, {
+		classNames: "mt-form-gap",
+		children: t("subscriptions.label")
+	}) }), subscribedObjects.map((object) => /* @__PURE__ */ jsx(Input.Root, { children: /* @__PURE__ */ jsxs("div", {
+		className: "flex items-center gap-2",
+		children: [/* @__PURE__ */ jsx(Input.Checkbox, {
+			checked: subscribedUris.has(Obj.getURI(object)),
+			onCheckedChange: (checked) => {
+				handleSubscriptionChange(object, checked === true);
+			}
+		}), /* @__PURE__ */ jsx(Input.Label, { children: Obj.getLabel(object) ?? object.id })]
+	}) }, object.id))] });
+};
+//#endregion
+//#region src/components/ChatPrompt/ChatActions.tsx
+var ChatActions = ({ classNames, children, docId, microphone, processing, debug, onEvent }) => {
+	const { t } = useTranslation(meta.profile.key);
+	const transcriptionAvailable = useOptionalCapabilities(TranscriptionCapabilities.RecordingSession).length > 0;
+	const [session, setSession] = useOptionalAtomCapabilityState(TranscriptionCapabilities.RecordingSession);
+	const [settings, setSettings] = useOptionalAtomCapabilityState(TranscriptionCapabilities.Settings);
+	const recording = !!session?.recording && session.id === docId;
+	const recordMode = settings?.recordMode ?? "toggle";
+	const entityExtraction = settings?.entityExtraction !== false;
+	const selectedDeviceId = settings?.audioDeviceId ?? "";
+	const [devices, setDevices] = useState([]);
+	useEffect(() => {
+		if (!microphone || !transcriptionAvailable || !navigator.mediaDevices?.enumerateDevices) return;
+		let cancelled = false;
+		const refresh = async () => {
+			const all = await navigator.mediaDevices.enumerateDevices();
+			if (cancelled) return;
+			setDevices(all.filter((device) => device.kind === "audioinput" && device.deviceId).map((device, index) => ({
+				deviceId: device.deviceId,
+				label: device.label || `Microphone ${index + 1}`
+			})));
+		};
+		refresh();
+		navigator.mediaDevices.addEventListener("devicechange", refresh);
+		return () => {
+			cancelled = true;
+			navigator.mediaDevices.removeEventListener("devicechange", refresh);
+		};
+	}, [microphone, transcriptionAvailable]);
+	const handleToggle = useCallback(() => {
+		if (!docId) return;
+		setSession((current) => current?.recording && current.id === docId ? null : {
+			id: docId,
+			recording: true
+		});
+	}, [setSession, docId]);
+	const handlePressStart = useCallback(() => {
+		if (!docId) return;
+		setSession(() => ({
+			id: docId,
+			recording: true
+		}));
+	}, [setSession, docId]);
+	const handlePressEnd = useCallback(() => {
+		setSession((current) => current?.id === docId ? null : current);
+	}, [setSession, docId]);
+	const handleRecordModeChange = useCallback((mode) => setSettings((current) => ({
+		...current,
+		recordMode: mode
+	})), [setSettings]);
+	const handleEntityExtractionChange = useCallback((value) => setSettings((current) => ({
+		...current,
+		entityExtraction: value
+	})), [setSettings]);
+	const handleSelectDevice = useCallback((deviceId) => setSettings((current) => ({
+		...current,
+		audioDeviceId: deviceId || void 0
+	})), [setSettings]);
+	const recordLabel = recording ? t("stop-recording.label") : recordMode === "hold" ? t("hold-to-record.label") : t("start-recording.label");
+	return /* @__PURE__ */ jsxs("div", {
+		className: mx("flex items-center", classNames),
+		children: [
+			children,
+			microphone && docId && transcriptionAvailable && /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(MicButton, {
+				iconOnly: true,
+				variant: "ghost",
+				label: recordLabel,
+				recording,
+				mode: recordMode,
+				onToggle: handleToggle,
+				onPressStart: handlePressStart,
+				onPressEnd: handlePressEnd,
+				"data-testid": "assistant.record"
+			}), /* @__PURE__ */ jsxs(DropdownMenu.Root, { children: [/* @__PURE__ */ jsx(DropdownMenu.Trigger, {
+				asChild: true,
+				children: /* @__PURE__ */ jsx(IconButton, {
+					icon: "ph--caret-down--regular",
+					iconOnly: true,
+					label: t("recording-options.label"),
+					variant: "ghost",
+					classNames: "w-4",
+					"data-testid": "assistant.record.options"
+				})
+			}), /* @__PURE__ */ jsx(DropdownMenu.Portal, { children: /* @__PURE__ */ jsxs(DropdownMenu.Content, { children: [/* @__PURE__ */ jsxs(DropdownMenu.Viewport, { children: [
+				/* @__PURE__ */ jsx(DropdownMenu.GroupLabel, { children: t("record-mode.label") }),
+				/* @__PURE__ */ jsx(SettingsSelectableItem, {
+					label: t("record-mode.toggle.label"),
+					selected: recordMode === "toggle",
+					onSelect: () => handleRecordModeChange("toggle")
+				}),
+				/* @__PURE__ */ jsx(SettingsSelectableItem, {
+					label: t("record-mode.hold.label"),
+					selected: recordMode === "hold",
+					onSelect: () => handleRecordModeChange("hold")
+				}),
+				/* @__PURE__ */ jsx(DropdownMenu.Separator, {}),
+				/* @__PURE__ */ jsx(DropdownMenu.GroupLabel, { children: t("audio-device.label") }),
+				/* @__PURE__ */ jsx(SettingsSelectableItem, {
+					label: t("audio-device.default.label"),
+					selected: selectedDeviceId === "",
+					onSelect: () => handleSelectDevice("")
+				}),
+				devices.map((device) => /* @__PURE__ */ jsx(SettingsSelectableItem, {
+					label: device.label,
+					selected: selectedDeviceId === device.deviceId,
+					onSelect: () => handleSelectDevice(device.deviceId)
+				}, device.deviceId)),
+				/* @__PURE__ */ jsx(DropdownMenu.Separator, {}),
+				/* @__PURE__ */ jsxs(DropdownMenu.CheckboxItem, {
+					checked: entityExtraction,
+					onCheckedChange: handleEntityExtractionChange,
+					classNames: "gap-2",
+					"data-testid": "assistant.entity-extraction",
+					children: [/* @__PURE__ */ jsx("span", {
+						className: "grow truncate",
+						children: t("settings.entity-extraction.label")
+					}), /* @__PURE__ */ jsx(DropdownMenu.ItemIndicator, {
+						asChild: true,
+						children: /* @__PURE__ */ jsx(Icon, {
+							icon: "ph--check--regular",
+							size: 4
+						})
+					})]
+				})
+			] }), /* @__PURE__ */ jsx(DropdownMenu.Arrow, {})] }) })] })] }),
+			debug && /* @__PURE__ */ jsx(IconButton, {
+				variant: "ghost",
+				icon: "ph--wrench--regular",
+				iconOnly: true,
+				label: t("debug.button"),
+				onClick: () => onEvent?.({ type: "toggle-debug" })
+			}),
+			/* @__PURE__ */ jsx(IconButton, {
+				disabled: !processing,
+				variant: "ghost",
+				classNames: processing && "text-error-text",
+				icon: processing ? "ph--square--duotone" : "ph--square--regular",
+				iconOnly: true,
+				label: t("cancel-processing.button"),
+				onClick: () => {
+					onEvent?.({ type: "cancel" });
+				}
+			})
+		]
+	});
+};
+var SettingsSelectableItem = ({ label, selected, onSelect }) => /* @__PURE__ */ jsxs(DropdownMenu.Item, {
+	classNames: "gap-2",
+	role: "menuitemradio",
+	"aria-checked": selected,
+	onSelect,
+	children: [/* @__PURE__ */ jsx("span", {
+		className: "grow truncate",
+		children: label
+	}), selected && /* @__PURE__ */ jsx(Icon, {
+		icon: "ph--check--regular",
+		size: 4
+	})]
+});
+//#endregion
+//#region src/components/ChatPrompt/ChatMcpErrors.tsx
+/**
+* Inline banner that lists MCP servers that failed to connect during the most recent request.
+* The chat itself keeps working without these servers — this just lets the user see what was dropped.
+*/
+var ChatMcpErrors = ({ classNames, processor }) => {
+	const { t } = useTranslation(meta.profile.key);
+	const errors = useAtomValue(processor.mcpErrors);
+	const handleDismiss = useCallback(() => {
+		processor.dismissMcpErrors();
+	}, [processor]);
+	if (errors.length === 0) return null;
+	return /* @__PURE__ */ jsxs(Message$1.Root, {
+		classNames: ["m-1", classNames],
+		valence: "warning",
+		children: [/* @__PURE__ */ jsx(Message$1.Title, {
+			onClose: handleDismiss,
+			children: t("mcp-server-error.label")
+		}), /* @__PURE__ */ jsx(Message$1.Body, {
+			asChild: true,
+			children: /* @__PURE__ */ jsx("ul", {
+				className: "flex flex-col gap-0.5 text-sm",
+				children: errors.map((error) => /* @__PURE__ */ jsxs("li", {
+					className: "truncate",
+					children: [
+						/* @__PURE__ */ jsx("span", {
+							className: "font-mono",
+							children: error.url
+						}),
+						" — ",
+						/* @__PURE__ */ jsx("span", { children: error.message })
+					]
+				}, `${error.url}::${error.protocol}`))
+			})
+		})]
+	});
+};
+//#endregion
+//#region src/components/ChatPrompt/ChatOptions.tsx
+var styles$1 = {
+	panel: "w-[calc(100dvw-.5rem)] sm:w-max max-w-document-width",
+	toolbar: "p-0! gap-0! border-t border-separator"
+};
+/**
+* Manages the runtime context for the chat.
+*/
+var ChatOptions = ({ chat, db, context, registry, presets, preset, onPresetChange }) => {
+	const { t } = useTranslation(meta.profile.key);
+	return /* @__PURE__ */ jsxs("div", {
+		className: "flex",
+		children: [/* @__PURE__ */ jsxs(Popover.Root, { children: [/* @__PURE__ */ jsx(Popover.Trigger, {
+			asChild: true,
+			children: /* @__PURE__ */ jsx(IconButton, {
+				variant: "ghost",
+				icon: "ph--plus--regular",
+				iconOnly: true,
+				label: t("context-objects.button")
+			})
+		}), /* @__PURE__ */ jsx(Popover.Portal, { children: /* @__PURE__ */ jsxs(Popover.Content, {
+			side: "top",
+			classNames: styles$1.panel,
+			children: [/* @__PURE__ */ jsx(Popover.Viewport, { children: /* @__PURE__ */ jsx(ObjectsPanel, {
+				db,
+				context
+			}) }), /* @__PURE__ */ jsx(Popover.Arrow, {})]
+		}) })] }), /* @__PURE__ */ jsxs(Popover.Root, { children: [/* @__PURE__ */ jsx(Popover.Trigger, {
+			asChild: true,
+			children: /* @__PURE__ */ jsx(IconButton, {
+				variant: "ghost",
+				icon: "ph--sliders-horizontal--regular",
+				iconOnly: true,
+				label: t("context-settings.button")
+			})
+		}), /* @__PURE__ */ jsx(Popover.Portal, { children: /* @__PURE__ */ jsxs(Popover.Content, {
+			side: "top",
+			classNames: styles$1.panel,
+			children: [/* @__PURE__ */ jsx(Popover.Viewport, { children: /* @__PURE__ */ jsx(Tabs.Root, {
+				asChild: true,
+				orientation: "horizontal",
+				defaultValue: "view",
+				defaultActivePart: "list",
+				tabIndex: -1,
+				children: /* @__PURE__ */ jsxs(Tabs.Viewport, {
+					classNames: mx("grid grid-rows-[1fr_40px] w-full"),
+					children: [
+						/* @__PURE__ */ jsx(Tabs.Panel, {
+							tabIndex: -1,
+							classNames: "dx-focus-ring-inset overflow-hidden",
+							value: "view",
+							children: /* @__PURE__ */ jsx(ViewPanel, { chat })
+						}),
+						/* @__PURE__ */ jsx(Tabs.Panel, {
+							tabIndex: -1,
+							classNames: "dx-focus-ring-inset overflow-hidden",
+							value: "skills",
+							children: /* @__PURE__ */ jsx(SkillsPanel, {
+								registry,
+								db,
+								context
+							})
+						}),
+						/* @__PURE__ */ jsx(Tabs.Panel, {
+							tabIndex: -1,
+							classNames: "dx-focus-ring-inset overflow-hidden",
+							value: "mcp-servers",
+							children: /* @__PURE__ */ jsx(McpServersPanel, { db })
+						}),
+						/* @__PURE__ */ jsx(Tabs.Panel, {
+							tabIndex: -1,
+							classNames: "dx-focus-ring-inset overflow-hidden",
+							value: "model",
+							children: /* @__PURE__ */ jsx(ModelsPanel, {
+								presets,
+								preset,
+								onPresetChange
+							})
+						}),
+						/* @__PURE__ */ jsxs(Tabs.Tablist, {
+							classNames: [styles$1.toolbar],
+							children: [
+								/* @__PURE__ */ jsx(Tabs.IconButton, {
+									value: "view",
+									icon: "ph--eye--regular",
+									label: t("chat-view.title")
+								}),
+								/* @__PURE__ */ jsx(Tabs.IconButton, {
+									value: "skills",
+									icon: "ph--blueprint--regular",
+									label: t("options.skills.title")
+								}),
+								/* @__PURE__ */ jsx(Tabs.IconButton, {
+									value: "mcp-servers",
+									icon: "ph--plugs-connected--regular",
+									label: t("options.mcp.title")
+								}),
+								/* @__PURE__ */ jsx(Tabs.IconButton, {
+									value: "model",
+									icon: "ph--cpu--regular",
+									label: t("options.chat-model.title")
+								})
+							]
+						})
+					]
+				})
+			}) }), /* @__PURE__ */ jsx(Popover.Arrow, {})]
+		}) })] })]
+	});
+};
+var SkillsPanel = ({ registry, db, context }) => {
+	const { t } = useTranslation(meta.profile.key);
+	const skills = useSkills({
+		registry,
+		db
+	});
+	const activeSkills = useActiveSkills({ context });
+	const { onUpdateSkill } = useSkillHandlers({
+		db,
+		context,
+		registry
+	});
+	const { results, handleSearch } = useSearchListResults({
+		items: skills,
+		extract: (skill) => skill.name
+	});
+	return /* @__PURE__ */ jsx(SearchList.Root, {
+		onSearch: handleSearch,
+		children: /* @__PURE__ */ jsxs(SearchList.Content, {
+			classNames: "flex flex-col",
+			children: [/* @__PURE__ */ jsx(SearchList.Viewport, { children: results.map((skill) => {
+				const skillKey = Obj.getMeta(skill).key ?? skill.id;
+				const isActive = activeSkills.has(skillKey);
+				return /* @__PURE__ */ jsx(SearchList.Item, {
+					classNames: "flex items-center overflow-hidden",
+					value: skillKey,
+					label: skill.name,
+					checked: isActive,
+					onSelect: () => onUpdateSkill?.(skillKey, !isActive)
+				}, skillKey);
+			}) }), /* @__PURE__ */ jsx(SearchList.Input, {
+				placeholder: t("search.placeholder"),
+				classNames: "border-t border-separator",
+				autoFocus: true
+			})]
+		})
+	});
+};
+var ViewPanel = ({ chat }) => {
+	const { t } = useTranslation(meta.profile.key);
+	const [view, setView] = useObject(chat, "viewType");
+	const value = view ?? "normal";
+	return /* @__PURE__ */ jsx(Listbox.Root, {
+		value,
+		onValueChange: setView,
+		autoFocus: true,
+		children: /* @__PURE__ */ jsx(Listbox.Content, {
+			"aria-label": t("chat-view.title"),
+			children: Assistant.ChatViews.map((view) => /* @__PURE__ */ jsxs(Listbox.Item, {
+				id: view,
+				classNames: "px-2 py-1 dx-focus-ring rounded-xs",
+				children: [/* @__PURE__ */ jsx(Listbox.ItemLabel, { children: t(`chat-view.${view}.label`, { defaultValue: view }) }), /* @__PURE__ */ jsx(Listbox.Indicator, {})]
+			}, view))
+		})
+	});
+};
+var ModelsPanel = ({ presets, preset, onPresetChange }) => {
+	const { t } = useTranslation(meta.profile.key);
+	return /* @__PURE__ */ jsx(Listbox.Root, {
+		value: preset,
+		onValueChange: onPresetChange,
+		autoFocus: true,
+		children: /* @__PURE__ */ jsx(Listbox.Content, {
+			"aria-label": t("options.chat-model.title"),
+			children: presets?.map(({ id, label }) => /* @__PURE__ */ jsxs(Listbox.Item, {
+				id,
+				classNames: "px-2 py-1 dx-focus-ring rounded-xs",
+				children: [/* @__PURE__ */ jsx(Listbox.ItemLabel, { children: label }), /* @__PURE__ */ jsx(Listbox.Indicator, {})]
+			}, id))
+		})
+	});
+};
+var McpServersPanel = ({ db }) => {
+	const { t } = useTranslation(meta.profile.key);
+	const servers = useQuery(db, Filter.type(McpServer.McpServer));
+	const [adding, setAdding] = useState(false);
+	const handleAdd = useCallback((name, url, protocol, apiKey) => {
+		db.add(Obj.make(McpServer.McpServer, {
+			name,
+			url,
+			protocol,
+			apiKey,
+			enabled: true
+		}));
+		setAdding(false);
+	}, [db]);
+	const handleRemove = useCallback((server) => {
+		db.remove(server);
+	}, [db]);
+	return /* @__PURE__ */ jsxs("div", {
+		className: "p-form-chrome",
+		children: [servers.map((server) => /* @__PURE__ */ jsx(McpServerRow, {
+			server,
+			onRemove: handleRemove
+		}, server.id)), adding ? /* @__PURE__ */ jsx(McpServerForm, {
+			onSubmit: handleAdd,
+			onCancel: () => setAdding(false)
+		}) : /* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsx(IconButton, {
+			variant: "ghost",
+			icon: "ph--plus--regular",
+			label: t("mcp-server-add.label"),
+			onClick: () => setAdding(true)
+		}) })]
+	});
+};
+/**
+* `useQuery` returns live objects but only re-renders on result-identity changes,
+* so we must subscribe to the per-server `enabled` field via `useObject` to keep the
+* switch in sync with mutations made through the returned setter.
+*/
+var McpServerRow = ({ server, onRemove }) => {
+	const { t } = useTranslation(meta.profile.key);
+	const [enabled, setEnabled] = useObject(server, "enabled");
+	return /* @__PURE__ */ jsxs("div", {
+		className: "flex items-center gap-2 px-form-chrome",
+		children: [
+			/* @__PURE__ */ jsxs(Input.Root, { children: [/* @__PURE__ */ jsx(Input.Label, {
+				srOnly: true,
+				children: server.name
+			}), /* @__PURE__ */ jsx(Input.Switch, {
+				checked: enabled !== false,
+				onCheckedChange: (checked) => setEnabled(!!checked)
+			})] }),
+			/* @__PURE__ */ jsx("span", {
+				className: "flex-1 truncate text-sm",
+				children: server.name
+			}),
+			/* @__PURE__ */ jsx("span", {
+				className: "truncate text-xs text-description",
+				children: server.url
+			}),
+			/* @__PURE__ */ jsx(IconButton, {
+				variant: "ghost",
+				icon: "ph--x--regular",
+				iconOnly: true,
+				label: t("mcp-server-remove.label"),
+				onClick: () => onRemove(server)
+			})
+		]
+	});
+};
+var McpServerForm = ({ onSubmit, onCancel }) => {
+	const { t } = useTranslation(meta.profile.key);
+	const [name, setName] = useState("");
+	const [url, setUrl] = useState("");
+	const [protocol, setProtocol] = useState("sse");
+	const [apiKey, setApiKey] = useState("");
+	const canSubmit = name.trim().length > 0 && url.trim().length > 0;
+	const handleSubmit = useCallback(() => {
+		if (canSubmit) onSubmit(name.trim(), url.trim(), protocol, apiKey.trim() || void 0);
+	}, [
+		canSubmit,
+		name,
+		url,
+		protocol,
+		apiKey,
+		onSubmit
+	]);
+	return /* @__PURE__ */ jsxs("div", {
+		className: "space-y-2 px-form-chrome",
+		children: [
+			/* @__PURE__ */ jsxs(Input.Root, { children: [/* @__PURE__ */ jsx(Input.Label, {
+				srOnly: true,
+				children: t("mcp-server-name.label")
+			}), /* @__PURE__ */ jsx(Input.TextInput, {
+				placeholder: t("mcp-server-name.placeholder"),
+				value: name,
+				onChange: (event) => setName(event.target.value),
+				autoFocus: true
+			})] }),
+			/* @__PURE__ */ jsxs(Input.Root, { children: [/* @__PURE__ */ jsx(Input.Label, {
+				srOnly: true,
+				children: t("mcp-server-url.label")
+			}), /* @__PURE__ */ jsx(Input.TextInput, {
+				placeholder: t("mcp-server-url.placeholder"),
+				value: url,
+				onChange: (event) => setUrl(event.target.value)
+			})] }),
+			/* @__PURE__ */ jsxs(Select.Root, {
+				value: protocol,
+				onValueChange: (value) => setProtocol(value),
+				children: [/* @__PURE__ */ jsx(Select.TriggerButton, { placeholder: t("mcp-server-protocol.label") }), /* @__PURE__ */ jsx(Select.Portal, { children: /* @__PURE__ */ jsx(Select.Content, { children: /* @__PURE__ */ jsxs(Select.Viewport, { children: [/* @__PURE__ */ jsx(Select.Option, {
+					value: "sse",
+					children: "SSE"
+				}), /* @__PURE__ */ jsx(Select.Option, {
+					value: "http",
+					children: "HTTP"
+				})] }) }) })]
+			}),
+			/* @__PURE__ */ jsxs(Input.Root, { children: [/* @__PURE__ */ jsx(Input.Label, {
+				srOnly: true,
+				children: t("mcp-server-api-key.label")
+			}), /* @__PURE__ */ jsx(Input.TextInput, {
+				type: "password",
+				placeholder: t("mcp-server-api-key.placeholder"),
+				value: apiKey,
+				onChange: (event) => setApiKey(event.target.value)
+			})] }),
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex gap-2",
+				children: [/* @__PURE__ */ jsx(IconButton, {
+					variant: "ghost",
+					icon: "ph--check--regular",
+					iconOnly: true,
+					label: t("save.button"),
+					onClick: handleSubmit,
+					disabled: !canSubmit
+				}), /* @__PURE__ */ jsx(IconButton, {
+					variant: "ghost",
+					icon: "ph--x--regular",
+					iconOnly: true,
+					label: t("cancel.button"),
+					onClick: onCancel
+				})]
+			})
+		]
+	});
+};
+var ANY = "__any__";
+/** @private */
+var ObjectsPanel = ({ db, context }) => {
+	const { t } = useTranslation(meta.profile.key);
+	const types = useFilteredTypes(db);
+	const typeOptions = useMemo(() => {
+		const options = types.map((type) => {
+			const typename = Type.getTypename(type);
+			return {
+				uri: Type.getURI(type),
+				label: t("typename.label", {
+					ns: typename,
+					defaultValue: typename
+				})
+			};
+		});
+		options.sort((a, b) => a.label.localeCompare(b.label));
+		return options;
+	}, [types, t]);
+	const [selectedUri, setSelectedUri] = useState(ANY);
+	const anyFilter = useMemo(() => Filter.or(...typeOptions.map(({ uri }) => Filter.type(uri))), [typeOptions]);
+	const objects = useQuery(db, selectedUri === ANY ? anyFilter : Filter.type(selectedUri));
+	const { objects: contextObjects, onUpdateObject } = useContextObjects({
+		db,
+		context
+	});
+	const { results, handleSearch } = useSearchListResults({
+		items: objects,
+		extract: (object) => Obj.getLabel(object) ?? Obj.getTypename(object) ?? object.id
+	});
+	return /* @__PURE__ */ jsxs(SearchList.Root, {
+		onSearch: handleSearch,
+		children: [/* @__PURE__ */ jsx(SearchList.Content, {
+			classNames: "p-form-chrome [&:has([cmdk-list-sizer]:empty)]:py-0",
+			children: /* @__PURE__ */ jsx(SearchList.Viewport, { children: results.length ? results.map((object) => {
+				const isActive = contextObjects.findIndex((obj) => obj.id === object.id) !== -1;
+				const { icon, hue } = Obj.getIcon(object) ?? {
+					icon: "ph--cube--regular",
+					hue: void 0
+				};
+				const styles = hue ? getStyles(hue) : void 0;
+				return /* @__PURE__ */ jsx(SearchList.Item, {
+					classNames: "flex items-center overflow-hidden",
+					value: object.id,
+					icon,
+					iconClassNames: styles?.text,
+					label: Obj.getLabel(object) ?? Obj.getTypename(object) ?? object.id,
+					checked: isActive,
+					onSelect: () => onUpdateObject?.(Obj.getURI(object), !isActive)
+				}, object.id);
+			}) : /* @__PURE__ */ jsx(SearchList.Item, {
+				value: "__empty__",
+				label: t("no-results.message")
+			}) })
+		}), /* @__PURE__ */ jsxs("div", {
+			className: mx("flex flex-col", styles$1.toolbar),
+			children: [/* @__PURE__ */ jsxs(Select.Root, {
+				value: selectedUri === ANY ? void 0 : selectedUri,
+				onValueChange: (val) => setSelectedUri(val),
+				children: [/* @__PURE__ */ jsx(Select.TriggerButton, { placeholder: t("type-filter.placeholder") }), /* @__PURE__ */ jsx(Select.Portal, { children: /* @__PURE__ */ jsxs(Select.Content, { children: [
+					/* @__PURE__ */ jsx(Select.ScrollUpButton, {}),
+					/* @__PURE__ */ jsxs(Select.Viewport, { children: [/* @__PURE__ */ jsx(Select.Option, {
+						value: ANY,
+						children: t("any-type-filter.label")
+					}), typeOptions.map(({ uri, label }) => /* @__PURE__ */ jsx(Select.Option, {
+						value: uri,
+						children: label
+					}, uri))] }),
+					/* @__PURE__ */ jsx(Select.ScrollDownButton, {}),
+					/* @__PURE__ */ jsx(Select.Arrow, {})
+				] }) })]
+			}), /* @__PURE__ */ jsx(SearchList.Input, {
+				placeholder: t("search.placeholder"),
+				autoFocus: true
+			})]
+		})]
+	});
+};
+//#endregion
+//#region src/components/ChatPrompt/ChatReferences.tsx
+var ChatReferences = ({ classNames, context, db }) => {
+	const { t } = useTranslation(meta.profile.key);
+	const { objects, onUpdateObject } = useContextObjects({
+		db,
+		context
+	});
+	return /* @__PURE__ */ jsx("ul", {
+		className: mx("flex", classNames),
+		children: objects.map((obj) => {
+			const uri = Obj.getURI(obj);
+			const typename = Obj.getTypename(obj);
+			const label = Obj.getLabel(obj) ?? (typename ? ["object-name.placeholder", { ns: typename }] : obj.id);
+			const { icon, hue } = Obj.getIcon(obj) ?? {
+				icon: DEFAULT_OBJECT_ICON,
+				hue: void 0
+			};
+			hue && getStyles(hue);
+			return /* @__PURE__ */ jsxs("li", {
+				className: "dx-tag py-0 flex items-center gap-1",
+				"data-hue": "neutral",
+				children: [
+					/* @__PURE__ */ jsx(Icon, {
+						icon,
+						size: 4
+					}),
+					toLocalizedString(label, t),
+					/* @__PURE__ */ jsx(IconButton, {
+						icon: "ph--x--bold",
+						iconOnly: true,
+						variant: "ghost",
+						label: t("remove-object.label"),
+						classNames: "p-0 hover:bg-transparent",
+						size: 3,
+						onClick: () => onUpdateObject?.(uri, false)
+					})
+				]
+			}, uri.toString());
+		})
+	});
+};
+var DEFAULT_OBJECT_ICON = "ph--cube--regular";
+//#endregion
+//#region src/components/ChatPrompt/useChatVoiceInput.ts
+var RECORDER_INTERVAL_MS = 200;
+/**
+* Drives word-by-word streaming transcription into the chat editor via PendingTextStreamer.
+* Reads the active RecordingSession and Settings capabilities; activates when the session id
+* matches the given docId and the session is recording.
+*/
+var useChatVoiceInput = (docId, editorRef) => {
+	const { t } = useTranslation(meta.profile.key);
+	const [session] = useOptionalAtomCapabilityState(TranscriptionCapabilities$1.RecordingSession);
+	const [settings] = useOptionalAtomCapabilityState(TranscriptionCapabilities$1.Settings);
+	const active = !!session?.recording && session.id === docId;
+	const streamerRef = useRef(null);
+	useEffect(() => {
+		if (!active) return;
+		const view = editorRef.current?.view;
+		if (!view) return;
+		const streamer = new PendingTextStreamer(editorPendingTextSink(view), {
+			mode: settings?.streamMode ?? "word",
+			wordIntervalMs: settings?.wordIntervalMs ?? 80
+		});
+		streamer.start({
+			anchor: view.state.selection.main.head,
+			placeholder: t("recording.placeholder")
+		});
+		streamerRef.current = streamer;
+		return () => {
+			streamer.dispose();
+			streamerRef.current = null;
+			const currentView = editorRef.current?.view;
+			if (currentView) {
+				const pending = currentView.state.field(pendingTextState, false);
+				if (pending && pending.final.length === 0) currentView.dispatch({ effects: cancelPendingText.of() });
+			}
+		};
+	}, [
+		active,
+		settings?.streamMode,
+		settings?.wordIntervalMs
+	]);
+	const handleSegments = useCallback(async (segments) => {
+		const text = segments.map((segment) => segment.text).join(" ").trim();
+		if (text.length > 0) streamerRef.current?.push(text);
+	}, []);
+	const transcriberConfig = useMemo(() => ({ transcribeAfterChunksAmount: Math.max(1, Math.round((settings?.transcribeAfterMs ?? 4e3) / RECORDER_INTERVAL_MS)) }), [settings?.transcribeAfterMs]);
+	const recorderConfig = useMemo(() => ({ interval: RECORDER_INTERVAL_MS }), []);
+	useTranscriber({
+		audioStreamTrack: useAudioTrack(active, useMemo(() => settings?.audioDeviceId ? { deviceId: { exact: settings.audioDeviceId } } : void 0, [settings?.audioDeviceId])),
+		transcriberConfig,
+		recorderConfig,
+		onSegments: handleSegments
+	});
+};
+//#endregion
+//#region src/components/ChatPrompt/ChatPrompt.tsx
+var ChatPrompt = ({ classNames, outline, db, chat, processor, event, online, placeholder, onPresetChange, settings = true, presets, preset, companionTo }) => {
+	const { t } = useTranslation(meta.profile.key);
+	const error = useAtomValue(processor.error).pipe(Option.getOrUndefined);
+	const streaming = useAtomValue(processor.streaming);
+	const activeRef = useDynamicRef(useAtomValue(processor.active));
+	const editorRef = useRef(null);
+	useEffect(() => {
+		return event.on((ev) => {
+			if (ev.type === "update-prompt" && !editorRef.current?.getText()?.length) {
+				editorRef.current?.setText(ev.text);
+				editorRef.current?.focus();
+			}
+		});
+	}, [event]);
+	const fallbackDocId = useId();
+	const docId = chat?.id ?? fallbackDocId;
+	useChatVoiceInput(docId, editorRef);
+	const keymapExtensions = useChatKeymapExtensions({ event });
+	const [companion] = useObject(companionTo);
+	const [instructions] = useObject(Obj.instanceOf(Project.Project, companion) ? companion.instructions : void 0);
+	const commandsRef = useDynamicRef(instructions?.commands ?? []);
+	const commandsExtension = useMemo(() => commands({ getCommands: () => commandsRef.current.map(({ sentinel, description }) => ({
+		sentinel,
+		description
+	})) }), [commandsRef]);
+	const extensions = useMemo(() => [
+		keymapExtensions,
+		pendingText(),
+		commandsExtension
+	], [keymapExtensions, commandsExtension]);
+	const handleSubmit = useCallback((text) => {
+		if (!activeRef.current) {
+			event.emit({
+				type: "submit",
+				text
+			});
+			return true;
+		}
+	}, [event]);
+	const handleEvent = useCallback((ev) => {
+		event.emit(ev);
+	}, [event]);
+	return /* @__PURE__ */ jsxs("div", {
+		role: "group",
+		className: mx("flex flex-col w-full dx-density-md", outline && "dx-group-surface rounded-sm border border-subdued-separator transition transition-border [&:has(.cm-content:focus)]:border-separator", classNames),
+		children: [
+			/* @__PURE__ */ jsx(ChatMcpErrors, { processor }),
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex p-2 gap-2",
+				children: [/* @__PURE__ */ jsx(ChatStatusIndicator, {
+					classNames: "p-1",
+					preset,
+					error,
+					processing: streaming
+				}), /* @__PURE__ */ jsx(ChatEditor, {
+					ref: editorRef,
+					autoFocus: true,
+					markdown: true,
+					lineWrapping: true,
+					classNames: "col-span-2 pt-0.5",
+					placeholder: placeholder ?? t("prompt.placeholder"),
+					extensions,
+					onSubmit: handleSubmit
+				})]
+			}),
+			db && settings && /* @__PURE__ */ jsxs("div", {
+				className: "flex items-center overflow-hidden p-1.5",
+				children: [
+					/* @__PURE__ */ jsx(ChatOptions, {
+						chat,
+						db,
+						registry: processor.registry,
+						context: processor.context,
+						preset,
+						presets,
+						onPresetChange
+					}),
+					/* @__PURE__ */ jsx("div", {
+						className: "flex h-6 grow overflow-x-auto scrollbar-none",
+						children: /* @__PURE__ */ jsx(ChatReferences, {
+							db,
+							context: processor.context
+						})
+					}),
+					/* @__PURE__ */ jsx(ChatActions, {
+						classNames: "col-span-2",
+						microphone: true,
+						docId,
+						processing: streaming,
+						onEvent: handleEvent,
+						children: online !== void 0 && /* @__PURE__ */ jsxs(Input.Root, { children: [/* @__PURE__ */ jsx(Input.Label, {
+							srOnly: true,
+							children: t("online-switch.label")
+						}), /* @__PURE__ */ jsx(Input.Switch, {
+							classNames: "mx-1",
+							checked: online,
+							disabled: true
+						})] })
+					})
+				]
+			})
+		]
+	});
+};
+ChatPrompt.displayName = "Chat.Prompt";
+//#endregion
+//#region src/components/ChatPrompt/ChatStatus.tsx
+var CHAT_STREAM_STATUS_NAME = "Chat.StreamStatus";
+var TICK_MS = 1e3;
+/**
+* Live status pill rendered at the bottom of the chat thread.
+*
+* The block-widget host re-mounts this component each time wire's drip queue toggles
+* (`wireDrainingEffect`) — so all visible state is derived from chat-context values that
+* survive the unmount: the latest `stats` block on the chat context's `messages` for token counts,
+* and `requestTiming` (start/end wall-clock timestamps) for the elapsed value.
+*
+* Shows:
+* - elapsed seconds since the most recent request started (frozen at end-of-request)
+* - last completed turn's output token count (from the most recent `stats` content block)
+* - cumulative session total tokens across all `stats` content blocks
+*/
+var ChatStatus$1 = ({ classNames, icon }) => {
+	const { messages, requestTiming } = useChatContext(CHAT_STREAM_STATUS_NAME);
+	const { lastOutputTokens, sessionTotalTokens } = useMemo(() => {
+		let last;
+		let total = 0;
+		for (const message of messages) for (const block of message.blocks) if (isStats(block) && block.usage) {
+			last = block.usage.outputTokens;
+			total += block.usage.totalTokens ?? 0;
+		}
+		return {
+			lastOutputTokens: last,
+			sessionTotalTokens: total
+		};
+	}, [messages]);
+	const isRunning = requestTiming != null && requestTiming.endedAt == null;
+	const show = requestTiming || lastOutputTokens || sessionTotalTokens > 0;
+	if (!show) return null;
+	return /* @__PURE__ */ jsxs(ChatStatus.Root, {
+		defaultRunning: false,
+		classNames: ["py-2 gap-2 text-sm", classNames],
+		children: [icon && /* @__PURE__ */ jsx(ChatStatus.Icon, { children: /* @__PURE__ */ jsx(Matrix, {
+			classNames: "w-5 h-5",
+			dotClassNames: "bg-primary-500",
+			dim: 4,
+			dotSize: 3,
+			count: 10,
+			interval: 500,
+			active: isRunning
+		}) }), show && /* @__PURE__ */ jsxs("div", {
+			className: "flex items-center",
+			children: [
+				requestTiming && /* @__PURE__ */ jsx(ChatStatus.Text, { children: /* @__PURE__ */ jsx(Elapsed, { timing: requestTiming }) }),
+				lastOutputTokens != null && /* @__PURE__ */ jsxs(Fragment$1, { children: [requestTiming && /* @__PURE__ */ jsx(ChatStatus.Separator, {}), /* @__PURE__ */ jsxs(ChatStatus.Text, { children: ["↓ ", Unit.Thousand(lastOutputTokens).toString()] })] }),
+				sessionTotalTokens > 0 && /* @__PURE__ */ jsxs(Fragment$1, { children: [(requestTiming || lastOutputTokens != null) && /* @__PURE__ */ jsx(ChatStatus.Separator, {}), /* @__PURE__ */ jsxs(ChatStatus.Text, { children: ["Σ ", Unit.Thousand(sessionTotalTokens).toString()] })] })
+			]
+		})]
+	});
+};
+/**
+* Wall-clock-derived elapsed display. Tick interval forces a re-render every second while
+* the request is active so the displayed value advances; once `endedAt` is set, the value
+* is frozen and the interval is no longer scheduled.
+*/
+var Elapsed = ({ timing }) => {
+	const isRunning = timing.endedAt == null;
+	const [now, setNow] = useState(Date.now());
+	useEffect(() => {
+		if (!isRunning) return;
+		const id = setInterval(() => setNow(Date.now()), TICK_MS);
+		return () => clearInterval(id);
+	}, [isRunning]);
+	return /* @__PURE__ */ jsx(Fragment$1, { children: formatElapsed((timing.endedAt ?? now) - timing.startedAt) });
+};
+var isStats = (block) => block._tag === "stats";
+//#endregion
+//#region src/components/ChatThread/sync/tool-widget-state.ts
+/**
+* Mirrors tool-related branches of {@link blockToMarkdown} so widget props stay in sync with message blocks.
+*/
+var applyToolBlockToWidgetState = (context, block) => {
+	switch (block._tag) {
+		case "toolCall":
+			context.updateWidget(block.toolCallId, { blocks: [block] });
+			break;
+		case "toolResult":
+			context.updateWidget(block.toolCallId, ({ blocks = [] } = { blocks: [] }) => ({ blocks: [...blocks, block] }));
+			break;
+	}
+};
+/**
+* Re-applies tool widget state after a full document replace (e.g. {@link MarkdownStreamController.setContent}),
+* which clears accumulated widget props via `xmlTagResetEffect`.
+*/
+var rehydrateToolWidgetsFromMessages = (context, messages) => {
+	for (const message of messages) for (const block of message.blocks) applyToolBlockToWidgetState(context, block);
+};
+//#endregion
+//#region src/components/ChatThread/sync/sync.ts
+/**
+* Thread context passed to renderer.
+* This enables the renderer to "stream" content into the widget state.
+*/
+var MessageThreadContext = class {
+	_widgetState;
+	_handlers;
+	constructor(_widgetState, _handlers = {}) {
+		this._widgetState = _widgetState;
+		this._handlers = _handlers;
+	}
+	updateWidget(id, value) {
+		this._widgetState?.updateWidget(id, value);
+	}
+	getObjectLabel(_id) {
+		return "Object";
+	}
+	rewind(messageId) {
+		this._handlers.onRewind?.(messageId);
+	}
+};
+/**
+* Syncs messages with the editor.
+*
+* Reflects the AI streaming contract:
+* - Messages and their blocks are appended in order.
+* - Only the last block in `messages` may be `pending`; all earlier blocks are finalized.
+* - The renderer's output for a streaming block grows monotonically (see {@link BlockRenderer}).
+* - The document is read-only outside this syncer.
+*
+* Under those rules the syncer needs only:
+* - `_completed`: the flat-block index past which everything has been fully appended.
+* - `_trailing`: chars of the in-flight block (at index `_completed`) already appended.
+* - `_threadId`: identity sentinel; if `messages[0]?.id` changes, the document is replaced.
+*/
+var MessageSyncer = class {
+	_document;
+	_renderer;
+	_threadId;
+	/**
+	* Ids of the messages rendered so far, in document order. `update` streams a suffix, so it needs to
+	* know when the incoming list no longer extends what is on screen — a rewind drops turns, and an
+	* append-only path would leave them rendered.
+	*/
+	_renderedIds = [];
+	/** Cumulative block index (across all completed blocks in all messages). */
+	_completed = 0;
+	/** Chars of the in-flight block (at index `_completed`) already appended. */
+	_trailing = 0;
+	/** Document offset at the `_completed` boundary (length of all fully-appended blocks). */
+	_completedOffset = 0;
+	/** Per-message document offset ranges, keyed by message id in document order. */
+	_spans = /* @__PURE__ */ new Map();
+	_context;
+	constructor(_document, _renderer, handlers = {}) {
+		this._document = _document;
+		this._renderer = _renderer;
+		this._context = new MessageThreadContext(this._document, handlers);
+	}
+	get context() {
+		return this._context;
+	}
+	/**
+	* Per-message document offset spans, in document order. Valid synchronously after
+	* {@link reset} or {@link update} (the offsets are derived from the same rendered buffer
+	* that is dispatched to the document).
+	*/
+	getSpans() {
+		return Array.from(this._spans, ([id, { from, to }]) => ({
+			id,
+			from,
+			to
+		}));
+	}
+	/**
+	* Replace the document with the rendering of `messages`. Use on mount, on thread switch,
+	* and from {@link update} when it detects an identity change in `messages[0]`.
+	*/
+	reset(messages = []) {
+		this._threadId = messages[0]?.id;
+		this._renderedIds = messages.map((message) => message.id);
+		this._completed = 0;
+		this._trailing = 0;
+		this._completedOffset = 0;
+		this._spans.clear();
+		const buffer = this._walk(messages);
+		this._document.setContent(buffer).then(() => {
+			rehydrateToolWidgetsFromMessages(this._context, messages);
+		});
+	}
+	/**
+	* Whether `messages` still begins with everything already rendered, making this an append.
+	*
+	* A rewind removes turns from the middle or end of the thread, and the streaming path can only add
+	* text — so anything other than an extension has to go through {@link reset}.
+	*/
+	#extendsRendered(messages) {
+		if (messages.length < this._renderedIds.length) return false;
+		return this._renderedIds.every((id, index) => messages[index]?.id === id);
+	}
+	/**
+	* Stream the suffix of the rendered messages into the document.
+	* Returns `true` if the document was replaced (initial mount or thread switch), `false`
+	* if the call was a streaming append (or a no-op).
+	*/
+	update(messages) {
+		if (messages[0]?.id !== this._threadId || !this.#extendsRendered(messages)) {
+			this.reset(messages);
+			return true;
+		}
+		this._renderedIds = messages.map((message) => message.id);
+		const buffer = this._walk(messages);
+		if (buffer.length > 0) this._document.append(buffer);
+		return false;
+	}
+	/**
+	* Walk flat blocks starting at `_completed`, advancing the cursors and returning the chars
+	* to append. Blocks before `_completed` are skipped — their renderer is never re-invoked,
+	* which preserves single-shot side effects (e.g. tool widget state mutation).
+	*/
+	_walk(messages) {
+		let buffer = "";
+		let index = 0;
+		let offset = this._completedOffset;
+		outer: for (const message of messages) for (const block of message.blocks) {
+			if (index < this._completed) {
+				index++;
+				continue;
+			}
+			const rendered = this._renderer(this._context, message, block) ?? "";
+			if (rendered.length > this._trailing) buffer += rendered.slice(this._trailing);
+			const renderedLength = Math.max(rendered.length, this._trailing);
+			this._saveRange(message.id, offset, offset + renderedLength);
+			if (block.pending) {
+				if (rendered.length > this._trailing) this._trailing = rendered.length;
+				break outer;
+			}
+			this._completed = index + 1;
+			this._trailing = 0;
+			offset += renderedLength;
+			this._completedOffset = offset;
+			index++;
+		}
+		return buffer;
+	}
+	/** Record (or extend) the offset range of a message. `from` is preserved; `to` never regresses. */
+	_saveRange(id, from, to) {
+		const existing = this._spans.get(id);
+		if (existing) existing.to = Math.max(existing.to, to);
+		else this._spans.set(id, {
+			from,
+			to
+		});
+	}
+};
+//#endregion
+//#region src/components/ChatThread/widgets/format-time.ts
+/**
+* Relative ("5 min ago", "yesterday") within two days, absolute date beyond that. The exact
+* timestamp is always available via the `title` tooltip.
+*
+* Recent prompts are the ones a reader places by elapsed time; older ones by date.
+*/
+var DAY_MS = 1440 * 60 * 1e3;
+var formatTime = (created, now = Date.now()) => {
+	const date = new Date(created);
+	if (Number.isNaN(date.getTime())) return "";
+	const elapsed = now - date.getTime();
+	if (elapsed < 0 || elapsed >= 2 * DAY_MS) return date.toLocaleDateString(void 0, {
+		month: "short",
+		day: "numeric"
+	});
+	const format = new Intl.RelativeTimeFormat(void 0, { numeric: "auto" });
+	const minutes = Math.round(elapsed / 6e4);
+	if (minutes < 1) return format.format(-Math.max(1, Math.round(elapsed / 1e3)), "second");
+	if (minutes < 60) return format.format(-minutes, "minute");
+	const hours = Math.round(minutes / 60);
+	if (hours < 24) return format.format(-hours, "hour");
+	return format.format(-Math.round(hours / 24), "day");
+};
+//#endregion
+//#region src/components/ChatThread/widgets/BranchWidget.tsx
+/**
+* Mini toolbar rendered below each user prompt, offering a soft fork ("rewind") back to that prompt
+* along with when it was sent.
+*/
+var BranchWidget = ({ messageId, created, context }) => {
+	const { t } = useTranslation(meta.profile.key);
+	const handleRewind = useCallback(() => {
+		if (messageId) context?.rewind(messageId);
+	}, [context, messageId]);
+	if (!messageId) return null;
+	return /* @__PURE__ */ jsxs("div", {
+		role: "toolbar",
+		className: "flex items-center p-1 gap-1 justify-end text-xs text-subdued hover:text-inherit",
+		children: [/* @__PURE__ */ jsx(IconButton, {
+			classNames: "min-h-0 p-1",
+			icon: "ph--clock-counter-clockwise--regular",
+			iconOnly: true,
+			variant: "ghost",
+			size: 4,
+			label: t("rewind.label"),
+			"data-testid": "chat.rewind",
+			onClick: handleRewind
+		}), created && /* @__PURE__ */ jsx("time", {
+			dateTime: created,
+			title: new Date(created).toLocaleString(),
+			children: formatTime(created)
+		})]
+	});
+};
+//#endregion
+//#region src/components/ChatThread/widgets/FallbackWidget.tsx
+var FallbackWidget = ({ _tag, ...props }) => {
+	return /* @__PURE__ */ jsx(TogglePanel.Root, { children: /* @__PURE__ */ jsxs(TogglePanel.Content, { children: [/* @__PURE__ */ jsx(TogglePanel.Header, {
+		classNames: "dx-group-surface",
+		children: _tag
+	}), /* @__PURE__ */ jsx(TogglePanel.Body, {
+		classNames: "dx-modal-surface",
+		children: /* @__PURE__ */ jsx(TogglePanel.Viewport, { children: /* @__PURE__ */ jsx(JsonHighlighter, {
+			classNames: "p-2! text-sm",
+			data: props
+		}) })
+	})] }) });
+};
+FallbackWidget.displayName = "Fallback";
+//#endregion
+//#region src/components/ChatThread/widgets/defaults.ts
+var styles = {
+	/**
+	* Vertical rhythm for block widgets. Padding, never margin: CodeMirror measures a widget from its own
+	* box, so a margin sits outside what it can see and its height model drifts from what is rendered —
+	* the error accumulates down the document until the turn-fold gutter markers are visibly misaligned.
+	* Note padding does not collapse between adjacent siblings the way margins do
+	*/
+	padding: "pt-2 pb-4",
+	border: "border border-subdued-separator rounded-sm"
+};
+//#endregion
+//#region src/components/ChatThread/widgets/ReasoningWidget.ts
+/**
+* AI reasoning widget.
+*/
+var ReasoningWidget = class extends WidgetType {
+	text;
+	#pos;
+	/** The timer id last registered for this instance (may differ from the map if superseded). */
+	#ownedTimerId = null;
+	constructor(text, pos) {
+		super();
+		this.text = text;
+		this.#pos = pos === void 0 || pos === "" ? "reasoning" : String(pos);
+	}
+	eq(other) {
+		return this.text === other.text && this.#pos === other.#pos;
+	}
+	toDOM() {
+		return Domino.of("div").classNames(styles.padding).append(Domino.of("div").classNames("relative overflow-hidden p-px", styles.border).attributes({ "data-trail-container": "" }).append(Domino.of("div").classNames("relative z-10 dx-base-surface rounded-sm text-sm text-subdued py-1", "grid grid-cols-[24px_1fr] gap-x-0.5 items-start").append(Domino.of("div").classNames("flex h-5 w-full shrink-0 items-center justify-center self-start").append(Domino.svg("ph--brain--regular").classNames("shrink-0 size-4 opacity-70")), Domino.of("div").classNames("px-2 max-h-[5lh] overflow-y-auto dx-scrollbar-thin min-w-0").text(this.text).attributes({ "data-reasoning-text": "" })), Domino.of("div").attributes({ "data-id": this.#pos }))).root;
+	}
+	updateDOM(dom) {
+		dom.querySelector("[data-reasoning-text]")?.replaceChildren(this.text);
+		const container = dom.querySelector("[data-trail-container]");
+		let trailHost = container?.querySelector("[data-id]");
+		if (container && !trailHost) {
+			trailHost = Domino.of("div").attributes({ "data-id": this.#pos }).root;
+			container.append(trailHost);
+		}
+		if (trailHost?.childElementCount === 0) trailHost.append(...createTrailLayers());
+		this.#scheduleTrailRemoval(dom);
+		return true;
+	}
+	destroy(_dom) {
+		this.#clearOwnedTrailTimer();
+	}
+	#scheduleTrailRemoval(dom) {
+		const previous = trailRemovalTimers.get(this.#pos);
+		if (previous !== void 0) clearTimeout(previous);
+		const timerId = setTimeout(() => {
+			if (trailRemovalTimers.get(this.#pos) !== timerId) return;
+			trailRemovalTimers.delete(this.#pos);
+			this.#ownedTimerId = null;
+			dom.querySelector("[data-id]")?.remove();
+		}, TRAIL_REMOVAL_DELAY_MS);
+		trailRemovalTimers.set(this.#pos, timerId);
+		this.#ownedTimerId = timerId;
+	}
+	#clearOwnedTrailTimer() {
+		const active = trailRemovalTimers.get(this.#pos);
+		if (active !== void 0 && active === this.#ownedTimerId) {
+			clearTimeout(active);
+			trailRemovalTimers.delete(this.#pos);
+		}
+		this.#ownedTimerId = null;
+	}
+};
+var trail = [
+	"absolute z-0 aspect-[2/1] w-16",
+	"bg-[radial-gradient(at_100%_50%,_theme(colors.green.700),_transparent_80%)]",
+	"[offset-anchor:100%_50%] [offset-path:border-box]"
+];
+/** Delay after the last content update before hiding the trail. */
+var TRAIL_REMOVAL_DELAY_MS = 1e3;
+/**
+* One pending removal timer per logical block. Streaming creates a new widget instance each tick;
+* `destroy` may run after the next instance has already scheduled, so we must not clear a newer timer.
+*/
+var trailRemovalTimers = /* @__PURE__ */ new Map();
+var createTrailLayers = () => [Domino.of("div").classNames(...trail, "animate-trail").root, Domino.of("div").classNames(...trail, "animate-trail-offset").root];
+//#endregion
+//#region src/components/ChatThread/widgets/ReferenceWidget.ts
+var ReferenceWidget = class extends WidgetType {
+	text;
+	dxn;
+	constructor(text, dxn) {
+		super();
+		this.text = text;
+		this.dxn = dxn;
+	}
+	eq(other) {
+		return this.dxn === other.dxn;
+	}
+	toDOM() {
+		return Domino.of("div").classNames(styles.padding).append(Domino.of("dx-anchor").classNames("dx-tag--anchor").attributes({ dxn: this.dxn }).text(this.text)).root;
+	}
+};
+//#endregion
+//#region src/components/ChatThread/widgets/SelectWidget.ts
+/**
+* Simple prompt widget.
+*/
+var SelectWidget = class extends WidgetType {
+	options;
+	constructor(options) {
+		super();
+		this.options = options;
+	}
+	eq(other) {
+		return JSON.stringify(this.options) === JSON.stringify(other.options);
+	}
+	/**
+	* NOTE: Container must set var based on user's identity.
+	*/
+	toDOM() {
+		return Domino.of("div").attributes({ role: "group" }).classNames(styles.padding, "flex flex-wrap gap-1").append(...this.options.map((option) => Domino.of("button").classNames("dx-button inline-block max-w-[100cqi]").attributes({
+			"data-action": "submit",
+			"data-value": option,
+			"data-density": "md"
+		}).text(option))).root;
+	}
+};
+//#endregion
+//#region src/components/ChatThread/widgets/StatsWidget.ts
+/**
+* Simple stats widget.
+*/
+var StatsWidget = class extends WidgetType {
+	text;
+	constructor(text) {
+		super();
+		this.text = text;
+	}
+	eq(other) {
+		return this.text === other.text;
+	}
+	toDOM() {
+		return Domino.of("div").classNames(styles.padding, "text-sm text-placeholder").text(this.text).root;
+	}
+	updateDOM(dom) {
+		dom.textContent = this.text;
+		return true;
+	}
+};
+//#endregion
+//#region src/components/ChatThread/widgets/StatusWidget.ts
+/**
+* AI status widget.
+*/
+var StatusWidget = class extends WidgetType {
+	text;
+	constructor(text) {
+		super();
+		this.text = text;
+	}
+	eq(other) {
+		return this.text === other.text;
+	}
+	toDOM() {
+		return Domino.of("div").classNames(styles.padding).append(Domino.of("div").classNames("relative overflow-hidden rounded-sm").append(Domino.of("div").classNames("grid grid-cols-[24px_1fr] gap-x-0.5 gap-y-0 items-start px-0.5 py-0.5 text-placeholder").append(Domino.of("div").classNames("flex h-5 w-full shrink-0 items-center justify-center self-start").append(Domino.svg("ph--info--regular").classNames("shrink-0 size-4 opacity-70")), Domino.of("div").classNames("relative min-w-0").append(Domino.of("div").classNames("relative z-10 rounded-sm text-sm leading-5").attributes({ "data-status-text": "" }).text(this.text))))).root;
+	}
+	updateDOM(dom) {
+		dom.querySelector("[data-status-text]")?.replaceChildren(this.text);
+		return true;
+	}
+};
+//#endregion
+//#region src/components/ChatThread/widgets/SuggestionWidget.ts
+/**
+* Simple prompt widget.
+*/
+var SuggestionWidget = class extends WidgetType {
+	text;
+	constructor(text) {
+		super();
+		this.text = text;
+	}
+	eq(other) {
+		return this.text === other.text;
+	}
+	toDOM() {
+		return Domino.of("span").classNames(mx$1("inline-flex max-w-[calc(100cqi-8px)] py-1 pe-1 overflow-hidden")).append(Domino.of("button").attributes({
+			"data-density": "md",
+			"data-action": "submit",
+			"data-value": this.text
+		}).classNames(mx$1("dx-button gap-2 w-full overflow-hidden")).append(Domino.of("dx-icon").attributes({ icon: "ph--lightning--regular" }), Domino.of("span").classNames("flex-1 truncate min-w-0").text(this.text))).root;
+	}
+};
+//#endregion
+//#region src/components/ChatThread/widgets/SummaryWidget.tsx
+var SummaryWidget = ({ children }) => {
+	const { t } = useTranslation(meta.profile.key);
+	return /* @__PURE__ */ jsx(TogglePanel.Root, { children: /* @__PURE__ */ jsxs(TogglePanel.Content, {
+		classNames: styles.border,
+		children: [/* @__PURE__ */ jsx(TogglePanel.Header, {
+			classNames: "text-sm dx-group-surface",
+			children: t("summary.label")
+		}), /* @__PURE__ */ jsx(TogglePanel.Body, { children: /* @__PURE__ */ jsx("div", {
+			className: "p-1 text-sm text-subdued",
+			children
+		}) })]
+	}) });
+};
+//#endregion
+//#region src/components/ChatThread/widgets/SurfaceWidget.tsx
+var __dxlog_file$3 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/components/ChatThread/widgets/SurfaceWidget.tsx";
+/**
+* Renders an agent-requested UI surface (the `<surface>` content block) by dispatching to a
+* registered {@link ChatSurface} surface keyed on its `role`. The payload is carried as JSON in the
+* tag's text content; a malformed payload renders the surface with no data rather than throwing.
+*/
+var SurfaceWidget = ({ role, children }) => {
+	const data = useMemo(() => {
+		const raw = getXmlTextChild(children ?? []);
+		if (!raw) return;
+		try {
+			const parsed = JSON.parse(raw);
+			return parsed != null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
+		} catch (err) {
+			log.warn("failed to parse surface data", {
+				raw,
+				err
+			}, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$3,
+				L: 31,
+				S: void 0
+			});
+			return;
+		}
+	}, [children]);
+	if (!role) return null;
+	return /* @__PURE__ */ jsx(Surface.Surface, {
+		type: ChatSurface,
+		data: {
+			role,
+			data
+		},
+		limit: 1
+	});
+};
+//#endregion
+//#region src/components/ChatThread/widgets/ToolWidget.tsx
+var ToolWidget = ({ view, blocks = [] }) => {
+	const { t } = useTranslation(meta.profile.key);
+	const items = useMemo(() => {
+		let lastToolCall;
+		const tools = [];
+		return blocks.filter((block) => block._tag === "toolCall" || block._tag === "toolResult" || block._tag === "stats").map((block) => {
+			switch (block._tag) {
+				case "toolCall": {
+					if (block.pending && lastToolCall?.block.toolCallId === block.toolCallId) return null;
+					const tool = tools.find((tool) => tool.name === block.name);
+					lastToolCall = {
+						tool,
+						block
+					};
+					return {
+						title: tool?.description ?? [t("tool-call.label"), block.name].filter(Boolean).join(" "),
+						icon: block.operationIcon,
+						content: {
+							...block,
+							input: safeParseJson(block.input)
+						}
+					};
+				}
+				case "toolResult": {
+					if (block.error) return {
+						title: t("tool-error.label"),
+						icon: lastToolCall?.block.operationIcon,
+						content: block
+					};
+					const title = lastToolCall?.tool?.description ?? [t("tool-result.label"), lastToolCall?.block.name].filter(Boolean).join(" ");
+					const icon = lastToolCall?.block.operationIcon;
+					lastToolCall = void 0;
+					return {
+						title,
+						icon,
+						content: {
+							...block,
+							result: typeof block.result === "string" ? safeParseJson(block.result) : block.result
+						}
+					};
+				}
+				case "stats":
+					if (!lastToolCall) return null;
+					return {
+						title: t("stats.label"),
+						icon: lastToolCall.block.operationIcon,
+						content: block
+					};
+			}
+		}).filter(isNonNullable);
+	}, [blocks, t]);
+	const handleChangeOpen = useCallback(() => {
+		setTimeout(() => {
+			view?.requestMeasure();
+		}, 1e3);
+	}, [view]);
+	if (!items.length) return null;
+	return /* @__PURE__ */ jsx(ToolPanel, {
+		items,
+		onChangeOpen: handleChangeOpen
+	});
+};
+var DEFAULT_TOOL_ICON = "ph--wrench--regular";
+var ToolPanel = ({ items, onChangeOpen }) => {
+	const tabsRef = useRef(null);
+	const [selected, setSelected] = useState(0);
+	const [open, setOpen] = useState(false);
+	useEffect(() => {
+		setSelected((prev) => Math.min(prev, Math.max(0, items.length - 1)));
+	}, [items.length]);
+	useEffect(() => {
+		onChangeOpen?.(open);
+		if (open) tabsRef.current?.focus();
+	}, [open, onChangeOpen]);
+	const handleSelect = useCallback((index) => {
+		setSelected(index);
+	}, []);
+	const headerIcon = items[items.length - 1]?.icon ?? items[0]?.icon ?? DEFAULT_TOOL_ICON;
+	return /* @__PURE__ */ jsx(TogglePanel.Root, {
+		open,
+		onChangeOpen: setOpen,
+		children: /* @__PURE__ */ jsxs(TogglePanel.Content, { children: [/* @__PURE__ */ jsx(TogglePanel.Header, {
+			classNames: "flex items-center gap-2 text-sm",
+			children: /* @__PURE__ */ jsxs("div", {
+				className: "w-full grid grid-cols-[1fr_auto] items-center gap-2",
+				children: [/* @__PURE__ */ jsx(TextCrawl, {
+					classNames: "text-description",
+					lines: items.map((item) => item.title),
+					autoAdvance: true,
+					greedy: true
+				}, "status-roll"), /* @__PURE__ */ jsx(IconBlock, { children: /* @__PURE__ */ jsx(Icon, {
+					icon: headerIcon,
+					size: 4
+				}) })]
+			})
+		}), /* @__PURE__ */ jsx(TogglePanel.Body, { children: /* @__PURE__ */ jsxs(TogglePanel.Viewport, {
+			classNames: "grid grid-cols-[32px_1fr]",
+			children: [/* @__PURE__ */ jsx(NumericTabs, {
+				ref: tabsRef,
+				classNames: "p-1",
+				length: items.length,
+				selected,
+				onSelect: handleSelect
+			}), /* @__PURE__ */ jsx(JsonHighlighter, {
+				data: items[selected]?.content,
+				classNames: "p-1 text-xs bg-transparent",
+				replacer: {
+					maxDepth: 3,
+					maxArrayLen: 10,
+					maxStringLen: 128
+				}
+			})]
+		}) })] })
+	});
+};
+//#endregion
+//#region src/components/ChatThread/registry.tsx
+var __dxlog_file$2 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/components/ChatThread/registry.tsx";
+/**
+* Custom XML tags registry.
+*
+* NOTE: `<prompt>` has no widget — it is rendered via mark + line decorations
+* (`xmlBlockDecoration`) in MarkdownStream so the prompt text remains part of the document
+* and can be highlighted by `xmlFormatting`. It is still listed here so the markdown block
+* parser (`xmlBlockParsers`) knows to keep `<prompt>...</prompt>` as a single HTMLBlock
+* — otherwise an unregistered prompt opens a Paragraph that lazy-continues into the
+* following lines and breaks parsing of subsequent multi-line tags (e.g. a `<reasoning>`
+* block whose content contains an ordered list).
+*/
+var componentRegistry = {
+	"prompt": { block: true },
+	"link-preview": {
+		block: false,
+		urlSchemes: ["dxn:", "echo:"],
+		factory: ({ label, dxn }) => typeof label === "string" && typeof dxn === "string" ? new AnchorWidget(label, dxn) : null
+	},
+	"synthetic": {
+		block: true,
+		factory: ({ children, range }) => {
+			const text = getXmlTextChild(children);
+			return text ? new ReasoningWidget(text, range.from) : null;
+		}
+	},
+	"reasoning": {
+		block: true,
+		streaming: true,
+		factory: ({ children, range }) => {
+			const text = getXmlTextChild(children);
+			return text ? new ReasoningWidget(text, range.from) : null;
+		}
+	},
+	"reference": {
+		block: false,
+		factory: ({ children, ref }) => {
+			const text = getXmlTextChild(children);
+			return text && ref ? new ReferenceWidget(text, ref) : null;
+		}
+	},
+	"select": {
+		block: true,
+		factory: ({ children }) => {
+			const options = children?.map((option) => option._tag === "option" && getXmlTextChild(option.children)).filter(Boolean);
+			return options?.length ? new SelectWidget(options) : null;
+		}
+	},
+	"suggestion": {
+		block: false,
+		factory: ({ children }) => {
+			const text = getXmlTextChild(children);
+			return text ? new SuggestionWidget(text) : null;
+		}
+	},
+	"stats": {
+		block: true,
+		factory: ({ children }) => {
+			const text = getXmlTextChild(children);
+			return text ? new StatsWidget(text) : null;
+		}
+	},
+	"status": {
+		block: true,
+		streaming: true,
+		factory: ({ children }) => {
+			const text = getXmlTextChild(children);
+			return text ? new StatusWidget(text) : null;
+		}
+	},
+	"branch": {
+		block: true,
+		Component: BranchWidget
+	},
+	"summary": {
+		block: true,
+		Component: SummaryWidget
+	},
+	"surface": {
+		block: true,
+		Component: SurfaceWidget
+	},
+	"toolCall": {
+		block: true,
+		Component: (props) => /* @__PURE__ */ jsx("div", {
+			className: "py-2",
+			children: /* @__PURE__ */ jsx(ToolWidget, { ...props })
+		})
+	},
+	"toolResult": {
+		block: true,
+		Component: FallbackWidget
+	},
+	"toolkit": {
+		block: true,
+		Component: FallbackWidget
+	},
+	"json": {
+		block: true,
+		Component: FallbackWidget
+	}
+};
+/**
+* Create a {@link BlockRenderer} that filters blocks based on the chat view type.
+*
+* - `summary`: only user prompts.
+* - `normal`: user prompts + assistant text + tool calls + summary/select/suggestion/reference + status. Hides reasoning.
+* - `thinking`: same as normal plus reasoning.
+* - `debug`: renders every block (raw fallbacks visible).
+*/
+function createBlockRenderer(viewType) {
+	return (context, message, block) => {
+		if (!isBlockVisible(viewType, message, block)) return;
+		let str = blockToMarkdownImpl(context, message, block);
+		if (str && !block.pending) {
+			if (block._tag === "suggestion") return str += " ";
+			return str += "\n";
+		}
+		return str;
+	};
+}
+var isBlockVisible = (viewType, message, block) => {
+	switch (viewType) {
+		case "debug": return true;
+		case "normal": return block._tag !== "reasoning";
+		case "summary": return block._tag === "text" && block.disposition !== "synthetic";
+		default: return true;
+	}
+};
+var blockToMarkdownImpl = (context, message, block) => {
+	log("blockToMarkdown", { block: JSON.stringify(block) }, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$2,
+		L: 217,
+		S: void 0
+	});
+	switch (block._tag) {
+		case "text":
+			if (message.sender.role === "user") if (block.disposition === "synthetic") return renderXMLBlock("synthetic", {
+				content: block.text,
+				pending: block.pending
+			});
+			else return `\n<prompt>${block.text}</prompt>\n${renderBranchToolbar(message)}\n`;
+			else {
+				const text = block.text.trim();
+				if (text.length > 0) return text;
+			}
+			break;
+		case "reference": {
+			if (block.pending) return;
+			const dxn = block.reference.uri;
+			return `<reference ref="${dxn.toString()}">${context.getObjectLabel(dxn)}</reference>`;
+		}
+		case "suggestion":
+			if (block.pending) return;
+			return `<suggestion>${block.text}</suggestion>`;
+		case "select":
+			if (block.pending || block.options.length === 0) return;
+			return `<select>${block.options.map((option) => `<option>${option}</option>`).join("")}</select>`;
+		case "toolCall":
+			applyToolBlockToWidgetState(context, block);
+			return `<toolCall id="${block.toolCallId}" />`;
+		case "toolResult":
+			applyToolBlockToWidgetState(context, block);
+			break;
+		case "stats": return "";
+		case "reasoning": {
+			let text = block.reasoningText ?? block.redactedText;
+			if (!text) return;
+			return renderXMLBlock("reasoning", {
+				content: text,
+				pending: block.pending
+			});
+		}
+		case "summary": return renderXMLBlock("summary", {
+			content: block.content,
+			pending: block.pending
+		});
+		case "status": return renderXMLBlock("status", {
+			content: block.statusText,
+			pending: block.pending
+		});
+		case "surface":
+			if (block.pending) return;
+			return renderXMLBlock("surface", {
+				content: JSON.stringify(block.data ?? {}),
+				attributes: `role="${escapeXmlAttribute(block.role)}"`
+			});
+		default: return `<json id="${message.id}">\n${JSON.stringify(block)}\n</json>`;
+	}
+};
+/**
+* Mini toolbar below a user prompt: branch (soft fork) plus when the prompt was sent.
+* `messageId` rather than `id` because a tag's `id` attribute would shadow the widget's own id.
+*/
+var renderBranchToolbar = (message) => `<branch messageId="${escapeXmlAttribute(message.id)}" created="${escapeXmlAttribute(message.created)}" />`;
+/**
+* Escape text embedded in generated XML so the mixed XML parser does not treat `&`, `<`, `>` as markup.
+*/
+var escapeXmlTextContent = (raw) => raw.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+/** Escape a value embedded in a double-quoted XML attribute (e.g. a model-supplied surface role). */
+var escapeXmlAttribute = (raw) => escapeXmlTextContent(raw).replace(/"/g, "&quot;");
+var renderXMLBlock = (tag, opts) => {
+	const content = escapeXmlTextContent((opts.content ?? "").replace(/\n\n/g, " ").trim());
+	if (opts.pending) return `<${tag}${opts.attributes ? ` ${opts.attributes}` : ""}>${content}`;
+	else return `<${tag}${opts.attributes ? ` ${opts.attributes}` : ""}>${content}</${tag}>`;
+};
+//#endregion
+//#region src/components/ChatThread/ChatThread.tsx
+var defaultOptions = {
+	autoScroll: true,
+	cursor: false,
+	fader: false,
+	typewriter: true
+};
+var ChatThread$1 = forwardRef(({ classNames, identity, messages = [], error, options = defaultOptions, footer, debug = false, extensions, viewType, onEvent, onSpans }, forwardedRef) => {
+	const [controller, setController] = useState(null);
+	const handleMarkdownStreamRef = useCallback((instance) => {
+		setController(instance);
+		setRef(forwardedRef, instance);
+	}, [forwardedRef]);
+	const userHue = useMemo(() => identity?.data?.hue || keyToFallback(identity?.identityKey ? PublicKey.fromHex(identity.identityKey) : PublicKey.random()).hue, [identity]);
+	const initializedRef = useRef(false);
+	useEffect(() => {
+		if (!controller) {
+			initializedRef.current = false;
+			return;
+		}
+		controller.scrollToBottom(initializedRef.current ? "smooth" : "instant");
+		initializedRef.current = true;
+	}, [controller, error]);
+	const onEventRef = useRef(onEvent);
+	useEffect(() => {
+		onEventRef.current = onEvent;
+	}, [onEvent]);
+	const handleRewind = useCallback((id) => onEventRef.current?.({
+		type: "rewind",
+		id
+	}), []);
+	const renderer = useMemo(() => createBlockRenderer(viewType), [viewType]);
+	const syncer = useMemo(() => controller && new MessageSyncer(controller, renderer, { onRewind: handleRewind }), [
+		controller,
+		renderer,
+		handleRewind
+	]);
+	useEffect(() => {
+		if (!syncer) return;
+		controller?.setContext(syncer.context);
+		controller?.setContext(syncer.context);
+		if (syncer.update(messages)) controller?.scrollToBottom("instant");
+		onSpans?.(syncer.getSpans());
+	}, [
+		controller,
+		syncer,
+		messages,
+		onSpans
+	]);
+	return /* @__PURE__ */ jsx("div", {
+		"data-hue": userHue,
+		className: "contents",
+		children: /* @__PURE__ */ jsx(MarkdownStream, {
+			classNames,
+			registry: componentRegistry,
+			options,
+			debug,
+			extensions,
+			footer,
+			onEvent: useCallback(({ type, value }) => {
+				switch (type) {
+					case "submit":
+						value && onEvent?.({
+							type,
+							text: value
+						});
+						break;
+				}
+			}, [onEvent]),
+			ref: handleMarkdownStreamRef
+		}, viewType)
+	});
+});
+//#endregion
+//#region src/components/TaskList/TaskList.tsx
+/**
+* Renders the conversation's working checklist (the outline's markdown `- [ ]` lines).
+* Durable promoted tasks keep richer state; the checklist is the at-a-glance view.
+*/
+var TaskList = composable(({ outline, activeTitle, ...props }, forwardedRef) => {
+	const [text] = useObject(outline.content);
+	const items = useMemo(() => Outline.parseChecklist(text?.content ?? ""), [text?.content]);
+	if (items.length === 0) return null;
+	return /* @__PURE__ */ jsx(Listbox.Root, { children: /* @__PURE__ */ jsx(Listbox.Viewport, {
+		...composableProps(props, { classNames: "dx-container" }),
+		ref: forwardedRef,
+		children: /* @__PURE__ */ jsx(Listbox.Content, {
+			"aria-label": "Tasks",
+			children: items.map((item) => /* @__PURE__ */ jsx(TaskListItem, {
+				item,
+				active: item.title === activeTitle
+			}, item.title))
+		})
+	}) });
+});
+var TaskListItem = ({ item, active }) => {
+	return /* @__PURE__ */ jsx(Listbox.Item, {
+		id: item.title,
+		classNames: "py-0",
+		children: /* @__PURE__ */ jsxs("div", {
+			className: "flex items-center gap-2 min-w-0",
+			children: [
+				/* @__PURE__ */ jsx(Icon, {
+					icon: item.done ? "ph--check--regular" : "ph--circle--regular",
+					classNames: item.done ? "text-success-text" : void 0,
+					size: 4
+				}),
+				/* @__PURE__ */ jsx("span", {
+					className: "sr-only",
+					children: item.done ? "done" : "to do"
+				}),
+				/* @__PURE__ */ jsx("span", {
+					className: "truncate flex-1",
+					children: item.title
+				}),
+				active && /* @__PURE__ */ jsx(Tag, {
+					hue: "info",
+					children: "working"
+				})
+			]
+		})
+	});
+};
+//#endregion
+//#region src/components/Chat/thread.ts
+/**
+* Append order for {@link Feed.history}, which walks lineage positionally rather than by time.
+*
+* Position is authoritative but server-assigned: locally-written blocks — and every block until a
+* position authority acknowledges them — report `+Infinity`, and a query returns an unordered set, so
+* position alone leaves them in arbitrary order. `created` breaks those ties: sound locally, where one
+* conversation's messages come off one clock, and consulted only when position cannot decide.
+*/
+var byAppendOrder = (a, b) => {
+	const positionA = Feed.getPosition(a);
+	const positionB = Feed.getPosition(b);
+	if (positionA !== positionB) return positionA < positionB ? -1 : 1;
+	return a.created < b.created ? -1 : a.created > b.created ? 1 : 0;
+};
+/**
+* The turns a thread should render: those reachable from the feed's head, so a rewind's abandoned turns
+* disappear from the view exactly as they disappear from the model's history.
+*
+* A pending `rewindFrom` truncates the view to what precedes it — the rewound-to prompt and everything
+* after it, since the point of rewinding to a prompt is to re-ask it. The pointer is cleared by the next
+* append (which turns the fork into lineage), so a rewind that is never followed through stays visible
+* as a truncated thread with the prompt restored in the composer.
+*/
+var projectThread = ({ feedMessages, pendingMessages = [], rewindFrom }) => {
+	const all = Array$1.dedupeWith([...feedMessages, ...pendingMessages], ({ id: a }, { id: b }) => a === b);
+	const sorted = Array$1.sort(all, byAppendOrder);
+	if (rewindFrom !== void 0) {
+		const index = sorted.findIndex((message) => message.id === rewindFrom);
+		if (index === 0) return { messages: [] };
+		if (index > 0) return { messages: Feed.history(sorted, { head: sorted[index - 1].id }).items };
+	}
+	return { messages: Feed.history(sorted).items };
+};
+/**
+* What a rewind to `messageId` implies: the messages to discard from, and the prompt text to restore so
+* the user can edit and resend it.
+*
+* Returns `undefined` when the message is absent, so a stale click is a no-op rather than a truncation.
+*/
+var resolveRewind = (messages, messageId) => {
+	const message = messages.find((candidate) => candidate.id === messageId);
+	if (!message) return;
+	return {
+		rewindFrom: messageId,
+		text: Message.extractText(message)
+	};
+};
+//#endregion
+//#region src/components/Chat/Chat.tsx
+var __dxlog_file$1 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/components/Chat/Chat.tsx";
+var ChatRoot = ({ children, chat, processor, db: dbFallback, onEvent, onSubmit, getContext, ...props }) => {
+	const [debug, setDebug] = useState(false);
+	const streaming = useAtomValue(processor.streaming);
+	const requestTiming = useRequestTiming({ active: useAtomValue(processor.active) });
+	const lastPrompt = useRef(void 0);
+	const db = chat && Obj.getDatabase(chat) || dbFallback;
+	const [feedSnapshot] = useObject(chat?.feed);
+	const feed = Obj.getReactiveOrUndefined(feedSnapshot);
+	const event = useMemo(() => new Event(), []);
+	const [controller, setController] = useState(null);
+	const [messageRanges, setMessageRanges] = useState([]);
+	const feedMessages = useQuery(db, feed ? Query.select(Filter.type(Message.Message)).from(feed) : Query.select(Filter.nothing()));
+	const pendingMessages = useAtomValue(processor.messages);
+	const { messages } = useMemo(() => projectThread({
+		feedMessages,
+		pendingMessages,
+		rewindFrom: feedSnapshot?.rewindFrom
+	}), [
+		feedMessages,
+		pendingMessages,
+		feedSnapshot?.rewindFrom
+	]);
+	const dump = useDebug({ processor });
+	const error = useAtomValue(processor.error);
+	useEffect(() => {
+		if (Option.isSome(error)) event.emit({
+			type: "error",
+			error: error.value
+		});
+	}, [event, error]);
+	useEffect(() => {
+		return event.on((ev) => {
+			switch (ev.type) {
+				case "toggle-debug":
+					setDebug((debug) => {
+						if (debug) return false;
+						else {
+							dump();
+							return true;
+						}
+					});
+					break;
+				case "submit": {
+					const text = ev.text.trim();
+					if (!streaming && text.length) {
+						lastPrompt.current = ev.text;
+						const context = getContext?.();
+						Promise.resolve(onSubmit?.(text)).then(() => processor.request({
+							message: text,
+							context
+						}));
+					}
+					break;
+				}
+				case "rewind": {
+					const rewind = feed && resolveRewind(messages, ev.id);
+					if (rewind) {
+						Obj.update(feed, (feed) => {
+							feed.rewindFrom = rewind.rewindFrom;
+						});
+						event.emit({
+							type: "update-prompt",
+							text: rewind.text
+						});
+					}
+					break;
+				}
+				case "retry":
+					if (!streaming) processor.retry();
+					break;
+				case "cancel":
+					processor.cancel();
+					if (streaming) {
+						if (lastPrompt.current) event.emit({
+							type: "update-prompt",
+							text: lastPrompt.current
+						});
+					}
+					break;
+			}
+			onEvent?.(ev);
+		});
+	}, [
+		event,
+		dump,
+		processor,
+		streaming,
+		onEvent,
+		onSubmit,
+		getContext,
+		feed,
+		messages
+	]);
+	return /* @__PURE__ */ jsx(ChatContextProvider, {
+		debug,
+		event,
+		db,
+		chat,
+		messages,
+		processor,
+		requestTiming,
+		controller,
+		setController,
+		messageRanges,
+		setMessageRanges,
+		...props,
+		children
+	});
+};
+ChatRoot.displayName = "Chat.Root";
+var useRequestTiming = ({ active }) => {
+	const [requestTiming, setRequestTiming] = useState(null);
+	useEffect(() => {
+		if (active) setRequestTiming({
+			startedAt: Date.now(),
+			endedAt: null
+		});
+		else setRequestTiming((prev) => prev && prev.endedAt == null ? {
+			...prev,
+			endedAt: Date.now()
+		} : prev);
+	}, [active]);
+	return requestTiming;
+};
+var CHAT_TOOLBAR_NAME = "Chat.Toolbar";
+var ChatToolbar = composable(({ children, attendableId, alwaysActive, companionTo, ...props }, forwardedRef) => {
+	const { chat } = useChatContext(CHAT_TOOLBAR_NAME);
+	const menuActions = useChatToolbarActions({
+		chat,
+		companionTo
+	});
+	return /* @__PURE__ */ jsx(Menu.Root, {
+		...menuActions,
+		attendableId,
+		alwaysActive,
+		children: /* @__PURE__ */ jsx(Menu.Toolbar, {
+			...composableProps(props),
+			ref: forwardedRef,
+			children
+		})
+	});
+});
+ChatToolbar.displayName = CHAT_TOOLBAR_NAME;
+var CHAT_CONTENT_NAME = "Chat.Content";
+var ChatContent = composable(({ children, ...props }, forwardedRef) => {
+	return /* @__PURE__ */ jsx("div", {
+		...composableProps(props, { classNames: "dx-expander flex flex-col" }),
+		ref: forwardedRef,
+		children
+	});
+});
+ChatContent.displayName = CHAT_CONTENT_NAME;
+var PROMPT_SNIPPET_LINES = 3;
+var PROMPT_SNIPPET_CHARS = 280;
+var PROMPT_TITLE_CHARS = 100;
+/** First non-empty line of a message's text, truncated for the marker title. */
+var promptTitle = (message) => {
+	const firstLine = Message.extractText(message).trim().split("\n").find((line) => line.trim().length) ?? "";
+	return firstLine.length > PROMPT_TITLE_CHARS ? `${firstLine.slice(0, PROMPT_TITLE_CHARS)}…` : firstLine;
+};
+/** First few text lines of an assistant reply (tool calls, reasoning and status are excluded). */
+var replySnippet = (message) => {
+	const text = Message.extractText(message).trim();
+	if (!text.length) return;
+	const snippet = text.split("\n").filter((line) => line.trim().length).slice(0, PROMPT_SNIPPET_LINES).join("\n");
+	return snippet.length > PROMPT_SNIPPET_CHARS ? `${snippet.slice(0, PROMPT_SNIPPET_CHARS)}…` : snippet;
+};
+/**
+* Build one minimap marker per user-prompt turn: title = the prompt text, description = a
+* snippet of the following assistant reply, range = the turn's document span (prompt start →
+* next prompt start). Positions come from the syncer's per-message range table.
+*/
+var buildMarkers = (messages, ranges) => {
+	const rangeById = new Map(ranges.map((range) => [range.id, range]));
+	const markers = [];
+	for (let index = 0; index < messages.length; index++) {
+		const message = messages[index];
+		if (message.sender.role !== "user") continue;
+		const range = rangeById.get(message.id);
+		if (!range) continue;
+		let turnTo = range.to;
+		let description;
+		for (let next = index + 1; next < messages.length; next++) {
+			const nextMessage = messages[next];
+			const nextRange = rangeById.get(nextMessage.id);
+			if (nextMessage.sender.role === "user") {
+				if (nextRange) turnTo = nextRange.from;
+				break;
+			}
+			if (nextRange) turnTo = nextRange.to;
+			if (!description && nextMessage.sender.role === "assistant") description = replySnippet(nextMessage);
+		}
+		markers.push({
+			id: message.id,
+			title: promptTitle(message) || "Prompt",
+			description,
+			range: {
+				from: range.from,
+				to: turnTo
+			}
+		});
+	}
+	return markers;
+};
+var CHAT_THREAD_NAME = "Chat.Thread";
+var ChatThread = ({ viewType, debug: debugProp, onViewUsage, ...props }) => {
+	const { t } = useTranslation(meta.profile.key);
+	const { debug, event, messages, processor, messageRanges, setController, setMessageRanges } = useChatContext(CHAT_THREAD_NAME);
+	const extensions = useChatKeymapExtensions({ event });
+	const identity = useIdentity();
+	const error = useAtomValue(processor.error).pipe(Option.getOrUndefined);
+	const [toastError, setToastError] = useState(void 0);
+	const toastAction = toastError instanceof AiUsageQuotaError ? toastError.action : void 0;
+	const debugView = viewType === "debug";
+	const controllerRef = useRef(null);
+	const handleControllerRef = useCallback((instance) => {
+		controllerRef.current = instance;
+		setController(instance);
+	}, [setController]);
+	const promptPositionsRef = useDynamicRef(useMemo(() => buildMarkers(messages, messageRanges).map((marker) => marker.range.from).sort((a, b) => a - b), [messages, messageRanges]));
+	const navigateToPrompt = useCallback((direction) => {
+		const controller = controllerRef.current;
+		const positions = promptPositionsRef.current;
+		if (!controller || !positions.length) return;
+		const anchor = controller.getVisibleRange()?.from ?? 0;
+		const epsilon = 2;
+		const target = direction > 0 ? positions.find((pos) => pos > anchor + epsilon) : [...positions].reverse().find((pos) => pos < anchor - epsilon);
+		if (target != null) controller.scrollTo(target, { y: "start" });
+	}, [promptPositionsRef]);
+	useEffect(() => {
+		return event.on((event) => {
+			switch (event.type) {
+				case "rewind":
+					console.log("rewind", event);
+					break;
+				case "submit":
+				case "scroll-to-bottom":
+					controllerRef.current?.scrollToBottom();
+					break;
+				case "nav-previous":
+					navigateToPrompt(-1);
+					break;
+				case "nav-next":
+					navigateToPrompt(1);
+					break;
+				case "error":
+					setToastError(event.error);
+					break;
+				default: log.info("no handled", event, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$1,
+					L: 428,
+					S: void 0
+				});
+			}
+		});
+	}, [event, navigateToPrompt]);
+	const handleEvent = useCallback((ev) => {
+		event.emit(ev);
+	}, [event]);
+	if (!identity) return /* @__PURE__ */ jsx("div", { className: "dx-expander" });
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(ChatThread$1, {
+		...props,
+		identity,
+		messages,
+		error,
+		debug: debugProp ?? (debug || debugView),
+		viewType,
+		extensions,
+		onEvent: handleEvent,
+		onSpans: setMessageRanges,
+		ref: handleControllerRef
+	}), /* @__PURE__ */ jsxs(Toast.Root, {
+		type: "foreground",
+		open: !!toastError,
+		duration: 2e4,
+		onOpenChange: (open) => !open && setToastError(void 0),
+		children: [
+			/* @__PURE__ */ jsx(Toast.Title, {
+				icon: "ph--warning--regular",
+				onClose: () => setToastError(void 0),
+				children: t("ai-service-error.label")
+			}),
+			/* @__PURE__ */ jsx(Toast.Description, { children: toastError?.message }),
+			toastAction && onViewUsage && /* @__PURE__ */ jsx(Toast.Actions, { children: /* @__PURE__ */ jsx(Toast.Action, {
+				altText: t(toastAction.labelKey),
+				asChild: true,
+				children: /* @__PURE__ */ jsx(Button, {
+					onClick: () => {
+						setToastError(void 0);
+						onViewUsage();
+					},
+					children: t(toastAction.labelKey)
+				})
+			}) })
+		]
+	})] });
+};
+ChatThread.displayName = CHAT_THREAD_NAME;
+var CHAT_MINIMAP_NAME = "Chat.Minimap";
+/**
+* Anchor-marker rail for the thread: one tick per user-prompt turn. Reads the shared controller
+* and the syncer's range table from context; clicking a tick scrolls the thread to that turn.
+*/
+var ChatMinimap = ({ classNames }) => {
+	const { messages, messageRanges, controller } = useChatContext(CHAT_MINIMAP_NAME);
+	const [visibleRange, setVisibleRange] = useState(void 0);
+	useEffect(() => {
+		if (!controller) return;
+		return controller.onVisibleRangeChange(setVisibleRange);
+	}, [controller]);
+	const markers = useMemo(() => buildMarkers(messages, messageRanges), [messages, messageRanges]);
+	const handleSelect = useCallback((marker) => {
+		controller?.scrollTo(marker.range.from, { y: "start" });
+	}, [controller]);
+	if (!markers.length) return null;
+	return /* @__PURE__ */ jsx(Minimap, {
+		classNames,
+		markers,
+		visibleRange,
+		onSelect: handleSelect
+	});
+};
+ChatMinimap.displayName = CHAT_MINIMAP_NAME;
+var CHAT_PROMPT_NAME = "Chat.Prompt";
+var ChatPrompt$1 = (props) => {
+	const { chat, db, processor, event } = useChatContext(CHAT_PROMPT_NAME);
+	return /* @__PURE__ */ jsx(ChatPrompt, {
+		...props,
+		chat,
+		db,
+		processor,
+		event
+	});
+};
+ChatPrompt$1.displayName = CHAT_PROMPT_NAME;
+var CHAT_TASK_LIST_NAME = "Chat.TaskList";
+var ChatTaskList = composable(({ outline: outlineProp, ...props }, forwardedRef) => {
+	const { chat } = useChatContext(CHAT_TASK_LIST_NAME);
+	const outline = useAtomValue(useMemo(() => Atom.make((get) => outlineProp ?? Option.fromNullable(chat).pipe(Option.map((_) => get(Obj.atom(_))), Option.flatMapNullable((_) => _?.outline?.atom), Option.map(get), Option.getOrUndefined)), [chat, outlineProp]));
+	if (!outline) return null;
+	return /* @__PURE__ */ jsx(TaskList, {
+		...props,
+		outline,
+		ref: forwardedRef
+	});
+});
+ChatTaskList.displayName = CHAT_TASK_LIST_NAME;
+var Chat = {
+	Root: ChatRoot,
+	Toolbar: ChatToolbar,
+	Content: ChatContent,
+	Prompt: ChatPrompt$1,
+	Status: ChatStatus$1,
+	Thread: ChatThread,
+	Minimap: ChatMinimap,
+	TaskList: ChatTaskList
+};
+//#endregion
+//#region src/components/ConnectorAuthMenu/ConnectorAuthMenu.tsx
+/** Root node the connector-auth group hangs off in the component's local graph. */
+var NODE_ID = "connector-auth-root";
+/**
+* Standalone connector-auth menu: a trigger button that opens a dropdown of the same
+* {@link connectorAuthActions} owning plugins contribute to object toolbars. Existing
+* {@link Connection}s are offered for reuse (bind inline) alongside a "Connect X" entry per connector
+* with an auth flow. Renders nothing when there is nothing to offer.
+*/
+var ConnectorAuthMenu = ({ connectorIds, db, existingTarget }) => {
+	const { t } = useTranslation(meta.profile.key);
+	const registry = useContext(RegistryContext);
+	const runAction = useActionRunner();
+	const allConnectors = useCapabilities(Connector).flat();
+	const allConnections = useQuery(db, Filter.type(Connection.Connection));
+	const graph = useMemo(() => {
+		if (!db) return;
+		const actions = connectorAuthActions({
+			connectorIds,
+			db,
+			spaceId: db.spaceId,
+			existingTarget,
+			allConnectors,
+			allConnections
+		});
+		if (actions.length === 0) return;
+		const nextGraph = Graph.make({ registry });
+		nextGraph.pipe(Graph.addNodes([{
+			id: NODE_ID,
+			type: NODE_ID,
+			data: null,
+			properties: {},
+			actions
+		}]));
+		return nextGraph;
+	}, [
+		registry,
+		connectorIds,
+		db,
+		existingTarget,
+		allConnectors,
+		allConnections
+	]);
+	const menuActions = useGraphMenuActions(graph, CONNECTOR_AUTH_GROUP_ID);
+	if (!graph) return null;
+	return /* @__PURE__ */ jsxs(Menu.Root, {
+		...menuActions,
+		onAction: runAction,
+		attendableId: NODE_ID,
+		alwaysActive: true,
+		children: [/* @__PURE__ */ jsx(Menu.Trigger, {
+			asChild: true,
+			children: /* @__PURE__ */ jsx(IconButton, {
+				variant: "ghost",
+				icon: "ph--plugs--regular",
+				label: t("connect.label")
+			})
+		}), /* @__PURE__ */ jsx(Menu.Content, {})]
+	});
+};
+ConnectorAuthMenu.displayName = "ConnectorAuthMenu";
+//#endregion
+//#region src/components/ProcessTree/ProcessTree.tsx
+var DEFAULT_DEPTH = 1;
+/** Extra label inset per nesting level (status icons stay aligned). */
+var LABEL_INDENT_REM = .5;
+/** Nested subprocess rows (level > 1) only surface still-active processes. */
+var NESTED_ACTIVE_STATES = /* @__PURE__ */ new Set([
+	Process.State.RUNNING,
+	Process.State.HYBERNATING,
+	Process.State.TERMINATING
+]);
+var ProcessTree = React.memo(composable(({ processes, depth = DEFAULT_DEPTH, onProcessSelect, onProcessTerminate, ...props }, forwardedRef) => {
+	const rows = useMemo(() => buildProcessTreeRows(processes, depth), [processes, depth]);
+	return /* @__PURE__ */ jsx(ScrollArea.Root, {
+		...composableProps(props, { classNames: "dx-expander" }),
+		thin: true,
+		ref: forwardedRef,
+		children: /* @__PURE__ */ jsx(ScrollArea.Viewport, { children: /* @__PURE__ */ jsx(Treegrid.Root, {
+			classNames: "grid grid-cols-[min-content_1fr_min-content_min-content]",
+			children: rows.map(({ process, path }) => /* @__PURE__ */ jsx(ProcessTreeRowView, {
+				process,
+				path,
+				onProcessSelect,
+				onProcessTerminate
+			}, path.join(TREEGRID_PATH_SEPARATOR)))
+		}) })
+	});
+}));
+var ProcessTreeRowView = ({ process, path, onProcessSelect, onProcessTerminate }) => {
+	const duration = Unit.Duration(process.metrics.wallTime);
+	const level = path.length;
+	const nested = level > 1;
+	return /* @__PURE__ */ jsxs(Treegrid.Row, {
+		id: path.join(TREEGRID_PATH_SEPARATOR),
+		classNames: mx("col-span-full grid grid-cols-subgrid gap-2 ps-1", onProcessSelect && "dx-hover"),
+		children: [
+			/* @__PURE__ */ jsxs(Treegrid.Cell, {
+				classNames: "flex items-center gap-0.5",
+				children: [nested && /* @__PURE__ */ jsx(Icon, {
+					icon: "ph--arrow-elbow-down-right--regular",
+					size: 3,
+					classNames: "shrink-0 text-subdued"
+				}), /* @__PURE__ */ jsx(Tooltip.Trigger, {
+					content: process.state.toString(),
+					children: /* @__PURE__ */ jsx(Icon, {
+						size: 4,
+						synchronized: true,
+						classNames: mx(process.state === Process.State.RUNNING && "animate-spin", process.state === Process.State.FAILED && "text-error-text", process.state === Process.State.SUCCEEDED && "text-success-text"),
+						icon: Match.value(process.state).pipe(Match.when(Process.State.RUNNING, () => "ph--spinner-gap--regular"), Match.when(Process.State.SUCCEEDED, () => "ph--check-circle--regular"), Match.when(Process.State.FAILED, () => "ph--warning--regular"), Match.when(Process.State.HYBERNATING, () => "ph--spinner--regular"), Match.when(Process.State.IDLE, () => "ph--moon-stars--regular"), Match.when(Process.State.TERMINATING, () => "ph--x-circle--regular"), Match.when(Process.State.TERMINATED, () => "ph--x-circle--regular"), Match.orElse(() => "ph--spinner-gap--regular"))
+					})
+				})]
+			}),
+			/* @__PURE__ */ jsx(Treegrid.Cell, {
+				classNames: "flex items-center truncate",
+				style: nested ? { paddingInlineStart: `${(level - 1) * LABEL_INDENT_REM}rem` } : void 0,
+				onClick: () => onProcessSelect?.(process),
+				children: /* @__PURE__ */ jsx("span", {
+					className: mx("truncate text-sm", level === 1 && "font-medium", process.state !== Process.State.RUNNING && "text-description"),
+					children: process.params.name ?? process.pid.toString()
+				})
+			}),
+			/* @__PURE__ */ jsx(Treegrid.Cell, {
+				classNames: "flex items-center justify-end text-xs text-description tabular-nums",
+				children: [Process.State.FAILED, Process.State.SUCCEEDED].includes(process.state) && /* @__PURE__ */ jsx("span", {
+					className: "whitespace-nowrap",
+					children: duration.toString()
+				})
+			}),
+			/* @__PURE__ */ jsx(Treegrid.Cell, { children: onProcessTerminate && /* @__PURE__ */ jsx(IconButton, {
+				classNames: "min-h-0 p-1",
+				icon: "ph--x--regular",
+				iconOnly: true,
+				variant: "ghost",
+				size: 4,
+				label: "Actions",
+				onClick: (event) => {
+					event.stopPropagation();
+					onProcessTerminate?.(process);
+				}
+			}) })
+		]
+	});
+};
+var sortProcesses = (processes) => {
+	return [
+		...processes.filter((process) => [Process.State.RUNNING, Process.State.HYBERNATING].includes(process.state)),
+		...processes.filter((process) => [Process.State.IDLE].includes(process.state)).slice(0, 3),
+		...processes.filter((process) => [
+			Process.State.SUCCEEDED,
+			Process.State.FAILED,
+			Process.State.TERMINATED
+		].includes(process.state))
+	].sort((left, right) => {
+		const leftCompletedAt = Option.getOrElse(left.completedAt, () => Infinity);
+		return Option.getOrElse(right.completedAt, () => Infinity) - leftCompletedAt;
+	});
+};
+var sortNestedActive = (processes) => processes.filter((process) => NESTED_ACTIVE_STATES.has(process.state)).sort((left, right) => {
+	const priority = (state) => state === Process.State.RUNNING ? 0 : state === Process.State.HYBERNATING ? 1 : 2;
+	return priority(left.state) - priority(right.state);
+});
+/**
+* Flattens the process forest to a fixed depth. Rows are always shown expanded (no collapse).
+*/
+var buildProcessTreeRows = (processes, maxDepth) => {
+	const pidSet = new Set(processes.map((process) => String(process.pid)));
+	const childrenByParent = /* @__PURE__ */ new Map();
+	const roots = [];
+	for (const process of processes) {
+		const parent = process.parentPid;
+		if (parent === null || !pidSet.has(String(parent))) {
+			roots.push(process);
+			continue;
+		}
+		const key = String(parent);
+		const siblings = childrenByParent.get(key) ?? [];
+		siblings.push(process);
+		childrenByParent.set(key, siblings);
+	}
+	const sortedRoots = sortProcesses(roots);
+	const rows = [];
+	const visit = (process, path, level) => {
+		if (level > maxDepth) return;
+		rows.push({
+			process,
+			path
+		});
+		if (level >= maxDepth) return;
+		const children = sortNestedActive(childrenByParent.get(String(process.pid)) ?? []);
+		for (const child of children) visit(child, [...path, String(child.pid)], level + 1);
+	};
+	for (const root of sortedRoots) visit(root, [String(root.pid)], 1);
+	return rows;
+};
+//#endregion
+//#region src/components/Toolbox/Toolbox.tsx
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/components/Toolbox/Toolbox.tsx";
+var Toolbox = composable(({ functions, services, skills, activeSkills, ...props }, forwardedRef) => {
+	return /* @__PURE__ */ jsx(ScrollArea.Root, {
+		...composableProps(props),
+		thin: true,
+		orientation: "vertical",
+		ref: forwardedRef,
+		children: /* @__PURE__ */ jsxs(ScrollArea.Viewport, { children: [
+			skills && skills.length > 0 && /* @__PURE__ */ jsx(Section, {
+				title: "Skills",
+				items: skills.map(({ name, description, tools }) => ({
+					name,
+					description,
+					subitems: tools.map((toolId) => ({ name: `∙ ${safeToolId(toolId)}` }))
+				}))
+			}),
+			activeSkills && activeSkills.length > 0 && /* @__PURE__ */ jsx(Section, {
+				title: "Skills",
+				items: activeSkills.map(({ target }) => ({
+					name: target?.name ?? "",
+					description: target?.description ?? "",
+					subitems: target?.tools.map((toolId) => ({ name: `∙ ${safeToolId(toolId)}` }))
+				}))
+			}),
+			services && services.length > 0 && /* @__PURE__ */ jsx(Section, {
+				title: "Services",
+				items: services.map(({ service: { serviceId, name, description } }) => ({
+					name: name ?? serviceId,
+					description
+				}))
+			}),
+			functions && functions.length > 0 && /* @__PURE__ */ jsx(Section, {
+				title: "Functions",
+				items: functions.map(({ name, description }) => ({
+					name,
+					description
+				}))
+			})
+		] })
+	});
+});
+Toolbox.displayName = "Toolbox";
+var Section = ({ title, items, striped }) => {
+	const stripeClassNames = "odd:bg-neutral-50 dark:odd:bg-neutral-800";
+	const gridClassNames = "grid grid-cols-[8rem_1fr]";
+	const subGridClassNames = mx("col-span-full grid grid-cols-subgrid text-xs px-2", striped && stripeClassNames);
+	return /* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("h1", {
+		className: "px-2 text-sm",
+		children: title
+	}), /* @__PURE__ */ jsx("div", {
+		className: gridClassNames,
+		children: items.map(({ name, description, subitems }, i) => /* @__PURE__ */ jsxs(Fragment, { children: [name && /* @__PURE__ */ jsxs("div", {
+			className: subGridClassNames,
+			children: [/* @__PURE__ */ jsx("div", {
+				className: "truncate text-primary-500",
+				children: name
+			}), /* @__PURE__ */ jsx("div", {
+				className: "line-clamp-2",
+				children: description
+			})]
+		}), subitems?.map(({ name, description }, i) => /* @__PURE__ */ jsxs("div", {
+			className: mx(subGridClassNames, striped && stripeClassNames),
+			children: [/* @__PURE__ */ jsx("div", {
+				className: "truncate",
+				children: name
+			}), /* @__PURE__ */ jsx("div", {
+				className: "line-clamp-3 text-subdued",
+				children: description
+			})]
+		}, i))] }, i))
+	})] });
+};
+var ToolboxPanel = ({ classNames, db, processor }) => {
+	const services = useQuery(db, Filter.type(ServiceType));
+	const [serviceTools, setServiceTools] = useState([]);
+	useEffect(() => {
+		log("creating service tools...", { services: services.length }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 123,
+			S: void 0
+		});
+		queueMicrotask(async () => {});
+	}, [services]);
+	const functions = useQuery(db, Filter.type(Operation.PersistentOperation));
+	return /* @__PURE__ */ jsx(Toolbox, {
+		classNames,
+		skills: processor?.context.getSkills(),
+		services: serviceTools,
+		functions
+	});
+};
+var safeToolId = (name) => {
+	return name.split("_").pop();
+};
+//#endregion
+export { AgentProperties, Chat, ChatPrompt, ConnectorAuthMenu, ProcessTree, TaskList, Toolbox, ToolboxPanel, TracePanel };
+
+//# sourceMappingURL=components.mjs.map