@yielded/agent 0.1.0-beta.181 → 0.1.0-beta.182

package/src/durable/DurableAgentRuntime.ts

@@ -1155,6 +1155,15 @@ const isCoordinatorHaltCause = (
     (reason) => reason._tag !== "Fail" || reason.error instanceof CoordinatorHalt,
   );
 
+const isPersistenceCapacityCause = (cause: Cause.Cause<unknown>): boolean =>
+  cause.reasons.length > 0 &&
+  cause.reasons.every(
+    (reason) =>
+      Cause.isFailReason(reason) &&
+      reason.error instanceof ThreadStoreError &&
+      reason.error.cause instanceof AgentPersistenceCapacityError,
+  );
+
 const PolicyFailure = Schema.TaggedStruct("AgentPolicyError", {
   limit: PolicyLimit,
 });
@@ -6150,6 +6159,26 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
                 return "committed" as const;
               }
 
+              if (
+                commit._tag === "Response" &&
+                commit.defer !== true &&
+                response !== undefined &&
+                progress !== undefined
+              ) {
+                // This read-only preflight proves that no append or Tool dispatch began.
+                // Append failures and recovered declarations retain their existing uncertainty.
+                const admissible = yield* progress.preflight(yield* turnResponseBatch(input)).pipe(
+                  Effect.provideService(CurrentRunWriter, ctx),
+                  Effect.as(true),
+                  Effect.catchCauseIf(
+                    (cause) => isPersistenceCapacityCause(cause),
+                    () => Effect.succeed(false),
+                  ),
+                );
+
+                if (!admissible) return "capacity-refused" as const;
+              }
+
               if (commit._tag === "Response" && commit.defer === true) {
                 if (
                   toolOperations.length === 0 ||
@@ -6216,11 +6245,18 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
                     message: "Dispatch has no scoped progress writer",
                   });
 
-                const batch = yield* progress
-                  .defer(candidate.batch)
-                  .pipe(Effect.provideService(CurrentRunWriter, ctx));
+                const batch = yield* progress.defer(candidate.batch).pipe(
+                  Effect.provideService(CurrentRunWriter, ctx),
+                  Effect.asSome,
+                  Effect.catchCauseIf(
+                    (cause) => isPersistenceCapacityCause(cause),
+                    () => Effect.succeedNone,
+                  ),
+                );
 
-                deferredResponse = { ...candidate, batch };
+                // Deferral does not append, and installs its reservation only after every check.
+                if (Option.isNone(batch)) return "capacity-refused" as const;
+                deferredResponse = { ...candidate, batch: batch.value };
 
                 return "deferred" as const;
               }

package/src/durable/RunContinuation.ts

@@ -1840,6 +1840,15 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
   const publish = (batch: CanonicalBatch) =>
     captureFacts(batch).pipe(Effect.flatMap(publishCaptured));
 
+  const preflight = (batch: CanonicalBatch) =>
+    gate.withPermits(1)(
+      Effect.gen(function* () {
+        const owned = yield* captureFacts(batch);
+
+        yield* prepare(owned, yield* tail, "preflight");
+      }),
+    );
+
   const reserve = (runId: RunId, probe: CanonicalBatch, bytes: number) =>
     gate.withPermits(1)(
       Effect.gen(function* () {
@@ -1952,6 +1961,7 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
   return {
     commit,
     publish,
+    preflight,
     reserve,
     defer,
     check,

package/src/engine/RunOptions.ts

@@ -688,10 +688,13 @@ export interface RunDurabilityHook<Error = never, Requirements = never> {
    * `committed` accepts the supplied facts canonically. `deferred` is valid only for a Response
    * with `defer: true`: validation and ownership succeeded, but no canonical acceptance occurred.
    * The interpreter retains its response and inputs until the Settled commit is accepted.
+   * `capacity-refused` is valid only for a fresh Response rejected before any storage append or
+   * Tool work. The interpreter settles every application call as not dispatched, atomically with
+   * that response. A failed append or an already accepted response must never return this value.
    */
   readonly commitTurn: (
     commit: RunTurnCommit,
-  ) => Effect.Effect<"committed" | "deferred", Error, Requirements>;
+  ) => Effect.Effect<"committed" | "deferred" | "capacity-refused", Error, Requirements>;
   /** Check the writer fence after approval/authorization and before handler permits; no write. */
   readonly checkToolDispatch: Effect.Effect<void, Error, Requirements>;
   readonly step: RunStepHook<Error, Requirements>;

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

@@ -757,7 +757,7 @@ const acceptTurnCommit = <E, R>(
   trace: TurnTrace,
   durability: RunDurabilityHook<E, R> | undefined,
   commit: RunTurnCommit,
-): Effect.Effect<void, E | ModelProtocolError | AgentPolicyError, R> =>
+): Effect.Effect<void | "capacity-refused", E | ModelProtocolError | AgentPolicyError, R> =>
   Effect.suspend(() => {
     if (trace.commitFailed) return Effect.void;
 
@@ -767,6 +767,15 @@ const acceptTurnCommit = <E, R>(
 
     return Effect.onExitPrimitive(
       Effect.flatMap(accepted, (receipt) => {
+        if (receipt === "capacity-refused")
+          return commit._tag === "Response" && trace.responseCommitted !== true
+            ? Effect.succeed(receipt)
+            : Effect.fail(
+                ModelProtocolError.make({
+                  message: "Durability refused capacity after response acceptance",
+                }),
+              );
+
         if (receipt === "deferred")
           return commit._tag === "Response" && commit.defer === true
             ? Effect.void
@@ -837,7 +846,7 @@ const settleTurn = <E, R>(
                   ...(response === undefined ? {} : { response }),
                   results,
                   ...(completion === undefined ? {} : { completion }),
-                }),
+                }).pipe(Effect.asVoid),
         );
       });
 
@@ -1663,7 +1672,7 @@ const makeToolFailedEvent = Effect.fnUntraced(function* (
 /**
  * Settle a rejected Tool batch without starting any handler: every open
  * application call receives the encoded failure as its model-visible result.
- * Only budget rejections (RUN-018) are exempt from repeated-failure folding;
+ * Policy and persistence budget rejections are exempt from repeated-failure folding;
  * correctable model declarations count as ordinary failed calls. Emit one
  * `ToolCallFailed` per call with no `ToolCallStarted` (the
  * approval-denied precedent). The caller hands the trace to
@@ -1676,10 +1685,10 @@ const settleRejectedBatch = Effect.fnUntraced(function* (
   context: RunContext,
   turnId: TurnId,
   trace: TurnTrace,
-  error: AgentPolicyError | ModelProtocolError,
+  error: AgentPolicyError | AgentPersistenceCapacityError | ModelProtocolError,
   alreadySettled?: ReadonlySet<string>,
 ): Effect.fn.Return<ReadonlyArray<RunEvent>, ModelProtocolError> {
-  const budgetRejected = error._tag === "AgentPolicyError" ? true : undefined;
+  const budgetRejected = error._tag !== "ModelProtocolError" ? true : undefined;
 
   const encodedResult = {
     _tag: error._tag,
@@ -7349,9 +7358,10 @@ const makeTurn = <
                     return yield* ModelProtocolError.make({
                       message: "Tool dispatch has no validated response facts",
                     });
+
                   // Idempotency only permits replay of the original operation. Re-asking the
                   // model could choose different arguments or a new key, so it keeps the barrier.
-                  yield* acceptTurnCommit(context, trace, options.durability, {
+                  const admission = yield* acceptTurnCommit(context, trace, options.durability, {
                     _tag: "Response",
                     turn,
                     turnId,
@@ -7370,6 +7380,33 @@ const makeTurn = <
                       ? { defer: true as const }
                       : {}),
                   });
+
+                  if (admission === "capacity-refused") {
+                    const rejection = yield* settleRejectedBatch(
+                      context,
+                      turnId,
+                      trace,
+                      AgentPersistenceCapacityError.make({
+                        message:
+                          "This application tool batch was not dispatched because its durable results exceed available capacity. Retry the needed application tools in smaller batches. Earlier tool results remain valid.",
+                      }),
+                    );
+
+                    return publishEvents(context, rejection).pipe(
+                      Effect.andThen(
+                        toolBatchContinuation(
+                          agent,
+                          context,
+                          trace,
+                          prompt,
+                          turn,
+                          turnId,
+                          toolCalls,
+                          options,
+                        ),
+                      ),
+                    );
+                  }
                 }
 
                 const toolResults = executeToolBatch(