@effect-agent/testing 0.1.0-beta.41 → 0.1.0-beta.44

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

@@ -50,6 +50,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)),
 });
@@ -111,6 +112,7 @@ export const destinationLookup = (
   query: DestinationQuery,
 ): Effect.Effect<DestinationFacts, DestinationGuideUnavailable> => {
   const facts = guideFacts.get(query.destination);
+
   return facts === undefined
     ? Effect.fail(
         DestinationGuideUnavailable.make({
@@ -123,15 +125,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,
@@ -146,7 +151,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 });
   }),
 );
@@ -223,7 +230,9 @@ 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}`,
@@ -460,19 +469,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))),
@@ -483,6 +496,7 @@ export const makeDestinationResearcherModel = (destinations: ReadonlyArray<strin
         ),
       prompts: Ref.get(prompts),
     };
+
     const model = Model.make(
       "scripted",
       "destination-researcher-scripted",
@@ -491,15 +505,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"),
@@ -507,12 +524,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));
                 }),
               ),
@@ -520,5 +540,6 @@ export const makeDestinationResearcherModel = (destinations: ReadonlyArray<strin
         }),
       ),
     );
+
     return { controls, model };
   });

package/src/scripted-model.ts

@@ -2,9 +2,11 @@ import { Context, Effect, Layer, Ref, Schema, Stream } from "effect";
 import { AiError, LanguageModel, Response } 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"),
@@ -44,6 +47,7 @@ export const ScriptedGeneratePart = Schema.Union([
   Schema.toEncoded(Response.ResponseMetadataPart),
   Schema.toEncoded(Response.FinishPart),
 ]).annotate({ identifier: "ScriptedGeneratePart" });
+
 export type ScriptedGeneratePart = typeof ScriptedGeneratePart.Type;
 
 /**
@@ -69,6 +73,7 @@ export const ScriptedStreamPart = Schema.Union([
   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 +84,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 +99,7 @@ export const ScriptedStreamTurn = Schema.TaggedStruct("Stream", {
   parts: Schema.Array(ScriptedStreamPart),
   termination: ScriptedStreamTermination,
 });
+
 export type ScriptedStreamTurn = typeof ScriptedStreamTurn.Type;
 
 /**
@@ -147,8 +155,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 +171,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 +181,7 @@ const takeTurn = Effect.fn("ScriptedModel.takeTurn")(
           },
         ] as const;
       }
+
       return [
         turn,
         {
@@ -206,6 +218,7 @@ const streamForTurn = (
   let stream: Stream.Stream<Response.StreamPartEncoded, AiError.AiError> = Stream.fromIterable(
     turn.parts,
   );
+
   switch (turn.termination._tag) {
     case "Complete": {
       break;
@@ -227,6 +240,7 @@ const streamForTurn = (
   if (turn.onStreamFinalize !== undefined) {
     stream = stream.pipe(Stream.ensuring(turn.onStreamFinalize));
   }
+
   return stream;
 };
 
@@ -262,16 +276,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);
               }),
             ),