effect-agent 0.1.0-beta.103 → 0.1.0-beta.106

package/dist/{Subagent-C2s8PFrd.mjs → Subagent-uXWHXiKb.mjs}

@@ -3,12 +3,13 @@ import { AgentId, DelegationId, RunId, SettlementId, ThreadId, ToolCallId } from
 import { n as utf8ByteLength } from "./utf8-DchGZRBd.mjs";
 import { AgentPolicy } from "./core/AgentPolicy.mjs";
 import { IdempotencyKey, JoinedToHost, Receipt } from "./core/Receipt.mjs";
+import { i as Failure, o as Value } from "./FailureDiagnostic-BElLOoED.mjs";
 import { IdGenerator as IdGenerator$1 } from "./core/IdGenerator.mjs";
 import { BackgroundSpawnTool, DelegationTool, SubagentBudgetReservation, SubagentDelegationCaps, SubagentExecutionFailure, SubagentExecutionFailureClassification, SubagentGrant, SubagentReservationAmounts, WorkerOperationTool, narrowSubagentGrant } from "./core/SubagentContract.mjs";
 import { RunUsageReport, unknownRunTotals } from "./core/Usage.mjs";
 import { WorkerCompletion, WorkerContext, WorkerError, WorkerPage, WorkerRef, WorkerReport, WorkerStarted, WorkerSummary } from "./core/Worker.mjs";
 import { BackgroundReporting, SubagentHost, WorkerReportPreparationFailure } from "./engine/SubagentHost.mjs";
-import { a as SubagentDurability, i as AgentSpawner, o as SubagentDurabilityError, s as ToolCallWaiting } from "./AgentRuntime-BWOnNc0d.mjs";
+import { a as SubagentDurability, i as AgentSpawner, o as SubagentDurabilityError, s as ToolCallWaiting } from "./AgentRuntime-e2M5UoXn.mjs";
 import { RunEventSink } from "./engine/RunEventSink.mjs";
 import { SubagentBudgetExhausted, SubagentObservedUsage, SubagentReservationRequest, SubagentReservations, makeBudgetReservationId } from "./capabilities/SubagentReservations.mjs";
 import { t as utf8Bytes } from "./utf8-BYfhEkcj.mjs";
@@ -75,7 +76,10 @@ var SubagentPrestartDenied = class extends Schema.TaggedError()("SubagentPrestar
 var SubagentProjectionFailure = class extends Schema.TaggedError()("SubagentProjectionFailure", {
 	delegationId: DelegationId,
 	stage: Schema.Literals(["input", "result"]),
-	message: BoundedFailureText
+	message: BoundedFailureText,
+	/** Original validation error; detailed diagnostics are never part of the safe message. */
+	cause: Schema.optionalKey(Value),
+	stack: Schema.optionalKey(Schema.String)
 }) {};
 const millisOfMaxDuration = (policy) => Math.max(1, Math.ceil(Duration.toMillis(policy.maxDuration)));
 /**
@@ -308,8 +312,8 @@ const reportingToWorker = (report, destination) => {
 //#region src/capabilities/internal/subagent-background.ts
 /** Portable identity checked against this declaration; possession grants no authority. */
 const Worker = (declaration) => WorkerRef.check(Schema.makeFilter((worker) => worker.delegationId === declaration.delegationId && worker.targetAgentId === declaration.target.id)).pipe(Schema.brand(`@effect-agent/Worker/${declaration.name}`));
-/** Observes one exact Receipt. Terminal failure data never includes raw child output. */
-const WorkerObservation = (success) => Schema.Union([
+/** Model-facing projection deliberately excludes operator-private diagnostics. */
+const toolObservation = (success) => Schema.Union([
 	Schema.Struct({
 		_tag: Schema.Literal("Pending"),
 		receipt: Receipt
@@ -331,6 +335,18 @@ const WorkerObservation = (success) => Schema.Union([
 		failure: SubagentExecutionFailure
 	})
 ]);
+/** One exact Receipt, including private canonical failure evidence for programmatic callers. */
+const WorkerObservation = (success) => {
+	const projected = toolObservation(success);
+	return Schema.Union([
+		projected.members[0],
+		projected.members[1],
+		Schema.Struct({
+			...projected.members[2].fields,
+			diagnostic: Schema.optionalKey(Failure)
+		})
+	]);
+};
 const host = Effect.serviceOption(SubagentHost).pipe(Effect.flatMap((service) => Option.match(service, {
 	onNone: () => WorkerError.make({
 		operation: "context",
@@ -341,25 +357,29 @@ const host = Effect.serviceOption(SubagentHost).pipe(Effect.flatMap((service) =>
 const receiptEqual = (left, right) => left.threadId === right.threadId && left.submissionId === right.submissionId && left.receiptId === right.receiptId && left.queueSequence === right.queueSequence;
 const operations = (declaration) => {
 	const workerSchema = Worker(declaration);
-	const projectionFailure = (stage) => SubagentProjectionFailure.make({
+	const projectionFailure = (stage, cause) => SubagentProjectionFailure.make({
 		delegationId: declaration.delegationId,
 		stage,
+		...cause === void 0 ? {} : { cause },
 		message: stage === "input" ? "Worker input did not satisfy the declaration Schema" : "Worker result did not satisfy the declaration Schema"
 	});
-	const validateWorker = (worker, operation) => Schema.decodeUnknownEffect(workerSchema)(worker).pipe(Effect.mapError(() => WorkerError.make({
+	const validateWorker = (worker, operation) => Schema.decodeUnknownEffect(workerSchema)(worker).pipe(Effect.mapError((cause) => WorkerError.make({
 		operation,
-		reason: "worker-mismatch"
+		reason: "worker-mismatch",
+		cause
 	})));
-	const validateReceipt = (worker, receipt, operation) => Schema.decodeEffect(Receipt.check(Schema.makeFilter((value) => value.threadId === worker.threadId)))(receipt).pipe(Effect.mapError(() => WorkerError.make({
+	const validateReceipt = (worker, receipt, operation) => Schema.decodeEffect(Receipt.check(Schema.makeFilter((value) => value.threadId === worker.threadId)))(receipt).pipe(Effect.mapError((cause) => WorkerError.make({
 		operation,
-		reason: "receipt-mismatch"
+		reason: "receipt-mismatch",
+		cause
 	})));
 	const context = host.pipe(Effect.flatMap((service) => service.context), Effect.flatMap(Schema.decodeUnknownEffect(Schema.toType(WorkerContext))), Effect.mapError((error) => Schema.is(WorkerError)(error) ? error : WorkerError.make({
 		operation: "context",
-		reason: "corrupt"
+		reason: "corrupt",
+		cause: error
 	})));
 	const prepare = Effect.fn("Subagent.prepareWorkerInput")(function* (parameters, caller) {
-		const encodedParameters = yield* Schema.encodeEffect(declaration.parameters)(parameters).pipe(Effect.mapError(() => projectionFailure("input")));
+		const encodedParameters = yield* Schema.encodeEffect(declaration.parameters)(parameters).pipe(Effect.mapError((cause) => projectionFailure("input", cause)));
 		const source = caller.source;
 		const preparation = source._tag === "tool" ? {
 			source: "tool",
@@ -381,12 +401,13 @@ const operations = (declaration) => {
 		const input = yield* declaration.prepareInput(parameters, preparation);
 		return {
 			encodedParameters,
-			encodedInput: yield* Schema.encodeEffect(declaration.target.input)(input).pipe(Effect.mapError(() => projectionFailure("input")))
+			encodedInput: yield* Schema.encodeEffect(declaration.target.input)(input).pipe(Effect.mapError((cause) => projectionFailure("input", cause)))
 		};
 	});
-	const validateKey = (key, operation) => Schema.decodeEffect(IdempotencyKey)(key).pipe(Effect.mapError(() => WorkerError.make({
+	const validateKey = (key, operation) => Schema.decodeEffect(IdempotencyKey)(key).pipe(Effect.mapError((cause) => WorkerError.make({
 		operation,
-		reason: "idempotency-conflict"
+		reason: "idempotency-conflict",
+		cause
 	})));
 	return {
 		start: Effect.fn("Subagent.start")(function* (parameters, options) {
@@ -413,7 +434,7 @@ const operations = (declaration) => {
 			});
 			const resolvedTarget = Option.getOrUndefined(effectiveTarget);
 			const resolved = resolveSubagentPolicy(declaration, options.budgetScope === "worker-run" ? resolvedTarget ?? declaration.target.policy : caller.policy, void 0, options.budgetScope === "worker-run" ? "root-attached" : "conserved", resolvedTarget);
-			const encodedGrant = yield* Schema.encodeEffect(SubagentGrant)(grant).pipe(Effect.mapError(() => projectionFailure("input")));
+			const encodedGrant = yield* Schema.encodeEffect(SubagentGrant)(grant).pipe(Effect.mapError((cause) => projectionFailure("input", cause)));
 			const started = yield* service.start({
 				...prepared,
 				delegationId: declaration.delegationId,
@@ -429,9 +450,10 @@ const operations = (declaration) => {
 				}),
 				toolCallAllowance: resolveToolCallAllowance(declaration.toolCallAllowance, parameters, resolved.policy, resolved.childPolicy)
 			});
-			const validated = yield* Schema.decodeEffect(WorkerStarted)(started).pipe(Effect.mapError(() => WorkerError.make({
+			const validated = yield* Schema.decodeEffect(WorkerStarted)(started).pipe(Effect.mapError((cause) => WorkerError.make({
 				operation: "start",
-				reason: "corrupt"
+				reason: "corrupt",
+				cause
 			})));
 			return {
 				worker: yield* validateWorker(validated.worker, "start"),
@@ -478,18 +500,25 @@ const operations = (declaration) => {
 			const base = {
 				_tag: "Settled",
 				receipt: returned,
-				...observed.runId === void 0 ? {} : { runId: yield* Schema.decodeEffect(RunId)(observed.runId).pipe(Effect.mapError(() => WorkerError.make({
+				...observed.runId === void 0 ? {} : { runId: yield* Schema.decodeEffect(RunId)(observed.runId).pipe(Effect.mapError((cause) => WorkerError.make({
 					operation,
-					reason: "corrupt"
+					reason: "corrupt",
+					cause
 				}))) },
-				settlementId: yield* Schema.decodeEffect(SettlementId)(observed.settlementId).pipe(Effect.mapError(() => WorkerError.make({
+				settlementId: yield* Schema.decodeEffect(SettlementId)(observed.settlementId).pipe(Effect.mapError((cause) => WorkerError.make({
 					operation,
-					reason: "corrupt"
+					reason: "corrupt",
+					cause
 				})))
 			};
 			if (observed.outcome === "failed" || observed.outcome === "aborted") return {
 				...base,
 				outcome: observed.outcome,
+				...observed.diagnostic === void 0 ? {} : { diagnostic: yield* Schema.decodeEffect(Failure)(observed.diagnostic).pipe(Effect.mapError((cause) => WorkerError.make({
+					operation,
+					reason: "corrupt",
+					cause
+				}))) },
 				failure: SubagentExecutionFailure.make({
 					delegationId: declaration.delegationId,
 					targetAgentId: declaration.target.id,
@@ -505,18 +534,18 @@ const operations = (declaration) => {
 				operation,
 				reason: "corrupt"
 			});
-			const parameters = yield* Schema.decodeUnknownEffect(declaration.parameters)(observed.encodedParameters).pipe(Effect.mapError(() => projectionFailure("result")));
-			const output = yield* Schema.decodeUnknownEffect(declaration.target.output)(observed.encodedResult).pipe(Effect.mapError(() => projectionFailure("result")));
+			const parameters = yield* Schema.decodeUnknownEffect(declaration.parameters)(observed.encodedParameters).pipe(Effect.mapError((cause) => projectionFailure("result", cause)));
+			const output = yield* Schema.decodeUnknownEffect(declaration.target.output)(observed.encodedResult).pipe(Effect.mapError((cause) => projectionFailure("result", cause)));
 			const result = yield* declaration.projectResult(output, { budgetExhausted: observed.budgetExhausted }, parameters);
-			const encoded = yield* Schema.encodeEffect(declaration.success)(result).pipe(Effect.mapError(() => projectionFailure("result")));
-			const json = yield* Schema.decodeUnknownEffect(Schema.Json)(encoded).pipe(Effect.mapError(() => projectionFailure("result")));
+			const encoded = yield* Schema.encodeEffect(declaration.success)(result).pipe(Effect.mapError((cause) => projectionFailure("result", cause)));
+			const json = yield* Schema.decodeUnknownEffect(Schema.Json)(encoded).pipe(Effect.mapError((cause) => projectionFailure("result", cause)));
 			const caller = yield* context;
 			if (utf8ByteLength(JSON.stringify(json)) > (declaration.policy?.maxResultBytes ?? caller.policy.toolResultBounds.maxBytes)) return yield* projectionFailure("result");
 			return yield* Schema.decodeUnknownEffect(Schema.toType(WorkerObservation(declaration.success)))({
 				...base,
 				outcome: "completed",
 				result
-			}).pipe(Effect.mapError(() => projectionFailure("result")));
+			}).pipe(Effect.mapError((cause) => projectionFailure("result", cause)));
 		}),
 		list: Effect.fn("Subagent.list")(function* (options = {}) {
 			const service = yield* host;
@@ -726,7 +755,7 @@ const background$1 = (declaration, selected) => {
 	const inspectTool = Tool.make(`${declaration.name}_inspect`, {
 		description: `Inspect one exact ${declaration.name} Receipt without waiting.`,
 		parameters: receiptParameters,
-		success: WorkerObservation(declaration.success),
+		success: toolObservation(declaration.success),
 		failure
 	}).annotate(WorkerOperationTool, true).addDependency(SubagentHost);
 	const summaryTool = Tool.make(`${declaration.name}_summary`, {
@@ -774,7 +803,13 @@ const background$1 = (declaration, selected) => {
 			}),
 			[inspectTool.name]: (parameters) => Effect.gen(function* () {
 				const service = yield* host;
-				return yield* ops.observe("inspect", parameters.worker, parameters.receipt).pipe(Effect.provideService(SubagentHost, service), Effect.provide(captured));
+				return yield* ops.observe("inspect", parameters.worker, parameters.receipt).pipe(Effect.map((observed) => {
+					if ("diagnostic" in observed) {
+						const { diagnostic: _diagnostic, ...projected } = observed;
+						return projected;
+					}
+					return observed;
+				}), Effect.provideService(SubagentHost, service), Effect.provide(captured));
 			}),
 			[listTool.name]: (parameters) => ops.list(parameters),
 			[summaryTool.name]: (parameters) => summary(declaration, parameters.worker),
@@ -1466,4 +1501,4 @@ function background(targetOrDeclaration, selected) {
 //#endregion
 export { delegationCapsFromPolicy as C, delegationAllocationFromPolicy as S, reporting as _, define as a, SubagentPrestartDenied as b, Worker as c, cancel as d, followUp as f, start as g, observe as h, background as i, WorkerObservation as l, list as m, SubagentResult as n, layer as o, inspect as p, Subagent_exports as r, make as s, SubagentDurableAccounting as t, awaitWorker as u, reportingToWorker as v, SubagentProjectionFailure as x, SubagentPolicy as y };
 
-//# sourceMappingURL=Subagent-C2s8PFrd.mjs.map
+//# sourceMappingURL=Subagent-uXWHXiKb.mjs.map