@effect-uai/core 0.5.0 → 0.5.2

package/dist/retry/Retry.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Retry.d.mts","names":[],"sources":["../../src/retry/Retry.ts"],"mappings":";;;;;;;;;cACoD,cAAA;;;;;;;;;;;AAAA;;;;;;;;;;;;;;;;;;cA6BvC,SAAA,SAAkB,cAAA;EAAA,SACpB,KAAA,EAAO,WAAA,GAAsB,WAAA,GAAsB,OAAA;AAAA;;cAIjD,WAAA,GACX,CAAA,EAAG,OAAA,KACF,CAAA,IAAK,WAAA,GAAsB,WAAA,GAAsB,OAAA;;;;;;;cAgBvC,MAAA,QACL,QAAA,EAAU,QAAA,CAAS,QAAA,CAAS,GAAA,EAAK,SAAA,aAChC,CAAA,EAAG,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,OAAA,EAAiB,CAAA,MAAK,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,OAAA,EAAiB,CAAA;AAzBrF;;;;;;;;;;AAAA,cAkDa,MAAA,QACL,QAAA,EAAU,QAAA,CAAS,QAAA,CAAS,GAAA,EAAK,OAAA,aAChC,GAAA,EAAK,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,OAAA,EAAiB,CAAA,MAAK,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,OAAA,EAAiB,CAAA"}

package/dist/retry/Retry.mjs

@@ -0,0 +1,69 @@
+import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+import { Data, Effect, Stream } from "effect";
+//#region src/retry/Retry.ts
+var Retry_exports = /* @__PURE__ */ __exportAll({
+	Retryable: () => Retryable,
+	effect: () => effect,
+	isRetryable: () => isRetryable,
+	stream: () => stream
+});
+/**
+* Subset-aware retry helpers for `AiError`.
+*
+* Effect's own `Effect.retry` / `Stream.retry` apply the schedule to
+* every failure. For AI calls that's the wrong policy — replaying a
+* `ContentFiltered` or `InvalidRequest` won't change the outcome and
+* just wastes quota. These helpers gate the schedule on the
+* {@link Retryable} subset (rate limits, transport hiccups, timeouts);
+* everything else propagates unchanged.
+*
+* Two carriers:
+* - {@link stream} — for `Stream<A, AiError, R>` (e.g. `streamTurn`,
+*   `streamSynthesis`, `streamTranscriptionFrom`). Caveat: the entire
+*   stream re-runs on retry, so deltas before the failure replay on
+*   the next attempt.
+* - {@link effect} — for `Effect<A, AiError, R>` (e.g. `turn`, `embed`,
+*   `embedMany`, `synthesize`, `transcribe`). At-most-once.
+*
+* Composes with `Stream.retry` / `Effect.retry` directly (no naming
+* collision since these live under the `Retry` namespace).
+*/
+/**
+* Wrapper around the retryable subset of `AiError`. Internal to the
+* lift/retry/unlift dance — exported so callers can build their own
+* variants if needed (e.g. a custom schedule that observes `cause`).
+*/
+var Retryable = class extends Data.TaggedError("RetryableAi") {};
+/** Type-narrowing predicate for the retryable subset. */
+const isRetryable = (e) => e._tag === "RateLimited" || e._tag === "Unavailable" || e._tag === "Timeout";
+/**
+* Retry a `Stream<A, AiError, R>` on the retryable subset. Other
+* failures bypass the schedule and propagate unchanged. The whole
+* stream replays on each attempt — deltas emitted before the failure
+* are re-emitted on the next try.
+*/
+const stream = (schedule) => (s) => s.pipe(Stream.map((value) => ({
+	_tag: "Item",
+	value
+})), Stream.catchIf(isRetryable, (cause) => Stream.fail(new Retryable({ cause })), (cause) => Stream.succeed({
+	_tag: "Terminal",
+	cause
+})), Stream.retry(schedule), Stream.catchTag("RetryableAi", (e) => Stream.fail(e.cause)), Stream.flatMap((item) => item._tag === "Item" ? Stream.succeed(item.value) : Stream.fail(item.cause)));
+/**
+* Retry an `Effect<A, AiError, R>` on the retryable subset. Other
+* failures bypass the schedule and propagate unchanged. At-most-once
+* — the underlying call only re-runs if the previous attempt failed
+* with a retryable tag.
+*
+* Skips the lift/unlift dance the Stream variant needs: `Effect.retry`
+* exposes a `while:` predicate so the error channel stays a plain
+* `AiError` throughout.
+*/
+const effect = (schedule) => (eff) => Effect.retry(eff, {
+	schedule,
+	while: isRetryable
+});
+//#endregion
+export { Retryable, effect, isRetryable, stream, Retry_exports as t };
+
+//# sourceMappingURL=Retry.mjs.map

package/dist/retry/Retry.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Retry.mjs","names":[],"sources":["../../src/retry/Retry.ts"],"sourcesContent":["import { Data, Effect, type Schedule, Stream } from \"effect\"\nimport type * as AiError from \"../domain/AiError.js\"\n\n/**\n * Subset-aware retry helpers for `AiError`.\n *\n * Effect's own `Effect.retry` / `Stream.retry` apply the schedule to\n * every failure. For AI calls that's the wrong policy — replaying a\n * `ContentFiltered` or `InvalidRequest` won't change the outcome and\n * just wastes quota. These helpers gate the schedule on the\n * {@link Retryable} subset (rate limits, transport hiccups, timeouts);\n * everything else propagates unchanged.\n *\n * Two carriers:\n * - {@link stream} — for `Stream<A, AiError, R>` (e.g. `streamTurn`,\n *   `streamSynthesis`, `streamTranscriptionFrom`). Caveat: the entire\n *   stream re-runs on retry, so deltas before the failure replay on\n *   the next attempt.\n * - {@link effect} — for `Effect<A, AiError, R>` (e.g. `turn`, `embed`,\n *   `embedMany`, `synthesize`, `transcribe`). At-most-once.\n *\n * Composes with `Stream.retry` / `Effect.retry` directly (no naming\n * collision since these live under the `Retry` namespace).\n */\n\n/**\n * Wrapper around the retryable subset of `AiError`. Internal to the\n * lift/retry/unlift dance — exported so callers can build their own\n * variants if needed (e.g. a custom schedule that observes `cause`).\n */\nexport class Retryable extends Data.TaggedError(\"RetryableAi\")<{\n  readonly cause: AiError.RateLimited | AiError.Unavailable | AiError.Timeout\n}> {}\n\n/** Type-narrowing predicate for the retryable subset. */\nexport const isRetryable = (\n  e: AiError.AiError,\n): e is AiError.RateLimited | AiError.Unavailable | AiError.Timeout =>\n  e._tag === \"RateLimited\" || e._tag === \"Unavailable\" || e._tag === \"Timeout\"\n\n// Lift events to Items, non-retryable failures to Terminal values\n// (escape retry), retryable failures to wrapped errors (only thing\n// retry sees).\ntype Lifted<A> =\n  | { readonly _tag: \"Item\"; readonly value: A }\n  | { readonly _tag: \"Terminal\"; readonly cause: AiError.AiError }\n\n/**\n * Retry a `Stream<A, AiError, R>` on the retryable subset. Other\n * failures bypass the schedule and propagate unchanged. The whole\n * stream replays on each attempt — deltas emitted before the failure\n * are re-emitted on the next try.\n */\nexport const stream =\n  <Out>(schedule: Schedule.Schedule<Out, Retryable>) =>\n  <A, R>(s: Stream.Stream<A, AiError.AiError, R>): Stream.Stream<A, AiError.AiError, R> =>\n    s.pipe(\n      Stream.map((value): Lifted<A> => ({ _tag: \"Item\", value })),\n      Stream.catchIf(\n        isRetryable,\n        (cause) => Stream.fail(new Retryable({ cause })),\n        (cause) => Stream.succeed<Lifted<A>>({ _tag: \"Terminal\", cause }),\n      ),\n      Stream.retry(schedule),\n      Stream.catchTag(\"RetryableAi\", (e) => Stream.fail<AiError.AiError>(e.cause)),\n      Stream.flatMap((item) =>\n        item._tag === \"Item\" ? Stream.succeed(item.value) : Stream.fail(item.cause),\n      ),\n    )\n\n/**\n * Retry an `Effect<A, AiError, R>` on the retryable subset. Other\n * failures bypass the schedule and propagate unchanged. At-most-once\n * — the underlying call only re-runs if the previous attempt failed\n * with a retryable tag.\n *\n * Skips the lift/unlift dance the Stream variant needs: `Effect.retry`\n * exposes a `while:` predicate so the error channel stays a plain\n * `AiError` throughout.\n */\nexport const effect =\n  <Out>(schedule: Schedule.Schedule<Out, AiError.AiError>) =>\n  <A, R>(eff: Effect.Effect<A, AiError.AiError, R>): Effect.Effect<A, AiError.AiError, R> =>\n    Effect.retry(eff, { schedule, while: isRetryable })\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,IAAa,YAAb,cAA+B,KAAK,YAAY,cAAc,CAE3D;;AAGH,MAAa,eACX,MAEA,EAAE,SAAS,iBAAiB,EAAE,SAAS,iBAAiB,EAAE,SAAS;;;;;;;AAerE,MAAa,UACL,cACC,MACL,EAAE,KACA,OAAO,KAAK,WAAsB;CAAE,MAAM;CAAQ;CAAO,EAAE,EAC3D,OAAO,QACL,cACC,UAAU,OAAO,KAAK,IAAI,UAAU,EAAE,OAAO,CAAC,CAAC,GAC/C,UAAU,OAAO,QAAmB;CAAE,MAAM;CAAY;CAAO,CAAC,CAClE,EACD,OAAO,MAAM,SAAS,EACtB,OAAO,SAAS,gBAAgB,MAAM,OAAO,KAAsB,EAAE,MAAM,CAAC,EAC5E,OAAO,SAAS,SACd,KAAK,SAAS,SAAS,OAAO,QAAQ,KAAK,MAAM,GAAG,OAAO,KAAK,KAAK,MAAM,CAC5E,CACF;;;;;;;;;;;AAYL,MAAa,UACL,cACC,QACL,OAAO,MAAM,KAAK;CAAE;CAAU,OAAO;CAAa,CAAC"}

package/dist/retry/Retry.test.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/retry/Retry.test.mjs

@@ -0,0 +1,142 @@
+import { ContentFiltered, RateLimited, Timeout, Unavailable } from "../domain/AiError.mjs";
+import { effect, stream } from "./Retry.mjs";
+import { i as it, n as globalExpect, r as describe } from "../dist-DV5ISja1.mjs";
+import { Cause, Effect, Exit, Option, Ref, Schedule, Stream } from "effect";
+//#region src/retry/Retry.test.ts
+const planned = (attempts, plan) => Stream.unwrap(Ref.getAndUpdate(attempts, (n) => n + 1).pipe(Effect.map((n) => plan[Math.min(n, plan.length - 1)])));
+const plannedEffect = (attempts, plan) => Ref.getAndUpdate(attempts, (n) => n + 1).pipe(Effect.flatMap((n) => plan[Math.min(n, plan.length - 1)]));
+describe("Retry.stream", () => {
+	it("retries on RateLimited and yields success on the next attempt", async () => {
+		const program = Effect.gen(function* () {
+			const attempts = yield* Ref.make(0);
+			const s = planned(attempts, [Stream.fail(new RateLimited({
+				provider: "mock",
+				raw: null
+			})), Stream.fromIterable(["a", "b"])]).pipe(stream(Schedule.recurs(3)));
+			const out = yield* Stream.runCollect(s);
+			const count = yield* Ref.get(attempts);
+			return {
+				out: Array.from(out),
+				count
+			};
+		});
+		const { out, count } = await Effect.runPromise(program);
+		globalExpect(count).toBe(2);
+		globalExpect(out).toEqual(["a", "b"]);
+	});
+	it("surfaces the underlying retryable failure when retries are exhausted", async () => {
+		const cause = new Unavailable({
+			provider: "mock",
+			raw: null
+		});
+		const s = Stream.fail(cause).pipe(stream(Schedule.recurs(2)));
+		const exit = await Effect.runPromise(Effect.exit(Stream.runCollect(s)));
+		globalExpect(Exit.isFailure(exit)).toBe(true);
+		if (Exit.isFailure(exit)) globalExpect(Cause.findErrorOption(exit.cause)).toEqual(Option.some(cause));
+	});
+	it("bypasses retry for non-retryable AiError (ContentFiltered)", async () => {
+		const program = Effect.gen(function* () {
+			const attempts = yield* Ref.make(0);
+			const cause = new ContentFiltered({
+				provider: "mock",
+				raw: null
+			});
+			const s = planned(attempts, [Stream.fail(cause)]).pipe(stream(Schedule.recurs(5)));
+			return {
+				exit: yield* Effect.exit(Stream.runCollect(s)),
+				count: yield* Ref.get(attempts),
+				cause
+			};
+		});
+		const { exit, count, cause } = await Effect.runPromise(program);
+		globalExpect(count).toBe(1);
+		globalExpect(Exit.isFailure(exit)).toBe(true);
+		if (Exit.isFailure(exit)) globalExpect(Cause.findErrorOption(exit.cause)).toEqual(Option.some(cause));
+	});
+	it("preserves items emitted before a retryable failure (and replays on retry)", async () => {
+		const program = Effect.gen(function* () {
+			const s = planned(yield* Ref.make(0), [Stream.concat(Stream.succeed("partial"), Stream.fail(new Timeout({
+				provider: "mock",
+				raw: null
+			}))), Stream.fromIterable(["partial", "done"])]).pipe(stream(Schedule.recurs(1)));
+			const out = yield* Stream.runCollect(s);
+			return Array.from(out);
+		});
+		globalExpect(await Effect.runPromise(program)).toEqual([
+			"partial",
+			"partial",
+			"done"
+		]);
+	});
+});
+describe("Retry.effect", () => {
+	it("retries on RateLimited and yields success on the next attempt", async () => {
+		const program = Effect.gen(function* () {
+			const attempts = yield* Ref.make(0);
+			return {
+				value: yield* plannedEffect(attempts, [Effect.fail(new RateLimited({
+					provider: "mock",
+					raw: null
+				})), Effect.succeed("ok")]).pipe(effect(Schedule.recurs(3))),
+				count: yield* Ref.get(attempts)
+			};
+		});
+		const { value, count } = await Effect.runPromise(program);
+		globalExpect(count).toBe(2);
+		globalExpect(value).toBe("ok");
+	});
+	it("surfaces the underlying retryable failure when retries are exhausted", async () => {
+		const cause = new Unavailable({
+			provider: "mock",
+			raw: null
+		});
+		const eff = Effect.fail(cause).pipe(effect(Schedule.recurs(2)));
+		const exit = await Effect.runPromise(Effect.exit(eff));
+		globalExpect(Exit.isFailure(exit)).toBe(true);
+		if (Exit.isFailure(exit)) globalExpect(Cause.findErrorOption(exit.cause)).toEqual(Option.some(cause));
+	});
+	it("bypasses retry for non-retryable AiError (ContentFiltered)", async () => {
+		const program = Effect.gen(function* () {
+			const attempts = yield* Ref.make(0);
+			const cause = new ContentFiltered({
+				provider: "mock",
+				raw: null
+			});
+			return {
+				exit: yield* Effect.exit(plannedEffect(attempts, [Effect.fail(cause)]).pipe(effect(Schedule.recurs(5)))),
+				count: yield* Ref.get(attempts),
+				cause
+			};
+		});
+		const { exit, count, cause } = await Effect.runPromise(program);
+		globalExpect(count).toBe(1);
+		globalExpect(Exit.isFailure(exit)).toBe(true);
+		if (Exit.isFailure(exit)) globalExpect(Cause.findErrorOption(exit.cause)).toEqual(Option.some(cause));
+	});
+	it("does NOT replay successful prior work — at-most-once semantics", async () => {
+		const program = Effect.gen(function* () {
+			const attempts = yield* Ref.make(0);
+			return {
+				value: yield* plannedEffect(attempts, [
+					Effect.fail(new Timeout({
+						provider: "mock",
+						raw: null
+					})),
+					Effect.fail(new Timeout({
+						provider: "mock",
+						raw: null
+					})),
+					Effect.succeed("done")
+				]).pipe(effect(Schedule.recurs(5))),
+				count: yield* Ref.get(attempts)
+			};
+		});
+		const { value, count } = await Effect.runPromise(program);
+		globalExpect(count).toBe(3);
+		globalExpect(value).toBe("done");
+	});
+});
+//#endregion
+export {};
+
+//# sourceMappingURL=Retry.test.mjs.map

package/dist/retry/Retry.test.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Retry.test.mjs","names":["AiError.RateLimited","Retry.stream","AiError.Unavailable","AiError.ContentFiltered","AiError.Timeout","Retry.effect"],"sources":["../../src/retry/Retry.test.ts"],"sourcesContent":["import { Cause, Effect, Exit, Option, Ref, Schedule, Stream } from \"effect\"\nimport { describe, expect, it } from \"vitest\"\nimport * as AiError from \"../domain/AiError.js\"\nimport * as Retry from \"./Retry.js\"\n\n// Each call pulls the next plan entry; the last entry repeats forever\n// (so \"succeed on attempt N\" plans naturally re-yield success after).\nconst planned = <A, E>(\n  attempts: Ref.Ref<number>,\n  plan: ReadonlyArray<Stream.Stream<A, E>>,\n): Stream.Stream<A, E> =>\n  Stream.unwrap(\n    Ref.getAndUpdate(attempts, (n) => n + 1).pipe(\n      Effect.map((n) => plan[Math.min(n, plan.length - 1)]!),\n    ),\n  )\n\nconst plannedEffect = <A, E>(\n  attempts: Ref.Ref<number>,\n  plan: ReadonlyArray<Effect.Effect<A, E>>,\n): Effect.Effect<A, E> =>\n  Ref.getAndUpdate(attempts, (n) => n + 1).pipe(\n    Effect.flatMap((n) => plan[Math.min(n, plan.length - 1)]!),\n  )\n\ndescribe(\"Retry.stream\", () => {\n  it(\"retries on RateLimited and yields success on the next attempt\", async () => {\n    const program = Effect.gen(function* () {\n      const attempts = yield* Ref.make(0)\n      const s = planned(attempts, [\n        Stream.fail<AiError.AiError>(new AiError.RateLimited({ provider: \"mock\", raw: null })),\n        Stream.fromIterable([\"a\", \"b\"]),\n      ]).pipe(Retry.stream(Schedule.recurs(3)))\n      const out = yield* Stream.runCollect(s)\n      const count = yield* Ref.get(attempts)\n      return { out: Array.from(out), count }\n    })\n\n    const { out, count } = await Effect.runPromise(program)\n    expect(count).toBe(2)\n    expect(out).toEqual([\"a\", \"b\"])\n  })\n\n  it(\"surfaces the underlying retryable failure when retries are exhausted\", async () => {\n    const cause = new AiError.Unavailable({ provider: \"mock\", raw: null })\n    const s = Stream.fail<AiError.AiError>(cause).pipe(Retry.stream(Schedule.recurs(2)))\n\n    const exit = await Effect.runPromise(Effect.exit(Stream.runCollect(s)))\n    expect(Exit.isFailure(exit)).toBe(true)\n    if (Exit.isFailure(exit)) {\n      expect(Cause.findErrorOption(exit.cause)).toEqual(Option.some(cause))\n    }\n  })\n\n  it(\"bypasses retry for non-retryable AiError (ContentFiltered)\", async () => {\n    const program = Effect.gen(function* () {\n      const attempts = yield* Ref.make(0)\n      const cause = new AiError.ContentFiltered({ provider: \"mock\", raw: null })\n      const s = planned(attempts, [Stream.fail<AiError.AiError>(cause)]).pipe(\n        Retry.stream(Schedule.recurs(5)),\n      )\n      const exit = yield* Effect.exit(Stream.runCollect(s))\n      const count = yield* Ref.get(attempts)\n      return { exit, count, cause }\n    })\n\n    const { exit, count, cause } = await Effect.runPromise(program)\n    expect(count).toBe(1)\n    expect(Exit.isFailure(exit)).toBe(true)\n    if (Exit.isFailure(exit)) {\n      expect(Cause.findErrorOption(exit.cause)).toEqual(Option.some(cause))\n    }\n  })\n\n  it(\"preserves items emitted before a retryable failure (and replays on retry)\", async () => {\n    // Documents the 'replays on retry' caveat: the entire stream re-runs.\n    const program = Effect.gen(function* () {\n      const attempts = yield* Ref.make(0)\n      const s = planned(attempts, [\n        Stream.concat(\n          Stream.succeed(\"partial\"),\n          Stream.fail<AiError.AiError>(new AiError.Timeout({ provider: \"mock\", raw: null })),\n        ),\n        Stream.fromIterable([\"partial\", \"done\"]),\n      ]).pipe(Retry.stream(Schedule.recurs(1)))\n      const out = yield* Stream.runCollect(s)\n      return Array.from(out)\n    })\n\n    const out = await Effect.runPromise(program)\n    expect(out).toEqual([\"partial\", \"partial\", \"done\"])\n  })\n})\n\ndescribe(\"Retry.effect\", () => {\n  it(\"retries on RateLimited and yields success on the next attempt\", async () => {\n    const program = Effect.gen(function* () {\n      const attempts = yield* Ref.make(0)\n      const value = yield* plannedEffect(attempts, [\n        Effect.fail<AiError.AiError>(new AiError.RateLimited({ provider: \"mock\", raw: null })),\n        Effect.succeed(\"ok\"),\n      ]).pipe(Retry.effect(Schedule.recurs(3)))\n      const count = yield* Ref.get(attempts)\n      return { value, count }\n    })\n\n    const { value, count } = await Effect.runPromise(program)\n    expect(count).toBe(2)\n    expect(value).toBe(\"ok\")\n  })\n\n  it(\"surfaces the underlying retryable failure when retries are exhausted\", async () => {\n    const cause = new AiError.Unavailable({ provider: \"mock\", raw: null })\n    const eff = Effect.fail<AiError.AiError>(cause).pipe(Retry.effect(Schedule.recurs(2)))\n\n    const exit = await Effect.runPromise(Effect.exit(eff))\n    expect(Exit.isFailure(exit)).toBe(true)\n    if (Exit.isFailure(exit)) {\n      expect(Cause.findErrorOption(exit.cause)).toEqual(Option.some(cause))\n    }\n  })\n\n  it(\"bypasses retry for non-retryable AiError (ContentFiltered)\", async () => {\n    const program = Effect.gen(function* () {\n      const attempts = yield* Ref.make(0)\n      const cause = new AiError.ContentFiltered({ provider: \"mock\", raw: null })\n      const exit = yield* Effect.exit(\n        plannedEffect(attempts, [Effect.fail<AiError.AiError>(cause)]).pipe(\n          Retry.effect(Schedule.recurs(5)),\n        ),\n      )\n      const count = yield* Ref.get(attempts)\n      return { exit, count, cause }\n    })\n\n    const { exit, count, cause } = await Effect.runPromise(program)\n    expect(count).toBe(1)\n    expect(Exit.isFailure(exit)).toBe(true)\n    if (Exit.isFailure(exit)) {\n      expect(Cause.findErrorOption(exit.cause)).toEqual(Option.some(cause))\n    }\n  })\n\n  it(\"does NOT replay successful prior work — at-most-once semantics\", async () => {\n    // Contrast with Retry.stream: an Effect.retry only re-invokes the\n    // failing computation. No replay of work done before the failure\n    // (there's nothing to replay — Effects are single-shot).\n    const program = Effect.gen(function* () {\n      const attempts = yield* Ref.make(0)\n      const value = yield* plannedEffect(attempts, [\n        Effect.fail<AiError.AiError>(new AiError.Timeout({ provider: \"mock\", raw: null })),\n        Effect.fail<AiError.AiError>(new AiError.Timeout({ provider: \"mock\", raw: null })),\n        Effect.succeed(\"done\"),\n      ]).pipe(Retry.effect(Schedule.recurs(5)))\n      const count = yield* Ref.get(attempts)\n      return { value, count }\n    })\n\n    const { value, count } = await Effect.runPromise(program)\n    expect(count).toBe(3)\n    expect(value).toBe(\"done\")\n  })\n})\n"],"mappings":"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"}

package/dist/testing/MockProvider.d.mts

@@ -1,5 +1,5 @@
-import { d as Item } from "../Items-DqbaJoz7.mjs";
-import { r as Turn } from "../Turn-ChbL2foc.mjs";
+import { d as Item } from "../Items-BH8xUkoR.mjs";
+import { r as Turn } from "../Turn-0CwCAyVe.mjs";
 import { LanguageModel, LanguageModelService } from "../language-model/LanguageModel.mjs";
 import { Duration, Effect, Layer } from "effect";
 

package/dist/testing/MockProvider.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"MockProvider.d.mts","names":[],"sources":["../../src/testing/MockProvider.ts"],"mappings":";;;;;;KAMY,WAAA;;AAAZ;;;;WAMW,aAAA,GAAgB,QAAA,CAAS,KAAA;AAAA;AAAA,KAGxB,IAAA;EAAA,SACD,OAAA,EAAS,aAAA,CAAc,IAAA;EAAA,SACvB,IAAA,EAAM,IAAA;AAAA;;;;;;;KASL,YAAA;EAAA,SACD,KAAA,EAAO,aAAA,CAAc,IAAA;AAAA;;;;;cAqGnB,KAAA,GACX,aAAA,EAAe,aAAA,CAAc,IAAA,GAC7B,OAAA,GAAU,WAAA,KACT,KAAA,CAAM,KAAA,CAAM,aAAA;AAzGf;;;;AAAA,cAqHa,iBAAA,GACX,aAAA,EAAe,aAAA,CAAc,IAAA,GAC7B,OAAA,GAAU,WAAA;EAAA,SAED,KAAA,EAAO,KAAA,CAAM,KAAA,CAAM,aAAA;EAAA,SACnB,QAAA,EAAU,MAAA,CAAO,MAAA,CAAO,YAAA;AAAA;;AApBnC;;;;;cAwCa,IAAA,GACX,aAAA,EAAe,aAAA,CAAc,IAAA,GAC7B,OAAA,GAAU,WAAA;EAAA,SAED,OAAA,EAAS,oBAAA;EAAA,SACT,QAAA,EAAU,MAAA,CAAO,MAAA,CAAO,YAAA;AAAA"}
+{"version":3,"file":"MockProvider.d.mts","names":[],"sources":["../../src/testing/MockProvider.ts"],"mappings":";;;;;;KAUY,WAAA;;AAAZ;;;;WAMW,aAAA,GAAgB,QAAA,CAAS,KAAA;AAAA;AAAA,KAGxB,IAAA;EAAA,SACD,OAAA,EAAS,aAAA,CAAc,IAAA;EAAA,SACvB,IAAA,EAAM,IAAA;AAAA;;;;;;;KASL,YAAA;EAAA,SACD,KAAA,EAAO,aAAA,CAAc,IAAA;AAAA;;;;;cAsGnB,KAAA,GACX,aAAA,EAAe,aAAA,CAAc,IAAA,GAC7B,OAAA,GAAU,WAAA,KACT,KAAA,CAAM,KAAA,CAAM,aAAA;AA1Gf;;;;AAAA,cAsHa,iBAAA,GACX,aAAA,EAAe,aAAA,CAAc,IAAA,GAC7B,OAAA,GAAU,WAAA;EAAA,SAED,KAAA,EAAO,KAAA,CAAM,KAAA,CAAM,aAAA;EAAA,SACnB,QAAA,EAAU,MAAA,CAAO,MAAA,CAAO,YAAA;AAAA;;AApBnC;;;;;cAwCa,IAAA,GACX,aAAA,EAAe,aAAA,CAAc,IAAA,GAC7B,OAAA,GAAU,WAAA;EAAA,SAED,OAAA,EAAS,oBAAA;EAAA,SACT,QAAA,EAAU,MAAA,CAAO,MAAA,CAAO,YAAA;AAAA"}

package/dist/testing/MockProvider.mjs

@@ -1,7 +1,7 @@
 import { InvalidRequest } from "../domain/AiError.mjs";
 import { isOutputText } from "../domain/Items.mjs";
 import { TurnEvent } from "../domain/Turn.mjs";
-import { LanguageModel } from "../language-model/LanguageModel.mjs";
+import { LanguageModel, turnFromStream } from "../language-model/LanguageModel.mjs";
 import { Array, Effect, Layer, Match, Option, Ref, Schedule, Stream } from "effect";
 //#region src/testing/MockProvider.ts
 const itemToDeltas = Match.type().pipe(Match.discriminators("type")({
@@ -29,13 +29,19 @@ const exhausted = (n, attempt) => new InvalidRequest({
 	raw: `MockProvider exhausted: ${n} turns scripted, but call ${attempt} was made`
 });
 const noRecord = (_) => Effect.void;
-const buildService = (scriptedTurns, options, cursor, record) => ({ streamTurn: (request) => Stream.unwrap(Ref.getAndUpdate(cursor, (n) => n + 1).pipe(Effect.flatMap((i) => Option.match(Array.get(scriptedTurns, i), {
-	onNone: () => Effect.succeed(Stream.fail(exhausted(scriptedTurns.length, i + 1))),
-	onSome: (turn) => record({
-		history: request.history,
-		turn
-	}).pipe(Effect.as(pacedDeltas(turn, options)))
-})))) });
+const buildService = (scriptedTurns, options, cursor, record) => {
+	const streamTurn = (request) => Stream.unwrap(Ref.getAndUpdate(cursor, (n) => n + 1).pipe(Effect.flatMap((i) => Option.match(Array.get(scriptedTurns, i), {
+		onNone: () => Effect.succeed(Stream.fail(exhausted(scriptedTurns.length, i + 1))),
+		onSome: (turn) => record({
+			history: request.history,
+			turn
+		}).pipe(Effect.as(pacedDeltas(turn, options)))
+	}))));
+	return {
+		streamTurn,
+		turn: turnFromStream(streamTurn)
+	};
+};
 const makeRecorderUnsafe = () => {
 	const ref = Ref.makeUnsafe([]);
 	return {

package/dist/testing/MockProvider.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"MockProvider.mjs","names":["AiError.InvalidRequest","Arr"],"sources":["../../src/testing/MockProvider.ts"],"sourcesContent":["import { Array as Arr, Duration, Effect, Layer, Match, Option, Ref, Schedule, Stream } from \"effect\"\nimport * as AiError from \"../domain/AiError.js\"\nimport { type Item, isOutputText } from \"../domain/Items.js\"\nimport { LanguageModel, type LanguageModelService } from \"../language-model/LanguageModel.js\"\nimport { type Turn, TurnEvent } from \"../domain/Turn.js\"\n\nexport type MockOptions = {\n  /**\n   * If set, deltas of each scripted turn are spaced by this duration via\n   * `Schedule.spaced`. Combine with `TestClock.adjust` for deterministic\n   * timing in tests.\n   */\n  readonly deltaInterval?: Duration.Input\n}\n\nexport type Call = {\n  readonly history: ReadonlyArray<Item>\n  readonly turn: Turn\n}\n\n/**\n * A scripted mock provider. Pre-canned `Turn` outputs are returned in order,\n * one per call to `streamTurn`. Each scripted turn is split into synthetic\n * deltas (text → ToolCallStart → ToolCallArgsDelta → ... → TurnComplete)\n * so streaming consumers can see realistic delta shapes.\n */\nexport type MockRecorder = {\n  readonly calls: ReadonlyArray<Call>\n}\n\n// ---------------------------------------------------------------------------\n// Pure projection: Turn → ReadonlyArray<TurnEvent>\n// ---------------------------------------------------------------------------\n\nconst itemToDeltas: (item: Item) => ReadonlyArray<TurnEvent> = Match.type<Item>().pipe(\n  Match.discriminators(\"type\")({\n    message: (m): ReadonlyArray<TurnEvent> =>\n      m.role === \"assistant\"\n        ? m.content.filter(isOutputText).map((b) => TurnEvent.TextDelta({ text: b.text }))\n        : [],\n    function_call: (fc) => [\n      TurnEvent.ToolCallStart({ call_id: fc.call_id, name: fc.name }),\n      TurnEvent.ToolCallArgsDelta({ call_id: fc.call_id, delta: fc.arguments }),\n    ],\n    function_call_output: () => [],\n    reasoning: (r) =>\n      r.summary !== undefined\n        ? [TurnEvent.ReasoningDelta({ text: r.summary, kind: \"summary\" as const })]\n        : [],\n  }),\n  Match.exhaustive,\n)\n\nconst turnToDeltas = (turn: Turn): ReadonlyArray<TurnEvent> => [\n  ...turn.items.flatMap(itemToDeltas),\n  TurnEvent.TurnComplete({ turn }),\n]\n\nconst pacedDeltas = (turn: Turn, options?: MockOptions): Stream.Stream<TurnEvent> => {\n  const base = Stream.fromIterable(turnToDeltas(turn))\n  return options?.deltaInterval === undefined\n    ? base\n    : base.pipe(Stream.schedule(Schedule.spaced(options.deltaInterval)))\n}\n\n// ---------------------------------------------------------------------------\n// Canonical service factory. One implementation; sync/Layer/recorder\n// variants below are just different ways to wire the cursor + record hook.\n// ---------------------------------------------------------------------------\n\nconst exhausted = (n: number, attempt: number): AiError.AiError =>\n  new AiError.InvalidRequest({\n    provider: \"mock\",\n    raw: `MockProvider exhausted: ${n} turns scripted, but call ${attempt} was made`,\n  })\n\nconst noRecord = (_: Call): Effect.Effect<void> => Effect.void\n\nconst buildService = (\n  scriptedTurns: ReadonlyArray<Turn>,\n  options: MockOptions | undefined,\n  cursor: Ref.Ref<number>,\n  record: (call: Call) => Effect.Effect<void>,\n): LanguageModelService => ({\n  streamTurn: (request) =>\n    Stream.unwrap(\n      Ref.getAndUpdate(cursor, (n) => n + 1).pipe(\n        Effect.flatMap(\n          (i): Effect.Effect<Stream.Stream<TurnEvent, AiError.AiError>> =>\n            Option.match(Arr.get(scriptedTurns, i), {\n              onNone: () => Effect.succeed(Stream.fail(exhausted(scriptedTurns.length, i + 1))),\n              onSome: (turn) =>\n                record({ history: request.history, turn }).pipe(\n                  Effect.as(pacedDeltas(turn, options)),\n                ),\n            }),\n        ),\n      ),\n    ),\n})\n\n// ---------------------------------------------------------------------------\n// Recorder handle. Unsafe Ref is local: it backs both the `record` write\n// hook (called inside the service) and the `recorder` read effect (called\n// by the test). Both close over the same cell.\n// ---------------------------------------------------------------------------\n\ntype RecorderHandle = {\n  readonly record: (call: Call) => Effect.Effect<void>\n  readonly recorder: Effect.Effect<MockRecorder>\n}\n\nconst makeRecorderUnsafe = (): RecorderHandle => {\n  const ref = Ref.makeUnsafe<ReadonlyArray<Call>>([])\n  return {\n    record: (call) => Ref.update(ref, Arr.append(call)),\n    recorder: Ref.get(ref).pipe(Effect.map((calls): MockRecorder => ({ calls }))),\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Public API\n// ---------------------------------------------------------------------------\n\n/**\n * Layer that registers a `MockProvider` against the `LanguageModel` tag.\n * Calls beyond the scripted turn count fail with `InvalidRequest`.\n */\nexport const layer = (\n  scriptedTurns: ReadonlyArray<Turn>,\n  options?: MockOptions,\n): Layer.Layer<LanguageModel> =>\n  Layer.effect(\n    LanguageModel,\n    Ref.make(0).pipe(\n      Effect.map((cursor) => buildService(scriptedTurns, options, cursor, noRecord)),\n    ),\n  )\n\n/**\n * Like `layer`, but also exposes a recorder that captures every call\n * (history + returned turn).\n */\nexport const layerWithRecorder = (\n  scriptedTurns: ReadonlyArray<Turn>,\n  options?: MockOptions,\n): {\n  readonly layer: Layer.Layer<LanguageModel>\n  readonly recorder: Effect.Effect<MockRecorder>\n} => {\n  const { record, recorder } = makeRecorderUnsafe()\n  return {\n    layer: Layer.effect(\n      LanguageModel,\n      Ref.make(0).pipe(\n        Effect.map((cursor) => buildService(scriptedTurns, options, cursor, record)),\n      ),\n    ),\n    recorder,\n  }\n}\n\n/**\n * Build the `LanguageModelService` value directly (no Layer), plus a\n * recorder. Use this when you want to swap models mid-program via\n * `Effect.provideService` instead of providing one model for the whole\n * program via `Layer`.\n */\nexport const make = (\n  scriptedTurns: ReadonlyArray<Turn>,\n  options?: MockOptions,\n): {\n  readonly service: LanguageModelService\n  readonly recorder: Effect.Effect<MockRecorder>\n} => {\n  const cursor = Ref.makeUnsafe(0)\n  const { record, recorder } = makeRecorderUnsafe()\n  return {\n    service: buildService(scriptedTurns, options, cursor, record),\n    recorder,\n  }\n}\n"],"mappings":";;;;;;AAkCA,MAAM,eAAyD,MAAM,MAAY,CAAC,KAChF,MAAM,eAAe,OAAO,CAAC;CAC3B,UAAU,MACR,EAAE,SAAS,cACP,EAAE,QAAQ,OAAO,aAAa,CAAC,KAAK,MAAM,UAAU,UAAU,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,GAChF,EAAE;CACR,gBAAgB,OAAO,CACrB,UAAU,cAAc;EAAE,SAAS,GAAG;EAAS,MAAM,GAAG;EAAM,CAAC,EAC/D,UAAU,kBAAkB;EAAE,SAAS,GAAG;EAAS,OAAO,GAAG;EAAW,CAAC,CAC1E;CACD,4BAA4B,EAAE;CAC9B,YAAY,MACV,EAAE,YAAY,KAAA,IACV,CAAC,UAAU,eAAe;EAAE,MAAM,EAAE;EAAS,MAAM;EAAoB,CAAC,CAAC,GACzE,EAAE;CACT,CAAC,EACF,MAAM,WACP;AAED,MAAM,gBAAgB,SAAyC,CAC7D,GAAG,KAAK,MAAM,QAAQ,aAAa,EACnC,UAAU,aAAa,EAAE,MAAM,CAAC,CACjC;AAED,MAAM,eAAe,MAAY,YAAoD;CACnF,MAAM,OAAO,OAAO,aAAa,aAAa,KAAK,CAAC;AACpD,QAAO,SAAS,kBAAkB,KAAA,IAC9B,OACA,KAAK,KAAK,OAAO,SAAS,SAAS,OAAO,QAAQ,cAAc,CAAC,CAAC;;AAQxE,MAAM,aAAa,GAAW,YAC5B,IAAIA,eAAuB;CACzB,UAAU;CACV,KAAK,2BAA2B,EAAE,4BAA4B,QAAQ;CACvE,CAAC;AAEJ,MAAM,YAAY,MAAiC,OAAO;AAE1D,MAAM,gBACJ,eACA,SACA,QACA,YAC0B,EAC1B,aAAa,YACX,OAAO,OACL,IAAI,aAAa,SAAS,MAAM,IAAI,EAAE,CAAC,KACrC,OAAO,SACJ,MACC,OAAO,MAAMC,MAAI,IAAI,eAAe,EAAE,EAAE;CACtC,cAAc,OAAO,QAAQ,OAAO,KAAK,UAAU,cAAc,QAAQ,IAAI,EAAE,CAAC,CAAC;CACjF,SAAS,SACP,OAAO;EAAE,SAAS,QAAQ;EAAS;EAAM,CAAC,CAAC,KACzC,OAAO,GAAG,YAAY,MAAM,QAAQ,CAAC,CACtC;CACJ,CAAC,CACL,CACF,CACF,EACJ;AAaD,MAAM,2BAA2C;CAC/C,MAAM,MAAM,IAAI,WAAgC,EAAE,CAAC;AACnD,QAAO;EACL,SAAS,SAAS,IAAI,OAAO,KAAKA,MAAI,OAAO,KAAK,CAAC;EACnD,UAAU,IAAI,IAAI,IAAI,CAAC,KAAK,OAAO,KAAK,WAAyB,EAAE,OAAO,EAAE,CAAC;EAC9E;;;;;;AAWH,MAAa,SACX,eACA,YAEA,MAAM,OACJ,eACA,IAAI,KAAK,EAAE,CAAC,KACV,OAAO,KAAK,WAAW,aAAa,eAAe,SAAS,QAAQ,SAAS,CAAC,CAC/E,CACF;;;;;AAMH,MAAa,qBACX,eACA,YAIG;CACH,MAAM,EAAE,QAAQ,aAAa,oBAAoB;AACjD,QAAO;EACL,OAAO,MAAM,OACX,eACA,IAAI,KAAK,EAAE,CAAC,KACV,OAAO,KAAK,WAAW,aAAa,eAAe,SAAS,QAAQ,OAAO,CAAC,CAC7E,CACF;EACD;EACD;;;;;;;;AASH,MAAa,QACX,eACA,YAIG;CACH,MAAM,SAAS,IAAI,WAAW,EAAE;CAChC,MAAM,EAAE,QAAQ,aAAa,oBAAoB;AACjD,QAAO;EACL,SAAS,aAAa,eAAe,SAAS,QAAQ,OAAO;EAC7D;EACD"}
+{"version":3,"file":"MockProvider.mjs","names":["AiError.InvalidRequest","Arr"],"sources":["../../src/testing/MockProvider.ts"],"sourcesContent":["import { Array as Arr, Duration, Effect, Layer, Match, Option, Ref, Schedule, Stream } from \"effect\"\nimport * as AiError from \"../domain/AiError.js\"\nimport { type Item, isOutputText } from \"../domain/Items.js\"\nimport {\n  LanguageModel,\n  type LanguageModelService,\n  turnFromStream,\n} from \"../language-model/LanguageModel.js\"\nimport { type Turn, TurnEvent } from \"../domain/Turn.js\"\n\nexport type MockOptions = {\n  /**\n   * If set, deltas of each scripted turn are spaced by this duration via\n   * `Schedule.spaced`. Combine with `TestClock.adjust` for deterministic\n   * timing in tests.\n   */\n  readonly deltaInterval?: Duration.Input\n}\n\nexport type Call = {\n  readonly history: ReadonlyArray<Item>\n  readonly turn: Turn\n}\n\n/**\n * A scripted mock provider. Pre-canned `Turn` outputs are returned in order,\n * one per call to `streamTurn`. Each scripted turn is split into synthetic\n * deltas (text → ToolCallStart → ToolCallArgsDelta → ... → TurnComplete)\n * so streaming consumers can see realistic delta shapes.\n */\nexport type MockRecorder = {\n  readonly calls: ReadonlyArray<Call>\n}\n\n// ---------------------------------------------------------------------------\n// Pure projection: Turn → ReadonlyArray<TurnEvent>\n// ---------------------------------------------------------------------------\n\nconst itemToDeltas: (item: Item) => ReadonlyArray<TurnEvent> = Match.type<Item>().pipe(\n  Match.discriminators(\"type\")({\n    message: (m): ReadonlyArray<TurnEvent> =>\n      m.role === \"assistant\"\n        ? m.content.filter(isOutputText).map((b) => TurnEvent.TextDelta({ text: b.text }))\n        : [],\n    function_call: (fc) => [\n      TurnEvent.ToolCallStart({ call_id: fc.call_id, name: fc.name }),\n      TurnEvent.ToolCallArgsDelta({ call_id: fc.call_id, delta: fc.arguments }),\n    ],\n    function_call_output: () => [],\n    reasoning: (r) =>\n      r.summary !== undefined\n        ? [TurnEvent.ReasoningDelta({ text: r.summary, kind: \"summary\" as const })]\n        : [],\n  }),\n  Match.exhaustive,\n)\n\nconst turnToDeltas = (turn: Turn): ReadonlyArray<TurnEvent> => [\n  ...turn.items.flatMap(itemToDeltas),\n  TurnEvent.TurnComplete({ turn }),\n]\n\nconst pacedDeltas = (turn: Turn, options?: MockOptions): Stream.Stream<TurnEvent> => {\n  const base = Stream.fromIterable(turnToDeltas(turn))\n  return options?.deltaInterval === undefined\n    ? base\n    : base.pipe(Stream.schedule(Schedule.spaced(options.deltaInterval)))\n}\n\n// ---------------------------------------------------------------------------\n// Canonical service factory. One implementation; sync/Layer/recorder\n// variants below are just different ways to wire the cursor + record hook.\n// ---------------------------------------------------------------------------\n\nconst exhausted = (n: number, attempt: number): AiError.AiError =>\n  new AiError.InvalidRequest({\n    provider: \"mock\",\n    raw: `MockProvider exhausted: ${n} turns scripted, but call ${attempt} was made`,\n  })\n\nconst noRecord = (_: Call): Effect.Effect<void> => Effect.void\n\nconst buildService = (\n  scriptedTurns: ReadonlyArray<Turn>,\n  options: MockOptions | undefined,\n  cursor: Ref.Ref<number>,\n  record: (call: Call) => Effect.Effect<void>,\n): LanguageModelService => {\n  const streamTurn: LanguageModelService[\"streamTurn\"] = (request) =>\n    Stream.unwrap(\n      Ref.getAndUpdate(cursor, (n) => n + 1).pipe(\n        Effect.flatMap(\n          (i): Effect.Effect<Stream.Stream<TurnEvent, AiError.AiError>> =>\n            Option.match(Arr.get(scriptedTurns, i), {\n              onNone: () => Effect.succeed(Stream.fail(exhausted(scriptedTurns.length, i + 1))),\n              onSome: (turn) =>\n                record({ history: request.history, turn }).pipe(\n                  Effect.as(pacedDeltas(turn, options)),\n                ),\n            }),\n        ),\n      ),\n    )\n  return { streamTurn, turn: turnFromStream(streamTurn) }\n}\n\n// ---------------------------------------------------------------------------\n// Recorder handle. Unsafe Ref is local: it backs both the `record` write\n// hook (called inside the service) and the `recorder` read effect (called\n// by the test). Both close over the same cell.\n// ---------------------------------------------------------------------------\n\ntype RecorderHandle = {\n  readonly record: (call: Call) => Effect.Effect<void>\n  readonly recorder: Effect.Effect<MockRecorder>\n}\n\nconst makeRecorderUnsafe = (): RecorderHandle => {\n  const ref = Ref.makeUnsafe<ReadonlyArray<Call>>([])\n  return {\n    record: (call) => Ref.update(ref, Arr.append(call)),\n    recorder: Ref.get(ref).pipe(Effect.map((calls): MockRecorder => ({ calls }))),\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Public API\n// ---------------------------------------------------------------------------\n\n/**\n * Layer that registers a `MockProvider` against the `LanguageModel` tag.\n * Calls beyond the scripted turn count fail with `InvalidRequest`.\n */\nexport const layer = (\n  scriptedTurns: ReadonlyArray<Turn>,\n  options?: MockOptions,\n): Layer.Layer<LanguageModel> =>\n  Layer.effect(\n    LanguageModel,\n    Ref.make(0).pipe(\n      Effect.map((cursor) => buildService(scriptedTurns, options, cursor, noRecord)),\n    ),\n  )\n\n/**\n * Like `layer`, but also exposes a recorder that captures every call\n * (history + returned turn).\n */\nexport const layerWithRecorder = (\n  scriptedTurns: ReadonlyArray<Turn>,\n  options?: MockOptions,\n): {\n  readonly layer: Layer.Layer<LanguageModel>\n  readonly recorder: Effect.Effect<MockRecorder>\n} => {\n  const { record, recorder } = makeRecorderUnsafe()\n  return {\n    layer: Layer.effect(\n      LanguageModel,\n      Ref.make(0).pipe(\n        Effect.map((cursor) => buildService(scriptedTurns, options, cursor, record)),\n      ),\n    ),\n    recorder,\n  }\n}\n\n/**\n * Build the `LanguageModelService` value directly (no Layer), plus a\n * recorder. Use this when you want to swap models mid-program via\n * `Effect.provideService` instead of providing one model for the whole\n * program via `Layer`.\n */\nexport const make = (\n  scriptedTurns: ReadonlyArray<Turn>,\n  options?: MockOptions,\n): {\n  readonly service: LanguageModelService\n  readonly recorder: Effect.Effect<MockRecorder>\n} => {\n  const cursor = Ref.makeUnsafe(0)\n  const { record, recorder } = makeRecorderUnsafe()\n  return {\n    service: buildService(scriptedTurns, options, cursor, record),\n    recorder,\n  }\n}\n"],"mappings":";;;;;;AAsCA,MAAM,eAAyD,MAAM,MAAY,CAAC,KAChF,MAAM,eAAe,OAAO,CAAC;CAC3B,UAAU,MACR,EAAE,SAAS,cACP,EAAE,QAAQ,OAAO,aAAa,CAAC,KAAK,MAAM,UAAU,UAAU,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,GAChF,EAAE;CACR,gBAAgB,OAAO,CACrB,UAAU,cAAc;EAAE,SAAS,GAAG;EAAS,MAAM,GAAG;EAAM,CAAC,EAC/D,UAAU,kBAAkB;EAAE,SAAS,GAAG;EAAS,OAAO,GAAG;EAAW,CAAC,CAC1E;CACD,4BAA4B,EAAE;CAC9B,YAAY,MACV,EAAE,YAAY,KAAA,IACV,CAAC,UAAU,eAAe;EAAE,MAAM,EAAE;EAAS,MAAM;EAAoB,CAAC,CAAC,GACzE,EAAE;CACT,CAAC,EACF,MAAM,WACP;AAED,MAAM,gBAAgB,SAAyC,CAC7D,GAAG,KAAK,MAAM,QAAQ,aAAa,EACnC,UAAU,aAAa,EAAE,MAAM,CAAC,CACjC;AAED,MAAM,eAAe,MAAY,YAAoD;CACnF,MAAM,OAAO,OAAO,aAAa,aAAa,KAAK,CAAC;AACpD,QAAO,SAAS,kBAAkB,KAAA,IAC9B,OACA,KAAK,KAAK,OAAO,SAAS,SAAS,OAAO,QAAQ,cAAc,CAAC,CAAC;;AAQxE,MAAM,aAAa,GAAW,YAC5B,IAAIA,eAAuB;CACzB,UAAU;CACV,KAAK,2BAA2B,EAAE,4BAA4B,QAAQ;CACvE,CAAC;AAEJ,MAAM,YAAY,MAAiC,OAAO;AAE1D,MAAM,gBACJ,eACA,SACA,QACA,WACyB;CACzB,MAAM,cAAkD,YACtD,OAAO,OACL,IAAI,aAAa,SAAS,MAAM,IAAI,EAAE,CAAC,KACrC,OAAO,SACJ,MACC,OAAO,MAAMC,MAAI,IAAI,eAAe,EAAE,EAAE;EACtC,cAAc,OAAO,QAAQ,OAAO,KAAK,UAAU,cAAc,QAAQ,IAAI,EAAE,CAAC,CAAC;EACjF,SAAS,SACP,OAAO;GAAE,SAAS,QAAQ;GAAS;GAAM,CAAC,CAAC,KACzC,OAAO,GAAG,YAAY,MAAM,QAAQ,CAAC,CACtC;EACJ,CAAC,CACL,CACF,CACF;AACH,QAAO;EAAE;EAAY,MAAM,eAAe,WAAW;EAAE;;AAczD,MAAM,2BAA2C;CAC/C,MAAM,MAAM,IAAI,WAAgC,EAAE,CAAC;AACnD,QAAO;EACL,SAAS,SAAS,IAAI,OAAO,KAAKA,MAAI,OAAO,KAAK,CAAC;EACnD,UAAU,IAAI,IAAI,IAAI,CAAC,KAAK,OAAO,KAAK,WAAyB,EAAE,OAAO,EAAE,CAAC;EAC9E;;;;;;AAWH,MAAa,SACX,eACA,YAEA,MAAM,OACJ,eACA,IAAI,KAAK,EAAE,CAAC,KACV,OAAO,KAAK,WAAW,aAAa,eAAe,SAAS,QAAQ,SAAS,CAAC,CAC/E,CACF;;;;;AAMH,MAAa,qBACX,eACA,YAIG;CACH,MAAM,EAAE,QAAQ,aAAa,oBAAoB;AACjD,QAAO;EACL,OAAO,MAAM,OACX,eACA,IAAI,KAAK,EAAE,CAAC,KACV,OAAO,KAAK,WAAW,aAAa,eAAe,SAAS,QAAQ,OAAO,CAAC,CAC7E,CACF;EACD;EACD;;;;;;;;AASH,MAAa,QACX,eACA,YAIG;CACH,MAAM,SAAS,IAAI,WAAW,EAAE;CAChC,MAAM,EAAE,QAAQ,aAAa,oBAAoB;AACjD,QAAO;EACL,SAAS,aAAa,eAAe,SAAS,QAAQ,OAAO;EAC7D;EACD"}

package/dist/tool/HistoryCheck.d.mts

@@ -1,4 +1,4 @@
-import { d as Item, o as FunctionCall } from "../Items-DqbaJoz7.mjs";
+import { d as Item, o as FunctionCall } from "../Items-BH8xUkoR.mjs";
 import { ToolResult } from "./Outcome.mjs";
 
 //#region src/tool/HistoryCheck.d.ts

package/dist/tool/Outcome.d.mts

@@ -1,4 +1,4 @@
-import { o as FunctionCall, s as FunctionCallOutput } from "../Items-DqbaJoz7.mjs";
+import { o as FunctionCall, s as FunctionCallOutput } from "../Items-BH8xUkoR.mjs";
 import { Data } from "effect";
 import * as _$effect_Unify0 from "effect/Unify";
 

package/dist/tool/Resolvers.d.mts

@@ -1,4 +1,4 @@
-import { o as FunctionCall } from "../Items-DqbaJoz7.mjs";
+import { o as FunctionCall } from "../Items-BH8xUkoR.mjs";
 import { ToolResult } from "./Outcome.mjs";
 import { ToolEvent } from "./ToolEvent.mjs";
 import { Data, Effect, Queue, Scope, Stream } from "effect";

package/dist/tool/Tool.d.mts

@@ -1,2 +1,2 @@
-import { a as Tool, c as ToolInputSchema, d as fromEffectSchema, f as fromStandardSchema, g as toDescriptors, h as streaming, i as StreamingTool, m as make, n as AnyPlainTool, o as ToolDescriptor, p as isStreamingTool, r as AnyStreamingTool, s as ToolError, t as AnyKindTool, u as execute } from "../Tool-Y0__Py1H.mjs";
+import { a as Tool, c as ToolInputSchema, d as fromEffectSchema, f as fromStandardSchema, g as toDescriptors, h as streaming, i as StreamingTool, m as make, n as AnyPlainTool, o as ToolDescriptor, p as isStreamingTool, r as AnyStreamingTool, s as ToolError, t as AnyKindTool, u as execute } from "../Tool-87ViKCCO.mjs";
 export { AnyKindTool, AnyPlainTool, AnyStreamingTool, StreamingTool, Tool, ToolDescriptor, ToolError, ToolInputSchema, execute, fromEffectSchema, fromStandardSchema, isStreamingTool, make, streaming, toDescriptors };

package/dist/tool/Toolkit.d.mts

@@ -1,5 +1,5 @@
-import { o as FunctionCall } from "../Items-DqbaJoz7.mjs";
-import { a as Tool, i as StreamingTool, o as ToolDescriptor, t as AnyKindTool } from "../Tool-Y0__Py1H.mjs";
+import { o as FunctionCall } from "../Items-BH8xUkoR.mjs";
+import { a as Tool, i as StreamingTool, o as ToolDescriptor, t as AnyKindTool } from "../Tool-87ViKCCO.mjs";
 import { Event } from "../loop/Loop.mjs";
 import { ToolResult } from "./Outcome.mjs";
 import { ToolEvent } from "./ToolEvent.mjs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-uai/core",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "Low-level primitives (loop, conversation, items, tools, streaming codecs) for building AI agents with Effect.",
   "keywords": [
     "agents",
@@ -94,6 +94,10 @@
       "types": "./dist/loop/Loop.d.mts",
       "import": "./dist/loop/Loop.mjs"
     },
+    "./Retry": {
+      "types": "./dist/retry/Retry.d.mts",
+      "import": "./dist/retry/Retry.mjs"
+    },
     "./Vector": {
       "types": "./dist/math/Vector.d.mts",
       "import": "./dist/math/Vector.mjs"

package/src/index.ts

@@ -14,6 +14,7 @@ export * as SpeechSynthesizer from "./speech-synthesizer/SpeechSynthesizer.js"
 export * as Transcriber from "./transcriber/Transcriber.js"
 export * as Vector from "./math/Vector.js"
 export * as Loop from "./loop/Loop.js"
+export * as Retry from "./retry/Retry.js"
 export * as Tool from "./tool/Tool.js"
 export * as Toolkit from "./tool/Toolkit.js"
 export * as Outcome from "./tool/Outcome.js"

package/src/language-model/LanguageModel.test.ts

@@ -1,9 +1,13 @@
-import { Cause, Effect, Exit, Layer, Option, Ref, Schedule, Stream } from "effect"
+import { Cause, Effect, Exit, Layer, Option, Stream } from "effect"
 import { describe, expect, it } from "vitest"
 import * as AiError from "../domain/AiError.js"
 import * as Items from "../domain/Items.js"
 import { type Turn, TurnEvent } from "../domain/Turn.js"
-import { LanguageModel, retry, turn } from "./LanguageModel.js"
+import { LanguageModel, type LanguageModelService, turn, turnFromStream } from "./LanguageModel.js"
+
+const serviceFromStream = (
+  streamTurn: LanguageModelService["streamTurn"],
+): LanguageModelService => ({ streamTurn, turn: turnFromStream(streamTurn) })
 import * as MockProvider from "../testing/MockProvider.js"
 
 const oneTextTurn = (text: string): Turn => ({
@@ -26,9 +30,12 @@ describe("LanguageModel.turn", () => {
 
   it("fails with IncompleteTurn when the stream ends without TurnComplete", async () => {
     // Custom service whose stream emits a single TextDelta and then ends.
-    const broken = Layer.succeed(LanguageModel, {
-      streamTurn: () => Stream.fromIterable<TurnEvent>([TurnEvent.TextDelta({ text: "partial" })]),
-    })
+    const broken = Layer.succeed(
+      LanguageModel,
+      serviceFromStream(() =>
+        Stream.fromIterable<TurnEvent>([TurnEvent.TextDelta({ text: "partial" })]),
+      ),
+    )
 
     const program = turn({ history: [Items.userText("hi")], model: "mock" })
     const exit = await Effect.runPromise(Effect.exit(program.pipe(Effect.provide(broken))))
@@ -45,9 +52,10 @@ describe("LanguageModel.turn", () => {
 
   it("propagates an AiError raised by streamTurn", async () => {
     const rateLimited = new AiError.RateLimited({ provider: "mock", raw: null })
-    const failing = Layer.succeed(LanguageModel, {
-      streamTurn: () => Stream.fail<AiError.AiError>(rateLimited),
-    })
+    const failing = Layer.succeed(
+      LanguageModel,
+      serviceFromStream(() => Stream.fail<AiError.AiError>(rateLimited)),
+    )
 
     const program = turn({ history: [], model: "mock" })
     const exit = await Effect.runPromise(Effect.exit(program.pipe(Effect.provide(failing))))
@@ -63,13 +71,15 @@ describe("LanguageModel.turn", () => {
     // should pick the last one (the most recent assembled Turn).
     const first = oneTextTurn("first")
     const second = oneTextTurn("second")
-    const weird = Layer.succeed(LanguageModel, {
-      streamTurn: () =>
+    const weird = Layer.succeed(
+      LanguageModel,
+      serviceFromStream(() =>
         Stream.fromIterable<TurnEvent>([
           TurnEvent.TurnComplete({ turn: first }),
           TurnEvent.TurnComplete({ turn: second }),
         ]),
-    })
+      ),
+    )
 
     const program = turn({ history: [], model: "mock" })
     const result = await Effect.runPromise(program.pipe(Effect.provide(weird)))
@@ -77,94 +87,3 @@ describe("LanguageModel.turn", () => {
     expect(result).toEqual(second)
   })
 })
-
-describe("LanguageModel.retry", () => {
-  const textDelta = (text: string): TurnEvent => TurnEvent.TextDelta({ text })
-  const textTurn = (text: string): Turn => ({
-    items: [Items.assistantText(text)],
-    usage: { input_tokens: 0, output_tokens: 0 },
-    stop_reason: "stop",
-  })
-  const completeEvent = (text: string): TurnEvent =>
-    TurnEvent.TurnComplete({ turn: textTurn(text) })
-
-  // Builds a stream that emits a failure or success based on attempt counter.
-  // Each call to the returned Effect produces a fresh attempt stream.
-  const attemptStream = (
-    attempts: Ref.Ref<number>,
-    plan: ReadonlyArray<Stream.Stream<TurnEvent, AiError.AiError>>,
-  ): Stream.Stream<TurnEvent, AiError.AiError> =>
-    Stream.unwrap(
-      Ref.getAndUpdate(attempts, (n) => n + 1).pipe(
-        Effect.map((n) => plan[Math.min(n, plan.length - 1)]!),
-      ),
-    )
-
-  it("retries on RateLimited and yields the success on the next attempt", async () => {
-    const program = Effect.gen(function* () {
-      const attempts = yield* Ref.make(0)
-      const stream = attemptStream(attempts, [
-        Stream.fail(new AiError.RateLimited({ provider: "mock", raw: null })),
-        Stream.fromIterable([textDelta("ok"), completeEvent("ok")]),
-      ]).pipe(retry(Schedule.recurs(3)))
-      const events = yield* Stream.runCollect(stream)
-      const count = yield* Ref.get(attempts)
-      return { events: Array.from(events), count }
-    })
-
-    const { events, count } = await Effect.runPromise(program)
-    expect(count).toBe(2)
-    expect(events.map((e) => e._tag)).toEqual(["TextDelta", "TurnComplete"])
-  })
-
-  it("surfaces the underlying retryable failure when retries are exhausted", async () => {
-    const cause = new AiError.Unavailable({ provider: "mock", raw: null })
-    const stream = Stream.fail<AiError.AiError>(cause).pipe(retry(Schedule.recurs(2)))
-
-    const exit = await Effect.runPromise(Effect.exit(Stream.runCollect(stream)))
-    expect(Exit.isFailure(exit)).toBe(true)
-    if (Exit.isFailure(exit)) {
-      expect(Cause.findErrorOption(exit.cause)).toEqual(Option.some(cause))
-    }
-  })
-
-  it("bypasses retry for non-retryable AiError (ContentFiltered)", async () => {
-    const program = Effect.gen(function* () {
-      const attempts = yield* Ref.make(0)
-      const cause = new AiError.ContentFiltered({ provider: "mock", raw: null })
-      const stream = attemptStream(attempts, [Stream.fail(cause)]).pipe(retry(Schedule.recurs(5)))
-      const exit = yield* Effect.exit(Stream.runCollect(stream))
-      const count = yield* Ref.get(attempts)
-      return { exit, count, cause }
-    })
-
-    const { exit, count, cause } = await Effect.runPromise(program)
-    expect(count).toBe(1) // no retry happened
-    expect(Exit.isFailure(exit)).toBe(true)
-    if (Exit.isFailure(exit)) {
-      expect(Cause.findErrorOption(exit.cause)).toEqual(Option.some(cause))
-    }
-  })
-
-  it("preserves deltas emitted before a retryable failure (and replays on retry)", async () => {
-    // Documents the 'replays on retry' caveat in the JSDoc — first attempt
-    // emits a delta then fails; second attempt is a clean success. Consumer
-    // sees the first delta twice (once from the failed attempt, once from
-    // the replay).
-    const program = Effect.gen(function* () {
-      const attempts = yield* Ref.make(0)
-      const stream = attemptStream(attempts, [
-        Stream.concat(
-          Stream.succeed<TurnEvent>(textDelta("partial")),
-          Stream.fail(new AiError.Timeout({ provider: "mock", raw: null })),
-        ),
-        Stream.fromIterable([textDelta("partial"), completeEvent("done")]),
-      ]).pipe(retry(Schedule.recurs(1)))
-      const events = yield* Stream.runCollect(stream)
-      return Array.from(events)
-    })
-
-    const events = await Effect.runPromise(program)
-    expect(events.map((e) => e._tag)).toEqual(["TextDelta", "TextDelta", "TurnComplete"])
-  })
-})