effect-agent 0.1.0-beta.113 → 0.1.0-beta.115

package/dist/{RunOptions-BoESJrxw.d.mts → RunOptions-CSBsSj0X.d.mts}

@@ -6,10 +6,10 @@ import { r as ModelCallUsage, s as RunTotals, t as ChildRunUsage } from "./Usage
 import { a as AgentInputError, u as AgentToolAuthorizationCheckError } from "./AgentError-Bn1ytXRD.mjs";
 import { t as ToolParameterRejection } from "./ToolResult-BKdqWRff.mjs";
 import { t as AgentPolicy } from "./AgentPolicy-BqDoSXO6.mjs";
-import { r as AnyDefinition } from "./Agent-DriBcXBN.mjs";
+import { r as AnyDefinition } from "./Agent-D9cXqfF3.mjs";
 import { o as MemoryRecallError } from "./MemoryReference-B8Q3UJoJ.mjs";
 import { t as RunPolicyUsage } from "./RunPolicyUsage-ClZxyR46.mjs";
-import { n as WorkerBudgetScope, t as FrameworkMessage } from "./Worker-Du9dhVnp.mjs";
+import { a as WorkerBudgetScope, r as FrameworkMessage } from "./Worker-fwWkBg12.mjs";
 import { c as ModelCallContext, r as ContextRolloverSelection } from "./ContextWindow-DRQ5Mbm2.mjs";
 import { c as ContextMessageTokenEstimator, n as CompactionError } from "./ContextCompactor-WwSIG_Z2.mjs";
 import { l as ToolExecutionClassValue, o as RunStepHook } from "./DurableStep-Cry_iol4.mjs";
@@ -932,4 +932,4 @@ type RunOptionsError<Options> = Options extends RunOptions<infer Error, infer _R
 type RunOptionsRequirements<Options> = Options extends RunOptions<infer _Error, infer Requirements> ? Requirements : never;
 //#endregion
 export { RunTurnResponseCommit as $, RunInputCommand as A, RunSubagentChildIdentity as B, RunContextPreparationPassthrough as C, RunCostEstimateValue as D, RunCostEstimateRequest as E, RunOptions_d_exports as F, RunToolAuthorization as G, RunSubagentEstablishRequest as H, RunResumeUsage as I, RunToolAuthorizationRequest as J, RunToolAuthorizationDecision as K, RunResumeUsageSchema as L, RunOptions as M, RunOptionsError as N, RunCostEstimator as O, RunOptionsRequirements as P, RunTransientContextHook as Q, RunSchedulingHook as R, RunContextPreparationError as S, RunCostEstimate as T, RunSubagentHook as U, RunSubagentDigests as V, RunSubagentJoinRequest as W, RunToolFailureObserver as X, RunToolCallDescriptor as Y, RunToolScheduling as Z, RunBudgetHook as _, ChildEstablishWaiting as a, RunUsageDelta as at, RunContextHook as b, ModelToolFailure as c, ProgrammaticPreflightFailure as d, RunTurnResume as et, ProgrammaticToolFailure as f, RunApprovalRequest as g, RunApprovalHook as h, ChildEstablishStatus as i, RunTurnUsage as it, RunInputHook as j, RunDurabilityHook as k, ModelUsageAccounting as l, RunApprovalDecision as m, ChildEstablishDenied as n, RunTurnResumeSettledCall as nt, CommandDrainPolicy as o, ToolFailureObservation as ot, ResolvedModelCall as p, RunToolAuthorizationHook as q, ChildEstablishSettled as r, RunTurnResumeSettledCallSchema as rt, CurrentToolFailureObserver as s, toolFailureObserverLayer as st, AgentUpdateAcceptance as t, RunTurnResumeCall as tt, PreparedRunContext as u, RunBufferLimits as v, RunContextRequest as w, RunContextPreparation as x, RunCompactionCommit as y, RunSchedulingOverride as z };
-//# sourceMappingURL=RunOptions-BoESJrxw.d.mts.map
+//# sourceMappingURL=RunOptions-CSBsSj0X.d.mts.map

package/dist/{Schedule-DGPyXBzK.d.mts → Schedule-krSnBcbU.d.mts}

@@ -1,6 +1,6 @@
 import { a as Receipt } from "./Receipt-BAHyigAF.mjs";
 import { a as FailureDiagnostic_d_exports, r as Diagnostic } from "./FailureDiagnostic-CaAkzGHL.mjs";
-import { _ as Digest, h as DefinitionDigests } from "./Records-BtxMy8xD.mjs";
+import { _ as Digest, h as DefinitionDigests } from "./Records-Byeb70tt.mjs";
 import { Context, Effect, Schema } from "effect";
 declare namespace Schedule_d_exports {
   export { ScheduleAuthorizationDecision, ScheduleAuthorizationError, ScheduleAuthorizer, ScheduleCapacityError, ScheduleChange, ScheduleConfiguration, ScheduleConflict, ScheduleDestination, ScheduleDueCursor, ScheduleFailpoint, ScheduleFailpointError, ScheduleId, ScheduleInstant, ScheduleKey, ScheduleManagementAuthorization, ScheduleManagementOperation, ScheduleNotFound, ScheduleOccurrenceAuthorization, ScheduleOwner, SchedulePage, SchedulePageRequest, SchedulePending, ScheduleRecord, ScheduleRefusal, ScheduleRetry, ScheduleRetryReason, ScheduleScope, ScheduleSkippedRange, ScheduleSnapshot, ScheduleSnapshotPage, ScheduleStorageError, ScheduleStore, ScheduleStoreFailure, ScheduleTiming, ScheduleTimingRequest, ScheduleValidationError, ScheduleWake, ScheduledEnvelope, ScheduledInputAdmission, ScheduledInputFailure, ScheduledInputRefused, ScheduledInputRetryable, SchedulingLimits, defaultSchedulingLimits };
@@ -844,4 +844,4 @@ declare const ScheduleFailpoint: Context.Reference<{
 }>;
 //#endregion
 export { ScheduleSnapshotPage as A, ScheduledInputAdmission as B, ScheduleRecord as C, ScheduleScope as D, ScheduleRetryReason as E, ScheduleTimingRequest as F, defaultSchedulingLimits as G, ScheduledInputRefused as H, ScheduleValidationError as I, ScheduleWake as L, ScheduleStore as M, ScheduleStoreFailure as N, ScheduleSkippedRange as O, ScheduleTiming as P, Schedule_d_exports as R, SchedulePending as S, ScheduleRetry as T, ScheduledInputRetryable as U, ScheduledInputFailure as V, SchedulingLimits as W, ScheduleNotFound as _, ScheduleChange as a, SchedulePage as b, ScheduleDestination as c, ScheduleFailpointError as d, ScheduleId as f, ScheduleManagementOperation as g, ScheduleManagementAuthorization as h, ScheduleCapacityError as i, ScheduleStorageError as j, ScheduleSnapshot as k, ScheduleDueCursor as l, ScheduleKey as m, ScheduleAuthorizationError as n, ScheduleConfiguration as o, ScheduleInstant as p, ScheduleAuthorizer as r, ScheduleConflict as s, ScheduleAuthorizationDecision as t, ScheduleFailpoint as u, ScheduleOccurrenceAuthorization as v, ScheduleRefusal as w, SchedulePageRequest as x, ScheduleOwner as y, ScheduledEnvelope as z };
-//# sourceMappingURL=Schedule-DGPyXBzK.d.mts.map
+//# sourceMappingURL=Schedule-krSnBcbU.d.mts.map

package/dist/{Subagent-D9eYdGTl.mjs → Subagent-Di8EEjWZ.mjs}

@@ -7,9 +7,9 @@ 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 { a as WorkerError, c as WorkerRef, d as WorkerStarted, f as WorkerSummary, g as MessageStatus, h as MessageRef, i as WorkerContext, l as WorkerReport, r as WorkerCompletion, s as WorkerPage } from "./Worker-T_3RbaKc.mjs";
+import { C as MessageStatus, S as MessageRef, _ as WorkerStop, c as WorkerError, d as WorkerPage, f as WorkerRef, g as WorkerStarted, o as WorkerCompletion, p as WorkerReport, s as WorkerContext, v as WorkerStopped, y as WorkerSummary } from "./Worker-CfwzMZEK.mjs";
 import { BackgroundReporting, SubagentHost, WorkerReportPreparationFailure } from "./engine/SubagentHost.mjs";
-import { a as SubagentDurability, i as AgentSpawner, o as SubagentDurabilityError, s as ToolCallWaiting } from "./AgentRuntime-DLwPoEVH.mjs";
+import { a as SubagentDurability, i as AgentSpawner, o as SubagentDurabilityError, s as ToolCallWaiting } from "./AgentRuntime-Cp1hAb-W.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";
@@ -228,11 +228,10 @@ const projectReport = (declaration) => Effect.fn("Subagent.projectReport")(funct
 		encodedResult
 	};
 });
-/** Framework reporting shares the same bounded declaration projection as custom mapping. */
+/** Project a canonical child outcome into the bounded standard completion message. */
 const automaticReporting = (declaration) => ({
 	delegationId: declaration.delegationId,
 	target: declaration.target,
-	mode: "standard",
 	prepare: Effect.fn("Subagent.automaticReport")(function* (report) {
 		const { projected, encodedResult } = yield* projectReport(declaration)(report);
 		const encoded = projected.outcome === "completed" ? {
@@ -242,72 +241,14 @@ const automaticReporting = (declaration) => ({
 			...projected,
 			failure: yield* Schema.encodeEffect(SubagentExecutionFailure)(projected.failure).pipe(Effect.mapError(() => WorkerReportPreparationFailure.make({ stage: "projection" })))
 		};
-		return {
-			encodedInput: null,
-			message: yield* Schema.decodeEffect(WorkerCompletion)({
-				_tag: "WorkerCompletion",
-				schemaVersion: 1,
-				report: encoded,
-				budgetExhausted: report.observation.budgetExhausted
-			}).pipe(Effect.mapError(() => WorkerReportPreparationFailure.make({ stage: "projection" })))
-		};
+		return { message: yield* Schema.decodeEffect(WorkerCompletion)({
+			_tag: "WorkerCompletion",
+			schemaVersion: 1,
+			report: encoded,
+			budgetExhausted: report.observation.budgetExhausted
+		}).pipe(Effect.mapError(() => WorkerReportPreparationFailure.make({ stage: "projection" }))) };
 	})
 });
-/**
-* Define an optional application-specific conversion for `background({ reportToParent: report })`.
-* Existing Agent Registration `reporting` arrays remain supported. The input Schema must be the coordinator Definition's exact input Schema.
-* Preparation is bounded by the durable host; a retained prepared envelope is never reprojected
-* during delivery retries. The callback should be deterministic and have no external side effects.
-*/
-const reporting = (declaration, options) => {
-	const prepare = Effect.fn("Subagent.reporting.prepare")(function* (report) {
-		const { projected } = yield* projectReport(declaration)(report);
-		const input = yield* options.prepare(projected);
-		const encoded = yield* Schema.encodeEffect(options.input)(input).pipe(Effect.mapError(() => WorkerReportPreparationFailure.make({ stage: "input" })));
-		return { encodedInput: yield* Schema.decodeUnknownEffect(Schema.Json)(encoded).pipe(Effect.mapError(() => WorkerReportPreparationFailure.make({ stage: "input" }))) };
-	});
-	return Object.freeze({
-		delegationId: declaration.delegationId,
-		target: declaration.target,
-		input: options.input,
-		prepare
-	});
-};
-/**
-* Adapt a report expressed in a receiving worker declaration's Parameters to its Agent input.
-* Use this on that worker's registration when it can itself launch reporting workers. This
-* explicit conversion preserves custom Parameters and charges the next input to its ancestor.
-*/
-const reportingToWorker = (report, destination) => {
-	if (report.input !== destination.parameters) throw new TypeError("Worker reporting must use the destination declaration's Parameters Schema");
-	return Object.freeze({
-		delegationId: report.delegationId,
-		target: report.target,
-		input: destination.target.input,
-		destination: {
-			delegationId: destination.delegationId,
-			target: destination.target
-		},
-		prepare: Effect.fn("Subagent.reportingToWorker.prepare")(function* (run) {
-			const encodedParameters = (yield* report.prepare(run)).encodedInput;
-			const invalid = () => WorkerReportPreparationFailure.make({ stage: "input" });
-			const parameters = yield* Schema.decodeEffect(destination.parameters)(encodedParameters).pipe(Effect.mapError(invalid));
-			const input = yield* destination.prepareInput(parameters, {
-				source: "programmatic",
-				delegationId: destination.delegationId,
-				parent: {
-					agentId: run.context.source.agentId,
-					threadId: run.context.source.threadId
-				}
-			});
-			const encoded = yield* Schema.encodeEffect(destination.target.input)(input).pipe(Effect.mapError(invalid));
-			return {
-				encodedInput: yield* Schema.decodeUnknownEffect(Schema.Json)(encoded).pipe(Effect.mapError(invalid)),
-				encodedParameters
-			};
-		})
-	});
-};
 //#endregion
 //#region src/capabilities/internal/subagent-background.ts
 /** Portable identity checked against this declaration; possession grants no authority. */
@@ -388,7 +329,6 @@ const operations = (declaration) => {
 		cause: error
 	})));
 	const prepare = Effect.fn("Subagent.prepareWorkerInput")(function* (parameters, caller) {
-		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",
@@ -408,10 +348,7 @@ const operations = (declaration) => {
 			}
 		};
 		const input = yield* declaration.prepareInput(parameters, preparation);
-		return {
-			encodedParameters,
-			encodedInput: yield* Schema.encodeEffect(declaration.target.input)(input).pipe(Effect.mapError((cause) => projectionFailure("input", cause)))
-		};
+		return 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((cause) => WorkerError.make({
 		operation,
@@ -436,28 +373,34 @@ const operations = (declaration) => {
 				reason: "grant-violation",
 				message: "The inherited grant does not permit background children"
 			});
-			const prepared = yield* prepare(parameters, caller);
-			const effectiveTarget = yield* service.resolveTargetPolicy({
-				target: declaration.target,
-				encodedInput: prepared.encodedInput
-			});
-			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 encodedParameters = yield* Schema.encodeEffect(declaration.parameters)(parameters).pipe(Effect.mapError((cause) => projectionFailure("input", cause)));
 			const encodedGrant = yield* Schema.encodeEffect(SubagentGrant)(grant).pipe(Effect.mapError((cause) => projectionFailure("input", cause)));
 			const started = yield* service.start({
-				...prepared,
 				delegationId: declaration.delegationId,
 				target: declaration.target,
 				idempotencyKey: key,
-				...options.budgetScope === void 0 ? {} : { budgetScope: options.budgetScope },
+				encodedParameters,
 				encodedGrant,
-				policy: resolved.childPolicy,
-				budget: SubagentBudgetReservation.make({
-					caps: resolved.caps,
-					allocation: resolved.allocation,
-					...resolved.policy.descendantInvocations === void 0 ? {} : { descendantInvocations: resolved.policy.descendantInvocations }
-				}),
-				toolCallAllowance: resolveToolCallAllowance(declaration.toolCallAllowance, parameters, resolved.policy, resolved.childPolicy)
+				...options.budgetScope === void 0 ? {} : { budgetScope: options.budgetScope },
+				prepare: Effect.gen(function* () {
+					const encodedInput = yield* prepare(parameters, caller);
+					const effectiveTarget = yield* service.resolveTargetPolicy({
+						target: declaration.target,
+						encodedInput
+					});
+					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);
+					return {
+						encodedInput,
+						policy: resolved.childPolicy,
+						budget: SubagentBudgetReservation.make({
+							caps: resolved.caps,
+							allocation: resolved.allocation,
+							...resolved.policy.descendantInvocations === void 0 ? {} : { descendantInvocations: resolved.policy.descendantInvocations }
+						}),
+						toolCallAllowance: resolveToolCallAllowance(declaration.toolCallAllowance, parameters, resolved.policy, resolved.childPolicy)
+					};
+				})
 			});
 			const validated = yield* Schema.decodeEffect(WorkerStarted)(started).pipe(Effect.mapError((cause) => WorkerError.make({
 				operation: "start",
@@ -478,9 +421,11 @@ const operations = (declaration) => {
 			const validated = yield* validateWorker(worker, "followUp");
 			const caller = yield* context;
 			const key = yield* validateKey(options.idempotencyKey, "followUp");
-			const prepared = yield* prepare(parameters, caller);
+			const encodedParameters = yield* Schema.encodeEffect(declaration.parameters)(parameters).pipe(Effect.mapError((cause) => projectionFailure("input", cause)));
+			const encodedInput = yield* prepare(parameters, caller);
 			const delivery = yield* validateDelivery(validated, yield* service.followUp({
-				...prepared,
+				encodedParameters,
+				encodedInput,
 				worker: validated,
 				target: declaration.target,
 				idempotencyKey: key
@@ -688,6 +633,30 @@ const observe = (declaration, worker, options = {}) => Stream.unwrap(Effect.gen(
 		...after === void 0 ? {} : { after }
 	});
 }));
+/** Seal a continuing worker, retaining a stable command identity across retries and Runs. */
+const stop = (declaration, worker, options) => Effect.gen(function* () {
+	const service = yield* host;
+	const command = yield* Schema.decodeEffect(WorkerStop)({
+		worker,
+		...options
+	}).pipe(Effect.mapError((cause) => WorkerError.make({
+		operation: "stop",
+		reason: "corrupt",
+		cause
+	})));
+	if (worker.delegationId !== declaration.delegationId || worker.targetAgentId !== declaration.target.id) return yield* WorkerError.make({
+		operation: "stop",
+		reason: "worker-mismatch"
+	});
+	return yield* service.stop({
+		...command,
+		target: declaration.target
+	}).pipe(Effect.flatMap(Schema.decodeEffect(WorkerStopped)), Effect.mapError((cause) => Schema.is(WorkerError)(cause) ? cause : WorkerError.make({
+		operation: "stop",
+		reason: "corrupt",
+		cause
+	})));
+});
 /** Wait for the exact Receipt. Interrupting this Effect never cancels accepted work. */
 const awaitWorker = (declaration, worker, receipt) => operations(declaration).observe("await", worker, receipt);
 /** List only workers visible through the caller-bound host facet. */
@@ -706,13 +675,8 @@ const InspectParameters = (declaration) => Schema.Struct({
 const Inspection = (success) => Schema.Union([MessageStatus, toolObservation(success)]);
 const WorkerParameters = (declaration) => Schema.Struct({ worker: Worker(declaration) });
 const Summary = (declaration) => Schema.Struct({
-	worker: Worker(declaration),
-	latestReceipt: Schema.NullOr(Receipt),
-	state: Schema.Literals([
-		"starting",
-		"active",
-		"idle"
-	])
+	...WorkerSummary.fields,
+	worker: Worker(declaration)
 });
 const FollowUpParameters = (declaration, parameters) => Schema.Struct({
 	worker: Worker(declaration),
@@ -782,8 +746,7 @@ let reportingServiceId = 0;
 * invocation dependencies. The attached `.tool` and its suspension behavior are unchanged.
 */
 const background$1 = (declaration, selected) => {
-	const report = selected.reportToParent === true ? automaticReporting(declaration) : selected.reportToParent;
-	if (report !== void 0 && (report.delegationId !== declaration.delegationId || report.target !== declaration.target)) throw new TypeError("Background reporting must use the same subagent declaration and target");
+	const report = selected.reportToParent === true ? automaticReporting(declaration) : void 0;
 	const reportService = Context.Service(`@effect-agent/capabilities/BackgroundReport/${declaration.name}/${reportingServiceId++}`);
 	const descriptor = report === void 0 ? void 0 : {
 		...report,
@@ -911,9 +874,8 @@ var Subagent_exports = /* @__PURE__ */ __exportAll({
 	list: () => list,
 	make: () => make,
 	observe: () => observe,
-	reporting: () => reporting,
-	reportingToWorker: () => reportingToWorker,
-	start: () => start
+	start: () => start,
+	stop: () => stop
 });
 const decodeDelegationId = Schema.decodeSync(DelegationId);
 /** Default delegation result, preserving partial-output information. */
@@ -1532,6 +1494,6 @@ function background(targetOrDeclaration, selected) {
 	return background$1(declaration, 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 };
+export { delegationCapsFromPolicy as S, stop as _, define as a, SubagentProjectionFailure 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, SubagentPolicy as v, delegationAllocationFromPolicy as x, SubagentPrestartDenied as y };
 
-//# sourceMappingURL=Subagent-D9eYdGTl.mjs.map
+//# sourceMappingURL=Subagent-Di8EEjWZ.mjs.map