@effect-agent/testing 0.1.0-beta.24 → 0.1.0-beta.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-agent/testing",
-  "version": "0.1.0-beta.24",
+  "version": "0.1.0-beta.25",
   "exports": {
     ".": {
       "types": "./dist/index.d.mts",
@@ -8,14 +8,14 @@
     }
   },
   "dependencies": {
-    "@effect-agent/capabilities": "0.1.0-beta.24",
-    "@effect-agent/core": "0.1.0-beta.24",
-    "@effect-agent/engine": "0.1.0-beta.24",
-    "@effect-agent/platform-node": "0.1.0-beta.24",
-    "@effect-agent/sandbox": "0.1.0-beta.24",
-    "@effect-agent/session": "0.1.0-beta.24",
-    "@effect-agent/storage-memory": "0.1.0-beta.24",
-    "@effect-agent/storage-sqlite": "0.1.0-beta.24",
+    "@effect-agent/capabilities": "0.1.0-beta.25",
+    "@effect-agent/core": "0.1.0-beta.25",
+    "@effect-agent/engine": "0.1.0-beta.25",
+    "@effect-agent/platform-node": "0.1.0-beta.25",
+    "@effect-agent/sandbox": "0.1.0-beta.25",
+    "@effect-agent/session": "0.1.0-beta.25",
+    "@effect-agent/storage-memory": "0.1.0-beta.25",
+    "@effect-agent/storage-sqlite": "0.1.0-beta.25",
     "effect": "4.0.0-rc.110"
   },
   "description": "Scripted models, deterministic fixtures, and adapter conformance kits for testing Effect Agent applications.",

package/src/certification.ts

@@ -51,8 +51,8 @@ import {
   type ResolvedBinding,
   type SubmissionSnapshot,
 } from "@effect-agent/session";
-import type { CertificationCaseResult } from "@effect-agent/session/testing";
 import {
+  type CertificationCaseResult,
   CertificationReport,
   CertificationSweepResult,
   CertificationTierThreeReport,
@@ -670,7 +670,7 @@ const failureTagOf = <E>(cause: Cause.Cause<E>): string => {
   if (Option.isSome(failure)) {
     const error: unknown = failure.value;
     if (typeof error === "object" && error !== null && "_tag" in error) {
-      return String((error as { _tag: unknown })._tag);
+      return String(error._tag);
     }
     return String(error).slice(0, 256);
   }

package/src/chaos.ts

@@ -10,9 +10,9 @@ import {
   ConversationId,
   IdGenerator,
   RunId,
-  SubmissionId,
   ToolCallId,
   TurnId,
+  type SubmissionId,
 } from "@effect-agent/core";
 import { DurableStep, DurableStepError, ToolExecutionClass } from "@effect-agent/engine";
 import {
@@ -42,6 +42,9 @@ import {
   verifyConversationInvariants,
   type CanonicalRecordEnvelope,
   type BatchId,
+  type DurableBindingFailure,
+  type DurableSubmitFailure,
+  type DurableWorkerFailure,
   type ProducerId,
   type Receipt,
   type ResolvedBinding,
@@ -51,7 +54,14 @@ import {
 } from "@effect-agent/session";
 import { Cause, Effect, Exit, Layer, Option, Ref, Schema, Stream } from "effect";
 import { FastCheck } from "effect/testing";
-import { LanguageModel, Model, Prompt, Tool, Toolkit, type Response } from "effect/unstable/ai";
+import {
+  LanguageModel,
+  Model,
+  Tool,
+  Toolkit,
+  type Prompt,
+  type Response,
+} from "effect/unstable/ai";
 
 /**
  * P7 WP4 chaos machinery (plan §5): a Schema-first `ChaosPlan`, a seeded generator over
@@ -176,12 +186,14 @@ export class ChaosConvergenceFailure extends Schema.TaggedError<ChaosConvergence
 /** Default root seed for chaos suites; override with the `CHAOS_SEED` environment variable. */
 export const DEFAULT_CHAOS_SEED = 20260813;
 
+const ChaosSeedFromEnvironment = Schema.FiniteFromString.check(Schema.isInt());
+const decodeChaosSeedFromEnvironment = Schema.decodeUnknownOption(ChaosSeedFromEnvironment);
+
 /** The root seed for this run: `CHAOS_SEED` when set to an integer, the default otherwise. */
 export const chaosSeedFromEnv = (env: Record<string, string | undefined>): number => {
   const raw = env["CHAOS_SEED"];
   if (raw === undefined || raw === "") return DEFAULT_CHAOS_SEED;
-  const parsed = Number.parseInt(raw, 10);
-  return Number.isSafeInteger(parsed) ? parsed : DEFAULT_CHAOS_SEED;
+  return Option.getOrElse(decodeChaosSeedFromEnvironment(raw), () => DEFAULT_CHAOS_SEED);
 };
 
 export interface ChaosGeneratorOptions {
@@ -458,11 +470,11 @@ const DELEGATE_CALL_ID = "chaos-delegate-1";
 const HEX = "0123456789abcdef";
 const decodeDigest = Schema.decodeSync(Digest);
 const laneDigests = (lane: number): DefinitionDigests => {
-  const digest = decodeDigest(HEX[lane % 8]!.repeat(64));
+  const digest = decodeDigest(HEX.charAt(lane % 8).repeat(64));
   return DefinitionDigests.make({ agent: digest, model: digest, tools: digest });
 };
 const childDigestStrings = (lane: number) => {
-  const char = HEX[8 + (lane % 8)]!;
+  const char = HEX.charAt(8 + (lane % 8));
   return { agent: char.repeat(64), model: char.repeat(64), tools: char.repeat(64) } as const;
 };
 const childLaneDigests = (lane: number): DefinitionDigests => {
@@ -565,10 +577,12 @@ interface LaneFixture {
   readonly ref: string;
   readonly deskInPlay: boolean;
   readonly submissionIndexes: ReadonlyArray<number>;
-  readonly submitOne: (flatIndex: number) => Effect.Effect<Receipt, unknown>;
+  readonly submitOne: (flatIndex: number) => Effect.Effect<Receipt, DurableSubmitFailure>;
   readonly drives: (
     firstReceipt: Receipt | undefined,
-  ) => ReadonlyArray<Effect.Effect<ReadonlyArray<Settlement>, unknown>>;
+  ) => ReadonlyArray<
+    Effect.Effect<ReadonlyArray<Settlement>, DurableWorkerFailure | DurableBindingFailure>
+  >;
   readonly childConversationOf: (firstReceipt: Receipt) => ConversationId | undefined;
 }
 
@@ -636,8 +650,8 @@ const makeLaneFixture = Effect.fn("Chaos.makeLaneFixture")(function* (
 
   const plainLaneFixture = (
     deskInPlay: boolean,
-    drive: Effect.Effect<ReadonlyArray<Settlement>, unknown>,
-    submitOne: (flatIndex: number) => Effect.Effect<Receipt, unknown>,
+    drive: Effect.Effect<ReadonlyArray<Settlement>, DurableWorkerFailure | DurableBindingFailure>,
+    submitOne: (flatIndex: number) => Effect.Effect<Receipt, DurableSubmitFailure>,
   ): LaneFixture => ({
     index: laneIndex,
     kind,
@@ -746,9 +760,9 @@ const makeLaneFixture = Effect.fn("Chaos.makeLaneFixture")(function* (
             submitOptionsFor(flatIndex),
           ),
         drives: (firstReceipt) => {
-          const drives: Array<Effect.Effect<ReadonlyArray<Settlement>, unknown>> = [
-            driveResolved(conversationId),
-          ];
+          const drives: Array<
+            Effect.Effect<ReadonlyArray<Settlement>, DurableWorkerFailure | DurableBindingFailure>
+          > = [driveResolved(conversationId)];
           if (firstReceipt !== undefined) {
             drives.push(
               driveResolved(
@@ -838,9 +852,9 @@ const resolutionPass = Effect.fn("Chaos.resolutionPass")(function* (
         const kind =
           plan.resolutionInjections.length === 0
             ? "never-happened"
-            : plan.resolutionInjections[
-                injectionIndex(flatIndex, call.toolCallId, plan.resolutionInjections.length)
-              ]!;
+            : (plan.resolutionInjections.at(
+                injectionIndex(flatIndex, call.toolCallId, plan.resolutionInjections.length),
+              ) ?? "never-happened");
         yield* tolerateTyped(
           runtime.resolveUnknown(
             UnknownResolutionCommand.make({
@@ -858,9 +872,9 @@ const resolutionPass = Effect.fn("Chaos.resolutionPass")(function* (
         const decision =
           plan.approvalDecisions.length === 0
             ? "approved"
-            : plan.approvalDecisions[
-                injectionIndex(flatIndex, pending.toolCallId, plan.approvalDecisions.length)
-              ]!;
+            : (plan.approvalDecisions.at(
+                injectionIndex(flatIndex, pending.toolCallId, plan.approvalDecisions.length),
+              ) ?? "approved");
         yield* tolerateTyped(
           runtime.resolveApproval(
             ApprovalDecisionCommand.make({
@@ -975,11 +989,19 @@ export const runChaosPlan = Effect.fn("Chaos.runChaosPlan")(function* (
     lanes.push(yield* makeLaneFixture(plan, lane, kind, laneSubmissions.get(lane) ?? [], desk));
   }
 
-  const states: Array<SubmissionState> = plan.submissions.map((spec, flatIndex) => ({
-    flatIndex,
-    lane: lanes.find((fixture) => fixture.index === spec.lane % plan.lanes)!,
-    receipt: undefined,
-  }));
+  const lanesByIndex = new Map(lanes.map((lane) => [lane.index, lane]));
+  const states: Array<SubmissionState> = [];
+  for (const [flatIndex, spec] of plan.submissions.entries()) {
+    const laneIndex = spec.lane % plan.lanes;
+    const lane = lanesByIndex.get(laneIndex);
+    if (lane === undefined) {
+      return yield* ChaosConvergenceFailure.make({
+        seed: plan.seed,
+        message: `submission ${flatIndex} addresses missing lane ${laneIndex}`,
+      });
+    }
+    states.push({ flatIndex, lane, receipt: undefined });
+  }
   const appliedAborts = new Set<number>();
 
   type ArmEntry =
@@ -1022,7 +1044,10 @@ export const runChaosPlan = Effect.fn("Chaos.runChaosPlan")(function* (
     }
 
     // Drive every lane (and discovered child lanes) in seeded order under the active arm.
-    const order = [...lanes].sort(() => random() - 0.5);
+    const order = lanes
+      .map((lane) => ({ lane, rank: random() }))
+      .sort((left, right) => left.rank - right.rank || left.lane.index - right.lane.index)
+      .map(({ lane }) => lane);
     for (const lane of order) {
       const firstFlat = lane.submissionIndexes[0];
       const firstReceipt = firstFlat === undefined ? undefined : states[firstFlat]?.receipt;

package/src/code-executor-conformance.d.ts

@@ -1,4 +1,4 @@
-import { CodeExecutor, SandboxImplementation } from "@effect-agent/sandbox";
+import { CodeExecutor, type SandboxImplementation } from "@effect-agent/sandbox";
 import { Effect, Schema } from "effect";
 declare const CodeExecutorConformanceViolation_base: Schema.Class<CodeExecutorConformanceViolation, Schema.TaggedStruct<"CodeExecutorConformanceViolation", {
     readonly caseName: Schema.String;

package/src/code-executor-conformance.ts

@@ -1,18 +1,18 @@
 import {
-  CodeExecutionError,
   CodeExecutionHost,
   CodeExecutionLimits,
   CodeExecutionNamespace,
   CodeExecutionRequest,
-  CodeExecutionResult,
   CodeExecutor,
-  CodeHostCall,
   CodeHostCallFailure,
-  CodeHostCallResult,
   CodeHostCallSuccess,
   NetworkAllowlist,
   NetworkDisabled,
-  SandboxImplementation,
+  type CodeExecutionError,
+  type CodeExecutionResult,
+  type CodeHostCall,
+  type CodeHostCallResult,
+  type SandboxImplementation,
 } from "@effect-agent/sandbox";
 import { Deferred, Duration, Effect, Fiber, Schema } from "effect";
 
@@ -404,6 +404,8 @@ export const codeExecutorConformanceCases = (
         "TEST-015 fails typed on a host outcome outside the protocol schema",
         makeRequest("async () => warehouse.query({})", { namespaces: [warehouseNamespace] }),
         {
+          // Deliberately violate the compile-time host contract to verify that an adapter
+          // independently decodes the runtime protocol boundary.
           call: () => Effect.succeed({ bogus: true } as unknown as CodeHostCallResult),
         },
         "CodeExecutionProtocolError",

package/src/code-executor-substitute.ts

@@ -1,9 +1,6 @@
 import {
   CodeExecutionHost,
-  CodeExecutionLimits,
-  CodeExecutionNamespace,
   CodeExecutionProtocolError,
-  CodeExecutionRequest,
   CodeExecutionResourceUse,
   CodeExecutionResult,
   CodeExecutionTimeoutError,
@@ -17,6 +14,9 @@ import {
   CodeProgramFailedError,
   CodeSourceError,
   SandboxImplementation,
+  type CodeExecutionLimits,
+  type CodeExecutionNamespace,
+  type CodeExecutionRequest,
 } from "@effect-agent/sandbox";
 import { Clock, Duration, Effect, Fiber, Layer, Option, Queue, Schema } from "effect";
 
@@ -346,6 +346,9 @@ const executeInProcess: CodeExecutorExecute = Effect.fn("InProcessCodeExecutor.e
 
     const factory = yield* Effect.try({
       try: () =>
+        // This substitute intentionally evaluates authored test programs in-process and reports
+        // an `unisolated` posture. Real adapters own the security boundary and never use this path.
+        // oxlint-disable-next-line typescript/no-implied-eval
         new Function(
           ...shadowedGlobals,
           "console",
@@ -399,7 +402,7 @@ const executeInProcess: CodeExecutorExecute = Effect.fn("InProcessCodeExecutor.e
         }
         let outcome: unknown;
         try {
-          outcome = (candidate as () => unknown)();
+          outcome = candidate();
         } catch (cause) {
           throw new EvaluationThrew(cause);
         }

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

@@ -18,7 +18,8 @@ import {
   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 { LanguageModel, Model, type Response } from "effect/unstable/ai";
 
 import { DeterministicIdGeneratorLayer } from "../travel-planner/deterministic-layers.ts";

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

@@ -44,13 +44,22 @@ export const docsMcpIdentity = McpServerIdentity.make({
  * 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"];
-  const defs = schema["$defs"] as JsonSchema.Definitions | undefined;
-  if (typeof ref !== "string" || defs === undefined) return schema as McpSchema.ToolJsonSchema;
+  if (typeof ref !== "string") {
+    return decodeToolJsonSchema(schema);
+  }
 
+  const defs = decodeJsonSchemaDefinitions(schema["$defs"]);
   const resolved = JsonSchema.resolve$ref(ref, defs);
-  return (resolved ?? schema) as McpSchema.ToolJsonSchema;
+  return decodeToolJsonSchema(resolved ?? schema);
 };
 
 const fetchDocumentOutputSchema = flattenTopLevelRef(

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

@@ -15,8 +15,6 @@ export const phase1Trip = Schema.decodeSync(TripRequest)({
   budgetCents: 350_000,
   currency: "USD",
 });
-/** Backward-compatible fixture alias while consumers transition to the P1 name. */
-export const phase0Trip = phase1Trip;
 export const expectedTravelPlan: TravelPlanValue = Schema.decodeSync(TravelPlan)({
   itineraries: [
     {
@@ -82,4 +80,3 @@ export const phase1HappyPathTurns = [
     termination: { _tag: "Complete" },
   },
 ] satisfies readonly [ScriptedTurnInput, ScriptedTurnInput];
-export const phase0HappyPathTurns = phase1HappyPathTurns;

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

@@ -20,14 +20,16 @@ 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,

package/src/fixtures/warehouse/index.ts

@@ -1,9 +1,9 @@
 import { ToolExecutionClass } from "@effect-agent/engine";
 import { SqliteClient } from "@effect/sql-sqlite-node";
-import { Context, Duration, Effect, Layer, Option, Predicate, Schema } from "effect";
+import { Context, Effect, Layer, Option, Predicate, Schema, type Duration } from "effect";
 import { Tool, Toolkit } from "effect/unstable/ai";
 import * as SqlClient from "effect/unstable/sql/SqlClient";
-import { SqlError } from "effect/unstable/sql/SqlError";
+import type { SqlError } from "effect/unstable/sql/SqlError";
 
 /**
  * The C3 read-only SQL reference integration (plan §8, SEC-015): application
@@ -196,7 +196,7 @@ const decodeRow = Schema.decodeUnknownOption(Schema.Record(Schema.String, Schema
  * on the reason's cause. No error-text matching.
  */
 const isWriteDenial = (error: SqlError): boolean => {
-  const cause = (error.reason as { readonly cause?: unknown }).cause;
+  const cause = error.reason.cause;
   return (
     Predicate.isObject(cause) &&
     "errcode" in cause &&
@@ -206,7 +206,7 @@ const isWriteDenial = (error: SqlError): boolean => {
 };
 
 const sqlFailureMessage = (error: SqlError): string => {
-  const cause = (error.reason as { readonly cause?: unknown }).cause;
+  const cause = error.reason.cause;
   const detail =
     Predicate.isObject(cause) && "errstr" in cause && typeof cause.errstr === "string"
       ? `: ${cause.errstr}`
@@ -275,7 +275,7 @@ export const warehouseDbLayer = (
           return yield* denied;
         }
         const rawRows = yield* sql
-          .unsafe<Record<string, unknown>>(text, parameters as Array<unknown>)
+          .unsafe<Record<string, unknown>>(text, [...parameters])
           .withoutTransform.pipe(
             Effect.catchTag("SqlError", (error) =>
               Effect.fail<WarehouseQueryDenied | WarehouseQueryFailed>(