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

package/src/engine/SubagentHost.ts

@@ -10,6 +10,8 @@ import { type IdempotencyKey, type JoinedToHost, type Receipt } from "../core/Re
 import type { SubagentBudgetReservation } from "../core/SubagentContract.ts";
 import {
   WorkerError,
+  type WorkerStop,
+  type WorkerStopped,
   type WorkerCompletion,
   type WorkerHistoryEntry,
   type WorkerContext,
@@ -36,6 +38,30 @@ export interface StartWorkerRequest {
   readonly budgetScope?: WorkerBudgetScope;
 }
 
+/**
+ * First-admission preparation stays lazy until the owner authorizes the caller and checks the
+ * retained command. Replays compare declared parameters/options and reuse the original capture.
+ * Prepared policy, budget, and allowance are frozen first-admission configuration, not replay
+ * arguments; changing them requires a new command key. Current caller authorization still applies.
+ * Preparation must be free of external effects: concurrent first admissions can prepare before
+ * the retained delivery chooses its first writer.
+ */
+export interface DeferredStartWorkerRequest<E = never, R = never> extends Pick<
+  StartWorkerRequest,
+  | "delegationId"
+  | "target"
+  | "idempotencyKey"
+  | "encodedParameters"
+  | "encodedGrant"
+  | "budgetScope"
+> {
+  readonly prepare: Effect.Effect<
+    Pick<StartWorkerRequest, "encodedInput" | "policy" | "budget" | "toolCallAllowance">,
+    E,
+    R
+  >;
+}
+
 export interface FollowUpWorkerRequest {
   readonly worker: WorkerRef;
   readonly target: Agent.AnyDefinition;
@@ -92,26 +118,16 @@ export class WorkerReportPreparationFailure extends Schema.TaggedError<WorkerRep
 ) {}
 
 /**
- * Source-owned projection discovered from background tools or supplied by a custom registration.
+ * Source-owned standard projection discovered from background tools.
  * The concrete descriptor retains its E/R; durable registration captures R and records
  * bounded preparation failure rather than serializing arbitrary application errors.
  */
 export interface WorkerReporting<E = never, R = never> {
   readonly delegationId: DelegationId;
   readonly target: Agent.AnyDefinition;
-  /** Standard messages retain the parent's original application input. */
-  readonly mode?: "standard";
-  readonly input?: Schema.Top;
-  /** Required for custom mapping when the receiving coordinator is itself an established worker. */
-  readonly destination?: {
-    readonly delegationId: DelegationId;
-    readonly target: Agent.AnyDefinition;
-  };
   readonly prepare: (report: WorkerRunReport) => Effect.Effect<
     {
-      readonly encodedInput: Schema.Json;
-      readonly encodedParameters?: Schema.Json;
-      readonly message?: WorkerCompletion;
+      readonly message: WorkerCompletion;
     },
     E | WorkerReportPreparationFailure,
     R
@@ -137,7 +153,10 @@ export class SubagentHost extends Context.Service<
       readonly target: Agent.AnyDefinition;
       readonly encodedInput: unknown;
     }) => Effect.Effect<Option.Option<AgentPolicy>, WorkerError>;
-    readonly start: (request: StartWorkerRequest) => Effect.Effect<WorkerStarted, WorkerError>;
+    /** Prepared callers retain strict input/policy conflicts; deferred callers replay the saved capture. */
+    readonly start: <E = never, R = never>(
+      request: StartWorkerRequest | DeferredStartWorkerRequest<E, R>,
+    ) => Effect.Effect<WorkerStarted, WorkerError | E, R>;
     readonly followUp: (
       request: FollowUpWorkerRequest,
     ) => Effect.Effect<MessageStatus, WorkerError>;
@@ -165,6 +184,10 @@ export class SubagentHost extends Context.Service<
       readonly limit: number;
       readonly after?: ThreadId;
     }) => Effect.Effect<WorkerPage, WorkerError>;
+    /** Seal the whole worker; retries reconcile the same command, including a lost acknowledgement. */
+    readonly stop: (
+      request: WorkerStop & { readonly target: Agent.AnyDefinition },
+    ) => Effect.Effect<WorkerStopped, WorkerError>;
     /** Cancel exactly this Receipt; preserve JoinedToHost without broadening its target. */
     readonly cancel: (
       request: WorkerReceiptRequest,
@@ -181,6 +204,7 @@ export class SubagentHost extends Context.Service<
     observe: () => Stream.fail(WorkerError.make({ operation: "observe", reason: "unavailable" })),
     await: () => WorkerError.make({ operation: "await", reason: "unavailable" }),
     list: () => WorkerError.make({ operation: "list", reason: "unavailable" }),
+    stop: () => WorkerError.make({ operation: "stop", reason: "unavailable" }),
     cancel: () => WorkerError.make({ operation: "cancel", reason: "unavailable" }),
   };
 

package/src/engine/internal/agent-runtime.ts

@@ -121,7 +121,11 @@ import {
   sumRunTotals,
   type UsageCompleteness,
 } from "../../core/Usage.ts";
-import { FrameworkMessage, type WorkerBudgetScope } from "../../core/Worker.ts";
+import {
+  AssignmentDisposition,
+  FrameworkMessage,
+  type WorkerBudgetScope,
+} from "../../core/Worker.ts";
 import { MessagingHost } from "../MessagingHost.ts";
 import { SubagentHost } from "../SubagentHost.ts";
 import { ThreadHistory, ThreadHistoryError } from "../ThreadHistory.ts";
@@ -5205,7 +5209,7 @@ const encodeRunDispositionCandidate = Effect.fn("AgentRuntime.encodeRunDispositi
       }),
   });
 
-  if (selected === undefined) return undefined;
+  if (selected === undefined && declaration.workerLifecycle === undefined) return undefined;
 
   const encoded = yield* Schema.encodeUnknownEffect(declaration.schema)(selected).pipe(
     Effect.mapError((cause) =>
@@ -5216,6 +5220,17 @@ const encodeRunDispositionCandidate = Effect.fn("AgentRuntime.encodeRunDispositi
     ),
   );
 
+  if (declaration.workerLifecycle === "assignment") {
+    return yield* Schema.decodeUnknownEffect(AssignmentDisposition)(encoded).pipe(
+      Effect.mapError((cause) =>
+        AgentRunDispositionError.make({
+          cause,
+          message: "Assignment disposition must encode completed or waiting",
+        }),
+      ),
+    );
+  }
+
   return yield* Schema.decodeUnknownEffect(Schema.Json)(encoded).pipe(
     Effect.mapError((cause) =>
       AgentRunDispositionError.make({