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

package/src/{scripted-model.ts → ScriptedModel.ts}

@@ -1,10 +1,12 @@
 import { Context, Effect, Layer, Ref, Schema, Stream } from "effect";
-import { AiError, LanguageModel, Response } from "effect/unstable/ai";
+import { AiError, LanguageModel, Response, Toolkit } from "effect/unstable/ai";
 
 const ScriptedPartMetadata = Schema.Record(Schema.String, Schema.NullOr(Schema.Json));
+
 const ScriptedPartBase = {
   metadata: Schema.optionalKey(ScriptedPartMetadata),
 };
+
 const ScriptedToolCallPart = Schema.Struct({
   ...ScriptedPartBase,
   type: Schema.Literal("tool-call"),
@@ -13,6 +15,7 @@ const ScriptedToolCallPart = Schema.Struct({
   params: Schema.Unknown,
   providerExecuted: Schema.optionalKey(Schema.Boolean),
 });
+
 const ScriptedToolResultPart = Schema.Struct({
   ...ScriptedPartBase,
   type: Schema.Literal("tool-result"),
@@ -31,44 +34,25 @@ const ScriptedToolResultPart = Schema.Struct({
  * performs the toolkit-specific decode when the scripted response is consumed.
  */
 export const ScriptedGeneratePart = Schema.Union([
-  Schema.toEncoded(Response.TextPart),
-  Schema.toEncoded(Response.ReasoningPart),
+  Schema.toEncoded(Response.Part(Toolkit.empty)),
+  // PartEncoded also admits these reasoning markers, which the Part schema omits.
   Schema.toEncoded(Response.ReasoningDeltaPart),
   Schema.toEncoded(Response.ReasoningEndPart),
   ScriptedToolCallPart,
   ScriptedToolResultPart,
-  Schema.toEncoded(Response.ToolApprovalRequestPart),
-  Schema.toEncoded(Response.FilePart),
-  Schema.toEncoded(Response.DocumentSourcePart),
-  Schema.toEncoded(Response.UrlSourcePart),
-  Schema.toEncoded(Response.ResponseMetadataPart),
-  Schema.toEncoded(Response.FinishPart),
 ]).annotate({ identifier: "ScriptedGeneratePart" });
+
 export type ScriptedGeneratePart = typeof ScriptedGeneratePart.Type;
 
 /**
  * Schema for encoded Effect AI streaming response parts.
  */
 export const ScriptedStreamPart = Schema.Union([
-  Schema.toEncoded(Response.TextStartPart),
-  Schema.toEncoded(Response.TextDeltaPart),
-  Schema.toEncoded(Response.TextEndPart),
-  Schema.toEncoded(Response.ReasoningStartPart),
-  Schema.toEncoded(Response.ReasoningDeltaPart),
-  Schema.toEncoded(Response.ReasoningEndPart),
-  Schema.toEncoded(Response.ToolParamsStartPart),
-  Schema.toEncoded(Response.ToolParamsDeltaPart),
-  Schema.toEncoded(Response.ToolParamsEndPart),
+  Schema.toEncoded(Response.StreamPart(Toolkit.empty)),
   ScriptedToolCallPart,
   ScriptedToolResultPart,
-  Schema.toEncoded(Response.ToolApprovalRequestPart),
-  Schema.toEncoded(Response.FilePart),
-  Schema.toEncoded(Response.DocumentSourcePart),
-  Schema.toEncoded(Response.UrlSourcePart),
-  Schema.toEncoded(Response.ResponseMetadataPart),
-  Schema.toEncoded(Response.FinishPart),
-  Schema.toEncoded(Response.ErrorPart),
 ]).annotate({ identifier: "ScriptedStreamPart" });
+
 export type ScriptedStreamPart = typeof ScriptedStreamPart.Type;
 
 /** Controls whether a scripted stream completes, fails, or waits for interruption. */
@@ -79,12 +63,14 @@ export const ScriptedStreamTermination = Schema.Union([
   }),
   Schema.TaggedStruct("Hang", {}),
 ]);
+
 export type ScriptedStreamTermination = typeof ScriptedStreamTermination.Type;
 
 /** One non-streaming invocation and the encoded response parts it returns. */
 export const ScriptedGenerateTurn = Schema.TaggedStruct("Generate", {
   parts: Schema.Array(ScriptedGeneratePart),
 });
+
 export type ScriptedGenerateTurn = typeof ScriptedGenerateTurn.Type;
 
 /** One streaming invocation with its encoded parts and terminal behavior. */
@@ -92,6 +78,7 @@ export const ScriptedStreamTurn = Schema.TaggedStruct("Stream", {
   parts: Schema.Array(ScriptedStreamPart),
   termination: ScriptedStreamTermination,
 });
+
 export type ScriptedStreamTurn = typeof ScriptedStreamTurn.Type;
 
 /**
@@ -147,8 +134,10 @@ const runAssertion = Effect.fn("ScriptedModel.runAssertion")((
   if (assertion === undefined) {
     return Effect.void;
   }
+
   return Effect.suspend(() => {
     const result = assertion(request);
+
     return Effect.isEffect(result) ? result : Effect.void;
   });
 });
@@ -161,6 +150,7 @@ const takeTurn = Effect.fn("ScriptedModel.takeTurn")(
   ): Effect.Effect<ScriptedTurnInput, AiError.AiError> =>
     Ref.modify(state, (current) => {
       const turn = current.remaining[0];
+
       if (turn === undefined) {
         return [
           undefined,
@@ -170,6 +160,7 @@ const takeTurn = Effect.fn("ScriptedModel.takeTurn")(
           },
         ] as const;
       }
+
       return [
         turn,
         {
@@ -206,6 +197,7 @@ const streamForTurn = (
   let stream: Stream.Stream<Response.StreamPartEncoded, AiError.AiError> = Stream.fromIterable(
     turn.parts,
   );
+
   switch (turn.termination._tag) {
     case "Complete": {
       break;
@@ -227,6 +219,7 @@ const streamForTurn = (
   if (turn.onStreamFinalize !== undefined) {
     stream = stream.pipe(Stream.ensuring(turn.onStreamFinalize));
   }
+
   return stream;
 };
 
@@ -262,16 +255,20 @@ export class ScriptedModel extends Context.Service<
           generateText: (options) =>
             Effect.gen(function* () {
               const turn = yield* takeTurn(state, "generate", options);
+
               yield* runAssertion(turn.assertRequest, options);
               const generateTurn = yield* requireGenerateTurn(turn);
+
               return [...generateTurn.parts];
             }),
           streamText: (options) =>
             Stream.unwrap(
               Effect.gen(function* () {
                 const turn = yield* takeTurn(state, "stream", options);
+
                 yield* runAssertion(turn.assertRequest, options);
                 const streamTurn = yield* requireStreamTurn(turn);
+
                 return streamForTurn(streamTurn);
               }),
             ),

package/src/TravelPlanner.ts

@@ -0,0 +1,232 @@
+/** Shared Travel Planner definitions, deterministic services, and durability fixtures. */
+export {
+  AirportCode,
+  QuoteId,
+  TripRequest,
+  FlightQuery,
+  LodgingQuery,
+  ActivityQuery,
+  FlightOption,
+  LodgingOption,
+  ActivitySearchResult,
+  Itinerary,
+  TravelPlan,
+  FlightUnavailable,
+  LodgingUnavailable,
+  ActivityUnavailable,
+  GuidanceFailure,
+  FlightCatalog,
+  LodgingCatalog,
+  ActivityCatalog,
+  TravelGuidance,
+  SearchFlights,
+  SearchLodging,
+  SearchActivities,
+  TravelPlannerToolkit,
+  TravelPlannerToolkitLayer,
+  TravelPlanner,
+} from "./fixtures/travel-planner/definition.ts";
+
+export {
+  CatalogLifecycleCounts,
+  CatalogLifecycle,
+  type TravelPlannerCompletionControls,
+  ReverseCompletionToolkitLayer,
+  FlightCatalogLayer,
+  LodgingCatalogLayer,
+  ActivityCatalogLayer,
+  BookingRef,
+  SupplierOperation,
+  SupplierBookingRecord,
+  SupplierUnavailable,
+  type SupplierBookRequest,
+  type SupplierHoldControls,
+  cancelBookingIdempotencyKey,
+  supplierBookingRefFor,
+  SupplierBookingDesk,
+  TravelGuidanceLayer,
+  DeterministicIdGeneratorLayer,
+  TravelPlannerRuntimeLayer,
+} from "./fixtures/travel-planner/deterministic-layers.ts";
+
+export {
+  ItineraryHoldRequest,
+  ItineraryHold,
+  ItineraryHoldUnavailable,
+  ItineraryHoldGateway,
+  HoldItinerary,
+  TravelPlannerPhase2Toolkit,
+  TravelPlannerPhase2ToolkitLayer,
+  TravelPlannerPhase2,
+} from "./fixtures/travel-planner/phase2.ts";
+
+export {
+  phase3TravelPlannerThreadId,
+  phase3TravelPlannerProducerId,
+  phase3TravelPlannerRunId,
+  phase3TravelPlannerDefinitionDigests,
+  phase3TravelPlannerInitialBatch,
+  phase3TravelPlannerCompletionBatch,
+  phase3TravelPlannerBatches,
+  phase3TravelPlannerEncodedFixture,
+  TravelPlannerProjectionError,
+  travelPlanFromProjection,
+  makePhase3TravelPlannerCheckpoint,
+} from "./fixtures/travel-planner/phase3.ts";
+
+export {
+  phase4TravelPlannerDeploymentId,
+  phase4TravelPlannerProducerId,
+  phase4TravelPlannerPrincipal,
+  phase4TravelPlannerDefinitionDigests,
+  phase4TravelPlannerSubmitOptions,
+  DurableSearchFlights,
+  DurableSearchLodging,
+  DurableSearchActivities,
+  TravelPlannerPhase4Toolkit,
+  TravelPlannerPhase4ToolkitLayer,
+  TravelPlannerPhase4,
+  makePhase4TravelPlannerAgent,
+  phase4TravelPlannerWorkerLayer,
+  TravelPlannerDurableEvidenceError,
+  travelPlanFromDurableSettlement,
+  normalizeDurableTravelPlannerEvidence,
+} from "./fixtures/travel-planner/phase4.ts";
+
+export {
+  phase5TravelPlannerDeploymentId,
+  phase5TravelPlannerProducerId,
+  phase5TravelPlannerPrincipal,
+  phase5TravelPlannerDefinitionDigests,
+  phase5TravelPlannerSubmitOptions,
+  TravelerRef,
+  FlightBookingRequest,
+  SupplierBookingConfirmation,
+  CancelBookingRequest,
+  CancellationConfirmation,
+  ItineraryBookingRequest,
+  ItineraryConfirmation,
+  TravelBookingReport,
+  bookFlightIdempotencyKey,
+  itineraryStepIdempotencyKey,
+  BookFlight,
+  CancelBooking,
+  BookItinerary,
+  TravelPlannerPhase5Toolkit,
+  TravelPlannerPhase5ToolkitLayer,
+  TravelSupplierReconcilerLayer,
+  TravelPlannerPhase5,
+  TravelPlannerBookingEvidenceError,
+  assertSettledBookingsExistAtSupplier,
+  phase5TravelPlannerWorkerLayer,
+} from "./fixtures/travel-planner/phase5.ts";
+
+export {
+  phase6TravelPlannerDeploymentId,
+  phase6TravelPlannerProducerPrefix,
+  phase6TravelPlannerProducerId,
+  phase6GatedPlannerDefinitionDigests,
+  type CrossPlatformEvidenceIdentity,
+  normalizeCrossPlatformTravelPlannerEvidence,
+  phase6FlightCallId,
+  phase6LodgingCallId,
+  phase6ActivityCallId,
+  phase6PlannerModel,
+  releasePhase6PlannerGate,
+  resetPhase6PlannerGate,
+  phase6GatedTrip,
+  phase6GatedPlannerModel,
+  phase6SupplierDesk,
+  phase6SupplierDeskLayer,
+  phase6SupplierReconcilerLayer,
+  phase6BookingToolCallId,
+  phase6BookingRef,
+  phase6BookingTrip,
+  phase6BookingModel,
+  phase6GuideInvocationCount,
+  phase6ResearchMission,
+  phase6ResearchDestination,
+  phase6ChildLookupCallId,
+  phase6CoordinatorModel,
+  releasePhase6ResearcherGate,
+  resetPhase6ResearcherGate,
+  phase6ResearcherModel,
+  makePhase6TravelPlannerBindings,
+  phase6TravelPlannerGoldenEvidence,
+} from "./fixtures/travel-planner/phase6.ts";
+
+export {
+  PHASE7_LIVE_GATE_ENV,
+  PHASE7_LIVE_CREDENTIAL_ENV,
+  type Phase7LiveGateEnvironment,
+  phase7LiveProfileEnabled,
+} from "./fixtures/travel-planner/phase7.ts";
+
+export {
+  phase1Trip,
+  expectedTravelPlan,
+  phase1HappyPathTurns,
+} from "./fixtures/travel-planner/scenarios.ts";
+
+export {
+  DestinationQuery,
+  DestinationFacts,
+  DestinationGuideUnavailable,
+  DestinationGuide,
+  LookupDestination,
+  DestinationResearcherToolkit,
+  DestinationResearcherToolkitLayer,
+  DestinationBrief,
+  DestinationReport,
+  DestinationResearcher,
+  destinationLookup,
+  destinationReportFor,
+  encodedDestinationReport,
+  DestinationGuideLayer,
+  DestinationResearchSupportLayer,
+  DestinationResearchRequest,
+  DestinationResearchFindings,
+  DestinationResearchFailed,
+  ResearchDispatchGate,
+  destinationResearchPolicy,
+  destinationResearchDelegation,
+  mapResearchChildFailure,
+  destinationResearchHandlersLayer,
+  ResearchMission,
+  DestinationRecommendation,
+  DestinationShortlist,
+  coordinatorConfidentialMarker,
+  missionConfidentialMarker,
+  TravelCoordinatorToolkit,
+  TravelCoordinator,
+  researchMission,
+  expectedDestinationShortlist,
+  type DestinationResearchCall,
+  coordinatorResearchTurn,
+  coordinatorShortlistTurn,
+  researcherHappyPathTurns,
+  type DestinationResearcherControls,
+  makeDestinationResearcherModel,
+} from "./fixtures/travel-planner/subagents.ts";
+
+export {
+  s2TravelPlannerDeploymentId,
+  s2TravelPlannerProducerId,
+  s2TravelPlannerPrincipal,
+  s2CoordinatorDigests,
+  s2ResearcherDigestStrings,
+  s2ResearcherDigests,
+  s2TravelPlannerSubmitOptions,
+  s2CoordinatorSubmitAgent,
+  durableResearchAllocation,
+  durableResearchCallId,
+  durableChildLookupCallId,
+  durableResearchFinding,
+  durableResearchShortlist,
+  encodedDestinationFacts,
+  makeInvocationCountingModel,
+  durableDestinationResearchHandlersLayer,
+  type DurableResearchHarnessOptions,
+  type DurableResearchHarness,
+  makeDurableResearchHarness,
+} from "./fixtures/travel-planner/subagents-durable.ts";

package/src/fixtures/docs-researcher/definition.ts

@@ -1,6 +1,8 @@
-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, Effect, Schema } from "effect";
 import { Tool, Toolkit } from "effect/unstable/ai";
 
@@ -16,10 +18,12 @@ import { Tool, Toolkit } from "effect/unstable/ai";
 export const ResearchDocumentId = Schema.NonEmptyString.check(Schema.isMaxLength(64)).pipe(
   Schema.brand("@effect-agent/testing/docs-researcher/ResearchDocumentId"),
 );
+
 export type ResearchDocumentId = typeof ResearchDocumentId.Type;
 
 const BoundedTitle = Schema.NonEmptyString.check(Schema.isMaxLength(120));
 const BoundedBody = Schema.NonEmptyString.check(Schema.isMaxLength(16 * 1024));
+
 /** Bounded summary text: the ONLY child-derived text that may cross to the parent. */
 export const BoundedSummary = Schema.NonEmptyString.check(Schema.isMaxLength(240));
 
@@ -66,6 +70,7 @@ export const FetchDocument = Tool.make("fetch_document", {
 });
 
 export const DocContentToolkit = Toolkit.make(FetchDocument);
+
 export const docContentToolkitLayer = DocContentToolkit.toLayer({
   fetch_document: (query) => Effect.flatMap(DocumentLibrary, (library) => library.fetch(query)),
 });
@@ -73,11 +78,11 @@ export const docContentToolkitLayer = DocContentToolkit.toLayer({
 // ---------------------------------------------------------------------------
 // Deterministic corpus. Every body deliberately embeds BOTH a secret marker
 // and a distinctive body phrase: the tests assert that neither ever reaches
-// the parent Conversation, the parent prompts, or a redacted preview — only
+// the parent Thread, the parent prompts, or a redacted preview — only
 // the bounded summary crosses the delegation boundary (SUB-015, SEC-008).
 // ---------------------------------------------------------------------------
 
-/** Never allowed outside a child Conversation or an unredacted fixture value. */
+/** Never allowed outside a child Thread or an unredacted fixture value. */
 export const docsDocumentBodySecret = "docs-vault-secret-771";
 
 const decodeDocumentId = Schema.decodeSync(ResearchDocumentId);
@@ -109,7 +114,7 @@ const corpusEntries = new Map<string, CorpusEntry>(
       document: ResearchDocument.make({
         documentId: decodeDocumentId(entry.documentId),
         title: entry.title,
-        body: `${entry.bodyPhrase}: internal working notes. ${docsDocumentBodySecret}. ${entry.summary} Raw notes stay inside the child Conversation.`,
+        body: `${entry.bodyPhrase}: internal working notes. ${docsDocumentBodySecret}. ${entry.summary} Raw notes stay inside the child Thread.`,
       }),
       bodyPhrase: entry.bodyPhrase,
       summary: entry.summary,
@@ -125,9 +130,11 @@ export const researchCorpusDocumentIds: ReadonlyArray<ResearchDocumentId> = [
 
 const requireCorpusEntry = (documentId: string): CorpusEntry => {
   const entry = corpusEntries.get(documentId);
+
   if (entry === undefined) {
     throw new Error(`No deterministic corpus entry exists for document ${documentId}`);
   }
+
   return entry;
 };
 
@@ -136,6 +143,7 @@ export const researchDocumentLookup = (
   query: DocumentQuery,
 ): Effect.Effect<ResearchDocument, DocumentUnavailable> => {
   const entry = corpusEntries.get(query.documentId);
+
   return entry === undefined
     ? Effect.fail(
         DocumentUnavailable.make({
@@ -180,7 +188,7 @@ export const documentSummaryFor = (documentId: string): DocumentSummary =>
 export const encodedDocumentSummary = (documentId: string): string =>
   JSON.stringify(Schema.encodeSync(DocumentSummary)(documentSummaryFor(documentId)));
 
-export const DocSummarizer = Agent.define("doc-summarizer", {
+export const DocSummarizer = Agent.make("doc-summarizer", {
   input: SummaryBrief,
   output: DocumentSummary,
   instructions:
@@ -200,7 +208,7 @@ export const DocSummarizer = Agent.define("doc-summarizer", {
 // Delegation Definition: the coordinator sees exactly one Tool with explicit
 // projections and finite bounds. `projectResult` is the declassification
 // boundary (SUB-015): only the bounded summary crosses; the fetched body —
-// secret marker included — stays in the child Conversation.
+// secret marker included — stays in the child Thread.
 // ---------------------------------------------------------------------------
 
 export class SummaryRequest extends Schema.Class<SummaryRequest>("SummaryRequest")({
@@ -300,7 +308,7 @@ export const docsMissionConfidentialMarker = "docs-mission-dossier-42f";
 
 export const DocsResearcherToolkit = Toolkit.make(delegateDocumentSummary.tool);
 
-export const DocsResearcher = Agent.define("docs-researcher", {
+export const DocsResearcher = Agent.make("docs-researcher", {
   input: ResearchRequest,
   output: ResearchDigest,
   instructions: [
@@ -322,7 +330,7 @@ export const DocsResearcher = Agent.define("docs-researcher", {
 
 /** The default two-document research mission. */
 export const researchMissionRequest = ResearchRequest.make({
-  question: `Summarize the durability and subagent notes; keep ${docsMissionConfidentialMarker} inside the coordinator conversation.`,
+  question: `Summarize the durability and subagent notes; keep ${docsMissionConfidentialMarker} inside the coordinator thread.`,
   documentIds: researchCorpusDocumentIds,
 });
 
@@ -333,6 +341,7 @@ export const expectedResearchDigest = (
   ResearchDigest.make({
     findings: documentIds.map((documentId) => {
       const summary = documentSummaryFor(documentId);
+
       return SummaryFinding.make({
         documentId: summary.documentId,
         summary: summary.summary,