@effect-uai/core 0.2.0 → 0.4.0

package/dist/testing/MockSpeechSynthesizer.mjs

@@ -0,0 +1,95 @@
+import { InvalidRequest } from "../domain/AiError.mjs";
+import { SpeechSynthesizer, TtsIncrementalText } from "../speech-synthesizer/SpeechSynthesizer.mjs";
+import { Effect, Layer, Ref, Stream } from "effect";
+//#region src/testing/MockSpeechSynthesizer.ts
+const makeService = (script, record) => Effect.gen(function* () {
+	const bCursor = yield* Ref.make(0);
+	const ssCursor = yield* Ref.make(0);
+	const ssfCursor = yield* Ref.make(0);
+	return {
+		synthesize: (request) => Effect.gen(function* () {
+			yield* record.synthesize(request);
+			const i = yield* Ref.getAndUpdate(bCursor, (n) => n + 1);
+			const scripted = script.blobs ?? [];
+			if (i >= scripted.length) return yield* Effect.fail(new InvalidRequest({
+				provider: "mock",
+				raw: `MockSpeechSynthesizer exhausted: ${scripted.length} blobs scripted, but call ${i + 1} was made`
+			}));
+			return scripted[i];
+		}),
+		streamSynthesis: (request) => Stream.unwrap(Effect.gen(function* () {
+			yield* record.streamSynthesis(request);
+			const i = yield* Ref.getAndUpdate(ssCursor, (n) => n + 1);
+			const scripted = script.streamSynthesisChunks ?? [];
+			if (i >= scripted.length) return Stream.fail(new InvalidRequest({
+				provider: "mock",
+				raw: `MockSpeechSynthesizer exhausted: ${scripted.length} streamSynthesis lists scripted, but call ${i + 1} was made`
+			}));
+			return Stream.fromIterable(scripted[i]);
+		})),
+		streamSynthesisFrom: (textIn, request) => Stream.unwrap(Effect.gen(function* () {
+			yield* record.streamSynthesisFrom(request);
+			const i = yield* Ref.getAndUpdate(ssfCursor, (n) => n + 1);
+			const scripted = script.streamSynthesisFromChunks ?? [];
+			if (i >= scripted.length) return Stream.fail(new InvalidRequest({
+				provider: "mock",
+				raw: `MockSpeechSynthesizer exhausted: ${scripted.length} streamSynthesisFrom lists scripted, but call ${i + 1} was made`
+			}));
+			return Stream.drain(textIn).pipe(Stream.concat(Stream.fromIterable(scripted[i])));
+		}))
+	};
+});
+/**
+* Layer providing the `SpeechSynthesizer` service AND the
+* `TtsIncrementalText` capability marker. Use for the common case
+* where code under test exercises `streamSynthesisFrom`.
+*/
+const layer = (script) => {
+	const bCalls = Ref.makeUnsafe([]);
+	const ssCalls = Ref.makeUnsafe([]);
+	const ssfCalls = Ref.makeUnsafe([]);
+	const synthesizerLayer = Layer.effect(SpeechSynthesizer, makeService(script, {
+		synthesize: (req) => Ref.update(bCalls, (xs) => [...xs, req]),
+		streamSynthesis: (req) => Ref.update(ssCalls, (xs) => [...xs, req]),
+		streamSynthesisFrom: (req) => Ref.update(ssfCalls, (xs) => [...xs, req])
+	}));
+	return {
+		layer: Layer.merge(synthesizerLayer, Layer.succeed(TtsIncrementalText, void 0)),
+		recorder: Effect.gen(function* () {
+			return {
+				synthesizeCalls: yield* Ref.get(bCalls),
+				streamSynthesisCalls: yield* Ref.get(ssCalls),
+				streamSynthesisFromCalls: yield* Ref.get(ssfCalls)
+			};
+		})
+	};
+};
+/**
+* Variant that omits the `TtsIncrementalText` marker — simulates a
+* provider without incremental-text-in support (e.g. OpenAI, AWS
+* Polly non-Generative). Calls to `streamSynthesisFrom` in code under
+* test should be a compile-time error.
+*/
+const layerWithoutIncremental = (script) => {
+	const bCalls = Ref.makeUnsafe([]);
+	const ssCalls = Ref.makeUnsafe([]);
+	const ssfCalls = Ref.makeUnsafe([]);
+	return {
+		layer: Layer.effect(SpeechSynthesizer, makeService(script, {
+			synthesize: (req) => Ref.update(bCalls, (xs) => [...xs, req]),
+			streamSynthesis: (req) => Ref.update(ssCalls, (xs) => [...xs, req]),
+			streamSynthesisFrom: (req) => Ref.update(ssfCalls, (xs) => [...xs, req])
+		})),
+		recorder: Effect.gen(function* () {
+			return {
+				synthesizeCalls: yield* Ref.get(bCalls),
+				streamSynthesisCalls: yield* Ref.get(ssCalls),
+				streamSynthesisFromCalls: yield* Ref.get(ssfCalls)
+			};
+		})
+	};
+};
+//#endregion
+export { layer, layerWithoutIncremental };
+
+//# sourceMappingURL=MockSpeechSynthesizer.mjs.map

package/dist/testing/MockSpeechSynthesizer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockSpeechSynthesizer.mjs","names":["AiError.InvalidRequest"],"sources":["../../src/testing/MockSpeechSynthesizer.ts"],"sourcesContent":["import { Effect, Layer, Ref, Stream } from \"effect\"\nimport type { AudioBlob, AudioChunk } from \"../domain/Audio.js\"\nimport * as AiError from \"../domain/AiError.js\"\nimport {\n  SpeechSynthesizer,\n  TtsIncrementalText,\n  type CommonStreamSynthesizeRequest,\n  type CommonSynthesizeRequest,\n  type SpeechSynthesizerService,\n} from \"../speech-synthesizer/SpeechSynthesizer.js\"\n\nexport type MockSynthesizerRecorder = {\n  readonly synthesizeCalls: ReadonlyArray<CommonSynthesizeRequest>\n  readonly streamSynthesisCalls: ReadonlyArray<CommonSynthesizeRequest>\n  readonly streamSynthesisFromCalls: ReadonlyArray<CommonStreamSynthesizeRequest>\n}\n\nexport type MockSynthesizerScript = {\n  /** One blob per `synthesize` call, consumed in order. */\n  readonly blobs?: ReadonlyArray<AudioBlob>\n  /** One chunk-list per `streamSynthesis` call, consumed in order. */\n  readonly streamSynthesisChunks?: ReadonlyArray<ReadonlyArray<AudioChunk>>\n  /** One chunk-list per `streamSynthesisFrom` call, consumed in order. */\n  readonly streamSynthesisFromChunks?: ReadonlyArray<ReadonlyArray<AudioChunk>>\n}\n\nconst makeService = (\n  script: MockSynthesizerScript,\n  record: {\n    readonly synthesize: (req: CommonSynthesizeRequest) => Effect.Effect<void>\n    readonly streamSynthesis: (req: CommonSynthesizeRequest) => Effect.Effect<void>\n    readonly streamSynthesisFrom: (req: CommonStreamSynthesizeRequest) => Effect.Effect<void>\n  },\n) =>\n  Effect.gen(function* () {\n    const bCursor = yield* Ref.make(0)\n    const ssCursor = yield* Ref.make(0)\n    const ssfCursor = yield* Ref.make(0)\n    const service: SpeechSynthesizerService = {\n      synthesize: (request) =>\n        Effect.gen(function* () {\n          yield* record.synthesize(request)\n          const i = yield* Ref.getAndUpdate(bCursor, (n) => n + 1)\n          const scripted = script.blobs ?? []\n          if (i >= scripted.length) {\n            return yield* Effect.fail(\n              new AiError.InvalidRequest({\n                provider: \"mock\",\n                raw: `MockSpeechSynthesizer exhausted: ${scripted.length} blobs scripted, but call ${i + 1} was made`,\n              }),\n            )\n          }\n          return scripted[i]!\n        }),\n      streamSynthesis: (request) =>\n        Stream.unwrap(\n          Effect.gen(function* () {\n            yield* record.streamSynthesis(request)\n            const i = yield* Ref.getAndUpdate(ssCursor, (n) => n + 1)\n            const scripted = script.streamSynthesisChunks ?? []\n            if (i >= scripted.length) {\n              return Stream.fail(\n                new AiError.InvalidRequest({\n                  provider: \"mock\",\n                  raw: `MockSpeechSynthesizer exhausted: ${scripted.length} streamSynthesis lists scripted, but call ${i + 1} was made`,\n                }),\n              )\n            }\n            return Stream.fromIterable(scripted[i]!)\n          }),\n        ),\n      streamSynthesisFrom: <E, R>(\n        textIn: Stream.Stream<string, E, R>,\n        request: CommonStreamSynthesizeRequest,\n      ): Stream.Stream<AudioChunk, AiError.AiError | E, R> =>\n        Stream.unwrap(\n          Effect.gen(function* () {\n            yield* record.streamSynthesisFrom(request)\n            const i = yield* Ref.getAndUpdate(ssfCursor, (n) => n + 1)\n            const scripted = script.streamSynthesisFromChunks ?? []\n            if (i >= scripted.length) {\n              const exhausted: Stream.Stream<AudioChunk, AiError.AiError | E, R> = Stream.fail(\n                new AiError.InvalidRequest({\n                  provider: \"mock\",\n                  raw: `MockSpeechSynthesizer exhausted: ${scripted.length} streamSynthesisFrom lists scripted, but call ${i + 1} was made`,\n                }),\n              )\n              return exhausted\n            }\n            // Drain the input text fully before emitting scripted audio chunks,\n            // so consumers can assert on what text was pushed.\n            return Stream.drain(textIn).pipe(Stream.concat(Stream.fromIterable(scripted[i]!)))\n          }),\n        ),\n    }\n    return service\n  })\n\n/**\n * Layer providing the `SpeechSynthesizer` service AND the\n * `TtsIncrementalText` capability marker. Use for the common case\n * where code under test exercises `streamSynthesisFrom`.\n */\nexport const layer = (\n  script: MockSynthesizerScript,\n): {\n  readonly layer: Layer.Layer<SpeechSynthesizer | TtsIncrementalText>\n  readonly recorder: Effect.Effect<MockSynthesizerRecorder>\n} => {\n  const bCalls = Ref.makeUnsafe<ReadonlyArray<CommonSynthesizeRequest>>([])\n  const ssCalls = Ref.makeUnsafe<ReadonlyArray<CommonSynthesizeRequest>>([])\n  const ssfCalls = Ref.makeUnsafe<ReadonlyArray<CommonStreamSynthesizeRequest>>([])\n  const synthesizerLayer = Layer.effect(\n    SpeechSynthesizer,\n    makeService(script, {\n      synthesize: (req) => Ref.update(bCalls, (xs) => [...xs, req]),\n      streamSynthesis: (req) => Ref.update(ssCalls, (xs) => [...xs, req]),\n      streamSynthesisFrom: (req) => Ref.update(ssfCalls, (xs) => [...xs, req]),\n    }),\n  )\n  const live = Layer.merge(synthesizerLayer, Layer.succeed(TtsIncrementalText, undefined))\n  return {\n    layer: live,\n    recorder: Effect.gen(function* () {\n      const synthesizeCalls = yield* Ref.get(bCalls)\n      const streamSynthesisCalls = yield* Ref.get(ssCalls)\n      const streamSynthesisFromCalls = yield* Ref.get(ssfCalls)\n      return { synthesizeCalls, streamSynthesisCalls, streamSynthesisFromCalls }\n    }),\n  }\n}\n\n/**\n * Variant that omits the `TtsIncrementalText` marker — simulates a\n * provider without incremental-text-in support (e.g. OpenAI, AWS\n * Polly non-Generative). Calls to `streamSynthesisFrom` in code under\n * test should be a compile-time error.\n */\nexport const layerWithoutIncremental = (\n  script: MockSynthesizerScript,\n): {\n  readonly layer: Layer.Layer<SpeechSynthesizer>\n  readonly recorder: Effect.Effect<MockSynthesizerRecorder>\n} => {\n  const bCalls = Ref.makeUnsafe<ReadonlyArray<CommonSynthesizeRequest>>([])\n  const ssCalls = Ref.makeUnsafe<ReadonlyArray<CommonSynthesizeRequest>>([])\n  const ssfCalls = Ref.makeUnsafe<ReadonlyArray<CommonStreamSynthesizeRequest>>([])\n  const live = Layer.effect(\n    SpeechSynthesizer,\n    makeService(script, {\n      synthesize: (req) => Ref.update(bCalls, (xs) => [...xs, req]),\n      streamSynthesis: (req) => Ref.update(ssCalls, (xs) => [...xs, req]),\n      streamSynthesisFrom: (req) => Ref.update(ssfCalls, (xs) => [...xs, req]),\n    }),\n  )\n  return {\n    layer: live,\n    recorder: Effect.gen(function* () {\n      const synthesizeCalls = yield* Ref.get(bCalls)\n      const streamSynthesisCalls = yield* Ref.get(ssCalls)\n      const streamSynthesisFromCalls = yield* Ref.get(ssfCalls)\n      return { synthesizeCalls, streamSynthesisCalls, streamSynthesisFromCalls }\n    }),\n  }\n}\n"],"mappings":"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"}

package/dist/testing/MockTranscriber.d.mts

@@ -0,0 +1,37 @@
+import { TranscriptEvent, TranscriptResult } from "../domain/Transcript.mjs";
+import { CommonStreamTranscribeRequest, CommonTranscribeRequest, SttStreaming, Transcriber } from "../transcriber/Transcriber.mjs";
+import { Effect, Layer } from "effect";
+
+//#region src/testing/MockTranscriber.d.ts
+/**
+ * Recorder of every call made to the mock.
+ */
+type MockTranscriberRecorder = {
+  readonly transcribeCalls: ReadonlyArray<CommonTranscribeRequest>;
+  readonly streamCalls: ReadonlyArray<CommonStreamTranscribeRequest>;
+};
+type MockTranscriberScript = {
+  /** One result per `transcribe` call, consumed in order. */readonly transcripts?: ReadonlyArray<TranscriptResult>; /** One event-list per `streamTranscriptionFrom` call, consumed in order. */
+  readonly streams?: ReadonlyArray<ReadonlyArray<TranscriptEvent>>;
+};
+/**
+ * Returns a Layer that provides both the `Transcriber` service and the
+ * `SttStreaming` capability marker. Use when the code under test calls
+ * `streamTranscriptionFrom`.
+ */
+declare const layer: (script: MockTranscriberScript) => {
+  readonly layer: Layer.Layer<Transcriber | SttStreaming>;
+  readonly recorder: Effect.Effect<MockTranscriberRecorder>;
+};
+/**
+ * Variant that omits the `SttStreaming` marker — use to test that
+ * consumers calling `streamTranscriptionFrom` fail to compile against
+ * a non-streaming provider.
+ */
+declare const layerSyncOnly: (script: MockTranscriberScript) => {
+  readonly layer: Layer.Layer<Transcriber>;
+  readonly recorder: Effect.Effect<MockTranscriberRecorder>;
+};
+//#endregion
+export { MockTranscriberRecorder, MockTranscriberScript, layer, layerSyncOnly };
+//# sourceMappingURL=MockTranscriber.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MockTranscriber.d.mts","names":[],"sources":["../../src/testing/MockTranscriber.ts"],"mappings":";;;;;;;AAcA;KAAY,uBAAA;EAAA,SACD,eAAA,EAAiB,aAAA,CAAc,uBAAA;EAAA,SAC/B,WAAA,EAAa,aAAA,CAAc,6BAAA;AAAA;AAAA,KAG1B,qBAAA;EAHY,oEAKb,WAAA,GAAc,aAAA,CAAc,gBAAA,GALF;EAAA,SAO1B,OAAA,GAAU,aAAA,CAAc,aAAA,CAAc,eAAA;AAAA;;;;;;cA6DpC,KAAA,GACX,MAAA,EAAQ,qBAAA;EAAA,SAEC,KAAA,EAAO,KAAA,CAAM,KAAA,CAAM,WAAA,GAAc,YAAA;EAAA,SACjC,QAAA,EAAU,MAAA,CAAO,MAAA,CAAO,uBAAA;AAAA;;;;;;cA2BtB,aAAA,GACX,MAAA,EAAQ,qBAAA;EAAA,SAEC,KAAA,EAAO,KAAA,CAAM,KAAA,CAAM,WAAA;EAAA,SACnB,QAAA,EAAU,MAAA,CAAO,MAAA,CAAO,uBAAA;AAAA"}

package/dist/testing/MockTranscriber.mjs

@@ -0,0 +1,77 @@
+import { InvalidRequest } from "../domain/AiError.mjs";
+import { SttStreaming, Transcriber } from "../transcriber/Transcriber.mjs";
+import { Effect, Layer, Ref, Stream } from "effect";
+//#region src/testing/MockTranscriber.ts
+const makeService = (script, record) => Effect.gen(function* () {
+	const tCursor = yield* Ref.make(0);
+	const sCursor = yield* Ref.make(0);
+	return {
+		transcribe: (request) => Effect.gen(function* () {
+			yield* record.transcribe(request);
+			const i = yield* Ref.getAndUpdate(tCursor, (n) => n + 1);
+			const scripted = script.transcripts ?? [];
+			if (i >= scripted.length) return yield* Effect.fail(new InvalidRequest({
+				provider: "mock",
+				raw: `MockTranscriber exhausted: ${scripted.length} transcripts scripted, but call ${i + 1} was made`
+			}));
+			return scripted[i];
+		}),
+		streamTranscriptionFrom: (audioIn, request) => Stream.unwrap(Effect.gen(function* () {
+			yield* record.stream(request);
+			const i = yield* Ref.getAndUpdate(sCursor, (n) => n + 1);
+			const scripted = script.streams ?? [];
+			if (i >= scripted.length) return Stream.fail(new InvalidRequest({
+				provider: "mock",
+				raw: `MockTranscriber exhausted: ${scripted.length} streams scripted, but call ${i + 1} was made`
+			}));
+			return Stream.drain(audioIn).pipe(Stream.concat(Stream.fromIterable(scripted[i])));
+		}))
+	};
+});
+/**
+* Returns a Layer that provides both the `Transcriber` service and the
+* `SttStreaming` capability marker. Use when the code under test calls
+* `streamTranscriptionFrom`.
+*/
+const layer = (script) => {
+	const tCalls = Ref.makeUnsafe([]);
+	const sCalls = Ref.makeUnsafe([]);
+	const transcriberLayer = Layer.effect(Transcriber, makeService(script, {
+		transcribe: (req) => Ref.update(tCalls, (xs) => [...xs, req]),
+		stream: (req) => Ref.update(sCalls, (xs) => [...xs, req])
+	}));
+	return {
+		layer: Layer.merge(transcriberLayer, Layer.succeed(SttStreaming, void 0)),
+		recorder: Effect.gen(function* () {
+			return {
+				transcribeCalls: yield* Ref.get(tCalls),
+				streamCalls: yield* Ref.get(sCalls)
+			};
+		})
+	};
+};
+/**
+* Variant that omits the `SttStreaming` marker — use to test that
+* consumers calling `streamTranscriptionFrom` fail to compile against
+* a non-streaming provider.
+*/
+const layerSyncOnly = (script) => {
+	const tCalls = Ref.makeUnsafe([]);
+	const sCalls = Ref.makeUnsafe([]);
+	return {
+		layer: Layer.effect(Transcriber, makeService(script, {
+			transcribe: (req) => Ref.update(tCalls, (xs) => [...xs, req]),
+			stream: (req) => Ref.update(sCalls, (xs) => [...xs, req])
+		})),
+		recorder: Effect.gen(function* () {
+			return {
+				transcribeCalls: yield* Ref.get(tCalls),
+				streamCalls: yield* Ref.get(sCalls)
+			};
+		})
+	};
+};
+//#endregion
+export { layer, layerSyncOnly };
+
+//# sourceMappingURL=MockTranscriber.mjs.map

package/dist/testing/MockTranscriber.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockTranscriber.mjs","names":["AiError.InvalidRequest"],"sources":["../../src/testing/MockTranscriber.ts"],"sourcesContent":["import { Effect, Layer, Ref, Stream } from \"effect\"\nimport * as AiError from \"../domain/AiError.js\"\nimport type { TranscriptEvent, TranscriptResult } from \"../domain/Transcript.js\"\nimport {\n  SttStreaming,\n  Transcriber,\n  type CommonStreamTranscribeRequest,\n  type CommonTranscribeRequest,\n  type TranscriberService,\n} from \"../transcriber/Transcriber.js\"\n\n/**\n * Recorder of every call made to the mock.\n */\nexport type MockTranscriberRecorder = {\n  readonly transcribeCalls: ReadonlyArray<CommonTranscribeRequest>\n  readonly streamCalls: ReadonlyArray<CommonStreamTranscribeRequest>\n}\n\nexport type MockTranscriberScript = {\n  /** One result per `transcribe` call, consumed in order. */\n  readonly transcripts?: ReadonlyArray<TranscriptResult>\n  /** One event-list per `streamTranscriptionFrom` call, consumed in order. */\n  readonly streams?: ReadonlyArray<ReadonlyArray<TranscriptEvent>>\n}\n\nconst makeService = (\n  script: MockTranscriberScript,\n  record: {\n    readonly transcribe: (req: CommonTranscribeRequest) => Effect.Effect<void>\n    readonly stream: (req: CommonStreamTranscribeRequest) => Effect.Effect<void>\n  },\n) =>\n  Effect.gen(function* () {\n    const tCursor = yield* Ref.make(0)\n    const sCursor = yield* Ref.make(0)\n    const service: TranscriberService = {\n      transcribe: (request) =>\n        Effect.gen(function* () {\n          yield* record.transcribe(request)\n          const i = yield* Ref.getAndUpdate(tCursor, (n) => n + 1)\n          const scripted = script.transcripts ?? []\n          if (i >= scripted.length) {\n            return yield* Effect.fail(\n              new AiError.InvalidRequest({\n                provider: \"mock\",\n                raw: `MockTranscriber exhausted: ${scripted.length} transcripts scripted, but call ${i + 1} was made`,\n              }),\n            )\n          }\n          return scripted[i]!\n        }),\n      streamTranscriptionFrom: <E, R>(\n        audioIn: Stream.Stream<Uint8Array, E, R>,\n        request: CommonStreamTranscribeRequest,\n      ): Stream.Stream<TranscriptEvent, AiError.AiError | E, R> =>\n        Stream.unwrap(\n          Effect.gen(function* () {\n            yield* record.stream(request)\n            const i = yield* Ref.getAndUpdate(sCursor, (n) => n + 1)\n            const scripted = script.streams ?? []\n            if (i >= scripted.length) {\n              const exhausted: Stream.Stream<TranscriptEvent, AiError.AiError | E, R> = Stream.fail(\n                new AiError.InvalidRequest({\n                  provider: \"mock\",\n                  raw: `MockTranscriber exhausted: ${scripted.length} streams scripted, but call ${i + 1} was made`,\n                }),\n              )\n              return exhausted\n            }\n            // Drain the input audio fully before emitting the scripted events,\n            // so consumers can assert on what bytes were pushed.\n            return Stream.drain(audioIn).pipe(Stream.concat(Stream.fromIterable(scripted[i]!)))\n          }),\n        ),\n    }\n    return service\n  })\n\n/**\n * Returns a Layer that provides both the `Transcriber` service and the\n * `SttStreaming` capability marker. Use when the code under test calls\n * `streamTranscriptionFrom`.\n */\nexport const layer = (\n  script: MockTranscriberScript,\n): {\n  readonly layer: Layer.Layer<Transcriber | SttStreaming>\n  readonly recorder: Effect.Effect<MockTranscriberRecorder>\n} => {\n  const tCalls = Ref.makeUnsafe<ReadonlyArray<CommonTranscribeRequest>>([])\n  const sCalls = Ref.makeUnsafe<ReadonlyArray<CommonStreamTranscribeRequest>>([])\n  const transcriberLayer = Layer.effect(\n    Transcriber,\n    makeService(script, {\n      transcribe: (req) => Ref.update(tCalls, (xs) => [...xs, req]),\n      stream: (req) => Ref.update(sCalls, (xs) => [...xs, req]),\n    }),\n  )\n  const live = Layer.merge(transcriberLayer, Layer.succeed(SttStreaming, undefined))\n  return {\n    layer: live,\n    recorder: Effect.gen(function* () {\n      const transcribeCalls = yield* Ref.get(tCalls)\n      const streamCalls = yield* Ref.get(sCalls)\n      return { transcribeCalls, streamCalls }\n    }),\n  }\n}\n\n/**\n * Variant that omits the `SttStreaming` marker — use to test that\n * consumers calling `streamTranscriptionFrom` fail to compile against\n * a non-streaming provider.\n */\nexport const layerSyncOnly = (\n  script: MockTranscriberScript,\n): {\n  readonly layer: Layer.Layer<Transcriber>\n  readonly recorder: Effect.Effect<MockTranscriberRecorder>\n} => {\n  const tCalls = Ref.makeUnsafe<ReadonlyArray<CommonTranscribeRequest>>([])\n  const sCalls = Ref.makeUnsafe<ReadonlyArray<CommonStreamTranscribeRequest>>([])\n  const live = Layer.effect(\n    Transcriber,\n    makeService(script, {\n      transcribe: (req) => Ref.update(tCalls, (xs) => [...xs, req]),\n      stream: (req) => Ref.update(sCalls, (xs) => [...xs, req]),\n    }),\n  )\n  return {\n    layer: live,\n    recorder: Effect.gen(function* () {\n      const transcribeCalls = yield* Ref.get(tCalls)\n      const streamCalls = yield* Ref.get(sCalls)\n      return { transcribeCalls, streamCalls }\n    }),\n  }\n}\n"],"mappings":";;;;AA0BA,MAAM,eACJ,QACA,WAKA,OAAO,IAAI,aAAa;CACtB,MAAM,UAAU,OAAO,IAAI,KAAK,EAAE;CAClC,MAAM,UAAU,OAAO,IAAI,KAAK,EAAE;AAyClC,QAAO;EAvCL,aAAa,YACX,OAAO,IAAI,aAAa;AACtB,UAAO,OAAO,WAAW,QAAQ;GACjC,MAAM,IAAI,OAAO,IAAI,aAAa,UAAU,MAAM,IAAI,EAAE;GACxD,MAAM,WAAW,OAAO,eAAe,EAAE;AACzC,OAAI,KAAK,SAAS,OAChB,QAAO,OAAO,OAAO,KACnB,IAAIA,eAAuB;IACzB,UAAU;IACV,KAAK,8BAA8B,SAAS,OAAO,kCAAkC,IAAI,EAAE;IAC5F,CAAC,CACH;AAEH,UAAO,SAAS;IAChB;EACJ,0BACE,SACA,YAEA,OAAO,OACL,OAAO,IAAI,aAAa;AACtB,UAAO,OAAO,OAAO,QAAQ;GAC7B,MAAM,IAAI,OAAO,IAAI,aAAa,UAAU,MAAM,IAAI,EAAE;GACxD,MAAM,WAAW,OAAO,WAAW,EAAE;AACrC,OAAI,KAAK,SAAS,OAOhB,QAN0E,OAAO,KAC/E,IAAIA,eAAuB;IACzB,UAAU;IACV,KAAK,8BAA8B,SAAS,OAAO,8BAA8B,IAAI,EAAE;IACxF,CAAC,CAEY;AAIlB,UAAO,OAAO,MAAM,QAAQ,CAAC,KAAK,OAAO,OAAO,OAAO,aAAa,SAAS,GAAI,CAAC,CAAC;IACnF,CACH;EAES;EACd;;;;;;AAOJ,MAAa,SACX,WAIG;CACH,MAAM,SAAS,IAAI,WAAmD,EAAE,CAAC;CACzE,MAAM,SAAS,IAAI,WAAyD,EAAE,CAAC;CAC/E,MAAM,mBAAmB,MAAM,OAC7B,aACA,YAAY,QAAQ;EAClB,aAAa,QAAQ,IAAI,OAAO,SAAS,OAAO,CAAC,GAAG,IAAI,IAAI,CAAC;EAC7D,SAAS,QAAQ,IAAI,OAAO,SAAS,OAAO,CAAC,GAAG,IAAI,IAAI,CAAC;EAC1D,CAAC,CACH;AAED,QAAO;EACL,OAFW,MAAM,MAAM,kBAAkB,MAAM,QAAQ,cAAc,KAAA,EAAU,CAEpE;EACX,UAAU,OAAO,IAAI,aAAa;AAGhC,UAAO;IAAE,iBAAA,OAFsB,IAAI,IAAI,OAAO;IAEpB,aAAA,OADC,IAAI,IAAI,OAAO;IACH;IACvC;EACH;;;;;;;AAQH,MAAa,iBACX,WAIG;CACH,MAAM,SAAS,IAAI,WAAmD,EAAE,CAAC;CACzE,MAAM,SAAS,IAAI,WAAyD,EAAE,CAAC;AAQ/E,QAAO;EACL,OARW,MAAM,OACjB,aACA,YAAY,QAAQ;GAClB,aAAa,QAAQ,IAAI,OAAO,SAAS,OAAO,CAAC,GAAG,IAAI,IAAI,CAAC;GAC7D,SAAS,QAAQ,IAAI,OAAO,SAAS,OAAO,CAAC,GAAG,IAAI,IAAI,CAAC;GAC1D,CAAC,CAGS;EACX,UAAU,OAAO,IAAI,aAAa;AAGhC,UAAO;IAAE,iBAAA,OAFsB,IAAI,IAAI,OAAO;IAEpB,aAAA,OADC,IAAI,IAAI,OAAO;IACH;IACvC;EACH"}

package/dist/tool/HistoryCheck.d.mts

@@ -1,7 +1,10 @@
-import { m as Item, o as FunctionCall } from "../Items-D1C2686t.mjs";
-import { t as ToolResult } from "../Outcome-GiaNvt7i.mjs";
+import { d as Item, o as FunctionCall } from "../Items-Hg5AsYxl.mjs";
+import { ToolResult } from "./Outcome.mjs";
 
 //#region src/tool/HistoryCheck.d.ts
+declare namespace HistoryCheck_d_exports {
+  export { cancelAllPending, findUnansweredCalls, isReconciled };
+}
 /**
  * Return every `function_call` in `history` that does not have a matching
  * `function_call_output` later in `history` (correlated by `call_id`).
@@ -20,5 +23,5 @@ declare const isReconciled: (history: ReadonlyArray<Item>) => boolean;
  */
 declare const cancelAllPending: (history: ReadonlyArray<Item>, reason?: string) => ReadonlyArray<ToolResult>;
 //#endregion
-export { cancelAllPending, findUnansweredCalls, isReconciled };
+export { cancelAllPending, findUnansweredCalls, isReconciled, HistoryCheck_d_exports as t };
 //# sourceMappingURL=HistoryCheck.d.mts.map

package/dist/tool/HistoryCheck.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"HistoryCheck.d.mts","names":[],"sources":["../../src/tool/HistoryCheck.ts"],"mappings":";;;;;;;;;cAyBa,mBAAA,GACX,OAAA,EAAS,aAAA,CAAc,IAAA,MACtB,aAAA,CAAc,YAAA;AAMjB;AAAA,cAAa,YAAA,GAAgB,OAAA,EAAS,aAAA,CAAc,IAAA;;;;;;;;AAWpD;cAAa,gBAAA,GACX,OAAA,EAAS,aAAA,CAAc,IAAA,GACvB,MAAA,cACC,aAAA,CAAc,UAAA"}
+{"version":3,"file":"HistoryCheck.d.mts","names":[],"sources":["../../src/tool/HistoryCheck.ts"],"mappings":";;;;;;;;;;;;cAyBa,mBAAA,GAAuB,OAAA,EAAS,aAAA,CAAc,IAAA,MAAQ,aAAA,CAAc,YAAA;;cAMpE,YAAA,GAAgB,OAAA,EAAS,aAAA,CAAc,IAAA;;;;;AAApD;;;;cAWa,gBAAA,GACX,OAAA,EAAS,aAAA,CAAc,IAAA,GACvB,MAAA,cACC,aAAA,CAAc,UAAA"}

package/dist/tool/HistoryCheck.mjs

@@ -1,3 +1,4 @@
+import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
 import { isFunctionCall, isFunctionCallOutput } from "../domain/Items.mjs";
 import { cancelled } from "./Outcome.mjs";
 //#region src/tool/HistoryCheck.ts
@@ -13,6 +14,11 @@ import { cancelled } from "./Outcome.mjs";
 * Recipe author calls these at known transition points (right before the
 * next provider request). Not invoked from inside the loop.
 */
+var HistoryCheck_exports = /* @__PURE__ */ __exportAll({
+	cancelAllPending: () => cancelAllPending,
+	findUnansweredCalls: () => findUnansweredCalls,
+	isReconciled: () => isReconciled
+});
 /**
 * Return every `function_call` in `history` that does not have a matching
 * `function_call_output` later in `history` (correlated by `call_id`).
@@ -34,6 +40,6 @@ const isReconciled = (history) => findUnansweredCalls(history).length === 0;
 */
 const cancelAllPending = (history, reason) => findUnansweredCalls(history).map((call) => cancelled(call, reason));
 //#endregion
-export { cancelAllPending, findUnansweredCalls, isReconciled };
+export { cancelAllPending, findUnansweredCalls, isReconciled, HistoryCheck_exports as t };
 
 //# sourceMappingURL=HistoryCheck.mjs.map

package/dist/tool/HistoryCheck.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"HistoryCheck.mjs","names":[],"sources":["../../src/tool/HistoryCheck.ts"],"sourcesContent":["/**\n * History-consistency primitives. Useful even WITHOUT HITL.\n *\n * Every provider rejects a new request if any prior `function_call` lacks\n * a matching `function_call_output`. Multi-turn flows that can be\n * interrupted, restarted, or branched (HITL, mid-stream abort, persisted\n * checkpoints, stateless HTTP servers) need to detect orphans and\n * synthesize closing outputs before submitting.\n *\n * Recipe author calls these at known transition points (right before the\n * next provider request). Not invoked from inside the loop.\n */\nimport {\n  type FunctionCall,\n  type Item,\n  isFunctionCall,\n  isFunctionCallOutput,\n} from \"../domain/Items.js\"\nimport { type ToolResult, cancelled } from \"./Outcome.js\"\n\n/**\n * Return every `function_call` in `history` that does not have a matching\n * `function_call_output` later in `history` (correlated by `call_id`).\n * Empty result = history is provider-submittable from this invariant.\n */\nexport const findUnansweredCalls = (\n  history: ReadonlyArray<Item>,\n): ReadonlyArray<FunctionCall> => {\n  const answered = new Set(history.filter(isFunctionCallOutput).map((o) => o.call_id))\n  return history.filter(isFunctionCall).filter((c) => !answered.has(c.call_id))\n}\n\n/** Cheap predicate: is this history submittable to a provider? */\nexport const isReconciled = (history: ReadonlyArray<Item>): boolean =>\n  findUnansweredCalls(history).length === 0\n\n/**\n * Synthesize cancellation results for every unanswered call. Caller maps\n * via `toFunctionCallOutput` and appends to history before submitting.\n *\n * Use when: a new user message arrives mid-approval; an approval timer\n * fires; a persisted checkpoint contains orphans (crash recovery); a\n * stateless HTTP server reconstructed history from a stale checkpoint.\n */\nexport const cancelAllPending = (\n  history: ReadonlyArray<Item>,\n  reason?: string,\n): ReadonlyArray<ToolResult> =>\n  findUnansweredCalls(history).map((call) => cancelled(call, reason))\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAyBA,MAAa,uBACX,YACgC;CAChC,MAAM,WAAW,IAAI,IAAI,QAAQ,OAAO,qBAAqB,CAAC,KAAK,MAAM,EAAE,QAAQ,CAAC;AACpF,QAAO,QAAQ,OAAO,eAAe,CAAC,QAAQ,MAAM,CAAC,SAAS,IAAI,EAAE,QAAQ,CAAC;;;AAI/E,MAAa,gBAAgB,YAC3B,oBAAoB,QAAQ,CAAC,WAAW;;;;;;;;;AAU1C,MAAa,oBACX,SACA,WAEA,oBAAoB,QAAQ,CAAC,KAAK,SAAS,UAAU,MAAM,OAAO,CAAC"}
+{"version":3,"file":"HistoryCheck.mjs","names":[],"sources":["../../src/tool/HistoryCheck.ts"],"sourcesContent":["/**\n * History-consistency primitives. Useful even WITHOUT HITL.\n *\n * Every provider rejects a new request if any prior `function_call` lacks\n * a matching `function_call_output`. Multi-turn flows that can be\n * interrupted, restarted, or branched (HITL, mid-stream abort, persisted\n * checkpoints, stateless HTTP servers) need to detect orphans and\n * synthesize closing outputs before submitting.\n *\n * Recipe author calls these at known transition points (right before the\n * next provider request). Not invoked from inside the loop.\n */\nimport {\n  type FunctionCall,\n  type Item,\n  isFunctionCall,\n  isFunctionCallOutput,\n} from \"../domain/Items.js\"\nimport { type ToolResult, cancelled } from \"./Outcome.js\"\n\n/**\n * Return every `function_call` in `history` that does not have a matching\n * `function_call_output` later in `history` (correlated by `call_id`).\n * Empty result = history is provider-submittable from this invariant.\n */\nexport const findUnansweredCalls = (history: ReadonlyArray<Item>): ReadonlyArray<FunctionCall> => {\n  const answered = new Set(history.filter(isFunctionCallOutput).map((o) => o.call_id))\n  return history.filter(isFunctionCall).filter((c) => !answered.has(c.call_id))\n}\n\n/** Cheap predicate: is this history submittable to a provider? */\nexport const isReconciled = (history: ReadonlyArray<Item>): boolean =>\n  findUnansweredCalls(history).length === 0\n\n/**\n * Synthesize cancellation results for every unanswered call. Caller maps\n * via `toFunctionCallOutput` and appends to history before submitting.\n *\n * Use when: a new user message arrives mid-approval; an approval timer\n * fires; a persisted checkpoint contains orphans (crash recovery); a\n * stateless HTTP server reconstructed history from a stale checkpoint.\n */\nexport const cancelAllPending = (\n  history: ReadonlyArray<Item>,\n  reason?: string,\n): ReadonlyArray<ToolResult> => findUnansweredCalls(history).map((call) => cancelled(call, reason))\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,MAAa,uBAAuB,YAA8D;CAChG,MAAM,WAAW,IAAI,IAAI,QAAQ,OAAO,qBAAqB,CAAC,KAAK,MAAM,EAAE,QAAQ,CAAC;AACpF,QAAO,QAAQ,OAAO,eAAe,CAAC,QAAQ,MAAM,CAAC,SAAS,IAAI,EAAE,QAAQ,CAAC;;;AAI/E,MAAa,gBAAgB,YAC3B,oBAAoB,QAAQ,CAAC,WAAW;;;;;;;;;AAU1C,MAAa,oBACX,SACA,WAC8B,oBAAoB,QAAQ,CAAC,KAAK,SAAS,UAAU,MAAM,OAAO,CAAC"}

package/dist/tool/Outcome.d.mts

@@ -1,2 +1,138 @@
-import { a as isFailure, c as toFunctionCallOutput, i as executionError, n as cancelled, o as isValue, r as denied, s as rejected, t as ToolResult } from "../Outcome-GiaNvt7i.mjs";
-export { ToolResult, cancelled, denied, executionError, isFailure, isValue, rejected, toFunctionCallOutput };
+import { o as FunctionCall, s as FunctionCallOutput } from "../Items-Hg5AsYxl.mjs";
+import { Data } from "effect";
+import * as _$effect_Unify0 from "effect/Unify";
+
+//#region src/tool/Outcome.d.ts
+declare namespace Outcome_d_exports {
+  export { ToolResult, cancelled, denied, executionError, isFailure, isValue, rejected, toFunctionCallOutput };
+}
+type ToolResult = Data.TaggedEnum<{
+  Value: {
+    readonly call_id: string;
+    readonly tool: string;
+    readonly value: unknown;
+  };
+  Failure: {
+    readonly call_id: string;
+    readonly tool: string;
+    readonly kind: string;
+    readonly reason?: string;
+  };
+}>;
+/**
+ * Namespace of constructors, type guards, and matchers for `ToolResult`,
+ * provided by `Data.taggedEnum`. Use `ToolResult.$is("Value")` for type
+ * narrowing and `ToolResult.$match({ Value, Failure })` for exhaustive
+ * pattern matching. Synthetic-result helpers (`denied`, `cancelled`,
+ * `executionError`, `rejected`) below are kinder constructors than the
+ * raw `ToolResult.Failure(...)`.
+ */
+declare const ToolResult: {
+  readonly Value: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Value";
+    readonly call_id: string;
+    readonly tool: string;
+    readonly value: unknown;
+  }, "_tag">;
+  readonly Failure: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Failure";
+    readonly call_id: string;
+    readonly tool: string;
+    readonly kind: string;
+    readonly reason?: string;
+  }, "_tag">;
+  readonly $is: <Tag extends "Value" | "Failure">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Value";
+    readonly call_id: string;
+    readonly tool: string;
+    readonly value: unknown;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Failure";
+    readonly call_id: string;
+    readonly tool: string;
+    readonly kind: string;
+    readonly reason?: string;
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends {
+      readonly Value: (args: {
+        readonly _tag: "Value";
+        readonly call_id: string;
+        readonly tool: string;
+        readonly value: unknown;
+      }) => any;
+      readonly Failure: (args: {
+        readonly _tag: "Failure";
+        readonly call_id: string;
+        readonly tool: string;
+        readonly kind: string;
+        readonly reason?: string;
+      }) => any;
+    }>(cases: Cases): (value: {
+      readonly _tag: "Value";
+      readonly call_id: string;
+      readonly tool: string;
+      readonly value: unknown;
+    } | {
+      readonly _tag: "Failure";
+      readonly call_id: string;
+      readonly tool: string;
+      readonly kind: string;
+      readonly reason?: string;
+    }) => _$effect_Unify0.Unify<ReturnType<Cases["Value" | "Failure"]>>;
+    <Cases extends {
+      readonly Value: (args: {
+        readonly _tag: "Value";
+        readonly call_id: string;
+        readonly tool: string;
+        readonly value: unknown;
+      }) => any;
+      readonly Failure: (args: {
+        readonly _tag: "Failure";
+        readonly call_id: string;
+        readonly tool: string;
+        readonly kind: string;
+        readonly reason?: string;
+      }) => any;
+    }>(value: {
+      readonly _tag: "Value";
+      readonly call_id: string;
+      readonly tool: string;
+      readonly value: unknown;
+    } | {
+      readonly _tag: "Failure";
+      readonly call_id: string;
+      readonly tool: string;
+      readonly kind: string;
+      readonly reason?: string;
+    }, cases: Cases): _$effect_Unify0.Unify<ReturnType<Cases["Value" | "Failure"]>>;
+  };
+};
+declare const isValue: (u: unknown) => u is {
+  readonly _tag: "Value";
+  readonly call_id: string;
+  readonly tool: string;
+  readonly value: unknown;
+};
+declare const isFailure: (u: unknown) => u is {
+  readonly _tag: "Failure";
+  readonly call_id: string;
+  readonly tool: string;
+  readonly kind: string;
+  readonly reason?: string;
+};
+declare const rejected: (call: FunctionCall, kind: string, reason?: string) => ToolResult;
+/** Explicit user/policy rejection. */
+declare const denied: (call: FunctionCall, reason?: string) => ToolResult;
+/** Implicit non-answer (follow-up, inactivity, abort). */
+declare const cancelled: (call: FunctionCall, reason?: string) => ToolResult;
+/** Tool's own execution failed (parse error, schema, runtime crash). */
+declare const executionError: (call: FunctionCall, reason: string) => ToolResult;
+declare const toFunctionCallOutput: (r: ToolResult) => FunctionCallOutput;
+//#endregion
+export { ToolResult, cancelled, denied, executionError, isFailure, isValue, rejected, Outcome_d_exports as t, toFunctionCallOutput };
+//# sourceMappingURL=Outcome.d.mts.map

package/dist/tool/Outcome.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Outcome.d.mts","names":[],"sources":["../../src/tool/Outcome.ts"],"mappings":";;;;;;;;KAqBY,UAAA,GAAa,IAAA,CAAK,UAAA;EAC5B,KAAA;IAAA,SACW,OAAA;IAAA,SACA,IAAA;IAAA,SACA,KAAA;EAAA;EAEX,OAAA;IAAA,SACW,OAAA;IAAA,SACA,IAAA;IAAA,SACA,IAAA;IAAA,SACA,MAAA;EAAA;AAAA;;;;;;AAYb;;;cAAa,UAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAEA,OAAA,GAAO,CAAA,cAAA,CAAA;EAAA;;;;;cACP,SAAA,GAAS,CAAA,cAAA,CAAA;EAAA;;;;;;cAMT,QAAA,GAAY,IAAA,EAAM,YAAA,EAAc,IAAA,UAAc,MAAA,cAAkB,UAAA;;cAShE,MAAA,GAAU,IAAA,EAAM,YAAA,EAAc,MAAA,cAAkB,UAAA;;cAIhD,SAAA,GAAa,IAAA,EAAM,YAAA,EAAc,MAAA,cAAkB,UAAA;;cAInD,cAAA,GAAkB,IAAA,EAAM,YAAA,EAAc,MAAA,aAAiB,UAAA;AAAA,cAOvD,oBAAA,GAAwB,CAAA,EAAG,UAAA,KAAa,kBAAA"}

package/dist/tool/Outcome.mjs

@@ -1,5 +1,6 @@
+import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
 import { functionCallOutput } from "../domain/Items.mjs";
-import { Match } from "effect";
+import { Data } from "effect";
 //#region src/tool/Outcome.ts
 /**
 * Post-execution and synthetic tool results.
@@ -14,10 +15,28 @@ import { Match } from "effect";
 * and `unknown` would invite non-serializable values (Date, Map, BigInt,
 * fn). Recipes that want structured detail JSON.stringify themselves.
 */
-const isValue = (r) => r._tag === "Value";
-const isFailure = (r) => r._tag === "Failure";
-const rejected = (call, kind, reason) => ({
-	_tag: "Failure",
+var Outcome_exports = /* @__PURE__ */ __exportAll({
+	ToolResult: () => ToolResult,
+	cancelled: () => cancelled,
+	denied: () => denied,
+	executionError: () => executionError,
+	isFailure: () => isFailure,
+	isValue: () => isValue,
+	rejected: () => rejected,
+	toFunctionCallOutput: () => toFunctionCallOutput
+});
+/**
+* Namespace of constructors, type guards, and matchers for `ToolResult`,
+* provided by `Data.taggedEnum`. Use `ToolResult.$is("Value")` for type
+* narrowing and `ToolResult.$match({ Value, Failure })` for exhaustive
+* pattern matching. Synthetic-result helpers (`denied`, `cancelled`,
+* `executionError`, `rejected`) below are kinder constructors than the
+* raw `ToolResult.Failure(...)`.
+*/
+const ToolResult = Data.taggedEnum();
+const isValue = ToolResult.$is("Value");
+const isFailure = ToolResult.$is("Failure");
+const rejected = (call, kind, reason) => ToolResult.Failure({
 	call_id: call.call_id,
 	tool: call.name,
 	kind,
@@ -29,11 +48,14 @@ const denied = (call, reason) => rejected(call, "denied", reason);
 const cancelled = (call, reason) => rejected(call, "cancelled", reason);
 /** Tool's own execution failed (parse error, schema, runtime crash). */
 const executionError = (call, reason) => rejected(call, "execution_error", reason);
-const toFunctionCallOutput = (r) => Match.value(r).pipe(Match.tag("Value", (v) => functionCallOutput(v.call_id, JSON.stringify(v.value))), Match.tag("Failure", (f) => functionCallOutput(f.call_id, JSON.stringify(f.reason !== void 0 ? {
-	kind: f.kind,
-	reason: f.reason
-} : { kind: f.kind }))), Match.exhaustive);
+const toFunctionCallOutput = (r) => ToolResult.$match(r, {
+	Value: (v) => functionCallOutput(v.call_id, JSON.stringify(v.value)),
+	Failure: (f) => functionCallOutput(f.call_id, JSON.stringify(f.reason !== void 0 ? {
+		kind: f.kind,
+		reason: f.reason
+	} : { kind: f.kind }))
+});
 //#endregion
-export { cancelled, denied, executionError, isFailure, isValue, rejected, toFunctionCallOutput };
+export { ToolResult, cancelled, denied, executionError, isFailure, isValue, rejected, Outcome_exports as t, toFunctionCallOutput };
 
 //# sourceMappingURL=Outcome.mjs.map

package/dist/tool/Outcome.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"Outcome.mjs","names":[],"sources":["../../src/tool/Outcome.ts"],"sourcesContent":["/**\n * Post-execution and synthetic tool results.\n *\n *   - Executed tools emit ToolResult.Value.\n *   - Approval/cancellation policy emits synthetic ToolResult.Failure.\n *\n * Wire conversion stays at the recipe boundary via `toFunctionCallOutput`\n * so recipes can inspect, redact, or audit values before serialization.\n *\n * `output` and `reason` are `string`, not `unknown`: the wire wants strings,\n * and `unknown` would invite non-serializable values (Date, Map, BigInt,\n * fn). Recipes that want structured detail JSON.stringify themselves.\n */\nimport { Match } from \"effect\"\nimport type { FunctionCall, FunctionCallOutput } from \"../domain/Items.js\"\nimport { functionCallOutput } from \"../domain/Items.js\"\n\n// ---------------------------------------------------------------------------\n// ToolResult\n// ---------------------------------------------------------------------------\n\nexport type ToolResult =\n  | {\n      readonly _tag: \"Value\"\n      readonly call_id: string\n      readonly tool: string\n      readonly value: unknown\n    }\n  | {\n      readonly _tag: \"Failure\"\n      readonly call_id: string\n      readonly tool: string\n      readonly kind: string\n      readonly reason?: string\n    }\n\nexport const isValue = (r: ToolResult): r is Extract<ToolResult, { _tag: \"Value\" }> =>\n  r._tag === \"Value\"\n\nexport const isFailure = (r: ToolResult): r is Extract<ToolResult, { _tag: \"Failure\" }> =>\n  r._tag === \"Failure\"\n\n// Synthesizers. `denied` and `cancelled` are operationally distinct;\n// anything else is just a recipe-chosen `kind` via `rejected`.\n// ---------------------------------------------------------------------------\n\nexport const rejected = (\n  call: FunctionCall,\n  kind: string,\n  reason?: string,\n): ToolResult => ({\n  _tag: \"Failure\",\n  call_id: call.call_id,\n  tool: call.name,\n  kind,\n  ...(reason !== undefined ? { reason } : {}),\n})\n\n/** Explicit user/policy rejection. */\nexport const denied = (call: FunctionCall, reason?: string): ToolResult =>\n  rejected(call, \"denied\", reason)\n\n/** Implicit non-answer (follow-up, inactivity, abort). */\nexport const cancelled = (call: FunctionCall, reason?: string): ToolResult =>\n  rejected(call, \"cancelled\", reason)\n\n/** Tool's own execution failed (parse error, schema, runtime crash). */\nexport const executionError = (call: FunctionCall, reason: string): ToolResult =>\n  rejected(call, \"execution_error\", reason)\n\n// ---------------------------------------------------------------------------\n// Wire conversion - the one place structured → string happens.\n// ---------------------------------------------------------------------------\n\nexport const toFunctionCallOutput = (r: ToolResult): FunctionCallOutput =>\n  Match.value(r).pipe(\n    Match.tag(\"Value\", (v) => functionCallOutput(v.call_id, JSON.stringify(v.value))),\n    Match.tag(\"Failure\", (f) =>\n      functionCallOutput(\n        f.call_id,\n        JSON.stringify(\n          f.reason !== undefined ? { kind: f.kind, reason: f.reason } : { kind: f.kind },\n        ),\n      ),\n    ),\n    Match.exhaustive,\n  )\n"],"mappings":";;;;;;;;;;;;;;;;AAoCA,MAAa,WAAW,MACtB,EAAE,SAAS;AAEb,MAAa,aAAa,MACxB,EAAE,SAAS;AAMb,MAAa,YACX,MACA,MACA,YACgB;CAChB,MAAM;CACN,SAAS,KAAK;CACd,MAAM,KAAK;CACX;CACA,GAAI,WAAW,KAAA,IAAY,EAAE,QAAQ,GAAG,EAAE;CAC3C;;AAGD,MAAa,UAAU,MAAoB,WACzC,SAAS,MAAM,UAAU,OAAO;;AAGlC,MAAa,aAAa,MAAoB,WAC5C,SAAS,MAAM,aAAa,OAAO;;AAGrC,MAAa,kBAAkB,MAAoB,WACjD,SAAS,MAAM,mBAAmB,OAAO;AAM3C,MAAa,wBAAwB,MACnC,MAAM,MAAM,EAAE,CAAC,KACb,MAAM,IAAI,UAAU,MAAM,mBAAmB,EAAE,SAAS,KAAK,UAAU,EAAE,MAAM,CAAC,CAAC,EACjF,MAAM,IAAI,YAAY,MACpB,mBACE,EAAE,SACF,KAAK,UACH,EAAE,WAAW,KAAA,IAAY;CAAE,MAAM,EAAE;CAAM,QAAQ,EAAE;CAAQ,GAAG,EAAE,MAAM,EAAE,MAAM,CAC/E,CACF,CACF,EACD,MAAM,WACP"}
+{"version":3,"file":"Outcome.mjs","names":[],"sources":["../../src/tool/Outcome.ts"],"sourcesContent":["/**\n * Post-execution and synthetic tool results.\n *\n *   - Executed tools emit ToolResult.Value.\n *   - Approval/cancellation policy emits synthetic ToolResult.Failure.\n *\n * Wire conversion stays at the recipe boundary via `toFunctionCallOutput`\n * so recipes can inspect, redact, or audit values before serialization.\n *\n * `output` and `reason` are `string`, not `unknown`: the wire wants strings,\n * and `unknown` would invite non-serializable values (Date, Map, BigInt,\n * fn). Recipes that want structured detail JSON.stringify themselves.\n */\nimport { Data } from \"effect\"\nimport type { FunctionCall, FunctionCallOutput } from \"../domain/Items.js\"\nimport { functionCallOutput } from \"../domain/Items.js\"\n\n// ---------------------------------------------------------------------------\n// ToolResult\n// ---------------------------------------------------------------------------\n\nexport type ToolResult = Data.TaggedEnum<{\n  Value: {\n    readonly call_id: string\n    readonly tool: string\n    readonly value: unknown\n  }\n  Failure: {\n    readonly call_id: string\n    readonly tool: string\n    readonly kind: string\n    readonly reason?: string\n  }\n}>\n\n/**\n * Namespace of constructors, type guards, and matchers for `ToolResult`,\n * provided by `Data.taggedEnum`. Use `ToolResult.$is(\"Value\")` for type\n * narrowing and `ToolResult.$match({ Value, Failure })` for exhaustive\n * pattern matching. Synthetic-result helpers (`denied`, `cancelled`,\n * `executionError`, `rejected`) below are kinder constructors than the\n * raw `ToolResult.Failure(...)`.\n */\nexport const ToolResult = Data.taggedEnum<ToolResult>()\n\nexport const isValue = ToolResult.$is(\"Value\")\nexport const isFailure = ToolResult.$is(\"Failure\")\n\n// Synthesizers. `denied` and `cancelled` are operationally distinct;\n// anything else is just a recipe-chosen `kind` via `rejected`.\n// ---------------------------------------------------------------------------\n\nexport const rejected = (call: FunctionCall, kind: string, reason?: string): ToolResult =>\n  ToolResult.Failure({\n    call_id: call.call_id,\n    tool: call.name,\n    kind,\n    ...(reason !== undefined ? { reason } : {}),\n  })\n\n/** Explicit user/policy rejection. */\nexport const denied = (call: FunctionCall, reason?: string): ToolResult =>\n  rejected(call, \"denied\", reason)\n\n/** Implicit non-answer (follow-up, inactivity, abort). */\nexport const cancelled = (call: FunctionCall, reason?: string): ToolResult =>\n  rejected(call, \"cancelled\", reason)\n\n/** Tool's own execution failed (parse error, schema, runtime crash). */\nexport const executionError = (call: FunctionCall, reason: string): ToolResult =>\n  rejected(call, \"execution_error\", reason)\n\n// ---------------------------------------------------------------------------\n// Wire conversion - the one place structured → string happens.\n// ---------------------------------------------------------------------------\n\nexport const toFunctionCallOutput = (r: ToolResult): FunctionCallOutput =>\n  ToolResult.$match(r, {\n    Value: (v) => functionCallOutput(v.call_id, JSON.stringify(v.value)),\n    Failure: (f) =>\n      functionCallOutput(\n        f.call_id,\n        JSON.stringify(\n          f.reason !== undefined ? { kind: f.kind, reason: f.reason } : { kind: f.kind },\n        ),\n      ),\n  })\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CA,MAAa,aAAa,KAAK,YAAwB;AAEvD,MAAa,UAAU,WAAW,IAAI,QAAQ;AAC9C,MAAa,YAAY,WAAW,IAAI,UAAU;AAMlD,MAAa,YAAY,MAAoB,MAAc,WACzD,WAAW,QAAQ;CACjB,SAAS,KAAK;CACd,MAAM,KAAK;CACX;CACA,GAAI,WAAW,KAAA,IAAY,EAAE,QAAQ,GAAG,EAAE;CAC3C,CAAC;;AAGJ,MAAa,UAAU,MAAoB,WACzC,SAAS,MAAM,UAAU,OAAO;;AAGlC,MAAa,aAAa,MAAoB,WAC5C,SAAS,MAAM,aAAa,OAAO;;AAGrC,MAAa,kBAAkB,MAAoB,WACjD,SAAS,MAAM,mBAAmB,OAAO;AAM3C,MAAa,wBAAwB,MACnC,WAAW,OAAO,GAAG;CACnB,QAAQ,MAAM,mBAAmB,EAAE,SAAS,KAAK,UAAU,EAAE,MAAM,CAAC;CACpE,UAAU,MACR,mBACE,EAAE,SACF,KAAK,UACH,EAAE,WAAW,KAAA,IAAY;EAAE,MAAM,EAAE;EAAM,QAAQ,EAAE;EAAQ,GAAG,EAAE,MAAM,EAAE,MAAM,CAC/E,CACF;CACJ,CAAC"}

package/dist/tool/Resolvers.d.mts

@@ -1,13 +1,16 @@
-import { o as FunctionCall } from "../Items-D1C2686t.mjs";
-import { t as ToolResult } from "../Outcome-GiaNvt7i.mjs";
-import { t as ToolEvent } from "../ToolEvent-wTMgb2GO.mjs";
+import { o as FunctionCall } from "../Items-Hg5AsYxl.mjs";
+import { ToolResult } from "./Outcome.mjs";
+import { ToolEvent } from "./ToolEvent.mjs";
 import { Effect, Queue, Scope, Stream } from "effect";
 
 //#region src/tool/Resolvers.d.ts
-interface ToolCallPlan {
+declare namespace Resolvers_d_exports {
+  export { ApprovalMapEntry, ToolCallDecision, ToolCallPlan, Verdict, approvalRequested, approve, fromApprovalMap, fromVerdictQueue, reject, splitToolCallDecisions };
+}
+type ToolCallPlan = {
   readonly approved: ReadonlyArray<FunctionCall>;
   readonly rejected: ReadonlyArray<ToolResult>;
-}
+};
 type ToolCallDecision = {
   readonly _tag: "Approved";
   readonly call: FunctionCall;
@@ -19,11 +22,11 @@ declare const approve: (call: FunctionCall) => ToolCallDecision;
 declare const reject: (result: ToolResult) => ToolCallDecision;
 declare const splitToolCallDecisions: (decisions: ReadonlyArray<ToolCallDecision>) => ToolCallPlan;
 declare const approvalRequested: (call: FunctionCall) => ToolEvent;
-interface Verdict {
+type Verdict = {
   readonly call_id: string;
   readonly decision: "approve" | "deny";
   readonly reason?: string;
-}
+};
 /**
  * Queue-backed approval planner. Safe calls are returned immediately in
  * `approved`; gated calls emit `ApprovalRequested` events and later produce
@@ -42,5 +45,5 @@ type ApprovalMapEntry = {
 };
 declare const fromApprovalMap: (predicate: (call: FunctionCall) => boolean, approvals: ReadonlyMap<string, ApprovalMapEntry>) => (calls: ReadonlyArray<FunctionCall>) => ToolCallPlan;
 //#endregion
-export { ApprovalMapEntry, ToolCallDecision, ToolCallPlan, Verdict, approvalRequested, approve, fromApprovalMap, fromVerdictQueue, reject, splitToolCallDecisions };
+export { ApprovalMapEntry, ToolCallDecision, ToolCallPlan, Verdict, approvalRequested, approve, fromApprovalMap, fromVerdictQueue, reject, splitToolCallDecisions, Resolvers_d_exports as t };
 //# sourceMappingURL=Resolvers.d.mts.map

package/dist/tool/Resolvers.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"Resolvers.d.mts","names":[],"sources":["../../src/tool/Resolvers.ts"],"mappings":";;;;;;UAYiB,YAAA;EAAA,SACN,QAAA,EAAU,aAAA,CAAc,YAAA;EAAA,SACxB,QAAA,EAAU,aAAA,CAAc,UAAA;AAAA;AAAA,KAGvB,gBAAA;EAAA,SACG,IAAA;EAAA,SAA2B,IAAA,EAAM,YAAA;AAAA;EAAA,SACjC,IAAA;EAAA,SAA2B,MAAA,EAAQ,UAAA;AAAA;AAAA,cAErC,OAAA,GAAW,IAAA,EAAM,YAAA,KAAe,gBAAA;AAAA,cAKhC,MAAA,GAAU,MAAA,EAAQ,UAAA,KAAa,gBAAA;AAAA,cAK/B,sBAAA,GACX,SAAA,EAAW,aAAA,CAAc,gBAAA,MACxB,YAAA;AAAA,cASU,iBAAA,GAAqB,IAAA,EAAM,YAAA,KAAe,SAAA;AAAA,UAWtC,OAAA;EAAA,SACN,OAAA;EAAA,SACA,QAAA;EAAA,SACA,MAAA;AAAA;;;;;AAnCX;cA2Ca,gBAAA,GAET,SAAA,GAAY,IAAA,EAAM,YAAA,cAClB,QAAA,EAAU,KAAA,CAAM,OAAA,CAAQ,OAAA,OAGxB,KAAA,EAAO,aAAA,CAAc,YAAA,MACpB,MAAA,CAAO,MAAA;EAAA,SAEG,QAAA,EAAU,aAAA,CAAc,YAAA;EAAA,SACxB,SAAA,EAAW,MAAA,CAAO,MAAA,CAAO,gBAAA;EAAA,SACzB,QAAA,EAAU,MAAA,CAAO,MAAA,CAAO,SAAA;AAAA,UAGnC,KAAA,CAAM,KAAA;AAAA,KAkDE,gBAAA;EAAA,SACG,QAAA;AAAA;EAAA,SACA,QAAA;EAAA,SAA2B,MAAA;AAAA;AAAA,cAE7B,eAAA,GAET,SAAA,GAAY,IAAA,EAAM,YAAA,cAClB,SAAA,EAAW,WAAA,SAAoB,gBAAA,OAEhC,KAAA,EAAO,aAAA,CAAc,YAAA,MAAgB,YAAA"}
+{"version":3,"file":"Resolvers.d.mts","names":[],"sources":["../../src/tool/Resolvers.ts"],"mappings":";;;;;;;;;KAYY,YAAA;EAAA,SACD,QAAA,EAAU,aAAA,CAAc,YAAA;EAAA,SACxB,QAAA,EAAU,aAAA,CAAc,UAAA;AAAA;AAAA,KAGvB,gBAAA;EAAA,SACG,IAAA;EAAA,SAA2B,IAAA,EAAM,YAAA;AAAA;EAAA,SACjC,IAAA;EAAA,SAA2B,MAAA,EAAQ,UAAA;AAAA;AAAA,cAErC,OAAA,GAAW,IAAA,EAAM,YAAA,KAAe,gBAAA;AAAA,cAKhC,MAAA,GAAU,MAAA,EAAQ,UAAA,KAAa,gBAAA;AAAA,cAK/B,sBAAA,GAA0B,SAAA,EAAW,aAAA,CAAc,gBAAA,MAAoB,YAAA;AAAA,cASvE,iBAAA,GAAqB,IAAA,EAAM,YAAA,KAAe,SAAA;AAAA,KAW3C,OAAA;EAAA,SACD,OAAA;EAAA,SACA,QAAA;EAAA,SACA,MAAA;AAAA;;;;;;cAQE,gBAAA,GACV,SAAA,GAAY,IAAA,EAAM,YAAA,cAA0B,QAAA,EAAU,KAAA,CAAM,OAAA,CAAQ,OAAA,OAEnE,KAAA,EAAO,aAAA,CAAc,YAAA,MACpB,MAAA,CAAO,MAAA;EAAA,SAEG,QAAA,EAAU,aAAA,CAAc,YAAA;EAAA,SACxB,SAAA,EAAW,MAAA,CAAO,MAAA,CAAO,gBAAA;EAAA,SACzB,QAAA,EAAU,MAAA,CAAO,MAAA,CAAO,SAAA;AAAA,UAGnC,KAAA,CAAM,KAAA;AAAA,KAkDE,gBAAA;EAAA,SACG,QAAA;AAAA;EAAA,SACA,QAAA;EAAA,SAA2B,MAAA;AAAA;AAAA,cAE7B,eAAA,GACV,SAAA,GAAY,IAAA,EAAM,YAAA,cAA0B,SAAA,EAAW,WAAA,SAAoB,gBAAA,OAC3E,KAAA,EAAO,aAAA,CAAc,YAAA,MAAgB,YAAA"}

package/dist/tool/Resolvers.mjs

@@ -1,3 +1,4 @@
+import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
 import { cancelled, denied } from "./Outcome.mjs";
 import { Deferred, Effect, Queue, Stream } from "effect";
 //#region src/tool/Resolvers.ts
@@ -8,6 +9,14 @@ import { Deferred, Effect, Queue, Stream } from "effect";
 * results must be returned to the model. Tool execution stays explicit at
 * the recipe boundary via `Toolkit.executeAll`.
 */
+var Resolvers_exports = /* @__PURE__ */ __exportAll({
+	approvalRequested: () => approvalRequested,
+	approve: () => approve,
+	fromApprovalMap: () => fromApprovalMap,
+	fromVerdictQueue: () => fromVerdictQueue,
+	reject: () => reject,
+	splitToolCallDecisions: () => splitToolCallDecisions
+});
 const approve = (call) => ({
 	_tag: "Approved",
 	call
@@ -63,6 +72,6 @@ const fromApprovalMap = (predicate, approvals) => (calls) => splitToolCallDecisi
 	return v.decision === "approve" ? approve(call) : reject(denied(call, v.reason));
 }));
 //#endregion
-export { approvalRequested, approve, fromApprovalMap, fromVerdictQueue, reject, splitToolCallDecisions };
+export { approvalRequested, approve, fromApprovalMap, fromVerdictQueue, reject, splitToolCallDecisions, Resolvers_exports as t };
 
 //# sourceMappingURL=Resolvers.mjs.map