@dxos/plugin-assistant 0.10.0 → 0.11.0

package/dist/lib/chunk-local-model-resolver.mjs

@@ -0,0 +1,25 @@
+import { AppCapabilities } from "@dxos/app-toolkit";
+import { Capability } from "@dxos/app-framework";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { LMStudioResolver, OllamaResolver } from "@dxos/ai/resolvers";
+import * as OpenAiClient from "@effect/ai-openai/OpenAiClient";
+import * as FetchHttpClient from "@effect/platform/FetchHttpClient";
+import * as HttpClient from "@effect/platform/HttpClient";
+//#region src/capabilities/local-model-resolver.ts
+/**
+* To start LM Studio server:
+* ```bash
+* ~/.lmstudio/bin/lms server start --cors
+* ```
+*
+* To start Ollama server:
+* ```bash
+* OLLAMA_ORIGINS="*" ollama serve
+* ```
+*/
+var localModelResolver = Capability.makeModule(() => Effect.succeed([Capability.contributes(AppCapabilities.AiModelResolver, LMStudioResolver.make().pipe(Layer.provide(OpenAiClient.layer({ apiUrl: LMStudioResolver.DEFAULT_LMSTUDIO_ENDPOINT })), Layer.provide(FetchHttpClient.layer))), Capability.contributes(AppCapabilities.AiModelResolver, OllamaResolver.make({ transformClient: HttpClient.withTracerPropagation(false) }).pipe(Layer.provide(FetchHttpClient.layer)))]));
+//#endregion
+export { localModelResolver as default };
+
+//# sourceMappingURL=chunk-local-model-resolver.mjs.map

package/dist/lib/chunk-local-model-resolver.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk-local-model-resolver.mjs","names":[],"sources":["../../src/capabilities/local-model-resolver.ts"],"sourcesContent":["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as OpenAiClient from '@effect/ai-openai/OpenAiClient';\nimport * as FetchHttpClient from '@effect/platform/FetchHttpClient';\nimport * as HttpClient from '@effect/platform/HttpClient';\nimport * as Effect from 'effect/Effect';\nimport * as Layer from 'effect/Layer';\n\nimport { LMStudioResolver, OllamaResolver } from '@dxos/ai/resolvers';\nimport { Capability } from '@dxos/app-framework';\nimport { AppCapabilities } from '@dxos/app-toolkit';\n\n/**\n * To start LM Studio server:\n * ```bash\n * ~/.lmstudio/bin/lms server start --cors\n * ```\n *\n * To start Ollama server:\n * ```bash\n * OLLAMA_ORIGINS=\"*\" ollama serve\n * ```\n */\nconst localModelResolver = Capability.makeModule<[]>(() =>\n  Effect.succeed([\n    Capability.contributes(\n      AppCapabilities.AiModelResolver,\n      LMStudioResolver.make().pipe(\n        Layer.provide(\n          OpenAiClient.layer({\n            apiUrl: LMStudioResolver.DEFAULT_LMSTUDIO_ENDPOINT,\n          }),\n        ),\n        Layer.provide(FetchHttpClient.layer),\n      ),\n    ),\n    Capability.contributes(\n      AppCapabilities.AiModelResolver,\n      OllamaResolver.make({\n        transformClient: HttpClient.withTracerPropagation(false),\n      }).pipe(Layer.provide(FetchHttpClient.layer)),\n    ),\n  ]),\n);\n\nexport default localModelResolver;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAyBA,IAAM,qBAAqB,WAAW,iBACpC,OAAO,QAAQ,CACb,WAAW,YACT,gBAAgB,iBAChB,iBAAiB,KAAK,CAAC,CAAC,KACtB,MAAM,QACJ,aAAa,MAAM,EACjB,QAAQ,iBAAiB,0BAC3B,CAAC,CACH,GACA,MAAM,QAAQ,gBAAgB,KAAK,CACrC,CACF,GACA,WAAW,YACT,gBAAgB,iBAChB,eAAe,KAAK,EAClB,iBAAiB,WAAW,sBAAsB,KAAK,EACzD,CAAC,CAAC,CAAC,KAAK,MAAM,QAAQ,gBAAgB,KAAK,CAAC,CAC9C,CACF,CAAC,CACH"}

package/dist/lib/chunk-markdown-extension.mjs

@@ -0,0 +1,27 @@
+import { t as promptRunExtension } from "./chunk-extensions.mjs";
+import { Capabilities, Capability } from "@dxos/app-framework";
+import { Obj } from "@dxos/echo";
+import * as Effect from "effect/Effect";
+import { MarkdownCapabilities } from "@dxos/plugin-markdown/types";
+import { RoutineOperation } from "@dxos/plugin-routine/types";
+//#region src/capabilities/markdown-extension.ts
+var markdown_extension_default = Capability.makeModule(Effect.fnUntraced(function* () {
+	const capabilities = yield* Capability.Service;
+	return Capability.contributes(MarkdownCapabilities.ExtensionProvider, [({ document: doc, viewMode }) => {
+		if (viewMode === "source") return;
+		if (!doc) return;
+		const db = Obj.getDatabase(doc);
+		if (!db) return;
+		const { invokePromise } = capabilities.get(Capabilities.OperationInvoker);
+		return promptRunExtension({ onRun: (promptText) => {
+			invokePromise(RoutineOperation.RunPromptInNewChat, {
+				db,
+				instructions: promptText
+			});
+		} });
+	}]);
+}));
+//#endregion
+export { markdown_extension_default as default };
+
+//# sourceMappingURL=chunk-markdown-extension.mjs.map

package/dist/lib/chunk-markdown-extension.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk-markdown-extension.mjs","names":[],"sources":["../../src/capabilities/markdown-extension.ts"],"sourcesContent":["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { Capabilities, Capability } from '@dxos/app-framework';\nimport { Obj } from '@dxos/echo';\nimport { MarkdownCapabilities } from '@dxos/plugin-markdown/types';\nimport { RoutineOperation } from '@dxos/plugin-routine/types';\n\nimport { promptRunExtension } from '../extensions';\n\nexport default Capability.makeModule(\n  Effect.fnUntraced(function* () {\n    const capabilities = yield* Capability.Service;\n\n    return Capability.contributes(MarkdownCapabilities.ExtensionProvider, [\n      ({ document: doc, viewMode }) => {\n        if (viewMode === 'source') {\n          return undefined;\n        }\n\n        if (!doc) {\n          return undefined;\n        }\n\n        const db = Obj.getDatabase(doc);\n        if (!db) {\n          return undefined;\n        }\n\n        const { invokePromise } = capabilities.get(Capabilities.OperationInvoker);\n\n        return promptRunExtension({\n          onRun: (promptText) => {\n            void invokePromise(RoutineOperation.RunPromptInNewChat, { db, instructions: promptText });\n          },\n        });\n      },\n    ]);\n  }),\n);\n"],"mappings":";;;;;;;AAaA,IAAA,6BAAe,WAAW,WACxB,OAAO,WAAW,aAAa;CAC7B,MAAM,eAAe,OAAO,WAAW;CAEvC,OAAO,WAAW,YAAY,qBAAqB,mBAAmB,EACnE,EAAE,UAAU,KAAK,eAAe;EAC/B,IAAI,aAAa,UACf;EAGF,IAAI,CAAC,KACH;EAGF,MAAM,KAAK,IAAI,YAAY,GAAG;EAC9B,IAAI,CAAC,IACH;EAGF,MAAM,EAAE,kBAAkB,aAAa,IAAI,aAAa,gBAAgB;EAExE,OAAO,mBAAmB,EACxB,QAAQ,eAAe;GACrB,cAAmB,iBAAiB,oBAAoB;IAAE;IAAI,cAAc;GAAW,CAAC;EAC1F,EACF,CAAC;CACH,CACF,CAAC;AACH,CAAC,CACH"}

package/dist/lib/{neutral/chunk-L7AR4VTA.mjs → chunk-meta.mjs}

@@ -1,16 +1,13 @@
-// src/meta.ts
 import { Plugin } from "@dxos/app-framework";
 import { DXN } from "@dxos/keys";
-
-// dx.config.ts
 import { Config2 } from "@dxos/app-framework/config";
 import { trim } from "@dxos/util";
-var dx_config_default = Config2.make({
-  plugin: {
-    key: "org.dxos.plugin.assistant",
-    name: "Assistant",
-    author: "DXOS",
-    description: trim`
+//#region dx.config.ts
+var dx_config_default = Config2.make({ plugin: {
+	key: "org.dxos.plugin.assistant",
+	name: "Assistant",
+	author: "DXOS",
+	description: trim`
       AssistantPlugin brings a conversational AI assistant into DXOS Composer, letting users chat naturally
       with objects in their spaces. Every Chat is a first-class ECHO object — messages are persisted,
       replicated across peers in real time, and can be bound to any document or collection as a companion
@@ -31,23 +28,21 @@ var dx_config_default = Config2.make({
       TracePanel visualises that trace as a commit graph or raw JSON, giving developers full observability
       into what the model did and why.
     `,
-    icon: {
-      key: "ph--sparkle--regular",
-      hue: "sky"
-    },
-    source: "https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-assistant",
-    spec: "PLUGIN.mdl"
-  }
-});
-
-// src/meta.ts
+	icon: {
+		key: "ph--sparkle--regular",
+		hue: "sky"
+	},
+	source: "https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-assistant",
+	spec: "PLUGIN.mdl",
+	tags: ["alpha"]
+} });
+//#endregion
+//#region src/meta.ts
 var meta = Plugin.getMetaFromConfig(dx_config_default);
 var ASSISTANT_DIALOG = DXN.make(`${meta.profile.key}.assistantDialog`);
+/** Companion variant identifier for the assistant chat panel. */
 var ASSISTANT_COMPANION_VARIANT = "assistant-chat";
+//#endregion
+export { ASSISTANT_DIALOG as n, meta as r, ASSISTANT_COMPANION_VARIANT as t };
 
-export {
-  meta,
-  ASSISTANT_DIALOG,
-  ASSISTANT_COMPANION_VARIANT
-};
-//# sourceMappingURL=chunk-L7AR4VTA.mjs.map
+//# sourceMappingURL=chunk-meta.mjs.map

package/dist/lib/chunk-meta.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk-meta.mjs","names":[],"sources":["../../dx.config.ts","../../src/meta.ts"],"sourcesContent":["//\n// Copyright 2025 DXOS.org\n//\n\nimport { Config2 } from '@dxos/app-framework/config';\nimport { trim } from '@dxos/util';\n\nexport default Config2.make({\n  plugin: {\n    key: 'org.dxos.plugin.assistant',\n    name: 'Assistant',\n    author: 'DXOS',\n    description: trim`\n      AssistantPlugin brings a conversational AI assistant into DXOS Composer, letting users chat naturally\n      with objects in their spaces. Every Chat is a first-class ECHO object — messages are persisted,\n      replicated across peers in real time, and can be bound to any document or collection as a companion\n      panel that appears alongside the primary view.\n\n      AI capabilities are delivered through a flexible multi-provider model layer. Users can route requests\n      to the DXOS Edge service, a locally running Ollama instance, or LM Studio, and switch providers at\n      any time in Settings. Each provider can be configured with a preferred model, and the runtime\n      automatically falls back when a provider is unavailable.\n\n      Skills give every chat a specialised identity. Built-in skills cover general assistance,\n      web browsing, database interaction, web search, Discord and Linear integration, autonomous agents,\n      planning, memory, automation, and a wizard for authoring new skills. Binding a skill\n      changes the system instructions and the tool set exposed to the model in a single step.\n\n      Tool execution runs through the DXOS compute runtime so every AI action — opening a document,\n      searching the web, querying a database — produces a structured execution trace. The optional\n      TracePanel visualises that trace as a commit graph or raw JSON, giving developers full observability\n      into what the model did and why.\n    `,\n    icon: { key: 'ph--sparkle--regular', hue: 'sky' },\n    source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-assistant',\n    spec: 'PLUGIN.mdl',\n    tags: ['alpha'],\n  },\n});\n","//\n// Copyright 2023 DXOS.org\n//\n\nimport { Plugin } from '@dxos/app-framework';\nimport { DXN } from '@dxos/keys';\n\nimport config from '../dx.config';\n\nexport const meta = Plugin.getMetaFromConfig(config);\n\nexport const ASSISTANT_DIALOG = DXN.make(`${meta.profile.key}.assistantDialog`);\n\n/** Companion variant identifier for the assistant chat panel. */\nexport const ASSISTANT_COMPANION_VARIANT = 'assistant-chat';\n"],"mappings":";;;;;AAOA,IAAA,oBAAe,QAAQ,KAAK,EAC1B,QAAQ;CACN,KAAK;CACL,MAAM;CACN,QAAQ;CACR,aAAa,IAAI;;;;;;;;;;;;;;;;;;;;;CAqBjB,MAAM;EAAE,KAAK;EAAwB,KAAK;CAAM;CAChD,QAAQ;CACR,MAAM;CACN,MAAM,CAAC,OAAO;AAChB,EACF,CAAC;;;AC7BD,IAAa,OAAO,OAAO,kBAAkB,iBAAM;AAEnD,IAAa,mBAAmB,IAAI,KAAK,GAAG,KAAK,QAAQ,IAAI,iBAAiB;;AAG9E,IAAa,8BAA8B"}

package/dist/lib/chunk-operation-handler.mjs

@@ -0,0 +1,13 @@
+import { u as __exportAll } from "./chunk-types.mjs";
+import { Capabilities, Capability } from "@dxos/app-framework";
+import * as Effect from "effect/Effect";
+import { AssistantOperationHandlerSet } from "#operations";
+//#region src/capabilities/operation-handler.ts
+var operation_handler_exports = /* @__PURE__ */ __exportAll({ default: () => operation_handler_default });
+var operation_handler_default = Capability.makeModule(Effect.fnUntraced(function* () {
+	return Capability.contributes(Capabilities.OperationHandler, AssistantOperationHandlerSet);
+}));
+//#endregion
+export { operation_handler_exports as n, operation_handler_default as t };
+
+//# sourceMappingURL=chunk-operation-handler.mjs.map

package/dist/lib/chunk-operation-handler.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk-operation-handler.mjs","names":[],"sources":["../../src/capabilities/operation-handler.ts"],"sourcesContent":["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { Capabilities, Capability } from '@dxos/app-framework';\nimport type { OperationHandlerSet } from '@dxos/compute';\n\nimport { AssistantOperationHandlerSet } from '#operations';\n\nexport default Capability.makeModule<OperationHandlerSet.OperationHandlerSet>(\n  Effect.fnUntraced(function* () {\n    return Capability.contributes(Capabilities.OperationHandler, AssistantOperationHandlerSet);\n  }),\n);\n"],"mappings":";;;;;;AAWA,IAAA,4BAAe,WAAW,WACxB,OAAO,WAAW,aAAa;CAC7B,OAAO,WAAW,YAAY,aAAa,kBAAkB,4BAA4B;AAC3F,CAAC,CACH"}

package/dist/lib/chunk-paths.mjs

@@ -0,0 +1,8 @@
+import { GraphPath } from "@dxos/app-toolkit";
+import { Chat } from "@dxos/assistant-toolkit";
+//#region src/paths.ts
+var { getSectionPath: getChatsPath, getObjectPath: getChatPath } = GraphPath.createTypeSectionPaths(Chat.Chat, { groupId: GraphPath.GroupSegments.ai });
+//#endregion
+export { getChatsPath as n, getChatPath as t };
+
+//# sourceMappingURL=chunk-paths.mjs.map

package/dist/lib/chunk-paths.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk-paths.mjs","names":[],"sources":["../../src/paths.ts"],"sourcesContent":["//\n// Copyright 2025 DXOS.org\n//\n\nimport { GraphPath } from '@dxos/app-toolkit';\nimport { Chat } from '@dxos/assistant-toolkit';\n\nconst { getSectionPath: getChatsPath, getObjectPath: getChatPath } = GraphPath.createTypeSectionPaths(Chat.Chat, {\n  groupId: GraphPath.GroupSegments.ai,\n});\n\nexport { getChatPath, getChatsPath };\n"],"mappings":";;;AAOA,IAAM,EAAE,gBAAgB,cAAc,eAAe,gBAAgB,UAAU,uBAAuB,KAAK,MAAM,EAC/G,SAAS,UAAU,cAAc,GACnC,CAAC"}

package/dist/lib/chunk-processor.mjs

@@ -0,0 +1,432 @@
+import { Harness, McpServerError, PartialBlock, ToolExecutionServices, createSystemPrompt, formatSystemPrompt } from "@dxos/assistant";
+import { AgentService, Operation, Trace } from "@dxos/compute";
+import { DXN } from "@dxos/keys";
+import { trim } from "@dxos/util";
+import { Model, Provider } from "@dxos/ai";
+import { EffectEx } from "@dxos/effect";
+import { Database, Obj } from "@dxos/echo";
+import { Atom, Registry as Registry$1 } from "@effect-atom/atom";
+import { ContentBlock, Message } from "@dxos/types";
+import { AssistantOperation } from "#types";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { log } from "@dxos/log";
+import * as AiError from "@effect/ai/AiError";
+import * as Cause from "effect/Cause";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import * as Stream from "effect/Stream";
+import { UsageQuotaExceededError } from "@dxos/edge-client";
+//#region src/processor/presets.ts
+/** Presets for a provider: every model the provider serves (the catalog filtered by provider). */
+var presetsForProvider = (provider) => Model.forProvider(provider).map((model) => ({
+	id: model.id,
+	provider,
+	model: model.id,
+	backend: model.backend,
+	label: model.label
+}));
+/**
+* Reconcile a stored provider DXN with the runtime: map the bundled sidecar (`built-in`) and an
+* external server (`ollama`) onto whichever is actually available — they are environment-exclusive
+* (the sidecar exists only on desktop). Defaults to `edge` when unset or unparseable.
+*/
+var resolveProvider = (provider, hasBuiltIn) => {
+	const resolved = (provider ? DXN.tryMake(provider) : void 0) ?? Provider.edge.id;
+	if (resolved === Provider.ollama.id && hasBuiltIn) return Provider.builtIn.id;
+	if (resolved === Provider.builtIn.id && !hasBuiltIn) return Provider.ollama.id;
+	return resolved;
+};
+/** The {@link Settings.modelDefaults} key for a provider (`built-in` shares the `ollama` key). */
+var defaultsKeyForProvider = (provider) => provider === Provider.edge.id ? "edge" : provider === Provider.lmStudio.id ? "lmstudio" : "ollama";
+//#endregion
+//#region src/util/error-cause.ts
+/** Walk an error's `cause` chain and return the first value matching `predicate`. */
+var findInCause = (error, predicate) => {
+	let current = error;
+	const visited = /* @__PURE__ */ new Set();
+	while (current) {
+		if (visited.has(current)) break;
+		visited.add(current);
+		if (predicate(current)) return current;
+		current = current instanceof Error ? current.cause : void 0;
+	}
+};
+//#endregion
+//#region src/processor/prompt.ts
+/**
+* Prompt content for a request: the bare message, or — when the request carries selection context —
+* a synthetic block (system-generated user-turn content, hidden from the summary view) ahead of it.
+*/
+var createPromptContent = (request) => {
+	const selection = request.context?.selection;
+	if (!selection?.text.length) return request.message;
+	return [ContentBlock.Text.make({
+		disposition: "synthetic",
+		text: trim`
+        The user's current selection in the document they are viewing:
+        <selection>
+        ${selection.text}
+        </selection>
+      `
+	}), ContentBlock.Text.make({ text: request.message })];
+};
+//#endregion
+//#region src/processor/processor.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/processor/processor.ts";
+var defaultOptions = { model: Model.DEFAULT_EDGE };
+/** User-facing message shown when an AI request is rejected for exceeding the account usage quota (HTTP 429). */
+var QUOTA_EXCEEDED_MESSAGE = "You have reached your AI usage limit for this period.";
+/**
+* Display error for an over-quota (HTTP 429) rejection. Declares an {@link action} so the chat toast can
+* offer a usage-dashboard link declaratively — the UI renders whatever action an error declares rather
+* than branching on the error type.
+*/
+var AiUsageQuotaError = class extends Error {
+	action = { labelKey: "view-usage.label" };
+};
+/**
+* Matches an over-quota rejection (EDGE responds 429) in error text. The typed
+* {@link UsageQuotaExceededError} is wrapped deep in the cause chain and does not survive the
+* agent-process boundary — the failure is rendered to a string via `Cause.pretty`, which drops
+* nested causes — so detection also relies on the HTTP 429 that `@effect/ai`'s
+* {@link AiError.HttpResponseError} embeds in its message (e.g. "... (429 POST ...").
+*/
+var QUOTA_PATTERN = /\b429\b|rate.?limit|too many requests|usage quota|quota exceeded/i;
+/** Whether an error denotes an over-quota (HTTP 429) rejection, detected by typed status or message text. */
+var isQuotaError = (err) => {
+	if (AiError.isAiError(err)) {
+		if (err._tag === "HttpResponseError" && err.response.status === 429) return true;
+		return QUOTA_PATTERN.test(err.description ?? err.message);
+	}
+	return typeof err === "string" && QUOTA_PATTERN.test(err);
+};
+/**
+* Maps a failure from the agent fiber to an error suitable for display.
+* An over-quota (HTTP 429) rejection is surfaced as an actionable usage-limit message; the typed
+* {@link UsageQuotaExceededError} only survives on the direct path, so {@link isQuotaError} also
+* recognizes the stringified 429 the chat receives across the agent-process boundary.
+* Other {@link AiError}s originate from the AI service and are actionable by the user
+* (e.g., "model 'x' not found", "Connection refused"), so their detail is propagated.
+* Any other failure is treated as an internal/unexpected error and reported generically
+* to avoid leaking implementation detail.
+*/
+var parseError = (err) => {
+	const quotaError = findInCause(err, UsageQuotaExceededError.is);
+	if (quotaError || isQuotaError(err)) return new AiUsageQuotaError(quotaError?.message?.trim() || QUOTA_EXCEEDED_MESSAGE, { cause: err });
+	let message;
+	if (AiError.isAiError(err)) message = err.description?.trim() || err.message;
+	else if (typeof err === "string") {
+		const [, model] = err.match(/model\s+'([^']+)'\s+not\s+found/i) || [];
+		if (model) message = `The model is not available: ${model}`;
+	}
+	if (!message) message = "An unexpected error occurred.";
+	return new Error(message, { cause: err });
+};
+/**
+* Handles interactions with the AI service.
+* Uses AgentService to spawn a process-backed agent and subscribes to ephemeral trace events for streaming.
+*/
+var AiChatProcessor = class {
+	_conversation;
+	_runtime;
+	_feed;
+	_spaceLayer;
+	_options;
+	#registry;
+	/** Pending messages (finalized, non-streaming). */
+	#pending = Atom.make([]);
+	/** Currently streaming messages (from ephemeral trace events). */
+	#streaming = Atom.make([]);
+	/** Set of message IDs that have been finalized (non-pending delivered via ephemeral). */
+	#finalizedIds = /* @__PURE__ */ new Set();
+	/** Currently active request fiber. */
+	#requestFiber;
+	/** Last request (for retries). */
+	#lastRequest;
+	/** Streaming state. */
+	streaming = Atom.make((get) => get(this.#streaming).length > 0);
+	/** Active state. */
+	active = Atom.make(false);
+	/** Array of Messages (incl. the current message being streamed). */
+	messages = Atom.make((get) => [...get(this.#pending), ...get(this.#streaming)]);
+	/** Last error. */
+	error = Atom.make(Option.none());
+	/**
+	* MCP server connection errors observed during the most recent request.
+	* Misconfigured/unreachable servers are dropped from the toolkit so the chat
+	* keeps working; the entries here let the UI display which servers failed.
+	*/
+	mcpErrors = Atom.make([]);
+	constructor(_conversation, _runtime, _feed, _spaceLayer, _options = defaultOptions) {
+		this._conversation = _conversation;
+		this._runtime = _runtime;
+		this._feed = _feed;
+		this._spaceLayer = _spaceLayer;
+		this._options = _options;
+		this.#registry = this._options.observableRegistry ?? Registry$1.make();
+		if (this._options.model && !this._options.system) {
+			const capabilities = this._options.modelRegistry?.getCapabilities(this._options.model) ?? {};
+			this._options.system = createSystemPrompt(capabilities);
+		}
+	}
+	get context() {
+		return this._conversation.context;
+	}
+	get conversation() {
+		return this._conversation;
+	}
+	get registry() {
+		return this._options.registry;
+	}
+	get system() {
+		return this._options.system ?? "";
+	}
+	async getTools() {
+		return this._runtime.runPromise(Effect.provide(this._conversation.getTools(), ToolExecutionServices).pipe(Effect.provide(this._spaceLayer)));
+	}
+	async getSystemPrompt() {
+		return this._runtime.runPromise(Effect.gen(this, function* () {
+			const skills = this.context.getSkills();
+			const objects = this.context.getObjects();
+			const instructions = yield* this.#getInstructions();
+			const runtime = yield* Effect.runtime();
+			return yield* formatSystemPrompt({
+				system: this._options.system,
+				skills,
+				objects,
+				instructions
+			}).pipe(Effect.provideService(Harness.HarnessService, Harness.fromBinder({
+				feed: this._feed,
+				runtime,
+				binder: this.context
+			})));
+		}).pipe(Effect.provide(this._spaceLayer), Effect.orDie));
+	}
+	/**
+	* Resolves the chat's steering instructions, if any. The session is feed-centric and cannot reach
+	* its chat, so the ref is resolved here and handed down.
+	*/
+	#getInstructions() {
+		return Effect.gen(this, function* () {
+			const instructionsRef = this._options.chat?.target?.instructions;
+			if (!instructionsRef) return [];
+			const instructions = yield* Database.load(instructionsRef).pipe(Effect.orElseSucceed(() => void 0));
+			return instructions ? [instructions] : [];
+		});
+	}
+	/**
+	* Initiates a new request via AgentService.
+	*/
+	async request(requestProp) {
+		if (this.#requestFiber) await this.cancel();
+		try {
+			this.#lastRequest = requestProp;
+			this.#registry.set(this.error, Option.none());
+			this.#registry.set(this.mcpErrors, []);
+			this.#registry.set(this.active, true);
+			const effect = Effect.gen(this, function* () {
+				log.info("init agent session", {
+					feed: Obj.getURI(this._feed),
+					model: this._options.model,
+					provider: this._options.provider
+				}, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file,
+					L: 305,
+					S: this
+				});
+				const session = yield* AgentService.getSession(this._feed, {
+					model: this._options.model,
+					provider: this._options.provider,
+					instructions: this._options.chat?.target?.instructions
+				});
+				yield* session.subscribeEphemeral().pipe(Stream.runForEach((message) => Effect.sync(() => {
+					for (const event of message.events) if (Trace.isOfType(PartialBlock, event)) this.#handleEphemeralMessage(event.data);
+					else if (Trace.isOfType(McpServerError, event)) this.#handleMcpError(event.data);
+				})), Effect.fork);
+				log("chat processor submitting prompt", { length: requestProp.message.length }, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file,
+					L: 331,
+					S: this
+				});
+				yield* session.submitPrompt(createPromptContent(requestProp));
+				log("chat processor submitPrompt returned, waiting for agent", {}, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file,
+					L: 333,
+					S: this
+				});
+				if (!this._options.chat?.target?.name) yield* this.#updateChatName(requestProp.message);
+				yield* session.waitForCompletion();
+				log.info("session complete", void 0, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file,
+					L: 342,
+					S: this
+				});
+				this.#flushStreaming();
+			});
+			this.#requestFiber = this._runtime.runFork(effect.pipe(Effect.provide(this._spaceLayer)));
+			const exit = await this._runtime.runPromise(Fiber.await(this.#requestFiber));
+			if (Exit.isFailure(exit)) {
+				if (Cause.isInterruptedOnly(exit.cause)) {
+					this.#discardStreaming();
+					return;
+				}
+				throw EffectEx.causeToError(exit.cause);
+			}
+			this.#registry.set(this.error, Option.none());
+			this.#lastRequest = void 0;
+			this.#requestFiber = void 0;
+		} catch (err) {
+			log.error("request failed", { error: err }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 367,
+				S: this
+			});
+			this.#registry.set(this.error, Option.some(parseError(err)));
+		} finally {
+			log.info("setting active to false", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 370,
+				S: this
+			});
+			this.#registry.set(this.active, false);
+			this.#requestFiber = void 0;
+		}
+	}
+	/**
+	* Cancels the current request.
+	*/
+	async cancel() {
+		await EffectEx.runAndForwardErrors(Effect.gen(this, function* () {
+			log.info("cancelling request", { fiber: this.#requestFiber }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 382,
+				S: this
+			});
+			if (this.#requestFiber) yield* Fiber.interrupt(this.#requestFiber);
+			yield* (yield* AgentService.getSession(this._feed)).terminate();
+		}).pipe(Effect.provide(this._spaceLayer)));
+		this.#requestFiber = void 0;
+		this.#discardStreaming();
+		this.#registry.set(this.active, false);
+	}
+	/**
+	* Retry last failed request.
+	*/
+	async retry() {
+		if (this.#lastRequest) return this.request(this.#lastRequest);
+	}
+	/**
+	* Clears the recorded MCP server errors (e.g. after the user dismisses the warning banner).
+	*/
+	dismissMcpErrors() {
+		this.#registry.set(this.mcpErrors, []);
+	}
+	/**
+	* Update the current chat's name.
+	*/
+	async updateName(chat) {
+		const spaceId = Obj.getDatabase(chat)?.spaceId;
+		if (!spaceId) return;
+		EffectEx.unwrapExit(await this._runtime.runPromiseExit(Operation.invoke(AssistantOperation.UpdateChatName, { chat }, { spaceId }).pipe(Effect.provide(this._spaceLayer))));
+	}
+	/**
+	* Handles an ephemeral message from the agent process.
+	* Both pending and completed blocks arrive here. Completed blocks are deduped
+	* against messages already written to the feed queue to handle the race between
+	* ephemeral delivery and feed replication.
+	*/
+	#handleEphemeralMessage(event) {
+		const isPending = event.block.pending;
+		const message = Obj.make(Message.Message, {
+			id: event.messageId,
+			created: (/* @__PURE__ */ new Date()).toISOString(),
+			sender: { role: event.role },
+			blocks: [event.block]
+		});
+		if (isPending) {
+			if (this.#finalizedIds.has(event.messageId)) return;
+			this.#registry.update(this.#streaming, (streaming) => {
+				const idx = streaming.findIndex((existing) => existing.id === event.messageId);
+				if (idx >= 0) {
+					const updated = [...streaming];
+					updated[idx] = message;
+					return updated;
+				}
+				return [...streaming, message];
+			});
+		} else {
+			this.#finalizedIds.add(event.messageId);
+			this.#registry.update(this.#streaming, (streaming) => streaming.filter((existing) => existing.id !== message.id));
+			this.#registry.update(this.#pending, (pending) => {
+				if (pending.some((existing) => existing.id === message.id)) return pending;
+				return [...pending, message];
+			});
+		}
+	}
+	/**
+	* Records a per-server MCP failure, deduped by url+protocol so repeat misconfigurations
+	* across turns do not spam the UI.
+	*/
+	#handleMcpError(event) {
+		log.warn("MCP server error", event, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 474,
+			S: this
+		});
+		this.#registry.update(this.mcpErrors, (errors) => {
+			if (errors.some((existing) => existing.url === event.url && existing.protocol === event.protocol)) return errors;
+			return [...errors, event];
+		});
+	}
+	/**
+	* Drop in-flight streaming messages (cancel/interrupt — partial blocks are discarded).
+	*/
+	#discardStreaming() {
+		this.#registry.set(this.#streaming, []);
+		this.#finalizedIds.clear();
+	}
+	/**
+	* Move remaining streaming messages to pending (called when agent completes).
+	*/
+	#flushStreaming() {
+		const remaining = this.#registry.get(this.#streaming);
+		if (remaining.length > 0) {
+			this.#registry.update(this.#pending, (pending) => [...pending, ...remaining]);
+			this.#registry.set(this.#streaming, []);
+		}
+		this.#finalizedIds.clear();
+	}
+	/**
+	* Schedule a chat name update as a detached (fire-and-forget) operation.
+	* Called automatically on the first message; can also be invoked manually via the toolbar.
+	*/
+	#updateChatName(prompt) {
+		const chat = this._options.chat?.target;
+		if (!chat) return Effect.void;
+		const spaceId = Obj.getDatabase(chat)?.spaceId;
+		if (!spaceId) return Effect.void;
+		log.info("scheduling chat name update", void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 518,
+			S: this
+		});
+		return Operation.schedule(AssistantOperation.UpdateChatName, {
+			chat,
+			prompt
+		}, { spaceId });
+	}
+};
+//#endregion
+export { resolveProvider as a, presetsForProvider as i, AiUsageQuotaError as n, defaultsKeyForProvider as r, AiChatProcessor as t };
+
+//# sourceMappingURL=chunk-processor.mjs.map