@dxos/agent-runtime 0.11.1 → 0.12.0-next-73daef452f1464b62efdbca75fb0067c1066f264

package/dist/lib/chunk-AgentService.mjs

@@ -3,22 +3,29 @@ 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 { AgentService, getSession } from "@dxos/compute/AgentService";
+import * as Process from "@dxos/compute/Process";
+import * as Skill from "@dxos/compute/Skill";
 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 Clock from "effect/Clock";
 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 * as Struct from "effect/Struct";
+import * as Tool from "effect/unstable/ai/Tool";
+import * as Toolkit from "effect/unstable/ai/Toolkit";
 import { AiService, OpaqueToolkit } from "@dxos/ai";
+import * as Credential from "@dxos/compute/Credential";
+import * as Instructions from "@dxos/compute/Instructions";
+import * as Operation from "@dxos/compute/Operation";
 import * as StorageService from "@dxos/compute/StorageService";
+import * as Trace from "@dxos/compute/Trace";
 import { ContentBlock } from "@dxos/types";
 import { trim } from "@dxos/util";
 //#region \0rolldown/runtime.js
@@ -33,6 +40,20 @@ var __exportAll = (all, no_symbols) => {
 	return target;
 };
 //#endregion
+//#region src/agent-service/turn-producer.ts
+/**
+* The default producer: `AiSession.Session`, which resolves the model, binds skills and context
+* objects as tools, and appends each message to the feed via its `onOutput` hook.
+*/
+var makeAiSessionTurnProducer = ({ feed, runtime, instructions }) => EffectEx.acquireReleaseResource(() => new AiSession.Session({
+	feed,
+	runtime,
+	instructions
+})).pipe(Effect.map((session) => ({
+	runTurn: (params) => session.createRequest(params),
+	getSkills: () => session.context.getSkills()
+})));
+//#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";
@@ -42,7 +63,7 @@ var AGENT_PROCESS_KEY = "org.dxos.testing.process.agent";
 */
 var AgentProcess = (options) => Process.make({
 	key: AGENT_PROCESS_KEY,
-	input: Schema.Union(Schema.String, Schema.Array(ContentBlock.Any)),
+	input: Schema.Union([Schema.String, Schema.Array(ContentBlock.Any)]),
 	output: Schema.Void,
 	services: [
 		Database.Service,
@@ -61,38 +82,38 @@ var AgentProcess = (options) => Process.make({
 	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({
+	const runtime = yield* Effect.context();
+	const session = yield* (options.makeTurnProducer ?? makeAiSessionTurnProducer)({
 		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 clock = yield* Clock.Clock;
 	const alarmManager = new AlarmManager({
 		storageService,
 		setAlarm: (timeout) => ctx.setAlarm(timeout),
-		now: () => clock.unsafeCurrentTimeMillis()
+		now: () => clock.currentTimeMillisUnsafe()
 	});
 	yield* alarmManager.load();
 	yield* toolCallManager.reconcileWithInputQueue(inputQueue);
-	const strategy = Option.fromNullable(options.delegationStrategy);
+	const strategy = Option.fromNullishOr(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(),
+			skills: session.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);
+				if (Exit.isFailure(exit)) return yield* Effect.failCause(exit.cause);
 			}).pipe(Effect.asVoid, Effect.orDie)
 		});
 	});
@@ -113,7 +134,7 @@ var AgentProcess = (options) => Process.make({
 			log("agent work enqueued by end-request hook, continuing", void 0, {
 				"~LogMeta": "~LogMeta",
 				F: __dxlog_file$1,
-				L: 193,
+				L: 205,
 				S: this
 			});
 			alarmManager.reconcile(true);
@@ -122,13 +143,13 @@ var AgentProcess = (options) => Process.make({
 		log("agent work complete, succeeding", void 0, {
 			"~LogMeta": "~LogMeta",
 			F: __dxlog_file$1,
-			L: 198,
+			L: 210,
 			S: this
 		});
 		ctx.succeed();
 	});
 	return {
-		rpcHandlers: yield* HarnessControl.toHandlersContext({
+		rpcHandlers: yield* HarnessControl.toHandlers({
 			setAlarm: Effect.fn(function* ({ at, message }) {
 				yield* alarmManager.setWakeAt(DateTime.toEpochMillis(at), message);
 				alarmManager.reconcile(inputQueue.length > 0);
@@ -146,7 +167,7 @@ var AgentProcess = (options) => Process.make({
 			log("agent onInput received", { backlog: inputQueue.length }, {
 				"~LogMeta": "~LogMeta",
 				F: __dxlog_file$1,
-				L: 217,
+				L: 229,
 				S: this
 			});
 			const content = typeof prompt === "string" ? [ContentBlock.Text.make({ text: prompt })] : [...prompt];
@@ -157,21 +178,21 @@ var AgentProcess = (options) => Process.make({
 			log("agent onInput persisting queue", { depth: inputQueue.length }, {
 				"~LogMeta": "~LogMeta",
 				F: __dxlog_file$1,
-				L: 220,
+				L: 232,
 				S: this
 			});
 			yield* AgentEventsCell.set(inputQueue);
 			log("agent onInput persisted", { depth: inputQueue.length }, {
 				"~LogMeta": "~LogMeta",
 				F: __dxlog_file$1,
-				L: 222,
+				L: 234,
 				S: this
 			});
 			alarmManager.reconcile(true);
 			log("agent onInput alarm scheduled", void 0, {
 				"~LogMeta": "~LogMeta",
 				F: __dxlog_file$1,
-				L: 224,
+				L: 236,
 				S: this
 			});
 		}),
@@ -179,7 +200,7 @@ var AgentProcess = (options) => Process.make({
 			log("agent onAlarm fired", { pending: inputQueue.length }, {
 				"~LogMeta": "~LogMeta",
 				F: __dxlog_file$1,
-				L: 228,
+				L: 240,
 				S: this
 			});
 			const fired = yield* alarmManager.takeFiredAlarm();
@@ -187,7 +208,7 @@ var AgentProcess = (options) => Process.make({
 				log("agent onAlarm self-wake", { firedAt: fired.firedAt }, {
 					"~LogMeta": "~LogMeta",
 					F: __dxlog_file$1,
-					L: 233,
+					L: 245,
 					S: this
 				});
 				inputQueue.push({
@@ -197,26 +218,18 @@ var AgentProcess = (options) => Process.make({
 				});
 				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;
-			}
+			for (const pid of dropReportedToolResults(inputQueue, (pid) => toolCallManager.isReported(pid))) log.info("skip tool result that was reported synchronously", { pid }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 251,
+				S: this
+			});
 			const item = inputQueue.shift();
 			if (!item) {
 				log("agent onAlarm empty queue", {}, {
 					"~LogMeta": "~LogMeta",
 					F: __dxlog_file$1,
-					L: 251,
+					L: 256,
 					S: this
 				});
 				alarmManager.reconcile(false);
@@ -227,44 +240,35 @@ var AgentProcess = (options) => Process.make({
 			log("agent onAlarm handling", { tag: item._tag }, {
 				"~LogMeta": "~LogMeta",
 				F: __dxlog_file$1,
-				L: 258,
+				L: 263,
 				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);
+			const prompt = agentEventToPrompt(item);
 			log("begin request", { prompt }, {
 				"~LogMeta": "~LogMeta",
 				F: __dxlog_file$1,
-				L: 283,
+				L: 267,
 				S: this
 			});
 			log("trace agent request begin", void 0, {
 				"~LogMeta": "~LogMeta",
 				F: __dxlog_file$1,
-				L: 284,
+				L: 268,
 				S: this
 			});
 			yield* Trace.write(AgentRequestBegin, {});
-			yield* session.createRequest({
+			yield* session.runTurn({
 				prompt,
 				system: options.systemPrompt,
 				mcpServers: options.getMcpServers?.()
 			}).pipe(Effect.onExit((exit) => Trace.write(AgentRequestEnd, {
-				status: Exit.isSuccess(exit) ? "success" : Exit.isInterrupted(exit) ? "interrupted" : "error",
+				status: Exit.isSuccess(exit) ? "success" : Exit.hasInterrupts(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,
+				L: 288,
 				S: this
 			});
 			yield* AgentEventsCell.set(inputQueue);
@@ -283,7 +287,7 @@ var AgentProcess = (options) => Process.make({
 					}, {
 						"~LogMeta": "~LogMeta",
 						F: __dxlog_file$1,
-						L: 315,
+						L: 299,
 						S: this
 					});
 				}
@@ -300,7 +304,7 @@ var AgentProcess = (options) => Process.make({
 			log("childEvent", { event }, {
 				"~LogMeta": "~LogMeta",
 				F: __dxlog_file$1,
-				L: 341,
+				L: 325,
 				S: this
 			});
 			if (event._tag === "exited") {
@@ -309,7 +313,28 @@ var AgentProcess = (options) => Process.make({
 					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);
+					if (Option.isSome(strategy)) {
+						yield* strategy.value.onComplete(feed, delegation.id, exit);
+						const activeIds = new Set(delegations.map((delegation) => delegation.id));
+						const pending = yield* strategy.value.reconcile(feed, activeIds);
+						for (const next of pending) {
+							const pid = yield* next.spawn;
+							delegations.push({
+								pid,
+								id: next.id
+							});
+							log("delegated work", {
+								pid,
+								id: next.id
+							}, {
+								"~LogMeta": "~LogMeta",
+								F: __dxlog_file$1,
+								L: 347,
+								S: this
+							});
+						}
+						if (pending.length > 0) yield* DelegationsCell.set(delegations);
+					}
 					log("delegated work completed", {
 						pid: event.pid,
 						id: delegation.id,
@@ -317,7 +342,7 @@ var AgentProcess = (options) => Process.make({
 					}, {
 						"~LogMeta": "~LogMeta",
 						F: __dxlog_file$1,
-						L: 356,
+						L: 353,
 						S: this
 					});
 					yield* maybeComplete;
@@ -328,7 +353,7 @@ var AgentProcess = (options) => Process.make({
 							log.verbose("childEvent skipped (process gone, result already handled)", { pid: event.pid }, {
 								"~LogMeta": "~LogMeta",
 								F: __dxlog_file$1,
-								L: 369,
+								L: 366,
 								S: this
 							});
 							return;
@@ -356,7 +381,7 @@ var AgentProcess = (options) => Process.make({
 					}, {
 						"~LogMeta": "~LogMeta",
 						F: __dxlog_file$1,
-						L: 394,
+						L: 391,
 						S: this
 					});
 					yield* AgentEventsCell.set(inputQueue);
@@ -364,28 +389,32 @@ var AgentProcess = (options) => Process.make({
 					log("agent onChildEvent alarm scheduled", { depth: inputQueue.length }, {
 						"~LogMeta": "~LogMeta",
 						F: __dxlog_file$1,
-						L: 397,
+						L: 394,
 						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,
+					L: 396,
 					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(() => []));
+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.fromJsonString(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.
@@ -393,13 +422,13 @@ var AgentEventsCell = StorageService.cell(Schema.parseJson(Schema.Array(AgentEve
 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(() => []));
+}).mapFields(Struct.map(Schema.mutableKey));
+var DelegationsCell = StorageService.cell(Schema.fromJsonString(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: [] })));
+}).mapFields(Struct.map(Schema.mutableKey))).pipe(Schema.mutable) });
+var ToolCallStateCell = StorageService.cell(Schema.fromJsonString(ToolCallState.mapFields(Struct.map(Schema.mutableKey))), "toolCallState").pipe(StorageService.withDefault(() => ({ activeCalls: [] })));
 var ToolCallManager = class {
 	#storageService;
 	#state = { activeCalls: [] };
@@ -407,12 +436,12 @@ var ToolCallManager = class {
 		this.#storageService = storageService;
 	}
 	load() {
-		return Effect.gen(this, function* () {
+		return Effect.gen({ self: this }, function* () {
 			this.#state = yield* ToolCallStateCell.get;
 		}).pipe(Effect.provideService(StorageService.StorageService, this.#storageService));
 	}
 	beginCall(pid) {
-		return Effect.gen(this, function* () {
+		return Effect.gen({ self: this }, function* () {
 			this.#state.activeCalls.push({
 				pid,
 				reported: false
@@ -421,7 +450,7 @@ var ToolCallManager = class {
 		}).pipe(Effect.provideService(StorageService.StorageService, this.#storageService));
 	}
 	markAsReported(pid) {
-		return Effect.gen(this, function* () {
+		return Effect.gen({ self: this }, function* () {
 			const call = this.#state.activeCalls.find((call) => call.pid === pid);
 			if (!call) return;
 			call.reported = true;
@@ -443,7 +472,7 @@ var ToolCallManager = class {
 	* After reload the in-flight createRequest is gone, so those results must be redelivered via onAlarm.
 	*/
 	reconcileWithInputQueue(queue) {
-		return Effect.gen(this, function* () {
+		return Effect.gen({ self: this }, function* () {
 			let changed = false;
 			for (const item of queue) {
 				if (item._tag !== "tool_result") continue;
@@ -454,7 +483,7 @@ var ToolCallManager = class {
 					log("reconcile queued tool result", { pid: item.pid }, {
 						"~LogMeta": "~LogMeta",
 						F: __dxlog_file$1,
-						L: 537,
+						L: 535,
 						S: this
 					});
 				}
@@ -466,10 +495,43 @@ var ToolCallManager = class {
 /** 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();
 /**
+* Discards tool results at the head of the queue whose values already reached the agent.
+*
+* A tool that returned inside its turn is reported synchronously AND left queued; after a reload the
+* queue is replayed, so without this the model would be handed a result it has already seen. Only the
+* head is examined: a result further back belongs to a turn that has not run yet.
+*
+* Mutates `queue` and returns the pids dropped, so the caller owns the logging.
+*/
+var dropReportedToolResults = (queue, isReported) => {
+	const dropped = [];
+	while (queue.length > 0) {
+		const head = queue[0];
+		if (head._tag !== "tool_result" || !isReported(head.pid)) break;
+		queue.shift();
+		dropped.push(head.pid);
+	}
+	return dropped;
+};
+/**
+* Renders a queued event as the next turn's prompt.
+*
+* A tool result recovered across a reload is redelivered as a synthetic `<result pid=N>` TEXT block
+* rather than a tool-result part, because the request it belonged to is gone and its tool-call id
+* cannot be answered. `disposition: 'synthetic'` keeps it out of the user-visible transcript.
+*/
+var agentEventToPrompt = (event) => Match.value(event).pipe(Match.tag("prompt", (event) => [...event.content]), Match.tag("tool_result", (event) => [ContentBlock.Text.make({
+	text: event.isError ? toolErrorResponse(event.pid, event.result) : toolResultResponse(event.pid, event.result),
+	disposition: "synthetic"
+})]), Match.tag("alarm", (event) => [ContentBlock.Text.make({
+	text: wakeUpPrompt(event.firedAt, event.message),
+	disposition: "synthetic"
+})]), Match.exhaustive);
+/**
 * 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({
+var AgentAlarmCell = StorageService.cell(Schema.fromJsonString(Schema.NullOr(Schema.Struct({
 	wakeAt: Schema.Number,
 	message: Schema.NullOr(Schema.String)
 }))), "agentAlarm").pipe(StorageService.withDefault(() => null));
@@ -512,7 +574,7 @@ var AlarmManager = class {
 	}
 	/** Restores the persisted alarm state. */
 	load() {
-		return Effect.gen(this, function* () {
+		return Effect.gen({ self: this }, function* () {
 			const persisted = yield* AgentAlarmCell.get;
 			this.#wakeAt = persisted?.wakeAt ?? null;
 			this.#message = persisted?.message ?? null;
@@ -520,7 +582,7 @@ var AlarmManager = class {
 	}
 	/** Records a new self-wake target (with an optional reminder message) and persists it. */
 	setWakeAt(wakeAt, message = null) {
-		return Effect.gen(this, function* () {
+		return Effect.gen({ self: this }, function* () {
 			this.#wakeAt = wakeAt;
 			this.#message = message;
 			yield* AgentAlarmCell.set({
@@ -534,7 +596,7 @@ var AlarmManager = class {
 	* reminder message it carried (or `null` if no alarm was due).
 	*/
 	takeFiredAlarm() {
-		return Effect.gen(this, function* () {
+		return Effect.gen({ self: this }, function* () {
 			if (this.#wakeAt == null || this.#now() < this.#wakeAt) return null;
 			const firedAt = this.#wakeAt;
 			const message = this.#message;
@@ -571,7 +633,7 @@ var wakeUpPrompt = (firedAt, message) => message != null ? 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* () {
+var ToolExecutionService = ({ enableBackgrounding, backgroundThreshold = Duration.seconds(1), toolCallManager, feed }) => Layer.unwrap(Effect.gen(function* () {
 	const operationInvoker = yield* ProcessManager.ProcessOperationInvoker.Service;
 	return makeToolExecutionService({ invoke: (tool, input) => Effect.gen(function* () {
 		const operationDef = getOperationFromTool(tool).pipe(Option.getOrThrow);
@@ -581,7 +643,7 @@ var ToolExecutionService = ({ enableBackgrounding, backgroundThreshold = Duratio
 		}, {
 			"~LogMeta": "~LogMeta",
 			F: __dxlog_file$1,
-			L: 723,
+			L: 770,
 			S: this
 		});
 		const fiber = yield* operationInvoker.invokeFiber(operationDef, input, {
@@ -596,15 +658,15 @@ var ToolExecutionService = ({ enableBackgrounding, backgroundThreshold = Duratio
 		}, {
 			"~LogMeta": "~LogMeta",
 			F: __dxlog_file$1,
-			L: 733,
+			L: 780,
 			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;
+		const result = enableBackgrounding ? yield* awaitWithReport.pipe(Effect.timeout(backgroundThreshold), Effect.catchTag("TimeoutError", () => Effect.succeed(Exit.succeed(toolIsRunningInBackgroundResponse(fiber.pid))))) : yield* awaitWithReport;
 		log("result", { result }, {
 			"~LogMeta": "~LogMeta",
 			F: __dxlog_file$1,
-			L: 744,
+			L: 791,
 			S: this
 		});
 		return yield* result;
@@ -618,17 +680,17 @@ var AsynchronousExectionToolkit = class extends Toolkit.make(Tool.make("poll-too
       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({
+	parameters: Schema.Struct({
+		ids: Schema.Array(Schema.String).annotate({ description: "The IDs of the jobs to inspect." }),
+		wait: Schema.optional(Schema.Boolean).annotate({
 			description: "Whether to wait for the tool call to complete before returning.",
 			default: false
 		}),
-		timeout: Schema.optional(Schema.Number).annotations({
+		timeout: Schema.optional(Schema.Number).annotate({
 			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;
@@ -636,7 +698,7 @@ var AsynchronousExectionToolkitLayer = AsynchronousExectionToolkit.toLayer(Effec
 		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}`))));
+		})), Effect.catchTag("ProcessNotFoundError", () => Effect.succeed(`Process not found: ${pid}`)), Effect.catchTag("TimeoutError", () => Effect.succeed(`Process still running: ${pid}`))));
 	}) };
 }));
 /**
@@ -656,7 +718,7 @@ var isTerminalProcess = (state) => state === Process.State.SUCCEEDED || state ==
 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 runtime = yield* Effect.context();
 	const binder = yield* EffectEx.acquireReleaseResource(() => new AiContext.Binder({
 		feed,
 		runtime
@@ -670,11 +732,12 @@ var createSession = Effect.fn("createSession")(function* (opts) {
 		provider: opts?.provider
 	});
 }, Effect.scoped);
-var layer = (opts) => Layer.effect(AgentService$1, Effect.gen(function* () {
+var layer = (opts) => Layer.effect(AgentService, Effect.gen(function* () {
 	const processManager = yield* ProcessManager.Service;
 	const sessionCache = /* @__PURE__ */ new Map();
 	const makeExecutable = (model, provider) => AgentProcess({
 		systemPrompt: opts?.systemPrompt,
+		makeTurnProducer: opts?.makeTurnProducer,
 		model: model ?? opts?.model,
 		provider: provider ?? opts?.provider,
 		getMcpServers: opts?.getMcpServers,
@@ -743,16 +806,16 @@ var layer = (opts) => Layer.effect(AgentService$1, Effect.gen(function* () {
 			log("agent hydrate", { count: agents.length }, {
 				"~LogMeta": "~LogMeta",
 				F: __dxlog_file,
-				L: 140,
+				L: 150,
 				S: this
 			});
-			for (const agent of agents) yield* agent.hydrate(executable).pipe(Effect.catchAllCause((cause) => Effect.sync(() => log.warn("agent hydrate skipped", {
+			for (const agent of agents) yield* agent.hydrate(executable).pipe(Effect.catchCause((cause) => Effect.sync(() => log.warn("agent hydrate skipped", {
 				pid: agent.pid,
 				cause: Cause.pretty(cause)
 			}, {
 				"~LogMeta": "~LogMeta",
 				F: __dxlog_file,
-				L: 146,
+				L: 156,
 				S: this
 			}))));
 		})
@@ -761,14 +824,14 @@ var layer = (opts) => Layer.effect(AgentService$1, Effect.gen(function* () {
 var makeSession = (process, feed, releaseSession) => ({
 	feed,
 	getContext: () => Effect.gen(function* () {
-		const runtime = yield* Effect.runtime();
+		const runtime = yield* Effect.context();
 		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 runtime = yield* Effect.context();
 		const binder = yield* EffectEx.acquireReleaseResource(() => new AiContext.Binder({
 			feed,
 			runtime
@@ -784,6 +847,6 @@ var makeSession = (process, feed, releaseSession) => ({
 	subscribeEphemeral: () => process.subscribeEphemeral()
 });
 //#endregion
-export { __exportAll as i, layer as n, AGENT_PROCESS_KEY as r, AgentService_exports as t };
+export { __exportAll as a, makeAiSessionTurnProducer as i, layer as n, AGENT_PROCESS_KEY as r, AgentService_exports as t };
 
 //# sourceMappingURL=chunk-AgentService.mjs.map