@codeworksh/harness 0.2.0-dev.20261013041531 → 0.2.0-dev.20261013121551

package/effect.mjs

@@ -1,10 +1,10 @@
 import { n as __reExport, t as __exportAll } from "./rolldown-runtime-B4FMCO8f.mjs";
 import { a as io_exports, i as errors_exports, n as shell_exports, o as instance_exports, r as filesystem_exports, s as posix } from "./resource-DFZh0e-s.mjs";
-import "./daytona-ByTHZelc.mjs";
+import "./daytona-D4sNwzSr.mjs";
 import "./vercel-3GouQSJI.mjs";
 import { a as decode, n as dimensionNote, o as load$4, r as resize } from "./resize-Dwv5dCgY.mjs";
 import { createRequire, registerHooks } from "node:module";
-import { Cause, Clock, Config, Context, Crypto, DateTime, Deferred, Duration, Effect, Exit, Fiber, FiberSet, FileSystem, Layer, LayerMap, Option, Path, Predicate, PubSub, Queue, Random, Ref, Result, Schedule, Schema, SchemaIssue, Scope, Semaphore, Stream, String as String$1 } from "effect";
+import { Cause, Clock, Config, Context, Crypto, Data, DateTime, Deferred, Duration, Effect, Exit, Fiber, FiberSet, FileSystem, Layer, LayerMap, Metric, Option, Path, Predicate, PubSub, Queue, Random, Ref, Result, Schedule, Schema, SchemaIssue, Scope, Semaphore, Stream, String as String$1 } from "effect";
 import { Message, Model, getEnvApiKey, llm, normalizeOptionalNulls, stream } from "@codeworksh/aikit";
 import { MessageID as ID, SessionID as ID$1 } from "@codeworksh/plugin/ids";
 import { Migrator, SqlClient, SqlClient as SqlClient$1, SqlError, SqlSchema, SqlSchema as SqlSchema$1 } from "effect/sql";
@@ -2643,6 +2643,114 @@ const layer$22 = Layer.effect(Service$13, Effect.gen(function* () {
 	return Service$13.of({ assemble });
 }));
 //#endregion
+//#region src/telemetry/telemetry.ts
+const durationBuckets = Metric.boundariesFromIterable([
+	.01,
+	.02,
+	.04,
+	.08,
+	.16,
+	.32,
+	.64,
+	1.28,
+	2.56,
+	5.12,
+	10.24,
+	20.48,
+	40.96,
+	81.92
+]);
+const llmDuration = Metric.histogram("codework.llm.duration", {
+	description: "Provider request duration",
+	attributes: { unit: "s" },
+	boundaries: durationBuckets
+});
+const llmTtft = Metric.histogram("codework.llm.ttft", {
+	description: "Time to first token: from request start to the first streamed content",
+	attributes: { unit: "s" },
+	boundaries: Metric.boundariesFromIterable([
+		.001,
+		.005,
+		.01,
+		.02,
+		.04,
+		.06,
+		.08,
+		.1,
+		.25,
+		.5,
+		.75,
+		1,
+		2.5,
+		5,
+		7.5,
+		10
+	])
+});
+const llmTokens = Metric.counter("codework.llm.tokens", {
+	description: "Tokens used, by type; cache and reasoning tokens are part of input and output",
+	attributes: { unit: "{token}" },
+	incremental: true
+});
+const llmCost = Metric.counter("codework.llm.cost", {
+	description: "Provider request cost from the model catalog's prices",
+	attributes: { unit: "USD" },
+	incremental: true
+});
+const agentDuration = Metric.histogram("codework.agent.duration", {
+	description: "Session run duration, across every turn it drains",
+	attributes: { unit: "s" },
+	boundaries: Metric.boundariesFromIterable([
+		.1,
+		.2,
+		.4,
+		.8,
+		1.6,
+		3.2,
+		6.4,
+		12.8,
+		25.6,
+		51.2,
+		102.4,
+		204.8,
+		409.6
+	])
+});
+const toolDuration = Metric.histogram("codework.tool.duration", {
+	description: "Tool execution duration",
+	attributes: { unit: "s" },
+	boundaries: durationBuckets
+});
+const sandboxProvisionDuration = Metric.histogram("codework.sandbox.provision.duration", {
+	description: "Sandbox driver create and wake duration",
+	attributes: { unit: "s" },
+	boundaries: durationBuckets
+});
+const sandboxExecDuration = Metric.histogram("codework.sandbox.exec.duration", {
+	description: "Sandbox shell command duration",
+	attributes: { unit: "s" },
+	boundaries: durationBuckets
+});
+const sandboxActive = Metric.gauge("codework.sandbox.active", {
+	description: "Managed and remote sandboxes with at least one mount",
+	attributes: { unit: "{sandbox}" }
+});
+const record$1 = (metric, value, attributes) => Metric.update(Metric.withAttributes(metric, attributes), value);
+const adjust = (metric, delta, attributes) => Metric.modify(Metric.withAttributes(metric, attributes), delta);
+const errorType = (cause) => {
+	if (Cause.hasInterruptsOnly(cause)) return "interrupted";
+	const error = Cause.squash(cause);
+	return typeof error === "object" && error !== null && "_tag" in error && typeof error._tag === "string" ? error._tag : "_OTHER";
+};
+const withError = (attributes, exit) => Exit.isSuccess(exit) ? attributes : {
+	...attributes,
+	error: errorType(exit.cause)
+};
+const timed = (self, observe) => Effect.clockWith((clock) => {
+	const start = clock.currentTimeMillisUnsafe();
+	return self.pipe(Effect.onExit((exit) => observe((clock.currentTimeMillisUnsafe() - start) / 1e3, exit)));
+});
+//#endregion
 //#region src/sandbox/driver.ts
 var driver_exports = /* @__PURE__ */ __exportAll({});
 import * as import__codeworksh_plugin_sandbox_driver from "@codeworksh/plugin/sandbox/driver";
@@ -3029,6 +3137,22 @@ const parseJson = (driver, operation, value) => decodeUnknownJson(value).pipe(Ef
 	operation,
 	cause
 })));
+const provision = (driver, operation, self) => timed(self, (seconds, exit) => record$1(sandboxProvisionDuration, seconds, withError({
+	driver,
+	operation
+}, exit)));
+const timedShell = (shell, driver) => {
+	const time = (self) => timed(self, (seconds, exit) => record$1(sandboxExecDuration, seconds, withError({ driver }, exit)));
+	const stream = shell.stream;
+	return {
+		exec: (command, options) => time(shell.exec(command, options)),
+		execArgv: (argv, options) => time(shell.execArgv(argv, options)),
+		...stream === void 0 ? {} : { stream: (command, options) => Stream.unwrap(Effect.clockWith((clock) => {
+			const start = clock.currentTimeMillisUnsafe();
+			return Effect.succeed(stream(command, options).pipe(Stream.onExit((exit) => record$1(sandboxExecDuration, (clock.currentTimeMillisUnsafe() - start) / 1e3, withError({ driver }, exit)))));
+		})) }
+	};
+};
 const make$14 = Effect.fn("Sandbox.Controller.make")(function* (options) {
 	const sql = yield* SqlClient.SqlClient;
 	const registry = yield* Registry;
@@ -3039,20 +3163,22 @@ const make$14 = Effect.fn("Sandbox.Controller.make")(function* (options) {
 	const hostCreatedAt = asDate(yield* DateTime.now);
 	const refCount = (id) => refs.get(id) ?? 0;
 	const usage = (id, count = refCount(id)) => id === instance_exports.SandboxInstance.ID.local ? "pinned" : count > 0 ? "busy" : "idle";
+	const activeChanged = (lease, delta) => lease.driver === void 0 ? Effect.void : adjust(sandboxActive, delta, { driver: lease.driver });
 	const acquireLease = (id, lease) => gate.withPermits(1)(Effect.sync(() => {
 		const wasIdle = refCount(id) === 0;
 		refs.set(id, refCount(id) + 1);
 		lease.held = true;
 		return wasIdle;
-	}));
+	})).pipe(Effect.tap((wasIdle) => wasIdle ? activeChanged(lease, 1) : Effect.void));
 	const releaseLease = (id, lease) => Effect.gen(function* () {
 		if (!lease.held) return;
-		yield* gate.withPermits(1)(Effect.sync(() => {
+		if (yield* gate.withPermits(1)(Effect.sync(() => {
 			const next = Math.max(0, refCount(id) - 1);
 			if (next === 0) refs.delete(id);
 			else refs.set(id, next);
 			lease.held = false;
-		}));
+			return next === 0;
+		}))) yield* activeChanged(lease, -1);
 		if (!lease.mounted) return;
 		const now = yield* Effect.clockWith((clock) => clock.currentTimeMillis);
 		yield* sql`
@@ -3222,7 +3348,7 @@ const make$14 = Effect.fn("Sandbox.Controller.make")(function* (options) {
 		const attached = yield* runtime(row, "resolveCwd");
 		return driver_exports.SandboxDriver.AbsolutePath.make(io_exports.SandboxIO.resolveMountCwd(attached.input.runtimeConfig.defaultCwd, override));
 	});
-	const create = Effect.fn("Sandbox.Controller.create")(function* (input) {
+	const create = Effect.fn("Sandbox.Controller.create", { level: "Info" })(function* (input) {
 		const driver = yield* registry.get(input.driver.name);
 		const config = yield* registry.decodeCreateConfig(input.driver.name, input.config);
 		const id = input.instanceId ?? instance_exports.SandboxInstance.ID.create();
@@ -3238,10 +3364,10 @@ const make$14 = Effect.fn("Sandbox.Controller.make")(function* (options) {
 			status: "provisioning",
 			metadata: input.metadata
 		});
-		const provisioned = yield* driver.create({
+		const provisioned = yield* provision(driver.name, "create", driver.create({
 			instanceId: id,
 			config
-		}).pipe(Effect.catch((error) => persistProviderFailure(id, "faulted", error)));
+		})).pipe(Effect.catch((error) => persistProviderFailure(id, "faulted", error)));
 		return yield* Effect.gen(function* () {
 			const encoded = yield* registry.encodeRuntimeConfig(driver.name, provisioned.runtimeConfig);
 			const runtimeConfig = yield* encodeUnknownJson$1(encoded).pipe(Effect.mapError((cause) => (0, errors_exports.providerError)({
@@ -3330,7 +3456,8 @@ const make$14 = Effect.fn("Sandbox.Controller.make")(function* (options) {
 		let invalidateBeforeAttach = false;
 		const lease = reserved ?? {
 			held: false,
-			mounted: false
+			mounted: false,
+			driver: void 0
 		};
 		if (id === instance_exports.SandboxInstance.ID.local) identity = {
 			id,
@@ -3355,6 +3482,7 @@ const make$14 = Effect.fn("Sandbox.Controller.make")(function* (options) {
 			});
 			invalidateBeforeAttach = row.status !== "online";
 			const attached = yield* runtime(row, "mount");
+			lease.driver = attached.driver.name;
 			identity = {
 				id,
 				driver: attached.driver.name,
@@ -3377,7 +3505,10 @@ const make$14 = Effect.fn("Sandbox.Controller.make")(function* (options) {
 				lease.held = true;
 				return idle;
 			}));
-			if (reserved === void 0) yield* Effect.addFinalizer(() => releaseLease(id, lease));
+			if (reserved === void 0) {
+				yield* Effect.addFinalizer(() => releaseLease(id, lease));
+				if (wasIdle) yield* activeChanged(lease, 1);
+			}
 			if (wasIdle && invalidateBeforeAttach) yield* transports.invalidate(id);
 		}
 		const handleTransportError = (error) => {
@@ -3407,7 +3538,7 @@ const make$14 = Effect.fn("Sandbox.Controller.make")(function* (options) {
 						WHERE id = ${id}
 					`.pipe(Effect.orDie);
 		}
-		return Layer.mergeAll(Layer.succeed(io_exports.SandboxIO.Current, identity), Layer.succeed(io_exports.SandboxIO.FileSystem, filesystem_exports.SandboxFileSystem.withCwd(fs, identity.cwd)), Layer.succeed(io_exports.SandboxIO.Shell, (0, shell_exports.withCwd)(shell, identity.cwd))).pipe(io_exports.SandboxIO.withMutation);
+		return Layer.mergeAll(Layer.succeed(io_exports.SandboxIO.Current, identity), Layer.succeed(io_exports.SandboxIO.FileSystem, filesystem_exports.SandboxFileSystem.withCwd(fs, identity.cwd)), Layer.succeed(io_exports.SandboxIO.Shell, timedShell((0, shell_exports.withCwd)(shell, identity.cwd), identity.driver))).pipe(io_exports.SandboxIO.withMutation);
 	}));
 	const mount = (id, mountOptions) => mountLayer(id, mountOptions);
 	const withMount = (id, use, mountOptions) => use.pipe(Effect.provide(mount(id, mountOptions)), Effect.scoped);
@@ -3434,7 +3565,7 @@ const make$14 = Effect.fn("Sandbox.Controller.make")(function* (options) {
 		});
 		return yield* reload(id);
 	});
-	const wake = Effect.fn("Sandbox.Controller.wake")(function* (id) {
+	const wake = Effect.fn("Sandbox.Controller.wake", { level: "Info" })(function* (id) {
 		if (id === instance_exports.SandboxInstance.ID.local) return hostInfo();
 		const row = yield* requireRow(id);
 		if (row.status === "removed") return yield* new errors_exports.SandboxRemovedError({
@@ -3448,7 +3579,7 @@ const make$14 = Effect.fn("Sandbox.Controller.make")(function* (options) {
 			operation: "wake"
 		});
 		if (refCount(id) === 0) yield* transports.invalidate(id);
-		const observed = yield* attached.driver.wake(attached.input).pipe(Effect.catch((error) => (0, errors_exports.providerErrorIsNotFound)(error) ? markUnavailable(id, error) : persistProviderFailure(id, "faulted", error)));
+		const observed = yield* provision(attached.driver.name, "wake", attached.driver.wake(attached.input)).pipe(Effect.catch((error) => (0, errors_exports.providerErrorIsNotFound)(error) ? markUnavailable(id, error) : persistProviderFailure(id, "faulted", error)));
 		yield* updateObservation({
 			id,
 			status: observed.status,
@@ -3607,7 +3738,8 @@ const make$14 = Effect.fn("Sandbox.Controller.make")(function* (options) {
 		const id = input.instanceId ?? instance_exports.SandboxInstance.ID.create();
 		const lease = {
 			held: false,
-			mounted: false
+			mounted: false,
+			driver: input.driver.name
 		};
 		return Layer.unwrap(Effect.gen(function* () {
 			yield* acquireLease(id, lease);
@@ -5650,7 +5782,7 @@ const ancestors = (directory) => {
 * Which of `paths` are files. Absence is the expected answer and stays silent; any other failure
 * (permissions, a remote blip) is logged so a dropped file is not a mystery, then counts as absent.
 */
-const present$1 = (fs, paths) => Effect.forEach(paths, (path) => fs.stat(path).pipe(Effect.map((stat) => stat.isFile), Effect.catch((error) => filesystem_exports.SandboxFileSystem.isNotFoundError(error.cause) ? Effect.succeed(false) : Effect.logWarning(`could not stat instruction file ${path}`, error.cause).pipe(Effect.as(false)))), { concurrency: "unbounded" }).pipe(Effect.map((hits) => new Set(paths.filter((_, index) => hits[index]))));
+const present$1 = (fs, paths) => Effect.forEach(paths, (path) => fs.exists(path).pipe(Effect.flatMap((exists) => exists ? fs.stat(path).pipe(Effect.map((stat) => stat.isFile)) : Effect.succeed(false)), Effect.catch((error) => filesystem_exports.SandboxFileSystem.isNotFoundError(error.cause) ? Effect.succeed(false) : Effect.logWarning(`could not stat instruction file ${path}`, error.cause).pipe(Effect.as(false)))), { concurrency: "unbounded" }).pipe(Effect.map((hits) => new Set(paths.filter((_, index) => hits[index]))));
 /** A file that stats but does not read falls through to the next candidate. */
 const first = Effect.fnUntraced(function* (fs, directory, files) {
 	for (const name of names) {
@@ -9800,31 +9932,116 @@ const openWith = (options = {}) => Effect.fn("LLM.open")(function* (input, signa
 	});
 });
 const open = openWith();
+const isProviderError = Schema.is(ProviderError);
+/** `error.type` for a request: the provider's failure reason, so a terminal and a thrown failure agree. */
+const requestErrorType = (input, exit) => {
+	if (Exit.isFailure(exit)) {
+		const error = Cause.squash(exit.cause);
+		return isProviderError(error) ? error.reason._tag : errorType(exit.cause);
+	}
+	if (exit.value.outcome === "ended") return void 0;
+	if (exit.value.reason === "aborted") return "aborted";
+	return providerError(input, messageFailure(exit.value.message)).reason._tag;
+};
+const observe = Effect.fnUntraced(function* (input, timing, exit, drained) {
+	const now = yield* Effect.clockWith((clock) => clock.currentTimeMillis);
+	const labels = {
+		provider: input.provider,
+		model: input.model
+	};
+	const errorType = requestErrorType(input, exit);
+	yield* record$1(llmDuration, (now - timing.start) / 1e3, errorType === void 0 ? labels : {
+		...labels,
+		error: errorType
+	});
+	if (timing.firstToken !== void 0) {
+		const ttft = (timing.firstToken - timing.start) / 1e3;
+		yield* record$1(llmTtft, ttft, labels);
+		yield* Effect.annotateCurrentSpan("gen_ai.response.time_to_first_chunk", ttft);
+	}
+	if (errorType !== void 0) yield* Effect.annotateCurrentSpan("error.type", errorType);
+	const terminal = Exit.isSuccess(exit) ? exit.value : drained;
+	if (terminal === void 0) return;
+	const { message } = terminal;
+	const { usage } = message;
+	const inputTokens = usage.input + usage.cacheRead + usage.cacheWrite;
+	const tokens = {
+		input: inputTokens,
+		output: usage.output,
+		cache_read: usage.cacheRead,
+		cache_write: usage.cacheWrite,
+		reasoning: usage.reasoning ?? 0
+	};
+	for (const [type, count] of Object.entries(tokens)) if (count > 0) yield* record$1(llmTokens, count, {
+		...labels,
+		type
+	});
+	if (usage.cost.total > 0) yield* record$1(llmCost, usage.cost.total, labels);
+	yield* Effect.annotateCurrentSpan({
+		"gen_ai.response.model": message.responseModel ?? message.model,
+		...message.responseId === void 0 ? {} : { "gen_ai.response.id": message.responseId },
+		"gen_ai.response.finish_reasons": [terminal.reason],
+		"gen_ai.usage.input_tokens": inputTokens,
+		"gen_ai.usage.output_tokens": usage.output,
+		"gen_ai.usage.cache_read.input_tokens": usage.cacheRead,
+		"gen_ai.usage.cache_write.input_tokens": usage.cacheWrite,
+		...usage.reasoning === void 0 ? {} : { "gen_ai.usage.reasoning.output_tokens": usage.reasoning }
+	});
+});
+const isToken = (event) => event.type === "text.delta" || event.type === "thinking.delta" || event.type === "toolcall.delta";
+/**
+* A failed terminal is the request's result, not an error. It leaves the
+* traced request as a failure so the span records an error status, and is
+* recovered just outside it.
+*/
+var FailedTerminal = class extends Data.TaggedError("LLM.FailedTerminal") {};
 /**
 * Build a provider request from an opener. Tests use this with deterministic
 * aikit event streams; production uses `open` above.
 */
 const make$5 = (openStream) => {
-	const request = Effect.fn("LLM.run")(function* (input) {
+	const request = Effect.fn("LLM.run", {
+		kind: "client",
+		level: "Info"
+	})(function* (input) {
+		yield* Effect.annotateCurrentSpan({
+			"gen_ai.operation.name": "chat",
+			"gen_ai.provider.name": input.provider,
+			"gen_ai.request.model": input.model,
+			"gen_ai.conversation.id": input.sessionId,
+			"gen_ai.request.stream": true
+		});
+		const start = yield* Effect.clockWith((clock) => clock.currentTimeMillis);
+		let firstToken;
+		let drained;
+		const markToken = (event) => firstToken !== void 0 || !isToken(event) ? Effect.void : Effect.clockWith((clock) => Effect.sync(() => {
+			firstToken = clock.currentTimeMillisUnsafe();
+		}));
 		const signalScope = yield* Scope.make();
 		yield* Effect.addFinalizer((exit) => Scope.close(signalScope, exit));
 		const signal = yield* Effect.abortSignal.pipe(Scope.provide(signalScope));
 		const abort = Scope.close(signalScope, Exit.void);
-		return yield* Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+		const terminal = yield* Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
 			const iterable = yield* restore(openStream(input, signal)).pipe(Effect.onInterrupt(() => abort));
-			const consumer = yield* Stream.fromAsyncIterable(iterable, (cause) => providerErrorFromUnknown(input, cause)).pipe(Stream.runForEach(input.publisher.publish), Effect.andThen(input.publisher.terminal), Effect.interruptible).pipe(Effect.forkScoped({ startImmediately: true }));
+			const consumer = yield* Stream.fromAsyncIterable(iterable, (cause) => providerErrorFromUnknown(input, cause)).pipe(Stream.runForEach((event) => Effect.andThen(markToken(event), input.publisher.publish(event))), Effect.andThen(input.publisher.terminal), Effect.interruptible).pipe(Effect.forkScoped({ startImmediately: true }));
 			const awaited = yield* restore(Fiber.await(consumer)).pipe(Effect.onInterrupt(() => abort), Effect.exit);
 			if (Exit.isFailure(awaited)) {
-				const drained = yield* Fiber.await(consumer);
-				if (Exit.isFailure(drained)) return yield* Effect.failCause(drained.cause);
+				const consumed = yield* Fiber.await(consumer);
+				if (Exit.isFailure(consumed)) return yield* Effect.failCause(consumed.cause);
+				drained = consumed.value;
 				return yield* Effect.failCause(awaited.cause);
 			}
 			const completed = awaited.value;
 			if (Exit.isFailure(completed)) return yield* Effect.failCause(completed.cause);
 			return completed.value;
-		}));
-	});
-	return (input) => request(input).pipe(Effect.scoped);
+		})).pipe(Effect.onExit((exit) => observe(input, {
+			start,
+			firstToken
+		}, exit, drained)));
+		if (terminal.outcome === "failed") return yield* new FailedTerminal({ terminal });
+		return terminal;
+	});
+	return (input) => request(input).pipe(Effect.catchTag("LLM.FailedTerminal", (failed) => Effect.succeed(failed.terminal)), Effect.scoped);
 };
 const run$1 = make$5(open);
 //#endregion
@@ -10735,6 +10952,17 @@ const errorPart = (call, cause, now) => ({
 		end: endTime(call, now)
 	}
 });
+const observeTool = (snapshot, call, seconds, exit) => {
+	const tool = snapshot.tools.defs.some((def) => def.name === call.name) ? call.name : "_OTHER";
+	const labels = Exit.isFailure(exit) ? {
+		tool,
+		error: errorType(exit.cause)
+	} : exit.value.status === "completed" ? { tool } : {
+		tool,
+		error: exit.value.status
+	};
+	return record$1(toolDuration, seconds, labels);
+};
 const layer$3 = (options = {}) => Layer.effect(Service$7, Effect.gen(function* () {
 	const context = yield* Service$13;
 	const events = yield* Service$16;
@@ -10773,7 +11001,7 @@ const layer$3 = (options = {}) => Layer.effect(Service$7, Effect.gen(function* (
 		if (draft === void 0) return;
 		yield* publishFailure(draft, { _tag: "interrupted" });
 	});
-	const settleTools = Effect.fn("Loop.settleTools")(function* (snapshot, message, reason, markCommitted) {
+	const settleTools = Effect.fn("Loop.settleTools", { level: "Info" })(function* (snapshot, message, reason, markCommitted) {
 		const pending = message.parts.filter((part) => part.type === "toolCall" && part.status === "pending");
 		let interruptedCause;
 		const messageId = ID.from(message.messageId);
@@ -10812,7 +11040,12 @@ const layer$3 = (options = {}) => Layer.effect(Service$7, Effect.gen(function* (
 				return;
 			}
 			const settled = /* @__PURE__ */ new Set();
-			const handle = Effect.fn("Loop.handleTool")(function* (call) {
+			const handle = Effect.fn("Loop.handleTool", { level: "Info" })(function* (call) {
+				yield* Effect.annotateCurrentSpan({
+					"gen_ai.operation.name": "execute_tool",
+					"gen_ai.tool.name": call.name,
+					"gen_ai.tool.call.id": call.callID
+				});
 				yield* events.publish(ToolStarted, {
 					timestamp: yield* DateTime.now,
 					sessionId: snapshot.sessionId,
@@ -10822,7 +11055,7 @@ const layer$3 = (options = {}) => Layer.effect(Service$7, Effect.gen(function* (
 					label: snapshot.tools.defs.find((def) => def.name === call.name)?.label,
 					arguments: call.arguments
 				});
-				const handled = yield* snapshot.tools.handle(call, {
+				const execute = snapshot.tools.handle(call, {
 					sessionId: snapshot.sessionId,
 					messageId,
 					onProgress: (progress) => events.publish(ToolProgress$2, {
@@ -10833,6 +11066,7 @@ const layer$3 = (options = {}) => Layer.effect(Service$7, Effect.gen(function* (
 						partial: progress.partial
 					}).pipe(Effect.asVoid)
 				}).pipe(Effect.catchCauseIf((cause) => !Cause.hasInterrupts(cause), (cause) => Effect.map(Effect.clockWith((clock) => clock.currentTimeMillis), (now) => errorPart(call, cause, now))));
+				const handled = yield* timed(execute, (seconds, exit) => observeTool(snapshot, call, seconds, exit));
 				yield* Effect.uninterruptible(Effect.gen(function* () {
 					yield* settle(call, handled);
 					yield* Effect.sync(() => settled.add(call.callID));
@@ -10855,7 +11089,7 @@ const layer$3 = (options = {}) => Layer.effect(Service$7, Effect.gen(function* (
 		}));
 		return interruptedCause;
 	});
-	const runTurnAttempt = Effect.fn("Loop.runTurnAttempt")(function* (promotion, snapshot) {
+	const runTurnAttempt = Effect.fn("Loop.runTurnAttempt", { level: "Info" })(function* (promotion, snapshot) {
 		const sessionId = snapshot.sessionId;
 		if (promotion !== void 0) {
 			const cutoff = yield* events.latestSequence(sessionId);
@@ -10959,27 +11193,35 @@ const layer$3 = (options = {}) => Layer.effect(Service$7, Effect.gen(function* (
 			});
 		}));
 	});
-	const runTurn = Effect.fn("Loop.runTurn")(function* (promotion, snapshot) {
+	const runTurn = Effect.fn("Loop.runTurn", { level: "Info" })(function* (promotion, snapshot) {
 		return yield* runTurnAttempt(promotion, snapshot);
 	});
-	const run = Effect.fn("Loop.run")(function* (input) {
+	const run = Effect.fn("Loop.run", { level: "Info" })(function* (input) {
 		yield* healDanglingDraft(input.sessionId);
 		const hasSteer = yield* inputs.hasPending(input.sessionId, "steer");
 		const hasFollowUp = hasSteer ? false : yield* inputs.hasPending(input.sessionId, "followUp");
 		if (!input.force && !hasSteer && !hasFollowUp) return;
+		yield* Effect.annotateCurrentSpan({
+			"gen_ai.operation.name": "invoke_agent",
+			"gen_ai.agent.name": "codework",
+			"gen_ai.conversation.id": input.sessionId
+		});
 		let promotion = hasSteer ? "steer" : hasFollowUp ? "followUp" : void 0;
-		let shouldRun = true;
-		while (shouldRun) {
-			const snapshot = yield* state.snapshot(input.sessionId);
-			let needsContinuation = true;
-			while (needsContinuation) {
-				const result = yield* runTurn(promotion, snapshot);
-				promotion = "steer";
-				needsContinuation = result.needsContinuation || (yield* inputs.hasPending(input.sessionId, "steer"));
+		const drain = Effect.gen(function* () {
+			let shouldRun = true;
+			while (shouldRun) {
+				const snapshot = yield* state.snapshot(input.sessionId);
+				let needsContinuation = true;
+				while (needsContinuation) {
+					const result = yield* runTurn(promotion, snapshot);
+					promotion = "steer";
+					needsContinuation = result.needsContinuation || (yield* inputs.hasPending(input.sessionId, "steer"));
+				}
+				shouldRun = yield* inputs.hasPending(input.sessionId, "followUp");
+				promotion = shouldRun ? "followUp" : void 0;
 			}
-			shouldRun = yield* inputs.hasPending(input.sessionId, "followUp");
-			promotion = shouldRun ? "followUp" : void 0;
-		}
+		});
+		yield* timed(drain, (seconds, exit) => record$1(agentDuration, seconds, withError({}, exit)));
 	});
 	return Service$7.of({ run });
 }));
@@ -11300,7 +11542,7 @@ const runtimeOverrides = (driver, value) => {
 	}));
 	return Effect.succeed(value);
 };
-const create$2 = Effect.fn("Sandbox.create")(function* (input) {
+const create$2 = Effect.fn("Sandbox.create", { level: "Info" })(function* (input) {
 	const controller = yield* Controller;
 	const registry = yield* Registry;
 	const driverName = name(input.driver);
@@ -11326,7 +11568,7 @@ const Selection = Schema.Union([Schema.Struct({ id: instance_exports.SandboxInst
 	driver: Schema.String,
 	providerResourceId: (0, schema_exports$9.optional)(Schema.String)
 })]);
-const resolve = Effect.fn("Sandbox.resolve")(function* (input) {
+const resolve = Effect.fn("Sandbox.resolve", { level: "Info" })(function* (input) {
 	if ("id" in input) {
 		const found = yield* get$1(input.id);
 		if (Option.isNone(found)) return yield* new errors_exports.SandboxNotFoundError({ id: input.id });
@@ -11379,7 +11621,7 @@ const list = Effect.fn("Sandbox.list")(function* (input) {
 const refresh = Effect.fn("Sandbox.refresh")(function* (id) {
 	return yield* (yield* Controller).refresh(id);
 });
-const wake = Effect.fn("Sandbox.wake")(function* (id) {
+const wake = Effect.fn("Sandbox.wake", { level: "Info" })(function* (id) {
 	return yield* (yield* Controller).wake(id);
 });
 const stop = Effect.fn("Sandbox.stop")(function* (id) {