@powerhousedao/reactor-browser 6.2.2-dev.8 → 6.2.2-dev.81

package/dist/src/ai/index.js

@@ -0,0 +1,1296 @@
+import { H as ambientRenownTokenProvider, S as useSelectedDriveSafe, s as useSelectedNode } from "../../document-model-modules-DMIR-uSD.js";
+import { n as useSelectedDocumentId } from "../../selected-document-xFBNPc9Q.js";
+import { isFileNode, isFolderNode } from "@powerhousedao/shared/document-drive";
+import { useCallback, useEffect, useRef, useState, useSyncExternalStore } from "react";
+import { DriveCollectionId } from "@powerhousedao/reactor";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { z } from "zod";
+import { isStepCount, streamText, tool } from "ai";
+import { toResponseMessages } from "ai/internal";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { ArrowUp, Check, Maximize2, MessageCircle, Minimize2, Square, Trash2, X } from "lucide-react";
+import ReactMarkdown from "react-markdown";
+import remarkGfm from "remark-gfm";
+//#region src/ai/types.ts
+/** Tool names whose execution mutates the reactor and requires approval. */
+const WRITE_TOOLS = new Set([
+	"createDocument",
+	"addActions",
+	"deleteDocument",
+	"addDrive",
+	"deleteDrive",
+	"addRemoteDrive"
+]);
+/**
+* Whether executing the tool mutates state and requires user approval:
+* the built-in write tools, or any tool flagged destructive in its
+* annotations (covers package-provided tools outside the built-in set).
+*/
+function isWriteTool(name, annotations) {
+	return WRITE_TOOLS.has(name) || annotations?.destructiveHint === true;
+}
+//#endregion
+//#region src/ai/agent.ts
+/** Hard cap on model round-trips per user message (each tool step counts). */
+const MAX_AGENT_STEPS = 10;
+/**
+* Hard cap on the characters of one tool result fed back to the model.
+*
+* Large results (whole document states, catalog listings, schema
+* summaries) accumulate across steps because every step resends the whole
+* conversation; without a budget a few broad queries exhaust the model's
+* context and stall the turn. Over-budget results are truncated with a
+* marker so the model re-queries more narrowly.
+*/
+const MAX_TOOL_RESULT_CHARS = 12e3;
+const TRUNCATION_NOTE = "\n...[truncated: this tool result exceeded the context budget; re-query with a more specific filter or fewer items]";
+function boundedToolResult(value) {
+	const text = resultText(value);
+	if (text.length <= 12e3) return value;
+	return text.slice(0, MAX_TOOL_RESULT_CHARS) + TRUNCATION_NOTE;
+}
+function resultText(value) {
+	if (typeof value === "string") return value;
+	const json = JSON.stringify(value);
+	return typeof json === "string" ? json : "undefined";
+}
+/**
+* Number of the most recent turns whose tool results are kept in full in
+* the committed history. Tool results are re-derivable (the store is the
+* source of truth), so results older than that window are replaced with
+* one-line stubs: this is what keeps a long conversation from exhausting
+* the model's context.
+*/
+const FULL_RESULT_TURNS = 2;
+/** Tool results smaller than this are cheap to keep and are never stubbed. */
+const STUB_MIN_CHARS = 500;
+function toolResultChars(output) {
+	const part = output;
+	if (part.type === "text" && typeof part.value === "string") return part.value.length;
+	const target = part.value !== void 0 ? part.value : output;
+	const json = JSON.stringify(target);
+	return typeof json === "string" ? json.length : 0;
+}
+function argDigest(input) {
+	if (input === void 0) return "";
+	let text;
+	try {
+		text = JSON.stringify(input);
+	} catch {
+		text = "";
+	}
+	if (text.length <= 80) return text;
+	return `${text.slice(0, 77)}…`;
+}
+/**
+* Replaces tool results older than the last {@link FULL_RESULT_TURNS}
+* turns with one-line stubs naming the tool and its arguments. User and
+* assistant messages are never touched, and tool calls keep their input,
+* so the model can re-query any stubbed result with the same arguments.
+* Idempotent: stubs are below {@link STUB_MIN_CHARS} and pass through.
+*/
+function stubStaleToolResults(history) {
+	let users = 0;
+	let windowStart = 0;
+	for (let i = history.length - 1; i >= 0; i--) if (history[i].role === "user") {
+		users += 1;
+		if (users === 2) {
+			windowStart = i;
+			break;
+		}
+	}
+	if (users < 2) return history;
+	const callInputs = /* @__PURE__ */ new Map();
+	for (const m of history) if (m.role === "assistant" && Array.isArray(m.content)) {
+		for (const part of m.content) if (part.type === "tool-call") callInputs.set(part.toolCallId, part.input);
+	}
+	return history.map((m, i) => {
+		if (i >= windowStart || m.role !== "tool") return m;
+		const content = m.content.map((part) => {
+			if (part.type !== "tool-result") return part;
+			const chars = toolResultChars(part.output);
+			if (chars < 500) return part;
+			const stub = {
+				type: "text",
+				value: `[result omitted: ${part.toolName} ${argDigest(callInputs.get(part.toolCallId))} — ${chars} chars; re-query the tool to refetch]`
+			};
+			return {
+				...part,
+				output: stub
+			};
+		});
+		if (!content.some((part, index) => part !== m.content[index])) return m;
+		return {
+			...m,
+			content
+		};
+	});
+}
+/**
+* Creates the chat language model for a user-supplied OpenAI-compatible
+* endpoint. Requests go directly from the browser to the endpoint; the API
+* key is never sent to any Powerhouse server.
+*/
+/**
+* Resolves the configured base URL. Relative paths (e.g. `/v1`) resolve
+* against the page origin, so single-origin deployments can serve the
+* endpoint behind the same reverse proxy without CORS.
+*/
+function resolveBaseUrl(raw) {
+	const base = raw.trim().replace(/\/+$/, "");
+	if (/^https?:\/\//i.test(base)) return base;
+	if (typeof window === "undefined") return base;
+	return `${window.location.origin}${base.startsWith("/") ? "" : "/"}${base}`;
+}
+function createReactorChatModel(settings) {
+	return createOpenAICompatible({
+		name: "reactor-chat",
+		baseURL: resolveBaseUrl(settings.baseUrl),
+		apiKey: settings.apiKey
+	}).chatModel(settings.model.trim());
+}
+/**
+* Unwraps the MCP `CallToolResult` envelope produced by the reactor tool
+* core into a plain value for the AI SDK. Throws for error results so the
+* SDK surfaces them as tool errors in the next model step.
+*/
+function unwrapToolResult(raw) {
+	if (raw && typeof raw === "object") {
+		const envelope = raw;
+		if (typeof envelope.isError === "boolean" || Array.isArray(envelope.content)) {
+			if (envelope.isError) {
+				const text = envelope.content?.find((c) => c.type === "text")?.text ?? "Unknown tool error";
+				throw new Error(text.replace(/^Error:\s*/, ""));
+			}
+			if (envelope.structuredContent !== void 0) return envelope.structuredContent;
+			const textPart = envelope.content?.find((c) => c.type === "text");
+			if (textPart?.text !== void 0) try {
+				return JSON.parse(textPart.text);
+			} catch {
+				return textPart.text;
+			}
+			return null;
+		}
+	}
+	return raw;
+}
+/** Builds the system prompt, grounding the agent in the current selection. */
+function buildSystemPrompt(context) {
+	const lines = [
+		"You are an assistant embedded in the Powerhouse Connect drive explorer.",
+		"You operate on a local-first document store (the reactor) exclusively through the provided tools.",
+		"Documents are instances of typed document models; drives are collections that group documents and folders.",
+		"Prefer read-only tools to discover state (document models, drives, documents, relationships) before making changes.",
+		"Never invent document ids, drive ids, folder ids or document model types — discover them with the read tools first.",
+		"Never accept secret values (passwords, tokens, API keys) in chat. When a connection or configuration requires a secret, tell the user to enter it in the relevant editor (e.g. the connection editor) and point them to the document. Never ask the user to paste a secret into the chat.",
+		"When the user refers to 'this', 'here' or 'it' without naming a target, they mean the current selection below; prefer it for create/modify targets.",
+		"Tool results may be truncated when they are large: if you see a truncation marker, narrow the query (more specific filter, fewer items) instead of retrying the same call.",
+		"Older tool results in this conversation may be replaced by a short '[result omitted: ...]' stub as the context grows; that is normal housekeeping, not an error. If you still need the data, call the same tool again with the same arguments."
+	];
+	const selection = [];
+	if (context.driveName) selection.push(`The current drive is "${context.driveName}"` + (context.driveId ? ` (id: ${context.driveId})` : "") + ".");
+	if (context.nodeKind === "folder" && context.nodeName) selection.push(`The current folder is "${context.nodeName}".`);
+	if (context.documentType) selection.push(`The current document is "${context.documentName ?? "unnamed"}" of type "${context.documentType}"` + (context.documentId ? ` (id: ${context.documentId})` : "") + ".");
+	if (context.switchboardUrl) selection.push(`The switchboard for this drive is at ${context.switchboardUrl}; its GraphQL endpoint is ${context.switchboardGraphqlUrl ?? ""}. Use the getSwitchboardSchema tool to list the queries and mutations it exposes.`);
+	else if (context.driveId) selection.push("This drive is not synced to a switchboard, so no switchboard endpoints are available for it.");
+	if (selection.length > 0) lines.push("Current selection:", ...selection.map((s) => `- ${s}`));
+	else lines.push("Nothing is currently selected. When the target of an action is ambiguous, ask the user which drive, folder or document it should apply to.");
+	return lines.join("\n");
+}
+/**
+* Runs one tool-loop conversation turn against an OpenAI-compatible model.
+*
+* The agent keeps the model message history across turns. Write tools are
+* gated by the AI SDK's tool approval: when auto-approval is off, the
+* pending user decision is bridged through {@link approve}/{@link reject}.
+*/
+var ReactorChatAgent = class {
+	history;
+	approvals = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.options = options;
+		this.history = options.history ?? [];
+	}
+	/** The model history after the last completed turn, for the next agent. */
+	getHistory() {
+		return this.history;
+	}
+	/** Clears the conversation history (a fresh chat). */
+	reset() {
+		this.history = [];
+		this.cancelPendingApprovals();
+	}
+	/** Approves a pending write tool call, resuming the agent loop. */
+	approve(toolCallId) {
+		this.resolveApproval(toolCallId, true);
+	}
+	/** Rejects a pending write tool call; the rejection is fed to the model. */
+	reject(toolCallId) {
+		this.resolveApproval(toolCallId, false);
+	}
+	resolveApproval(toolCallId, approved) {
+		const resolve = this.approvals.get(toolCallId);
+		if (resolve) {
+			this.approvals.delete(toolCallId);
+			resolve(approved);
+		}
+	}
+	cancelPendingApprovals() {
+		for (const resolve of this.approvals.values()) resolve(false);
+		this.approvals.clear();
+	}
+	/** Runs one user turn: appends the message, streams the model, commits history. */
+	async send(text) {
+		const { onEvent, signal, settings } = this.options;
+		const userMessage = {
+			role: "user",
+			content: text
+		};
+		const messages = [...this.history, userMessage];
+		const tools = {};
+		for (const descriptor of this.options.tools) tools[descriptor.name] = tool({
+			description: descriptor.description,
+			inputSchema: z.object(descriptor.inputSchema),
+			execute: async (args) => boundedToolResult(unwrapToolResult(await descriptor.callback(args)))
+		});
+		const model = this.options.model ?? createReactorChatModel(settings);
+		const turnMessages = [];
+		let lastInputTokens;
+		const result = streamText({
+			model,
+			system: buildSystemPrompt(this.options.context),
+			messages,
+			tools,
+			stopWhen: isStepCount(10),
+			abortSignal: signal,
+			onStepEnd: async (step) => {
+				turnMessages.push(...await toResponseMessages({
+					content: step.content,
+					tools
+				}));
+				if (typeof step.usage.inputTokens === "number") lastInputTokens = step.usage.inputTokens;
+			},
+			toolApproval: async ({ toolCall }) => {
+				const descriptor = this.options.tools.find((t) => t.name === toolCall.toolName);
+				if (settings.autoApproveWrites || !isWriteTool(toolCall.toolName, descriptor?.annotations)) return "not-applicable";
+				const toolCallId = toolCall.toolCallId;
+				onEvent({
+					type: "approval-request",
+					toolCallId,
+					name: toolCall.toolName,
+					args: toolCall.input
+				});
+				const approved = await new Promise((resolve) => {
+					this.approvals.set(toolCallId, resolve);
+				});
+				onEvent({
+					type: "approval-resolved",
+					toolCallId,
+					approved
+				});
+				return approved ? "approved" : {
+					type: "denied",
+					reason: "The user denied this action. Do not retry it; acknowledge the denial and ask how to proceed."
+				};
+			}
+		});
+		for await (const part of result.fullStream) this.handleStreamPart(part, onEvent);
+		if (lastInputTokens !== void 0) onEvent({
+			type: "usage",
+			inputTokens: lastInputTokens
+		});
+		this.history = stubStaleToolResults([
+			...this.history,
+			userMessage,
+			...this.dropUnresolvedToolCalls(turnMessages)
+		]);
+		onEvent({ type: "finish" });
+	}
+	/**
+	* Removes tool calls that were never executed (step cap or abort):
+	* OpenAI-compatible APIs reject a tool call without its tool result.
+	*/
+	dropUnresolvedToolCalls(messages) {
+		const resolved = /* @__PURE__ */ new Set();
+		for (const m of messages) if (m.role === "tool") {
+			for (const part of m.content) if (part.type === "tool-result") resolved.add(part.toolCallId);
+		}
+		const out = [...messages];
+		if (out.length === 0) return out;
+		const last = out[out.length - 1];
+		if (last.role !== "assistant" || typeof last.content === "string") return out;
+		const content = last.content.filter((part) => part.type !== "tool-call" || resolved.has(part.toolCallId));
+		if (content.length === 0) out.pop();
+		else out[out.length - 1] = {
+			...last,
+			content
+		};
+		return out;
+	}
+	handleStreamPart(part, onEvent) {
+		const p = part;
+		switch (p.type) {
+			case "text-delta": {
+				const { text } = p;
+				onEvent({
+					type: "text-delta",
+					delta: text
+				});
+				break;
+			}
+			case "tool-call": {
+				const { toolCallId, toolName, input } = p;
+				onEvent({
+					type: "tool-start",
+					toolCallId,
+					name: toolName,
+					args: input
+				});
+				break;
+			}
+			case "tool-result": {
+				const { toolCallId, toolName, output } = p;
+				onEvent({
+					type: "tool-result",
+					toolCallId,
+					name: toolName,
+					state: "done",
+					result: output
+				});
+				break;
+			}
+			case "tool-error": {
+				const { toolCallId, toolName, error } = p;
+				onEvent({
+					type: "tool-result",
+					toolCallId,
+					name: toolName,
+					state: "error",
+					error: error instanceof Error ? error.message : String(error)
+				});
+				break;
+			}
+			case "tool-approval-response": {
+				const { approved, toolCall } = p;
+				if (!approved) onEvent({
+					type: "tool-result",
+					toolCallId: toolCall.toolCallId,
+					name: toolCall.toolName,
+					state: "rejected"
+				});
+				break;
+			}
+			case "tool-output-denied": {
+				const { toolCallId, toolName } = p;
+				onEvent({
+					type: "tool-result",
+					toolCallId,
+					name: toolName,
+					state: "rejected"
+				});
+				break;
+			}
+			case "abort": break;
+			case "error": {
+				const { error } = p;
+				onEvent({
+					type: "error",
+					error: error instanceof Error ? error.message : String(error)
+				});
+				break;
+			}
+			default: break;
+		}
+	}
+};
+//#endregion
+//#region src/ai/components/approval-card.tsx
+function formatArgs$1(args) {
+	let json;
+	try {
+		json = JSON.stringify(args, null, 2);
+	} catch {
+		return String(args);
+	}
+	return json.length > 400 ? `${json.slice(0, 400)}\n…` : json;
+}
+/**
+* In-chat approval card for a write tool call. Approving or rejecting
+* resolves the pending approval inside the agent loop.
+*/
+function ApprovalCard({ approval, onApprove, onReject }) {
+	return /* @__PURE__ */ jsxs("div", {
+		className: "rounded-lg border border-border bg-muted/40 p-3",
+		children: [
+			/* @__PURE__ */ jsxs("p", {
+				className: "mb-1 text-xs font-semibold uppercase tracking-wide text-muted-foreground",
+				children: ["Approval required — ", approval.name]
+			}),
+			/* @__PURE__ */ jsx("pre", {
+				className: "mb-3 max-h-40 overflow-auto rounded bg-background p-2 text-xs text-foreground",
+				children: formatArgs$1(approval.args)
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex gap-2",
+				children: [/* @__PURE__ */ jsxs("button", {
+					type: "button",
+					onClick: () => onApprove(approval.toolCallId),
+					className: "flex items-center gap-1.5 rounded-md bg-primary px-3 py-1.5 text-sm font-medium text-primary-foreground hover:bg-primary/90",
+					children: [/* @__PURE__ */ jsx(Check, { size: 14 }), "Approve"]
+				}), /* @__PURE__ */ jsxs("button", {
+					type: "button",
+					onClick: () => onReject(approval.toolCallId),
+					className: "flex items-center gap-1.5 rounded-md border border-border bg-background px-3 py-1.5 text-sm font-medium text-foreground hover:bg-muted",
+					children: [/* @__PURE__ */ jsx(X, { size: 14 }), "Reject"]
+				})]
+			})
+		]
+	});
+}
+//#endregion
+//#region src/ai/components/markdown.tsx
+/**
+* Markdown renderer for assistant messages.
+*
+* Uses react-markdown, which builds React elements from the markdown AST and
+* does not execute raw HTML — safe for model-generated content. remark-gfm
+* adds the table/strikethrough/task-list syntax the agent emits. Element
+* styling is scoped to the chat window's text-sm scale via Tailwind
+* utilities, so no extra CSS is needed.
+*/
+function Markdown({ text }) {
+	return /* @__PURE__ */ jsx(ReactMarkdown, {
+		remarkPlugins: [remarkGfm],
+		components: {
+			p: ({ children }) => /* @__PURE__ */ jsx("p", {
+				className: "my-1.5 leading-relaxed first:mt-0 last:mb-0",
+				children
+			}),
+			h1: ({ children }) => /* @__PURE__ */ jsx("h1", {
+				className: "mb-1 mt-3 font-semibold first:mt-0",
+				children
+			}),
+			h2: ({ children }) => /* @__PURE__ */ jsx("h2", {
+				className: "mb-1 mt-3 font-semibold first:mt-0",
+				children
+			}),
+			h3: ({ children }) => /* @__PURE__ */ jsx("h3", {
+				className: "mb-1 mt-2.5 font-semibold first:mt-0",
+				children
+			}),
+			ul: ({ children }) => /* @__PURE__ */ jsx("ul", {
+				className: "my-1.5 list-disc space-y-0.5 pl-5",
+				children
+			}),
+			ol: ({ children }) => /* @__PURE__ */ jsx("ol", {
+				className: "my-1.5 list-decimal space-y-0.5 pl-5",
+				children
+			}),
+			li: ({ children }) => /* @__PURE__ */ jsx("li", {
+				className: "leading-relaxed",
+				children
+			}),
+			blockquote: ({ children }) => /* @__PURE__ */ jsx("blockquote", {
+				className: "my-1.5 border-l-2 border-border pl-2.5 text-muted-foreground",
+				children
+			}),
+			hr: () => /* @__PURE__ */ jsx("hr", { className: "my-2 border-border" }),
+			a: ({ children, href }) => /* @__PURE__ */ jsx("a", {
+				href,
+				target: "_blank",
+				rel: "noreferrer noopener",
+				className: "text-primary underline",
+				children
+			}),
+			table: ({ children }) => /* @__PURE__ */ jsx("div", {
+				className: "my-1.5 overflow-x-auto",
+				children: /* @__PURE__ */ jsx("table", {
+					className: "w-full border-collapse text-xs",
+					children
+				})
+			}),
+			thead: ({ children }) => /* @__PURE__ */ jsx("thead", { children }),
+			th: ({ children }) => /* @__PURE__ */ jsx("th", {
+				className: "border border-border bg-muted px-2 py-1 text-left font-semibold",
+				children
+			}),
+			td: ({ children }) => /* @__PURE__ */ jsx("td", {
+				className: "border border-border px-2 py-1 align-top",
+				children
+			}),
+			pre: ({ children }) => /* @__PURE__ */ jsx("pre", {
+				className: "my-1.5 overflow-x-auto rounded-md bg-muted p-2.5 text-xs leading-relaxed",
+				children
+			}),
+			code: ({ children, className }) => {
+				if ((className ?? "").startsWith("language-")) return /* @__PURE__ */ jsx("code", {
+					className,
+					children
+				});
+				return /* @__PURE__ */ jsx("code", {
+					className: "rounded bg-muted px-1 py-0.5 text-[0.8125rem]",
+					children
+				});
+			}
+		},
+		children: text
+	});
+}
+//#endregion
+//#region src/ai/components/chat-window.tsx
+function formatArgs(args) {
+	let json;
+	try {
+		json = JSON.stringify(args);
+	} catch {
+		return String(args);
+	}
+	return json.length > 200 ? `${json.slice(0, 200)}…` : json;
+}
+function ToolCard({ part }) {
+	const [expanded, setExpanded] = useState(false);
+	return /* @__PURE__ */ jsxs("div", {
+		className: "rounded-lg border border-border bg-background p-2",
+		children: [/* @__PURE__ */ jsxs("button", {
+			type: "button",
+			onClick: () => setExpanded((e) => !e),
+			className: "flex w-full items-center gap-2 text-left text-xs text-foreground",
+			children: [
+				part.state === "done" && /* @__PURE__ */ jsx(Check, {
+					size: 13,
+					className: "shrink-0 text-info"
+				}),
+				part.state === "error" && /* @__PURE__ */ jsx(X, {
+					size: 13,
+					className: "shrink-0 text-destructive"
+				}),
+				part.state === "rejected" && /* @__PURE__ */ jsx(X, {
+					size: 13,
+					className: "shrink-0 text-muted-foreground"
+				}),
+				part.state === "executing" && /* @__PURE__ */ jsx("span", {
+					className: "shrink-0 text-muted-foreground",
+					children: "⋯"
+				}),
+				/* @__PURE__ */ jsxs("span", {
+					className: "font-mono text-muted-foreground",
+					children: [
+						part.name,
+						"(",
+						formatArgs(part.args),
+						")"
+					]
+				})
+			]
+		}), expanded && /* @__PURE__ */ jsx("pre", {
+			className: "mt-2 max-h-40 overflow-auto rounded bg-muted p-2 text-xs text-foreground",
+			children: JSON.stringify({
+				args: part.args,
+				result: part.result,
+				error: part.error
+			}, null, 2)
+		})]
+	});
+}
+function MessageView({ message, onApprove, onReject }) {
+	if (message.role === "user") return /* @__PURE__ */ jsx("div", {
+		className: "flex justify-end",
+		children: /* @__PURE__ */ jsx("div", {
+			className: "max-w-[85%] whitespace-pre-wrap rounded-lg bg-muted px-3 py-2 text-sm text-foreground",
+			children: message.parts.filter((p) => p.type === "text").map((p) => p.text).join("")
+		})
+	});
+	return /* @__PURE__ */ jsxs("div", {
+		className: "space-y-2",
+		children: [message.parts.map((part, index) => part.type === "text" ? /* @__PURE__ */ jsx("div", {
+			className: "text-sm text-foreground",
+			children: /* @__PURE__ */ jsx(Markdown, { text: part.text })
+		}, index) : /* @__PURE__ */ jsxs("div", {
+			className: "space-y-2",
+			children: [/* @__PURE__ */ jsx(ToolCard, { part }), part.state === "awaiting-approval" && /* @__PURE__ */ jsx(ApprovalCard, {
+				approval: {
+					toolCallId: part.toolCallId,
+					name: part.name,
+					args: part.args
+				},
+				onApprove,
+				onReject
+			})]
+		}, part.toolCallId)), message.parts.length === 0 && /* @__PURE__ */ jsx("div", {
+			className: "text-sm text-muted-foreground",
+			children: "Thinking…"
+		})]
+	});
+}
+/** The chat window panel, anchored above the FAB in the bottom-right. */
+function ChatWindow({ chat, onClose }) {
+	const [fullscreen, setFullscreen] = useState(false);
+	const [draft, setDraft] = useState("");
+	const listRef = useRef(null);
+	useEffect(() => {
+		const el = listRef.current;
+		if (el) el.scrollTo({ top: el.scrollHeight });
+	}, [chat.messages]);
+	useEffect(() => {
+		if (!fullscreen) return;
+		const onKey = (event) => {
+			if (event.key === "Escape") setFullscreen(false);
+		};
+		window.addEventListener("keydown", onKey);
+		return () => window.removeEventListener("keydown", onKey);
+	}, [fullscreen]);
+	const submit = () => {
+		const text = draft;
+		setDraft("");
+		chat.send(text);
+	};
+	return /* @__PURE__ */ jsxs("div", {
+		className: fullscreen ? "fixed inset-0 z-50 flex flex-col overflow-hidden bg-background" : "fixed bottom-24 right-6 z-40 flex max-h-[min(28rem,calc(100vh-8rem))] w-[min(24rem,calc(100vw-3rem))] flex-col overflow-hidden rounded-xl border border-border bg-background shadow-2xl",
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex items-center justify-between border-b border-border px-4 py-2.5",
+				children: [/* @__PURE__ */ jsx("span", {
+					className: "text-sm font-semibold text-foreground",
+					children: "AI Assistant"
+				}), /* @__PURE__ */ jsxs("div", {
+					className: "flex items-center gap-1 text-muted-foreground",
+					children: [
+						/* @__PURE__ */ jsx("button", {
+							type: "button",
+							"aria-label": fullscreen ? "Exit fullscreen" : "Fullscreen",
+							title: fullscreen ? "Exit fullscreen (Esc)" : "Fullscreen",
+							onClick: () => setFullscreen((f) => !f),
+							className: "rounded p-1 hover:bg-muted hover:text-foreground",
+							children: fullscreen ? /* @__PURE__ */ jsx(Minimize2, { size: 15 }) : /* @__PURE__ */ jsx(Maximize2, { size: 15 })
+						}),
+						/* @__PURE__ */ jsx("button", {
+							type: "button",
+							"aria-label": "Clear conversation",
+							title: "New chat",
+							onClick: chat.clear,
+							className: "rounded p-1 hover:bg-muted hover:text-foreground",
+							children: /* @__PURE__ */ jsx(Trash2, { size: 15 })
+						}),
+						/* @__PURE__ */ jsx("button", {
+							type: "button",
+							"aria-label": "Close AI chat",
+							title: "Close",
+							onClick: onClose,
+							className: "rounded p-1 hover:bg-muted hover:text-foreground",
+							children: /* @__PURE__ */ jsx(X, { size: 15 })
+						})
+					]
+				})]
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				ref: listRef,
+				className: "flex-1 space-y-3 overflow-y-auto px-4 py-3",
+				children: [
+					chat.messages.length === 0 && /* @__PURE__ */ jsx("div", {
+						className: "pt-8 text-center text-sm text-muted-foreground",
+						children: chat.configured ? /* @__PURE__ */ jsx("p", { children: "Ask the assistant to create or change documents, manage drives, or inspect read models." }) : /* @__PURE__ */ jsx("p", { children: "Add your OpenAI-compatible endpoint under Settings → AI Assistant, then start a conversation." })
+					}),
+					chat.messages.map((message) => /* @__PURE__ */ jsx(MessageView, {
+						message,
+						onApprove: chat.approve,
+						onReject: chat.reject
+					}, message.id)),
+					chat.error && /* @__PURE__ */ jsx("div", {
+						className: "rounded-lg border border-destructive/40 bg-destructive/10 p-2 text-xs text-destructive",
+						children: chat.error
+					})
+				]
+			}),
+			/* @__PURE__ */ jsx("div", {
+				className: "border-t border-border p-3",
+				children: /* @__PURE__ */ jsxs("div", {
+					className: "flex items-end gap-2",
+					children: [/* @__PURE__ */ jsx("textarea", {
+						rows: 2,
+						value: draft,
+						onChange: (e) => setDraft(e.target.value),
+						onKeyDown: (e) => {
+							if (e.key === "Enter" && !e.shiftKey) {
+								e.preventDefault();
+								submit();
+							}
+						},
+						placeholder: chat.configured ? "Ask the assistant… (Enter to send)" : "Configure the endpoint in settings first",
+						className: "max-h-32 min-h-[2.5rem] flex-1 resize-none rounded-md border border-border bg-background p-2 text-sm text-foreground placeholder:text-muted-foreground focus:outline-none",
+						disabled: chat.isStreaming
+					}), chat.isStreaming ? /* @__PURE__ */ jsx("button", {
+						type: "button",
+						"aria-label": "Stop generating",
+						title: "Stop",
+						onClick: chat.stop,
+						className: "flex size-9 shrink-0 items-center justify-center rounded-md bg-primary text-primary-foreground hover:bg-primary/90",
+						children: /* @__PURE__ */ jsx(Square, { size: 15 })
+					}) : /* @__PURE__ */ jsx("button", {
+						type: "button",
+						"aria-label": "Send message",
+						title: "Send",
+						onClick: submit,
+						disabled: !draft.trim() || !chat.configured,
+						className: "flex size-9 shrink-0 items-center justify-center rounded-md bg-primary text-primary-foreground hover:bg-primary/90 disabled:disabled-effect",
+						children: /* @__PURE__ */ jsx(ArrowUp, { size: 15 })
+					})]
+				})
+			})
+		]
+	});
+}
+//#endregion
+//#region src/ai/settings-store.ts
+const STORAGE_KEY = "ph-ai-chat-settings";
+const DEFAULT_AI_SETTINGS = {
+	enabled: false,
+	baseUrl: "",
+	apiKey: "",
+	model: "",
+	autoApproveWrites: false
+};
+let snapshot = load();
+const listeners = /* @__PURE__ */ new Set();
+function load() {
+	if (typeof localStorage === "undefined") return { ...DEFAULT_AI_SETTINGS };
+	try {
+		const raw = localStorage.getItem(STORAGE_KEY);
+		if (!raw) return { ...DEFAULT_AI_SETTINGS };
+		const parsed = JSON.parse(raw);
+		return {
+			enabled: typeof parsed.enabled === "boolean" ? parsed.enabled : false,
+			baseUrl: typeof parsed.baseUrl === "string" ? parsed.baseUrl : "",
+			apiKey: typeof parsed.apiKey === "string" ? parsed.apiKey : "",
+			model: typeof parsed.model === "string" ? parsed.model : "",
+			autoApproveWrites: typeof parsed.autoApproveWrites === "boolean" ? parsed.autoApproveWrites : false
+		};
+	} catch {
+		return { ...DEFAULT_AI_SETTINGS };
+	}
+}
+function persist(settings) {
+	try {
+		localStorage.setItem(STORAGE_KEY, JSON.stringify(settings));
+	} catch {}
+}
+function emit() {
+	for (const listener of listeners) listener();
+}
+/** Returns the current settings (stable snapshot for useSyncExternalStore). */
+function getAiSettings() {
+	return snapshot;
+}
+/** Merges a partial update, persists, and notifies subscribers. */
+function updateAiSettings(patch) {
+	snapshot = {
+		...snapshot,
+		...patch
+	};
+	persist(snapshot);
+	emit();
+	return snapshot;
+}
+/** Clears all stored settings. */
+function clearAiSettings() {
+	snapshot = { ...DEFAULT_AI_SETTINGS };
+	try {
+		localStorage.removeItem(STORAGE_KEY);
+	} catch {}
+	emit();
+}
+/** Subscribes to settings changes. Returns the unsubscribe function. */
+function subscribeAiSettings(listener) {
+	listeners.add(listener);
+	return () => {
+		listeners.delete(listener);
+	};
+}
+/** True when the endpoint, key and model are all configured. */
+function isAiConfigured(settings) {
+	return settings.baseUrl.trim().length > 0 && settings.apiKey.trim().length > 0 && settings.model.trim().length > 0;
+}
+//#endregion
+//#region src/ai/switchboard.ts
+/**
+* Reads the tab-side sync manager from the browser global. Returns
+* `undefined` in non-browser environments or before the reactor client
+* module is initialized.
+*/
+function getBrowserSyncManager() {
+	if (typeof window === "undefined") return;
+	return window.ph?.reactorClientModule?.reactorModule?.syncModule?.syncManager;
+}
+/** Suffix of the per-drive GraphQL channel endpoint the switchboard serves. */
+const GQL_CHANNEL_SUFFIX = "/graphql/r";
+/**
+* Resolves the switchboard that serves a drive, if any.
+*
+* Every remote drive stores its switchboard's exact GraphQL channel
+* endpoint in its sync remote — `channelConfig = { type: "gql",
+* parameters: { url: "<origin>/graphql/r" } }` — and the switchboard base
+* is that URL minus the `/graphql/r` suffix. Deriving it per drive (rather
+* than from a global setting) is what keeps multi-switchboard deployments
+* correct. Drives that are not synced to a remote switchboard (local
+* drives, other channel types, unexpected shapes) return `undefined`.
+*/
+function resolveDriveSwitchboard(driveId, syncManager) {
+	const manager = syncManager ?? getBrowserSyncManager();
+	if (!driveId || !manager) return;
+	const collectionId = DriveCollectionId.forDrive(driveId);
+	const remote = manager.list().find((r) => r.meta.collectionId.equals(collectionId));
+	if (!remote) return;
+	const { channelConfig } = remote.meta;
+	if (channelConfig.type !== "gql") return;
+	const url = channelConfig.parameters.url;
+	if (typeof url !== "string" || !url.endsWith(GQL_CHANNEL_SUFFIX)) return;
+	const switchboardUrl = url.slice(0, -10);
+	return {
+		switchboardUrl,
+		graphqlUrl: `${switchboardUrl}/graphql`
+	};
+}
+/**
+* Introspection over the switchboard supergraph's root query and mutation
+* fields. Types are requested with three levels of `ofType` nesting so
+* that common shapes like `[X!]!` (LIST(NON_NULL(LIST(X)))) render fully.
+*/
+const SWITCHBOARD_INTROSPECTION_QUERY = `
+  query SwitchboardIntrospection {
+    __schema {
+      queryType {
+        fields {
+          name
+          description
+          args {
+            name
+            type {
+              kind
+              name
+              ofType {
+                kind
+                name
+                ofType {
+                  kind
+                  name
+                  ofType {
+                    kind
+                    name
+                  }
+                }
+              }
+            }
+          }
+          type {
+            kind
+            name
+            ofType {
+              kind
+              name
+              ofType {
+                kind
+                name
+                ofType {
+                  kind
+                  name
+                }
+              }
+            }
+          }
+        }
+      }
+      mutationType {
+        fields {
+          name
+          description
+          args {
+            name
+            type {
+              kind
+              name
+              ofType {
+                kind
+                name
+                ofType {
+                  kind
+                  name
+                  ofType {
+                    kind
+                    name
+                  }
+                }
+              }
+            }
+          }
+          type {
+            kind
+            name
+            ofType {
+              kind
+              name
+              ofType {
+                kind
+                name
+                ofType {
+                  kind
+                  name
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+/**
+* Renders an introspected type reference as a GraphQL type string.
+* Recursion is bounded by the `ofType` nesting of the query, so it always
+* terminates.
+*/
+function renderTypeRef(type) {
+	if (!type) return "Unknown";
+	switch (type.kind) {
+		case "NON_NULL": return `${renderTypeRef(type.ofType)}!`;
+		case "LIST": return `[${renderTypeRef(type.ofType)}]`;
+		default: return type.name ?? "Unknown";
+	}
+}
+/** Cap on the number of fields reported per root type. */
+const MAX_FIELDS_PER_ROOT = 200;
+function summarizeFields(fields) {
+	const list = fields ?? [];
+	return {
+		fields: list.slice(0, MAX_FIELDS_PER_ROOT).map((field) => ({
+			name: field.name,
+			...field.description ? { description: field.description } : {},
+			args: field.args.map((arg) => `${arg.name}: ${renderTypeRef(arg.type)}`).join(", "),
+			returns: renderTypeRef(field.type)
+		})),
+		truncated: list.length > MAX_FIELDS_PER_ROOT
+	};
+}
+/**
+* Reduces a GraphQL `__schema` introspection payload (the `data.__schema`
+* object) to a compact summary of its root query and mutation fields.
+* Accepts `unknown` because the payload arrives over the wire.
+*/
+function summarizeIntrospectionSchema(schema) {
+	const introspection = schema ?? {};
+	const queries = summarizeFields(introspection.queryType?.fields);
+	const mutations = summarizeFields(introspection.mutationType?.fields);
+	return {
+		queries: queries.fields,
+		mutations: mutations.fields,
+		truncated: queries.truncated || mutations.truncated
+	};
+}
+const SWITCHBOARD_SCHEMA_TOOL_NAME = "getSwitchboardSchema";
+/**
+* Creates the read-only `getSwitchboardSchema` tool: it introspects the
+* GraphQL supergraph of the switchboard serving a drive and returns a
+* summary of its root queries and mutations. It reads the schema only and
+* never modifies data.
+*/
+function createSwitchboardSchemaTool(deps) {
+	const getSyncManager = deps?.getSyncManager ?? getBrowserSyncManager;
+	const getSelectedDriveId = deps?.getSelectedDriveId ?? (() => typeof window === "undefined" ? void 0 : window.ph?.selectedDriveId);
+	const tokenProvider = deps?.tokenProvider ?? ambientRenownTokenProvider;
+	const fetchImpl = deps?.fetchImpl ?? fetch;
+	const timeoutMs = deps?.timeoutMs ?? 1e4;
+	return {
+		name: SWITCHBOARD_SCHEMA_TOOL_NAME,
+		description: "Introspect the GraphQL endpoint of the switchboard serving a drive and list the queries and mutations it exposes (reactor operations, document-model read models, package subgraphs). Read-only: it reads the schema only and never modifies data. Omit driveId to introspect the currently selected drive.",
+		inputSchema: { driveId: z.string().describe("Drive to introspect. Omit to use the currently selected drive.").optional() },
+		annotations: { readOnlyHint: true },
+		callback: async (input) => {
+			const driveId = input?.driveId ?? getSelectedDriveId();
+			const sb = resolveDriveSwitchboard(driveId, getSyncManager());
+			if (!sb) throw new Error(driveId ? `Drive "${driveId}" has no switchboard: it is not synced to a remote switchboard.` : "No drive is currently selected and no driveId was given.");
+			const token = await tokenProvider();
+			let response;
+			try {
+				response = await fetchImpl(sb.graphqlUrl, {
+					method: "POST",
+					headers: {
+						"content-type": "application/json",
+						...token ? { authorization: `Bearer ${token}` } : {}
+					},
+					body: JSON.stringify({ query: SWITCHBOARD_INTROSPECTION_QUERY }),
+					signal: AbortSignal.timeout(timeoutMs)
+				});
+			} catch (error) {
+				throw new Error(`Switchboard at ${sb.graphqlUrl} is not reachable: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+			}
+			if (response.status === 401 || response.status === 403) throw new Error(`Switchboard at ${sb.graphqlUrl} refused the request (HTTP ${response.status}). Sign in to the switchboard (Renown) and try again.`);
+			if (!response.ok) throw new Error(`Switchboard introspection failed: HTTP ${response.status} ${response.statusText} from ${sb.graphqlUrl}`);
+			const body = await response.json();
+			const schemaErrors = body?.errors;
+			if (schemaErrors && schemaErrors.length > 0) throw new Error(schemaErrors.map((e) => e.message ?? "unknown error").join("; "));
+			const schema = body?.data?.__schema;
+			if (!schema?.queryType) throw new Error(`Switchboard at ${sb.graphqlUrl} did not return a GraphQL schema.`);
+			const summary = summarizeIntrospectionSchema(schema);
+			return {
+				switchboardUrl: sb.switchboardUrl,
+				graphqlUrl: sb.graphqlUrl,
+				...summary
+			};
+		}
+	};
+}
+//#endregion
+//#region src/ai/context.ts
+/**
+* Snapshot of the current selection in the drive explorer, used to make the
+* chat context-aware: "create a budget here" targets the selected drive,
+* "summarize this document" targets the selected document.
+*/
+function useChatContext() {
+	const [drive] = useSelectedDriveSafe();
+	const node = useSelectedNode();
+	const documentId = useSelectedDocumentId();
+	const context = {
+		driveId: drive?.header.id,
+		driveName: drive?.header.name
+	};
+	if (node) {
+		context.nodeId = node.id;
+		context.nodeName = node.name;
+		if (isFolderNode(node)) context.nodeKind = "folder";
+		else if (isFileNode(node)) context.nodeKind = "file";
+	}
+	if (documentId && node && isFileNode(node)) {
+		context.documentName = node.name;
+		context.documentType = node.documentType;
+		context.documentId = documentId;
+	}
+	const sb = resolveDriveSwitchboard(drive?.header.id);
+	if (sb) {
+		context.switchboardUrl = sb.switchboardUrl;
+		context.switchboardGraphqlUrl = sb.graphqlUrl;
+	}
+	return context;
+}
+//#endregion
+//#region src/ai/use-reactor-chat.ts
+function updateAssistantPart(messages, assistantId, update) {
+	if (!assistantId) return messages;
+	return messages.map((message) => message.id === assistantId ? {
+		...message,
+		parts: update(message.parts)
+	} : message);
+}
+function toErrorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/**
+* Drives one in-browser chat conversation against the reactor tools.
+*
+* `toolsProvider` lazily resolves the tool descriptors (e.g. from
+* `createReactorMcpProvider` bound to `window.ph.reactorClient`) when the
+* user sends a message, so the reactor does not need to be ready at render
+* time.
+*/
+function useReactorChat(toolsProvider) {
+	const [messages, setMessages] = useState([]);
+	const [isStreaming, setIsStreaming] = useState(false);
+	const [pendingApprovals, setPendingApprovals] = useState([]);
+	const [error, setError] = useState(null);
+	const agentRef = useRef(null);
+	const abortRef = useRef(null);
+	const streamingRef = useRef(false);
+	const pendingRef = useRef(/* @__PURE__ */ new Set());
+	const assistantIdRef = useRef(null);
+	const historyRef = useRef([]);
+	const settings = useSyncExternalStore(subscribeAiSettings, getAiSettings);
+	const context = useChatContext();
+	const handleEvent = useCallback((event) => {
+		const assistantId = assistantIdRef.current;
+		switch (event.type) {
+			case "text-delta":
+				setMessages((prev) => updateAssistantPart(prev, assistantId, (parts) => {
+					const last = parts[parts.length - 1];
+					if (last?.type === "text") return [...parts.slice(0, -1), {
+						...last,
+						text: last.text + event.delta
+					}];
+					return [...parts, {
+						type: "text",
+						text: event.delta
+					}];
+				}));
+				break;
+			case "tool-start":
+				setMessages((prev) => updateAssistantPart(prev, assistantId, (parts) => [...parts, {
+					type: "tool",
+					toolCallId: event.toolCallId,
+					name: event.name,
+					args: event.args,
+					state: pendingRef.current.has(event.toolCallId) ? "awaiting-approval" : "executing"
+				}]));
+				break;
+			case "approval-request":
+				pendingRef.current.add(event.toolCallId);
+				setMessages((prev) => updateAssistantPart(prev, assistantId, (parts) => parts.map((part) => part.type === "tool" && part.toolCallId === event.toolCallId ? {
+					...part,
+					state: "awaiting-approval"
+				} : part)));
+				setPendingApprovals((prev) => [...prev, {
+					toolCallId: event.toolCallId,
+					name: event.name,
+					args: event.args
+				}]);
+				break;
+			case "approval-resolved":
+				pendingRef.current.delete(event.toolCallId);
+				setPendingApprovals((prev) => prev.filter((a) => a.toolCallId !== event.toolCallId));
+				if (!event.approved) setMessages((prev) => updateAssistantPart(prev, assistantId, (parts) => parts.map((part) => part.type === "tool" && part.toolCallId === event.toolCallId ? {
+					...part,
+					state: "rejected"
+				} : part)));
+				break;
+			case "tool-result":
+				setMessages((prev) => updateAssistantPart(prev, assistantId, (parts) => parts.map((part) => part.type === "tool" && part.toolCallId === event.toolCallId ? {
+					...part,
+					state: event.state,
+					result: event.result,
+					error: event.error
+				} : part)));
+				break;
+			case "error":
+				setError(event.error);
+				break;
+			case "finish": break;
+		}
+	}, []);
+	const send = useCallback((text) => {
+		const trimmed = text.trim();
+		if (!trimmed || streamingRef.current) return;
+		setError(null);
+		const currentSettings = getAiSettings();
+		if (!isAiConfigured(currentSettings)) {
+			setError("Configure the AI endpoint, API key and model in settings first.");
+			return;
+		}
+		(async () => {
+			let tools;
+			try {
+				if (!toolsProvider) throw new Error("No tool provider configured");
+				tools = await toolsProvider();
+			} catch (toolError) {
+				setError(`Could not initialise the reactor tools: ${toErrorMessage(toolError)}`);
+				return;
+			}
+			if (tools.length === 0) {
+				setError("The reactor exposed no tools.");
+				return;
+			}
+			const controller = new AbortController();
+			abortRef.current = controller;
+			const agent = new ReactorChatAgent({
+				settings: currentSettings,
+				tools,
+				context,
+				onEvent: handleEvent,
+				signal: controller.signal,
+				history: historyRef.current
+			});
+			agentRef.current = agent;
+			const assistantId = crypto.randomUUID();
+			assistantIdRef.current = assistantId;
+			setMessages((prev) => [
+				...prev,
+				{
+					id: crypto.randomUUID(),
+					role: "user",
+					parts: [{
+						type: "text",
+						text: trimmed
+					}]
+				},
+				{
+					id: assistantId,
+					role: "assistant",
+					parts: []
+				}
+			]);
+			streamingRef.current = true;
+			setIsStreaming(true);
+			try {
+				await agent.send(trimmed);
+			} catch (sendError) {
+				setError(toErrorMessage(sendError));
+			} finally {
+				streamingRef.current = false;
+				setIsStreaming(false);
+				abortRef.current = null;
+				historyRef.current = agent.getHistory();
+			}
+		})();
+	}, [
+		toolsProvider,
+		context,
+		handleEvent
+	]);
+	const stop = useCallback(() => {
+		abortRef.current?.abort();
+	}, []);
+	const approve = useCallback((toolCallId) => {
+		agentRef.current?.approve(toolCallId);
+	}, []);
+	const reject = useCallback((toolCallId) => {
+		agentRef.current?.reject(toolCallId);
+	}, []);
+	const clear = useCallback(() => {
+		abortRef.current?.abort();
+		agentRef.current?.reset();
+		agentRef.current = null;
+		historyRef.current = [];
+		pendingRef.current.clear();
+		setPendingApprovals([]);
+		setError(null);
+		assistantIdRef.current = null;
+	}, []);
+	return {
+		messages,
+		isStreaming,
+		pendingApprovals,
+		error,
+		settings,
+		configured: isAiConfigured(settings),
+		send,
+		stop,
+		approve,
+		reject,
+		clear
+	};
+}
+//#endregion
+//#region src/ai/components/reactor-chat-fab.tsx
+/**
+* Bottom-right floating action button that opens the reactor AI chat window.
+*
+* `getTools` lazily resolves the reactor tool descriptors (from
+* `createReactorMcpProvider` bound to the browser reactor client) when the
+* user sends a message.
+*/
+function ReactorChatFab({ getTools }) {
+	const settings = useSyncExternalStore(subscribeAiSettings, getAiSettings);
+	const [open, setOpen] = useState(false);
+	const chat = useReactorChat(getTools);
+	if (!settings.enabled) return null;
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("button", {
+		type: "button",
+		"aria-label": open ? "Close AI chat" : "Open AI chat",
+		title: open ? "Close AI chat" : "AI chat",
+		onClick: () => setOpen((o) => !o),
+		className: "fixed bottom-6 right-6 z-40 flex size-12 items-center justify-center rounded-full bg-primary text-primary-foreground shadow-lg transition-transform hover:scale-105 disabled:disabled-effect",
+		children: open ? /* @__PURE__ */ jsx(X, { size: 20 }) : /* @__PURE__ */ jsx(MessageCircle, { size: 20 })
+	}), open && /* @__PURE__ */ jsx(ChatWindow, {
+		chat,
+		onClose: () => setOpen(false)
+	})] });
+}
+//#endregion
+export { ApprovalCard, ChatWindow, DEFAULT_AI_SETTINGS, FULL_RESULT_TURNS, MAX_AGENT_STEPS, MAX_TOOL_RESULT_CHARS, ReactorChatAgent, ReactorChatFab, STUB_MIN_CHARS, SWITCHBOARD_INTROSPECTION_QUERY, SWITCHBOARD_SCHEMA_TOOL_NAME, WRITE_TOOLS, buildSystemPrompt, clearAiSettings, createReactorChatModel, createSwitchboardSchemaTool, getAiSettings, getBrowserSyncManager, isAiConfigured, isWriteTool, resolveDriveSwitchboard, stubStaleToolResults, subscribeAiSettings, summarizeIntrospectionSchema, unwrapToolResult, updateAiSettings, useChatContext, useReactorChat };
+
+//# sourceMappingURL=index.js.map