effect-agent 0.1.0-beta.157 → 0.1.0-beta.159

package/src/core/AgentPolicy.ts

@@ -67,6 +67,12 @@ const AgentPolicyFields = Schema.Struct({
   runStatus: Schema.Literals(["appended", "off"]),
   /** Restart a disposable model call on joined input, at most twice per Run. Default off. */
   restartOnJoinedInput: Schema.optionalKey(Schema.Boolean),
+  /**
+   * Retries per model call after a retryable `AiError` or a 429/5xx stream error part,
+   * before any content. Provider-defined Tools must be `Tool.Readonly`. Exponential
+   * backoff honors longer `retryAfter` delays and counts toward `maxDuration`. Default 0.
+   */
+  modelRetries: Schema.optionalKey(NonNegativeInt),
   compaction: CompactionPolicy,
 }).check(
   Schema.makeFilter((policy) =>

package/src/core/SubagentContract.ts

@@ -77,13 +77,6 @@ export type SubagentBudgetReservation = typeof SubagentBudgetReservation.Type;
 export const DelegationDepth = Schema.Int.check(Schema.isGreaterThanOrEqualTo(1));
 export type DelegationDepth = typeof DelegationDepth.Type;
 
-/** @deprecated Names are application-owned; use DelegationTool metadata for classification. */
-export const delegationToolPrefix = "delegate_";
-
-/** @deprecated Checks a legacy spelling only, never execution, nesting or recovery semantics. */
-export const isDelegationToolName = (toolName: string): boolean =>
-  toolName.startsWith(delegationToolPrefix);
-
 /** Marks a Tool implementing the idempotent Subagent establishment protocol. */
 export const DelegationTool = Context.Reference<boolean>("@effect-agent/core/DelegationTool", {
   defaultValue: () => false,

package/src/durable/DurableAgentRuntime.ts

@@ -167,6 +167,7 @@ import { makeMessagingRuntime } from "./internal/messaging-host.ts";
 import * as ThreadInitialization from "./internal/thread-initialization.ts";
 import { makeWorkerRuntime, WorkerInputControl } from "./internal/worker-host.ts";
 import { WorkerRuntime } from "./internal/worker-runtime.ts";
+import { MessageDeliveryStore } from "./MessageDelivery.ts";
 import {
   OperationAuthorizationRequest,
   OperationAuthorizer,
@@ -1266,6 +1267,7 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
   const ledger = yield* SubmissionLedger;
   const submissionScheduling = yield* SubmissionScheduling;
   const store = yield* ThreadStore;
+  const deliveries = yield* Effect.serviceOption(MessageDeliveryStore);
 
   // Disposable: canonical tail and owner identify the exact projection, never ownership.
   // Retain only the most recent view; persisted checkpoints still govern cold recovery.
@@ -3112,7 +3114,75 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
    */
   const notifyParentOfChildSettlement = Effect.fn(
     "DurableAgentRuntime.notifyParentOfChildSettlement",
-  )(function* (submission: SubmissionSnapshot): Effect.fn.Return<void, LedgerError> {
+  )(function* (
+    submission: SubmissionSnapshot,
+    record: RecordEnvelope,
+  ): Effect.fn.Return<void, LedgerError> {
+    const admission = submission.messageAdmission;
+    const worker = submission.workerAdmission;
+
+    const key =
+      admission === undefined
+        ? worker === undefined
+          ? undefined
+          : {
+              ownerThreadId: worker.origin.source.threadId,
+              messageId: worker.messageId,
+            }
+        : Schema.is(MessageAdmission)(admission)
+          ? admission.message
+          : {
+              ownerThreadId:
+                admission._tag === "WorkerCompletion"
+                  ? admission.report.worker.threadId
+                  : admission.worker.threadId,
+              messageId: submission.idempotencyKey,
+            };
+
+    // Commit the destination's exact canonical acknowledgement at the source before
+    // making the ledger terminal. A failed/lost response is replayed during recovery.
+    if (key !== undefined && Option.isSome(deliveries)) {
+      const settled = yield* settlementPayloadFromRecord(record, submission.submissionId);
+
+      yield* deliveries.value
+        .change(key, {
+          _tag: "Complete",
+          nowMillis: yield* Clock.currentTimeMillis,
+          admissionKey: submission.idempotencyKey,
+          inputDigest: submission.inputDigest,
+          receipt: Receipt.make({
+            threadId: submission.threadId,
+            submissionId: submission.submissionId,
+            receiptId: submission.receiptId,
+            queueSequence: submission.queueSequence,
+          }),
+          settlement: Settlement.make({
+            submissionId: settled.submissionId,
+            receiptId: settled.receiptId,
+            settlementId: settled.settlementId,
+            outcome: settled.outcome,
+            settledAt: record.createdAt,
+            ...(settled.outcome === "failed" ? { failure: settled.result } : {}),
+            ...(settled.usageSummary === undefined ? {} : { usageSummary: settled.usageSummary }),
+            ...(settled.runDisposition === undefined
+              ? {}
+              : { runDisposition: settled.runDisposition }),
+          }),
+        })
+        .pipe(
+          Effect.catchCause((cause) =>
+            Effect.failCause(
+              Cause.map(cause, (error) =>
+                LedgerError.make({
+                  operation: "delivery-completion",
+                  message: "Destination acknowledgement remains pending",
+                  cause: error,
+                }),
+              ),
+            ),
+          ),
+        );
+    }
     if (submission.workerAdmission?.origin.reporting?.mode === "standard")
       yield* updateRuntime.repair(submission.threadId).pipe(
         Effect.mapError(() =>
@@ -3227,14 +3297,14 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
       Effect.asVoid,
     );
     yield* hit("terminalize:after-canonical-append");
-    yield* notifyParentOfChildSettlement(submission);
+    yield* notifyParentOfChildSettlement(submission, record);
 
     const settlement = yield* ledger.finalizeSettlement(
       SettlementFinalization.make({ submissionId, settlementId }),
     );
 
     yield* wake.notify(submission.threadId);
-    yield* notifyParentOfChildSettlement(submission);
+    yield* notifyParentOfChildSettlement(submission, record);
 
     return settlement;
   });
@@ -3349,7 +3419,7 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
       Effect.asVoid,
     );
     yield* hit("terminalize:after-canonical-append");
-    yield* notifyParentOfChildSettlement(submission);
+    yield* notifyParentOfChildSettlement(submission, reserved.record);
 
     const settlement = yield* ledger.finalizeSettlement(
       SettlementFinalization.make({ submissionId, settlementId }),
@@ -3358,7 +3428,7 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
     const canonicalSettlement = yield* settlementPayloadFromRecord(reserved.record, submissionId);
 
     yield* wake.notify(submission.threadId);
-    yield* notifyParentOfChildSettlement(submission);
+    yield* notifyParentOfChildSettlement(submission, reserved.record);
     yield* settleJoinedSubmissions(ctx, canonicalSettlement);
 
     return materializeSettlement(settlement, reserved.record);
@@ -3385,7 +3455,7 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
       );
       yield* hit("terminalize:after-canonical-append");
     }
-    yield* notifyParentOfChildSettlement(submission);
+    yield* notifyParentOfChildSettlement(submission, reservation.record);
 
     const settlement = yield* ledger.finalizeSettlement(
       SettlementFinalization.make({
@@ -3400,7 +3470,7 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
     );
 
     yield* wake.notify(submission.threadId);
-    yield* notifyParentOfChildSettlement(submission);
+    yield* notifyParentOfChildSettlement(submission, reservation.record);
     yield* settleJoinedSubmissions(ctx, canonicalSettlement);
 
     return materializeSettlement(settlement, reservation.record);
@@ -3413,7 +3483,7 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
   ): Effect.fn.Return<Settlement, LedgerError | SettlementConflict> {
     const canonicalSettlement = yield* settlementPayloadFromRecord(record, submission.submissionId);
 
-    yield* notifyParentOfChildSettlement(submission);
+    yield* notifyParentOfChildSettlement(submission, record);
 
     const settlement = yield* ledger.finalizeSettlement(
       SettlementFinalization.make({
@@ -3427,7 +3497,7 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
     );
 
     yield* wake.notify(submission.threadId);
-    yield* notifyParentOfChildSettlement(submission);
+    yield* notifyParentOfChildSettlement(submission, record);
 
     return materializeSettlement(settlement, snapshot.reservation?.record);
   });
@@ -4594,6 +4664,10 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
               journalMetadata,
             );
 
+      // Do not retain the metadata snapshot across model or Tool waits, including cache hits.
+      // The projected prompt owns its needed context.
+      journalMetadata = undefined;
+
       projectedJournal = {
         threadId: ctx.threadId,
         through: canonicalThrough,
@@ -8113,14 +8187,21 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
       const retainControl = controlRecords([submissionId]);
 
       const collectControl = (record: CanonicalRecordEnvelope): boolean => {
-        // Compaction payloads may carry large summaries or handoffs. Keep their metadata
-        // scoped to ordinary projection, never retained across this Attempt's model waits.
-        if (record.record.payload._tag === "CompactionCreated") journalMetadata = undefined;
-        else journalMetadata?.add(record);
+        journalMetadata?.add(record);
 
         return retainControl(record);
       };
 
+      const takeJournalMetadata = (): JournalMetadata | undefined => {
+        const metadata = journalMetadata?.snapshot();
+
+        // Reuse the validated prefix once, then release compaction payloads before model
+        // waits. An immediate resume falls back to a fresh canonical metadata scan.
+        if (metadata !== undefined && metadata.compactions.length > 0) journalMetadata = undefined;
+
+        return metadata;
+      };
+
       let records: ReadonlyArray<CanonicalRecordEnvelope> = yield* Stream.runCollect(
         initialView.canonical.pipe(Stream.filter(collectControl)),
       );
@@ -8492,7 +8573,7 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
           canonical,
           tail.tailSequence,
           initialView.seed,
-          journalMetadata?.snapshot(),
+          takeJournalMetadata(),
           lineage,
           approvalDecisionIntents,
           currentContracts,
@@ -11077,55 +11158,10 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
     return ObligationReport.make({ thresholds, entries, generatedAt });
   });
 
-  const runWorkerImpl = <
-    InputSchema extends Schema.Top,
-    OutputSchema extends Schema.Top,
-    Instructions,
-    Tools extends Record<string, Tool.Any>,
-    Provider,
-    ModelProvides,
-    ModelRequires,
-    InstructionError = InstructionErrorOf<Instructions, InputSchema["Type"]>,
-    InstructionRequirements = InstructionRequirementsOf<Instructions, InputSchema["Type"]>,
-    RunDispositionValue extends
-      | RunDispositionDeclaration<OutputSchema["Type"], Schema.Top>
-      | undefined = undefined,
-    InputPromptValue extends InputPromptSource<InputSchema["Type"], unknown, unknown> | undefined =
-      undefined,
-    UpdatesSchema extends Schema.Top | undefined = undefined,
-  >(
-    agent: RuntimeBinding<
-      InputSchema,
-      OutputSchema,
-      Instructions,
-      Tools,
-      Provider,
-      ModelProvides,
-      ModelRequires,
-      InstructionError,
-      InstructionRequirements,
-      RunDispositionValue,
-      InputPromptValue,
-      UpdatesSchema
-    >,
-  ) =>
-    Effect.gen(function* () {
-      // Wake subscriptions may drop hints, so a ledger scan seeds the worklist (persistence §14).
-      const nonterminal = yield* Stream.runCollect(ledger.scanNonterminal);
-      const seen = new Set<ThreadId>();
-
-      for (const submission of nonterminal) {
-        if (seen.has(submission.threadId)) continue;
-        seen.add(submission.threadId);
-        yield* processThreadImpl(agent, submission.threadId);
-      }
-      yield* Stream.runForEach(wake.wakes, (threadId) => processThreadImpl(agent, threadId));
-    });
-
   const runResolvedWorkerImpl = Effect.gen(function* () {
-    // The multi-binding worker (plan §1.7): every claimed head resolves its exact stored
-    // Binding from the explicit registration array, so one worker pool serves parent and child
-    // lanes (spec §12's smallest-pool wakeup proof runs over this loop).
+    // Each claimed head selects a current Binding by stable Agent ID and optional host routing.
+    // Original per-operation replay contracts still govern unfinished handlers, while one worker
+    // pool serves both parent and child lanes.
     const nonterminal = yield* Stream.runCollect(ledger.scanNonterminal);
     const seen = new Set<ThreadId>();
 
@@ -11219,7 +11255,6 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
     processThread: processThreadImpl,
     processThreadResolved: processThreadResolvedImpl,
     processThreadHead: processThreadHeadImpl,
-    runWorker: runWorkerImpl,
     runResolvedWorker: runResolvedWorkerImpl,
     runRecovery,
     recoverSubmission,
@@ -11261,11 +11296,8 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
  *   seam (Joining/Joined, plan §2.5): the queued input becomes canonical (`input:{sid}`) before
  *   the next model request, reattaches through the prompt-coverage rule after a crash, and the
  *   joined Submissions settle with the host outcome (DUR-002/DUR-016).
- * - `runWorker(agent)` — scan-seeded, wake-driven worker loop over every lane (WP4's host driver),
- *   over a singleton current Binding: a claimed head belonging to a different Agent never
- *   runs against this binding. Missing bindings leave accepted roots and children owed.
- * - `processThreadResolved(threadId)` / `runResolvedWorker` — the
- *   equivalents over registrations owned by the runtime Layer: each stable `agentId` selects
+ * - `processThreadResolved(threadId)` / `runResolvedWorker` — drain or continuously process
+ *   lanes using registrations owned by the runtime Layer: each stable `agentId` selects
  *   one current Binding. Unfinished operation contracts gate handler execution independently
  *   of immutable admission evidence; missing bindings release the claim with a typed refusal.
  * - `runRecovery()` — classify every nonterminal Submission with the pure `classifyRecovery` and
@@ -11468,59 +11500,6 @@ export class DurableAgentRuntime extends Context.Service<
       threadId: ThreadId,
       options?: { readonly yieldAfter?: DateTime.Utc },
     ) => Effect.Effect<Option.Option<Settlement>, DurableWorkerFailure | DurableBindingFailure>;
-    readonly runWorker: <
-      InputSchema extends Schema.Top,
-      OutputSchema extends Schema.Top,
-      Instructions,
-      Tools extends Record<string, Tool.Any>,
-      Provider,
-      ModelProvides,
-      ModelRequires,
-      InstructionError = InstructionErrorOf<Instructions, InputSchema["Type"]>,
-      InstructionRequirements = InstructionRequirementsOf<Instructions, InputSchema["Type"]>,
-      RunDispositionValue extends
-        | RunDispositionDeclaration<OutputSchema["Type"], Schema.Top>
-        | undefined = undefined,
-      InputPromptValue extends
-        | InputPromptSource<InputSchema["Type"], unknown, unknown>
-        | undefined = undefined,
-      UpdatesSchema extends Schema.Top | undefined = undefined,
-    >(
-      agent: RuntimeBinding<
-        InputSchema,
-        OutputSchema,
-        Instructions,
-        Tools,
-        Provider,
-        ModelProvides,
-        ModelRequires,
-        InstructionError,
-        InstructionRequirements,
-        RunDispositionValue,
-        InputPromptValue,
-        UpdatesSchema
-      >,
-    ) => Effect.Effect<
-      void,
-      DurableWorkerFailure | DurableBindingFailure,
-      DurableWorkerRequirements<
-        RuntimeBinding<
-          InputSchema,
-          OutputSchema,
-          Instructions,
-          Tools,
-          Provider,
-          ModelProvides,
-          ModelRequires,
-          InstructionError,
-          InstructionRequirements,
-          RunDispositionValue,
-          InputPromptValue,
-          UpdatesSchema
-        >,
-        InstructionRequirements
-      >
-    >;
     readonly runResolvedWorker: Effect.Effect<void, DurableWorkerFailure | DurableBindingFailure>;
     /**
      * Recover each pending Thread independently. History/child failures, defects and the

package/src/durable/MessageDelivery.ts

@@ -14,6 +14,8 @@ import { PreparedInput } from "./Subscription.ts";
 
 const Positive = Schema.Int.check(Schema.isGreaterThan(0));
 const BoundedName = Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(256));
+const receiptsEqual = Schema.toEquivalence(Receipt);
+const settlementsEqual = Schema.toEquivalence(Settlement);
 
 /** An owner is always a source Thread. Destination admission has its own frozen key. */
 export const MessageDeliveryKey = Schema.Struct({
@@ -66,7 +68,12 @@ export const defaultMessageDeliveryStoreLimits: MessageDeliveryStoreLimits = {
   maxRetainedUpdatesPerOwner: 256,
 };
 
-const ParkReason = Schema.Literals(["exhausted", "deadline", "status-unavailable"]);
+const ParkReason = Schema.Literals([
+  "exhausted",
+  "deadline",
+  "status-unavailable",
+  "awaiting-settlement",
+]);
 
 export const MessageDeliveryRecord = Schema.Struct({
   schemaVersion: Schema.Literal(1),
@@ -152,7 +159,20 @@ export const MessageDeliveryFailpoint = Context.Reference<{
 
 const fence = { expectedVersion: Positive, nowMillis: ScheduleInstant };
 
+/** Terminal destination evidence, independent of an expiring source transport claim. */
+export const MessageDeliveryCompletion = Schema.Struct({
+  receipt: Receipt,
+  settlement: Settlement,
+  admissionKey: IdempotencyKey,
+  inputDigest: Digest,
+});
+
 export const MessageDeliveryChange = Schema.Union([
+  Schema.Struct({
+    _tag: Schema.Literal("Complete"),
+    nowMillis: ScheduleInstant,
+    ...MessageDeliveryCompletion.fields,
+  }),
   Schema.Struct({ _tag: Schema.Literal("Claim"), ...fence }),
   Schema.Struct({ _tag: Schema.Literal("Accept"), ...fence, receipt: Receipt }),
   Schema.Struct({ _tag: Schema.Literal("Process"), ...fence, settlement: Settlement }),
@@ -424,6 +444,34 @@ export const applyMessageDeliveryChange = (
 ): Result.Result<MessageDeliveryRecord, MessageDeliveryError> => {
   const conflict = () => Result.fail(error("conflict", change._tag));
 
+  if (change._tag === "Complete") {
+    if (
+      change.admissionKey !== record.envelope.admissionKey ||
+      change.inputDigest !== record.envelope.inputDigest ||
+      change.receipt.threadId !== record.envelope.threadId ||
+      change.settlement.submissionId !== change.receipt.submissionId ||
+      change.settlement.receiptId !== change.receipt.receiptId ||
+      (record.receipt !== null && !receiptsEqual(record.receipt, change.receipt))
+    )
+      return Result.fail(error("corrupt", "completion-identity"));
+    if (record.status === "refused") return conflict();
+    if (record.status === "processed")
+      return record.settlement !== null && settlementsEqual(record.settlement, change.settlement)
+        ? Result.succeed(record)
+        : Result.fail(error("corrupt", "completion-identity"));
+
+    return Result.succeed({
+      ...record,
+      version: record.version + 1,
+      status: "processed",
+      receipt: change.receipt,
+      settlement: change.settlement,
+      leaseUntilMillis: null,
+      parkReason: null,
+      retry: { ...record.retry, parked: false },
+    });
+  }
+
   if (record.version !== change.expectedVersion) return conflict();
   if (record.status === "processed" || record.status === "refused") return conflict();
   const now = change.nowMillis;
@@ -540,21 +588,8 @@ export const applyMessageDeliveryChange = (
   }
   if (change._tag === "ObservePending") {
     if (record.status !== "accepted") return conflict();
-    if (now >= record.deadlineAtMillis) return Result.succeed(parked("deadline"));
 
-    return Result.succeed({
-      ...base,
-      leaseUntilMillis: null,
-      retry: {
-        ...record.retry,
-        automaticAttempts: 0,
-        lastFailure: null,
-        nextAttemptAtMillis: Math.min(
-          now + record.policy.settlementPollMillis,
-          record.deadlineAtMillis,
-        ),
-      },
-    });
+    return Result.succeed(parked("awaiting-settlement"));
   }
   if (change._tag === "Refuse") {
     if (record.status !== "pending") return conflict();
@@ -700,9 +735,10 @@ export class MessageDeliveryDriver extends Context.Service<
                 // Digest computation cannot extend this claim's admission authority.
                 if (timeout <= 0) return claimed;
 
-                type WithoutFence<T> = T extends MessageDeliveryChange
-                  ? Omit<T, "expectedVersion" | "nowMillis">
-                  : never;
+                type WithoutFence<T> =
+                  T extends Exclude<MessageDeliveryChange, { _tag: "Complete" }>
+                    ? Omit<T, "expectedVersion" | "nowMillis">
+                    : never;
 
                 const commit = (change: WithoutFence<MessageDeliveryChange>) =>
                   Clock.currentTimeMillis.pipe(
@@ -722,8 +758,16 @@ export class MessageDeliveryDriver extends Context.Service<
                   ).pipe(Effect.mapError((cause) => error("corrupt", "admission", cause)));
 
                   yield* failpoint.hit("message-delivery:admission:after");
-                  if (outcome._tag === "Receipt")
-                    return yield* commit({ _tag: "Accept", receipt: outcome.receipt });
+                  if (outcome._tag === "Receipt") {
+                    const accepted = yield* commit({ _tag: "Accept", receipt: outcome.receipt });
+
+                    return yield* store.change(key, {
+                      _tag: "Park",
+                      reason: "awaiting-settlement",
+                      expectedVersion: accepted.version,
+                      nowMillis: yield* Clock.currentTimeMillis,
+                    });
+                  }
                   if (outcome._tag === "Refused")
                     return yield* commit({
                       _tag: "Refuse",