@effect-agent/testing 0.0.1-beta.6 → 0.1.0-beta.100

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

@@ -1,17 +1,16 @@
-import { SubagentReservationsMemoryLive } from "@effect-agent/capabilities";
-import { Agent } from "@effect-agent/core";
+import { Duration, Effect, Layer, Schema, Stream } from "effect";
+import * as Agent from "effect-agent/agent";
+import { DurableWorkerBinding, type ResolvedBinding } from "effect-agent/agent-registration";
+import { type Receipt } from "effect-agent/durable-agent-runtime";
 import {
   DefinitionDigests,
   DeploymentId,
   Digest,
-  DurableWorkerBinding,
   ProducerId,
   type CanonicalRecordEnvelope,
-  type Receipt,
-  type ResolvedBinding,
-  type ToolReconciler,
-} from "@effect-agent/session";
-import { Duration, Effect, Layer, Schema, Stream } from "effect";
+} from "effect-agent/records";
+import { SubagentReservationsMemoryLive } from "effect-agent/subagent-reservations";
+import { type ToolReconciler } from "effect-agent/tool-reconciler";
 import { LanguageModel, Model, type Response } from "effect/unstable/ai";
 
 import { TravelPlan, TripRequest } from "./definition.ts";
@@ -54,58 +53,17 @@ import {
   encodedDestinationReport,
 } from "./subagents.ts";
 
-// ---------------------------------------------------------------------------
-// Phase 6 (P6): the SAME cumulative Travel Planner on the Cloudflare Durable
-// Object runtime, deployment class DC. This module is deliberately
-// platform-neutral (it imports no Cloudflare types): the worker Bindings it
-// builds are plain `ResolvedBinding` values a Conversation Object registers,
-// and the cross-platform evidence normal form is shared by the DN and DC
-// halves of the equivalence suite (plan §1.8, D-P6-6).
-// ---------------------------------------------------------------------------
-
-/**
- * The Phase 6 profile: the P4/P5/S2 Travel Planner claims re-earned on the Cloudflare Durable
- * Object runtime (deployment class `DC`), where eviction and alarm redelivery replace process
- * kill and restart as the exercised recovery path. `cloudflareEquivalence` is the claim the S2
- * fixture explicitly deferred to P6 (`TravelPlannerSubagentDurabilityProfile` pins it `false`
- * for `DN`): it flips to `true` here ONLY because the phase-6 suites assert byte-equal
- * cross-platform normalized canonical evidence against one committed golden. Exactly-once
- * EXTERNAL effects remain — deliberately — unclaimed on every platform (DUR-003).
- */
-export class TravelPlannerCloudflareProfile extends Schema.Class<TravelPlannerCloudflareProfile>(
-  "@effect-agent/testing/travel-planner/TravelPlannerCloudflareProfile",
-)({
-  deploymentClass: Schema.Literal("DC"),
-  durableAcceptedWork: Schema.Literal(true),
-  canonicalSchemaVersion: Schema.Literal(1),
-  /** P5 semantics under DC recovery: prepared/settled records, Unknown Outcomes, approvals. */
-  supplierBookingUncertaintyProtocol: Schema.Literal(true),
-  /** S2 semantics under DC recovery: cross-Object establishment/join, completed child never re-runs. */
-  durableAttachedSubagents: Schema.Literal(true),
-  /** DN and DC produce byte-equal cross-platform normalized canonical evidence (one golden). */
-  cloudflareEquivalence: Schema.Literal(true),
-  /** Never claimed at any phase on any platform (DUR-003). */
-  exactlyOnceExternalEffects: Schema.Literal(false),
-}) {}
-
-export const phase6TravelPlannerProfile = TravelPlannerCloudflareProfile.make({
-  deploymentClass: "DC",
-  durableAcceptedWork: true,
-  canonicalSchemaVersion: 1,
-  supplierBookingUncertaintyProtocol: true,
-  durableAttachedSubagents: true,
-  cloudflareEquivalence: true,
-  exactlyOnceExternalEffects: false,
-});
-
+/** Platform-neutral bindings and canonical evidence shared by Node and Cloudflare tests. */
 export const phase6TravelPlannerDeploymentId = Schema.decodeSync(DeploymentId)(
   "travel-planner-p6-deployment",
 );
-/** Producer prefix of the DC host; each Object mints `{prefix}:{conversationId}`. */
+
+/** Producer prefix of the DC host; each Object mints `{prefix}:{threadId}`. */
 export const phase6TravelPlannerProducerPrefix = "travel-planner-p6-producer";
-/** The full producer identity one DC Conversation Object mints for itself. */
-export const phase6TravelPlannerProducerId = (conversationId: string): ProducerId =>
-  Schema.decodeSync(ProducerId)(`${phase6TravelPlannerProducerPrefix}:${conversationId}`);
+
+/** The full producer identity one DC Thread Object mints for itself. */
+export const phase6TravelPlannerProducerId = (threadId: string): ProducerId =>
+  Schema.decodeSync(ProducerId)(`${phase6TravelPlannerProducerPrefix}:${threadId}`);
 
 const digestOf = (character: string) => Schema.decodeSync(Digest)(character.repeat(64));
 
@@ -127,11 +85,11 @@ export const phase6GatedPlannerDefinitionDigests = DefinitionDigests.make({
 
 /** The run-specific identities the cross-platform normal form scrubs. */
 export interface CrossPlatformEvidenceIdentity {
-  /** The Conversation lane the evidence came from. */
-  readonly conversationId: string;
+  /** The Thread lane the evidence came from. */
+  readonly threadId: string;
   /** The host's deployment identity (`DeploymentId` on every record envelope). */
   readonly deploymentId: string;
-  /** The full producer identity of the run (DN: configured; DC: `{prefix}:{conversationId}`). */
+  /** The full producer identity of the run (DN: configured; DC: `{prefix}:{threadId}`). */
   readonly producerId: string;
 }
 
@@ -143,12 +101,13 @@ const ComparableEnvelope = Schema.Struct({
   sequence: Schema.Number,
   record: Schema.Json,
 });
+
 const decodeComparableEnvelopes = Schema.decodeUnknownEffect(Schema.Array(ComparableEnvelope));
 
 /**
  * The CROSS-PLATFORM extension of `normalizeDurableTravelPlannerEvidence` (D-P6-6): after the
  * base normalization replaces the two ledger-minted identities (which also normalizes the
- * DC-format routable `{uuidv7}:{conversationId}` Submission identities and everything derived
+ * DC-format routable `{uuidv7}:{threadId}` Submission identities and everything derived
  * from them), this form additionally scrubs everything that legitimately differs between a DN
  * process and a DC Durable Object over the same scenario:
  *
@@ -158,7 +117,7 @@ const decodeComparableEnvelopes = Schema.decodeUnknownEffect(Schema.Array(Compar
  *   control (on DC even a CLEAN run carries one, because every pass reconciles before it
  *   claims, so the ready lane's input is applied through the recovery path). Canonical ORDER
  *   is the durability §5 claim; sequence contiguity is a platform artifact of who appended;
- * - the Conversation identity (DC lanes mint unique names per test run);
+ * - the Thread identity (DC lanes mint unique names per test run);
  * - the deployment and producer identities (host configuration, not canonical semantics);
  * - `createdAt` commit timestamps (wall clock);
  * - 64-hex digests (they hash RAW content that legally embeds run-specific identity, so they
@@ -180,15 +139,18 @@ export const normalizeCrossPlatformTravelPlannerEvidence = Effect.fn(
   const canonical = records.filter(
     (envelope) => envelope.record.payload._tag !== "RepairAnnotated",
   );
+
   const base = yield* normalizeDurableTravelPlannerEvidence(canonical, receipt);
+
   const scrubbed: unknown = JSON.parse(
     JSON.stringify(base)
       .replaceAll(identity.producerId, "{producerId}")
       .replaceAll(identity.deploymentId, "{deploymentId}")
-      .replaceAll(identity.conversationId, "{conversationId}")
+      .replaceAll(identity.threadId, "{threadId}")
       .replaceAll(/\d{4}-\d{2}-\d{2}T[0-9:.]+Z/g, "{timestamp}")
       .replaceAll(/"[0-9a-f]{64}"/g, '"{digest}"'),
   );
+
   const comparable = yield* decodeComparableEnvelopes(scrubbed).pipe(
     Effect.mapError((error) =>
       TravelPlannerDurableEvidenceError.make({
@@ -196,11 +158,13 @@ export const normalizeCrossPlatformTravelPlannerEvidence = Effect.fn(
       }),
     ),
   );
+
   const renumbered = comparable.map((entry, index) => ({
     batchId: entry.batchId,
     sequence: index + 1,
     record: entry.record,
   }));
+
   return yield* decodeComparableJson(renumbered).pipe(
     Effect.mapError((error) =>
       TravelPlannerDurableEvidenceError.make({
@@ -286,12 +250,18 @@ const plannerDecide = (promptJson: string): Stream.Stream<Response.StreamPartEnc
  * batch is committed history, every later request gets the plan — identical parts, so the DC
  * canonical evidence is byte-equivalent to the DN ScriptedModel run after normalization.
  */
-export const phase6PlannerModel = promptAwareModel("travel-planner-phase-4", plannerDecide);
+export const phase6PlannerModel = promptAwareModel("travel-planner-phase-4", (promptJson) =>
+  promptJson.includes("[gate:") && !promptJson.includes(phase6FlightCallId)
+    ? Stream.fromEffectDrain(awaitPlannerGate(gateMarkerFromPrompt(promptJson))).pipe(
+        Stream.concat(plannerDecide(promptJson)),
+      )
+    : plannerDecide(promptJson),
+);
 
 // ---------------------------------------------------------------------------
 // Deterministic test gate for the admission-limits rows. Module state is
 // intentionally NOT durable: it plays the external world's role (a slow
-// upstream model), never Conversation state.
+// upstream model), never Thread state.
 // ---------------------------------------------------------------------------
 
 const releasedPlannerGates = new Set<string>();
@@ -318,7 +288,7 @@ const gateMarkerFromPrompt = (promptJson: string): string =>
 
 /** A trip whose request text carries the gate marker the gated model waits on. */
 export const phase6GatedTrip = (marker: string): TripRequest =>
-  Schema.decodeUnknownSync(TripRequest)({
+  Schema.decodeSync(TripRequest)({
     request: `Plan a review-only London trip, but wait for the concierge. [gate:${marker}]`,
     origin: "SFO",
     destination: "LHR",
@@ -345,6 +315,7 @@ export const phase6GatedPlannerModel = Model.make(
         Stream.unwrap(
           Effect.sync(() => {
             const promptJson = JSON.stringify(options.prompt);
+
             return promptJson.includes(phase6FlightCallId)
               ? plannerDecide(promptJson)
               : Stream.fromEffectDrain(awaitPlannerGate(gateMarkerFromPrompt(promptJson))).pipe(
@@ -381,7 +352,7 @@ export const phase6SupplierDeskLayer: Layer.Layer<SupplierBookingDesk> = Layer.s
 
 /**
  * The REAL P5 supplier reconciliation policy over the shared desk, closed to no requirements
- * so a Conversation Object can install it directly: `book_flight` recovers only from supplier
+ * so a Thread Object can install it directly: `book_flight` recovers only from supplier
  * truth (absence stays fail-closed `Uncertain` → durable Unknown Outcome), keyed Steps are
  * provably re-enterable.
  */
@@ -400,7 +371,7 @@ export const phase6BookingRef = (marker: string): string =>
 
 /** A trip whose request text carries the per-lane booking case marker. */
 export const phase6BookingTrip = (marker: string): TripRequest =>
-  Schema.decodeUnknownSync(TripRequest)({
+  Schema.decodeSync(TripRequest)({
     request: `Book the approved London flight for the traveler. [case:${marker}]`,
     origin: "SFO",
     destination: "LHR",
@@ -448,6 +419,7 @@ const bookingReportParts = (marker: string): ReadonlyArray<Response.StreamPartEn
  */
 export const phase6BookingModel = promptAwareModel("travel-planner-phase-5", (promptJson) => {
   const marker = bookingMarkerFromPrompt(promptJson);
+
   return promptJson.includes(phase6BookingToolCallId(marker))
     ? Stream.fromIterable(bookingReportParts(marker))
     : Stream.fromIterable(bookingCallParts(marker));
@@ -471,13 +443,14 @@ const countingGuideLayer = Layer.succeed(
     lookup: (query) =>
       Effect.suspend(() => {
         guideInvocations += 1;
+
         return destinationLookup(query);
       }),
   }),
 );
 
 /** The one-candidate research mission of the DC delegation slice. */
-export const phase6ResearchMission = Schema.decodeUnknownSync(ResearchMission)({
+export const phase6ResearchMission = Schema.decodeSync(ResearchMission)({
   request: "Shortlist one September culture city for the DC delegation slice.",
   candidates: ["LHR"],
 });
@@ -576,14 +549,14 @@ export const phase6ResearcherModel = promptAwareModel("destination-researcher-p6
 );
 
 // ---------------------------------------------------------------------------
-// Worker Binding registrations for the DC Conversation Object
+// Worker Binding registrations for the DC Thread Object
 // ---------------------------------------------------------------------------
 
 /**
- * Every phase-6 Travel Planner worker Binding, captured with its requirement Contexts
- * (spec/subagents.md §11): the P4 planner and its gated twin, the P5 booking agent over the
+ * Every phase-6 Travel Planner worker Binding, captured with its requirement Contexts:
+ * one P4 planner whose prompt selects the optional test gate, the P5 booking agent over the
  * shared supplier desk, and the S2 coordinator/researcher pair wired through the durable
- * delegation Layer. A Conversation Object registers these via its `bindings` option; the
+ * delegation Layer. A Thread Object registers these via its `bindings` option; the
  * capture runs once per incarnation, and everything stateful the assertions rely on (desk,
  * guide counter, gates) lives at module level so it survives incarnation loss.
  */
@@ -594,11 +567,6 @@ export const makePhase6TravelPlannerBindings: Effect.Effect<ReadonlyArray<Resolv
       phase4TravelPlannerDefinitionDigests,
     ).pipe(Effect.provide(phase4TravelPlannerWorkerLayer));
 
-    const gatedPlanner: ResolvedBinding = yield* DurableWorkerBinding.make(
-      Agent.withModel(TravelPlannerPhase4, phase6GatedPlannerModel),
-      phase6GatedPlannerDefinitionDigests,
-    ).pipe(Effect.provide(phase4TravelPlannerWorkerLayer));
-
     const booking: ResolvedBinding = yield* DurableWorkerBinding.make(
       Agent.withModel(TravelPlannerPhase5, phase6BookingModel),
       phase5TravelPlannerDefinitionDigests,
@@ -609,6 +577,7 @@ export const makePhase6TravelPlannerBindings: Effect.Effect<ReadonlyArray<Resolv
     );
 
     const researcherBinding = Agent.withModel(DestinationResearcher, phase6ResearcherModel);
+
     const childToolkitLayer = DestinationResearcherToolkitLayer.pipe(
       Layer.provideMerge(countingGuideLayer),
     );
@@ -636,7 +605,7 @@ export const makePhase6TravelPlannerBindings: Effect.Effect<ReadonlyArray<Resolv
       s2ResearcherDigests,
     ).pipe(Effect.provide(childToolkitLayer));
 
-    return [planner, gatedPlanner, booking, coordinator, researcher];
+    return [planner, booking, coordinator, researcher];
   });
 
 // ---------------------------------------------------------------------------
@@ -651,21 +620,21 @@ export const makePhase6TravelPlannerBindings: Effect.Effect<ReadonlyArray<Resolv
  * value, so the two platforms' canonical outcomes are byte-equivalent transitively — the P6
  * exit gate "Travel Planner produces equivalent canonical outcomes under DN and DC".
  *
- * Regenerate ONLY when the Travel Planner scenario itself changes, by printing either suite's
+ * Regenerate ONLY when the Travel Planner scenario or canonical protocol changes, by printing either suite's
  * normalized value; both suites must then agree on the new golden.
  */
 export const phase6TravelPlannerGoldenEvidence: Schema.Json = [
   {
-    batchId: "conversation-created:{conversationId}",
+    batchId: "thread-created:{threadId}",
     sequence: 1,
     record: {
-      recordId: "conversation-created:{conversationId}",
-      family: "conversation",
+      recordId: "thread-created:{threadId}",
+      family: "thread",
       schemaVersion: 1,
       createdAt: "{timestamp}",
       deploymentId: "{deploymentId}",
       payload: {
-        _tag: "ConversationCreated",
+        _tag: "ThreadCreated",
         agentId: "travel-planner-phase-4",
         definitions: {
           agent: "{digest}",
@@ -680,7 +649,7 @@ export const phase6TravelPlannerGoldenEvidence: Schema.Json = [
     sequence: 2,
     record: {
       recordId: "input:{submissionId}",
-      family: "conversation",
+      family: "thread",
       schemaVersion: 1,
       createdAt: "{timestamp}",
       deploymentId: "{deploymentId}",
@@ -704,19 +673,83 @@ export const phase6TravelPlannerGoldenEvidence: Schema.Json = [
     },
   },
   {
-    batchId: "turn-response:run:{submissionId}:1",
+    batchId: "run-start:run:{submissionId}",
     sequence: 3,
+    record: {
+      recordId: "run-start:run:{submissionId}",
+      family: "thread",
+      schemaVersion: 1,
+      createdAt: "{timestamp}",
+      deploymentId: "{deploymentId}",
+      payload: {
+        _tag: "RunStarted",
+        runId: "run:{submissionId}",
+        policyAccountingVersion: 1,
+        maxDurationMillis: 30_000,
+      },
+    },
+  },
+  {
+    batchId: "turn-response:run:{submissionId}:1",
+    sequence: 4,
     record: {
       recordId: "model-response:run:{submissionId}:1",
-      family: "conversation",
+      family: "thread",
       schemaVersion: 1,
       createdAt: "{timestamp}",
       deploymentId: "{deploymentId}",
       payload: {
         _tag: "ModelResponseRecorded",
+        toolOperations: [
+          {
+            toolCallId: "flight-call-1",
+            toolName: "search_flights",
+            executionClass: "readonly",
+            executionKind: "ordinary",
+            replay: "{digest}",
+          },
+          {
+            toolCallId: "lodging-call-1",
+            toolName: "search_lodging",
+            executionClass: "readonly",
+            executionKind: "ordinary",
+            replay: "{digest}",
+          },
+          {
+            toolCallId: "activity-call-1",
+            toolName: "search_activities",
+            executionClass: "readonly",
+            executionKind: "ordinary",
+            replay: "{digest}",
+          },
+        ],
         runId: "run:{submissionId}",
         turnId: "turn:run:{submissionId}:1",
         turn: 1,
+        inputTokens: 128,
+        outputTokens: 96,
+        runScopedPrefixLength: 2,
+        modelUsage: [
+          {
+            provider: "scripted",
+            model: "travel-planner-phase-4",
+            purpose: "turn",
+            usageStatus: "partial",
+            pricingStatus: "unknown",
+            inputTokens: {
+              total: 128,
+              uncached: 128,
+              cacheRead: 0,
+              cacheWrite: 0,
+            },
+            outputTokens: {
+              total: 96,
+              text: 96,
+              reasoning: 0,
+            },
+            costMicrousd: 0,
+          },
+        ],
         messages: {
           content: [
             {
@@ -784,10 +817,10 @@ export const phase6TravelPlannerGoldenEvidence: Schema.Json = [
   },
   {
     batchId: "turn-results:run:{submissionId}:1",
-    sequence: 4,
+    sequence: 5,
     record: {
       recordId: "tool-settled:run:{submissionId}:1:flight-call-1",
-      family: "conversation",
+      family: "thread",
       schemaVersion: 1,
       createdAt: "{timestamp}",
       deploymentId: "{deploymentId}",
@@ -808,10 +841,10 @@ export const phase6TravelPlannerGoldenEvidence: Schema.Json = [
   },
   {
     batchId: "turn-results:run:{submissionId}:1",
-    sequence: 5,
+    sequence: 6,
     record: {
       recordId: "tool-settled:run:{submissionId}:1:lodging-call-1",
-      family: "conversation",
+      family: "thread",
       schemaVersion: 1,
       createdAt: "{timestamp}",
       deploymentId: "{deploymentId}",
@@ -831,10 +864,10 @@ export const phase6TravelPlannerGoldenEvidence: Schema.Json = [
   },
   {
     batchId: "turn-results:run:{submissionId}:1",
-    sequence: 6,
+    sequence: 7,
     record: {
       recordId: "tool-settled:run:{submissionId}:1:activity-call-1",
-      family: "conversation",
+      family: "thread",
       schemaVersion: 1,
       createdAt: "{timestamp}",
       deploymentId: "{deploymentId}",
@@ -852,10 +885,10 @@ export const phase6TravelPlannerGoldenEvidence: Schema.Json = [
   },
   {
     batchId: "turn:run:{submissionId}:2",
-    sequence: 7,
+    sequence: 8,
     record: {
       recordId: "model-response:run:{submissionId}:2",
-      family: "conversation",
+      family: "thread",
       schemaVersion: 1,
       createdAt: "{timestamp}",
       deploymentId: "{deploymentId}",
@@ -864,6 +897,29 @@ export const phase6TravelPlannerGoldenEvidence: Schema.Json = [
         runId: "run:{submissionId}",
         turnId: "turn:run:{submissionId}:2",
         turn: 2,
+        inputTokens: 128,
+        outputTokens: 96,
+        modelUsage: [
+          {
+            provider: "scripted",
+            model: "travel-planner-phase-4",
+            purpose: "turn",
+            usageStatus: "partial",
+            pricingStatus: "unknown",
+            inputTokens: {
+              total: 128,
+              uncached: 128,
+              cacheRead: 0,
+              cacheWrite: 0,
+            },
+            outputTokens: {
+              total: 96,
+              text: 96,
+              reasoning: 0,
+            },
+            costMicrousd: 0,
+          },
+        ],
         messages: {
           content: [
             {
@@ -878,12 +934,51 @@ export const phase6TravelPlannerGoldenEvidence: Schema.Json = [
       },
     },
   },
+  {
+    batchId: "turn:run:{submissionId}:2",
+    sequence: 9,
+    record: {
+      recordId: "run-completed:run:{submissionId}",
+      family: "thread",
+      schemaVersion: 1,
+      createdAt: "{timestamp}",
+      deploymentId: "{deploymentId}",
+      payload: {
+        _tag: "RunCompleted",
+        resultDigest: "{digest}",
+        runId: "run:{submissionId}",
+        output: {
+          itineraries: [
+            {
+              title: "Westward light, eastbound overnight",
+              route: "San Francisco → London",
+              dates: "14–19 September 2026",
+              flight: "EA 218 · nonstop · SFO 18:40 → LHR 13:05+1",
+              lodging: "Bloomsbury House · refundable studio · 4 nights",
+              activities: ["British Museum timed entry", "Thames evening walk"],
+              estimatedTotalCents: 284000,
+              currency: "USD",
+              quoteId: "quote-sfo-lhr-001",
+              assumptions: [
+                "Two travelers sharing one studio",
+                "Quote is read-only availability, not a reservation",
+              ],
+              unresolvedConstraints: [
+                "Traveler names and accessibility requests are intentionally omitted",
+              ],
+              nextAction: "review",
+            },
+          ],
+        },
+      },
+    },
+  },
   {
     batchId: "submission-settlement:{submissionId}",
-    sequence: 8,
+    sequence: 10,
     record: {
       recordId: "settlement:{submissionId}",
-      family: "conversation",
+      family: "thread",
       schemaVersion: 1,
       createdAt: "{timestamp}",
       deploymentId: "{deploymentId}",
@@ -917,6 +1012,43 @@ export const phase6TravelPlannerGoldenEvidence: Schema.Json = [
             },
           ],
         },
+        usageSummary: {
+          usageStatus: "partial",
+          pricingStatus: "unknown",
+          unobservedModelCalls: 0,
+          modelCalls: 2,
+          inputTokens: {
+            total: 256,
+            uncached: 256,
+            cacheRead: 0,
+            cacheWrite: 0,
+          },
+          outputTokens: {
+            total: 192,
+            text: 192,
+            reasoning: 0,
+          },
+          costMicrousd: 0,
+          byModel: [
+            {
+              provider: "scripted",
+              model: "travel-planner-phase-4",
+              modelCalls: 2,
+              inputTokens: {
+                total: 256,
+                uncached: 256,
+                cacheRead: 0,
+                cacheWrite: 0,
+              },
+              outputTokens: {
+                total: 192,
+                text: 192,
+                reasoning: 0,
+              },
+              costMicrousd: 0,
+            },
+          ],
+        },
       },
     },
   },