@dxos/assistant 0.10.0 → 0.11.1

package/dist/lib/index.mjs

@@ -0,0 +1,1958 @@
+import * as Tool from "@effect/ai/Tool";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Record from "effect/Record";
+import * as Schema from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
+import { AgentStatus, AiParser, AiPreprocessor, AiSummarizer, AiToolNotFoundError, OpaqueToolkit, ToolExecutionService, ToolResolverService, callTool, withoutToolCallParising } from "@dxos/ai";
+import { LayerSpec, Operation, Process, ServiceNotAvailableError, Skill, Template, Trace } from "@dxos/compute";
+import { todo } from "@dxos/debug";
+import { Annotation, DXN, Database, EID, Feed, Filter, Obj, Query, Ref, Registry, Type } from "@dxos/echo";
+import { assertArgument, invariant } from "@dxos/invariant";
+import { EncodedReference } from "@dxos/echo-protocol";
+import { EID as EID$1, EntityId, SpaceId } from "@dxos/keys";
+import { ComplexSet, isNonNullable, isTruthy, trim } from "@dxos/util";
+import { next } from "@automerge/automerge";
+import { ObjectVersion, toCursorRange } from "@dxos/echo-client";
+import { Doc } from "@dxos/echo-doc";
+import { LogLevel, log } from "@dxos/log";
+import * as AiError from "@effect/ai/AiError";
+import * as HttpClientError from "@effect/platform/HttpClientError";
+import { BaseError } from "@dxos/errors";
+import { MESSAGE_PROPERTY_TOOL_CALL_ID, ProcessManager } from "@dxos/compute-runtime";
+import { Actor, ContentBlock, Message } from "@dxos/types";
+import * as Function from "effect/Function";
+import { pipe } from "effect/Function";
+import * as LanguageModel from "@effect/ai/LanguageModel";
+import * as Array$1 from "effect/Array";
+import * as Chunk from "effect/Chunk";
+import * as Stream from "effect/Stream";
+import * as Toolkit from "@effect/ai/Toolkit";
+import { Atom, Registry as Registry$1 } from "@effect-atom/atom";
+import * as Runtime from "effect/Runtime";
+import { Resource } from "@dxos/context";
+import * as Either from "effect/Either";
+import * as Order from "effect/Order";
+import { McpToolkit } from "@dxos/mcp-client";
+import { FeedProtocol } from "@dxos/protocols";
+import * as DateTime from "effect/DateTime";
+import { EffectEx } from "@dxos/effect";
+import * as Rpc from "@effect/rpc/Rpc";
+import * as RpcGroup from "@effect/rpc/RpcGroup";
+import defaultsDeep from "lodash.defaultsdeep";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/util/artifact.ts
+/**
+* @deprecated
+*/
+var createArtifactElement = (id) => `<artifact id=${id} />`;
+/**
+* A model-friendly way to reference an object.
+* Supports vairous formats that will be normalized to a DXN.
+*
+* @internal
+*/
+var ArtifactURI = class extends Schema.String.annotations({
+	description: trim`
+    The URI of the referenced object. Protocols accepted:
+    - echo://01KG7R1ZXWFMWQ4DA1Q6TN1DG4. 
+    - space ID, object ID tuple (spaceID:objectID)
+    - Only object ID that is assumed to be in the current space (01KG7R1ZXWFMWQ4DA1Q6TN1DG4)
+    - dxn:org.dxos.type.calendar:0.1.0 -- named entity from the registry. Absoutely make sure it actually exists in the registry.
+
+    URIs can be prepended with an @ symbol for compatibility with in-text references.
+  `,
+	examples: [
+		"echo://01KG7R1ZXWFMWQ4DA1Q6TN1DG4",
+		"@echo://01KG7R1ZXWFMWQ4DA1Q6TN1DG4",
+		"BM3FSHFOMJCHCG5QW7JTVKGYABD2GAA7G:01KG7R1ZXWFMWQ4DA1Q6TN1DG4",
+		"01KG7R1ZXWFMWQ4DA1Q6TN1DG4",
+		"dxn:org.dxos.type.calendar:0.1.0",
+		"@dxn:org.dxos.type.calendar:0.1.0"
+	]
+}) {
+	static toEchoURI(reference, owningSpaceId) {
+		const stripped = reference.startsWith("@") ? reference.slice(1) : reference;
+		if (stripped.startsWith("echo:") || stripped.startsWith("dxn:")) return EID$1.parse(stripped);
+		else if (stripped.includes(":")) {
+			const [spaceId, objectId] = stripped.split(":");
+			if (!SpaceId.isValid(spaceId) || !EntityId.isValid(objectId)) throw new Error(`Unable to parse object reference: ${reference}`);
+			return spaceId === owningSpaceId ? EID$1.make({ entityId: objectId }) : EID$1.make({
+				spaceId,
+				entityId: objectId
+			});
+		} else if (EntityId.isValid(stripped)) return EID$1.make({ entityId: stripped });
+		else throw new Error(`Unable to parse object reference: ${reference}`);
+	}
+	/**
+	* Resolves an artifact ID to an object.
+	*/
+	static resolve(schema, ref) {
+		const uri = ArtifactURI.toEchoURI(ref);
+		return Database.resolve(Ref.fromURI(uri), schema);
+	}
+};
+/**
+* Schema that decodes ECHO reference object from an LLM-friendly input.
+*/
+var RefFromLLM = Schema.transform(ArtifactURI, Ref.Ref(Obj.Unknown), {
+	decode: (fromA) => {
+		const eid = ArtifactURI.toEchoURI(fromA);
+		return EncodedReference.fromURI(EID$1.toLocal(eid));
+	},
+	encode: (toI) => EncodedReference.toURI(toI),
+	strict: false
+}).annotations({ description: ArtifactURI.ast.annotations.description });
+//#endregion
+//#region src/util/diff.ts
+var __dxlog_file$6 = "/__w/dxos/dxos/packages/core/compute/assistant/src/util/diff.ts";
+/**
+* Convert a list of diffs into a list of operations.
+*/
+var reduceDiffs = (diffs) => {
+	return diffs.reduce((acc, diff) => {
+		const current = acc[acc.length - 1];
+		const [op, ...rest] = diff.split(" ");
+		switch (op) {
+			case "-":
+				if (current && !current.match) current.match += rest.join(" ");
+				else acc.push({
+					match: rest.join(" "),
+					replace: ""
+				});
+				return acc;
+			case "+":
+				if (current && !current.replace) current.replace += rest.join(" ");
+				else acc.push({
+					match: "",
+					replace: rest.join(" ")
+				});
+				return acc;
+			default: throw new Error(`Invalid diff format: each line must start with "- " or "+ ", got: ${JSON.stringify(diff)}`);
+		}
+	}, []);
+};
+/**
+* Resolves text diffs against the accessor's current value into cursor-anchored replacements.
+*/
+var computeDiffsWithCursors = (accessor, diffs) => {
+	return reduceDiffs(diffs).map((diff) => {
+		const idx = Doc.getValue(accessor).indexOf(diff.match);
+		if (idx !== -1) return {
+			cursor: toCursorRange(accessor, idx, idx + diff.match.length),
+			text: diff.replace
+		};
+	}).filter(isNonNullable);
+};
+/**
+* Applies text diffs to the accessor-backed document and returns the resulting string.
+*/
+var applyDiffs = (accessor, diffs, { errorOnNotFound = false } = {}) => {
+	for (const diff of reduceDiffs(diffs)) accessor.handle.change((doc) => {
+		const idx = Doc.getValue(accessor).indexOf(diff.match);
+		if (idx !== -1) next.splice(doc, accessor.path, idx, diff.match.length, diff.replace);
+		else if (errorOnNotFound) throw new Error(`Diff not found: ${diff.match}`);
+		else log.warn("diff not found", diff, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$6,
+			L: 93,
+			S: void 0
+		});
+	});
+	return Doc.getValue(accessor);
+};
+//#endregion
+//#region src/util/errors.ts
+/**
+* Generic error from AI model.
+*/
+var AiModelError = class extends BaseError.extend("AiModelError", "AI model error") {};
+/**
+* Generic error for AI agent execution.
+*/
+var AiAssistantError = class extends BaseError.extend("AiAssistantError", "AI assistant error") {};
+//#endregion
+//#region src/util/error-handling.ts
+var AnthropicErrorResponse = Schema.Struct({
+	type: Schema.Literal("error"),
+	error: Schema.Struct({
+		type: Schema.String,
+		message: Schema.String
+	})
+});
+var mapAiError = (err) => Effect.gen(function* () {
+	const cause = err.cause;
+	if (HttpClientError.isHttpClientError(cause) && cause.reason === "StatusCode") {
+		const body = yield* cause.response.json.pipe(Effect.flatMap(Schema.decodeUnknown(AnthropicErrorResponse, { exact: false })));
+		const parsedCause = new AiModelError({
+			message: body.error.message,
+			context: {
+				model: "anthropic",
+				type: body.error.type
+			}
+		});
+		return AiError.UnknownError.make({
+			description: body.error.message,
+			module: err.module,
+			method: err.method,
+			cause: parsedCause
+		});
+	}
+	return err;
+}).pipe(Effect.catchAll(() => Effect.succeed(err)));
+//#endregion
+//#region src/util/execution-graph.ts
+var SKIP_BLOCKS = ["text"];
+/**
+* Models the execution graph based on a stream of events.
+*/
+var ExecutionGraph = class {
+	_skipBlocks;
+	_commits = [];
+	_branchNames = /* @__PURE__ */ new Set();
+	_lastBlockId;
+	_toolCallCommitIds = /* @__PURE__ */ new Map();
+	_lastCommitByBranch = /* @__PURE__ */ new Map();
+	_pendingToolResults = /* @__PURE__ */ new Map();
+	constructor(_skipBlocks = SKIP_BLOCKS) {
+		this._skipBlocks = _skipBlocks;
+	}
+	/**
+	* Adds events to the graph.
+	*/
+	addEvents(events) {
+		const sortedEvents = this.sortObjectsByCreated(events);
+		for (const event of sortedEvents) if (Obj.instanceOf(Message.Message, event)) this._processMessage(event);
+		else if (Obj.instanceOf(AgentStatus, event)) this._processAgentStatus(event);
+	}
+	/**
+	* Processes a message event and creates commits for its blocks.
+	*/
+	_processMessage(message) {
+		const messageCommits = messageToCommits(message, this._lastBlockId, this._toolCallCommitIds, this._lastCommitByBranch, this._skipBlocks);
+		this._commits.push(...messageCommits);
+		messageCommits.forEach((commit) => this._branchNames.add(commit.branch));
+		this._trackToolCalls(messageCommits);
+		if (messageCommits.length > 0) this._lastBlockId = messageCommits[messageCommits.length - 1].id;
+	}
+	/**
+	* Processes an AgentStatus event.
+	*/
+	_processAgentStatus(event) {
+		const branch = this._getToolCallBranch(event.parentMessage, event.toolCallId);
+		this._branchNames.add(branch);
+		const agentStatusCommit = {
+			id: event.id,
+			branch,
+			message: event.message,
+			icon: "ph--flag--regular",
+			parents: this._getAgentStatusParents(event),
+			timestamp: new Date(event.created)
+		};
+		this._commits.push(agentStatusCommit);
+		this._lastBlockId = event.id;
+		if (event.toolCallId) {
+			this._lastCommitByBranch.set(branch, event.id);
+			this._updatePendingToolResults(event.toolCallId, event.id);
+		}
+	}
+	/**
+	* Stable sort: objects with 'created' field are sorted by it, others remain in place.
+	*/
+	sortObjectsByCreated(objects) {
+		const sortedObjects = objects.slice();
+		const createdObjects = [];
+		sortedObjects.forEach((obj, idx) => {
+			if (obj && typeof obj.created === "string") createdObjects.push({
+				idx,
+				obj
+			});
+		});
+		createdObjects.sort((a, b) => {
+			return new Date(a.obj.created).getTime() - new Date(b.obj.created).getTime();
+		});
+		let createdIdx = 0;
+		return sortedObjects.map((obj, _idx) => {
+			if (obj && typeof obj.created === "string") return createdObjects[createdIdx++].obj;
+			return obj;
+		});
+	}
+	/**
+	* Returns the current state of the graph.
+	*/
+	getGraph(lastRequest = false) {
+		const idx = lastRequest ? this._commits.findLastIndex((c) => c.tags?.includes("user")) : -1;
+		const commits = idx === -1 ? this._commits : this._commits.slice(idx);
+		return {
+			branches: Array.from(this._branchNames),
+			commits
+		};
+	}
+	/**
+	* Tracks tool calls and handles pending tool result updates.
+	*/
+	_trackToolCalls(commits) {
+		commits.forEach((commit) => {
+			if (this._isToolCallCommit(commit)) {
+				const toolCallId = this._extractToolCallId(commit.id);
+				if (toolCallId) this._toolCallCommitIds.set(toolCallId, commit.id);
+			}
+			if (this._isToolResultCommit(commit)) {
+				const toolCallId = this._extractToolCallId(commit.id);
+				if (toolCallId) {
+					this._pendingToolResults.set(toolCallId, commit.id);
+					this._handleLateToolResultUpdate(toolCallId, commit.id);
+				}
+			}
+			this._lastCommitByBranch.set(commit.branch, commit.id);
+		});
+	}
+	/**
+	* Updates pending tool results to point to an AgentStatus event.
+	*/
+	_updatePendingToolResults(toolCallId, agentStatusId) {
+		const toolResultId = this._pendingToolResults.get(toolCallId);
+		if (!toolResultId) return;
+		const toolResultCommit = this._commits.find((c) => c.id === toolResultId);
+		if (!toolResultCommit) return;
+		const toolCallCommitId = this._toolCallCommitIds.get(toolCallId);
+		if (!toolCallCommitId) return;
+		const toolCallIndex = toolResultCommit.parents.indexOf(toolCallCommitId);
+		if (toolCallIndex !== -1) toolResultCommit.parents[toolCallIndex] = agentStatusId;
+		this._pendingToolResults.delete(toolCallId);
+	}
+	/**
+	* Handles late updates when AgentStatus is processed before tool result.
+	*/
+	_handleLateToolResultUpdate(toolCallId, toolResultId) {
+		const toolCallCommitId = this._toolCallCommitIds.get(toolCallId);
+		if (!toolCallCommitId) return;
+		const toolCallBranch = `${toolCallCommitId.split("_toolCall_")[0]}_${toolCallId}`;
+		const agentStatusCommitId = this._lastCommitByBranch.get(toolCallBranch);
+		if (agentStatusCommitId && agentStatusCommitId !== toolCallCommitId) {
+			const toolResultCommit = this._commits.find((c) => c.id === toolResultId);
+			if (toolResultCommit) {
+				const toolCallIndex = toolResultCommit.parents.indexOf(toolCallCommitId);
+				if (toolCallIndex !== -1) toolResultCommit.parents[toolCallIndex] = agentStatusCommitId;
+			}
+			this._pendingToolResults.delete(toolCallId);
+		}
+	}
+	/**
+	* Gets the branch name for a tool call.
+	*/
+	_getToolCallBranch(parentMessage, toolCallId) {
+		if (toolCallId) return toolCallId;
+		return parentMessage || "main";
+	}
+	/**
+	* Gets the parents for an AgentStatus commit.
+	*/
+	_getAgentStatusParents(event) {
+		if (event.parentMessage && event.toolCallId) return [getToolCallId(event.parentMessage, event.toolCallId)];
+		return [];
+	}
+	/**
+	* Checks if a commit is a tool call commit.
+	*/
+	_isToolCallCommit(commit) {
+		return commit.message.includes("Calling tool");
+	}
+	/**
+	* Checks if a commit is a tool result commit.
+	*/
+	_isToolResultCommit(commit) {
+		return commit.message.includes("Tool call succeeded") || commit.message.includes("Tool error:");
+	}
+	/**
+	* Extracts tool call ID from a commit ID.
+	*/
+	_extractToolCallId(commitId) {
+		const toolCallMatch = commitId.match(/_toolCall_(.+)$/);
+		const toolResultMatch = commitId.match(/_toolResult_(.+)$/);
+		return toolCallMatch?.[1] || toolResultMatch?.[1];
+	}
+};
+/**
+* Creates commits for all blocks in a message.
+*/
+var messageToCommits = (message, lastBlockId, toolCallIds, lastCommitByBranch, skipBlocks) => {
+	let previousBlockId = lastBlockId;
+	return message.blocks.map((block, idx) => {
+		const branch = getMessageBranch(message);
+		const parents = getBlockParents(block, previousBlockId, message, toolCallIds, lastCommitByBranch);
+		if (skipBlocks?.includes(block._tag)) return null;
+		const commit = createBlockCommit(block, message, branch, parents, idx);
+		if (commit) previousBlockId = commit.id;
+		return commit;
+	}).filter(isNonNullable);
+};
+/**
+* Determines the parent commits for a block based on its type and context.
+*/
+var getBlockParents = (block, previousBlockId, message, toolCallIds, lastCommitByBranch) => {
+	const parents = [];
+	if (block._tag === "toolResult") {
+		if (previousBlockId) parents.push(previousBlockId);
+		const toolCallCommitId = toolCallIds?.get(block.toolCallId);
+		if (toolCallCommitId) {
+			const toolCallBranch = getToolCallBranchFromCommitId(toolCallCommitId, block.toolCallId);
+			const lastBlockFromToolCallBranch = lastCommitByBranch?.get(toolCallBranch);
+			if (lastBlockFromToolCallBranch) parents.push(lastBlockFromToolCallBranch);
+			else parents.push(toolCallCommitId);
+		}
+	} else if (previousBlockId) parents.push(previousBlockId);
+	else {
+		const toolCallParent = getParentId(message);
+		if (toolCallParent) parents.push(toolCallParent);
+	}
+	return parents;
+};
+/**
+* Creates a commit for a specific block.
+*/
+var createBlockCommit = (block, message, branch, parents, idx) => {
+	const timestamp = new Date(message.created);
+	switch (block._tag) {
+		case "text":
+			if (!block.text.trim().length) return null;
+			return {
+				id: getGenericBlockId(message.id, idx),
+				branch,
+				parents,
+				timestamp,
+				...message.sender.role === "user" ? {
+					icon: "ph--user--regular",
+					tags: ["user"],
+					message: "Processing request..."
+				} : {
+					icon: "ph--drone--regular",
+					message: `Response (${block.text.split(" ").length} words)`
+				}
+			};
+		case "toolCall": return {
+			id: getToolCallId(message.id, block.toolCallId),
+			branch,
+			parents,
+			timestamp,
+			icon: "ph--wrench--regular",
+			level: LogLevel.INFO,
+			message: `Calling tool (${block.name})`
+		};
+		case "toolResult": return {
+			id: getToolResultId(message.id, block.toolCallId),
+			branch,
+			parents,
+			timestamp,
+			icon: block.error ? "ph--x-circle--regular" : "ph--check-circle--regular",
+			level: block.error ? LogLevel.ERROR : LogLevel.INFO,
+			message: block.error ? "Tool error: " + block.error : "Tool call succeeded"
+		};
+		case "stats": return {
+			id: getGenericBlockId(message.id, idx),
+			branch,
+			parents,
+			timestamp,
+			icon: "ph--rocket--regular",
+			level: LogLevel.INFO,
+			message: ContentBlock.createStatsMessage(block)
+		};
+		case "status": return {
+			id: getGenericBlockId(message.id, idx),
+			branch,
+			parents,
+			timestamp,
+			message: block.statusText,
+			level: LogLevel.INFO,
+			icon: "ph--flag--regular"
+		};
+		case "reasoning": return {
+			id: getGenericBlockId(message.id, idx),
+			branch,
+			parents,
+			timestamp,
+			message: block.reasoningText ?? "Thinking...",
+			icon: "ph--brain--regular"
+		};
+		case "reference": return {
+			id: getGenericBlockId(message.id, idx),
+			branch,
+			parents,
+			timestamp,
+			icon: "ph--link--regular",
+			message: stringifyRef(block.reference)
+		};
+		default: return null;
+	}
+};
+/**
+* Gets the tool call branch name from a tool call commit ID.
+*/
+var getToolCallBranchFromCommitId = (toolCallCommitId, toolCallId) => {
+	return `${toolCallCommitId.split("_toolCall_")[0]}_${toolCallId}`;
+};
+var getToolCallId = (messageId, toolCallId) => `${messageId}_toolCall_${toolCallId}`;
+var getToolResultId = (messageId, toolCallId) => `${messageId}_toolResult_${toolCallId}`;
+var getGenericBlockId = (messageId, idx) => `${messageId}_block_${idx}`;
+var getBranchName = (options) => {
+	if (options.toolCallId) return options.toolCallId;
+	else if (options.parentMessage) return options.parentMessage;
+	else return "main";
+};
+var getMessageBranch = (message) => {
+	return getBranchName({
+		parentMessage: message.parentMessage,
+		toolCallId: message.properties?.[MESSAGE_PROPERTY_TOOL_CALL_ID]
+	});
+};
+var getParentId = (message) => {
+	if (message.parentMessage && message.properties?.[MESSAGE_PROPERTY_TOOL_CALL_ID]) return getToolCallId(message.parentMessage, message.properties[MESSAGE_PROPERTY_TOOL_CALL_ID]);
+	else return;
+};
+var stringifyRef = (ref) => {
+	if (ref.target) return stringifyObject(ref.target);
+	const echoUri = EID$1.tryParse(ref.uri);
+	return (echoUri ? EID$1.getEntityId(echoUri) : void 0) ?? "";
+};
+var stringifyObject = (obj) => {
+	return Obj.getLabel(obj) ?? Obj.getTypename(obj) ?? obj.id;
+};
+//#endregion
+//#region src/util/tracing.ts
+/**
+* Partial content block emitted.
+*/
+var PartialBlock = Trace.EventType("assistant.partialBlock", {
+	schema: Schema.Struct({
+		messageId: Obj.ID,
+		role: Actor.Role,
+		block: ContentBlock.Any
+	}),
+	isEphemeral: true
+});
+/**
+* Complete content block emitted.
+*/
+var CompleteBlock = Trace.EventType("assistant.completeBlock", {
+	schema: Schema.Struct({
+		messageId: Obj.ID,
+		role: Actor.Role,
+		block: ContentBlock.Any
+	}),
+	isEphemeral: false
+});
+var AgentRequestBegin = Trace.EventType("assistant.agentRequestBegin", {
+	schema: Schema.Struct({}),
+	isEphemeral: false
+});
+var AgentRequestEnd = Trace.EventType("assistant.agentRequestEnd", {
+	schema: Schema.Struct({
+		status: Schema.Literal("success", "error", "interrupted"),
+		error: Schema.optional(Schema.String)
+	}),
+	isEphemeral: false
+});
+/**
+* Emitted when an MCP server connection fails for a request turn.
+* Ephemeral so that misconfigured/unreachable servers don't pollute the durable feed,
+* but can still be surfaced to the user via the live ephemeral event stream.
+*/
+var McpServerError = Trace.EventType("assistant.mcpServerError", {
+	schema: Schema.Struct({
+		url: Schema.String,
+		protocol: Schema.Literal("sse", "http"),
+		message: Schema.String
+	}),
+	isEphemeral: true
+});
+//#endregion
+//#region src/tool-runtime/services.ts
+var __dxlog_file$5 = "/__w/dxos/dxos/packages/core/compute/assistant/src/tool-runtime/services.ts";
+var makeToolResolverFromOperations = ({ toolkit: extraToolkit = OpaqueToolkit.empty } = {}) => {
+	return Layer.effect(ToolResolverService, Effect.gen(function* () {
+		const toolkitProvider = yield* OpaqueToolkit.OpaqueToolkitProvider;
+		const registry = yield* Registry.Service;
+		return { resolve: (id) => Effect.gen(function* () {
+			const tool = OpaqueToolkit.merge(extraToolkit, toolkitProvider.getToolkit()).toolkit.tools[id];
+			if (tool) return tool;
+			const key = DXN.isDXN(id) ? id : `dxn:${id}`;
+			const results = yield* Effect.promise(() => registry.query(Filter.and(Filter.type(Operation.PersistentOperation), Filter.key(key))).run());
+			if (results.length > 0) return projectFunctionToTool(Operation.deserialize(results[0]));
+			return yield* Effect.fail(new AiToolNotFoundError(id));
+		}) };
+	}));
+};
+var makeToolExecutionService = (opts) => Layer.effect(ToolExecutionService, Effect.gen(function* () {
+	const toolkit = (yield* OpaqueToolkit.OpaqueToolkitProvider).getToolkit();
+	const toolkitHandler = yield* toolkit.toolkit.pipe(Effect.provide(toolkit.layer));
+	invariant(isHandlerLike(toolkitHandler), void 0, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$5,
+		L: 71,
+		S: this,
+		A: ["isHandlerLike(toolkitHandler)", ""]
+	});
+	return { handlersFor: (toolkit) => {
+		const makeHandler = (tool) => {
+			return Effect.fn(`toolFunctionHandler ${tool.name}`)(function* (input) {
+				if (toolkitHandler.tools[tool.name]) {
+					if (Tool.isProviderDefined(tool)) throw new Error("Attempted to call a provider-defined tool");
+					const { result } = yield* toolkitHandler.handle(tool.name, input);
+					return result;
+				}
+				return yield* opts.invoke(tool, input).pipe(Effect.catchAllDefect((defect) => Effect.fail(defect)));
+			});
+		};
+		return toolkit.of(Record.map(toolkit.tools, (tool, _name) => Tool.isUserDefined(tool) ? makeHandler(tool) : null));
+	} };
+}));
+var makeToolExecutionServiceFromOperationInvoker = () => {
+	return Layer.unwrapEffect(Effect.gen(function* () {
+		const operationInvoker = yield* Operation.Service;
+		return makeToolExecutionService({ invoke: (tool, input) => Effect.gen(function* () {
+			const operationDef = getOperationFromTool(tool).pipe(Option.getOrThrow);
+			return yield* operationInvoker.invoke(operationDef, input).pipe(Effect.orDie);
+		}) });
+	}));
+};
+var ToolExecutionServices = Layer.mergeAll(makeToolResolverFromOperations(), makeToolExecutionServiceFromOperationInvoker());
+var FunctionToolAnnotation = class extends Context.Tag("@dxos/assistant/FunctionToolAnnotation")() {};
+var getOperationFromTool = (tool) => {
+	return Context.getOption(FunctionToolAnnotation)(tool.annotations).pipe(Option.map(({ definition }) => definition));
+};
+var toolCache = /* @__PURE__ */ new WeakMap();
+/**
+* Empty parameters schema annotated with an explicit JSON schema so that
+* @effect/ai versions that call JSONSchema.fromAST directly (≥0.35.0) still
+* produce a valid `{type: "object"}` for the Anthropic API instead of the
+* constEmptyStruct `{anyOf: [{type:"object"},{type:"array"}]}`.
+*/
+var EMPTY_PARAMETERS_SCHEMA = Schema.Struct({}).annotations({ [SchemaAST.JSONSchemaAnnotationId]: {
+	type: "object",
+	properties: {},
+	required: [],
+	additionalProperties: false
+} });
+/**
+* Projects an `Operation.Definition` into an `AiTool`.
+*/
+var projectFunctionToTool = (fn) => {
+	if (toolCache.has(fn)) return toolCache.get(fn);
+	const fields = createStructFieldsFromSchema(fn.input);
+	const parametersSchema = Object.keys(fields).length === 0 ? EMPTY_PARAMETERS_SCHEMA : Schema.Struct(fields);
+	const tool = Tool.make(makeToolName(fn.meta.name ?? fn.meta.key), {
+		description: fn.meta.description,
+		failure: Schema.Any
+	}).setParameters(parametersSchema).annotate(FunctionToolAnnotation, { definition: fn });
+	toolCache.set(fn, tool);
+	return tool;
+};
+/**
+* @returns Tool name produced from function name by escaping invalid characters.
+*/
+var makeToolName = (name) => {
+	const toolName = name.toLowerCase().replace(/[^a-zA-Z0-9]/g, "-");
+	invariant(toolName.match(/^[a-z_][a-z0-9-_]*$/), void 0, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$5,
+		L: 171,
+		S: void 0,
+		A: ["toolName.match(/^[a-z_][a-z0-9-_]*$/)", ""]
+	});
+	return toolName;
+};
+/**
+* Projects an operation input struct into the LLM-facing tool parameter fields, mapping each
+* property through {@link mapSchemaTypeForLLM} (so refs become the model-friendly `RefFromLLM`).
+* Exported for testing.
+*/
+var createStructFieldsFromSchema = (schema) => {
+	switch (schema.ast._tag) {
+		case "TypeLiteral": return Object.fromEntries(schema.ast.propertySignatures.map((prop) => [prop.name, Schema.make(mapSchemaTypeForLLM(prop.type))]));
+		case "VoidKeyword": return {};
+		default: return todo(`Unsupported schema AST: ${schema.ast._tag}`);
+	}
+};
+/**
+* Picks an LLM-friendly schema type for the given schema AST.
+* The picked schema type decodes to the original schema type.
+*/
+var mapSchemaTypeForLLM = (ast) => {
+	if (Ref.isRefType(ast)) {
+		const description = ast.annotations.description ? ast.annotations.description + "\n" + RefFromLLM.ast.annotations.description : RefFromLLM.ast.annotations.description;
+		return RefFromLLM.annotations({ description }).ast;
+	} else if (SchemaAST.isTupleType(ast)) return new SchemaAST.TupleType(ast.elements.map((t) => new SchemaAST.OptionalType(mapSchemaTypeForLLM(t.type), t.isOptional, t.annotations)), ast.rest.map((t) => new SchemaAST.Type(mapSchemaTypeForLLM(t.type), t.annotations)), ast.isReadonly, ast.annotations);
+	else if (SchemaAST.isTypeLiteral(ast)) return new SchemaAST.TypeLiteral(ast.propertySignatures.map((p) => new SchemaAST.PropertySignature(p.name, mapSchemaTypeForLLM(p.type), p.isOptional, p.isReadonly, p.annotations)), ast.indexSignatures, ast.annotations);
+	else if (SchemaAST.isUnion(ast)) return SchemaAST.Union.make(ast.types.map((member) => mapSchemaTypeForLLM(member)), ast.annotations);
+	return ast;
+};
+var isHandlerLike = (value) => {
+	return typeof value.tools === "object" && typeof value.handle === "function";
+};
+//#endregion
+//#region src/request/artifact-diff.ts
+/**
+* Resolves artifact ids to their versions.
+* Used to give the model a sense of the changes to the artifacts made by users during the conversation.
+* The artifacts versions are pinned in the history, and whenever the artifact changes in-between assistant's steps,
+* a diff is inserted into the conversation.
+*
+* Can be optionally provided to the session run call.
+*/
+var ArtifactDiffResolver = class extends Context.Tag("@dxos/assistant/ArtifactDiffResolver")() {};
+//#endregion
+//#region src/request/format.ts
+var __dxlog_file$4 = "/__w/dxos/dxos/packages/core/compute/assistant/src/request/format.ts";
+/**
+* Formats the system prompt.
+*/
+var formatSystemPrompt = ({ system, skills = [], objects = [], instructions = [] }) => Effect.gen(function* () {
+	const skillDefs = yield* Function.pipe(skills, Effect.forEach((skill) => Effect.succeed(skill.instructions)), Effect.flatMap(Effect.forEach((template) => Effect.gen(function* () {
+		return trim`
+            <skill>
+              ${yield* Template.processTemplate(template)}
+            </skill>
+          `;
+	}))), Effect.map((skills) => skills.length > 0 ? ["## Skills Definitions", ...skills].join("\n\n") : void 0));
+	const instructionDefs = yield* Function.pipe(instructions, Effect.forEach((instructions) => Effect.gen(function* () {
+		const text = yield* Database.load(instructions.text).pipe(Effect.map((doc) => doc.content.trim()), Effect.catchTag("EntityNotFoundError", () => Effect.succeed("")));
+		const commands = (instructions.commands ?? []).map(({ sentinel, description, prompt }) => `- \`${sentinel}\`${description ? ` (${description})` : ""}: ${prompt}`);
+		const parts = [text];
+		if (commands.length > 0) parts.push(["When the user message contains one of these sentinel commands, follow its prompt:", ...commands].join("\n"));
+		return `<instructions>\n${parts.filter(Boolean).join("\n\n")}\n</instructions>`;
+	})), Effect.map((defs) => defs.length > 0 ? ["## Instructions", ...defs].join("\n\n") : void 0));
+	const objectDefs = yield* Function.pipe(objects, Effect.forEach((object) => {
+		const label = Obj.getLabel(object);
+		return Effect.succeed(trim`
+            <object>
+              <dxn>${Obj.getURI(object)}</dxn>
+              <typename>${Obj.getTypename(object)}</typename>${label ? `\n  <label>${label}</label>` : ""}
+            </object>
+          `);
+	}), Effect.map((objects) => objects.length > 0 ? ["## Context Objects", ...objects].join("\n\n") : void 0));
+	return yield* Function.pipe(Effect.succeed([
+		system,
+		instructionDefs,
+		skillDefs,
+		objectDefs
+	].filter((def) => def !== void 0)), Effect.map((parts) => parts.join("\n\n")));
+}).pipe(Effect.withSpan("formatSystemPrompt"));
+/**
+* Formats the user prompt.
+*/
+var formatUserPrompt = ({ prompt, history = [] }) => Effect.gen(function* () {
+	const blocks = [];
+	const artifactDiffResolver = yield* Effect.serviceOption(ArtifactDiffResolver);
+	if (Option.isSome(artifactDiffResolver)) {
+		const versions = gatherObjectVersions(history);
+		const artifactDiff = yield* Effect.tryPromise({
+			try: () => artifactDiffResolver.value.resolve([...versions.entries()].map(([id, version]) => ({
+				id,
+				lastVersion: version
+			}))),
+			catch: AiAssistantError.wrap({ message: "Artifact diff resolution error" })
+		});
+		log("version", {
+			artifactDiff,
+			versions
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$4,
+			L: 133,
+			S: this
+		});
+		for (const [id, { version }] of [...artifactDiff.entries()]) {
+			if (ObjectVersion.equals(version, versions.get(id))) {
+				artifactDiff.delete(id);
+				continue;
+			}
+			blocks.push({
+				_tag: "anchor",
+				objectId: id,
+				version
+			});
+		}
+		if (artifactDiff.size > 0) blocks.push(createArtifactUpdateBlock(artifactDiff));
+	}
+	return Obj.make(Message.Message, {
+		created: (/* @__PURE__ */ new Date()).toISOString(),
+		sender: { role: "user" },
+		blocks: typeof prompt === "string" ? [...blocks, {
+			_tag: "text",
+			text: prompt
+		}] : [...blocks, ...prompt]
+	});
+}).pipe(Effect.withSpan("formatUserPrompt"));
+var gatherObjectVersions = (messages) => {
+	const artifactIds = /* @__PURE__ */ new Map();
+	for (const message of messages) for (const block of message.blocks) if (block._tag === "anchor") artifactIds.set(block.objectId, block.version);
+	return artifactIds;
+};
+var createArtifactUpdateBlock = (artifactDiff) => {
+	return {
+		_tag: "text",
+		disposition: "synthetic",
+		text: trim`
+      The following artifacts have been updated since the last message:
+      ${[...artifactDiff.entries()].map(([id, { diff }]) => `<changed-artifact id="${id}">${diff ? `\n${diff}` : ""}</changed-artifact>`).join("\n")}
+    `
+	};
+};
+//#endregion
+//#region src/request/observer.ts
+var GenerationObserver = Object.freeze({
+	make: ({ onBegin = Function.constant(Effect.void), onPart = Function.constant(Effect.void), onBlock = Function.constant(Effect.void), onEnd = Function.constant(Effect.void), onMessage = Function.constant(Effect.void) } = {}) => ({
+		onBegin,
+		onPart,
+		onBlock,
+		onEnd,
+		onMessage
+	}),
+	noop: () => GenerationObserver.make(),
+	/**
+	* Debug printer to be used in unit-tests and browser devtools.
+	*/
+	fromPrinter: (printer) => GenerationObserver.make({
+		onBlock: (block) => Effect.sync(() => {
+			if (block.pending) return;
+			printer.printContentBlock(block);
+		}),
+		onMessage: (message) => Effect.sync(() => {
+			if (message.sender.role === "assistant") return;
+			printer.printMessage(message);
+		})
+	})
+});
+//#endregion
+//#region src/request/AiRequest.ts
+var AiRequest_exports = /* @__PURE__ */ __exportAll({ Request: () => Request });
+var __dxlog_file$3 = "/__w/dxos/dxos/packages/core/compute/assistant/src/request/AiRequest.ts";
+/**
+* Contains message history, tools, current context.
+* Current context means the state of the app, time of day, and other contextual information.
+* It makes requests to the model, its a state machine.
+* It keeps track of the current goal.
+* It manages the context window.
+* Tracks the success criteria of reaching the goal, exposing metrics (stretch).
+* Could be run locally in the app or remotely.
+* Could be personal or shared.
+*/
+var Request = class {
+	_options;
+	/** Prevents concurrent execution of session. */
+	_semaphore = Effect.runSync(Effect.makeSemaphore(1));
+	_observer;
+	_onOutput;
+	/** Message history from queue. */
+	_history = [];
+	/** Pending messages for this session (incl. the current prompt). */
+	_pending = [];
+	_started = 0;
+	_ended = 0;
+	_toolCalls = 0;
+	constructor(_options = {}) {
+		this._options = _options;
+		this._observer = _options.observer ?? GenerationObserver.noop();
+		this._onOutput = _options.onOutput ?? (() => Effect.void);
+	}
+	get duration() {
+		return this._ended - this._started;
+	}
+	get toolCalls() {
+		return this._toolCalls;
+	}
+	get pending() {
+		return this._pending;
+	}
+	_submitMessage = (message) => Effect.gen(this, function* () {
+		this._pending.push(message);
+		yield* this._observer.onMessage(message);
+		if (this._options.persist === false) return message;
+		for (const block of message.blocks) {
+			log("write complete block", {
+				messageId: message.id,
+				role: message.sender.role,
+				block: JSON.stringify(block)
+			}, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$3,
+				L: 162,
+				S: this
+			});
+			yield* Trace.write(CompleteBlock, {
+				messageId: message.id,
+				role: message.sender.role,
+				block
+			});
+		}
+		yield* this._onOutput(message);
+		return message;
+	});
+	getToolCalls = () => pipe([...this._history, ...this._pending], Array$1.reverse, Array$1.takeWhile((_) => _.sender.role === "assistant"), Array$1.flatMap((_) => _.blocks.filter(ContentBlock.is("toolCall")).map((block) => ({
+		block,
+		message: _
+	}))), Array$1.filter((_) => !_.block.providerExecuted), Array$1.reverse);
+	/**
+	* Initialize a session: set up history, perform summarization if needed, and submit the user prompt.
+	* Must be called before `runTurn()`.
+	*/
+	begin = ({ prompt, system, history = [], skills = [], objects = [], instructions = [] }) => Effect.gen(this, function* () {
+		this._started = Date.now();
+		this._history = [...history];
+		this._pending = [];
+		const systemPrompt = yield* formatSystemPrompt({
+			system,
+			skills,
+			objects,
+			instructions
+		}).pipe(Effect.orDie);
+		if (this._options.summarizationThreshold !== void 0) {
+			if ((yield* AiPreprocessor.estimateTokens(yield* AiPreprocessor.preprocessPrompt([...this._history], { system: systemPrompt }))) > this._options.summarizationThreshold) {
+				const summary = yield* AiSummarizer.summarize([...this._history]);
+				yield* this._submitMessage(summary);
+			}
+		}
+		yield* this._submitMessage(yield* formatUserPrompt({
+			prompt,
+			history
+		}));
+	}).pipe(Effect.withSpan("AiRequest.begin"));
+	/**
+	* Execute a single turn: one LLM generation followed by tool execution.
+	* The toolkit and system prompt can be updated between turns to reflect context changes (e.g. dynamically enabled skills).
+	*/
+	runAgentTurn = ({ system, toolkit: opaqueToolkit }) => Effect.gen(this, function* () {
+		log("request", {
+			system: {
+				snippet: createSnippet(system),
+				length: system.length
+			},
+			pending: this._pending.length,
+			history: this._history.length
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$3,
+			L: 230,
+			S: this
+		});
+		const prompt = yield* AiPreprocessor.preprocessPrompt([...this._history, ...this._pending], {
+			system,
+			cacheControl: "ephemeral"
+		});
+		const toolkit = opaqueToolkit ? yield* opaqueToolkit.handlers : void 0;
+		const observer = this._observer;
+		let currentMessageId = null;
+		let finishReason;
+		const messages = yield* LanguageModel.streamText({
+			prompt,
+			toolkit,
+			disableToolCallResolution: true
+		}).pipe(withoutToolCallParising, AiParser.parseResponse({
+			emitPartial: true,
+			onBegin: () => observer.onBegin(),
+			onBlock: (block) => observer.onBlock(block),
+			onPart: (part) => observer.onPart(part),
+			onEnd: (summary) => observer.onEnd(summary)
+		}), Stream.map((block) => enrichToolCallBlock(block, toolkit)), Stream.mapEffect((block) => Effect.gen(this, function* () {
+			if (block._tag === "stats" && block.finishReason !== void 0) finishReason = block.finishReason;
+			if (block.pending) {
+				currentMessageId ??= Obj.ID.random();
+				log("emit ephemeral message", {
+					id: currentMessageId,
+					type: block._tag
+				}, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$3,
+					L: 269,
+					S: this
+				});
+				yield* Trace.write(PartialBlock, {
+					messageId: currentMessageId,
+					role: "assistant",
+					block
+				});
+				return Option.none();
+			} else {
+				currentMessageId ??= Obj.ID.random();
+				const id = currentMessageId;
+				currentMessageId = null;
+				log("emit complete message", {
+					id,
+					type: block._tag
+				}, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$3,
+					L: 280,
+					S: this
+				});
+				const message = Obj.make(Message.Message, {
+					id,
+					created: (/* @__PURE__ */ new Date()).toISOString(),
+					sender: { role: "assistant" },
+					blocks: [block]
+				});
+				return Option.some(yield* this._submitMessage(message));
+			}
+		}), {
+			concurrency: 1,
+			unordered: false
+		}), Stream.filterMap((_) => _), Stream.runCollect, Effect.map(Chunk.toArray));
+		log("messages", { messages }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$3,
+			L: 296,
+			S: this
+		});
+		if (finishReason === "pause") return {
+			messages,
+			done: false,
+			finishReason
+		};
+		if (this.getToolCalls().length === 0) {
+			this._ended = Date.now();
+			return {
+				messages,
+				done: true,
+				finishReason
+			};
+		} else if (!toolkit) throw new Error("No toolkit provided");
+		return {
+			messages,
+			done: false,
+			finishReason
+		};
+	}).pipe(Effect.withSpan("AiRequest.runAgentTurn"));
+	runTools = ({ toolkit: opaqueToolkit }) => Effect.gen(this, function* () {
+		const toolkit = opaqueToolkit ? yield* opaqueToolkit.handlers : void 0;
+		const toolCalls = this.getToolCalls();
+		const toolResults = yield* Effect.forEach(toolCalls, ({ block, message }) => {
+			if (!toolkit) throw new Error("No toolkit provided");
+			return callTool(toolkit, block);
+		});
+		yield* this._submitMessage(Obj.make(Message.Message, {
+			created: (/* @__PURE__ */ new Date()).toISOString(),
+			sender: { role: "tool" },
+			blocks: toolResults
+		}));
+		this._toolCalls += toolResults.length;
+	}).pipe(Effect.withSpan("AiRequest.runTools"));
+	/**
+	* Run a full conversation turn loop. Equivalent to calling `begin()` then `runTurn()` in a loop.
+	*/
+	run = ({ prompt, system: systemTemplate, history = [], objects = [], skills = [], instructions = [], toolkit }) => Effect.gen(this, function* () {
+		yield* this.begin({
+			prompt,
+			system: systemTemplate,
+			history,
+			objects,
+			skills,
+			instructions
+		});
+		const system = yield* formatSystemPrompt({
+			system: systemTemplate,
+			skills,
+			objects,
+			instructions
+		}).pipe(Effect.orDie);
+		do {
+			const { done, finishReason } = yield* this.runAgentTurn({
+				system,
+				toolkit
+			});
+			if (done) break;
+			if (finishReason === "pause") continue;
+			yield* this.runTools({ toolkit });
+		} while (true);
+		log("done", {
+			pending: this._pending.length,
+			duration: this.duration,
+			tools: this._toolCalls
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$3,
+			L: 374,
+			S: this
+		});
+		return this._pending;
+	}).pipe(this._semaphore.withPermits(1), Effect.withSpan("AiRequest.run"));
+};
+/**
+* Annotates `toolCall` blocks with metadata about the backing Operation, when one exists.
+* Tool calls that resolve to a toolkit handler (no Operation) are left unchanged so callers can
+* distinguish operation invocations from inline tool calls.
+*/
+var enrichToolCallBlock = (block, toolkit) => {
+	if (block._tag !== "toolCall" || !toolkit) return block;
+	const tool = toolkit.tools[block.name];
+	if (!tool) return block;
+	let operationOpt;
+	try {
+		operationOpt = getOperationFromTool(tool);
+	} catch {
+		return block;
+	}
+	if (Option.isNone(operationOpt)) return block;
+	const { meta } = operationOpt.value;
+	return {
+		...block,
+		operationKey: meta.key,
+		operationName: meta.name,
+		operationIcon: meta.icon
+	};
+};
+var createSnippet = (text, len = 32) => text.length <= len * 2 ? text : [
+	text.slice(0, len),
+	"...",
+	text.slice(-len)
+].join("");
+//#endregion
+//#region src/session/toolkit.ts
+/**
+* Build a combined toolkit from the skill tools and the provided toolkit.
+*/
+var createToolkit = ({ toolkit: toolkitProp, skills = [], opaqueToolkits = [] }) => Effect.gen(function* () {
+	const skillToolkit = yield* ToolResolverService.resolveToolkit(skills.flatMap(({ tools }) => tools));
+	const skillToolHandler = yield* skillToolkit.toContext(ToolExecutionService.handlersFor(skillToolkit));
+	const opaqueToolkit = OpaqueToolkit.merge(...opaqueToolkits);
+	const toolkitDefs = [
+		toolkitProp?.toolkit,
+		skillToolkit,
+		opaqueToolkit.toolkit
+	].filter(isTruthy);
+	const mergedToolkit = Toolkit.merge(...toolkitDefs);
+	const combinedHandlerLayer = Layer.mergeAll(Layer.succeedContext(skillToolHandler), toolkitProp?.layer ?? OpaqueToolkit.empty.layer, opaqueToolkit.layer);
+	return OpaqueToolkit.make(mergedToolkit, combinedHandlerLayer);
+});
+//#endregion
+//#region src/session/AiContext.ts
+var AiContext_exports = /* @__PURE__ */ __exportAll({
+	Binder: () => Binder,
+	Binding: () => Binding,
+	Bindings: () => Bindings
+});
+var __dxlog_file$2 = "/__w/dxos/dxos/packages/core/compute/assistant/src/session/AiContext.ts";
+/**
+* Thread message that binds or unbinds contextual objects to a conversation.
+*/
+var Binding = class extends Type.makeObject(DXN.make("org.dxos.type.contextBinding", "0.1.0"))(Schema.Struct({
+	skills: Schema.Struct({
+		added: Schema.Array(Ref.Ref(Skill.Skill)),
+		removed: Schema.Array(Ref.Ref(Skill.Skill))
+	}),
+	objects: Schema.Struct({
+		added: Schema.Array(Ref.Ref(Obj.Unknown)),
+		removed: Schema.Array(Ref.Ref(Obj.Unknown))
+	})
+}).pipe(Annotation.HiddenAnnotation.set(true))) {};
+var Bindings = class {
+	skills = new ComplexSet((ref) => ref.uri);
+	objects = new ComplexSet((ref) => {
+		const echoUri = EID$1.tryParse(ref.uri);
+		return echoUri ? EID$1.getEntityId(echoUri) : void 0;
+	});
+	toJSON() {
+		return {
+			skills: Array$1.fromIterable(this.skills).map((ref) => ref.uri),
+			objects: Array$1.fromIterable(this.objects).map((ref) => ref.uri)
+		};
+	}
+};
+/**
+* Manages bindings of skills and objects to a conversation.
+*/
+var Binder = class extends Resource {
+	_skills = Atom.make([]).pipe(Atom.keepAlive);
+	_objects = Atom.make([]).pipe(Atom.keepAlive);
+	_registry;
+	_feed;
+	_runtime;
+	#bindingsQuery;
+	constructor(options) {
+		super();
+		assertArgument(options.feed, "options.feed", "Feed is required");
+		assertArgument(options.runtime, "options.runtime", "Feed runtime is required");
+		this._feed = options.feed;
+		this._runtime = options.runtime;
+		this._registry = options.registry ?? Registry$1.make();
+	}
+	/**
+	* Returns the skills atom for subscription.
+	*/
+	get skills() {
+		return this._skills;
+	}
+	/**
+	* Returns the objects atom for subscription.
+	*/
+	get objects() {
+		return this._objects;
+	}
+	/**
+	* Gets the current skills value.
+	*/
+	getSkills() {
+		return this._registry.get(this._skills);
+	}
+	/**
+	* Gets the current objects value.
+	*/
+	getObjects() {
+		return this._registry.get(this._objects);
+	}
+	/**
+	* Subscribe to changes in skills.
+	*/
+	subscribeSkills(cb) {
+		return this._registry.subscribe(this._skills, () => cb(this._registry.get(this._skills)));
+	}
+	/**
+	* Subscribe to changes in objects.
+	*/
+	subscribeObjects(cb) {
+		return this._registry.subscribe(this._objects, () => cb(this._registry.get(this._objects)));
+	}
+	async _open() {
+		this.#bindingsQuery = await Runtime.runPromise(this._runtime)(Feed.query(this._feed, Query.type(Binding)));
+		const initialResults = await this.#bindingsQuery.run();
+		await this._updateBindings(initialResults);
+		this._ctx.onDispose(this.#bindingsQuery.subscribe(async () => {
+			await this._updateBindings(this.#bindingsQuery.results);
+		}));
+	}
+	/**
+	* Re-reads bindings from the feed to pick up changes made by other processes.
+	*/
+	async sync() {
+		if (this.#bindingsQuery) {
+			const results = await this.#bindingsQuery.run();
+			log("sync", { bindingItems: results.length }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$2,
+				L: 151,
+				S: this
+			});
+			await this._updateBindings(results);
+			log("sync complete", {
+				skills: this._registry.get(this._skills).length,
+				skillKeys: this._registry.get(this._skills).map((bp) => Skill.getKey(bp))
+			}, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$2,
+				L: 153,
+				S: this
+			});
+		}
+	}
+	async _updateBindings(items) {
+		if (items.length === 0) return;
+		const bindings = this._reduce(items);
+		log("_updateBindings", {
+			items: items.length,
+			skillRefs: [...bindings.skills].map((ref) => ({
+				uri: ref.uri,
+				available: ref.isAvailable
+			}))
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$2,
+			L: 168,
+			S: this
+		});
+		const currentSkills = this._registry.get(this._skills);
+		const currentObjects = this._registry.get(this._objects);
+		const resolvedSkills = await this._resolve(bindings.skills, currentSkills);
+		const resolvedObjects = await this._resolve(bindings.objects, currentObjects);
+		log("_updateBindings resolved", {
+			resolvedSkills: resolvedSkills.length,
+			resolvedSkillKeys: resolvedSkills.map((bp) => Obj.getMeta(bp).key ?? "<missing>")
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$2,
+			L: 179,
+			S: this
+		});
+		const keyedSkills = resolvedSkills.filter((bp) => {
+			if (Obj.getMeta(bp).key === void 0) {
+				log.warn("dropping skill with no meta key", { uri: Obj.getURI(bp) }, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$2,
+					L: 188,
+					S: this
+				});
+				return false;
+			}
+			return true;
+		});
+		const reducedSkillDxns = new Set([...bindings.skills].map((ref) => ref.uri));
+		const reducedObjectDxns = new Set([...bindings.objects].map((ref) => ref.uri));
+		const filteredSkills = currentSkills.filter((obj) => {
+			const uri = Obj.getURI(obj);
+			return uri != null && reducedSkillDxns.has(uri) && Obj.getMeta(obj).key !== void 0;
+		});
+		const filteredObjects = currentObjects.filter((obj) => {
+			const uri = Obj.getURI(obj);
+			return uri != null && reducedObjectDxns.has(uri);
+		});
+		const mergedSkills = this._mergeInto(filteredSkills, keyedSkills);
+		const mergedObjects = this._mergeInto(filteredObjects, resolvedObjects);
+		this._registry.set(this._skills, mergedSkills);
+		this._registry.set(this._objects, mergedObjects);
+		log("updated bindings", {
+			skills: mergedSkills.length,
+			objects: mergedObjects.length
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$2,
+			L: 212,
+			S: this
+		});
+	}
+	async _close() {
+		this._registry.set(this._skills, []);
+		this._registry.set(this._objects, []);
+	}
+	async bind({ skills, objects }) {
+		const currentSkills = this._registry.get(this._skills);
+		const currentObjects = this._registry.get(this._objects);
+		const { added: addedSkills, next: nextSkills } = this._processBindings(skills, currentSkills);
+		const { added: addedObjects, next: nextObjects } = this._processBindings(objects, currentObjects);
+		if (!addedSkills.length && !addedObjects.length) return;
+		this._registry.set(this._skills, nextSkills);
+		this._registry.set(this._objects, nextObjects);
+		log("bind", {
+			skills: addedSkills.length,
+			objects: addedObjects.length
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$2,
+			L: 238,
+			S: this
+		});
+		await Runtime.runPromise(this._runtime)(Feed.append(this._feed, [Obj.make(Binding, {
+			skills: {
+				added: addedSkills,
+				removed: []
+			},
+			objects: {
+				added: addedObjects,
+				removed: []
+			}
+		})]));
+	}
+	async unbind({ skills, objects }) {
+		if (!skills?.length && !objects?.length) return;
+		const removedSkillDxns = (skills ?? []).map((ref) => ref.uri);
+		const removedObjectDxns = (objects ?? []).map((ref) => ref.uri);
+		if (removedSkillDxns.length > 0) {
+			const current = this._registry.get(this._skills);
+			this._registry.set(this._skills, current.filter((obj) => !removedSkillDxns.some((uri) => Obj.getURI(obj) === uri)));
+		}
+		if (removedObjectDxns.length > 0) {
+			const current = this._registry.get(this._objects);
+			this._registry.set(this._objects, current.filter((obj) => !removedObjectDxns.some((uri) => Obj.getURI(obj) === uri)));
+		}
+		log("unbind", {
+			skills: skills?.length,
+			objects: objects?.length
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$2,
+			L: 278,
+			S: this
+		});
+		await Runtime.runPromise(this._runtime)(Feed.append(this._feed, [Obj.make(Binding, {
+			skills: {
+				added: [],
+				removed: skills ?? []
+			},
+			objects: {
+				added: [],
+				removed: objects ?? []
+			}
+		})]));
+	}
+	/**
+	* Process bindings to filter duplicates and determine next state.
+	*/
+	_processBindings(refs, current) {
+		const next = [...current];
+		const added = [];
+		if (!refs?.length) return {
+			added,
+			next
+		};
+		const seen = new Set(current.map((obj) => Obj.getURI(obj)));
+		for (const ref of refs) {
+			const uri = ref.uri;
+			if (seen.has(uri)) continue;
+			seen.add(uri);
+			added.push(ref);
+			if (ref.isAvailable) {
+				const target = ref.target;
+				if (target) next.push(target);
+			}
+		}
+		return {
+			added,
+			next
+		};
+	}
+	/**
+	* Reduce results into sets of skills and objects.
+	*/
+	_reduce(items) {
+		return Function.pipe(items, Array$1.reduce(new Bindings(), (context, { skills, objects }) => {
+			skills.added.forEach((ref) => context.skills.add(ref));
+			skills.removed.forEach((ref) => context.skills.delete(ref));
+			objects.added.forEach((ref) => context.objects.add(ref));
+			objects.removed.forEach((ref) => {
+				for (const obj of context.objects) if (obj.uri === ref.uri || EID$1.tryParse(obj.uri) && EID$1.tryParse(ref.uri) && EID$1.getEntityId(EID$1.tryParse(obj.uri)) === EID$1.getEntityId(EID$1.tryParse(ref.uri))) context.objects.delete(obj);
+			});
+			return context;
+		}));
+	}
+	/**
+	* Merge resolved items into the current set, adding only items not already present (by DXN).
+	*/
+	_mergeInto(current, resolved) {
+		const seen = new Set(current.map((obj) => Obj.getURI(obj)));
+		const merged = [...current];
+		for (const obj of resolved) {
+			const uri = Obj.getURI(obj);
+			if (!seen.has(uri)) {
+				seen.add(uri);
+				merged.push(obj);
+			}
+		}
+		return merged;
+	}
+	/**
+	* Resolve references to objects, loading them first if needed and falling back to existing objects.
+	* DXN refs (e.g. `dxn:org.dxos.skill.database`) resolve via the wired-up ECHO ref resolver
+	* which already spans both the space DB and the hypergraph registry.
+	*/
+	async _resolve(refs, current) {
+		const refArray = [...refs];
+		await Promise.all(refArray.map((ref) => ref.tryLoad()));
+		return refArray.map((ref) => {
+			let target;
+			if (ref.isAvailable) target = ref.target;
+			return target ?? current.find((obj) => Obj.getURI(obj) === ref.uri);
+		}).filter(isNonNullable);
+	}
+};
+//#endregion
+//#region src/session/SessionLink.ts
+var SessionLink_exports = /* @__PURE__ */ __exportAll({ SessionLink: () => SessionLink });
+/**
+* Feed-level record that links this session to a point in another session's history.
+* When present in a feed, the messages from the referenced feed up to and including
+* `messageId` are prepended to the conversation history before each turn.
+*/
+var SessionLink = class extends Type.makeObject(DXN.make("org.dxos.type.sessionLink", "0.1.0"))(Schema.Struct({
+	/** Reference to the feed of the source session. */
+	feedRef: Ref.Ref(Feed.Feed),
+	/** Messages from the source feed up to and including this message ID are injected. */
+	messageId: Obj.ID
+})) {};
+//#endregion
+//#region src/session/SessionLoader.ts
+/**
+* Loads and reifies conversation history by resolving SessionLink feed records.
+*/
+var SessionLoader = class {
+	/**
+	* Prepends linked history to `messages` when the feed contains a SessionLink.
+	* Queries the feed for any SessionLink record; if found, loads messages from
+	* the referenced feed up to and including `messageId` and prepends them.
+	*/
+	reifyHistory(feed, messages) {
+		return Effect.gen(function* () {
+			const link = (yield* Feed.query(feed, Filter.type(SessionLink)).run).filter(Obj.instanceOf(SessionLink))[0];
+			if (!link) return messages;
+			const sourceFeed = link.feedRef.target;
+			if (!sourceFeed) return messages;
+			const sorted = [...(yield* Feed.query(sourceFeed, Filter.type(Message.Message)).run).filter(Obj.instanceOf(Message.Message))].sort((a, b) => a.created.localeCompare(b.created));
+			const cutoffIndex = sorted.findIndex((m) => m.id === link.messageId);
+			if (cutoffIndex < 0) return messages;
+			return [...sorted.slice(0, cutoffIndex + 1), ...messages];
+		});
+	}
+};
+//#endregion
+//#region src/session/Harness.ts
+var Harness_exports = /* @__PURE__ */ __exportAll({
+	HarnessService: () => HarnessService,
+	NotSupportedError: () => NotSupportedError,
+	bindContext: () => bindContext,
+	binder: () => binder,
+	enqueueMessage: () => enqueueMessage,
+	fromBinder: () => fromBinder,
+	history: () => history,
+	layerSpec: () => layerSpec,
+	make: () => make,
+	queryContext: () => queryContext,
+	setAlarm: () => setAlarm
+});
+/**
+* Provides access to the controlling harness for tools and operations that are executed by the agent.
+*
+* Replaces AiContextService and AiSessionService.
+*/
+var HarnessService = class extends Context.Tag("@dxos/assistant/HarnessService")() {};
+/**
+* Acess current context binder.
+*/
+var binder = Effect.flatMap(HarnessService, (service) => service.binder);
+/**
+* Query the context using a filter.
+*/
+var queryContext = (filter) => Effect.flatMap(HarnessService, (service) => service.queryContext(filter));
+/**
+* Query the session history.
+*/
+var history = Effect.flatMap(HarnessService, (service) => service.history);
+/**
+* Enqueue a message to the harness.
+*/
+var enqueueMessage = (options) => Effect.flatMap(HarnessService, (service) => service.enqueueMessage(options));
+var setAlarm = (options) => Effect.flatMap(HarnessService, (service) => service.setAlarm(options));
+/**
+* Binds skills and/or objects to the conversation context.
+*/
+var bindContext = ({ skills, objects }) => Effect.gen(function* () {
+	const sessionBinder = yield* binder;
+	yield* Effect.promise(() => sessionBinder.bind({
+		skills,
+		objects
+	}));
+});
+var NotSupportedError = class extends BaseError.extend("NotSupportedError", "Operation not supported") {};
+/**
+* Process-affinity {@link LayerSpec} that materialises {@link HarnessService} from the resolution
+* context's `conversation` DXN. Merges the former `AiContext.Service` (Tier A) with live host
+* dispatch (Tier B).
+*/
+var layerSpec = LayerSpec.make({
+	affinity: "process",
+	requires: [Database.Service, ProcessManager.Service],
+	provides: [HarnessService]
+}, (context) => Layer.scoped(HarnessService, Effect.gen(function* () {
+	if (!context.conversation) return yield* Effect.die(new ServiceNotAvailableError(HarnessService.key, { message: `Service not available: ${HarnessService.key} — process spawn is missing 'conversation' in environment (set via Operation.withInvocationOptions or ProcessManager.spawn environment)` }));
+	const conversation = context.conversation;
+	return yield* make({
+		conversation,
+		processManager: yield* ProcessManager.Service,
+		runtime: yield* Effect.runtime()
+	});
+})));
+/**
+* Builds the {@link Service} for a conversation-scoped resolution context. Tier A resolves the
+* conversation feed / {@link AiContext.Binder} once; Tier B looks up the owning host process lazily per call
+* and dispatches over its `Handle.rpc` control surface (raising {@link NotSupportedError} when no
+* live host owns the conversation).
+*/
+var make = ({ conversation, processManager, runtime }) => Effect.gen(function* () {
+	const feed = yield* Database.resolve(EID.parse(conversation), Feed.Feed).pipe(Effect.provide(runtime), Effect.orDie);
+	return makeService({
+		feed,
+		runtime,
+		binder: yield* EffectEx.acquireReleaseResource(() => new Binder({
+			feed,
+			runtime
+		})),
+		owningHost: lookupOwningHost(processManager, conversation)
+	});
+});
+/**
+* Builds the {@link Service} from a {@link AiContext.Binder} already opened for the conversation (e.g. the
+* agent's own turn fiber, which has no `ProcessManager.Service` in scope). Tier A is fully served;
+* Tier B raises {@link NotSupportedError} since the live-host control surface is not reachable here.
+*/
+var fromBinder = ({ feed, runtime, binder }) => makeService({
+	feed,
+	runtime,
+	binder,
+	owningHost: Effect.fail(new NotSupportedError())
+});
+var makeService = ({ feed, runtime, binder, owningHost }) => ({
+	binder: Effect.succeed(binder),
+	history: Effect.gen(function* () {
+		const messages = yield* Feed.query(feed, Filter.type(Message.Message)).run;
+		return yield* new SessionLoader().reifyHistory(feed, messages);
+	}).pipe(Effect.provide(runtime)),
+	queryContext: (filter) => Effect.sync(() => {
+		const match = Filter.toPredicate(filter);
+		return binder.getObjects().filter(match);
+	}),
+	enqueueMessage: ({ content }) => owningHost.pipe(Effect.flatMap((rpc) => rpc.enqueueMessage({ content }))),
+	setAlarm: ({ at, message }) => owningHost.pipe(Effect.flatMap((rpc) => rpc.setAlarm({
+		at: DateTime.toUtc(at),
+		message
+	})))
+});
+/**
+* Resolves the live host owning `conversation` per call (so a process replacement — e.g. a model
+* switch — is never captured stale) and exposes its `HarnessControl` RPC client.
+*/
+var lookupOwningHost = (processManager, conversation) => Effect.gen(function* () {
+	const host = (yield* processManager.list({ target: conversation })).find((process) => !isTerminalProcess(process.status.state) && Option.getOrElse(Annotation.getDictionary(process.params.annotations, Process.HarnessHostAnnotation), () => false));
+	if (!host) return yield* Effect.fail(new NotSupportedError());
+	return host.rpc;
+});
+var isTerminalProcess = (state) => state === Process.State.SUCCEEDED || state === Process.State.FAILED || state === Process.State.TERMINATED;
+//#endregion
+//#region src/session/SkillHooks.ts
+var SkillHooks_exports = /* @__PURE__ */ __exportAll({ runHooks: () => runHooks });
+var __dxlog_file$1 = "/__w/dxos/dxos/packages/core/compute/assistant/src/session/SkillHooks.ts";
+/**
+* Runs every {@link Skill.Hook} on `skills` whose spec matches `phase`. Each hook resolves its
+* `function` ref to a {@link Operation.PersistentOperation}, deserializes it to a definition, and
+* invokes it with the templated `input` via `invoke`. Hooks without a function ref are skipped.
+*
+* Hook failures are isolated: a throwing hook logs and is swallowed so one skill's hook cannot
+* abort the request lifecycle (or the sibling hooks).
+*/
+var runHooks = ({ skills, phase, invoke }) => Effect.gen(function* () {
+	for (const skill of skills) for (const hook of skill.hooks ?? []) {
+		if (hook.spec._tag !== phase) continue;
+		if (!hook.function) continue;
+		yield* Effect.gen(function* () {
+			const record = yield* Database.load(hook.function);
+			invariant(Obj.instanceOf(Operation.PersistentOperation, record), "Hook function must be an operation.", {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 59,
+				S: this,
+				A: ["Obj.instanceOf(Operation.PersistentOperation, record)", "'Hook function must be an operation.'"]
+			});
+			yield* invoke(Operation.deserialize(record), { ...hook.input });
+		}).pipe(Effect.catchAllCause((cause) => Effect.sync(() => log.warn("skill hook failed", {
+			phase,
+			skill: Skill.getKey(skill),
+			cause
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 66,
+			S: this
+		}))));
+	}
+});
+//#endregion
+//#region src/session/AiSession.ts
+var AiSession_exports = /* @__PURE__ */ __exportAll({ Session: () => Session });
+var __dxlog_file = "/__w/dxos/dxos/packages/core/compute/assistant/src/session/AiSession.ts";
+/**
+* Summarization threshold in tokens.
+*/
+var SUMMARY_THRESHOLD = 8e4;
+/**
+* Durable conversation state (initiated by users and agents) backed by a Feed.
+* Executes tools based on AI responses and supports cancellation of in-progress requests.
+*/
+var Session = class extends Resource {
+	_feed;
+	_runtime;
+	#instructions;
+	/**
+	* Skills and objects bound to the session.
+	*/
+	_binder;
+	_sessionLoader = new SessionLoader();
+	constructor(options) {
+		super();
+		this._feed = options.feed;
+		this._runtime = options.runtime;
+		this.#instructions = options.instructions ?? [];
+		invariant(this._feed, void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 94,
+			S: this,
+			A: ["this._feed", ""]
+		});
+		invariant(this._runtime, void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 95,
+			S: this,
+			A: ["this._runtime", ""]
+		});
+		this._binder = new Binder({
+			feed: this._feed,
+			runtime: this._runtime,
+			registry: options.registry
+		});
+	}
+	async _open() {
+		await this._binder.open(this._ctx);
+	}
+	get feed() {
+		return this._feed;
+	}
+	get context() {
+		return this._binder;
+	}
+	/**
+	* The conversation as the model should see it: only the messages reachable from the feed's current
+	* head, so a soft fork's abandoned turns are excluded.
+	*/
+	async getHistory() {
+		const { items: reachable } = Feed.history(await this.#messagesInAppendOrder());
+		return Runtime.runPromise(this._runtime)(this._sessionLoader.reifyHistory(this._feed, reachable));
+	}
+	/**
+	* Every message in the feed, in append order — what `Feed.history` needs, since it walks lineage
+	* positionally rather than by `created`, a wall clock peers do not agree on.
+	*/
+	async #messagesInAppendOrder() {
+		const items = await (await Runtime.runPromise(this._runtime)(Feed.query(this._feed, Filter.type(Message.Message)))).run();
+		return Array$1.sort(items.filter(Obj.instanceOf(Message.Message)), byFeedPosition);
+	}
+	getTools() {
+		return Effect.gen(this, function* () {
+			return (yield* createToolkit({ skills: this.context.getSkills() })).toolkit.tools;
+		}).pipe(Effect.orDie);
+	}
+	/**
+	* Not provided by default, since users might want to override them.
+	*/
+	makeToolExecutionServices() {
+		return ToolExecutionServices.pipe(Layer.provide(Operation.withInvocationOptions({ conversation: Obj.getURI(this._feed) })));
+	}
+	/**
+	* Appends one of this turn's messages to the feed, consuming a pending rewind if there is one.
+	*
+	* The rewind decision is made in the UI, but the continuation is appended by the agent's process,
+	* which resolves the feed and never sees the chat — so the feed carries the intent and this is where
+	* it becomes lineage. `rewindFrom` names the earliest discarded message, so the new parent is whatever
+	* precedes it; nothing preceding means the continuation starts a fresh line. Only the first message of
+	* a turn finds it set, since the append clears it, so the rest of the turn chains implicitly. Clearing
+	* after the append (rather than before) leaves the rewind pending if the turn fails.
+	*/
+	async appendTurnMessage(message) {
+		const rewindFrom = this._feed.rewindFrom;
+		const parent = rewindFrom !== void 0 ? await this.#parentForRewind(rewindFrom) : void 0;
+		return Runtime.runPromise(this._runtime)(Effect.gen(this, function* () {
+			yield* Feed.append(this._feed, [message], parent !== void 0 ? { parent } : void 0);
+			if (rewindFrom !== void 0) Obj.update(this._feed, (feed) => {
+				feed.rewindFrom = void 0;
+			});
+		}));
+	}
+	/** The message preceding `rewindFrom` in append order, which the continuation parents to. */
+	async #parentForRewind(rewindFrom) {
+		const messages = await this.#messagesInAppendOrder();
+		const index = messages.findIndex((message) => message.id === rewindFrom);
+		return index > 0 ? messages[index - 1].id : void 0;
+	}
+	/**
+	* Creates a new cancelable request effect.
+	*/
+	createRequest(params) {
+		return Effect.gen(this, function* () {
+			const history = yield* Effect.promise(() => this.getHistory());
+			const skills = this.context.getSkills();
+			const objects = this.context.getObjects();
+			log("run", {
+				history: history.length,
+				skills: skills.length,
+				objects: objects.length
+			}, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 202,
+				S: this
+			});
+			const request = new Request({
+				summarizationThreshold: SUMMARY_THRESHOLD,
+				observer: params.observer,
+				persist: params.persist,
+				onOutput: (message) => Effect.promise(() => this.appendTurnMessage(message))
+			});
+			yield* request.begin({
+				history,
+				skills,
+				objects,
+				instructions: this.#instructions,
+				prompt: params.prompt,
+				system: params.system
+			});
+			yield* runHooks({
+				skills,
+				phase: "begin-request",
+				invoke: (operation, input) => Operation.invoke(operation, input).pipe(Effect.asVoid, Effect.orDie)
+			});
+			do {
+				yield* Effect.promise(() => this.context.sync());
+				const currentSkills = this.context.getSkills();
+				const mcps = yield* connectMcpServers(currentSkills, params.mcpServers);
+				const toolkit = yield* createToolkit({
+					toolkit: params.toolkit,
+					skills: currentSkills,
+					opaqueToolkits: mcps
+				});
+				log("toolkit", { tools: Record.keys(toolkit.toolkit.tools) }, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file,
+					L: 243,
+					S: this
+				});
+				const system = yield* formatSystemPrompt({
+					system: params.system,
+					skills: currentSkills,
+					objects: this.context.getObjects(),
+					instructions: this.#instructions
+				}).pipe(Effect.orDie);
+				const { done, finishReason } = yield* request.runAgentTurn({
+					system,
+					toolkit
+				});
+				if (done) break;
+				if (finishReason === "pause") continue;
+				yield* request.runTools({ toolkit });
+			} while (true);
+			log("result", {
+				messages: request.pending.length,
+				duration: request.duration,
+				toolCalls: request.toolCalls
+			}, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 264,
+				S: this
+			});
+			return [...request.pending];
+		}).pipe(Effect.provide(Layer.mergeAll(Layer.succeed(HarnessService, fromBinder({
+			feed: this._feed,
+			runtime: this._runtime,
+			binder: this.context
+		})), Operation.withInvocationOptions({ conversation: Obj.getURI(this._feed) }))), Effect.withSpan("AiSession.createRequest"));
+	}
+};
+var connectMcpServers = (skills, spaceMcpServers = []) => {
+	const skillServers = pipe(skills, Array$1.flatMap((_) => _.mcpServers ?? []), Array$1.map(({ url, protocol, apiKey }) => ({
+		url,
+		protocol,
+		apiKey
+	})));
+	const spaceServers = spaceMcpServers.map(({ url, protocol, apiKey }) => ({
+		url,
+		protocol,
+		apiKey
+	}));
+	return pipe([...skillServers, ...spaceServers], Effect.forEach((options) => McpToolkit.make(options).pipe(Effect.tap((toolkit) => log.info("Connected to MCP server", {
+		url: options.url,
+		tools: Object.keys(toolkit.toolkit.tools).length
+	}, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file,
+		L: 311,
+		S: void 0
+	})), Effect.tapError((error) => Effect.gen(function* () {
+		log.warn("Failed to connect to MCP server", {
+			url: error.url,
+			protocol: error.protocol,
+			message: error.message
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 316,
+			S: this
+		});
+		yield* Trace.write(McpServerError, {
+			url: error.url,
+			protocol: error.protocol,
+			message: error.message
+		});
+	})), Effect.catchAllDefect((defect) => Effect.gen(function* () {
+		const message = defect instanceof Error ? defect.message : String(defect);
+		log.warn("Unexpected MCP defect", {
+			url: options.url,
+			message
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 333,
+			S: this
+		});
+		yield* Trace.write(McpServerError, {
+			url: options.url,
+			protocol: options.protocol,
+			message: `Unexpected MCP failure: ${message}`
+		});
+		return yield* Effect.fail(new McpToolkit.McpConnectionError({
+			url: options.url,
+			protocol: options.protocol,
+			message
+		}));
+	})), Effect.either)), Effect.map(Array$1.filterMap((_) => Either.getRight(_))));
+};
+/**
+* Orders feed items by the position the server assigned them. Unpositioned blocks (written locally and
+* not yet acknowledged) sort last, which is what we want: a message just written is the newest.
+*/
+var byFeedPosition = Order.make((a, b) => {
+	const positionA = feedPosition(a);
+	const positionB = feedPosition(b);
+	return positionA === positionB ? 0 : positionA < positionB ? -1 : 1;
+});
+var feedPosition = (message) => {
+	const key = Obj.getKeys(message, FeedProtocol.KEY_QUEUE_POSITION).at(0)?.id;
+	const position = key !== void 0 ? Number(key) : NaN;
+	return Number.isNaN(position) ? Number.POSITIVE_INFINITY : position;
+};
+//#endregion
+//#region src/session/harness-control.ts
+/**
+* Typed control surface on the live host process that owns a conversation's harness.
+*
+* The same group is declared as the agent process's `rpcs` (so its handlers run on the host's
+* server fiber with the live `AlarmManager`/`inputQueue` in scope) and used by {@link HarnessService}
+* Tier B to dispatch over the discovered host's `Handle.rpc` — keeping both ends on one contract.
+*/
+var HarnessControl = RpcGroup.make(Rpc.make("setAlarm", {
+	payload: Schema.Struct({
+		at: Schema.DateTimeUtc,
+		message: Schema.NullOr(Schema.String)
+	}),
+	success: Schema.Void
+}), Rpc.make("enqueueMessage", {
+	payload: Schema.Struct({ content: Schema.Array(ContentBlock.Any) }),
+	success: Schema.Void
+}));
+//#endregion
+//#region src/templates/instructions/format.tpl?raw
+var format_default = "{{! System Core }}\n\n## Input Formats\n\n### Skills\n\nYou may be provided with Skill definitions that include specific instructions and tools for a given set of tasks.\nBlue print instructions will be enclosed in a <skill> tag.\n\n### Context objects\n\nYou may be provided with references to objects that are relevant to the current prompt.\nObjects will be in the form of a <object> tag with a <dxn> element that is the unique key of the object required by many tools.\nThe <typename> element is the type of the object.\n\n<object>\n  <dxn>object-id</dxn>\n  <typename>example.com/type/TypeName</typename>\n</object>\n\n## Response Formats\n\nIt is very important to respond in the correct format.\nYou response must be valid Markdown.\nIn some cases you should respond with well-formed XML tags along with the content.\nCode snippets should use 2-space indents.\n\n{{#if cot}}\nBefore responding, explain your reasoning and include your detailed chain-of-thought enclosed in a <cot> tag.\nThe <cot> tag should be the first thing in your response.\n{{/if}}\n\n## Block references\n\nYou can reply with a block reference for objects if you have the DXN. For example:\n\n<object>\n  <dxn>dxn:queue:data:B6INSIBY3CBEF4M5VZRYBCMAHQMPYK5AJ:01K24XMVHSZHS97SG1VTVQDM5Z:01K24XPK464FSCKVQJAB2H662M</dxn>\n</object>\n<object>\n  <dxn>dxn:echo:@:01K24XPK464FSCKVQJAB2H662M</dxn>\n</object>\n\n### Suggestions\n\nEach suggestion must in the form of a proposed action enclosed in a <suggestion> tag.\nExample: <suggestion>Show on a map</suggestion>\nDo not use bullets when listing suggestions.\n\n### Multiple choice questions\n\nYou may ask multiple choice questions by wrapping consise options inside <option> tags inside a well formed <select> tag.\nExample: <select><option>Yes</option><option>No</option></select>\n\n## Context\n\nThe current date and time is {{DATETIME}}.\n";
+//#endregion
+//#region src/templates/instructions/system.tpl?raw
+var system_default = "{{! System Prompt }}\n\n- You are a helpful assistant called Kai. \n- Your name is Kai and you are powered by different language models.\n- You were created by DXOS and operate inside of Composer and on the DXOS EDGE network.\n- In your initial greeting state your name and make some suggestions based on the current context objects.\n- You are an advanced AI assistant capable of creating and managing artifacts from provided data and tools.\n- Your task is to process user commands and questions and decide how best to respond.\n- In general be concise and direct.\n- Follow all instructions carefully.\n\n## Planning\n\n- Analyze the structure and type of the content in the user's message.\n- Determine if you complete the task using the available skill definitions?\n- If you can't complete the task using the available skill definitions, query the list of available skill definitions using the appropriate tool.\n- Identify which skill definitions are relevant to the user's request.\n- Evaluate the potential benefits of creating an artifact vs. normal processing for each identified element.\n- Make a final decision on whether to create an artifact and explain your reasoning.\n- Are the required skill definitions already available?\n- If not, select which skill definition(s) will be the most relevant and require them using the require_artifact_definitions tool.\n- The require'd artifact tools will be available for use after require.\n- If creating an artifact, outline how you will structure it within the response.\n- Decide if the artifact needs to be shown to the user.\n- Call the show tool to show the artifact to the user.\n- Your reasoning must include: whether to use artifacts or not, to create one or query, whether to show the artifact to the user, and how to structure the response.\n\n## Skills and Artifacts\n\n- Determine if the interaction involves an artifact. Prefer artifacts for tables, lists, spreadsheets, kanbans, games, images, and other structured data.\n- Determine if the user is explicitly talking about creating a new artifact, or wants to use an existing artifact.\n- If it is ambiguous, query for existing artifacts first and then decide.\n- If you decide to create an artifact, call the associated tool to create the artifact.\n- Artifacts are stored in the database. Tools are used to create and query artifacts.\n- If you are unsure about creating an artifact ask the user for clarification.\n- Artifacts are mutable objects that can change over the course of the conversation.\n- Always re-query the artifact using the tool (like query or inspect) to get the latest state of the artifact before answering the user.\n- You must never generate the id of the artifact; only recall the ids that are already in the history.\n- Artifacts are created by requiring the specific artifact using the require_artifact tool and creating it by calling the associated tool.\n- You can add suggested actions at the end of your response.\n- Suggested actions should be very concise and start with a verb and be phrased as a command to an agent -- not a question to the user.\n- Suggested actions must be in the form of a user instruction that you can follow.\n- Suggested actions could include actions that create artifacts.\n- After creating an artifact use a tool to add it to the chat context.\n\n## Navigation\n\n- When the user asks to open, go to, navigate to, or show a specific document, page, or object, use the navigation tools instead of loading content inline. Navigation is always two steps: first resolve a navigation path with Resolve navigation targets, then open that path with Open.\n- The Open tool accepts navigation **paths** only. Never pass an object DXN, URI, or id to Open — pass only a `path` returned by Resolve navigation targets. Passing anything else will fail to navigate.\n- To open a specific object: call Resolve navigation targets with the object's URI in the `query.uri` field — use the value from the object's `<dxn>` tag in context (which may be an `echo:` EID or a `dxn:` DXN), then pass the returned target's `path` to Open.\n- To navigate to a page (not a specific object): call Resolve navigation targets without arguments to list the available pages, then pass the chosen target's `path` to Open.\n- Do not respond with the document's content when the user asks to open it — open it in the main content area instead.\n- If multiple targets match, present the options to the user and let them choose which to open.\n\n## Response format\n\n- NEVER output narration text outside `<status>` tags or the final user-facing answer. Any progress update, transition sentence, or \"let me…\" lead-in MUST be wrapped in `<status>...</status>`. Violating this is an error.\n- When updating the user about the progress of the work you are doing, put the update in a <status> XML tag.\n- Only when you need to show the result to the user or ask a question use a text block without status tags.\n- After a `</status>` tag, the next output must be either another `<status>` tag, a tool call, or the final user-facing answer — never a transition sentence.\n\n<example>\n// reasoning...\n<status>Looking for emails from Depot</status>\n// tool call..\n<status>Found 2 emails from Depot.</status>\n<status>Loading email details</status>\n// tool call\n<status>Located mailbox</status>\nI found **2 emails from Depot**:\n</example>\n\nDo not do (no status tags):\n\n<incorrect_example>\n// reasoning...\n// tool call..\nI found 2 emails from Depot. Let me load their details:\n// tool call\nI found **2 emails from Depot**:\n</incorrect_example>\n\nDo not do (transition sentence after a status tag, before tool calls):\n\n<incorrect_example>\n<status>Doing X</status>\nLet me start by doing X:\n// tool call\n</incorrect_example>\n\n- NEVER write a lead-in sentence before a tool call. Use a `<status>` tag instead.\n- Avoid using plain text to tell the user what you are about to do; instead, use status blocks.\n- WRONG: Let me get...\n- CORRECT: <status>Getting...</status>";
+//#endregion
+//#region src/templates/system.ts
+/**
+* Base system prompt.
+* NOTE: This contains protocol instructions that can not be dynamically edited.
+*/
+var createSystemPrompt = (options = {}) => Template.process(format_default, defaultsDeep(options, { DATETIME: (/* @__PURE__ */ new Date()).toISOString() }));
+var templates = { system: Template.make({
+	id: "01K2J2FZWH39F55CS7B26GP1Q3",
+	source: system_default
+}) };
+//#endregion
+export { AgentRequestBegin, AgentRequestEnd, AiAssistantError, AiContext_exports as AiContext, AiModelError, AiRequest_exports as AiRequest, AiSession_exports as AiSession, CompleteBlock, ExecutionGraph, GenerationObserver, Harness_exports as Harness, HarnessControl, McpServerError, PartialBlock, RefFromLLM, SessionLink_exports as SessionLink, SessionLoader, SkillHooks_exports as SkillHooks, ToolExecutionServices, applyDiffs, computeDiffsWithCursors, createArtifactElement, createStructFieldsFromSchema, createSystemPrompt, createToolkit, formatSystemPrompt, formatUserPrompt, getOperationFromTool, makeToolExecutionService, makeToolExecutionServiceFromOperationInvoker, makeToolResolverFromOperations, mapAiError, reduceDiffs, templates };
+
+//# sourceMappingURL=index.mjs.map