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

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

@@ -1,24 +1,14 @@
-import {
-  connectMcp,
-  Redactor,
-  SubagentReservationsMemoryLive,
-  type McpDiscovery,
-  type RedactedPreview,
-  type RedactionError,
-} from "@effect-agent/capabilities";
-import { Agent, type ConversationId } from "@effect-agent/core";
-import {
-  DefinitionDigests,
-  DeploymentId,
-  Digest,
-  DurableWorkerBinding,
-  Principal,
-  ProducerId,
-  type DurableSubmitOptions,
-  type IdempotencyKey,
-  type ResolvedBinding,
-} from "@effect-agent/session";
-import { Crypto, Effect, Layer, Ref, Schema, Stream } from "effect";
+import type { Crypto } from "effect";
+import { Effect, Layer, Ref, Schema, Stream } from "effect";
+import * as Agent from "effect-agent/agent";
+import { DurableWorkerBinding, type ResolvedBinding } from "effect-agent/agent-registration";
+import { type DurableSubmitOptions } from "effect-agent/durable-agent-runtime";
+import { type ThreadId } from "effect-agent/identifiers";
+import { connectMcp, type McpDiscovery } from "effect-agent/mcp";
+import { DefinitionDigests, DeploymentId, Digest, ProducerId } from "effect-agent/records";
+import { Redactor, type RedactedPreview, type RedactionError } from "effect-agent/redaction";
+import { SubagentReservationsMemoryLive } from "effect-agent/subagent-reservations";
+import { Principal, type IdempotencyKey } from "effect-agent/submission-ledger";
 import { LanguageModel, Model, type Response } from "effect/unstable/ai";
 
 import { DeterministicIdGeneratorLayer } from "../travel-planner/deterministic-layers.ts";
@@ -52,9 +42,11 @@ import {
 export const docsResearcherDeploymentId = Schema.decodeSync(DeploymentId)(
   "docs-researcher-p7-deployment",
 );
+
 export const docsResearcherProducerId = Schema.decodeSync(ProducerId)(
   "docs-researcher-p7-producer",
 );
+
 export const docsResearcherPrincipal = Schema.decodeSync(Principal)("docs-researcher-p7-principal");
 
 const digestOf = (pair: string) => Schema.decodeSync(Digest)(pair.repeat(32));
@@ -75,10 +67,10 @@ export const docsSummarizerDigests = DefinitionDigests.make({
 
 /** Durable admission options for one docs-researcher Submission on one mission lane. */
 export const docsResearcherSubmitOptions = (
-  conversationId: ConversationId,
+  threadId: ThreadId,
   idempotencyKey: IdempotencyKey,
 ): DurableSubmitOptions => ({
-  conversationId,
+  threadId,
   principal: docsResearcherPrincipal,
   idempotencyKey,
   definitions: docsCoordinatorDigests,
@@ -100,15 +92,13 @@ const scriptedUsage = { inputTokens: { total: 96 }, outputTokens: { total: 64 }
 const summaryDelegationParts = (
   documentIds: ReadonlyArray<string>,
 ): ReadonlyArray<Response.StreamPartEncoded> => [
-  ...documentIds.map(
-    (documentId): Response.StreamPartEncoded => ({
-      type: "tool-call",
-      id: summarizeCallId(documentId),
-      name: "delegate_document_summary",
-      params: { documentId },
-      providerExecuted: false,
-    }),
-  ),
+  ...documentIds.map((documentId): Response.StreamPartEncoded => ({
+    type: "tool-call",
+    id: summarizeCallId(documentId),
+    name: "delegate_document_summary",
+    params: { documentId },
+    providerExecuted: false,
+  })),
   { type: "finish", reason: "tool-calls", usage: scriptedUsage },
 ];
 
@@ -155,6 +145,7 @@ const makeCountingModel = (
   Effect.gen(function* () {
     const calls = yield* Ref.make(0);
     const prompts = yield* Ref.make<ReadonlyArray<string>>([]);
+
     const model = Model.make(
       "scripted",
       name,
@@ -167,13 +158,16 @@ const makeCountingModel = (
               Effect.gen(function* () {
                 yield* Ref.update(calls, (value) => value + 1);
                 const promptJson = JSON.stringify(request.prompt);
+
                 yield* Ref.update(prompts, (previous) => [...previous, promptJson]);
+
                 return Stream.fromIterable(yield* decide(promptJson));
               }),
             ),
         }),
       ),
     );
+
     return { model, calls: Ref.get(calls), prompts: Ref.get(prompts) };
   });
 
@@ -185,7 +179,7 @@ export interface DocsResearcherHarnessOptions {
 
 /** One durable coordinator/summarizer pair with observable counters and MCP evidence. */
 export interface DocsResearcherHarness {
-  /** Host registrations for `NodeDurableRuntimeOptions.bindings` (parent + child). */
+  /** Resolved registrations for the parent and child workers. */
   readonly bindings: ReadonlyArray<ResolvedBinding>;
   /** The validated MCP discovery the child toolkit registration was gated on. */
   readonly discovery: McpDiscovery;
@@ -218,12 +212,15 @@ export const makeDocsResearcherHarness = (options?: DocsResearcherHarnessOptions
     const discovery = yield* Effect.scoped(
       Effect.gen(function* () {
         const connection = yield* connectMcp(docsMcpRequest);
+
         yield* assertDiscoveryMatchesAuthoredToolkit(connection);
+
         return connection.discovery;
       }),
     ).pipe(Effect.provide(docsMcpConnectorLayer));
 
     const fetchCounts = yield* Ref.make<ReadonlyMap<string, number>>(new Map());
+
     const libraryLayer = Layer.succeed(
       DocumentLibrary,
       DocumentLibrary.of({
@@ -233,14 +230,17 @@ export const makeDocsResearcherHarness = (options?: DocsResearcherHarnessOptions
           ).pipe(Effect.andThen(researchDocumentLookup(query))),
       }),
     );
+
     const childToolkitLayer = docContentToolkitLayer.pipe(Layer.provideMerge(libraryLayer));
 
     const childModel = yield* makeCountingModel("doc-summarizer-p7", (promptJson) =>
       Effect.suspend(() => {
         const documentId = documentIds.find((candidate) => promptJson.includes(candidate));
+
         if (documentId === undefined) {
           return Effect.die(new Error("The summarizer prompt names no corpus document"));
         }
+
         return Effect.succeed(
           promptJson.includes(fetchCallId(documentId))
             ? summaryParts(documentId)
@@ -248,9 +248,11 @@ export const makeDocsResearcherHarness = (options?: DocsResearcherHarnessOptions
         );
       }),
     );
+
     const childBinding = Agent.withModel(DocSummarizer, childModel.model);
 
     const firstCallId = summarizeCallId(documentIds[0] ?? "durability-notes");
+
     const parentModel = yield* makeCountingModel("docs-researcher-p7", (promptJson) =>
       Effect.succeed(
         promptJson.includes(firstCallId)
@@ -258,6 +260,7 @@ export const makeDocsResearcherHarness = (options?: DocsResearcherHarnessOptions
           : summaryDelegationParts(documentIds),
       ),
     );
+
     const parentBinding = Agent.withModel(DocsResearcher, parentModel.model);
 
     const delegationLayer = docsSummaryHandlersLayer(childBinding).pipe(
@@ -274,6 +277,7 @@ export const makeDocsResearcherHarness = (options?: DocsResearcherHarnessOptions
       parentBinding,
       docsCoordinatorDigests,
     ).pipe(Effect.provide(delegationLayer));
+
     const childResolved: ResolvedBinding = yield* DurableWorkerBinding.make(
       childBinding,
       docsSummarizerDigests,
@@ -289,6 +293,7 @@ export const makeDocsResearcherHarness = (options?: DocsResearcherHarnessOptions
       fetchInvocations: (documentId) =>
         Ref.get(fetchCounts).pipe(Effect.map((current) => current.get(documentId) ?? 0)),
     };
+
     return harness;
   });
 
@@ -297,15 +302,17 @@ const encodeResearchDocument = Schema.encodeEffect(ResearchDocument);
 /**
  * The audit-surface preview of one fetched document: the raw document —
  * secret marker and all — passes through the configured structural `Redactor`
- * before anything may quote it outside the child Conversation (SEC-008,
+ * before anything may quote it outside the child Thread (SEC-008,
  * CAP-013). Tests assert the preview keeps shape but no scalar content.
  */
 export const redactedDocumentPreview = Effect.fn("DocsResearcher.redactedDocumentPreview")(
   function* (documentId: string): Effect.fn.Return<RedactedPreview, RedactionError, Redactor> {
     const redactor = yield* Redactor;
+
     const encoded = yield* encodeResearchDocument(researchDocumentFor(documentId)).pipe(
       Effect.orDie,
     );
+
     return yield* redactor.redact(encoded);
   },
 );

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

@@ -1,11 +1,12 @@
+import type { JsonSchema } from "effect";
+import { Effect, JsonPointer, Layer, Schema } from "effect";
 import {
   McpConnectionRequest,
   McpConnector,
   McpServerIdentity,
   McpToolkitMismatch,
   type McpConnection,
-} from "@effect-agent/capabilities";
-import { Effect, Layer, Schema } from "effect";
+} from "effect-agent/mcp";
 import { Tool } from "effect/unstable/ai";
 import * as McpSchema from "effect/unstable/ai/McpSchema";
 
@@ -37,10 +38,52 @@ export const docsMcpIdentity = McpServerIdentity.make({
   }),
 });
 
+/**
+ * `Tool.getJsonSchema` produces a `$ref`/`$defs`-shaped schema for
+ * `FetchDocument`'s named, refined parameters type, but `McpSchema.Tool`'s
+ * `inputSchema` requires a flat `{ type: "object", ... }` root — the shape a
+ * real MCP server advertises on the wire. This inlines the single top-level
+ * `$ref` so the derivation described above still holds byte-for-byte.
+ */
+const JsonSchemaDefinitions = Schema.Record(
+  Schema.String,
+  Schema.Record(Schema.String, Schema.Unknown),
+);
+
+const decodeJsonSchemaDefinitions = Schema.decodeUnknownSync(JsonSchemaDefinitions);
+const decodeToolJsonSchema = Schema.decodeUnknownSync(McpSchema.ToolJsonSchema);
+
+const flattenTopLevelRef = (schema: JsonSchema.JsonSchema): McpSchema.ToolJsonSchema => {
+  const ref = schema["$ref"];
+
+  if (typeof ref !== "string") {
+    return decodeToolJsonSchema(schema);
+  }
+
+  const defs = decodeJsonSchemaDefinitions(schema["$defs"]);
+
+  const key = ref.startsWith("#/$defs/")
+    ? JsonPointer.unescapeToken(ref.slice("#/$defs/".length))
+    : undefined;
+
+  const resolved = key !== undefined && Object.hasOwn(defs, key) ? defs[key] : undefined;
+
+  return decodeToolJsonSchema(resolved ?? schema);
+};
+
+const fetchDocumentOutputSchema = flattenTopLevelRef(
+  Tool.getJsonSchemaFromSchema(FetchDocument.successSchema),
+);
+
 const discoveredFetchDocument = McpSchema.Tool.make({
   name: FetchDocument.name,
   description: "Fetch one bounded research document by its identifier.",
-  inputSchema: Tool.getJsonSchema(FetchDocument),
+  inputSchema: flattenTopLevelRef(Tool.getJsonSchema(FetchDocument)),
+  // `validateMcpDiscovery` only compares an `outputSchema` derived down to an
+  // object type; mirror that so this fixture stays a real round-trip check.
+  ...(fetchDocumentOutputSchema.type === "object"
+    ? { outputSchema: fetchDocumentOutputSchema }
+    : {}),
 });
 
 const scriptedConnector = (tools: ReadonlyArray<McpSchema.Tool>): Layer.Layer<McpConnector> =>
@@ -98,9 +141,11 @@ export const assertDiscoveryMatchesAuthoredToolkit = Effect.fn(
   const authored = Object.values(DocContentToolkit.tools)
     .map((tool) => ({ name: tool.name, inputSchema: Tool.getJsonSchema(tool) }))
     .sort((left, right) => (left.name < right.name ? -1 : left.name > right.name ? 1 : 0));
+
   const discovered = Object.values(connection.toolkit.tools)
     .map((tool) => ({ name: tool.name, inputSchema: Tool.getJsonSchema(tool) }))
     .sort((left, right) => (left.name < right.name ? -1 : left.name > right.name ? 1 : 0));
+
   const matches =
     authored.length === discovered.length &&
     authored.every(
@@ -108,6 +153,7 @@ export const assertDiscoveryMatchesAuthoredToolkit = Effect.fn(
         tool.name === discovered[index]?.name &&
         isJsonEqual(tool.inputSchema, discovered[index]?.inputSchema),
     );
+
   if (!matches) {
     return yield* McpToolkitMismatch.make({
       serverId: connection.discovery.identity.serverId,

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

@@ -1,15 +1,18 @@
-import { Agent, AgentPolicy } from "@effect-agent/core";
 import { Context, Effect, Schema } from "effect";
+import * as Agent from "effect-agent/agent";
+import { AgentPolicy } from "effect-agent/agent-policy";
 import { Tool, Toolkit } from "effect/unstable/ai";
 
 export const AirportCode = Schema.NonEmptyString.pipe(
   Schema.brand("@effect-agent/testing/travel-planner/AirportCode"),
 );
+
 export type AirportCode = typeof AirportCode.Type;
 
 export const QuoteId = Schema.NonEmptyString.pipe(
   Schema.brand("@effect-agent/testing/travel-planner/QuoteId"),
 );
+
 export type QuoteId = typeof QuoteId.Type;
 
 export class TripRequest extends Schema.Class<TripRequest>("TripRequest")({
@@ -84,18 +87,22 @@ export class TravelPlan extends Schema.Class<TravelPlan>("TravelPlan")({
 }) {}
 
 const unavailableFields = { query: Schema.String, message: Schema.String };
+
 export class FlightUnavailable extends Schema.TaggedError<FlightUnavailable>()(
   "FlightUnavailable",
   unavailableFields,
 ) {}
+
 export class LodgingUnavailable extends Schema.TaggedError<LodgingUnavailable>()(
   "LodgingUnavailable",
   unavailableFields,
 ) {}
+
 export class ActivityUnavailable extends Schema.TaggedError<ActivityUnavailable>()(
   "ActivityUnavailable",
   unavailableFields,
 ) {}
+
 export class GuidanceFailure extends Schema.TaggedError<GuidanceFailure>()("GuidanceFailure", {
   message: Schema.String,
 }) {}
@@ -104,10 +111,12 @@ export class FlightCatalog extends Context.Service<
   FlightCatalog,
   { readonly search: (query: FlightQuery) => Effect.Effect<FlightOption, FlightUnavailable> }
 >()("@effect-agent/testing/travel-planner/FlightCatalog") {}
+
 export class LodgingCatalog extends Context.Service<
   LodgingCatalog,
   { readonly search: (query: LodgingQuery) => Effect.Effect<LodgingOption, LodgingUnavailable> }
 >()("@effect-agent/testing/travel-planner/LodgingCatalog") {}
+
 export class ActivityCatalog extends Context.Service<
   ActivityCatalog,
   {
@@ -116,6 +125,7 @@ export class ActivityCatalog extends Context.Service<
     ) => Effect.Effect<ActivitySearchResult, ActivityUnavailable>;
   }
 >()("@effect-agent/testing/travel-planner/ActivityCatalog") {}
+
 export class TravelGuidance extends Context.Service<
   TravelGuidance,
   { readonly instructions: (input: TripRequest) => Effect.Effect<string, GuidanceFailure> }
@@ -128,6 +138,7 @@ export const SearchFlights = Tool.make("search_flights", {
   failureMode: "error",
   dependencies: [FlightCatalog],
 });
+
 export const SearchLodging = Tool.make("search_lodging", {
   parameters: LodgingQuery,
   success: LodgingOption,
@@ -135,6 +146,7 @@ export const SearchLodging = Tool.make("search_lodging", {
   failureMode: "error",
   dependencies: [LodgingCatalog],
 });
+
 export const SearchActivities = Tool.make("search_activities", {
   parameters: ActivityQuery,
   success: ActivitySearchResult,
@@ -144,13 +156,14 @@ export const SearchActivities = Tool.make("search_activities", {
 });
 
 export const TravelPlannerToolkit = Toolkit.make(SearchFlights, SearchLodging, SearchActivities);
+
 export const TravelPlannerToolkitLayer = TravelPlannerToolkit.toLayer({
   search_flights: (query) => Effect.flatMap(FlightCatalog, (catalog) => catalog.search(query)),
   search_lodging: (query) => Effect.flatMap(LodgingCatalog, (catalog) => catalog.search(query)),
   search_activities: (query) => Effect.flatMap(ActivityCatalog, (catalog) => catalog.search(query)),
 });
 
-export const TravelPlanner = Agent.define("travel-planner", {
+export const TravelPlanner = Agent.make("travel-planner", {
   input: TripRequest,
   output: TravelPlan,
   instructions: (input) =>

package/src/fixtures/travel-planner/deterministic-layers.ts

@@ -1,5 +1,8 @@
-import { ConversationId, IdGenerator, RunId, TurnId } from "@effect-agent/core";
 import { Context, Deferred, Effect, Layer, Option, Ref, Schema } from "effect";
+import { IdGenerator } from "effect-agent/id-generator";
+import { ThreadId, RunId, TurnId } from "effect-agent/identifiers";
+import { RunContextPreparationPassthrough } from "effect-agent/run-options";
+import { ThreadHistory } from "effect-agent/thread-history";
 
 import {
   ActivityCatalog,
@@ -23,6 +26,7 @@ export class CatalogLifecycleCounts extends Schema.Class<CatalogLifecycleCounts>
   acquired: Schema.Natural,
   finalized: Schema.Natural,
 }) {}
+
 export class CatalogLifecycle extends Context.Service<
   CatalogLifecycle,
   {
@@ -36,6 +40,7 @@ export class CatalogLifecycle extends Context.Service<
     Effect.gen(function* () {
       const acquired = yield* Ref.make(0);
       const finalized = yield* Ref.make(0);
+
       return CatalogLifecycle.of({
         markAcquired: Ref.update(acquired, (n) => n + 1),
         markFinalized: Ref.update(finalized, (n) => n + 1),
@@ -53,11 +58,13 @@ const flight = FlightOption.make({
   estimatedCents: 180_000,
   currency: "USD",
 });
+
 const lodging = LodgingOption.make({
   lodging: "Bloomsbury House · refundable studio · 4 nights",
   estimatedCents: 104_000,
   currency: "USD",
 });
+
 const activities = ActivitySearchResult.make({
   activities: ["British Museum timed entry", "Thames evening walk"],
 });
@@ -84,6 +91,7 @@ export const ReverseCompletionToolkitLayer = Effect.gen(function* () {
   const releaseFlight = yield* Deferred.make<void>();
   const releaseLodging = yield* Deferred.make<void>();
   const releaseActivity = yield* Deferred.make<void>();
+
   const awaitRelease = <A>(
     started: Deferred.Deferred<void>,
     release: Deferred.Deferred<void>,
@@ -93,6 +101,7 @@ export const ReverseCompletionToolkitLayer = Effect.gen(function* () {
       Effect.andThen(Deferred.await(release)),
       Effect.as(value),
     );
+
   return {
     controls: {
       flightStarted: Deferred.await(flightStarted),
@@ -114,7 +123,9 @@ export const FlightCatalogLayer = Layer.effect(
   FlightCatalog,
   Effect.gen(function* () {
     const lifecycle = yield* CatalogLifecycle;
+
     yield* Effect.acquireRelease(lifecycle.markAcquired, () => lifecycle.markFinalized);
+
     return FlightCatalog.of({
       search: (query) =>
         query.origin === query.destination
@@ -128,11 +139,14 @@ export const FlightCatalogLayer = Layer.effect(
     });
   }),
 );
+
 export const LodgingCatalogLayer = Layer.effect(
   LodgingCatalog,
   Effect.gen(function* () {
     const lifecycle = yield* CatalogLifecycle;
+
     yield* Effect.acquireRelease(lifecycle.markAcquired, () => lifecycle.markFinalized);
+
     return LodgingCatalog.of({
       search: (query) =>
         query.nights < 1
@@ -146,11 +160,14 @@ export const LodgingCatalogLayer = Layer.effect(
     });
   }),
 );
+
 export const ActivityCatalogLayer = Layer.effect(
   ActivityCatalog,
   Effect.gen(function* () {
     const lifecycle = yield* CatalogLifecycle;
+
     yield* Effect.acquireRelease(lifecycle.markAcquired, () => lifecycle.markFinalized);
+
     return ActivityCatalog.of({
       search: (query) =>
         query.destination === ""
@@ -164,10 +181,12 @@ export const ActivityCatalogLayer = Layer.effect(
     });
   }),
 );
+
 /** Stable supplier-side booking identity, minted deterministically from the idempotency key. */
 export const BookingRef = Schema.NonEmptyString.pipe(
   Schema.brand("@effect-agent/testing/travel-planner/BookingRef"),
 );
+
 export type BookingRef = typeof BookingRef.Type;
 
 /** The supplier desk operations the P5 booking Tools and Steps invoke. */
@@ -178,6 +197,7 @@ export const SupplierOperation = Schema.Literals([
   "reserve-lodging",
   "issue-confirmation",
 ]);
+
 export type SupplierOperation = typeof SupplierOperation.Type;
 
 /**
@@ -286,7 +306,9 @@ export class SupplierBookingDesk extends Context.Service<
             request.idempotencyKey,
             (current.counts.get(request.idempotencyKey) ?? 0) + 1,
           );
+
           const existing = current.bookings.get(request.idempotencyKey);
+
           const record =
             existing ??
             SupplierBookingRecord.make({
@@ -296,18 +318,24 @@ export class SupplierBookingDesk extends Context.Service<
               detail: request.detail,
               status: "confirmed",
             });
+
           const bookings =
             existing === undefined
               ? new Map(current.bookings).set(request.idempotencyKey, record)
               : current.bookings;
+
           const hold = Option.fromNullishOr(current.holds.get(request.idempotencyKey));
+
           const holds = Option.isSome(hold)
             ? (() => {
                 const next = new Map(current.holds);
+
                 next.delete(request.idempotencyKey);
+
                 return next;
               })()
             : current.holds;
+
           return [
             { record, hold },
             { bookings, counts, holds },
@@ -318,9 +346,11 @@ export class SupplierBookingDesk extends Context.Service<
         Ref.modify(state, (current) => {
           const key = cancelBookingIdempotencyKey(bookingRef);
           const counts = new Map(current.counts).set(key, (current.counts.get(key) ?? 0) + 1);
+
           const existingEntry = [...current.bookings.entries()].find(
             ([, record]) => record.bookingRef === bookingRef,
           );
+
           if (existingEntry === undefined) {
             return [
               { record: Option.none<SupplierBookingRecord>(), hold: Option.none() },
@@ -328,19 +358,25 @@ export class SupplierBookingDesk extends Context.Service<
             ] as const;
           }
           const [storeKey, existing] = existingEntry;
+
           const cancelled =
             existing.status === "cancelled"
               ? existing
               : SupplierBookingRecord.make({ ...existing, status: "cancelled" });
+
           const bookings = new Map(current.bookings).set(storeKey, cancelled);
           const hold = Option.fromNullishOr(current.holds.get(key));
+
           const holds = Option.isSome(hold)
             ? (() => {
                 const next = new Map(current.holds);
+
                 next.delete(key);
+
                 return next;
               })()
             : current.holds;
+
           return [
             { record: Option.some(cancelled), hold },
             { bookings, counts, holds },
@@ -371,10 +407,12 @@ export class SupplierBookingDesk extends Context.Service<
           Effect.gen(function* () {
             const held = yield* Deferred.make<void>();
             const release = yield* Deferred.make<void>();
+
             yield* Ref.update(state, (current) => ({
               ...current,
               holds: new Map(current.holds).set(idempotencyKey, { held, release }),
             }));
+
             return {
               held: Deferred.await(held),
               release: Deferred.succeed(release, undefined).pipe(Effect.asVoid),
@@ -402,15 +440,17 @@ export const TravelGuidanceLayer = Layer.succeed(
       ),
   }),
 );
+
 export const DeterministicIdGeneratorLayer = Layer.effect(
   IdGenerator,
   Effect.gen(function* () {
-    const conversation = yield* Ref.make(0);
+    const thread = yield* Ref.make(0);
     const run = yield* Ref.make(0);
     const turn = yield* Ref.make(0);
+
     return IdGenerator.of({
-      nextConversationId: Ref.updateAndGet(conversation, (n) => n + 1).pipe(
-        Effect.map((n) => Schema.decodeSync(ConversationId)(`conversation-${n}`)),
+      nextThreadId: Ref.updateAndGet(thread, (n) => n + 1).pipe(
+        Effect.map((n) => Schema.decodeSync(ThreadId)(`thread-${n}`)),
       ),
       nextRunId: Ref.updateAndGet(run, (n) => n + 1).pipe(
         Effect.map((n) => Schema.decodeSync(RunId)(`run-${n}`)),
@@ -421,7 +461,10 @@ export const DeterministicIdGeneratorLayer = Layer.effect(
     });
   }),
 );
+
 export const TravelPlannerRuntimeLayer = Layer.mergeAll(
+  RunContextPreparationPassthrough,
+  ThreadHistory.layer,
   TravelPlannerToolkitLayer,
   FlightCatalogLayer,
   LodgingCatalogLayer,

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

@@ -1,5 +1,6 @@
-import { Agent, AgentPolicy } from "@effect-agent/core";
 import { Context, Effect, Schema } from "effect";
+import * as Agent from "effect-agent/agent";
+import { AgentPolicy } from "effect-agent/agent-policy";
 import { Tool, Toolkit } from "effect/unstable/ai";
 
 import {
@@ -75,7 +76,7 @@ export const TravelPlannerPhase2ToolkitLayer = TravelPlannerPhase2Toolkit.toLaye
     Effect.flatMap(ItineraryHoldGateway, (gateway) => gateway.hold(request)),
 });
 
-export const TravelPlannerPhase2 = Agent.define("travel-planner-phase-2", {
+export const TravelPlannerPhase2 = Agent.make("travel-planner-phase-2", {
   input: TripRequest,
   output: TravelPlan,
   instructions: (input) =>
@@ -86,7 +87,7 @@ export const TravelPlannerPhase2 = Agent.define("travel-planner-phase-2", {
     maxToolCalls: 4,
     maxDuration: "30 seconds",
     toolConcurrency: 3,
-    tokenBudget: 2_048,
+    tokenBudget: 4_096,
   }),
   description:
     "Build a review-only itinerary and require approval before creating a temporary hold.",