effect-agent 0.1.0-beta.150 → 0.1.0-beta.151

package/src/durable/DurableAgentRuntime.ts

@@ -163,6 +163,7 @@ import {
 } from "./internal/journal-checkpoint.ts";
 import { makeJournalMetadata, type JournalMetadata } from "./internal/journal-metadata.ts";
 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 {
@@ -181,7 +182,6 @@ import {
   CanonicalBatch,
   CanonicalSequence,
   CompactionCreated,
-  ThreadCreated,
   DefinitionDigests,
   ModelResponseInterrupted,
   PersistedJson,
@@ -357,6 +357,7 @@ import {
 } from "./ThreadStore.ts";
 import { PreparedToolCallEvidence, ToolReconciler } from "./ToolReconciler.ts";
 import { WakeScheduler } from "./WakeScheduler.ts";
+import { WorkerAdmissionPort, WorkerAdmissionRequest } from "./WorkerAdmission.ts";
 
 // Capture the tracing call site once; each application still creates a fresh Attempt span.
 const withThreadHeadSpan = Effect.withSpan("DurableAgentRuntime.processThreadHead");
@@ -536,13 +537,7 @@ const childUsageReportsOf = (state: SubagentCallRecords): ReadonlyArray<ChildRun
     });
   });
 
-/** Deterministic batch identity of one Thread's initial `ThreadCreated` append. */
-export const threadCreatedBatchId = (threadId: ThreadId): BatchId =>
-  decodeBatchId(`thread-created:${threadId}`);
-
-/** Deterministic record identity of one Thread's `ThreadCreated` record. */
-export const threadCreatedRecordId = (threadId: ThreadId): RecordId =>
-  decodeRecordId(`thread-created:${threadId}`);
+export { threadCreatedBatchId, threadCreatedRecordId } from "./internal/thread-initialization.ts";
 
 /** Deterministic batch identity of one executed recovery decision's audit append (DUR-013). */
 export const recoveryRepairBatchId = (submissionId: SubmissionId, decisionTag: string): BatchId =>
@@ -1262,6 +1257,7 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
   bindings: ReadonlyArray<ResolvedBinding>,
 ) {
   const registeredBindings = [...bindings];
+  const workerAdmissionPort = yield* WorkerAdmissionPort;
   const ledger = yield* SubmissionLedger;
   const submissionScheduling = yield* SubmissionScheduling;
   const store = yield* ThreadStore;
@@ -2380,67 +2376,17 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
       .materialize(ThreadMaterialization.make({ threadId, producerEpoch }))
       .pipe(Effect.catchTag("FenceRejected", () => Effect.void));
 
-  /**
-   * Coordinator invariant: every Thread's first canonical record is `ThreadCreated`,
-   * so `tailSequence >= 1` is the deterministic already-created check. A lost race (conflict or
-   * fence) is verified against that invariant instead of being trusted blindly. An admitted
-   * child can be claimed before it is runnable; that advances the shared storage fence without
-   * appending anything. Re-read and retry that initialization race with the current fence.
-   */
-  const ensureThreadCreated = Effect.fn("DurableAgentRuntime.ensureThreadCreated")(
-    function* (
-      threadId: ThreadId,
-      agentId: AgentId,
-      definitions: DefinitionDigests,
-    ): Effect.fn.Return<
-      void,
-      ThreadStoreError | ThreadNotMaterialized | AppendConflict | FenceRejected
-    > {
-      const tail = yield* store.inspectTail(ThreadTailRequest.make({ threadId }));
-
-      if (tail.tailSequence > 0) return;
-
-      const record = yield* makeEnvelope(
-        threadCreatedRecordId(threadId),
-        ThreadCreated.make({ agentId, definitions }),
-      );
-
-      yield* store
-        .append(
-          FencedAppendRequest.make({
-            threadId,
-            batch: CanonicalBatch.make({
-              batchId: threadCreatedBatchId(threadId),
-              producerId: config.producerId,
-              records: [record],
-            }),
-            expectedTailSequence: tail.tailSequence,
-            expectedTailDigest: tail.tailDigest,
-            producerEpoch: tail.producerEpoch,
-          }),
-        )
-        .pipe(
-          Effect.catchTag(["AppendConflict", "FenceRejected"], (error) =>
-            store
-              .inspectTail(ThreadTailRequest.make({ threadId }))
-              .pipe(
-                Effect.flatMap((current) =>
-                  current.tailSequence > 0 ? Effect.void : Effect.fail(error),
-                ),
-              ),
-          ),
-          Effect.andThen(wake.notify(threadId)),
-          Effect.asVoid,
-        );
-    },
-    (effect) =>
-      effect.pipe(
-        Effect.retry({
-          times: 7,
-          while: (error) => error._tag === "AppendConflict" || error._tag === "FenceRejected",
-        }),
-      ),
-  );
+  const ensureThreadCreated = (
+    threadId: ThreadId,
+    agentId: AgentId,
+    definitions: DefinitionDigests,
+  ) =>
+    ThreadInitialization.ensureThreadCreated(
+      { producerId: config.producerId, deploymentId: config.deploymentId },
+      threadId,
+      agentId,
+      definitions,
+    ).pipe(Effect.provideService(ThreadStore, store), Effect.provideService(WakeScheduler, wake));
 
   const attemptContextFor = Effect.fn("DurableAgentRuntime.attemptContextFor")(function* (
     threadId: ThreadId,
@@ -10109,41 +10055,64 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
         });
     }
 
-    const admitted = yield* ledger.admit(
-      yield* Schema.decodeEffect(AdmissionRequest)({
-        threadId: options.threadId,
-        principal: options.principal,
-        idempotencyKey: options.idempotencyKey,
-        ...(options.admissionGroup === undefined ? {} : { admissionGroup: options.admissionGroup }),
-        ...(options.admissionFence === undefined ? {} : { admissionFence: options.admissionFence }),
-        agentId: agent.definition.id,
-        agentDigests: options.definitions,
-        deploymentId: config.deploymentId,
-        inputPayload,
-        inputDigest,
-        ...(workerAdmission === undefined
-          ? {}
-          : {
-              workerAdmission: yield* Schema.encodeEffect(WorkerAdmission)(workerAdmission).pipe(
-                Effect.mapError(() =>
-                  LedgerError.make({
-                    operation: "submit",
-                    message: "Worker admission cannot be encoded",
-                  }),
-                ),
+    const request = yield* Schema.decodeEffect(AdmissionRequest)({
+      threadId: options.threadId,
+      principal: options.principal,
+      idempotencyKey: options.idempotencyKey,
+      ...(options.admissionGroup === undefined ? {} : { admissionGroup: options.admissionGroup }),
+      ...(options.admissionFence === undefined ? {} : { admissionFence: options.admissionFence }),
+      agentId: agent.definition.id,
+      agentDigests: options.definitions,
+      deploymentId: config.deploymentId,
+      inputPayload,
+      inputDigest,
+      ...(workerAdmission === undefined
+        ? {}
+        : {
+            workerAdmission: yield* Schema.encodeEffect(WorkerAdmission)(workerAdmission).pipe(
+              Effect.mapError(() =>
+                LedgerError.make({
+                  operation: "submit",
+                  message: "Worker admission cannot be encoded",
+                }),
               ),
-            }),
-        ...(messageAdmission === undefined ? {} : { messageAdmission }),
-      }).pipe(
-        Effect.mapError(() =>
-          LedgerError.make({
-            operation: "submit",
-            message: "Admission fields do not satisfy the ledger contract",
+            ),
           }),
-        ),
+      ...(messageAdmission === undefined ? {} : { messageAdmission }),
+    }).pipe(
+      Effect.mapError(() =>
+        LedgerError.make({
+          operation: "submit",
+          message: "Admission fields do not satisfy the ledger contract",
+        }),
       ),
     );
 
+    if (workerAdmission !== undefined) {
+      const admitted = yield* workerAdmissionPort
+        .admit(
+          WorkerAdmissionRequest.make({
+            ...request,
+            workerAdmission,
+            producerId: config.producerId,
+          }),
+        )
+        .pipe(
+          Effect.provideService(SubmissionLedger, ledger),
+          Effect.provideService(ThreadStore, store),
+          Effect.provideService(WakeScheduler, wake),
+          Effect.provideService(DurableRuntimeFailpoint, failpoint),
+        );
+
+      return Receipt.make({
+        receiptId: admitted.receiptId,
+        submissionId: admitted.submissionId,
+        threadId: request.threadId,
+        queueSequence: admitted.queueSequence,
+      });
+    }
+    const admitted = yield* ledger.admit(request);
+
     yield* hit("submit:after-admit");
 
     const receipt = Receipt.make({
@@ -10160,15 +10129,6 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
     }
     yield* materializeAtLeast(options.threadId, ZERO_EPOCH);
     yield* ensureThreadCreated(options.threadId, agent.definition.id, options.definitions);
-    if (workerAdmission !== undefined) {
-      yield* workerRuntime
-        .ensureOrigin(workerAdmission.origin)
-        .pipe(
-          Effect.mapError((cause) =>
-            LedgerError.make({ operation: "worker-origin", message: cause.reason, cause }),
-          ),
-        );
-    }
     yield* hit("submit:after-materialize");
     yield* ledger.markReady(MarkReadyRequest.make({ submissionId: admitted.submissionId }));
     yield* wake.notify(options.threadId);

package/src/durable/WorkerAdmission.ts

@@ -0,0 +1,104 @@
+import { Context, Effect, Schema } from "effect";
+
+import { DurableRuntimeFailpoint, DurableRuntimeFailpointError } from "./DurableFailpoint.ts";
+import { ensureThreadCreated, ensureWorkerOrigin } from "./internal/thread-initialization.ts";
+import { ProducerEpoch, ProducerId, WorkerAdmission } from "./Records.ts";
+import {
+  AdmissionConflict,
+  AdmissionPolicyError,
+  AdmissionRequest,
+  LedgerError,
+  MarkReadyRequest,
+  SubmissionLedger,
+} from "./SubmissionLedger.ts";
+import {
+  AppendConflict,
+  FenceRejected,
+  ThreadMaterialization,
+  ThreadNotMaterialized,
+  ThreadStore,
+  ThreadStoreError,
+} from "./ThreadStore.ts";
+import { WakeScheduler } from "./WakeScheduler.ts";
+
+/**
+ * Storage admission after source authorization, input validation and capacity reservation.
+ * This is an internal host port, not an authorization entrypoint. Hosts route the whole
+ * operation to the destination owner and enroll recovery before executing it.
+ */
+export class WorkerAdmissionRequest extends Schema.Class<WorkerAdmissionRequest>(
+  "@effect-agent/thread/WorkerAdmissionRequest",
+)({
+  ...AdmissionRequest.fields,
+  workerAdmission: WorkerAdmission,
+  producerId: ProducerId,
+}) {}
+
+export const WorkerAdmissionFailure = Schema.Union([
+  AdmissionConflict,
+  AdmissionPolicyError,
+  LedgerError,
+  ThreadStoreError,
+  ThreadNotMaterialized,
+  AppendConflict,
+  FenceRejected,
+  DurableRuntimeFailpointError,
+]);
+
+/** Local implementation shared by every host; retries finish the same admitted row. */
+export const admitWorker = Effect.fn("WorkerAdmission.admitWorker")(function* (
+  request: WorkerAdmissionRequest,
+) {
+  const origin = request.workerAdmission.origin;
+
+  if (
+    origin.worker.threadId !== request.threadId ||
+    origin.worker.targetAgentId !== request.agentId ||
+    request.parentLinkage !== undefined
+  )
+    return yield* LedgerError.make({
+      operation: "admit worker",
+      message: "Worker admission does not belong to the destination Thread",
+    });
+
+  const ledger = yield* SubmissionLedger;
+  const store = yield* ThreadStore;
+  const wake = yield* WakeScheduler;
+  const failpoint = yield* DurableRuntimeFailpoint;
+  const admitted = yield* ledger.admit(AdmissionRequest.make(request));
+
+  yield* failpoint.hit("submit:after-admit");
+  if (admitted.replayed && admitted.state !== "admitted") return admitted;
+
+  yield* store
+    .materialize(
+      ThreadMaterialization.make({
+        threadId: request.threadId,
+        producerEpoch: Schema.decodeSync(ProducerEpoch)(0),
+      }),
+    )
+    .pipe(Effect.catchTag("FenceRejected", () => Effect.void));
+
+  const config = {
+    producerId: request.producerId,
+    deploymentId: request.deploymentId,
+  };
+
+  yield* ensureThreadCreated(config, request.threadId, request.agentId, request.agentDigests);
+  yield* ensureWorkerOrigin(config, origin).pipe(
+    Effect.mapError((cause) =>
+      LedgerError.make({ operation: "worker-origin", message: cause.reason, cause }),
+    ),
+  );
+  yield* failpoint.hit("submit:after-materialize");
+  yield* ledger.markReady(MarkReadyRequest.make({ submissionId: admitted.submissionId }));
+  yield* wake.notify(request.threadId);
+
+  return admitted;
+});
+
+/** Placement adapter for the composite operation; local hosts use the same implementation. */
+export const WorkerAdmissionPort = Context.Reference<{ readonly admit: typeof admitWorker }>(
+  "@effect-agent/thread/WorkerAdmissionPort",
+  { defaultValue: () => ({ admit: admitWorker }) },
+);

package/src/durable/internal/thread-initialization.ts

@@ -0,0 +1,195 @@
+import { DateTime, Effect, Schema } from "effect";
+
+import type { AgentId, ThreadId } from "../../core/Identifiers.ts";
+import { WorkerError } from "../../core/Worker.ts";
+import { DurableRuntimeFailpoint } from "../DurableFailpoint.ts";
+import {
+  BatchId,
+  CanonicalBatch,
+  RecordEnvelope,
+  RecordId,
+  ThreadCreated,
+  WorkerOrigin,
+  WorkerOriginRecorded,
+  type DefinitionDigests,
+  type DeploymentId,
+  type ProducerId,
+} from "../Records.ts";
+import { workerOriginRecordId } from "../RunJournal.ts";
+import type {
+  AppendConflict,
+  FenceRejected,
+  ThreadNotMaterialized,
+  ThreadStoreError,
+} from "../ThreadStore.ts";
+import {
+  FencedAppendRequest,
+  ThreadIdentityRequest,
+  ThreadTailRequest,
+  ThreadStore,
+} from "../ThreadStore.ts";
+import { WakeScheduler } from "../WakeScheduler.ts";
+import { definitionDigestsEqual } from "./agent-registration.ts";
+
+interface InitializationConfig {
+  readonly producerId: ProducerId;
+  readonly deploymentId: DeploymentId;
+}
+
+/** Stable identities retained across admission retries and recovery. */
+export const threadCreatedBatchId = (threadId: ThreadId): BatchId =>
+  Schema.decodeSync(BatchId)(`thread-created:${threadId}`);
+
+export const threadCreatedRecordId = (threadId: ThreadId): RecordId =>
+  Schema.decodeSync(RecordId)(`thread-created:${threadId}`);
+
+/**
+ * Coordinator invariant: every Thread's first canonical record is `ThreadCreated`,
+ * so `tailSequence >= 1` is the deterministic already-created check. A lost race (conflict or
+ * fence) is verified against that invariant instead of being trusted blindly. An admitted
+ * child can be claimed before it is runnable; that advances the shared storage fence without
+ * appending anything. Re-read and retry that initialization race with the current fence.
+ */
+export const ensureThreadCreated = Effect.fn("DurableAgentRuntime.ensureThreadCreated")(
+  function* (
+    config: InitializationConfig,
+    threadId: ThreadId,
+    agentId: AgentId,
+    definitions: DefinitionDigests,
+  ): Effect.fn.Return<
+    void,
+    ThreadStoreError | ThreadNotMaterialized | AppendConflict | FenceRejected,
+    ThreadStore | WakeScheduler
+  > {
+    const store = yield* ThreadStore;
+    const wake = yield* WakeScheduler;
+    const tail = yield* store.inspectTail(ThreadTailRequest.make({ threadId }));
+
+    if (tail.tailSequence > 0) return;
+
+    const record = yield* Effect.map(DateTime.now, (createdAt) =>
+      RecordEnvelope.make({
+        recordId: threadCreatedRecordId(threadId),
+        family: "thread",
+        schemaVersion: 1,
+        createdAt,
+        deploymentId: config.deploymentId,
+        payload: ThreadCreated.make({ agentId, definitions }),
+      }),
+    );
+
+    yield* store
+      .append(
+        FencedAppendRequest.make({
+          threadId,
+          batch: CanonicalBatch.make({
+            batchId: threadCreatedBatchId(threadId),
+            producerId: config.producerId,
+            records: [record],
+          }),
+          expectedTailSequence: tail.tailSequence,
+          expectedTailDigest: tail.tailDigest,
+          producerEpoch: tail.producerEpoch,
+        }),
+      )
+      .pipe(
+        Effect.catchTag(["AppendConflict", "FenceRejected"], (error) =>
+          store
+            .inspectTail(ThreadTailRequest.make({ threadId }))
+            .pipe(
+              Effect.flatMap((current) =>
+                current.tailSequence > 0 ? Effect.void : Effect.fail(error),
+              ),
+            ),
+        ),
+        Effect.andThen(wake.notify(threadId)),
+        Effect.asVoid,
+      );
+  },
+  (effect) =>
+    effect.pipe(
+      Effect.retry({
+        times: 7,
+        while: (error) => error._tag === "AppendConflict" || error._tag === "FenceRejected",
+      }),
+    ),
+);
+
+const sameOrigin = Schema.toEquivalence(WorkerOrigin);
+
+export const ensureWorkerOrigin = Effect.fn("WorkerHost.ensureOrigin")(
+  function* (config: InitializationConfig, origin: WorkerOrigin) {
+    const store = yield* ThreadStore;
+    const failpoint = yield* DurableRuntimeFailpoint;
+
+    for (let attempt = 0; attempt < 16; attempt++) {
+      const current = yield* store.readIdentity(
+        ThreadIdentityRequest.make({ threadId: origin.worker.threadId }),
+      );
+
+      const existing = current.records.find(
+        ({ record }) => record.payload._tag === "WorkerOriginRecorded",
+      )?.record.payload;
+
+      if (existing?._tag === "WorkerOriginRecorded") {
+        if (!sameOrigin(existing.origin, origin))
+          return yield* WorkerError.make({ operation: "start", reason: "worker-mismatch" });
+
+        return;
+      }
+      const first = current.records[0]?.record.payload;
+
+      if (
+        first?._tag !== "ThreadCreated" ||
+        first.agentId !== origin.worker.targetAgentId ||
+        !definitionDigestsEqual(first.definitions, origin.targetDigests) ||
+        current.records.some(({ record }) => record.payload._tag === "SubagentLineageRecorded")
+      )
+        return yield* WorkerError.make({ operation: "start", reason: "worker-mismatch" });
+      const id = workerOriginRecordId(origin.worker.threadId);
+
+      yield* failpoint.hit("worker:before-origin-append");
+
+      const appended = yield* store
+        .append(
+          FencedAppendRequest.make({
+            threadId: origin.worker.threadId,
+            producerEpoch: current.producerEpoch,
+            expectedTailSequence: current.tailSequence,
+            expectedTailDigest: current.tailDigest,
+            batch: CanonicalBatch.make({
+              batchId: Schema.decodeSync(BatchId)(id),
+              producerId: config.producerId,
+              records: [
+                RecordEnvelope.make({
+                  recordId: id,
+                  family: "thread",
+                  schemaVersion: 1,
+                  createdAt: DateTime.makeUnsafe(origin.createdAtMillis),
+                  deploymentId: config.deploymentId,
+                  payload: WorkerOriginRecorded.make({ origin }),
+                }),
+              ],
+            }),
+          }),
+        )
+        .pipe(
+          Effect.as(true),
+          Effect.catchTag(["AppendConflict", "FenceRejected"], () => Effect.succeed(false)),
+        );
+
+      if (appended) {
+        yield* failpoint.hit("worker:after-origin-append");
+
+        return;
+      }
+    }
+
+    return yield* WorkerError.make({ operation: "start", reason: "storage" });
+  },
+  Effect.mapError((cause) =>
+    cause._tag === "WorkerError"
+      ? cause
+      : WorkerError.make({ operation: "start", reason: "storage", cause }),
+  ),
+);