@dxos/agent-runtime 0.0.0 → 0.11.0

package/dist/lib/chunk-AgentService.mjs

@@ -0,0 +1,789 @@
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import { AgentRequestBegin, AgentRequestEnd, AiContext, AiSession, HarnessControl, SkillHooks, getOperationFromTool, makeToolExecutionService, makeToolResolverFromOperations } from "@dxos/assistant";
+import { Credential, Instructions, Operation, Process, Skill, Trace } from "@dxos/compute";
+import { ProcessManager } from "@dxos/compute-runtime";
+import { AgentService as AgentService$1, getSession } from "@dxos/compute/AgentService";
+import { Annotation, Database, Feed, Obj, Ref, Registry } from "@dxos/echo";
+import { EffectEx } from "@dxos/effect";
+import { DXN, EID } from "@dxos/keys";
+import { log } from "@dxos/log";
+import * as Tool from "@effect/ai/Tool";
+import * as Toolkit from "@effect/ai/Toolkit";
+import * as DateTime from "effect/DateTime";
+import * as Duration from "effect/Duration";
+import * as Exit from "effect/Exit";
+import * as Match from "effect/Match";
+import * as Schema from "effect/Schema";
+import { AiService, OpaqueToolkit } from "@dxos/ai";
+import * as StorageService from "@dxos/compute/StorageService";
+import { ContentBlock } from "@dxos/types";
+import { trim } from "@dxos/util";
+//#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/agent-service/agent-process.ts
+var __dxlog_file$1 = "/__w/dxos/dxos/packages/core/compute/agent-runtime/src/agent-service/agent-process.ts";
+var AGENT_PROCESS_KEY = "org.dxos.testing.process.agent";
+/**
+* Hosts a persistent, suspendible AiAgent that can process a number of prompts.
+* The process target is a queue DXN string.
+*/
+var AgentProcess = (options) => Process.make({
+	key: AGENT_PROCESS_KEY,
+	input: Schema.Union(Schema.String, Schema.Array(ContentBlock.Any)),
+	output: Schema.Void,
+	services: [
+		Database.Service,
+		OpaqueToolkit.OpaqueToolkitProvider,
+		Operation.Service,
+		Registry.Service,
+		StorageService.StorageService,
+		ProcessManager.ProcessOperationInvoker.Service,
+		AiService.AiService,
+		Credential.CredentialsService
+	],
+	rpcs: HarnessControl
+}, (ctx) => Effect.gen(function* () {
+	const feedDxn = Annotation.getDictionary(ctx.params.annotations, Process.TargetAnnotation).pipe(Option.getOrUndefined);
+	if (feedDxn == null) return yield* Effect.die(/* @__PURE__ */ new Error("Agent executable requires spawn options.target set to a queue DXN."));
+	const feed = yield* Database.resolve(feedDxn, Feed.Feed).pipe(Effect.orDie);
+	const instructionsDxn = Annotation.getDictionary(ctx.params.annotations, Process.InstructionsAnnotation).pipe(Option.getOrUndefined);
+	const instructions = instructionsDxn ? yield* Database.resolve(instructionsDxn, Instructions.Instructions).pipe(Effect.orElseSucceed(() => void 0)) : void 0;
+	const runtime = yield* Effect.runtime();
+	const session = yield* EffectEx.acquireReleaseResource(() => new AiSession.Session({
+		feed,
+		runtime,
+		instructions: instructions ? [instructions] : []
+	}));
+	let inputQueue = [...yield* AgentEventsCell.get];
+	const storageService = yield* StorageService.StorageService;
+	const toolCallManager = new ToolCallManager(storageService);
+	yield* toolCallManager.load();
+	const clock = yield* Effect.clock;
+	const alarmManager = new AlarmManager({
+		storageService,
+		setAlarm: (timeout) => ctx.setAlarm(timeout),
+		now: () => clock.unsafeCurrentTimeMillis()
+	});
+	yield* alarmManager.load();
+	yield* toolCallManager.reconcileWithInputQueue(inputQueue);
+	const strategy = Option.fromNullable(options.delegationStrategy);
+	let delegations = [...yield* DelegationsCell.get];
+	const requestModelLayer = AiService.model(options.model ? DXN.getName(options.model) : "com.anthropic.model.claude-opus-4-8.default", { provider: options.provider });
+	const operationInvoker = yield* ProcessManager.ProcessOperationInvoker.Service;
+	const runEndRequestHooks = Effect.gen(function* () {
+		yield* SkillHooks.runHooks({
+			skills: session.context.getSkills(),
+			phase: "end-request",
+			invoke: (operation, input) => Effect.gen(function* () {
+				const exit = yield* (yield* operationInvoker.invokeFiber(operation, input, {
+					environment: { conversation: Obj.getURI(feed) },
+					traceMeta: { conversation: Ref.make(feed) }
+				})).await;
+				if (Exit.isFailure(exit)) yield* Effect.failCause(exit.cause);
+			}).pipe(Effect.asVoid, Effect.orDie)
+		});
+	});
+	const maybeComplete = Effect.gen(function* () {
+		if (isAgentWorkPending({
+			inputQueue,
+			alarmManager,
+			delegations,
+			toolCallManager
+		})) return;
+		yield* runEndRequestHooks;
+		if (isAgentWorkPending({
+			inputQueue,
+			alarmManager,
+			delegations,
+			toolCallManager
+		})) {
+			log("agent work enqueued by end-request hook, continuing", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 193,
+				S: this
+			});
+			alarmManager.reconcile(true);
+			return;
+		}
+		log("agent work complete, succeeding", void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 198,
+			S: this
+		});
+		ctx.succeed();
+	});
+	return {
+		rpcHandlers: yield* HarnessControl.toHandlersContext({
+			setAlarm: Effect.fn(function* ({ at, message }) {
+				yield* alarmManager.setWakeAt(DateTime.toEpochMillis(at), message);
+				alarmManager.reconcile(inputQueue.length > 0);
+			}),
+			enqueueMessage: Effect.fn(function* ({ content }) {
+				inputQueue.push({
+					_tag: "prompt",
+					content
+				});
+				yield* AgentEventsCell.set(inputQueue);
+				alarmManager.reconcile(true);
+			})
+		}),
+		onInput: Effect.fnUntraced(function* (prompt) {
+			log("agent onInput received", { backlog: inputQueue.length }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 217,
+				S: this
+			});
+			const content = typeof prompt === "string" ? [ContentBlock.Text.make({ text: prompt })] : [...prompt];
+			inputQueue.push({
+				_tag: "prompt",
+				content
+			});
+			log("agent onInput persisting queue", { depth: inputQueue.length }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 220,
+				S: this
+			});
+			yield* AgentEventsCell.set(inputQueue);
+			log("agent onInput persisted", { depth: inputQueue.length }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 222,
+				S: this
+			});
+			alarmManager.reconcile(true);
+			log("agent onInput alarm scheduled", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 224,
+				S: this
+			});
+		}),
+		onAlarm: Effect.fnUntraced(function* () {
+			log("agent onAlarm fired", { pending: inputQueue.length }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 228,
+				S: this
+			});
+			const fired = yield* alarmManager.takeFiredAlarm();
+			if (fired != null) {
+				log("agent onAlarm self-wake", { firedAt: fired.firedAt }, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$1,
+					L: 233,
+					S: this
+				});
+				inputQueue.push({
+					_tag: "alarm",
+					firedAt: fired.firedAt,
+					message: fired.message
+				});
+				yield* AgentEventsCell.set(inputQueue);
+			}
+			while (inputQueue.length > 0) {
+				const head = inputQueue[0];
+				if (head._tag === "tool_result" && toolCallManager.isReported(head.pid)) {
+					inputQueue.shift();
+					log.info("skip tool result that was reported synchronously", { pid: head.pid }, {
+						"~LogMeta": "~LogMeta",
+						F: __dxlog_file$1,
+						L: 243,
+						S: this
+					});
+					continue;
+				}
+				break;
+			}
+			const item = inputQueue.shift();
+			if (!item) {
+				log("agent onAlarm empty queue", {}, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$1,
+					L: 251,
+					S: this
+				});
+				alarmManager.reconcile(false);
+				yield* AgentEventsCell.set(inputQueue);
+				yield* maybeComplete;
+				return;
+			}
+			log("agent onAlarm handling", { tag: item._tag }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 258,
+				S: this
+			});
+			const prompt = Match.value(item).pipe(Match.tag("prompt", (item) => [...item.content]), Match.tag("tool_result", (item) => item.isError ? [ContentBlock.Text.make({
+				text: toolErrorResponse(item.pid, item.result),
+				disposition: "synthetic"
+			})] : [ContentBlock.Text.make({
+				text: toolResultResponse(item.pid, item.result),
+				disposition: "synthetic"
+			})]), Match.tag("alarm", (item) => [ContentBlock.Text.make({
+				text: wakeUpPrompt(item.firedAt, item.message),
+				disposition: "synthetic"
+			})]), Match.exhaustive);
+			log("begin request", { prompt }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 283,
+				S: this
+			});
+			log("trace agent request begin", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 284,
+				S: this
+			});
+			yield* Trace.write(AgentRequestBegin, {});
+			yield* session.createRequest({
+				prompt,
+				system: options.systemPrompt,
+				mcpServers: options.getMcpServers?.()
+			}).pipe(Effect.onExit((exit) => Trace.write(AgentRequestEnd, {
+				status: Exit.isSuccess(exit) ? "success" : Exit.isInterrupted(exit) ? "interrupted" : "error",
+				error: Exit.isFailure(exit) ? Cause.pretty(exit.cause) : void 0
+			})));
+			log("end request", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 304,
+				S: this
+			});
+			yield* AgentEventsCell.set(inputQueue);
+			if (Option.isSome(strategy)) {
+				const activeIds = new Set(delegations.map((delegation) => delegation.id));
+				const pending = yield* strategy.value.reconcile(feed, activeIds);
+				for (const delegation of pending) {
+					const pid = yield* delegation.spawn;
+					delegations.push({
+						pid,
+						id: delegation.id
+					});
+					log("delegated work", {
+						pid,
+						id: delegation.id
+					}, {
+						"~LogMeta": "~LogMeta",
+						F: __dxlog_file$1,
+						L: 315,
+						S: this
+					});
+				}
+				if (pending.length > 0) yield* DelegationsCell.set(delegations);
+			}
+			alarmManager.reconcile(inputQueue.length > 0);
+			yield* maybeComplete;
+		}, Effect.orDie, Effect.provide(Layer.mergeAll(makeToolResolverFromOperations(), ToolExecutionService({
+			toolCallManager,
+			feed,
+			enableBackgrounding: options.enableToolBackgrounding ?? false
+		}), AsynchronousExectionToolkitLayer, requestModelLayer).pipe(Layer.orDie))),
+		onChildEvent: Effect.fnUntraced(function* (event) {
+			log("childEvent", { event }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 341,
+				S: this
+			});
+			if (event._tag === "exited") {
+				const delegation = delegations.find((delegation) => delegation.pid === event.pid);
+				if (delegation) {
+					delegations = delegations.filter((other) => other.pid !== event.pid);
+					yield* DelegationsCell.set(delegations);
+					const exit = yield* (yield* (yield* ProcessManager.ProcessOperationInvoker.Service).attachFiber(event.pid).pipe(Effect.orDie)).await;
+					if (Option.isSome(strategy)) yield* strategy.value.onComplete(feed, delegation.id, exit);
+					log("delegated work completed", {
+						pid: event.pid,
+						id: delegation.id,
+						success: Exit.isSuccess(exit)
+					}, {
+						"~LogMeta": "~LogMeta",
+						F: __dxlog_file$1,
+						L: 356,
+						S: this
+					});
+					yield* maybeComplete;
+				} else if (toolCallManager.isToolCall(event.pid)) {
+					const attachExit = yield* (yield* ProcessManager.ProcessOperationInvoker.Service).attachFiber(event.pid).pipe(Effect.exit);
+					if (Exit.isFailure(attachExit)) {
+						if (toolCallManager.isToolCall(event.pid) || inputQueue.some((item) => item._tag === "tool_result" && item.pid === event.pid) || toolCallManager.isReported(event.pid)) {
+							log.verbose("childEvent skipped (process gone, result already handled)", { pid: event.pid }, {
+								"~LogMeta": "~LogMeta",
+								F: __dxlog_file$1,
+								L: 369,
+								S: this
+							});
+							return;
+						}
+						return yield* Effect.failCause(attachExit.cause).pipe(Effect.orDie);
+					}
+					const result = yield* attachExit.value.await.pipe(Effect.orDie).pipe(Effect.map(Exit.match({
+						onSuccess: (value) => ({
+							_tag: "tool_result",
+							pid: event.pid,
+							result: value,
+							isError: false
+						}),
+						onFailure: (cause) => ({
+							_tag: "tool_result",
+							pid: event.pid,
+							result: Cause.pretty(cause),
+							isError: true
+						})
+					})));
+					inputQueue.push(result);
+					log("agent onChildEvent persisted tool result", {
+						depth: inputQueue.length,
+						childPid: event.pid
+					}, {
+						"~LogMeta": "~LogMeta",
+						F: __dxlog_file$1,
+						L: 394,
+						S: this
+					});
+					yield* AgentEventsCell.set(inputQueue);
+					alarmManager.reconcile(true);
+					log("agent onChildEvent alarm scheduled", { depth: inputQueue.length }, {
+						"~LogMeta": "~LogMeta",
+						F: __dxlog_file$1,
+						L: 397,
+						S: this
+					});
+				} else log.verbose("childEvent ignored non-tool call and not a delegation", { pid: event.pid }, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$1,
+					L: 399,
+					S: this
+				});
+			}
+		})
+	};
+}));
+var AgentEvent = Schema.Union(Schema.TaggedStruct("prompt", { content: Schema.Array(ContentBlock.Any) }), Schema.TaggedStruct("tool_result", {
+	pid: Process.ID,
+	result: Schema.Unknown,
+	isError: Schema.Boolean
+}), Schema.TaggedStruct("alarm", {
+	firedAt: Schema.Number,
+	message: Schema.NullOr(Schema.String)
+}));
+var AgentEventsCell = StorageService.cell(Schema.parseJson(Schema.Array(AgentEvent).pipe(Schema.mutable)), "inputQueue").pipe(StorageService.withDefault(() => []));
+/**
+* Tracks delegated sub-agent child processes (pid -> correlation id) so that, after a hibernation,
+* a delegated child's exit can be matched back to the work it was fulfilling.
+*/
+var Delegation = Schema.Struct({
+	pid: Process.ID,
+	id: Schema.String
+}).pipe(Schema.mutable);
+var DelegationsCell = StorageService.cell(Schema.parseJson(Schema.Array(Delegation).pipe(Schema.mutable)), "delegations").pipe(StorageService.withDefault(() => []));
+var ToolCallState = Schema.Struct({ activeCalls: Schema.Array(Schema.Struct({
+	pid: Process.ID,
+	reported: Schema.Boolean
+}).pipe(Schema.mutable)).pipe(Schema.mutable) });
+var ToolCallStateCell = StorageService.cell(Schema.parseJson(ToolCallState.pipe(Schema.mutable)), "toolCallState").pipe(StorageService.withDefault(() => ({ activeCalls: [] })));
+var ToolCallManager = class {
+	#storageService;
+	#state = { activeCalls: [] };
+	constructor(storageService) {
+		this.#storageService = storageService;
+	}
+	load() {
+		return Effect.gen(this, function* () {
+			this.#state = yield* ToolCallStateCell.get;
+		}).pipe(Effect.provideService(StorageService.StorageService, this.#storageService));
+	}
+	beginCall(pid) {
+		return Effect.gen(this, function* () {
+			this.#state.activeCalls.push({
+				pid,
+				reported: false
+			});
+			yield* ToolCallStateCell.set(this.#state);
+		}).pipe(Effect.provideService(StorageService.StorageService, this.#storageService));
+	}
+	markAsReported(pid) {
+		return Effect.gen(this, function* () {
+			const call = this.#state.activeCalls.find((call) => call.pid === pid);
+			if (!call) return;
+			call.reported = true;
+			yield* ToolCallStateCell.set(this.#state);
+		}).pipe(Effect.provideService(StorageService.StorageService, this.#storageService));
+	}
+	isToolCall(pid) {
+		return this.#state.activeCalls.some((call) => call.pid === pid);
+	}
+	isReported(pid) {
+		return this.#state.activeCalls.some((call) => call.pid === pid && call.reported);
+	}
+	/** True while a tool-call result has not yet been delivered back to the agent turn. */
+	hasPendingToolResults() {
+		return this.#state.activeCalls.some((call) => !call.reported);
+	}
+	/**
+	* Clears reported flags for tool calls that still have a pending queue entry.
+	* After reload the in-flight createRequest is gone, so those results must be redelivered via onAlarm.
+	*/
+	reconcileWithInputQueue(queue) {
+		return Effect.gen(this, function* () {
+			let changed = false;
+			for (const item of queue) {
+				if (item._tag !== "tool_result") continue;
+				const call = this.#state.activeCalls.find((entry) => entry.pid === item.pid);
+				if (call?.reported) {
+					call.reported = false;
+					changed = true;
+					log("reconcile queued tool result", { pid: item.pid }, {
+						"~LogMeta": "~LogMeta",
+						F: __dxlog_file$1,
+						L: 537,
+						S: this
+					});
+				}
+			}
+			if (changed) yield* ToolCallStateCell.set(this.#state);
+		}).pipe(Effect.provideService(StorageService.StorageService, this.#storageService));
+	}
+};
+/** True while the agent still has queued work, a self-wake, subprocesses, or undelivered tool results. */
+var isAgentWorkPending = ({ inputQueue, alarmManager, delegations, toolCallManager }) => inputQueue.length > 0 || alarmManager.wakeAt != null || delegations.length > 0 || toolCallManager.hasPendingToolResults();
+/**
+* Persisted next agent-scheduled self-wake: the UNIX timestamp (ms) and an optional reminder
+* message delivered when it fires, or `null` when no self-wake is set.
+*/
+var AgentAlarmCell = StorageService.cell(Schema.parseJson(Schema.NullOr(Schema.Struct({
+	wakeAt: Schema.Number,
+	message: Schema.NullOr(Schema.String)
+}))), "agentAlarm").pipe(StorageService.withDefault(() => null));
+/**
+* Computes the timeout to pass to `ctx.setAlarm`, reconciling pending queue work with the agent's
+* self-wake alarm. Returns `null` when no alarm should be scheduled (process can go idle).
+*/
+var computeAlarmDelay = ({ hasPendingWork, wakeAt, now }) => {
+	if (hasPendingWork) return 0;
+	if (wakeAt != null) return Math.max(0, wakeAt - now);
+	return null;
+};
+/**
+* Tracks the next agent-scheduled self-wake and keeps it in sync with the process alarm
+* (`ctx.setAlarm`). The agent sets alarms via the alarm blueprint, which dispatches to this manager
+* through the `HarnessControl` RPC surface; the process reconciles the underlying single-shot alarm
+* timer to fire at the earliest of pending work or the self-wake.
+*/
+var AlarmManager = class {
+	#storageService;
+	#setAlarm;
+	#now;
+	#wakeAt = null;
+	#message = null;
+	constructor({ storageService, setAlarm, now = () => Date.now() }) {
+		this.#storageService = storageService;
+		this.#setAlarm = setAlarm;
+		this.#now = now;
+	}
+	/** Currently scheduled self-wake timestamp (ms), or `null` when none is set. */
+	get wakeAt() {
+		return this.#wakeAt;
+	}
+	/** Reminder message delivered when the current self-wake fires, or `null` when none is set. */
+	get message() {
+		return this.#message;
+	}
+	now() {
+		return this.#now();
+	}
+	/** Restores the persisted alarm state. */
+	load() {
+		return Effect.gen(this, function* () {
+			const persisted = yield* AgentAlarmCell.get;
+			this.#wakeAt = persisted?.wakeAt ?? null;
+			this.#message = persisted?.message ?? null;
+		}).pipe(Effect.provideService(StorageService.StorageService, this.#storageService));
+	}
+	/** Records a new self-wake target (with an optional reminder message) and persists it. */
+	setWakeAt(wakeAt, message = null) {
+		return Effect.gen(this, function* () {
+			this.#wakeAt = wakeAt;
+			this.#message = message;
+			yield* AgentAlarmCell.set({
+				wakeAt,
+				message
+			});
+		}).pipe(Effect.provideService(StorageService.StorageService, this.#storageService));
+	}
+	/**
+	* Clears the self-wake alarm if it is due, returning the timestamp it was scheduled for and the
+	* reminder message it carried (or `null` if no alarm was due).
+	*/
+	takeFiredAlarm() {
+		return Effect.gen(this, function* () {
+			if (this.#wakeAt == null || this.#now() < this.#wakeAt) return null;
+			const firedAt = this.#wakeAt;
+			const message = this.#message;
+			this.#wakeAt = null;
+			this.#message = null;
+			yield* AgentAlarmCell.set(null);
+			return {
+				firedAt,
+				message
+			};
+		}).pipe(Effect.provideService(StorageService.StorageService, this.#storageService));
+	}
+	/**
+	* Reconciles the process alarm timer with pending work and the tracked self-wake, scheduling the
+	* earliest of the two. Does nothing when there is neither pending work nor a self-wake.
+	*/
+	reconcile(hasPendingWork) {
+		const delay = computeAlarmDelay({
+			hasPendingWork,
+			wakeAt: this.#wakeAt,
+			now: this.#now()
+		});
+		if (delay != null) this.#setAlarm(delay);
+	}
+};
+/**
+* Prompt delivered to the agent when a self-scheduled alarm fires. When the alarm carried a
+* reminder message it is surfaced verbatim, otherwise a generic continuation prompt is used.
+*/
+var wakeUpPrompt = (firedAt, message) => message != null ? trim`
+      Your scheduled alarm fired (it was set for ${new Date(firedAt).toISOString()}).
+      ${message}
+    ` : trim`
+      Your scheduled alarm fired (it was set for ${new Date(firedAt).toISOString()}).
+      Continue with whatever you intended to do when you scheduled this wake-up.
+    `;
+var ToolExecutionService = ({ enableBackgrounding, backgroundThreshold = Duration.seconds(1), toolCallManager, feed }) => Layer.unwrapEffect(Effect.gen(function* () {
+	const operationInvoker = yield* ProcessManager.ProcessOperationInvoker.Service;
+	return makeToolExecutionService({ invoke: (tool, input) => Effect.gen(function* () {
+		const operationDef = getOperationFromTool(tool).pipe(Option.getOrThrow);
+		log("invoking operation", {
+			operationDef,
+			input
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 723,
+			S: this
+		});
+		const fiber = yield* operationInvoker.invokeFiber(operationDef, input, {
+			environment: { conversation: Obj.getURI(feed) },
+			traceMeta: { conversation: Ref.make(feed) }
+		});
+		yield* toolCallManager.beginCall(fiber.pid);
+		log("invoked operation", {
+			operationDef,
+			input,
+			fiber
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 733,
+			S: this
+		});
+		const awaitWithReport = fiber.await.pipe(Effect.tap(() => toolCallManager.markAsReported(fiber.pid)));
+		const result = enableBackgrounding ? yield* awaitWithReport.pipe(Effect.timeout(backgroundThreshold), Effect.catchTag("TimeoutException", () => Effect.succeed(Exit.succeed(toolIsRunningInBackgroundResponse(fiber.pid))))) : yield* awaitWithReport;
+		log("result", { result }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 744,
+			S: this
+		});
+		return yield* result;
+	}) });
+}));
+var AsynchronousExectionToolkit = class extends Toolkit.make(Tool.make("poll-tools", {
+	description: trim`
+      Poll tool calls running in the background.
+      Set wait to true to wait for the tool call to complete before returning.
+      Only set wait to true if you dont have other tasks to perform in parallel.
+      Set an appropriate timeout to avoid waiting forever.
+      You will also be notified about the job completion separatelly, so you do not always need to inspect the job if you dont need the result right now.
+    `,
+	parameters: {
+		ids: Schema.Array(Schema.String).annotations({ description: "The IDs of the jobs to inspect." }),
+		wait: Schema.optional(Schema.Boolean).annotations({
+			description: "Whether to wait for the tool call to complete before returning.",
+			default: false
+		}),
+		timeout: Schema.optional(Schema.Number).annotations({
+			description: "Maximum time to wait for the job to complete. If the job does not complete within the timeout, the current state is returned.",
+			default: 1e4
+		})
+	}
+})) {};
+var AsynchronousExectionToolkitLayer = AsynchronousExectionToolkit.toLayer(Effect.gen(function* () {
+	const invoker = yield* ProcessManager.ProcessOperationInvoker.Service;
+	return { "poll-tools": ({ ids, wait, timeout = 1e4 }) => Effect.gen(function* () {
+		return yield* Effect.forEach(ids, (pid) => invoker.attachFiber(Process.ID.make(pid)).pipe(Effect.flatMap((_) => _.await), Effect.timeout(Duration.millis(timeout)), Effect.flatMap(Exit.match({
+			onSuccess: (value) => Effect.succeed(toolResultResponse(pid, value)),
+			onFailure: (cause) => Effect.succeed(toolErrorResponse(pid, Cause.pretty(cause)))
+		})), Effect.catchTag("ProcessNotFoundError", () => Effect.succeed(`Process not found: ${pid}`)), Effect.catchTag("TimeoutException", () => Effect.succeed(`Process still running: ${pid}`))));
+	}) };
+}));
+/**
+* Instructs model that the tool is running in the background.
+*/
+var toolIsRunningInBackgroundResponse = (pid) => `Tool is running in the background (id=${pid}); wait for the completion notification to get the result.`;
+var toolResultResponse = (pid, value) => `<result pid=${pid}>${JSON.stringify(value)}</result>`;
+var toolErrorResponse = (pid, cause) => `<error pid=${pid}>${cause}</error>`;
+//#endregion
+//#region src/agent-service/AgentService.ts
+var AgentService_exports = /* @__PURE__ */ __exportAll({
+	createSession: () => createSession,
+	layer: () => layer
+});
+var __dxlog_file = "/__w/dxos/dxos/packages/core/compute/agent-runtime/src/agent-service/AgentService.ts";
+var isTerminalProcess = (state) => state === Process.State.SUCCEEDED || state === Process.State.FAILED || state === Process.State.TERMINATED;
+var createSession = Effect.fn("createSession")(function* (opts) {
+	const skills = yield* Effect.forEach(opts?.skills ?? [], (skill) => Skill.upsert(Skill.getKey(skill)).pipe(Effect.map(Ref.make)));
+	const feed = yield* Database.add(Feed.make());
+	const runtime = yield* Effect.runtime();
+	const binder = yield* EffectEx.acquireReleaseResource(() => new AiContext.Binder({
+		feed,
+		runtime
+	}));
+	yield* Effect.promise(() => binder.bind({
+		skills,
+		objects: opts?.context ?? []
+	}));
+	return yield* getSession(feed, {
+		model: opts?.model,
+		provider: opts?.provider
+	});
+}, Effect.scoped);
+var layer = (opts) => Layer.effect(AgentService$1, Effect.gen(function* () {
+	const processManager = yield* ProcessManager.Service;
+	const sessionCache = /* @__PURE__ */ new Map();
+	const makeExecutable = (model, provider) => AgentProcess({
+		systemPrompt: opts?.systemPrompt,
+		model: model ?? opts?.model,
+		provider: provider ?? opts?.provider,
+		getMcpServers: opts?.getMcpServers,
+		enableToolBackgrounding: opts?.enableToolBackgrounding,
+		delegationStrategy: opts?.delegationStrategy
+	});
+	return {
+		getSession: (feed, options) => Effect.gen(function* () {
+			const model = options?.model ?? opts?.model;
+			const provider = options?.provider ?? opts?.provider;
+			const instructions = options?.instructions?.uri;
+			const cached = sessionCache.get(feed.id);
+			if (cached) {
+				if (cached.model === model && cached.provider === provider && cached.instructions === instructions && !isTerminalProcess(cached.handle.status.state)) return cached.session;
+				if (!isTerminalProcess(cached.handle.status.state)) yield* cached.handle.terminate();
+				sessionCache.delete(feed.id);
+			}
+			const target = Obj.getURI(feed);
+			const parsedEchoUri = EID.tryParse(target);
+			const spaceId = parsedEchoUri ? EID.getSpaceId(parsedEchoUri) : void 0;
+			const executable = makeExecutable(model, provider);
+			let activeProcess = (yield* processManager.list({
+				target,
+				key: executable.key
+			})).find((process) => !isTerminalProcess(process.status.state));
+			if (activeProcess) {
+				if (Option.getOrUndefined(Annotation.getDictionary(activeProcess.params.annotations, Process.InstructionsAnnotation)) !== instructions) {
+					yield* activeProcess.terminate();
+					activeProcess = void 0;
+				}
+			}
+			let handle;
+			if (activeProcess) {
+				yield* activeProcess.hydrate(executable);
+				handle = activeProcess;
+			} else handle = yield* processManager.spawn(executable, {
+				name: "Agent",
+				target,
+				annotations: Annotation.buildDictionary((dictionary) => {
+					Annotation.setDictionary(dictionary, Process.HarnessHostAnnotation, true);
+					if (options?.instructions) Annotation.setDictionary(dictionary, Process.InstructionsAnnotation, options.instructions.uri);
+				}),
+				environment: {
+					...spaceId !== void 0 ? { space: spaceId } : {},
+					conversation: target
+				},
+				traceMeta: { conversation: Ref.make(feed) }
+			});
+			const releaseSession = () => {
+				sessionCache.delete(feed.id);
+			};
+			const session = makeSession(handle, feed, releaseSession);
+			sessionCache.set(feed.id, {
+				model,
+				provider,
+				instructions,
+				handle,
+				session
+			});
+			return session;
+		}),
+		hydrate: Effect.fnUntraced(function* () {
+			sessionCache.clear();
+			const executable = makeExecutable();
+			const agents = yield* processManager.list({ key: AGENT_PROCESS_KEY });
+			log("agent hydrate", { count: agents.length }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 140,
+				S: this
+			});
+			for (const agent of agents) yield* agent.hydrate(executable).pipe(Effect.catchAllCause((cause) => Effect.sync(() => log.warn("agent hydrate skipped", {
+				pid: agent.pid,
+				cause: Cause.pretty(cause)
+			}, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 146,
+				S: this
+			}))));
+		})
+	};
+}));
+var makeSession = (process, feed, releaseSession) => ({
+	feed,
+	getContext: () => Effect.gen(function* () {
+		const runtime = yield* Effect.runtime();
+		return (yield* EffectEx.acquireReleaseResource(() => new AiContext.Binder({
+			feed,
+			runtime
+		}))).getObjects().map((object) => Ref.make(object));
+	}).pipe(Effect.scoped),
+	addContext: (context) => Effect.gen(function* () {
+		const runtime = yield* Effect.runtime();
+		const binder = yield* EffectEx.acquireReleaseResource(() => new AiContext.Binder({
+			feed,
+			runtime
+		}));
+		yield* Effect.promise(() => binder.bind({
+			skills: [],
+			objects: context
+		}));
+	}).pipe(Effect.scoped),
+	submitPrompt: (prompt) => process.submitInput(prompt),
+	waitForCompletion: () => process.runUntilSettled(),
+	terminate: () => process.terminate().pipe(Effect.tap(() => Effect.sync(releaseSession))),
+	subscribeEphemeral: () => process.subscribeEphemeral()
+});
+//#endregion
+export { __exportAll as i, layer as n, AGENT_PROCESS_KEY as r, AgentService_exports as t };
+
+//# sourceMappingURL=chunk-AgentService.mjs.map