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

package/src/code-executor-substitute.ts

@@ -91,6 +91,7 @@ const formatLogValue = (value: unknown): string => {
     if (typeof value === "string") {
       return value;
     }
+
     return JSON.stringify(value) ?? String(value);
   } catch {
     try {
@@ -104,17 +105,21 @@ const formatLogValue = (value: unknown): string => {
 const makeConsole = (capture: LogCapture, limits: CodeExecutionLimits) => {
   const write = (...values: ReadonlyArray<unknown>): void => {
     const joined = values.map(formatLogValue).join(" ");
+
     const line =
       joined.length > MAX_LOG_LINE_CHARACTERS
         ? `${joined.slice(0, MAX_LOG_LINE_CHARACTERS - 1)}…`
         : joined;
+
     const bytes = utf8ByteLength(line);
+
     if (capture.lines.length >= MAX_LOG_LINES || capture.bytes + bytes > limits.maxLogBytes) {
       throw new LogLimitSignal(capture.bytes + bytes);
     }
     capture.lines.push(line);
     capture.bytes += bytes;
   };
+
   return { debug: write, error: write, info: write, log: write, warn: write };
 };
 
@@ -131,18 +136,21 @@ const buildNamespaceObject = (
   offer: (pending: PendingHostCall) => void,
 ): Record<string, unknown> => {
   const methods: Record<string, unknown> = {};
+
   for (const method of namespace.methods) {
     methods[method] = (argument: unknown) =>
       new Promise((resolve, reject) => {
         offer({ namespace: namespace.name, method, argument, resolve, reject });
       });
   }
+
   return methods;
 };
 
 const boundedText = (value: unknown): string => {
   try {
     const text = value instanceof Error ? `${value.name}: ${value.message}` : formatLogValue(value);
+
     return text.slice(0, MAX_THROWN_CHARACTERS);
   } catch {
     return "[unserializable thrown value]";
@@ -160,9 +168,11 @@ const safeDecodeJson = (value: unknown): Option.Option<Schema.Json> => {
 
 const boundedThrown = (value: unknown): Schema.Json => {
   const decoded = safeDecodeJson(value);
+
   if (Option.isSome(decoded)) {
     try {
       const encoded = JSON.stringify(decoded.value);
+
       if (encoded !== undefined && encoded.length <= MAX_THROWN_CHARACTERS) {
         return decoded.value;
       }
@@ -170,12 +180,14 @@ const boundedThrown = (value: unknown): Schema.Json => {
       // fall through to the bounded string form
     }
   }
+
   return boundedText(value);
 };
 
 const encodedJsonByteLength = (value: Schema.Json): number | undefined => {
   try {
     const encoded = JSON.stringify(value);
+
     return encoded === undefined ? undefined : utf8ByteLength(encoded);
   } catch {
     return undefined;
@@ -213,6 +225,7 @@ const validateRequest = (
     }
     const reservedNames = new Set<string>([...shadowedGlobals, "console"]);
     const seen = new Set<string>();
+
     for (const namespace of request.namespaces) {
       if (reservedNames.has(namespace.name) || seen.has(namespace.name)) {
         return yield* CodeExecutorUnsupportedError.make({
@@ -224,6 +237,7 @@ const validateRequest = (
       seen.add(namespace.name);
     }
     const sourceBytes = utf8ByteLength(request.source);
+
     if (sourceBytes > request.limits.maxSourceBytes) {
       return yield* CodeSourceError.make({
         implementation: inProcessCodeExecutorImplementation,
@@ -246,6 +260,7 @@ const serveHostCalls = (
   Effect.gen(function* () {
     while (true) {
       const pending = yield* Queue.take(queue);
+
       counter.calls += 1;
       if (counter.calls > limits.maxHostCalls) {
         return yield* CodeHostCallLimitError.make({
@@ -255,11 +270,13 @@ const serveHostCalls = (
         });
       }
       const argument = safeDecodeJson(pending.argument);
+
       if (Option.isNone(argument)) {
         pending.reject(new TypeError("host call arguments must be JSON values"));
         continue;
       }
       const argumentBytes = encodedJsonByteLength(argument.value);
+
       if (argumentBytes === undefined || argumentBytes > limits.maxHostCallArgumentBytes) {
         return yield* CodeOutputLimitError.make({
           implementation: inProcessCodeExecutorImplementation,
@@ -269,6 +286,7 @@ const serveHostCalls = (
           logs: [...capture.lines],
         });
       }
+
       const rawOutcome = yield* host.call(
         CodeHostCall.make({
           namespace: pending.namespace,
@@ -276,7 +294,9 @@ const serveHostCalls = (
           argument: argument.value,
         }),
       );
+
       const outcome = decodeHostOutcome(rawOutcome);
+
       if (Option.isNone(outcome)) {
         return yield* CodeExecutionProtocolError.make({
           implementation: inProcessCodeExecutorImplementation,
@@ -288,6 +308,7 @@ const serveHostCalls = (
         continue;
       }
       const resultBytes = encodedJsonByteLength(outcome.value.value);
+
       if (resultBytes === undefined || resultBytes > limits.maxHostCallResultBytes) {
         return yield* CodeOutputLimitError.make({
           implementation: inProcessCodeExecutorImplementation,
@@ -307,6 +328,7 @@ const classifyProgramFailure = (
   capture: LogCapture,
 ): CodeOutputLimitError | CodeSourceError | CodeProgramFailedError => {
   const inner = thrown instanceof EvaluationThrew ? thrown.inner : thrown;
+
   if (inner instanceof LogLimitSignal) {
     return CodeOutputLimitError.make({
       implementation: inProcessCodeExecutorImplementation,
@@ -327,6 +349,7 @@ const classifyProgramFailure = (
   // split is by value shape: exception-like values read as `threw`, plain
   // rejection values (an uncaught host failure envelope) read as `rejected`.
   const reason = thrown instanceof EvaluationThrew || inner instanceof Error ? "threw" : "rejected";
+
   return CodeProgramFailedError.make({
     implementation: inProcessCodeExecutorImplementation,
     reason,
@@ -370,11 +393,13 @@ const executeInProcess: CodeExecutorExecute = Effect.fn("InProcessCodeExecutor.e
     // rejected synchronously, so the queue stays bounded against hostile
     // programs.
     let issuedHostCalls = 0;
+
     const namespaceObjects = request.namespaces.map((namespace) =>
       buildNamespaceObject(namespace, (pending) => {
         issuedHostCalls += 1;
         if (issuedHostCalls > request.limits.maxHostCalls + 1) {
           pending.reject(new Error(`host-call limit of ${request.limits.maxHostCalls} exceeded`));
+
           return;
         }
         Queue.offerUnsafe(queue, pending);
@@ -388,6 +413,7 @@ const executeInProcess: CodeExecutorExecute = Effect.fn("InProcessCodeExecutor.e
     const program = Effect.tryPromise({
       try: async () => {
         let candidate: unknown;
+
         try {
           candidate = factory(
             ...shadowedGlobals.map(() => undefined),
@@ -401,17 +427,20 @@ const executeInProcess: CodeExecutorExecute = Effect.fn("InProcessCodeExecutor.e
           throw new EvaluationThrew(new NotAFunction(typeof candidate));
         }
         let outcome: unknown;
+
         try {
           outcome = candidate();
         } catch (cause) {
           throw new EvaluationThrew(cause);
         }
+
         return await Promise.resolve(outcome);
       },
       catch: (thrown) => classifyProgramFailure(thrown, request.limits, capture),
     });
 
     const startedAt = yield* Clock.currentTimeMillis;
+
     // The wall-clock deadline interrupts only at asynchronous suspension
     // points: a synchronous runaway shares the host thread and cannot be
     // stopped in-process — exactly why the platform CPU enforcement cases
@@ -431,6 +460,7 @@ const executeInProcess: CodeExecutorExecute = Effect.fn("InProcessCodeExecutor.e
       }),
       Effect.ensuring(Fiber.interrupt(server)),
     );
+
     const finishedAt = yield* Clock.currentTimeMillis;
 
     // An unawaited burst can outrun the server: the program may return before
@@ -456,7 +486,9 @@ const executeInProcess: CodeExecutorExecute = Effect.fn("InProcessCodeExecutor.e
         }),
       ),
     );
+
     const resultBytes = encodedJsonByteLength(value);
+
     if (resultBytes === undefined || resultBytes > request.limits.maxResultBytes) {
       return yield* CodeOutputLimitError.make({
         implementation: inProcessCodeExecutorImplementation,

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

@@ -16,10 +16,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 +68,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)),
 });
@@ -125,9 +128,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 +141,7 @@ export const researchDocumentLookup = (
   query: DocumentQuery,
 ): Effect.Effect<ResearchDocument, DocumentUnavailable> => {
   const entry = corpusEntries.get(query.documentId);
+
   return entry === undefined
     ? Effect.fail(
         DocumentUnavailable.make({
@@ -333,6 +339,7 @@ export const expectedResearchDigest = (
   ResearchDigest.make({
     findings: documentIds.map((documentId) => {
       const summary = documentSummaryFor(documentId);
+
       return SummaryFinding.make({
         documentId: summary.documentId,
         summary: summary.summary,

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

@@ -53,9 +53,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));
@@ -154,6 +156,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,
@@ -166,13 +169,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) };
   });
 
@@ -217,12 +223,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({
@@ -232,14 +241,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)
@@ -247,9 +259,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)
@@ -257,6 +271,7 @@ export const makeDocsResearcherHarness = (options?: DocsResearcherHarnessOptions
           : summaryDelegationParts(documentIds),
       ),
     );
+
     const parentBinding = Agent.withModel(DocsResearcher, parentModel.model);
 
     const delegationLayer = docsSummaryHandlersLayer(childBinding).pipe(
@@ -273,6 +288,7 @@ export const makeDocsResearcherHarness = (options?: DocsResearcherHarnessOptions
       parentBinding,
       docsCoordinatorDigests,
     ).pipe(Effect.provide(delegationLayer));
+
     const childResolved: ResolvedBinding = yield* DurableWorkerBinding.make(
       childBinding,
       docsSummarizerDigests,
@@ -288,6 +304,7 @@ export const makeDocsResearcherHarness = (options?: DocsResearcherHarnessOptions
       fetchInvocations: (documentId) =>
         Ref.get(fetchCounts).pipe(Effect.map((current) => current.get(documentId) ?? 0)),
     };
+
     return harness;
   });
 
@@ -302,9 +319,11 @@ const encodeResearchDocument = Schema.encodeEffect(ResearchDocument);
 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

@@ -5,7 +5,8 @@ import {
   McpToolkitMismatch,
   type McpConnection,
 } from "@effect-agent/capabilities";
-import { Effect, JsonSchema, Layer, Schema } from "effect";
+import type { JsonSchema } from "effect";
+import { Effect, JsonPointer, Layer, Schema } from "effect";
 import { Tool } from "effect/unstable/ai";
 import * as McpSchema from "effect/unstable/ai/McpSchema";
 
@@ -48,17 +49,25 @@ 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 resolved = JsonSchema.resolve$ref(ref, 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);
 };
 
@@ -132,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(
@@ -142,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

@@ -5,11 +5,13 @@ 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 +86,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 +110,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 +124,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 +137,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 +145,7 @@ export const SearchLodging = Tool.make("search_lodging", {
   failureMode: "error",
   dependencies: [LodgingCatalog],
 });
+
 export const SearchActivities = Tool.make("search_activities", {
   parameters: ActivityQuery,
   success: ActivitySearchResult,
@@ -144,6 +155,7 @@ 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)),