@effect-agent/testing 0.1.0-beta.9 → 0.1.0-beta.90

package/src/fixtures/travel-planner/phase3.ts

@@ -1,45 +1,27 @@
-import { AgentId, ConversationId, RunId, SubmissionId } from "@effect-agent/core";
+import { Effect, Schema } from "effect";
+import { AgentId, ThreadId, RunId, SubmissionId } from "effect-agent/identifiers";
 import {
   BatchId,
   CanonicalBatch,
-  ConversationCheckpoint,
-  ConversationProjection,
   DefinitionDigests,
   DeploymentId,
   Digest,
   ProducerId,
   RecordEnvelope,
   RecordId,
-} from "@effect-agent/session";
-import { Effect, Schema } from "effect";
+} from "effect-agent/records";
+import { ThreadProjection } from "effect-agent/thread-projection";
+import { ThreadCheckpoint } from "effect-agent/thread-store";
 
 import { TravelPlan, TripRequest } from "./definition.ts";
 import { expectedTravelPlan, phase1Trip } from "./scenarios.ts";
 
-/**
- * The Phase 3 profile persists Conversation history but deliberately does not
- * claim durable admission or recovery of accepted work.
- */
-export class TravelPlannerPersistenceProfile extends Schema.Class<TravelPlannerPersistenceProfile>(
-  "@effect-agent/testing/travel-planner/TravelPlannerPersistenceProfile",
-)({
-  deploymentClass: Schema.Literal("P"),
-  durableAcceptedWork: Schema.Literal(false),
-  canonicalSchemaVersion: Schema.Literal(1),
-}) {}
-
-export const phase3TravelPlannerProfile = TravelPlannerPersistenceProfile.make({
-  deploymentClass: "P",
-  durableAcceptedWork: false,
-  canonicalSchemaVersion: 1,
-});
+export const phase3TravelPlannerThreadId = Schema.decodeSync(ThreadId)("travel-planner-p3-thread");
 
-export const phase3TravelPlannerConversationId = Schema.decodeSync(ConversationId)(
-  "travel-planner-p3-conversation",
-);
 export const phase3TravelPlannerProducerId = Schema.decodeSync(ProducerId)(
   "travel-planner-p3-producer",
 );
+
 export const phase3TravelPlannerRunId = Schema.decodeSync(RunId)("travel-planner-p3-run");
 
 const deploymentId = Schema.decodeSync(DeploymentId)("travel-planner-p3-scripted");
@@ -61,7 +43,7 @@ const travelPlanOutput = Schema.encodeSync(TravelPlan)(expectedTravelPlan);
 const record = (recordId: string, createdAt: string, payload: unknown) =>
   Schema.decodeUnknownSync(RecordEnvelope)({
     recordId: Schema.decodeSync(RecordId)(recordId),
-    family: "conversation",
+    family: "thread",
     schemaVersion: 1,
     createdAt,
     deploymentId,
@@ -69,7 +51,7 @@ const record = (recordId: string, createdAt: string, payload: unknown) =>
   });
 
 /**
- * The first atomic append establishes the Conversation and records its input.
+ * The first atomic append establishes the Thread and records its input.
  * Its encoded value is the redacted current-version persistence fixture.
  */
 export const phase3TravelPlannerInitialBatch = CanonicalBatch.make({
@@ -77,7 +59,7 @@ export const phase3TravelPlannerInitialBatch = CanonicalBatch.make({
   producerId: phase3TravelPlannerProducerId,
   records: [
     record("travel-planner-p3-created", "2026-09-01T00:00:00.000Z", {
-      _tag: "ConversationCreated",
+      _tag: "ThreadCreated",
       agentId,
       definitions: phase3TravelPlannerDefinitionDigests,
     }),
@@ -115,9 +97,8 @@ export const phase3TravelPlannerBatches = [
 ] as const;
 
 /** Portable current-version fixture; it contains no passenger identity or credentials. */
-export const phase3TravelPlannerEncodedFixture = Schema.encodeSync(Schema.Array(CanonicalBatch))(
-  phase3TravelPlannerBatches,
-);
+export const phase3TravelPlannerEncodedFixture: ReadonlyArray<typeof CanonicalBatch.Encoded> =
+  Schema.encodeSync(Schema.Array(CanonicalBatch))(phase3TravelPlannerBatches);
 
 export class TravelPlannerProjectionError extends Schema.TaggedError<TravelPlannerProjectionError>()(
   "TravelPlannerProjectionError",
@@ -126,9 +107,10 @@ export class TravelPlannerProjectionError extends Schema.TaggedError<TravelPlann
 
 /** Decode the itinerary projection rebuilt from canonical model-completion records. */
 export const travelPlanFromProjection = (
-  projection: ConversationProjection,
+  projection: ThreadProjection,
 ): Effect.Effect<TravelPlan, TravelPlannerProjectionError> => {
   const output = projection.modelOutputs.at(-1);
+
   if (output === undefined) {
     return Effect.fail(
       TravelPlannerProjectionError.make({
@@ -136,24 +118,19 @@ export const travelPlanFromProjection = (
       }),
     );
   }
+
   return Schema.decodeUnknownEffect(TravelPlan)(output).pipe(
     Effect.mapError((error) => TravelPlannerProjectionError.make({ message: error.message })),
   );
 };
 
 /** Build a disposable checkpoint bound to a validated canonical prefix. */
-export const makePhase3TravelPlannerCheckpoint = (
-  projection: ConversationProjection,
-): ConversationCheckpoint =>
-  Schema.decodeSync(ConversationCheckpoint)({
+export const makePhase3TravelPlannerCheckpoint = (projection: ThreadProjection): ThreadCheckpoint =>
+  Schema.decodeSync(ThreadCheckpoint)({
     schemaVersion: 1,
-    conversationId: projection.conversationId,
+    threadId: projection.threadId,
     throughSequence: projection.throughSequence,
     tailDigest: projection.tailDigest,
-    engineVersion: "phase-3-test-runtime",
-    agentDefinitionDigest: phase3TravelPlannerDefinitionDigests.agent,
-    modelDigest: phase3TravelPlannerDefinitionDigests.model,
-    toolDigest: phase3TravelPlannerDefinitionDigests.tools,
-    state: Schema.encodeSync(ConversationProjection)(projection),
+    state: Schema.encodeSync(ThreadProjection)(projection),
     createdAt: "2026-09-01T00:00:04.000Z",
   });

package/src/fixtures/travel-planner/phase4.ts

@@ -1,20 +1,20 @@
-import { Agent, AgentPolicy, type ConversationId } from "@effect-agent/core";
-import { ToolExecutionClass } from "@effect-agent/engine";
+import { Effect, Layer, Schema } from "effect";
+import * as Agent from "effect-agent/agent";
+import { AgentPolicy } from "effect-agent/agent-policy";
+import { type DurableSubmitOptions, type Receipt } from "effect-agent/durable-agent-runtime";
+import { ToolExecutionClass } from "effect-agent/durable-step";
+import { type ThreadId } from "effect-agent/identifiers";
 import {
   CanonicalRecordEnvelope,
   DefinitionDigests,
   DeploymentId,
   Digest,
-  Principal,
   ProducerId,
-  type DurableSubmitOptions,
-  type IdempotencyKey,
-  type Receipt,
-} from "@effect-agent/session";
-import { Effect, Layer, Schema } from "effect";
+} from "effect-agent/records";
+import { Principal, type IdempotencyKey } from "effect-agent/submission-ledger";
 import { Model, Tool, Toolkit } from "effect/unstable/ai";
 
-import { ScriptedModel, type ScriptedTurnInput } from "../../scripted-model.ts";
+import { ScriptedModel, type ScriptedTurnInput } from "../../ScriptedModel.ts";
 import {
   ActivityCatalog,
   ActivityQuery,
@@ -41,35 +41,14 @@ import {
 } from "./deterministic-layers.ts";
 import { phase1HappyPathTurns } from "./scenarios.ts";
 
-/**
- * The Phase 4 profile claims durable accepted work on the Node/SQLite runtime (deployment class
- * DN): once `submit` returns a Receipt, the Submission settles exactly once even across process
- * loss. The claim is limited to safe-to-repeat toolkits (D6): supplier booking is explicitly NOT
- * claimed safely replayable — replay-safe external mutation is P5 (Durable Tools) scope.
- */
-export class TravelPlannerDurabilityProfile extends Schema.Class<TravelPlannerDurabilityProfile>(
-  "@effect-agent/testing/travel-planner/TravelPlannerDurabilityProfile",
-)({
-  deploymentClass: Schema.Literal("DN"),
-  durableAcceptedWork: Schema.Literal(true),
-  canonicalSchemaVersion: Schema.Literal(1),
-  /** Supplier booking replay safety is P5 (Durable Tools) scope; DN does not claim it. */
-  supplierBookingReplaySafe: Schema.Literal(false),
-}) {}
-
-export const phase4TravelPlannerProfile = TravelPlannerDurabilityProfile.make({
-  deploymentClass: "DN",
-  durableAcceptedWork: true,
-  canonicalSchemaVersion: 1,
-  supplierBookingReplaySafe: false,
-});
-
 export const phase4TravelPlannerDeploymentId = Schema.decodeSync(DeploymentId)(
   "travel-planner-p4-deployment",
 );
+
 export const phase4TravelPlannerProducerId = Schema.decodeSync(ProducerId)(
   "travel-planner-p4-producer",
 );
+
 export const phase4TravelPlannerPrincipal = Schema.decodeSync(Principal)(
   "travel-planner-p4-principal",
 );
@@ -85,10 +64,10 @@ export const phase4TravelPlannerDefinitionDigests = DefinitionDigests.make({
 
 /** Durable admission options for one Travel Planner Submission on one trip lane. */
 export const phase4TravelPlannerSubmitOptions = (
-  conversationId: ConversationId,
+  threadId: ThreadId,
   idempotencyKey: IdempotencyKey,
 ): DurableSubmitOptions => ({
-  conversationId,
+  threadId,
   principal: phase4TravelPlannerPrincipal,
   idempotencyKey,
   definitions: phase4TravelPlannerDefinitionDigests,
@@ -112,6 +91,7 @@ export const DurableSearchFlights = Tool.make("search_flights", {
   failureMode: "error",
   dependencies: [FlightCatalog],
 }).annotate(ToolExecutionClass, "readonly");
+
 export const DurableSearchLodging = Tool.make("search_lodging", {
   parameters: Schema.Struct(LodgingQuery.fields),
   success: LodgingOption,
@@ -119,6 +99,7 @@ export const DurableSearchLodging = Tool.make("search_lodging", {
   failureMode: "error",
   dependencies: [LodgingCatalog],
 }).annotate(ToolExecutionClass, "readonly");
+
 export const DurableSearchActivities = Tool.make("search_activities", {
   parameters: Schema.Struct(ActivityQuery.fields),
   success: ActivitySearchResult,
@@ -147,7 +128,7 @@ export const TravelPlannerPhase4ToolkitLayer = TravelPlannerPhase4Toolkit.toLaye
  * runtime. The searches are read-only and safe to repeat across Attempts (D6); supplier booking
  * is deliberately absent because DN does NOT claim replay-safe external mutation (P5 scope).
  */
-export const TravelPlannerPhase4 = Agent.define("travel-planner-phase-4", {
+export const TravelPlannerPhase4 = Agent.make("travel-planner-phase-4", {
   input: TripRequest,
   output: TravelPlan,
   instructions: (input) =>
@@ -208,10 +189,12 @@ export const travelPlanFromDurableSettlement = Effect.fn(
   const settlements = records.flatMap((envelope) =>
     envelope.record.payload._tag === "SubmissionSettled" ? [envelope.record.payload] : [],
   );
+
   const settled = settlements.at(0);
+
   if (settled === undefined) {
     return yield* TravelPlannerDurableEvidenceError.make({
-      message: "The canonical Conversation Log has no SubmissionSettled record.",
+      message: "The canonical Thread Log has no SubmissionSettled record.",
     });
   }
   if (settled.outcome !== "completed" || settled.result === undefined) {
@@ -219,6 +202,7 @@ export const travelPlanFromDurableSettlement = Effect.fn(
       message: `The Submission settled ${settled.outcome} without a completed itinerary result.`,
     });
   }
+
   return yield* Schema.decodeUnknownEffect(TravelPlan)(settled.result).pipe(
     Effect.mapError((error) =>
       TravelPlannerDurableEvidenceError.make({
@@ -235,7 +219,7 @@ const decodeComparableJson = Schema.decodeUnknownEffect(Schema.Json);
  * Project canonical evidence into a Submission-identity-independent comparable form: batch
  * identity, canonical sequence, and the full encoded record, with the ledger-minted
  * `submissionId`/`receiptId` (and every identity derived from them: run, turn, batch, record,
- * and settlement ids) replaced by stable placeholders. Two Conversations whose normalized
+ * and settlement ids) replaced by stable placeholders. Two Threads whose normalized
  * evidence is equal took byte-equivalent canonical histories, so restart-equivalence can compare
  * a recovered run against an uninterrupted control run on a separate database.
  */
@@ -252,16 +236,19 @@ export const normalizeDurableTravelPlannerEvidence = Effect.fn(
       }),
     ),
   );
+
   const comparable = encoded.map((envelope) => ({
     batchId: envelope.batchId,
     sequence: envelope.sequence,
     record: envelope.record,
   }));
+
   const substituted: unknown = JSON.parse(
     JSON.stringify(comparable)
       .replaceAll(receipt.submissionId, "{submissionId}")
       .replaceAll(receipt.receiptId, "{receiptId}"),
   );
+
   return yield* decodeComparableJson(substituted).pipe(
     Effect.mapError((error) =>
       TravelPlannerDurableEvidenceError.make({

package/src/fixtures/travel-planner/phase5.ts

@@ -1,22 +1,25 @@
-import { Agent, AgentPolicy, type ConversationId } from "@effect-agent/core";
-import { DurableStep, DurableStepError, ToolExecutionClass } from "@effect-agent/engine";
+import { Effect, Layer, Option, Schema } from "effect";
+import * as Agent from "effect-agent/agent";
+import { AgentPolicy } from "effect-agent/agent-policy";
+import { type DurableSubmitOptions } from "effect-agent/durable-agent-runtime";
+import { DurableStep, DurableStepError, ToolExecutionClass } from "effect-agent/durable-step";
+import { type ThreadId } from "effect-agent/identifiers";
 import {
   DefinitionDigests,
   DeploymentId,
   Digest,
   PersistedJson,
-  Principal,
   ProducerId,
+  type CanonicalRecordEnvelope,
+} from "effect-agent/records";
+import { Principal, type IdempotencyKey } from "effect-agent/submission-ledger";
+import {
   ReconciliationCompleted,
   ReconciliationSafeToRetry,
   ReconciliationUncertain,
   ToolReconciler,
   ToolReconcilerError,
-  type CanonicalRecordEnvelope,
-  type DurableSubmitOptions,
-  type IdempotencyKey,
-} from "@effect-agent/session";
-import { Effect, Layer, Option, Schema } from "effect";
+} from "effect-agent/tool-reconciler";
 import { Tool, Toolkit } from "effect/unstable/ai";
 
 import {
@@ -42,42 +45,14 @@ import {
 } from "./deterministic-layers.ts";
 import { DurableSearchActivities, DurableSearchFlights, DurableSearchLodging } from "./phase4.ts";
 
-/**
- * The Phase 5 profile extends the P4 `DN` claim to consequential supplier mutation: booking
- * Tools enter the prepared/settled uncertainty protocol, unresolved external effects stop at
- * Unknown Outcomes instead of replaying, Durable Steps replay recorded results, and queued
- * traveler input joins the active Run. Exactly-once EXTERNAL execution is still — deliberately —
- * not claimed (DUR-003): the supplier's own idempotency keys are what dedupe repeats.
- */
-export class TravelPlannerBookingProfile extends Schema.Class<TravelPlannerBookingProfile>(
-  "@effect-agent/testing/travel-planner/TravelPlannerBookingProfile",
-)({
-  deploymentClass: Schema.Literal("DN"),
-  durableAcceptedWork: Schema.Literal(true),
-  canonicalSchemaVersion: Schema.Literal(1),
-  /** P5: supplier mutations get prepared/settled records, Unknown Outcomes, and reconciliation. */
-  supplierBookingUncertaintyProtocol: Schema.Literal(true),
-  /** P5: Durable Steps are exactly-once-RECORDED; their side effects stay at-least-once. */
-  durableStepsRecorded: Schema.Literal(true),
-  /** Never claimed at any phase (DUR-003). */
-  exactlyOnceExternalEffects: Schema.Literal(false),
-}) {}
-
-export const phase5TravelPlannerProfile = TravelPlannerBookingProfile.make({
-  deploymentClass: "DN",
-  durableAcceptedWork: true,
-  canonicalSchemaVersion: 1,
-  supplierBookingUncertaintyProtocol: true,
-  durableStepsRecorded: true,
-  exactlyOnceExternalEffects: false,
-});
-
 export const phase5TravelPlannerDeploymentId = Schema.decodeSync(DeploymentId)(
   "travel-planner-p5-deployment",
 );
+
 export const phase5TravelPlannerProducerId = Schema.decodeSync(ProducerId)(
   "travel-planner-p5-producer",
 );
+
 export const phase5TravelPlannerPrincipal = Schema.decodeSync(Principal)(
   "travel-planner-p5-principal",
 );
@@ -93,10 +68,10 @@ export const phase5TravelPlannerDefinitionDigests = DefinitionDigests.make({
 
 /** Durable admission options for one Travel Planner Submission on one trip lane. */
 export const phase5TravelPlannerSubmitOptions = (
-  conversationId: ConversationId,
+  threadId: ThreadId,
   idempotencyKey: IdempotencyKey,
 ): DurableSubmitOptions => ({
-  conversationId,
+  threadId,
   principal: phase5TravelPlannerPrincipal,
   idempotencyKey,
   definitions: phase5TravelPlannerDefinitionDigests,
@@ -105,6 +80,7 @@ export const phase5TravelPlannerSubmitOptions = (
 export const TravelerRef = Schema.NonEmptyString.pipe(
   Schema.brand("@effect-agent/testing/travel-planner/TravelerRef"),
 );
+
 export type TravelerRef = typeof TravelerRef.Type;
 
 /**
@@ -171,6 +147,7 @@ export class TravelBookingReport extends Schema.Class<TravelBookingReport>("Trav
  * to query external truth — both sides are exported so they cannot drift.
  */
 export const bookFlightIdempotencyKey = (toolCallId: string): string => `book-flight:${toolCallId}`;
+
 export const itineraryStepIdempotencyKey = (toolCallId: string, stepName: string): string =>
   `${toolCallId}:${stepName}`;
 
@@ -205,7 +182,7 @@ export const CancelBooking = Tool.make("cancel_booking", {
 
 /**
  * The Durable Tool: declaring `DurableStep` in `dependencies` is what makes it durable
- * (CONTEXT.md). Its handler divides supplier mutation into three named Steps — `reserve-flight`,
+ * (GLOSSARY.md). Its handler divides supplier mutation into three named Steps — `reserve-flight`,
  * `reserve-lodging`, `issue-confirmation` — each deriving its supplier idempotency key from
  * `(toolCallId, stepName)`, so re-entry after interruption replays recorded Step results and the
  * supplier dedupes any honestly-repeated call. The Tool itself carries no execution-class
@@ -252,11 +229,13 @@ export const TravelPlannerPhase5ToolkitLayer = TravelPlannerPhase5Toolkit.toLaye
     Effect.gen(function* () {
       const desk = yield* SupplierBookingDesk;
       const toolCallId = yield* requireToolCallId("book_flight", context.toolCallId);
+
       const record = yield* desk.book({
         operation: "book-flight",
         idempotencyKey: bookFlightIdempotencyKey(toolCallId),
         detail: `flight ${request.quoteId} for ${request.travelerRef} on ${request.departOn}`,
       });
+
       return SupplierBookingConfirmation.make({
         bookingRef: record.bookingRef,
         status: "confirmed",
@@ -267,6 +246,7 @@ export const TravelPlannerPhase5ToolkitLayer = TravelPlannerPhase5Toolkit.toLaye
     Effect.gen(function* () {
       const desk = yield* SupplierBookingDesk;
       const record = yield* desk.cancel(request.bookingRef);
+
       return CancellationConfirmation.make({
         bookingRef: record.bookingRef,
         status: "cancelled",
@@ -277,6 +257,7 @@ export const TravelPlannerPhase5ToolkitLayer = TravelPlannerPhase5Toolkit.toLaye
       const desk = yield* SupplierBookingDesk;
       const step = yield* DurableStep;
       const toolCallId = yield* requireToolCallId("book_itinerary", context.toolCallId);
+
       const bookStep = (
         stepName: "reserve-flight" | "reserve-lodging" | "issue-confirmation",
         detail: string,
@@ -290,18 +271,22 @@ export const TravelPlannerPhase5ToolkitLayer = TravelPlannerPhase5Toolkit.toLaye
             detail,
           }),
         );
+
       const flight = yield* bookStep(
         "reserve-flight",
         `flight ${request.quoteId} for ${request.travelerRef}`,
       );
+
       const lodging = yield* bookStep(
         "reserve-lodging",
         `lodging ${request.destination} for ${request.nights} nights (${request.travelerRef})`,
       );
+
       const confirmation = yield* bookStep(
         "issue-confirmation",
         `itinerary confirmation for ${request.travelerRef}`,
       );
+
       return ItineraryConfirmation.make({
         flightBookingRef: flight.bookingRef,
         lodgingBookingRef: lodging.bookingRef,
@@ -336,6 +321,7 @@ export const TravelSupplierReconcilerLayer: Layer.Layer<
   ToolReconciler,
   Effect.gen(function* () {
     const desk = yield* SupplierBookingDesk;
+
     return ToolReconciler.of({
       reconcile: (evidence) =>
         Effect.gen(function* () {
@@ -343,6 +329,7 @@ export const TravelSupplierReconcilerLayer: Layer.Layer<
             case "book_flight": {
               const key = bookFlightIdempotencyKey(evidence.toolCallId);
               const booking = yield* desk.lookup(key);
+
               if (Option.isSome(booking) && booking.value.status === "confirmed") {
                 const confirmation = yield* encodeConfirmation(
                   SupplierBookingConfirmation.make({
@@ -351,8 +338,10 @@ export const TravelSupplierReconcilerLayer: Layer.Layer<
                     detail: booking.value.detail,
                   }),
                 ).pipe(Effect.flatMap(decodePersistedJson));
+
                 return ReconciliationCompleted.make({ result: confirmation, isFailure: false });
               }
+
               return ReconciliationUncertain.make({
                 reason: `The supplier desk shows no confirmed booking under ${key}; a write may still be in flight.`,
               });
@@ -384,7 +373,7 @@ export const TravelSupplierReconcilerLayer: Layer.Layer<
  * idempotent-by-contract cancellation, and one Durable Tool whose Steps carry supplier
  * idempotency keys.
  */
-export const TravelPlannerPhase5 = Agent.define("travel-planner-phase-5", {
+export const TravelPlannerPhase5 = Agent.make("travel-planner-phase-5", {
   input: TripRequest,
   output: TravelBookingReport,
   instructions: [
@@ -413,6 +402,7 @@ export class TravelPlannerBookingEvidenceError extends Schema.TaggedError<Travel
 const bookingResultRefs = (result: unknown): ReadonlyArray<string> => {
   if (typeof result !== "object" || result === null) return [];
   const refs: Array<string> = [];
+
   for (const [field, value] of Object.entries(result)) {
     if (
       typeof value === "string" &&
@@ -424,6 +414,7 @@ const bookingResultRefs = (result: unknown): ReadonlyArray<string> => {
       refs.push(value);
     }
   }
+
   return refs;
 };
 
@@ -443,8 +434,10 @@ export const assertSettledBookingsExistAtSupplier = Effect.fn(
   const desk = yield* SupplierBookingDesk;
   const bookings = yield* desk.bookings;
   const knownRefs = new Set<string>(bookings.map((booking) => booking.bookingRef));
+
   for (const envelope of records) {
     const payload = envelope.record.payload;
+
     if (
       payload._tag !== "ToolCallSettled" ||
       payload.isFailure ||