@effect-agent/testing 0.1.0-beta.38 → 0.1.0-beta.40

package/src/certification.ts

@@ -7,7 +7,7 @@ import {
 import {
   Agent,
   AgentPolicy,
-  ConversationId,
+  ThreadId,
   IdGenerator,
   RunId,
   ToolCallId,
@@ -17,19 +17,16 @@ import {
 } from "@effect-agent/core";
 import { DurableStep, DurableStepError } from "@effect-agent/engine";
 import {
-  AgentBindingResolver,
   ApprovalDecisionCommand,
-  ConversationExportRequest,
-  ConversationStore,
+  ThreadExportRequest,
+  ThreadStore,
   DefinitionDigests,
   DeploymentId,
   Digest,
   DurableAgentRuntime,
   DurableRuntimeConfig,
-  DurableRuntimeFailpoint,
   DurableRuntimeFailpointError,
   DurableRuntimeFailpointLocation,
-  DurableRuntimeFailpointTestControl,
   DurableWorkerBinding,
   IdempotencyKey,
   LoadCheckpointRequest,
@@ -42,16 +39,17 @@ import {
   UnknownResolutionCommand,
   WakeScheduler,
   DEFAULT_OWNERSHIP_LEASE_DURATION,
-  childConversationIdFor,
-  verifyConversationInvariants,
+  childThreadIdFor,
+  verifyThreadInvariants,
   type BatchId,
   type DurableSubmitFailure,
   type DurableSubmitOptions,
   type Receipt,
   type ResolvedBinding,
   type SubmissionSnapshot,
-} from "@effect-agent/session";
+} from "@effect-agent/thread";
 import {
+  DurableRuntimeFailpointTestControl,
   type CertificationCaseResult,
   CertificationReport,
   CertificationSweepResult,
@@ -59,7 +57,7 @@ import {
   CertifiedAdapterIdentity,
   certifyPorts,
   type CertificationScenario,
-} from "@effect-agent/session/testing";
+} from "@effect-agent/thread/testing";
 import type { Crypto } from "effect";
 import {
   Cause,
@@ -89,7 +87,7 @@ import { LanguageModel, Model, Tool, Toolkit, type Response } from "effect/unsta
  *   (plain / uncertain-tool / durable-steps / approval / join / delegation). After the injected
  *   fault the runner asserts the state stays CLASSIFIABLE (recovery + the public unblocking
  *   operations `resolveUnknown`/`resolveApproval` are the only levers used) and that the
- *   re-drive CONVERGES to `verifyConversationInvariants` with `requireAllSettled` — including a
+ *   re-drive CONVERGES to `verifyThreadInvariants` with `requireAllSettled` — including a
  *   fully discharged digest-chain check, because the runner captures per-batch producer
  *   identity at append time.
  * - **Tier 3 — real loss lever**: recorded honestly. A durable adapter either supplies a
@@ -128,7 +126,7 @@ export interface CertifyDurableAdaptersOptions<LedgerE = never, StoreE = never>
    * does); the certification's own environment supplies nothing else.
    */
   readonly submissionLedger: Layer.Layer<SubmissionLedger, LedgerE, Crypto.Crypto>;
-  readonly conversationStore: Layer.Layer<ConversationStore, StoreE, Crypto.Crypto>;
+  readonly threadStore: Layer.Layer<ThreadStore, StoreE, Crypto.Crypto>;
   /** Defaults to `WakeScheduler.layerNoop`; the runner re-drives lanes explicitly. */
   readonly wakeScheduler?: Layer.Layer<WakeScheduler> | undefined;
   /** Executes Tier 3 in this run; takes precedence over `tierThreeEvidence`. */
@@ -173,6 +171,10 @@ export const TIER2_UNREACHED_LOCATIONS: ReadonlyArray<DurableRuntimeFailpointLoc
   // RUN-026 rows in `packages/testing/test/durable-runtime.test.ts`
   // (compaction failpoint idempotence across re-drive).
   "compaction:after-canonical-append",
+  // These shapes use neither programmatic Tools nor grace finalization. Their reservations
+  // are exercised before/after append in the public durable-runtime regression suite.
+  "policy:before-reservation-append",
+  "policy:after-reservation-append",
   "resolve:after-intent",
   "subagent:after-child-abort-intent",
 ];
@@ -205,7 +207,7 @@ const CHILD_DIGESTS = DefinitionDigests.make({
   tools: Schema.decodeSync(Digest)(CHILD_DIGEST_STRINGS.tools),
 });
 const PRINCIPAL = Schema.decodeSync(Principal)("principal-certification");
-const decodeConversationId = Schema.decodeSync(ConversationId);
+const decodeThreadId = Schema.decodeSync(ThreadId);
 const decodeIdempotencyKey = Schema.decodeSync(IdempotencyKey);
 const decodeToolCallId = Schema.decodeSync(ToolCallId);
 
@@ -280,7 +282,7 @@ const QuestionInput = Schema.Struct({ question: Schema.String });
 const AnswerOutput = Schema.Struct({ answer: Schema.String });
 
 /** plain / join: no tools — the pure Turn/submission/join seams. */
-const plainDefinition = Agent.define("certify-plain", {
+const plainDefinition = Agent.make("certify-plain", {
   input: QuestionInput,
   output: AnswerOutput,
   instructions: "Answer as JSON.",
@@ -294,7 +296,7 @@ const Book = Tool.make("book", {
   success: Schema.Struct({ confirmation: Schema.String }),
 });
 const bookToolkit = Toolkit.make(Book);
-const uncertainDefinition = Agent.define("certify-uncertain", {
+const uncertainDefinition = Agent.make("certify-uncertain", {
   input: QuestionInput,
   output: AnswerOutput,
   instructions: "Book it.",
@@ -310,7 +312,7 @@ const Itinerary = Tool.make("itinerary", {
   dependencies: [DurableStep],
 });
 const itineraryToolkit = Toolkit.make(Itinerary);
-const stepsDefinition = Agent.define("certify-steps", {
+const stepsDefinition = Agent.make("certify-steps", {
   input: QuestionInput,
   output: AnswerOutput,
   instructions: "Reserve the itinerary.",
@@ -325,7 +327,7 @@ const BookApproval = Tool.make("book", {
   needsApproval: true,
 });
 const approvalToolkit = Toolkit.make(BookApproval);
-const approvalDefinition = Agent.define("certify-approval", {
+const approvalDefinition = Agent.make("certify-approval", {
   input: QuestionInput,
   output: AnswerOutput,
   instructions: "Book after approval.",
@@ -334,7 +336,7 @@ const approvalDefinition = Agent.define("certify-approval", {
 });
 
 /** delegation: durable attached child plus an ordinary uncertain sibling in ONE batch. */
-const childDefinition = Agent.define("certify-child", {
+const childDefinition = Agent.make("certify-child", {
   input: QuestionInput,
   output: AnswerOutput,
   instructions: "Answer as JSON.",
@@ -374,7 +376,7 @@ const Lookup = Tool.make("lookup", {
   success: Schema.Struct({ value: Schema.String }),
 });
 
-const coordinatorDefinition = Agent.define("certify-coordinator", {
+const coordinatorDefinition = Agent.make("certify-coordinator", {
   input: Schema.Struct({ mission: Schema.String }),
   output: Schema.Struct({ report: Schema.String }),
   instructions: "Delegate and look up, then answer as JSON.",
@@ -402,7 +404,7 @@ const identifiers = Layer.effect(
         Effect.map((value) => decode(`${prefix}-${value}`)),
       );
     return {
-      nextConversationId: next(decodeConversationId, "certify-fixture-conversation"),
+      nextThreadId: next(decodeThreadId, "certify-fixture-thread"),
       nextRunId: next(Schema.decodeSync(RunId), "certify-fixture-run"),
       nextTurnId: next(Schema.decodeSync(TurnId), "certify-fixture-turn"),
     };
@@ -416,15 +418,15 @@ const delegationSupport = Layer.mergeAll(SubagentReservationsMemoryLive, identif
 // ---------------------------------------------------------------------------
 
 interface CertificationCell {
-  readonly resolver: (typeof AgentBindingResolver)["Service"];
+  readonly bindings: ReadonlyArray<ResolvedBinding>;
   /** Idempotent submission batch — safe to replay verbatim after a submit-boundary fault. */
   readonly submit: Effect.Effect<ReadonlyArray<Receipt>, DurableSubmitFailure, DurableAgentRuntime>;
   /** All lanes of the cell in drive order, computed from the (possibly replayed) receipts. */
-  readonly lanes: (receipts: ReadonlyArray<Receipt>) => ReadonlyArray<ConversationId>;
+  readonly lanes: (receipts: ReadonlyArray<Receipt>) => ReadonlyArray<ThreadId>;
 }
 
-const submitOptionsFor = (slug: string, conversationId: ConversationId): DurableSubmitOptions => ({
-  conversationId,
+const submitOptionsFor = (slug: string, threadId: ThreadId): DurableSubmitOptions => ({
+  threadId,
   principal: PRINCIPAL,
   idempotencyKey: decodeIdempotencyKey(`certify-key-${slug}`),
   definitions: DIGESTS,
@@ -436,20 +438,20 @@ const makeSingleAgentCell = (
   resolved: ResolvedBinding,
   slug: string,
 ): CertificationCell => {
-  const conversationId = decodeConversationId(`certify-${slug}`);
+  const threadId = decodeThreadId(`certify-${slug}`);
   const submit = Effect.gen(function* () {
     const runtime = yield* DurableAgentRuntime;
     const receipt = yield* runtime.submit(
       { definition: { id: definition.id, input: definition.input } },
       { question: `certify ${slug}` },
-      submitOptionsFor(slug, conversationId),
+      submitOptionsFor(slug, threadId),
     );
     return [receipt];
   });
   return {
-    resolver: AgentBindingResolver.fromBindings([resolved]),
+    bindings: [resolved],
     submit,
-    lanes: () => [conversationId],
+    lanes: () => [threadId],
   };
 };
 
@@ -537,7 +539,7 @@ const makeCell = Effect.fn("Certification.makeCell")(function* (
         promptShapeModel("certify-join", '{"answer":"host answer"}'),
       );
       const resolved = yield* DurableWorkerBinding.make(binding, DIGESTS);
-      const conversationId = decodeConversationId(`certify-${slug}`);
+      const threadId = decodeThreadId(`certify-${slug}`);
       const submitOne = (key: string, question: string) =>
         Effect.gen(function* () {
           const runtime = yield* DurableAgentRuntime;
@@ -545,7 +547,7 @@ const makeCell = Effect.fn("Certification.makeCell")(function* (
             { definition: { id: plainDefinition.id, input: plainDefinition.input } },
             { question },
             {
-              conversationId,
+              threadId,
               principal: PRINCIPAL,
               idempotencyKey: decodeIdempotencyKey(key),
               definitions: DIGESTS,
@@ -553,13 +555,13 @@ const makeCell = Effect.fn("Certification.makeCell")(function* (
           );
         });
       const cell: CertificationCell = {
-        resolver: AgentBindingResolver.fromBindings([resolved]),
+        bindings: [resolved],
         submit: Effect.gen(function* () {
           const host = yield* submitOne(`certify-key-${slug}-host`, "host question");
           const queued = yield* submitOne(`certify-key-${slug}-queued`, "queued question");
           return [host, queued];
         }),
-        lanes: () => [conversationId],
+        lanes: () => [threadId],
       };
       return cell;
     }
@@ -590,23 +592,23 @@ const makeCell = Effect.fn("Certification.makeCell")(function* (
         Effect.provide(Layer.mergeAll(delegationLayer, lookupLayer)),
       );
       const childResolved = yield* DurableWorkerBinding.make(childBinding, CHILD_DIGESTS);
-      const conversationId = decodeConversationId(`certify-${slug}`);
+      const threadId = decodeThreadId(`certify-${slug}`);
       const cell: CertificationCell = {
-        resolver: AgentBindingResolver.fromBindings([parentResolved, childResolved]),
+        bindings: [parentResolved, childResolved],
         submit: Effect.gen(function* () {
           const runtime = yield* DurableAgentRuntime;
           const receipt = yield* runtime.submit(
             { definition: { id: coordinatorDefinition.id, input: coordinatorDefinition.input } },
             { mission: "plan" },
-            submitOptionsFor(slug, conversationId),
+            submitOptionsFor(slug, threadId),
           );
           return [receipt];
         }),
         lanes: (receipts) => {
           const parent = receipts.at(0);
           return parent === undefined
-            ? [conversationId]
-            : [conversationId, childConversationIdFor(parent.submissionId, DELEGATE_CALL)];
+            ? [threadId]
+            : [threadId, childThreadIdFor(parent.submissionId, DELEGATE_CALL)];
         },
       };
       return cell;
@@ -624,16 +626,16 @@ const MAX_REDRIVE_ROUNDS = 8;
  * the digest chain is fully recomputed instead of skipped.
  */
 const verifyLane = Effect.fn("Certification.verifyLane")(function* (
-  lane: ConversationId,
+  lane: ThreadId,
   batchProducers: ReadonlyMap<BatchId, ProducerId>,
 ) {
-  const store = yield* ConversationStore;
+  const store = yield* ThreadStore;
   const ledger = yield* SubmissionLedger;
-  const exported = yield* store.export(ConversationExportRequest.make({ conversationId: lane }));
+  const exported = yield* store.export(ThreadExportRequest.make({ threadId: lane }));
   const rows = new Map<SubmissionId, SubmissionSnapshot>();
   const nonterminal = yield* Stream.runCollect(ledger.scanNonterminal);
   for (const submission of nonterminal) {
-    if (submission.conversationId === lane) rows.set(submission.submissionId, submission);
+    if (submission.threadId === lane) rows.set(submission.submissionId, submission);
   }
   const named = new Set<SubmissionId>();
   for (const envelope of exported.records) {
@@ -643,24 +645,26 @@ const verifyLane = Effect.fn("Certification.verifyLane")(function* (
       payload._tag === "SubmissionSettled" ||
       payload._tag === "AbortRequested"
     ) {
-      named.add(payload.submissionId);
+      if (payload.submissionId !== undefined) named.add(payload.submissionId);
     }
   }
   for (const submissionId of named) {
     if (rows.has(submissionId)) continue;
     const found = yield* ledger.lookup(SubmissionLookupById.make({ submissionId }));
-    if (Option.isSome(found) && found.value.conversationId === lane) {
+    if (Option.isSome(found) && found.value.threadId === lane) {
       rows.set(submissionId, found.value);
     }
   }
-  const checkpoint = yield* store.loadCheckpoint(
-    LoadCheckpointRequest.make({ conversationId: lane }),
-  );
-  return yield* verifyConversationInvariants({
+  const checkpoint =
+    store.checkpoints === undefined
+      ? Option.none()
+      : yield* store.checkpoints.load(LoadCheckpointRequest.make({ threadId: lane }));
+  return yield* verifyThreadInvariants({
     export: exported,
     submissions: [...rows.values()],
     batchProducers,
     checkpoint: Option.getOrUndefined(checkpoint),
+    checkpointsSupported: store.checkpoints !== undefined,
     requireAllSettled: true,
   });
 });
@@ -734,10 +738,7 @@ const runSweepCell = Effect.fn("Certification.runSweepCell")(function* (
   }
   const lanes = cell.lanes(receipts);
 
-  const driveLane = (lane: ConversationId) =>
-    runtime
-      .processConversationResolved(lane)
-      .pipe(Effect.provideService(AgentBindingResolver, cell.resolver));
+  const driveLane = (lane: ThreadId) => runtime.processThreadResolved(lane, cell.bindings);
 
   const allSettled = Effect.gen(function* () {
     for (const receipt of receipts) {
@@ -750,7 +751,7 @@ const runSweepCell = Effect.fn("Certification.runSweepCell")(function* (
   });
 
   // Re-drive to convergence using ONLY public operations: worker drives, recovery passes,
-  // and the authorized DUR-017/approval unblocking paths chosen from `explainConversation`.
+  // and the authorized DUR-017/approval unblocking paths chosen from `explainThread`.
   let converged = false;
   for (let round = 0; round < MAX_REDRIVE_ROUNDS && !converged; round++) {
     // Expire any lease a faulted Attempt left behind (D5): virtual time is the
@@ -761,7 +762,7 @@ const runSweepCell = Effect.fn("Certification.runSweepCell")(function* (
       yield* Effect.exit(driveLane(lane));
     }
     for (const lane of lanes) {
-      const explains = yield* Effect.exit(runtime.explainConversation(lane));
+      const explains = yield* Effect.exit(runtime.explainThread(lane));
       if (Exit.isFailure(explains)) continue;
       for (const explanation of explains.value) {
         for (const unknown of explanation.evidence.unknownCalls) {
@@ -873,9 +874,12 @@ export const resolveTierThree = Effect.fn("Certification.resolveTierThree")(func
   if (options.crashLever !== undefined) {
     const cases = yield* options.crashLever;
     return CertificationTierThreeReport.make({
-      status: "exercised",
+      status: cases.length === 0 ? "not-exercised" : "exercised",
       evidence: options.tierThreeEvidence ?? [],
       cases,
+      ...(cases.length === 0
+        ? { detail: "the supplied crash lever executed no real-loss cases" }
+        : {}),
     });
   }
   if (options.tierThreeEvidence !== undefined && options.tierThreeEvidence.length > 0) {
@@ -914,12 +918,12 @@ export const certifyDurableAdapters = <LedgerE = never, StoreE = never>(
 ): Effect.Effect<CertificationReport, LedgerE | StoreE, Crypto.Crypto> => {
   const batchProducers = new Map<BatchId, ProducerId>();
   // Interpose the candidate store with an append-time capture of each batch's producer
-  // identity — the one value the ConversationStore port deliberately does not export — so
+  // identity — the one value the ThreadStore port deliberately does not export — so
   // Tier 2's invariant verification recomputes the FULL digest chain instead of skipping it.
-  const capturingStore = Layer.effect(ConversationStore)(
+  const capturingStore = Layer.effect(ThreadStore)(
     Effect.gen(function* () {
-      const inner = yield* ConversationStore;
-      return ConversationStore.of({
+      const inner = yield* ThreadStore;
+      return ThreadStore.of({
         ...inner,
         append: (request) =>
           Effect.sync(() => {
@@ -927,13 +931,13 @@ export const certifyDurableAdapters = <LedgerE = never, StoreE = never>(
           }).pipe(Effect.andThen(inner.append(request))),
       });
     }),
-  ).pipe(Layer.provide(options.conversationStore));
+  ).pipe(Layer.provide(options.threadStore));
 
   const support = Layer.mergeAll(
     options.submissionLedger,
     capturingStore,
     options.wakeScheduler ?? WakeScheduler.layerNoop,
-    DurableRuntimeFailpoint.layerTest,
+    DurableRuntimeFailpointTestControl.layer,
     ToolReconciler.uncertain,
     DurableRuntimeConfig.layer({
       deploymentId: Schema.decodeSync(DeploymentId)("deployment-certification"),
@@ -976,7 +980,7 @@ export const certifyDurableAdapters = <LedgerE = never, StoreE = never>(
       tier3.cases.every((result) => result.status === "passed");
 
     return CertificationReport.make({
-      format: "effect-agent/certification@1",
+      format: "effect-agent/certification@2",
       adapter: CertifiedAdapterIdentity.make({
         name: options.adapter.name,
         ...(options.adapter.version === undefined ? {} : { version: options.adapter.version }),
@@ -987,6 +991,12 @@ export const certifyDurableAdapters = <LedgerE = never, StoreE = never>(
       tier2,
       tier3,
       ok,
+      fullyCertified:
+        ok &&
+        capabilities.durability !== "non-durable" &&
+        tier3.status === "exercised" &&
+        tier3.cases.length > 0 &&
+        tier3.cases.every((result) => result.suite === "real-loss"),
     });
   });