@effect-agent/testing 0.1.0-beta.8 → 0.1.0-beta.81

package/src/fixtures/travel-planner/subagents-durable.ts

@@ -1,33 +1,29 @@
 import {
   delegationAllocationFromPolicy,
-  SubagentReservationsMemoryLive,
   SubagentRuntime,
-} from "@effect-agent/capabilities";
-import { Agent, type ConversationId } from "@effect-agent/core";
-import type { RuntimeBinding } from "@effect-agent/engine";
-import {
-  DefinitionDigests,
-  DeploymentId,
-  Digest,
-  DurableWorkerBinding,
-  Principal,
-  ProducerId,
-  type DurableSubmitOptions,
-  type IdempotencyKey,
-  type ResolvedBinding,
-} from "@effect-agent/session";
+} from "@effect-agent/capabilities/Subagent";
+import { SubagentReservationsMemoryLive } from "@effect-agent/capabilities/SubagentReservations";
+import * as Agent from "@effect-agent/core/Agent";
+import { type ThreadId } from "@effect-agent/core/Identifiers";
+import { type RuntimeBinding } from "@effect-agent/engine/AgentRuntime";
+import { DurableWorkerBinding, type ResolvedBinding } from "@effect-agent/thread/AgentRegistration";
+import { type DurableSubmitOptions } from "@effect-agent/thread/DurableAgentRuntime";
+import { DefinitionDigests, DeploymentId, Digest, ProducerId } from "@effect-agent/thread/Records";
+import { Principal, type IdempotencyKey } from "@effect-agent/thread/SubmissionLedger";
 import { Effect, Layer, Ref, Schema, Stream } from "effect";
 import { LanguageModel, Model, type Response, type Toolkit } from "effect/unstable/ai";
 
 import { DeterministicIdGeneratorLayer } from "./deterministic-layers.ts";
-import {
+import type {
   DestinationBrief,
+  DestinationReport,
+  DestinationResearcherToolkit,
+} from "./subagents.ts";
+import {
   DestinationFacts,
   DestinationGuide,
   DestinationRecommendation,
-  DestinationReport,
   DestinationResearcher,
-  DestinationResearcherToolkit,
   DestinationResearcherToolkitLayer,
   destinationLookup,
   destinationReportFor,
@@ -40,46 +36,15 @@ import {
   TravelCoordinator,
 } from "./subagents.ts";
 
-// ---------------------------------------------------------------------------
-// S2 durability profile (spec/subagents.md §17): the S1 coordinator →
-// destination-researcher delegation re-run as ACCEPTED WORK on the Node/SQLite
-// runtime. The claim is `DN` durable attached Subagents only: establishment
-// and join are replay-safe by construction (SUB-016/SUB-019), a completed
-// child is never re-executed on a lost join acknowledgment, and NO claim of
-// exactly-once child external effects is made (rule 8; an unresolved ordinary
-// child Tool blocks as an Unknown Outcome instead, SUB-021). Cloudflare
-// equivalence is P6 scope and explicitly not claimed here.
-// ---------------------------------------------------------------------------
-
-export class TravelPlannerSubagentDurabilityProfile extends Schema.Class<TravelPlannerSubagentDurabilityProfile>(
-  "@effect-agent/testing/travel-planner/TravelPlannerSubagentDurabilityProfile",
-)({
-  deploymentClass: Schema.Literal("DN"),
-  durableAttachedSubagents: Schema.Literal(true),
-  canonicalSchemaVersion: Schema.Literal(1),
-  /** Establishment/join replay converges on one child Receipt, Conversation, and join batch. */
-  subagentReplaySafe: Schema.Literal(true),
-  /** Never claimed (rule 8): child ordinary Tools stop at Unknown Outcomes, they do not replay. */
-  childExternalEffectsExactlyOnce: Schema.Literal(false),
-  /** The same conformance suite under DO eviction/alarms is P6 scope (spec §17 `DC`). */
-  cloudflareEquivalence: Schema.Literal(false),
-}) {}
-
-export const s2TravelPlannerProfile = TravelPlannerSubagentDurabilityProfile.make({
-  deploymentClass: "DN",
-  durableAttachedSubagents: true,
-  canonicalSchemaVersion: 1,
-  subagentReplaySafe: true,
-  childExternalEffectsExactlyOnce: false,
-  cloudflareEquivalence: false,
-});
-
+/** Registered coordinator and researcher bindings for durable delegation tests. */
 export const s2TravelPlannerDeploymentId = Schema.decodeSync(DeploymentId)(
   "travel-planner-s2-deployment",
 );
+
 export const s2TravelPlannerProducerId = Schema.decodeSync(ProducerId)(
   "travel-planner-s2-producer",
 );
+
 export const s2TravelPlannerPrincipal = Schema.decodeSync(Principal)("travel-planner-s2-principal");
 
 const digestOf = (character: string) => Schema.decodeSync(Digest)(character.repeat(64));
@@ -94,7 +59,7 @@ export const s2CoordinatorDigests = DefinitionDigests.make({
 /**
  * The exact child Binding digest strings the application declares on
  * `SubagentRuntimeOptions.durable.targetDigests` AND the host registers with
- * the `AgentBindingResolver` for the researcher Binding. The coordinator
+ * the host's binding array for the researcher Binding. The coordinator
  * stores and verifies them byte-for-byte (SUB-023); a host registration under
  * different strings is a `ChildCompatibilityFailure`, never a substitution.
  */
@@ -112,10 +77,10 @@ export const s2ResearcherDigests = DefinitionDigests.make({
 
 /** Durable admission options for one coordinator Submission on one mission lane. */
 export const s2TravelPlannerSubmitOptions = (
-  conversationId: ConversationId,
+  threadId: ThreadId,
   idempotencyKey: IdempotencyKey,
 ): DurableSubmitOptions => ({
-  conversationId,
+  threadId,
   principal: s2TravelPlannerPrincipal,
   idempotencyKey,
   definitions: s2CoordinatorDigests,
@@ -166,6 +131,7 @@ export const durableResearchShortlist = (destination: string): DestinationShortl
  */
 export const encodedDestinationFacts = (destination: string): unknown => {
   const report = destinationReportFor(destination);
+
   return Schema.encodeSync(DestinationFacts)(
     DestinationFacts.make({
       destination: report.destination,
@@ -193,6 +159,7 @@ export const makeInvocationCountingModel = (
   Effect.gen(function* () {
     const calls = yield* Ref.make(0);
     const prompts = yield* Ref.make<ReadonlyArray<string>>([]);
+
     const model = Model.make(
       "scripted",
       name,
@@ -204,16 +171,19 @@ export const makeInvocationCountingModel = (
             Stream.unwrap(
               Effect.gen(function* () {
                 const call = yield* Ref.getAndUpdate(calls, (value) => value + 1);
+
                 yield* Ref.update(prompts, (previous) => [
                   ...previous,
                   JSON.stringify(request.prompt.content),
                 ]);
+
                 return Stream.fromIterable(script(call));
               }),
             ),
         }),
       ),
     );
+
     return { model, calls: Ref.get(calls), prompts: Ref.get(prompts) };
   });
 
@@ -304,7 +274,7 @@ export interface DurableResearchHarnessOptions {
 
 /** One durable coordinator/researcher pair with observable invocation counters. */
 export interface DurableResearchHarness {
-  /** Host registrations for `NodeDurableRuntimeOptions.bindings` (parent + child). */
+  /** Host registrations for `NodeDurableAgentRuntimeOptions.bindings` (parent + child). */
   readonly bindings: ReadonlyArray<ResolvedBinding>;
   /** Total coordinator model invocations across every Attempt and runtime handle. */
   readonly parentModelCalls: Effect.Effect<number>;
@@ -325,7 +295,7 @@ export interface DurableResearchHarness {
  * guide, Turn 2 writes the report), and both worker Bindings captured with
  * their requirement Contexts via `DurableWorkerBinding.make` under the exact
  * fixture digests. The returned `bindings` are plain values: they can be
- * registered with several `NodeDurableRuntime` stacks over the same SQLite
+ * registered with several `NodeDurableAgentRuntime` stacks over the same SQLite
  * file while the counters keep counting across all of them.
  */
 export const makeDurableResearchHarness = (options?: DurableResearchHarnessOptions) =>
@@ -334,6 +304,7 @@ export const makeDurableResearchHarness = (options?: DurableResearchHarnessOptio
     const focus = options?.focus ?? "museums";
 
     const guideInvocations = yield* Ref.make(0);
+
     const guideLayer = Layer.succeed(
       DestinationGuide,
       DestinationGuide.of({
@@ -343,6 +314,7 @@ export const makeDurableResearchHarness = (options?: DurableResearchHarnessOptio
           ),
       }),
     );
+
     const childToolkitLayer = DestinationResearcherToolkitLayer.pipe(
       Layer.provideMerge(guideLayer),
     );
@@ -350,6 +322,7 @@ export const makeDurableResearchHarness = (options?: DurableResearchHarnessOptio
     const childModel = yield* makeInvocationCountingModel("destination-researcher-s2", (call) =>
       call === 0 ? researcherLookupParts(destination) : researcherReportParts(destination),
     );
+
     const childBinding = Agent.withModel(DestinationResearcher, childModel.model);
 
     const parentModel = yield* makeInvocationCountingModel("travel-coordinator-s2", (call) =>
@@ -357,6 +330,7 @@ export const makeDurableResearchHarness = (options?: DurableResearchHarnessOptio
         ? delegationTurnParts(durableResearchCallId, destination, focus)
         : shortlistParts(durableResearchShortlist(destination)),
     );
+
     const parentBinding = Agent.withModel(TravelCoordinator, parentModel.model);
 
     const delegationLayer = durableDestinationResearchHandlersLayer(childBinding).pipe(
@@ -374,6 +348,7 @@ export const makeDurableResearchHarness = (options?: DurableResearchHarnessOptio
       parentBinding,
       s2CoordinatorDigests,
     ).pipe(Effect.provide(delegationLayer));
+
     const childResolved: ResolvedBinding = yield* DurableWorkerBinding.make(
       childBinding,
       options?.childRegistrationDigests ?? s2ResearcherDigests,
@@ -387,5 +362,6 @@ export const makeDurableResearchHarness = (options?: DurableResearchHarnessOptio
       childPrompts: childModel.prompts,
       guideInvocations: Ref.get(guideInvocations),
     };
+
     return harness;
   });

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

@@ -1,17 +1,18 @@
-import { Subagent, SubagentPolicy, SubagentRuntime } from "@effect-agent/capabilities";
-import { Agent, AgentPolicy } from "@effect-agent/core";
-import type { RuntimeBinding } from "@effect-agent/engine";
+import * as Subagent from "@effect-agent/capabilities/Subagent";
+import { SubagentPolicy, SubagentRuntime } from "@effect-agent/capabilities/Subagent";
+import * as Agent from "@effect-agent/core/Agent";
+import { AgentPolicy } from "@effect-agent/core/AgentPolicy";
+import { type RuntimeBinding } from "@effect-agent/engine/AgentRuntime";
 import { Context, Deferred, Effect, Layer, Ref, Schema, Stream } from "effect";
 import { LanguageModel, Model, type Response, Tool, Toolkit } from "effect/unstable/ai";
 
-import type { ScriptedTurnInput } from "../../scripted-model.ts";
+import type { ScriptedTurnInput } from "../../ScriptedModel.ts";
 import { AirportCode } from "./definition.ts";
 import { CatalogLifecycle } from "./deterministic-layers.ts";
 
 // ---------------------------------------------------------------------------
-// Destination Researcher: the S1 specialist child Agent
-// (spec/subagents.md §17 "deterministic scripted Travel Planner specialist
-// delegation"). The researcher is a normal Agent with one deterministic
+// Destination Researcher: the S1 specialist child Agent.
+// The researcher is a normal Agent with one deterministic
 // travel-service Tool; it never becomes a second child loop (SUB-001/003).
 // ---------------------------------------------------------------------------
 
@@ -51,6 +52,7 @@ export const LookupDestination = Tool.make("lookup_destination", {
 });
 
 export const DestinationResearcherToolkit = Toolkit.make(LookupDestination);
+
 export const DestinationResearcherToolkitLayer = DestinationResearcherToolkit.toLayer({
   lookup_destination: (query) => Effect.flatMap(DestinationGuide, (guide) => guide.lookup(query)),
 });
@@ -66,7 +68,7 @@ export class DestinationReport extends Schema.Class<DestinationReport>("Destinat
   advisory: Schema.NonEmptyString,
 }) {}
 
-export const DestinationResearcher = Agent.define("destination-researcher", {
+export const DestinationResearcher = Agent.make("destination-researcher", {
   input: DestinationBrief,
   output: DestinationReport,
   instructions:
@@ -112,6 +114,7 @@ export const destinationLookup = (
   query: DestinationQuery,
 ): Effect.Effect<DestinationFacts, DestinationGuideUnavailable> => {
   const facts = guideFacts.get(query.destination);
+
   return facts === undefined
     ? Effect.fail(
         DestinationGuideUnavailable.make({
@@ -124,15 +127,18 @@ export const destinationLookup = (
 
 const requireDestinationFacts = (destination: string): DestinationFacts => {
   const facts = guideFacts.get(destination);
+
   if (facts === undefined) {
     throw new Error(`No deterministic guide entry exists for destination ${destination}`);
   }
+
   return facts;
 };
 
 /** The report the scripted researcher writes after consulting the guide. */
 export const destinationReportFor = (destination: string): DestinationReport => {
   const facts = requireDestinationFacts(destination);
+
   return DestinationReport.make({
     destination: facts.destination,
     highlights: facts.highlights,
@@ -147,7 +153,9 @@ export const DestinationGuideLayer = Layer.effect(
   DestinationGuide,
   Effect.gen(function* () {
     const lifecycle = yield* CatalogLifecycle;
+
     yield* Effect.acquireRelease(lifecycle.markAcquired, () => lifecycle.markFinalized);
+
     return DestinationGuide.of({ lookup: destinationLookup });
   }),
 );
@@ -159,7 +167,7 @@ export const DestinationResearchSupportLayer = Layer.mergeAll(
 );
 
 // ---------------------------------------------------------------------------
-// Delegation Definition (spec/subagents.md §4): the coordinator sees exactly
+// Delegation Definition: the coordinator sees exactly
 // one Effect AI Tool with explicit input/result projections and finite bounds.
 // ---------------------------------------------------------------------------
 
@@ -189,7 +197,7 @@ export class DestinationResearchFailed extends Schema.TaggedError<DestinationRes
  * this gate before the handler reserves budget or spawns, so tests can order
  * concurrent delegation preflights without sleeps. It also keeps the
  * projection's construction requirements honestly visible in the handler
- * Layer's `R` (spec/subagents.md §4.1). The open Layer never waits.
+ * Layer's `R`. The open Layer never waits.
  */
 export class ResearchDispatchGate extends Context.Service<
   ResearchDispatchGate,
@@ -224,14 +232,16 @@ export const destinationResearchDelegation = Subagent.define("delegate_destinati
   prepareInput: (request) =>
     Effect.gen(function* () {
       const gate = yield* ResearchDispatchGate;
+
       yield* gate.awaitDispatch(request.destination);
+
       return DestinationBrief.make({
         destination: request.destination,
         focus: `research:${request.focus}`,
       });
     }),
   // The explicit declassification boundary (SUB-015): only the advisory
-  // crosses to the parent; guide highlights stay in the child Conversation.
+  // crosses to the parent; guide highlights stay in the child Thread.
   projectResult: (report) =>
     Effect.succeed(
       DestinationResearchFindings.make({
@@ -292,7 +302,7 @@ export const missionConfidentialMarker = "traveler-dossier-19f";
 
 export const TravelCoordinatorToolkit = Toolkit.make(destinationResearchDelegation.tool);
 
-export const TravelCoordinator = Agent.define("travel-coordinator", {
+export const TravelCoordinator = Agent.make("travel-coordinator", {
   input: ResearchMission,
   output: DestinationShortlist,
   instructions: [
@@ -314,7 +324,7 @@ export const TravelCoordinator = Agent.define("travel-coordinator", {
 });
 
 export const researchMission = Schema.decodeSync(ResearchMission)({
-  request: `Shortlist one September culture city; keep ${missionConfidentialMarker} inside the coordinator conversation.`,
+  request: `Shortlist one September culture city; keep ${missionConfidentialMarker} inside the coordinator thread.`,
   candidates: ["LHR", "CDG"],
 });
 
@@ -461,19 +471,23 @@ export const makeDestinationResearcherModel = (destinations: ReadonlyArray<strin
     const lifecycle = yield* CatalogLifecycle;
     const prompts = yield* Ref.make<ReadonlyArray<string>>([]);
     const gates = new Map<string, ResearcherGates>();
+
     for (const destination of destinations) {
       gates.set(destination, {
         started: yield* Deferred.make<void>(),
         release: yield* Deferred.make<void>(),
       });
     }
+
     const gatesFor = (destination: string): Effect.Effect<ResearcherGates> =>
       Effect.suspend(() => {
         const entry = gates.get(destination);
+
         return entry === undefined
           ? Effect.die(new Error(`No researcher gates exist for destination ${destination}`))
           : Effect.succeed(entry);
       });
+
     const controls: DestinationResearcherControls = {
       awaitStarted: (destination) =>
         gatesFor(destination).pipe(Effect.flatMap((entry) => Deferred.await(entry.started))),
@@ -484,6 +498,7 @@ export const makeDestinationResearcherModel = (destinations: ReadonlyArray<strin
         ),
       prompts: Ref.get(prompts),
     };
+
     const model = Model.make(
       "scripted",
       "destination-researcher-scripted",
@@ -492,15 +507,18 @@ export const makeDestinationResearcherModel = (destinations: ReadonlyArray<strin
         Effect.gen(function* () {
           yield* Effect.acquireRelease(lifecycle.markAcquired, () => lifecycle.markFinalized);
           const turn = yield* Ref.make(0);
+
           return yield* LanguageModel.make({
             generateText: () => Effect.succeed([]),
             streamText: (options) =>
               Stream.unwrap(
                 Effect.gen(function* () {
                   const promptJson = JSON.stringify(options.prompt.content);
+
                   const destination = destinations.find((candidate) =>
                     promptJson.includes(candidate),
                   );
+
                   if (destination === undefined) {
                     return yield* Effect.die(
                       new Error("The researcher prompt names no scripted destination"),
@@ -508,12 +526,15 @@ export const makeDestinationResearcherModel = (destinations: ReadonlyArray<strin
                   }
                   const entry = yield* gatesFor(destination);
                   const index = yield* Ref.getAndUpdate(turn, (value) => value + 1);
+
                   if (index === 0) {
                     yield* Ref.update(prompts, (previous) => [...previous, promptJson]);
                     yield* Deferred.succeed(entry.started, undefined);
+
                     return Stream.fromIterable(researcherLookupParts(destination));
                   }
                   yield* Deferred.await(entry.release);
+
                   return Stream.fromIterable(researcherReportParts(destination));
                 }),
               ),
@@ -521,5 +542,6 @@ export const makeDestinationResearcherModel = (destinations: ReadonlyArray<strin
         }),
       ),
     );
+
     return { controls, model };
   });

package/src/index.ts

@@ -1,11 +1 @@
-export * from "./certification.ts";
-export * from "./chaos.ts";
-export * from "./code-executor-conformance.ts";
-export * from "./code-executor-substitute.ts";
-export * from "./fixtures/docs-researcher/index.ts";
-export * from "./fixtures/travel-planner/index.ts";
-// The warehouse fixture is NOT re-exported here: it depends on
-// `@effect/sql-sqlite-node` (`node:sqlite`), which workerd consumers of this
-// barrel (the Cloudflare certification suites) cannot load. Import it
-// directly from `@effect-agent/testing/src/fixtures/warehouse/index.ts`.
-export * from "./scripted-model.ts";
+export * as ScriptedModel from "./ScriptedModel.ts";