@codeworksh/harness 0.0.1-dev.20260824182323 → 0.0.1-dev.20260825090614

package/effect.mjs

@@ -1,5 +1,5 @@
 import { n as __exportAll } from "./rolldown-runtime-B4iAMlE-.mjs";
-import { c as harness_exports, r as session_exports, s as sandbox_exports, u as tool_exports } from "./session-CF1B0VEr.mjs";
+import { c as harness_exports, h as run_exports, r as session_exports, s as sandbox_exports, u as tool_exports } from "./session-BpTL_HoS.mjs";
 //#region src/effect/tools.ts
 var tools_exports = /* @__PURE__ */ __exportAll({
 	Tools: () => tools_exports,
@@ -7,6 +7,6 @@ var tools_exports = /* @__PURE__ */ __exportAll({
 });
 const bash = "bash";
 //#endregion
-export { harness_exports as Harness, sandbox_exports as Sandbox, session_exports as Session, tool_exports as Tool, tools_exports as Tools };
+export { harness_exports as Harness, run_exports as Runner, sandbox_exports as Sandbox, session_exports as Session, tool_exports as Tool, tools_exports as Tools };
 
 //# sourceMappingURL=effect.mjs.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@codeworksh/harness",
-	"version": "0.0.1-dev.20260824182323",
+	"version": "0.0.1-dev.20260825090614",
 	"description": "AI agent harness — agent loop, tools, and code execution sandbox.",
 	"keywords": [
 		"agent",
@@ -51,7 +51,7 @@
 		"node": ">=24.14.1"
 	},
 	"dependencies": {
-		"@codeworksh/aikit": "0.7.1",
+		"@codeworksh/aikit": "0.7.2",
 		"@daytona/sdk": "^0.187.0",
 		"@effect/platform-node": "4.0.0-beta.107",
 		"@effect/sql-sqlite-node": "4.0.0-beta.107",

package/{session-CF1B0VEr.mjs → session-BpTL_HoS.mjs}

@@ -14,6 +14,7 @@ import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
 import { MemoryProvider, RealFSProvider, SqliteProvider, create } from "@platformatic/vfs";
 import { Bash } from "just-bash";
 import { createHash } from "crypto";
+import * as AikitFailure from "@codeworksh/aikit/failure";
 import { randomBytes } from "node:crypto";
 //#region src/schema.ts
 const aikitValidators = /* @__PURE__ */ new WeakMap();
@@ -985,7 +986,6 @@ const layer$20 = Layer.effect(Service$13, Effect.gen(function* () {
 	const sql = yield* SqlClient.SqlClient;
 	const pubsub = {
 		all: yield* PubSub.unbounded(),
-		durable: /* @__PURE__ */ new Map(),
 		typed: /* @__PURE__ */ new Map()
 	};
 	const projectors = /* @__PURE__ */ new Map();
@@ -993,7 +993,6 @@ const layer$20 = Layer.effect(Service$13, Effect.gen(function* () {
 	yield* Effect.addFinalizer(() => Effect.gen(function* () {
 		yield* PubSub.shutdown(pubsub.all);
 		yield* Effect.forEach(pubsub.typed.values(), PubSub.shutdown, { discard: true });
-		yield* Effect.forEach(pubsub.durable.values(), (wakes) => Effect.forEach(wakes, PubSub.shutdown, { discard: true }), { discard: true });
 	}));
 	const observe = (event, observer) => Effect.suspend(() => observer(event)).pipe(Effect.catchCauseIf((cause) => !Cause.hasInterrupts(cause), (cause) => Effect.logError("Event listener failed", {
 		eventID: event.id,
@@ -1097,7 +1096,7 @@ const layer$20 = Layer.effect(Service$13, Effect.gen(function* () {
 			message: `Expected string aggregate field ${durable.aggregate}`
 		}));
 		const encoded = yield* Schema.encodeUnknownEffect(definition.data)(event.data);
-		const committed = yield* sql.withTransaction(Effect.gen(function* () {
+		return yield* sql.withTransaction(Effect.gen(function* () {
 			const { seq } = yield* bumpSequence(aggregateId);
 			const existing = yield* findEventById(event.id);
 			if (Option.isSome(existing)) return yield* Effect.die(new InvalidDurableEventError({
@@ -1122,8 +1121,6 @@ const layer$20 = Layer.effect(Service$13, Effect.gen(function* () {
 			});
 			return payload;
 		}));
-		yield* Effect.forEach(pubsub.durable.get(aggregateId) ?? [], (wake) => PubSub.publish(wake, void 0), { discard: true });
-		return committed;
 	}, Effect.orDie, Effect.uninterruptible);
 	const publishEvent = Effect.fn("Event.publishEvent")(function* (definition, event) {
 		if (definition.durable) {
@@ -1175,19 +1172,32 @@ const layer$20 = Layer.effect(Service$13, Effect.gen(function* () {
 	const subscribe = (definition) => Stream.unwrap(getOrCreate(definition).pipe(Effect.map((created) => Stream.fromPubSub(created)))).pipe(Stream.map((event) => event));
 	const streamAll = () => Stream.fromPubSub(pubsub.all);
 	const stream = (input) => {
-		const tail = streamAll().pipe(Stream.filter((event) => event.data.sessionId === input.sessionId));
-		if (input.after === void 0) return tail;
-		return Stream.paginate(input.after, Effect.fn("Event.stream.history")(function* (after) {
-			const page = yield* readAggregate({
-				aggregateId: input.sessionId,
-				after,
-				limit: 100,
-				manifest: Manifest
-			});
-			const last = page.events.at(-1);
-			const next = page.hasMore && last?.durable !== void 0 ? Option.some(last.durable.seq) : Option.none();
-			return [page.events, next];
-		})).pipe(Stream.map((event) => event), Stream.concat(tail));
+		const forSession = (event) => event.data.sessionId === input.sessionId;
+		const after = input.after;
+		if (after === void 0) return streamAll().pipe(Stream.filter(forSession));
+		return Stream.unwrap(Effect.gen(function* () {
+			const subscription = yield* PubSub.subscribe(pubsub.all);
+			const watermark = yield* Ref.make(after);
+			const history = Stream.paginate(after, Effect.fn("Event.stream.history")(function* (after) {
+				const page = yield* readAggregate({
+					aggregateId: input.sessionId,
+					after,
+					limit: 100,
+					manifest: Manifest
+				});
+				const last = page.events.at(-1);
+				const next = page.hasMore && last?.durable !== void 0 ? Option.some(last.durable.seq) : Option.none();
+				return [page.events, next];
+			})).pipe(Stream.map((event) => event), Stream.tap((event) => {
+				const seq = event.durable?.seq;
+				return seq === void 0 ? Effect.void : Ref.update(watermark, (current) => Math.max(current, seq));
+			}));
+			const tail = Stream.fromSubscription(subscription).pipe(Stream.filter(forSession), Stream.filterEffect((event) => {
+				const seq = event.durable?.seq;
+				return seq === void 0 ? Effect.succeed(true) : Ref.get(watermark).pipe(Effect.map((replayed) => seq > replayed));
+			}));
+			return history.pipe(Stream.concat(tail));
+		}));
 	};
 	const listen = (listener) => Effect.sync(() => {
 		listeners.push(listener);
@@ -2565,7 +2575,7 @@ const sanitizeError = (cause, redact = makeRedactor()) => {
 		...code === void 0 ? {} : { code: redact(code) }
 	};
 };
-const providerError = (input) => {
+const providerError$1 = (input) => {
 	const error = new SandboxProviderError({
 		driver: input.driver,
 		operation: input.operation,
@@ -2881,7 +2891,7 @@ const encodeMetadataJson = Schema.encodeEffect(MetadataJson);
 const encodePersistedErrorJson = Schema.encodeEffect(PersistedErrorJson);
 /** Schema-aware runtime check; `instanceof` does not survive schema decoding. */
 const isSandboxProviderError = Schema.is(SandboxProviderError);
-const parseJson = (driver, operation, value) => decodeUnknownJson(value).pipe(Effect.mapError((cause) => providerError({
+const parseJson = (driver, operation, value) => decodeUnknownJson(value).pipe(Effect.mapError((cause) => providerError$1({
 	driver,
 	operation,
 	cause
@@ -2973,18 +2983,18 @@ const make$16 = Effect.fn("Sandbox.Controller.make")(function* (options = {}) {
 	const runtime = Effect.fn("Sandbox.Controller.runtime")(function* (row, operation) {
 		const driverName = Name.make(row.driver);
 		const driver = yield* registry.get(driverName);
-		if (driver.kind !== row.kind) return yield* providerError({
+		if (driver.kind !== row.kind) return yield* providerError$1({
 			driver: driverName,
 			operation,
 			cause: /* @__PURE__ */ new Error(`registered kind ${driver.kind} conflicts with persisted kind ${row.kind}`)
 		});
-		if (Option.isNone(row.runtimeConfig)) return yield* providerError({
+		if (Option.isNone(row.runtimeConfig)) return yield* providerError$1({
 			driver: driverName,
 			operation,
 			cause: /* @__PURE__ */ new Error(`sandbox runtime config is missing: ${row.id}`)
 		});
 		const decoded = yield* parseJson(driverName, operation, row.runtimeConfig.value);
-		const runtimeConfig = yield* registry.decodeRuntimeConfig(driverName, decoded).pipe(Effect.mapError((cause) => providerError({
+		const runtimeConfig = yield* registry.decodeRuntimeConfig(driverName, decoded).pipe(Effect.mapError((cause) => providerError$1({
 			driver: driverName,
 			operation,
 			cause
@@ -3101,7 +3111,7 @@ const make$16 = Effect.fn("Sandbox.Controller.make")(function* (options = {}) {
 		}).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) => providerError({
+			const runtimeConfig = yield* encodeUnknownJson$1(encoded).pipe(Effect.mapError((cause) => providerError$1({
 				driver: driver.name,
 				operation: "create",
 				cause
@@ -3149,7 +3159,7 @@ const make$16 = Effect.fn("Sandbox.Controller.make")(function* (options = {}) {
 			overrides: input.runtimeConfig
 		});
 		const encoded = yield* registry.encodeRuntimeConfig(driver.name, runtimeConfig);
-		const persisted = yield* encodeUnknownJson$1(encoded).pipe(Effect.mapError((cause) => providerError({
+		const persisted = yield* encodeUnknownJson$1(encoded).pipe(Effect.mapError((cause) => providerError$1({
 			driver: driver.name,
 			operation: "register",
 			cause
@@ -3741,7 +3751,7 @@ const make$13 = () => {
 	const resources = /* @__PURE__ */ new Map();
 	const find = (operation, input) => {
 		const vfs = resources.get(input.id);
-		return vfs === void 0 ? Effect.fail(providerError({
+		return vfs === void 0 ? Effect.fail(providerError$1({
 			driver: name,
 			operation,
 			cause: /* @__PURE__ */ new Error(`memory namespace is unavailable in this process: ${input.id}`),
@@ -3760,7 +3770,7 @@ const make$13 = () => {
 		},
 		createConfigCodec: CreateConfig$3,
 		runtimeConfigCodec: RuntimeConfig$3,
-		create: ({ instanceId, config }) => make$15({ cwd: config.initializeCwd ?? config.defaultCwd }).pipe(Effect.mapError((cause) => providerError({
+		create: ({ instanceId, config }) => make$15({ cwd: config.initializeCwd ?? config.defaultCwd }).pipe(Effect.mapError((cause) => providerError$1({
 			driver: name,
 			operation: "create",
 			cause
@@ -3772,7 +3782,7 @@ const make$13 = () => {
 				runtimeConfig: { defaultCwd: config.defaultCwd }
 			};
 		})),
-		runtimeConfigFor: ({ providerResourceId }) => Effect.fail(providerError({
+		runtimeConfigFor: ({ providerResourceId }) => Effect.fail(providerError$1({
 			driver: name,
 			operation: "runtimeConfigFor",
 			cause: /* @__PURE__ */ new Error(`memory resources cannot be reattached: ${providerResourceId}`),
@@ -3792,7 +3802,7 @@ const make$13 = () => {
 			providerStatus: "retained"
 		}),
 		destroy: (input) => Effect.suspend(() => {
-			return resources.delete(input.id) || Option.isSome(input.providerResourceId) ? Effect.void : Effect.fail(providerError({
+			return resources.delete(input.id) || Option.isSome(input.providerResourceId) ? Effect.void : Effect.fail(providerError$1({
 				driver: name,
 				operation: "destroy",
 				cause: /* @__PURE__ */ new Error(`memory namespace is unavailable: ${input.id}`),
@@ -3851,7 +3861,7 @@ const make$11 = () => {
 	const runtimeLocation = (input) => input.runtimeConfig.location ?? Option.getOrUndefined(input.providerResourceId);
 	const persistentTransport = (location) => {
 		const backend = layer$12({ location });
-		return transportLayer(Layer.effectContext(Layer.build(backend).pipe(Effect.mapError((cause) => providerError({
+		return transportLayer(Layer.effectContext(Layer.build(backend).pipe(Effect.mapError((cause) => providerError$1({
 			driver: name,
 			operation: "attach",
 			cause
@@ -3859,7 +3869,7 @@ const make$11 = () => {
 	};
 	const memoryResource = (operation, id) => {
 		const resource = memory.get(id);
-		return resource === void 0 ? Effect.fail(providerError({
+		return resource === void 0 ? Effect.fail(providerError$1({
 			driver: name,
 			operation,
 			cause: /* @__PURE__ */ new Error(`in-memory sqlite namespace is unavailable in this process: ${id}`),
@@ -3880,7 +3890,7 @@ const make$11 = () => {
 		runtimeConfigCodec: RuntimeConfig$2,
 		create: ({ instanceId, config }) => {
 			const location = config.location === void 0 ? void 0 : posix.resolve(config.location);
-			return make$12(location, { cwd: config.initializeCwd ?? config.defaultCwd }).pipe(Effect.mapError((cause) => providerError({
+			return make$12(location, { cwd: config.initializeCwd ?? config.defaultCwd }).pipe(Effect.mapError((cause) => providerError$1({
 				driver: name,
 				operation: "create",
 				cause
@@ -3899,7 +3909,7 @@ const make$11 = () => {
 			}));
 		},
 		runtimeConfigFor: ({ providerResourceId, overrides }) => {
-			if (!posix.isAbsolute(providerResourceId)) return Effect.fail(providerError({
+			if (!posix.isAbsolute(providerResourceId)) return Effect.fail(providerError$1({
 				driver: name,
 				operation: "runtimeConfigFor",
 				cause: /* @__PURE__ */ new Error(`sqldb resource path must be absolute: ${providerResourceId}`)
@@ -3914,7 +3924,7 @@ const make$11 = () => {
 		attach: (input) => {
 			if (input.runtimeConfig.inMemory) return Layer.unwrap(Effect.map(memoryResource("attach", input.id), (resource) => transport$2(resource.vfs)));
 			const location = runtimeLocation(input);
-			return location === void 0 ? Layer.unwrap(Effect.fail(providerError({
+			return location === void 0 ? Layer.unwrap(Effect.fail(providerError$1({
 				driver: name,
 				operation: "attach",
 				cause: /* @__PURE__ */ new Error(`sqldb runtime location is missing: ${input.id}`)
@@ -3926,12 +3936,12 @@ const make$11 = () => {
 				providerStatus: "online"
 			});
 			const location = runtimeLocation(input);
-			if (location === void 0) return Effect.fail(providerError({
+			if (location === void 0) return Effect.fail(providerError$1({
 				driver: name,
 				operation: "inspect",
 				cause: /* @__PURE__ */ new Error(`sqldb runtime location is missing: ${input.id}`)
 			}));
-			return fileSystem.access(location).pipe(Effect.mapError((cause) => providerError({
+			return fileSystem.access(location).pipe(Effect.mapError((cause) => providerError$1({
 				driver: name,
 				operation: "inspect",
 				cause,
@@ -3963,11 +3973,11 @@ const make$11 = () => {
 				return Effect.void;
 			}
 			const location = runtimeLocation(input);
-			return location === void 0 ? Effect.fail(providerError({
+			return location === void 0 ? Effect.fail(providerError$1({
 				driver: name,
 				operation: "destroy",
 				cause: /* @__PURE__ */ new Error(`sqldb runtime location is missing: ${input.id}`)
-			})) : fileSystem.remove(location, { force: true }).pipe(Effect.mapError((cause) => providerError({
+			})) : fileSystem.remove(location, { force: true }).pipe(Effect.mapError((cause) => providerError$1({
 				driver: name,
 				operation: "destroy",
 				cause
@@ -4185,7 +4195,7 @@ const make$9 = (client = {}) => {
 				sdk = loaded;
 				return run(loaded);
 			}),
-			catch: (cause) => providerError({
+			catch: (cause) => providerError$1({
 				driver: name$1,
 				operation,
 				cause,
@@ -4465,7 +4475,7 @@ const make$8 = (client = {}) => {
 	const redact = makeRedactor([client.token ?? ""]);
 	const attempt = (operation, run) => Effect.tryPromise({
 		try: run,
-		catch: (cause) => providerError({
+		catch: (cause) => providerError$1({
 			driver: name,
 			operation,
 			cause,
@@ -5043,29 +5053,125 @@ const layer$8 = (ref = {}) => Layer.effect(Service$5, Effect.gen(function* () {
 }));
 //#endregion
 //#region src/runner/run.ts
+var run_exports = /* @__PURE__ */ __exportAll({
+	LLMStreamError: () => LLMStreamError,
+	ModelCatalogError: () => ModelCatalogError,
+	ModelNotFoundError: () => ModelNotFoundError,
+	ProviderAuthenticationError: () => ProviderAuthenticationError,
+	ProviderAuthorizationError: () => ProviderAuthorizationError,
+	ProviderConfigurationError: () => ProviderConfigurationError,
+	ProviderContentPolicyError: () => ProviderContentPolicyError,
+	ProviderError: () => ProviderError,
+	ProviderFailureReason: () => ProviderFailureReason,
+	ProviderInvalidRequestError: () => ProviderInvalidRequestError,
+	ProviderInvalidResponseError: () => ProviderInvalidResponseError,
+	ProviderModelUnavailableError: () => ProviderModelUnavailableError,
+	ProviderQuotaError: () => ProviderQuotaError,
+	ProviderRateLimitError: () => ProviderRateLimitError,
+	ProviderTimeoutError: () => ProviderTimeoutError,
+	ProviderTransportError: () => ProviderTransportError,
+	ProviderUnavailableError: () => ProviderUnavailableError,
+	ProviderUnknownError: () => ProviderUnknownError,
+	Runner: () => run_exports,
+	SandboxDirectoryNotFoundError: () => SandboxDirectoryNotFoundError,
+	Service: () => Service$4
+});
 var SandboxDirectoryNotFoundError = class extends Schema.TaggedError()("Runner.SandboxDirectoryNotFoundError", {
 	sessionId: Schema.String,
 	sandboxInstanceId: ID$2,
 	directory: Schema.String
+}) {
+	get message() {
+		return `sandbox directory not found: ${this.directory}`;
+	}
+};
+const ProviderFailureFields = {
+	message: Schema.String,
+	isRetryable: Schema.Boolean,
+	status: optional(Schema.Finite),
+	code: optional(Schema.String),
+	requestId: optional(Schema.String),
+	retryAfter: optional(Schema.Duration)
+};
+var ProviderAuthenticationError = class extends Schema.TaggedError()("Runner.ProviderAuthenticationError", {
+	authentication: Schema.Literals([
+		"missing",
+		"invalid",
+		"expired"
+	]),
+	...ProviderFailureFields
 }) {};
+var ProviderConfigurationError = class extends Schema.TaggedError()("Runner.ProviderConfigurationError", ProviderFailureFields) {};
+var ProviderAuthorizationError = class extends Schema.TaggedError()("Runner.ProviderAuthorizationError", ProviderFailureFields) {};
+var ProviderModelUnavailableError = class extends Schema.TaggedError()("Runner.ProviderModelUnavailableError", ProviderFailureFields) {};
+var ProviderRateLimitError = class extends Schema.TaggedError()("Runner.ProviderRateLimitError", ProviderFailureFields) {};
+var ProviderQuotaError = class extends Schema.TaggedError()("Runner.ProviderQuotaError", ProviderFailureFields) {};
+var ProviderInvalidRequestError = class extends Schema.TaggedError()("Runner.ProviderInvalidRequestError", ProviderFailureFields) {};
+var ProviderContentPolicyError = class extends Schema.TaggedError()("Runner.ProviderContentPolicyError", ProviderFailureFields) {};
+var ProviderTimeoutError = class extends Schema.TaggedError()("Runner.ProviderTimeoutError", ProviderFailureFields) {};
+var ProviderTransportError = class extends Schema.TaggedError()("Runner.ProviderTransportError", ProviderFailureFields) {};
+var ProviderUnavailableError = class extends Schema.TaggedError()("Runner.ProviderUnavailableError", ProviderFailureFields) {};
+var ProviderInvalidResponseError = class extends Schema.TaggedError()("Runner.ProviderInvalidResponseError", ProviderFailureFields) {};
+var ProviderUnknownError = class extends Schema.TaggedError()("Runner.ProviderUnknownError", ProviderFailureFields) {};
+const ProviderFailureReason = Schema.Union([
+	ProviderAuthenticationError,
+	ProviderConfigurationError,
+	ProviderAuthorizationError,
+	ProviderModelUnavailableError,
+	ProviderRateLimitError,
+	ProviderQuotaError,
+	ProviderInvalidRequestError,
+	ProviderContentPolicyError,
+	ProviderTimeoutError,
+	ProviderTransportError,
+	ProviderUnavailableError,
+	ProviderInvalidResponseError,
+	ProviderUnknownError
+]);
+/** Stable provider boundary for SDK and RPC consumers; inspect `reason._tag` for the category. */
+var ProviderError = class extends Schema.TaggedError()("Runner.ProviderError", {
+	provider: Schema.String,
+	model: Schema.String,
+	reason: ProviderFailureReason
+}) {
+	cause = this.reason;
+	get message() {
+		return `${this.provider}/${this.model}: ${this.reason.message}`;
+	}
+	get isRetryable() {
+		return this.reason.isRetryable;
+	}
+};
+var ModelCatalogError = class extends Schema.TaggedError()("Runner.ModelCatalogError", {
+	path: Schema.String,
+	reason: Schema.Literals([
+		"missing",
+		"unreadable",
+		"empty",
+		"invalid"
+	]),
+	detail: Schema.String
+}) {
+	get message() {
+		return this.detail;
+	}
+};
 var ModelNotFoundError = class extends Schema.TaggedError()("Runner.ModelNotFoundError", {
 	provider: Schema.String,
 	model: Schema.String
-}) {};
-var ProviderTurnError = class extends Schema.TaggedError()("Runner.ProviderTurnError", {
-	provider: Schema.String,
-	model: Schema.String,
-	cause: Schema.Defect()
-}) {};
+}) {
+	get message() {
+		return `model "${this.model}" is not present for provider "${this.provider}" in the model catalog`;
+	}
+};
 var LLMStreamError = class extends Schema.TaggedError()("Runner.LLMStreamError", {
 	sessionId: Schema.String,
 	reason: Schema.String
-}) {};
-var TurnError = class extends Schema.TaggedError()("Runner.TurnError", {
-	sessionId: Schema.String,
-	messageId: optional(ID$1),
-	cause: TurnAbortCause
-}) {};
+}) {
+	get message() {
+		return `invalid provider event stream: ${this.reason}`;
+	}
+};
 var Service$4 = class extends Context.Service()("@codeworksh/harness/runner/run/Service") {};
 //#endregion
 //#region src/runner/execution.ts
@@ -5477,7 +5583,7 @@ const layer$6 = Layer.effect(Service$3, Effect.gen(function* () {
 				sessionId,
 				force
 			}).pipe(Effect.provideContext(Context.merge(locationContext, mountContext)));
-		}).pipe(Effect.scoped, Effect.tapCause((cause) => Cause.hasInterruptsOnly(cause) ? Effect.void : Effect.logError("failed to drain session", cause).pipe(Effect.annotateLogs({ sessionId }))));
+		}).pipe(Effect.scoped, Effect.tapCause((cause) => Cause.hasDies(cause) ? Effect.logError("runner defect", cause).pipe(Effect.annotateLogs({ sessionId })) : Effect.void));
 	}) });
 	return Service$3.of({
 		active: coordinator.active,
@@ -5645,15 +5751,72 @@ const runtimeOptions = (input, signal) => ({
 	sessionId: input.sessionId,
 	signal
 });
+const reasonFields = (failure) => ({
+	message: failure.message,
+	isRetryable: failure.retryable,
+	...failure.status === void 0 ? {} : { status: failure.status },
+	...failure.code === void 0 ? {} : { code: failure.code },
+	...failure.requestId === void 0 ? {} : { requestId: failure.requestId },
+	...failure.retryAfterMs === void 0 ? {} : { retryAfter: Duration.millis(failure.retryAfterMs) }
+});
+/** Lift Aikit's JSON-safe failure data into the Effect-native Runner error channel. */
+const providerError = (input, failure) => {
+	const fields = reasonFields(failure);
+	const reason = (() => {
+		switch (failure._tag) {
+			case "Authentication": return new ProviderAuthenticationError({
+				authentication: failure.reason,
+				...fields
+			});
+			case "Configuration": return new ProviderConfigurationError(fields);
+			case "Authorization": return new ProviderAuthorizationError(fields);
+			case "ModelUnavailable": return new ProviderModelUnavailableError(fields);
+			case "RateLimit": return new ProviderRateLimitError(fields);
+			case "Quota": return new ProviderQuotaError(fields);
+			case "InvalidRequest": return new ProviderInvalidRequestError(fields);
+			case "ContentPolicy": return new ProviderContentPolicyError(fields);
+			case "Timeout": return new ProviderTimeoutError(fields);
+			case "Transport": return new ProviderTransportError(fields);
+			case "Unavailable": return new ProviderUnavailableError(fields);
+			case "InvalidResponse": return new ProviderInvalidResponseError(fields);
+			case "Unknown": return new ProviderUnknownError(fields);
+		}
+	})();
+	return new ProviderError({
+		provider: input.provider,
+		model: input.model,
+		reason
+	});
+};
+const providerErrorFromUnknown = (input, cause) => providerError(input, AikitFailure.normalize(cause));
+const modelCatalogFailure = (cause) => {
+	if (typeof cause !== "object" || cause === null || !("name" in cause) || cause.name !== "ModelCatalogLoadError") return;
+	if (!("data" in cause) || typeof cause.data !== "object" || cause.data === null) return void 0;
+	const data = cause.data;
+	if (!("path" in data) || typeof data.path !== "string" || !("message" in data) || typeof data.message !== "string" || !("reason" in data) || data.reason !== "missing" && data.reason !== "unreadable" && data.reason !== "empty" && data.reason !== "invalid") return;
+	return {
+		path: data.path,
+		reason: data.reason,
+		message: data.message
+	};
+};
+/** Read structured terminal data while remaining compatible with older Aikit messages. */
+const messageFailure = (message) => {
+	const candidate = message.failure;
+	return AikitFailure.isFailure(candidate) ? candidate : AikitFailure.fromMessage(message.errorMessage ?? "The provider turn failed.");
+};
 /** Resolve the configured model and start aikit's provider stream. */
 const open = Effect.fn("LLM.open")(function* (input, signal) {
 	const model = yield* Effect.tryPromise({
 		try: () => llm(input.provider, input.model),
-		catch: (cause) => new ProviderTurnError({
-			provider: input.provider,
-			model: input.model,
-			cause
-		})
+		catch: (cause) => {
+			const catalog = modelCatalogFailure(cause);
+			return catalog === void 0 ? providerErrorFromUnknown(input, cause) : new ModelCatalogError({
+				path: catalog.path,
+				reason: catalog.reason,
+				detail: catalog.message
+			});
+		}
 	});
 	if (model === void 0) return yield* new ModelNotFoundError({
 		provider: input.provider,
@@ -5661,11 +5824,7 @@ const open = Effect.fn("LLM.open")(function* (input, signal) {
 	});
 	return yield* Effect.try({
 		try: () => stream(model, input.context, runtimeOptions(input, signal)),
-		catch: (cause) => new ProviderTurnError({
-			provider: input.provider,
-			model: input.model,
-			cause
-		})
+		catch: (cause) => providerErrorFromUnknown(input, cause)
 	});
 });
 /**
@@ -5680,11 +5839,7 @@ const make$4 = (openStream) => {
 		const abort = Scope.close(signalScope, Exit.void);
 		return 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) => new ProviderTurnError({
-				provider: input.provider,
-				model: input.model,
-				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(input.publisher.publish), 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);
@@ -6644,7 +6799,10 @@ const layer$4 = (options = {}) => {
 //#region src/runner/loop.ts
 const errorMessage = (cause) => {
 	const squashed = Cause.squash(cause);
-	return squashed instanceof Error ? squashed.message : String(squashed);
+	if (squashed instanceof Error && squashed.message.trim().length > 0) return squashed.message;
+	if (typeof squashed === "string" && squashed.trim().length > 0) return squashed;
+	if (typeof squashed === "object" && squashed !== null && "_tag" in squashed) return String(squashed._tag);
+	return "the turn failed for an unknown reason";
 };
 const terminalResult = (text) => ({
 	content: [{
@@ -6827,15 +6985,11 @@ const layer$3 = (options = {}) => Layer.effect(Service$4, Effect.gen(function* (
 				publisher
 			});
 			if (terminal.outcome === "failed") {
-				const cause = terminal.reason === "aborted" ? { _tag: "interrupted" } : {
-					_tag: "error",
-					message: terminal.message.errorMessage ?? "provider turn failed"
-				};
-				return yield* new TurnError({
-					sessionId,
-					...publisher.startedMessageId === void 0 ? {} : { messageId: publisher.startedMessageId },
-					cause
-				});
+				if (terminal.reason === "aborted") return yield* Effect.interrupt;
+				return yield* providerError({
+					provider: snapshot.provider,
+					model: snapshot.model
+				}, messageFailure(terminal.message));
 			}
 			const interrupted = yield* settleTools(snapshot, terminal.message, terminal.reason, () => {
 				committed = true;
@@ -6847,32 +7001,26 @@ const layer$3 = (options = {}) => Layer.effect(Service$4, Effect.gen(function* (
 			};
 		}).pipe(Effect.catchCause((cause) => {
 			if (committed) return Effect.failCause(cause);
-			const failure = Cause.findErrorOption(cause);
-			if (Option.isSome(failure) && failure.value._tag === "Runner.TurnError") return Effect.fail(failure.value);
 			const turnCause = Cause.hasInterruptsOnly(cause) ? { _tag: "interrupted" } : {
 				_tag: "error",
 				message: errorMessage(cause)
 			};
-			return Effect.fail(new TurnError({
-				sessionId,
-				...publisher?.startedMessageId === void 0 ? {} : { messageId: publisher.startedMessageId },
-				cause: turnCause
-			}));
+			const record = Effect.gen(function* () {
+				if (publisher?.startedMessageId !== void 0) {
+					const stored = yield* sessions.entry(publisher.startedMessageId);
+					if (Option.isSome(stored) && stored.value.entry.state === "draft") yield* publishFailure(stored.value, turnCause);
+				}
+				yield* events.publish(TurnAborted, {
+					timestamp: yield* DateTime.now,
+					sessionId,
+					cause: turnCause
+				});
+			});
+			return Effect.uninterruptible(record).pipe(Effect.andThen(Effect.failCause(cause)));
 		}));
 	});
 	const runTurn = Effect.fn("Loop.runTurn")(function* (promotion, snapshot) {
-		return yield* runTurnAttempt(promotion, snapshot).pipe(Effect.catchTag("Runner.TurnError", (error) => Effect.gen(function* () {
-			if (error.messageId !== void 0) {
-				const stored = yield* sessions.entry(error.messageId);
-				if (Option.isSome(stored) && stored.value.entry.state === "draft") yield* publishFailure(stored.value, error.cause);
-			}
-			yield* events.publish(TurnAborted, {
-				timestamp: yield* DateTime.now,
-				sessionId: snapshot.sessionId,
-				cause: error.cause
-			});
-			return yield* error;
-		})));
+		return yield* runTurnAttempt(promotion, snapshot);
 	});
 	const run$1 = Effect.fn("Loop.run")(function* (input) {
 		yield* healDanglingDraft(input.sessionId);
@@ -7265,6 +7413,6 @@ const attach = Effect.fn("Session.attach")(function* (input) {
 	return found.value;
 });
 //#endregion
-export { create$2 as a, harness_exports as c, ID$4 as d, Drivers as i, layer as l, create$1 as n, register as o, session_exports as r, sandbox_exports as s, attach as t, tool_exports as u };
+export { LLMTextDelta as _, create$2 as a, harness_exports as c, LLMStreamError as d, ModelCatalogError as f, LLMEnded as g, run_exports as h, Drivers as i, layer as l, ProviderError as m, create$1 as n, register as o, ModelNotFoundError as p, session_exports as r, sandbox_exports as s, attach as t, tool_exports as u, TurnEnded as v, ID$4 as y };
 
-//# sourceMappingURL=session-CF1B0VEr.mjs.map
+//# sourceMappingURL=session-BpTL_HoS.mjs.map