@eclipse-docks/extension-ai-system 0.7.141 → 0.8.1

package/dist/{runtime-DfNGzEjU.js → runtime-By5PP2BC.js}

@@ -1,4 +1,4 @@
-import { Directory, File, commandRegistry, persistenceService, workspaceService } from "@eclipse-docks/core";
+import { Directory, File, IN_MEMORY_ROOT_NAME, commandRegistry, filebrowserDialog, getInMemoryRoot, persistenceService, setInMemoryMountProjection, workspaceService } from "@eclipse-docks/core";
 import { Models } from "@opencode-ai/models";
 //#region src/runtime/events.ts
 /** Tiny in-process bus so runtime stays UI-agnostic. */
@@ -548,6 +548,17 @@ function normalizeProvidersSettings(raw) {
 	};
 }
 //#endregion
+//#region src/runtime/abort.ts
+/** True when an AbortSignal has already been aborted. */
+function isAborted(signal) {
+	return Boolean(signal?.aborted);
+}
+/** True for DOMException / Error abort failures from fetch and friends. */
+function isAbortError(err) {
+	if (!err || typeof err !== "object") return false;
+	return err.name === "AbortError";
+}
+//#endregion
 //#region src/runtime/models/openai-compatible.ts
 function wireContent(content) {
 	if (typeof content === "string") return content;
@@ -665,6 +676,10 @@ var OpenAICompatibleProvider = class {
 				signal: params.signal
 			});
 		} catch (err) {
+			if (params.signal?.aborted || isAbortError(err)) {
+				yield { type: "done" };
+				return;
+			}
 			yield {
 				type: "error",
 				error: err instanceof Error ? err.message : String(err)
@@ -683,7 +698,21 @@ var OpenAICompatibleProvider = class {
 		let buffer = "";
 		const toolAcc = /* @__PURE__ */ new Map();
 		while (true) {
-			const { done, value } = await reader.read();
+			let done;
+			let value;
+			try {
+				({done, value} = await reader.read());
+			} catch (err) {
+				if (params.signal?.aborted || isAbortError(err)) {
+					yield { type: "done" };
+					return;
+				}
+				yield {
+					type: "error",
+					error: err instanceof Error ? err.message : String(err)
+				};
+				return;
+			}
 			if (done) break;
 			buffer += decoder.decode(value, { stream: true });
 			const lines = buffer.split("\n");
@@ -955,227 +984,40 @@ function isMutatingName(name) {
 	return /^(write|edit|delete|mkdir|rm|mv|save|apply)/i.test(name) || name.includes("write") || name.includes("delete");
 }
 //#endregion
-//#region src/runtime/tools/workspace-adapter.ts
-function asRecord(value) {
-	return value && typeof value === "object" ? value : {};
-}
-/** Registers built-in workspace file tools on the broker. */
-function registerWorkspaceTools(broker) {
-	broker.register({
-		name: "workspace_list",
-		description: "List children of a workspace directory path",
-		parameters: {
-			type: "object",
-			properties: { path: {
-				type: "string",
-				description: "Directory path relative to workspace"
-			} },
-			required: ["path"]
-		}
-	}, async (call) => {
-		try {
-			const path = String(call.arguments.path ?? "");
-			const root = await workspaceService.getWorkspace();
-			if (!root) return {
-				id: call.id,
-				name: call.name,
-				ok: false,
-				output: null,
-				error: "No workspace"
-			};
-			const resource = await root.getResource(path.endsWith("/") ? path : `${path}/`);
-			if (!(resource instanceof Directory)) return {
-				id: call.id,
-				name: call.name,
-				ok: false,
-				output: null,
-				error: "Not a directory"
-			};
-			const children = await resource.listChildren(true);
-			return {
-				id: call.id,
-				name: call.name,
-				ok: true,
-				output: children.map((c) => ({
-					name: c.getName(),
-					path: c.getWorkspacePath()
-				}))
-			};
-		} catch (err) {
-			return {
-				id: call.id,
-				name: call.name,
-				ok: false,
-				output: null,
-				error: err instanceof Error ? err.message : String(err)
-			};
-		}
-	});
-	broker.register({
-		name: "workspace_read",
-		description: "Read a workspace file as text",
-		parameters: {
-			type: "object",
-			properties: { path: { type: "string" } },
-			required: ["path"]
-		}
-	}, async (call) => {
-		try {
-			const path = String(call.arguments.path ?? "");
-			const root = await workspaceService.getWorkspace();
-			if (!root) return {
-				id: call.id,
-				name: call.name,
-				ok: false,
-				output: null,
-				error: "No workspace"
-			};
-			const resource = await root.getResource(path);
-			if (!(resource instanceof File)) return {
-				id: call.id,
-				name: call.name,
-				ok: false,
-				output: null,
-				error: "Not a file"
-			};
-			const contents = await resource.getContents();
-			return {
-				id: call.id,
-				name: call.name,
-				ok: true,
-				output: contents
-			};
-		} catch (err) {
-			return {
-				id: call.id,
-				name: call.name,
-				ok: false,
-				output: null,
-				error: err instanceof Error ? err.message : String(err)
-			};
-		}
-	});
-	broker.register({
-		name: "workspace_write",
-		description: "Write text contents to a workspace file (creates parents as needed)",
-		parameters: {
-			type: "object",
-			properties: {
-				path: { type: "string" },
-				contents: { type: "string" }
-			},
-			required: ["path", "contents"]
-		}
-	}, async (call) => {
-		try {
-			const args = asRecord(call.arguments);
-			const path = String(args.path ?? "");
-			const contents = String(args.contents ?? "");
-			const root = await workspaceService.getWorkspace();
-			if (!root) return {
-				id: call.id,
-				name: call.name,
-				ok: false,
-				output: null,
-				error: "No workspace",
-				mutating: true
-			};
-			const resource = await root.getResource(path, { create: true });
-			if (!(resource instanceof File)) return {
-				id: call.id,
-				name: call.name,
-				ok: false,
-				output: null,
-				error: "Not a file",
-				mutating: true
-			};
-			await resource.saveContents(contents);
-			return {
-				id: call.id,
-				name: call.name,
-				ok: true,
-				output: { path },
-				mutating: true
-			};
-		} catch (err) {
-			return {
-				id: call.id,
-				name: call.name,
-				ok: false,
-				output: null,
-				error: err instanceof Error ? err.message : String(err),
-				mutating: true
-			};
-		}
-	});
+//#region src/runtime/attachment-paths.ts
+/** Mirrors core `IN_MEMORY_ROOT_NAME` without importing the filesys graph. */
+var IN_MEMORY_ROOT_NAME$1 = "in-memory";
+/** URI scheme for UI references (`in-memory://<sessionId>/<file>`). */
+var IN_MEMORY_URI_SCHEME = "in-memory://";
+/** Sanitize a single path segment (no slashes). Prefer id-prefixed names for uniqueness. */
+function safeAttachmentFileName(name, id) {
+	return `${id}-${(name || "attachment").replace(/[/\\]/g, "_").trim() || "attachment"}`;
+}
+/** Workspace path used by workspace_* tools (no protocol). */
+function attachmentWorkspacePath(sessionId, stored) {
+	return `${IN_MEMORY_ROOT_NAME$1}/${sessionId}/${safeAttachmentFileName(stored.name, stored.id)}`;
+}
+/** UI / catalog URI form (`in-memory://<sessionId>/<file>`). */
+function attachmentUri(sessionId, stored) {
+	return `${IN_MEMORY_URI_SCHEME}${sessionId}/${safeAttachmentFileName(stored.name, stored.id)}`;
 }
-//#endregion
-//#region src/runtime/tools/command-adapter.ts
-var SKIP = /* @__PURE__ */ new Set(["open_cognitive_ai_settings", "open_ai_config"]);
-/** Built-in tools that must survive command refresh (not command-backed). */
-var KEEP_TOOLS = /* @__PURE__ */ new Set([
-	"workspace_list",
-	"workspace_read",
-	"workspace_write",
-	"attachment_list",
-	"attachment_read"
-]);
-function sanitizeName(id) {
-	return id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
-}
-/** Registers Docks commands as first-class LLM tools (tool name = command id). */
-function refreshCommandTools(broker, role) {
-	for (const def of broker.listDefinitions("build")) if (!KEEP_TOOLS.has(def.name)) broker.unregister(def.name);
-	const commands = commandRegistry.listCommands(commandRegistry.createExecutionContext());
-	const entries = Object.values(commands);
-	for (const command of entries) {
-		if (!command?.id || SKIP.has(command.id)) continue;
-		if (!command.description) continue;
-		if ((role === "plan" || role === "explore") && /delete|write|save|rm|mv/i.test(command.id)) continue;
-		const toolName = sanitizeName(command.id);
-		if (KEEP_TOOLS.has(toolName)) continue;
-		const properties = {};
-		const required = [];
-		for (const p of command.parameters ?? []) {
-			properties[p.name] = {
-				type: p.type ?? "string",
-				description: p.description,
-				...p.allowedValues ? { enum: p.allowedValues } : {}
-			};
-			if (p.required) required.push(p.name);
-		}
-		broker.register({
-			name: toolName,
-			description: `${command.name}: ${command.description}`,
-			parameters: {
-				type: "object",
-				properties,
-				required
-			}
-		}, async (call, _sessionId) => {
-			try {
-				const result = await commandRegistry.execute(command.id, { params: call.arguments });
-				return {
-					id: call.id,
-					name: call.name,
-					ok: true,
-					output: result
-				};
-			} catch (err) {
-				return {
-					id: call.id,
-					name: call.name,
-					ok: false,
-					output: null,
-					error: err instanceof Error ? err.message : String(err)
-				};
-			}
-		});
+/**
+* Map `in-memory://…` references to composite workspace paths.
+* Real workspace paths are returned unchanged.
+*/
+function toWorkspaceToolPath(path) {
+	const trimmed = path.trim();
+	const lower = trimmed.toLowerCase();
+	if (lower === "in-memory:" || lower === "in-memory://" || lower === "in-memory") return IN_MEMORY_ROOT_NAME$1;
+	if (lower.startsWith("in-memory://")) {
+		const rest = trimmed.slice(12).replace(/^\/+/, "");
+		return rest ? `${IN_MEMORY_ROOT_NAME$1}/${rest}` : IN_MEMORY_ROOT_NAME$1;
 	}
+	return trimmed;
 }
 //#endregion
 //#region src/runtime/attachments.ts
-/** Soft cap per attached text file when stored / returned by attachment_read. */
+/** Soft cap per attached text file when stored / returned via workspace_read. */
 var MAX_ATTACHMENT_CHARS = 1e5;
 /** Soft cap for visual media attachments (bytes). */
 var MAX_IMAGE_BYTES = 4e6;
@@ -1384,7 +1226,7 @@ function toSessionAttachment(attachment, opts = {}) {
 		messageId: opts.messageId
 	};
 }
-/** Lightweight history/UI reference — no payload. */
+/** Lightweight history/UI reference — no payload (path is an in-memory workspace path/URI). */
 function toFileRefPart(stored) {
 	return {
 		type: "file",
@@ -1398,14 +1240,15 @@ function toFileRefPart(stored) {
 }
 /** One-line catalog entry published into the user turn for the model. */
 function formatAttachmentRefForModel(part) {
-	const label = part.path?.trim() || part.name;
+	const display = part.path || part.name;
+	const toolPath = toWorkspaceToolPath(display);
 	const kind = part.kind ?? "file";
 	const bytes = part.byteLength != null ? ` bytes=${part.byteLength}` : "";
-	return `[Attachment published: id=${part.id} name="${label}" kind=${kind}${part.mime ? ` mime=${part.mime}` : ""}${bytes}] → use attachment_read with id="${part.id}"`;
+	return `[Attachment published: ${display} kind=${kind}${part.mime ? ` mime=${part.mime}` : ""}${bytes}] → workspace_read path="${toolPath}"`;
 }
 /**
 * Build provider user content from history parts.
-* File parts are references only — payloads stay in the session store.
+* File parts are references only — payloads live under the in-memory workspace root.
 */
 function userContentFromParts(parts) {
 	const texts = [];
@@ -1416,71 +1259,10 @@ function userContentFromParts(parts) {
 	}
 	const body = [...texts, ...refs].join("\n").trim();
 	if (!refs.length) return body;
-	return [body, "Attachments live in this session store only. Call attachment_read (or attachment_list) before answering about them. Do not use canvas/workspace/editor commands to locate attachments."].filter(Boolean).join("\n");
-}
-function attachmentMeta(stored) {
-	return {
-		id: stored.id,
-		name: stored.name,
-		path: stored.path,
-		mime: stored.mime,
-		kind: stored.kind,
-		byteLength: stored.byteLength,
-		truncated: stored.truncated
-	};
-}
-function readTextAttachment(stored, opts = {}) {
-	if (stored.kind !== "text" && !(stored.kind === "image" && stored.text)) return {
-		ok: false,
-		error: `${stored.name} is not a text attachment`
-	};
-	const full = stored.text ?? "";
-	const offset = Math.max(0, opts.offset ?? 0);
-	const limit = Math.max(1, opts.limit ?? 4e4);
-	const slice = full.slice(offset, offset + limit);
-	return {
-		ok: true,
-		output: {
-			...attachmentMeta(stored),
-			offset,
-			length: slice.length,
-			totalLength: full.length,
-			truncated: offset + slice.length < full.length,
-			content: slice
-		}
-	};
+	return [body, "Session attachments are files under the in-memory workspace root. List with workspace_list, read with workspace_read. Do not connect storage backends to find them."].filter(Boolean).join("\n");
 }
 /** Marker field: specialist loop presents image bytes in a follow-up multimodal message. */
 var IMAGE_PRESENT_KEY = "_presentImage";
-function readImageAttachment(stored, opts = {}) {
-	if (stored.kind !== "image") return {
-		ok: false,
-		error: `${stored.name} is not an image attachment`
-	};
-	if (stored.text != null && isSvgAttachment(stored)) return readTextAttachment(stored, opts);
-	if (!stored.dataUrl) return {
-		ok: false,
-		error: `${stored.name} has no image payload`
-	};
-	const present = resolveMediaType({
-		name: stored.name,
-		mime: stored.mime
-	})?.vision !== false;
-	return {
-		ok: true,
-		output: {
-			...attachmentMeta(stored),
-			...present ? {
-				[IMAGE_PRESENT_KEY]: true,
-				dataUrl: stored.dataUrl,
-				note: "Image bytes will be provided to the model in the next message for vision inspection."
-			} : {
-				dataUrlOmitted: true,
-				note: "This media type is stored for preview; vision presentation is skipped. Ask for a raster export if needed."
-			}
-		}
-	};
-}
 function stripAttachmentToolOutput(output) {
 	if (!output || typeof output !== "object") return output;
 	const copy = { ...output };
@@ -1611,105 +1393,451 @@ async function readPromptAttachmentFromFile(file) {
 	};
 }
 //#endregion
-//#region src/runtime/tools/attachment-adapter.ts
-/** Registers read-only session attachment tools. */
-function registerAttachmentTools(broker, lookup) {
+//#region src/runtime/tools/workspace-path-qualify.ts
+function isInMemoryToolPath(path) {
+	return path === "in-memory" || path.startsWith(`in-memory/`);
+}
+function isWorkspaceRootPath(path) {
+	const trimmed = path.trim();
+	return !trimmed || trimmed === "." || trimmed === "/";
+}
+/** First path segment — composite roots are keyed by this name. */
+function firstPathSegment(path) {
+	return path.split("/").filter(Boolean)[0] ?? "";
+}
+function pathHasKnownRoot(path, rootNames) {
+	const first = firstPathSegment(path);
+	if (!first) return false;
+	return (rootNames instanceof Set ? rootNames : new Set(rootNames)).has(first);
+}
+function joinUnderRoot(rootPath, relativePath) {
+	const root = rootPath.replace(/\/+$/, "");
+	const relative = relativePath.replace(/^\/+/, "");
+	if (!root) return relative;
+	if (!relative) return root;
+	return `${root}/${relative}`;
+}
+/**
+* Decide how to qualify a workspace tool path that is missing a connected-root prefix.
+*/
+function decideRootQualification(path, durableRoots, mode) {
+	if (isInMemoryToolPath(path) || isWorkspaceRootPath(path)) return { action: "keep" };
+	if (pathHasKnownRoot(path, durableRoots)) return { action: "keep" };
+	if (durableRoots.length === 1) return {
+		action: "prefix",
+		root: durableRoots[0]
+	};
+	if (durableRoots.length === 0) return {
+		action: "error",
+		error: mode === "write" ? "No durable workspace folder connected. Connect a folder before writing, or use an in-memory/… path." : "No workspace folder connected."
+	};
+	if (mode === "write") return { action: "pick" };
+	return {
+		action: "error",
+		error: `Path must start with a workspace root (${durableRoots.join(", ")}). Example: ${durableRoots[0]}/${path}`
+	};
+}
+//#endregion
+//#region src/runtime/tools/workspace-path.ts
+/**
+* Ensure tool paths are under a composite workspace root.
+* - Already rooted / in-memory / empty → unchanged
+* - One durable root → auto-prefix
+* - Several durable roots (writes) → folder picker dialog
+*/
+async function qualifyWorkspaceToolPath(rawPath, mode = "write") {
+	const path = toWorkspaceToolPath(String(rawPath ?? ""));
+	if (isInMemoryToolPath(path) || isWorkspaceRootPath(path)) return {
+		ok: true,
+		path
+	};
+	const folders = await workspaceService.getFolders();
+	const allNames = folders.map((f) => f.name);
+	if (pathHasKnownRoot(path, allNames)) return {
+		ok: true,
+		path
+	};
+	const durableRoots = folders.filter((f) => f.type !== "in-memory").map((f) => f.name);
+	const decision = decideRootQualification(path, mode === "write" ? durableRoots : allNames.length ? allNames : durableRoots, mode);
+	if (decision.action === "keep") return {
+		ok: true,
+		path
+	};
+	if (decision.action === "prefix") return {
+		ok: true,
+		path: joinUnderRoot(decision.root, path),
+		resolvedFrom: path
+	};
+	if (decision.action === "error") return {
+		ok: false,
+		error: decision.error
+	};
+	const chosen = await filebrowserDialog("directory");
+	if (!chosen) return {
+		ok: false,
+		error: "Write cancelled: no workspace folder selected."
+	};
+	return {
+		ok: true,
+		path: joinUnderRoot(chosen, path),
+		resolvedFrom: path
+	};
+}
+//#endregion
+//#region src/runtime/tools/workspace-adapter.ts
+function asRecord(value) {
+	return value && typeof value === "object" ? value : {};
+}
+/** Some File backends (e.g. in-memory) expose mime; the abstract File does not. */
+function optionalMimeType(resource) {
+	const getMimeType = resource.getMimeType;
+	return typeof getMimeType === "function" ? getMimeType.call(resource) : void 0;
+}
+function fileNameFromPath(path) {
+	const parts = path.split("/").filter(Boolean);
+	return parts[parts.length - 1] || path;
+}
+/** Resolve a tool path against the shared in-memory root or the mounted workspace. */
+async function resolveResource(path, options) {
+	if (isInMemoryToolPath(path)) {
+		const root = getInMemoryRoot();
+		const relative = path === IN_MEMORY_ROOT_NAME ? "" : path.slice(`${IN_MEMORY_ROOT_NAME}/`.length);
+		if (!relative) return {
+			resource: root,
+			path: IN_MEMORY_ROOT_NAME
+		};
+		const lookup = options?.directory && !relative.endsWith("/") ? `${relative}/` : relative;
+		return {
+			resource: await root.getResource(lookup, options?.create ? { create: true } : void 0),
+			path
+		};
+	}
+	const workspace = await workspaceService.getWorkspace();
+	if (!workspace) return {
+		resource: null,
+		path
+	};
+	if (isWorkspaceRootPath(path)) return {
+		resource: workspace,
+		path: ""
+	};
+	const lookup = options?.directory && !path.endsWith("/") ? `${path}/` : path;
+	return {
+		resource: await workspace.getResource(lookup, options?.create ? { create: true } : void 0),
+		path
+	};
+}
+/**
+* Present image-like workspace files for vision (data URLs or known image extensions).
+* Returns null when the file should be treated as ordinary text.
+*/
+function visionToolOutput(path, contents, mimeHint) {
+	const name = fileNameFromPath(path);
+	const dataUrl = typeof contents === "string" && contents.startsWith("data:image/") ? contents : void 0;
+	const mime = mimeHint || (dataUrl ? dataUrl.slice(5, dataUrl.indexOf(";")) : void 0) || resolveMediaType({
+		name,
+		mime: mimeHint
+	})?.mime;
+	if (isSvgAttachment({
+		name,
+		mime,
+		text: dataUrl ? void 0 : contents
+	})) return null;
+	const media = resolveMediaType({
+		name,
+		mime
+	});
+	if (!dataUrl && media?.mode !== "raster") return null;
+	if (!dataUrl) return null;
+	return {
+		path,
+		name,
+		mime,
+		kind: "image",
+		...media?.vision !== false ? {
+			[IMAGE_PRESENT_KEY]: true,
+			dataUrl,
+			note: "Image bytes will be provided to the model in the next message for vision inspection."
+		} : {
+			dataUrlOmitted: true,
+			note: "This media type is stored for preview; vision presentation is skipped."
+		}
+	};
+}
+/** Registers built-in workspace file tools (paths may use in-memory:// URI form). */
+function registerWorkspaceTools(broker) {
 	broker.register({
-		name: "attachment_list",
-		description: "List chat-session attachments (id, name, kind, mime, size). Use this for files the user attached in chat — not workspace/canvas files. Payloads are omitted; call attachment_read to inspect one.",
+		name: "workspace_list",
+		description: "List children of a workspace directory. Omit path (or use \"\" / \"/\") for connected roots (use those path prefixes for writes). in-memory/… works without mounting.",
 		parameters: {
 			type: "object",
-			properties: {}
+			properties: { path: {
+				type: "string",
+				description: "Directory path under a connected root (empty = list roots). in-memory://… URIs are accepted."
+			} },
+			required: []
+		}
+	}, async (call) => {
+		try {
+			const path = toWorkspaceToolPath(String(call.arguments.path ?? ""));
+			const { resource } = await resolveResource(path, { directory: true });
+			if (!(resource instanceof Directory)) return {
+				id: call.id,
+				name: call.name,
+				ok: false,
+				output: null,
+				error: isInMemoryToolPath(path) ? "Not a directory" : "No workspace / not a directory"
+			};
+			const children = await resource.listChildren(true);
+			return {
+				id: call.id,
+				name: call.name,
+				ok: true,
+				output: children.map((c) => ({
+					name: c.getName(),
+					path: c.getWorkspacePath(),
+					kind: c instanceof Directory ? "directory" : "file"
+				}))
+			};
+		} catch (err) {
+			return {
+				id: call.id,
+				name: call.name,
+				ok: false,
+				output: null,
+				error: err instanceof Error ? err.message : String(err)
+			};
 		}
-	}, async (call, sessionId) => {
-		const items = lookup(sessionId).map(attachmentMeta);
-		return {
-			id: call.id,
-			name: call.name,
-			ok: true,
-			output: {
-				count: items.length,
-				attachments: items
-			}
-		};
 	});
 	broker.register({
-		name: "attachment_read",
-		description: "Inspect a chat-session attachment by id from the user message or attachment_list. Prefer this whenever the user asks about an attached screenshot/file. Text returns content (optional offset/limit). Images are presented for vision inspection.",
+		name: "workspace_read",
+		description: "Read a workspace file as text. Paths should be root/… from workspace_list; a bare name is auto-rooted when only one folder is connected. Image data-URL files are presented for vision.",
 		parameters: {
 			type: "object",
 			properties: {
-				id: {
+				path: {
 					type: "string",
-					description: "Attachment id from attachment_list or the user message"
+					description: "File path under a connected root (e.g. tests/readme.md)."
 				},
 				offset: {
 					type: "number",
-					description: "Text start offset (characters)"
+					description: "Text start offset"
 				},
 				limit: {
 					type: "number",
 					description: "Max text characters to return"
 				}
 			},
-			required: ["id"]
+			required: ["path"]
 		}
-	}, async (call, sessionId) => {
-		const id = String(call.arguments.id ?? "").trim();
-		if (!id) return {
-			id: call.id,
-			name: call.name,
-			ok: false,
-			output: null,
-			error: "id is required"
-		};
-		const stored = lookup(sessionId, id)[0];
-		if (!stored) return {
-			id: call.id,
-			name: call.name,
-			ok: false,
-			output: null,
-			error: `Unknown attachment: ${id}`
-		};
-		if (stored.kind === "image") {
-			const result = readImageAttachment(stored, {
-				offset: typeof call.arguments.offset === "number" ? call.arguments.offset : void 0,
-				limit: typeof call.arguments.limit === "number" ? call.arguments.limit : void 0
-			});
-			if (!result.ok) return {
+	}, async (call) => {
+		try {
+			const qualified = await qualifyWorkspaceToolPath(String(call.arguments.path ?? ""), "read");
+			if (!qualified.ok) return {
 				id: call.id,
 				name: call.name,
 				ok: false,
 				output: null,
-				error: result.error
+				error: qualified.error
 			};
+			const path = qualified.path;
+			const { resource } = await resolveResource(path);
+			if (!(resource instanceof File)) return {
+				id: call.id,
+				name: call.name,
+				ok: false,
+				output: null,
+				error: isInMemoryToolPath(path) ? "Not a file" : "No workspace / not a file"
+			};
+			const contents = await resource.getContents();
+			const text = typeof contents === "string" ? contents : String(contents ?? "");
+			const vision = visionToolOutput(path, text, optionalMimeType(resource));
+			if (vision) return {
+				id: call.id,
+				name: call.name,
+				ok: true,
+				output: vision
+			};
+			const offset = typeof call.arguments.offset === "number" ? Math.max(0, call.arguments.offset) : 0;
+			const limit = typeof call.arguments.limit === "number" ? Math.max(1, call.arguments.limit) : void 0;
+			if (offset || limit != null) {
+				const slice = text.slice(offset, limit != null ? offset + limit : void 0);
+				return {
+					id: call.id,
+					name: call.name,
+					ok: true,
+					output: {
+						path,
+						offset,
+						length: slice.length,
+						totalLength: text.length,
+						truncated: offset + slice.length < text.length,
+						content: slice
+					}
+				};
+			}
 			return {
 				id: call.id,
 				name: call.name,
 				ok: true,
-				output: result.output
+				output: text
+			};
+		} catch (err) {
+			return {
+				id: call.id,
+				name: call.name,
+				ok: false,
+				output: null,
+				error: err instanceof Error ? err.message : String(err)
+			};
+		}
+	});
+	broker.register({
+		name: "workspace_write",
+		description: "Write text to a workspace file (creates parents as needed). Prefer root/… paths from workspace_list. A bare filename uses the only durable root, or opens a folder picker when several roots are connected.",
+		parameters: {
+			type: "object",
+			properties: {
+				path: {
+					type: "string",
+					description: "File path under a connected root (e.g. tests/demo.canvas.js)."
+				},
+				contents: { type: "string" }
+			},
+			required: ["path", "contents"]
+		}
+	}, async (call) => {
+		try {
+			const args = asRecord(call.arguments);
+			const qualified = await qualifyWorkspaceToolPath(String(args.path ?? ""), "write");
+			if (!qualified.ok) return {
+				id: call.id,
+				name: call.name,
+				ok: false,
+				output: null,
+				error: qualified.error,
+				mutating: true
+			};
+			const path = qualified.path;
+			const contents = String(args.contents ?? "");
+			const { resource } = await resolveResource(path, { create: true });
+			if (!(resource instanceof File)) return {
+				id: call.id,
+				name: call.name,
+				ok: false,
+				output: null,
+				error: isInMemoryToolPath(path) ? "Not a file" : "No workspace / not a file",
+				mutating: true
+			};
+			await resource.saveContents(contents);
+			return {
+				id: call.id,
+				name: call.name,
+				ok: true,
+				output: {
+					path,
+					...qualified.resolvedFrom ? { resolvedFrom: qualified.resolvedFrom } : {}
+				},
+				mutating: true
+			};
+		} catch (err) {
+			return {
+				id: call.id,
+				name: call.name,
+				ok: false,
+				output: null,
+				error: err instanceof Error ? err.message : String(err),
+				mutating: true
 			};
 		}
-		const result = readTextAttachment(stored, {
-			offset: typeof call.arguments.offset === "number" ? call.arguments.offset : void 0,
-			limit: typeof call.arguments.limit === "number" ? call.arguments.limit : void 0
-		});
-		if (!result.ok) return {
-			id: call.id,
-			name: call.name,
-			ok: false,
-			output: null,
-			error: result.error
-		};
-		return {
-			id: call.id,
-			name: call.name,
-			ok: true,
-			output: result.output
-		};
 	});
 }
 //#endregion
+//#region src/runtime/tools/command-adapter.ts
+/** Commands that must never be exposed as LLM tools (pickers, storage boots, settings). */
+var SKIP = /* @__PURE__ */ new Set([
+	"open_cognitive_ai_settings",
+	"open_ai_config",
+	"load_workspace",
+	"connect_opfs",
+	"connect_indexeddb",
+	"disconnect_workspace",
+	"disconnect_folder",
+	"open_editor",
+	"list_extensions",
+	"enable_extension",
+	"disable_extension"
+]);
+var SKIP_PREFIXES = [
+	"connect_",
+	"disconnect_",
+	"install_",
+	"uninstall_"
+];
+/** Built-in tools that must survive command refresh (not command-backed). */
+var KEEP_TOOLS = /* @__PURE__ */ new Set([
+	"workspace_list",
+	"workspace_read",
+	"workspace_write"
+]);
+function sanitizeName(id) {
+	return id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
+}
+function shouldSkipCommand(id) {
+	if (SKIP.has(id)) return true;
+	return SKIP_PREFIXES.some((prefix) => id.startsWith(prefix));
+}
+/** Registers Docks commands as first-class LLM tools (tool name = command id). */
+function refreshCommandTools(broker, role) {
+	for (const def of broker.listDefinitions("build")) if (!KEEP_TOOLS.has(def.name)) broker.unregister(def.name);
+	const commands = commandRegistry.listCommands(commandRegistry.createExecutionContext());
+	const entries = Object.values(commands);
+	for (const command of entries) {
+		if (!command?.id || shouldSkipCommand(command.id)) continue;
+		if (!command.description) continue;
+		if ((role === "plan" || role === "explore") && /delete|write|save|rm|mv/i.test(command.id)) continue;
+		const toolName = sanitizeName(command.id);
+		if (KEEP_TOOLS.has(toolName)) continue;
+		const properties = {};
+		const required = [];
+		for (const p of command.parameters ?? []) {
+			properties[p.name] = {
+				type: p.type ?? "string",
+				description: p.description,
+				...p.allowedValues ? { enum: p.allowedValues } : {}
+			};
+			if (p.required) required.push(p.name);
+		}
+		broker.register({
+			name: toolName,
+			description: `${command.name}: ${command.description}`,
+			parameters: {
+				type: "object",
+				properties,
+				required
+			}
+		}, async (call, _sessionId) => {
+			try {
+				const result = await commandRegistry.execute(command.id, { params: call.arguments });
+				return {
+					id: call.id,
+					name: call.name,
+					ok: true,
+					output: result
+				};
+			} catch (err) {
+				return {
+					id: call.id,
+					name: call.name,
+					ok: false,
+					output: null,
+					error: err instanceof Error ? err.message : String(err)
+				};
+			}
+		});
+	}
+}
+//#endregion
 //#region src/runtime/compact/compaction.ts
 var COMPACT_SYSTEM = `You compress older chat turns into a durable summary for future assistant turns.
 Preserve: user goals, decisions, constraints, important file/paths, tool outcomes that still matter, and open questions.
@@ -2163,7 +2291,21 @@ async function runSpecialistLoop(input) {
 	};
 	const messages = historyToProviderMessages(input.systemPrompt, input.history, input.compactionSummary);
 	let success = true;
+	let cancelled = false;
+	const markCancelled = () => {
+		if (cancelled) return;
+		cancelled = true;
+		success = false;
+		if (!parts.some((p) => p.type === "text")) emit({
+			type: "text",
+			text: "Cancelled."
+		});
+	};
 	for (let iter = 0; iter < MAX_TOOL_ITERATIONS; iter++) {
+		if (isAborted(input.signal)) {
+			markCancelled();
+			break;
+		}
 		input.refreshTools?.();
 		const tools = input.broker.listDefinitions(input.role);
 		let pendingTools = [];
@@ -2175,6 +2317,7 @@ async function runSpecialistLoop(input) {
 			providerOptions: input.resolved.providerOptions,
 			signal: input.signal
 		})) {
+			if (isAborted(input.signal)) break;
 			if (chunk.type === "error") {
 				emit({
 					type: "text",
@@ -2203,6 +2346,10 @@ async function runSpecialistLoop(input) {
 				} else pendingTools.push({ ...chunk.toolCall });
 			}
 		}
+		if (isAborted(input.signal)) {
+			markCancelled();
+			break;
+		}
 		if (!pendingTools.length) {
 			if (assistantText && !parts.some((p) => p.type === "text")) emit({
 				type: "text",
@@ -2229,7 +2376,12 @@ async function runSpecialistLoop(input) {
 			})),
 			signal: input.signal
 		}) : null;
+		const pendingImages = [];
 		for (const tool of pendingTools) {
+			if (isAborted(input.signal)) {
+				markCancelled();
+				break;
+			}
 			let args = {};
 			try {
 				args = tool.arguments ? JSON.parse(tool.arguments) : {};
@@ -2267,26 +2419,30 @@ async function runSpecialistLoop(input) {
 				name: tool.name,
 				content: JSON.stringify(presentImage ? {
 					...safeOutput ?? {},
-					note: "Image bytes follow in the next user message for vision inspection."
+					note: "Image bytes follow after all tool results for vision inspection."
 				} : safeOutput)
 			});
-			if (presentImage) {
-				const dataUrl = String(rawOutput.dataUrl);
-				const name = String(rawOutput.name ?? "image");
-				const id = String(rawOutput.id ?? "");
-				messages.push({
-					role: "user",
-					content: [{
-						type: "text",
-						text: `Attachment image for inspection: id=${id} name="${name}"`
-					}, {
-						type: "image_url",
-						image_url: { url: dataUrl }
-					}]
-				});
-			}
+			if (presentImage) pendingImages.push({
+				id: String(rawOutput.id ?? ""),
+				name: String(rawOutput.name ?? "image"),
+				dataUrl: String(rawOutput.dataUrl)
+			});
 			if (!result.ok) success = false;
 		}
+		if (cancelled || isAborted(input.signal)) {
+			markCancelled();
+			break;
+		}
+		if (pendingImages.length) messages.push({
+			role: "user",
+			content: [{
+				type: "text",
+				text: pendingImages.length === 1 ? `Attachment image for inspection: id=${pendingImages[0].id} name="${pendingImages[0].name}"` : `Attachment images for inspection:\n${pendingImages.map((img) => `- id=${img.id} name="${img.name}"`).join("\n")}`
+			}, ...pendingImages.map((img) => ({
+				type: "image_url",
+				image_url: { url: img.dataUrl }
+			}))]
+		});
 	}
 	return {
 		message: {
@@ -2325,7 +2481,14 @@ function coalesceParts(parts) {
 //#endregion
 //#region src/runtime/specialists/index.ts
 function systemPromptFor(role, goal, opts = {}) {
-	const preamble = `You are a specialist in the Eclipse Docks AI runtime. Prefer tools for file and command actions. Be concise. ${opts.hasAttachments ? "This turn publishes session attachments. To inspect them, call attachment_read with the attachment id from the user message (attachment_list if you need ids). Do not open canvases, editors, workspaces, or unrelated commands to find attachment contents — they are not workspace files." : "When the user publishes attachments, use attachment_list / attachment_read to inspect them — do not assume their contents are already in the transcript."}`;
+	const preamble = `You are a specialist in the Eclipse Docks AI runtime. Prefer tools for file and command actions. Be concise. After tools finish, write a short human-friendly final reply (what you did and the outcome). Do not paste tool arguments, stdout, JSON, or command logs — those already appear in the UI details panel. ${opts.hasAttachments ? [
+		"This turn publishes session attachments under the shared in-memory root (in-memory/<sessionId>/… or in-memory://<sessionId>/…).",
+		"Read them with workspace_read / workspace_list — in-memory paths work without mounting that root into the workspace tree.",
+		"Do not call load_workspace / connect_opfs / connect_indexeddb to find attachments.",
+		"Canvas from a screenshot: workspace_read the attachment path → canvas.help → workspace_write a .canvas.js (into a durable workspace folder) → canvas.open / canvas.apply_source.",
+		"Qualify durable writes as <root>/<file> using a root from workspace_list (e.g. tests/demo.canvas.js); bare filenames are auto-rooted when a single durable folder is connected, otherwise a folder picker appears.",
+		"If no durable workspace folder is connected for writing canvases, say so and stop."
+	].join(" ") : "Session attachments live under the shared in-memory root and are readable via workspace_read / workspace_list."} Workspace paths use a connected root prefix from workspace_list (never write bare names at the composite root unless a single durable folder can auto-qualify them).`;
 	switch (role) {
 		case "plan": return `${preamble}\nMode: PLAN (read-only). Analyze and propose a plan for: ${goal}`;
 		case "explore": return `${preamble}\nMode: EXPLORE (read-only). Search and report findings for: ${goal}`;
@@ -2453,6 +2616,82 @@ function formatBucketDetail(bucket) {
 	return `${bucket.count} · ${tokens}`;
 }
 //#endregion
+//#region src/runtime/session-workspace.ts
+function attachmentContents(stored) {
+	if (stored.kind === "image") {
+		if (stored.dataUrl) return stored.dataUrl;
+		if (stored.text) return stored.text;
+	}
+	return stored.text ?? "";
+}
+/** Build live-file callbacks that always re-read via the caller-provided resolver. */
+function attachmentLiveContents(resolve) {
+	return {
+		get mimeType() {
+			return resolve()?.mime;
+		},
+		getContents() {
+			const stored = resolve();
+			if (!stored) throw new Error("Attachment payload is no longer available");
+			return attachmentContents(stored);
+		},
+		size() {
+			const stored = resolve();
+			if (!stored) return null;
+			if (stored.byteLength != null) return stored.byteLength;
+			return attachmentContents(stored).length;
+		}
+	};
+}
+/** Relative path under the shared in-memory root (`<sessionId>/<file>`). */
+function relativeAttachmentPath(sessionId, stored) {
+	return attachmentWorkspacePath(sessionId, stored).slice(`${IN_MEMORY_ROOT_NAME}/`.length);
+}
+/**
+* Publish a live file node. Payload is resolved only through `resolve` — nothing is copied.
+*/
+async function syncAttachmentToWorkspace(sessionId, stored, resolve) {
+	const root = getInMemoryRoot();
+	const relative = relativeAttachmentPath(sessionId, stored);
+	root.writeLiveFile(relative, attachmentLiveContents(resolve));
+	return attachmentWorkspacePath(sessionId, stored);
+}
+async function syncAttachmentsToWorkspace(sessionId, attachments, resolveById) {
+	for (const attachment of attachments) await syncAttachmentToWorkspace(sessionId, attachment, () => resolveById(attachment.id));
+}
+async function removeAttachmentFromWorkspace(sessionId, stored) {
+	const root = getInMemoryRoot();
+	const relative = relativeAttachmentPath(sessionId, stored);
+	const resource = await root.getResource(relative);
+	if (resource) await resource.delete();
+}
+async function removeSessionWorkspaceFolder(sessionId) {
+	const dir = await getInMemoryRoot().getResource(sessionId);
+	if (dir instanceof Directory) await dir.delete();
+}
+/**
+* Restrict the workspace-mounted in-memory view to a single folder name (active session).
+* Pass `null` to show the full tree again.
+*/
+function projectInMemoryMountToFolder(folderName) {
+	if (!folderName) {
+		setInMemoryMountProjection(null);
+		return;
+	}
+	const name = folderName;
+	setInMemoryMountProjection({
+		async listChildren(root) {
+			return [root.ensureDirectoryEntry(name)];
+		},
+		async getResource(root, path, options) {
+			const segments = path.split("/").filter((s) => s.trim());
+			if (segments[0] !== name) return null;
+			if (segments.length === 1 && (path.endsWith("/") || path === name)) return root.ensureDirectoryEntry(name);
+			return root.getResource(path, options);
+		}
+	});
+}
+//#endregion
 //#region src/runtime/cognitive-runtime.ts
 var PERSIST_KEY = "cognitive/v1/state";
 /** Auto-compact after a turn when live history exceeds this many messages. */
@@ -2487,12 +2726,6 @@ var CognitiveRuntime = class {
 			emit: false
 		});
 		registerWorkspaceTools(this.tools);
-		registerAttachmentTools(this.tools, (sessionId, attachmentId) => {
-			const list = this.sessions.get(sessionId)?.attachments ?? [];
-			if (!attachmentId) return list;
-			const found = list.find((a) => a.id === attachmentId);
-			return found ? [found] : [];
-		});
 		this.tools.setApprovalMode(this.approvalMode);
 		this.tools.setPermissionHandler(async (req) => this.requestPermission(req));
 		this.ready = this.hydrateAll();
@@ -2554,7 +2787,10 @@ var CognitiveRuntime = class {
 		return catalog.find((e) => e.providerId === this.providersSettings.defaultProviderId)?.id ?? catalog[0]?.id ?? "openai/gpt-4o-mini";
 	}
 	setModelPolicy(policy) {
-		this.policy = policy;
+		const next = normalizeModelPolicy(policy) ?? this.policy;
+		if (sameModelPolicy(this.policy, next)) return;
+		this.policy = next;
+		this.persist();
 	}
 	getModelPolicy() {
 		return this.policy;
@@ -2616,28 +2852,46 @@ var CognitiveRuntime = class {
 		if (focused) return focused.id;
 		return this.sessions.createSession().id;
 	}
-	/** Store attachment payloads on the session (not inlined into history until prompt). */
-	addAttachments(sessionId, attachments) {
+	/** Store attachment payloads on the session and mirror them into in-memory/<sessionId>/. */
+	async addAttachments(sessionId, attachments) {
 		const id = this.ensureSessionId(sessionId);
 		const session = this.sessions.get(id);
 		if (!session || !attachments.length) return [];
 		const room = Math.max(0, 8 - (session.attachments?.length ?? 0));
-		const accepted = attachments.slice(0, room).map((attachment) => toSessionAttachment(attachment));
+		const accepted = attachments.slice(0, room).map((attachment) => {
+			const stored = toSessionAttachment(attachment);
+			return {
+				...stored,
+				path: attachmentUri(id, stored)
+			};
+		});
 		if (!accepted.length) return [];
 		this.sessions.update(id, { attachments: [...session.attachments ?? [], ...accepted] });
 		this.commitSessions();
+		await this.mirrorAttachments(id, accepted).catch(() => void 0);
 		return accepted;
 	}
-	/** Remove an attachment payload from the session store. */
+	/** Remove an attachment payload from the session store and in-memory workspace. */
 	removeAttachment(sessionId, attachmentId) {
 		const session = this.sessions.get(sessionId);
 		if (!session) return false;
+		const removed = (session.attachments ?? []).find((a) => a.id === attachmentId);
 		const next = (session.attachments ?? []).filter((a) => a.id !== attachmentId);
 		if (next.length === (session.attachments?.length ?? 0)) return false;
 		this.sessions.update(sessionId, { attachments: next });
 		this.commitSessions();
+		if (removed) removeAttachmentFromWorkspace(sessionId, removed);
 		return true;
 	}
+	/** Drop a session and its in-memory attachment folder. */
+	removeSession(sessionId) {
+		const ok = this.sessions.remove(sessionId);
+		if (ok) {
+			removeSessionWorkspaceFolder(sessionId);
+			this.commitSessions();
+		}
+		return ok;
+	}
 	/**
 	* Compact a session: drop older turns, store a summary (LLM when possible),
 	* and persist. The summary is injected into later model calls.
@@ -2681,8 +2935,17 @@ var CognitiveRuntime = class {
 		const session = (input.sessionId ? this.sessions.get(input.sessionId) : this.sessions.focused()) ?? this.sessions.createSession();
 		const text = input.text.trim();
 		const messageId = `msg-${Date.now()}-u`;
-		const fresh = (input.attachments ?? []).slice(0, 8).map((attachment) => toSessionAttachment(attachment, { messageId }));
-		if (fresh.length) this.sessions.update(session.id, { attachments: [...this.sessions.get(session.id)?.attachments ?? [], ...fresh] });
+		const fresh = (input.attachments ?? []).slice(0, 8).map((attachment) => {
+			const stored = toSessionAttachment(attachment, { messageId });
+			return {
+				...stored,
+				path: attachmentUri(session.id, stored)
+			};
+		});
+		if (fresh.length) {
+			this.sessions.update(session.id, { attachments: [...this.sessions.get(session.id)?.attachments ?? [], ...fresh] });
+			await this.mirrorAttachments(session.id, fresh);
+		}
 		const existingIds = (input.attachmentIds ?? []).filter(Boolean);
 		const stored = this.sessions.get(session.id)?.attachments ?? [];
 		const byId = new Map(stored.map((a) => [a.id, a]));
@@ -2693,12 +2956,16 @@ var CognitiveRuntime = class {
 			if (found && !published.some((p) => p.id === found.id)) published.push(found);
 		}
 		if (!text && !published.length) throw new Error("Prompt requires text or at least one attachment");
+		if (published.length) await this.mirrorAttachments(session.id, published).catch(() => void 0);
 		const parts = [];
 		if (text) parts.push({
 			type: "text",
 			text
 		});
-		for (const item of published) parts.push(toFileRefPart(item));
+		for (const item of published) parts.push(toFileRefPart({
+			...item,
+			path: item.path || attachmentUri(session.id, item)
+		}));
 		const promptSummary = summarizePrompt(text, published.map((a) => ({
 			name: a.name,
 			kind: a.kind
@@ -2802,7 +3069,7 @@ var CognitiveRuntime = class {
 			sessionId: session.id,
 			activation: .7
 		});
-		if ((this.sessions.get(session.id)?.history.length ?? 0) > AUTO_COMPACT_AFTER) await this.compactSession(session.id, COMPACT_KEEP_COUNT, input.signal);
+		if (!Boolean(input.signal?.aborted) && (this.sessions.get(session.id)?.history.length ?? 0) > AUTO_COMPACT_AFTER) await this.compactSession(session.id, COMPACT_KEEP_COUNT, input.signal);
 		this.sessions.update(session.id, { status: "idle" });
 		this.events.publish(TOPIC.messageDone, {
 			sessionId: session.id,
@@ -2863,11 +3130,17 @@ var CognitiveRuntime = class {
 		});
 	}
 	emitSessions() {
+		const focusedId = this.sessions.focused()?.id ?? null;
+		projectInMemoryMountToFolder(focusedId);
 		this.events.publish(TOPIC.sessionChanged, {
 			sessions: this.sessions.list(),
-			focusedId: this.sessions.focused()?.id ?? null
+			focusedId
 		});
 	}
+	/** Live in-memory file refs that resolve payloads from the session store. */
+	mirrorAttachments(sessionId, attachments) {
+		return syncAttachmentsToWorkspace(sessionId, attachments, (attachmentId) => this.sessions.get(sessionId)?.attachments?.find((a) => a.id === attachmentId));
+	}
 	async hydrateAll() {
 		await loadModelsCatalog().catch(() => void 0);
 		await this.hydrateProviders();
@@ -2879,6 +3152,16 @@ var CognitiveRuntime = class {
 		if (!this.sessions.list().length) this.sessions.createSession({ title: "Chat" });
 		const mostRecent = this.sessions.list()[0];
 		if (mostRecent) this.sessions.focus(mostRecent.id);
+		for (const session of this.sessions.list()) {
+			const list = session.attachments ?? [];
+			if (!list.length) continue;
+			const stamped = list.map((a) => a.path ? a : {
+				...a,
+				path: attachmentUri(session.id, a)
+			});
+			if (stamped.some((a, i) => a.path !== list[i]?.path)) this.sessions.update(session.id, { attachments: stamped });
+			await this.mirrorAttachments(session.id, stamped).catch(() => void 0);
+		}
 		this.emitSessions();
 	}
 	async hydrateProviders() {
@@ -2906,6 +3189,8 @@ var CognitiveRuntime = class {
 				this.approvalMode = saved.approvalMode;
 				this.tools.setApprovalMode(saved.approvalMode);
 			}
+			const policy = normalizeModelPolicy(saved.modelPolicy);
+			if (policy) this.policy = policy;
 		} catch {}
 	}
 	async persist() {
@@ -2913,7 +3198,8 @@ var CognitiveRuntime = class {
 			await persistenceService.persistObject(PERSIST_KEY, {
 				sessions: this.sessions.snapshot(),
 				memory: this.memory.snapshot(),
-				approvalMode: this.approvalMode
+				approvalMode: this.approvalMode,
+				modelPolicy: this.policy
 			});
 		} catch {}
 	}
@@ -2921,6 +3207,32 @@ var CognitiveRuntime = class {
 function isToolApprovalMode(value) {
 	return value === "manual" || value === "auto_safe" || value === "auto_all";
 }
+function isOptimizeFor(value) {
+	return value === "cost" || value === "balance" || value === "intelligence";
+}
+function isEffortOrAuto(value) {
+	return value === "auto" || value === "none" || value === "minimal" || value === "low" || value === "medium" || value === "high" || value === "xhigh" || value === "max";
+}
+function normalizeModelPolicy(value) {
+	if (!value || typeof value !== "object") return null;
+	const raw = value;
+	if (raw.mode === "auto" && isOptimizeFor(raw.optimizeFor)) return {
+		mode: "auto",
+		optimizeFor: raw.optimizeFor
+	};
+	if (raw.mode === "manual" && typeof raw.model === "string" && raw.model.trim()) return {
+		mode: "manual",
+		model: raw.model.trim(),
+		...isEffortOrAuto(raw.effort) ? { effort: raw.effort } : {}
+	};
+	return null;
+}
+function sameModelPolicy(a, b) {
+	if (a.mode !== b.mode) return false;
+	if (a.mode === "auto" && b.mode === "auto") return a.optimizeFor === b.optimizeFor;
+	if (a.mode === "manual" && b.mode === "manual") return a.model === b.model && (a.effort ?? "auto") === (b.effort ?? "auto");
+	return false;
+}
 function externalCatalogEntry(id, providerId) {
 	return {
 		id,
@@ -2949,4 +3261,4 @@ function summarizePrompt(text, attachments) {
 //#endregion
 export { AI_SETTINGS_KEY as _, formatContextPercent as a, TOPIC as b, readPromptAttachmentFromFile as c, defaultProvidersSettings as d, listConfiguredModelIds as f, AI_SETTINGS_EDITOR_ID as g, loadModelsCatalog as h, formatBucketDetail as i, OpenAICompatibleProvider as l, detectEffortCapability as m, cognitiveRuntime as n, formatTokenCount as o, parseModelIds as p, estimateSessionContextUsage as r, ATTACHMENT_FILE_ACCEPT as s, CognitiveRuntime as t, fetchOpenAICompatibleModels as u, AI_VIEW_NAME as v, OPEN_AI_SETTINGS_COMMAND as y };
 
-//# sourceMappingURL=runtime-DfNGzEjU.js.map
+//# sourceMappingURL=runtime-By5PP2BC.js.map