@yielded/agent 0.1.0-beta.174 → 0.1.0-beta.176

package/src/durable/RunContinuation.ts

@@ -5,7 +5,7 @@ import { AgentPersistenceCapacityError } from "../core/AgentError.ts";
 import type { RunId, SubmissionId, ThreadId } from "../core/Identifiers.ts";
 import { ToolCallId } from "../core/Identifiers.ts";
 import { utf8ByteLength } from "../core/internal/utf8.ts";
-import { reference, resolveEvidence } from "./internal/evidence.ts";
+import { resolveEvidence } from "./internal/evidence.ts";
 import { continuationUsage } from "./internal/usage-totals.ts";
 export { reference, resolveEvidence } from "./internal/evidence.ts";
 import {
@@ -52,7 +52,7 @@ import {
   subagentRequestedRecordId,
   subagentStartedRecordId,
 } from "./RunJournal.ts";
-import type { RunStorageSession, RunWriter } from "./RunStorage.ts";
+import type { RunStorageSession } from "./RunStorage.ts";
 import {
   submissionAbortRecordId,
   submissionInputRecordId,
@@ -74,7 +74,7 @@ export { RunContinuation, RunContextRecorded, EvidenceReference } from "./Record
 /** Writer and progress sequencer selected at the local owner's resource boundary. */
 export class CurrentRunWriter extends Context.Service<
   CurrentRunWriter,
-  Pick<RunWriter, "threadId" | "tail" | "append" | "withProgress">
+  Pick<RunStorageSession, "threadId" | "tail" | "append" | "appendInput" | "withProgress">
 >()("@effect-agent/thread/CurrentRunWriter") {}
 
 /** Settlement publication keeps its original atomic authority and claim-scoped implementation. */
@@ -157,17 +157,14 @@ const isFrozenJsonData = (input: Schema.Json): boolean => {
   return true;
 };
 
-const validateBatchHeader = Schema.decodeSync(
+const validateBatchShape = Schema.decodeUnknownSync(
   Schema.Struct({
     batchId: CanonicalBatch.fields.batchId,
     producerId: CanonicalBatch.fields.producerId,
+    records: Schema.NonEmptyArray(Schema.Unknown).check(Schema.isMaxLength(256)),
   }),
 );
 
-const validateBatchCount = Schema.decodeUnknownSync(
-  Schema.NonEmptyArray(Schema.Unknown).check(Schema.isMaxLength(256)),
-);
-
 const ContinuationBytes = Schema.Struct({
   turnBytes: RunContinuation.fields.turnBytes,
   terminalBytes: RunContinuation.fields.terminalBytes,
@@ -185,15 +182,20 @@ const captureFacts = (batch: CommitBatch) =>
   Effect.try({
     try: () =>
       Result.gen(function* () {
-        const header = validateBatchHeader(batch);
+        const inputs = batch.records;
 
-        validateBatchCount(batch.records);
-        const encodings = yield* Result.all(batch.records.map(captureRecord));
+        const { batchId, producerId } = validateBatchShape({
+          batchId: batch.batchId,
+          producerId: batch.producerId,
+          records: inputs,
+        });
+
+        const encodings = yield* Result.all(inputs.map(captureRecord));
         const records = encodings.map((record) => record.canonical);
 
         return Object.freeze(
           CanonicalBatch.make(
-            { ...header, records: [records[0]!, ...records.slice(1)] },
+            { batchId, producerId, records: [records[0]!, ...records.slice(1)] },
             { disableChecks: true },
           ),
         );
@@ -236,14 +238,6 @@ export const prepareProgressAppend = (
   return Object.freeze(encodings.success.map((record) => record.progress));
 };
 
-const factUsageCharge = (facts: ReadonlyArray<RecordEnvelope>) =>
-  Effect.fromResult(Result.all(facts.map(recordEncoding))).pipe(
-    Effect.map((encodings) =>
-      encodings.reduce((bytes, record) => bytes + record.progress.terminalUsageBytes, 0),
-    ),
-    Effect.mapError((cause) => failure("Cannot account canonical progress facts", cause)),
-  );
-
 /** These values belong to the active Run, not its permanent conversation history. */
 export const isOperationalRecord = ({ payload }: RecordEnvelope): boolean =>
   payload._tag === "RunStarted" ||
@@ -717,9 +711,27 @@ const advanceFacts = Effect.fnUntraced(function* (
   let results = new Map(previous?.results);
   let childResults = new Map(previous?.childResults);
   let completionBytes = previous?.completionBytes;
+  let factBytes = 0;
+  let turn = previous?.continuation.turn ?? 1;
+  let usageCharge = 0;
+  let closingBytes = 0;
+  let closingCount = 0;
 
   for (const fact of facts) {
     const payload = fact.payload;
+    const captured = recordEncoding(fact);
+
+    if (Result.isFailure(captured))
+      return yield* failure("Cannot account canonical progress facts", captured.failure);
+    const encoded = captured.success;
+
+    factBytes += encoded.bytes;
+    if ("turn" in payload) turn = Math.max(turn, payload.turn);
+    usageCharge += encoded.progress.terminalUsageBytes;
+    if (encoded.progress.terminal) {
+      closingBytes += encoded.bytes;
+      closingCount++;
+    }
 
     switch (payload._tag) {
       case "RunStarted":
@@ -728,7 +740,7 @@ const advanceFacts = Effect.fnUntraced(function* (
       case "RunContextRecorded":
         if (savedContext !== undefined)
           return yield* failure("A Run's original context cannot be replaced");
-        savedContext = yield* reference(fact);
+        savedContext = EvidenceReference.make({ recordId: fact.recordId });
         position = "awaiting-model";
         break;
       case "ModelResponseRecorded": {
@@ -782,7 +794,7 @@ const advanceFacts = Effect.fnUntraced(function* (
         accounting.lastInputTokens = summary?.inputTokens ?? payload.inputTokens ?? 0;
         accounting.lastOutputTokens = summary?.outputTokens ?? payload.outputTokens ?? 0;
         accounting.unobservedModelCalls += payload.unobservedModelCalls ?? 0;
-        latestResponse = yield* reference(fact);
+        latestResponse = EvidenceReference.make({ recordId: fact.recordId });
         response = payload;
         results = new Map();
         childResults = new Map();
@@ -866,12 +878,12 @@ const advanceFacts = Effect.fnUntraced(function* (
                 ? 0
                 : utf8ByteLength(JSON.stringify(payload.runDisposition)))
             : undefined;
-        terminal = yield* reference(fact);
+        terminal = EvidenceReference.make({ recordId: fact.recordId });
         position = "settling";
         break;
       case "SubmissionSettled":
         if (payload.submissionId !== submissionId) break;
-        terminal = yield* reference(fact);
+        terminal = EvidenceReference.make({ recordId: fact.recordId });
         position = "settled";
         if (payload.usageSummary !== undefined) {
           accounting.modelCalls = payload.usageSummary.modelCalls;
@@ -929,22 +941,13 @@ const advanceFacts = Effect.fnUntraced(function* (
   if (previous?.continuation.position === "settled") position = "settled";
   else if (previous?.continuation.position === "settling" && position !== "settled")
     position = "settling";
-  const factBytes = facts.reduce((bytes, fact) => bytes + canonicalRecordBytes(fact), 0);
-
-  const turn = facts.reduce(
-    (current, fact) => ("turn" in fact.payload ? Math.max(current, fact.payload.turn) : current),
-    previous?.continuation.turn ?? 1,
-  );
 
   const turnBase =
     (previous?.continuation.turn === turn ? previous.continuation.turnBytes : initialBytes) +
     factBytes;
 
-  const usageCharge = yield* factUsageCharge(facts);
   const terminalUsageBytes = (previous?.continuation.terminalUsageBytes ?? 0) + usageCharge;
 
-  const closing = facts.filter(isTerminalBudgetFact);
-
   return {
     accounting,
     savedContext,
@@ -961,11 +964,9 @@ const advanceFacts = Effect.fnUntraced(function* (
     turnBase,
     usageCharge,
     terminalUsageBytes,
-    terminalBytes:
-      (previous?.continuation.terminalBytes ?? 0) +
-      closing.reduce((bytes, fact) => bytes + canonicalRecordBytes(fact), 0),
-    terminalRecords: (previous?.continuation.terminalRecords ?? 0) + closing.length,
-    closing: closing.length > 0,
+    terminalBytes: (previous?.continuation.terminalBytes ?? 0) + closingBytes,
+    terminalRecords: (previous?.continuation.terminalRecords ?? 0) + closingCount,
+    closing: closingCount > 0,
   };
 });
 
@@ -1046,6 +1047,14 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
   const gate = yield* Semaphore.make(1);
   const cached = new Map<RunId, ProgressState>();
 
+  let verifiedEmpty:
+    | {
+        readonly runId: RunId;
+        readonly through: CanonicalSequence;
+        readonly writer: CurrentRunWriter["Service"];
+      }
+    | undefined;
+
   const reservations = new Map<
     RecordId,
     {
@@ -1180,13 +1189,6 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
     };
   });
 
-  const loadState = (runId: RunId, after: CanonicalSequence) =>
-    Effect.suspend(() => {
-      const retained = cached.get(runId);
-
-      return retained === undefined ? loadUncachedState(runId, after) : Effect.succeed(retained);
-    });
-
   const checkFutureShapes = (
     state: ProgressState,
     cursorBytes?: number,
@@ -1316,12 +1318,9 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
     if (batch.records.some((record) => record.payload._tag === "RunContinuation"))
       return yield* failure("A caller cannot supply interpreter progress to the progress writer");
 
-    const ownedRecords = yield* Effect.fromResult(
-      Result.all(batch.records.map(captureRecord)),
-    ).pipe(
-      Effect.map((encodings) => encodings.map((record) => record.canonical)),
-      Effect.mapError((cause) => failure("Cannot capture canonical progress facts", cause)),
-    );
+    // Every private caller passes captureFacts' owned snapshot. Keep a mutable
+    // list for settlement accounting without capturing that snapshot a second time.
+    const ownedRecords = [...batch.records];
 
     const groups = new Map<RunId, Array<RecordEnvelope>>();
 
@@ -1338,7 +1337,16 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
     let executionCount = 0;
 
     for (const [runId, facts] of groups) {
-      const previous = yield* loadState(runId, after);
+      const empty =
+        verifiedEmpty?.runId === runId &&
+        verifiedEmpty.through === after &&
+        // Settlement preparation need not have a Run writer; absence disables reuse.
+        verifiedEmpty.writer ===
+          Option.getOrUndefined(yield* Effect.serviceOption(CurrentRunWriter));
+
+      const previous = empty
+        ? undefined
+        : (cached.get(runId) ?? (yield* loadUncachedState(runId, after)));
 
       let original = facts.find(
         (record) =>
@@ -1379,7 +1387,7 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
       if (previous === undefined && original === undefined)
         return yield* failure("Run has no accepted original input");
 
-      if (previous === undefined) {
+      if (previous === undefined && !empty) {
         const settled = yield* provide(
           getRecord({
             threadId,
@@ -1460,7 +1468,7 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
           ? previous.continuation.originalInput
           : original === undefined
             ? yield* failure("Run progress has no original input")
-            : yield* reference(original);
+            : EvidenceReference.make({ recordId: original.recordId });
 
       const next = yield* advanceFacts(previous, facts, submissionId, initialBytes);
 
@@ -1498,7 +1506,7 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
         ...(savedContext === undefined ? {} : { savedContext }),
         ...(latestResponse === undefined ? {} : { latestResponse }),
         ...(terminal === undefined ? {} : { terminal }),
-        lastFact: yield* reference(last),
+        lastFact: EvidenceReference.make({ recordId: last.recordId }),
         position,
         accounting,
       }).pipe(
@@ -1824,7 +1832,7 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
 
         yield* prepare(yield* captureFacts(probe), after);
         const recordId = probe.records[0].recordId;
-        const state = yield* loadState(runId, after);
+        const state = cached.get(runId) ?? (yield* loadUncachedState(runId, after));
 
         if (state === undefined) return yield* failure("Dispatch has no canonical Run progress");
         if (reservations.has(recordId))
@@ -1859,7 +1867,10 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
 
         if (response === undefined || response.payload._tag !== "ModelResponseRecorded")
           return yield* failure("Deferred dispatch has no response");
-        const progress = yield* loadState(response.payload.runId, after);
+
+        const progress =
+          cached.get(response.payload.runId) ??
+          (yield* loadUncachedState(response.payload.runId, after));
 
         if (progress === undefined) return yield* failure("Deferred dispatch has no Run progress");
 
@@ -1893,16 +1904,33 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
       }),
     );
 
+  const checkState = (state: ProgressState | undefined, recovered: boolean) => {
+    if (state === undefined) return Effect.fail(failure("Execution has no canonical Run progress"));
+
+    const capacity = () =>
+      state.continuation.position === "settling" || state.continuation.position === "settled"
+        ? Effect.void
+        : checkCapacity(state);
+
+    // Accepted states were shape-checked, but usage and reservations remain live inputs.
+    return recovered ? Effect.andThen(checkFutureShapes(state), capacity) : capacity();
+  };
+
   const check = (runId: RunId) =>
     gate.withPermits(1)(
-      Effect.gen(function* () {
-        const state = yield* loadState(runId, yield* tail);
+      Effect.flatMap(CurrentRunWriter, (writer) => {
+        if (writer.threadId !== threadId)
+          return Effect.fail(failure("Progress writer belongs to another Thread"));
+
+        const retained = cached.get(runId);
 
-        if (state === undefined) return yield* failure("Execution has no canonical Run progress");
-        // Accepted states were shape-checked during preparation; recovered states still need proof.
-        if (cached.get(runId) !== state) yield* checkFutureShapes(state);
-        if (state.continuation.position !== "settling" && state.continuation.position !== "settled")
-          yield* checkCapacity(state);
+        if (retained !== undefined) return checkState(retained, false);
+
+        return Effect.flatMap(writer.tail, (position) =>
+          Effect.flatMap(loadUncachedState(runId, position.sequence), (state) =>
+            checkState(state, true),
+          ),
+        );
       }),
     );
 
@@ -1912,6 +1940,29 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
     reserve,
     defer,
     check,
+    /** Internal read view immediately after this writer's acknowledged commit, while
+     * holding its initialization gates. Never authority across ownership or writes. */
+    acceptedCheckpoint: (runId: RunId) => cached.get(runId)?.checkpoint,
+    /** Scope a verified empty execution/evidence view to one owned initialization body.
+     * The caller holds progress+mutation gates; a changed writer or tail never reuses it. */
+    withVerifiedEmptyRun: <A, E, R>(
+      runId: RunId,
+      through: CanonicalSequence,
+      body: Effect.Effect<A, E, R>,
+    ): Effect.Effect<A, E, R | CurrentRunWriter> =>
+      Effect.flatMap(CurrentRunWriter, (writer) => {
+        const view = { runId, through, writer };
+
+        verifiedEmpty = view;
+
+        return body.pipe(
+          Effect.ensuring(
+            Effect.sync(() => {
+              if (verifiedEmpty === view) verifiedEmpty = undefined;
+            }),
+          ),
+        );
+      }),
     stageUsage: (runId: RunId, bytes: number) => {
       if (bytes === 0) stagedUsage.delete(runId);
       else stagedUsage.set(runId, bytes);