@effect-uai/core 0.2.0 → 0.4.0

package/dist/tool/ToolEvent.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"ToolEvent.mjs","names":[],"sources":["../../src/tool/ToolEvent.ts"],"sourcesContent":["/**\n * The event type emitted while handling tool calls.\n *\n *   - ApprovalRequested : gated calls waiting for approval\n *   - Intermediate      : per-element passthrough from a streaming tool's run\n *   - Output            : terminal result (carries a structured ToolResult)\n *\n * Recipes thread `ToolEvent.Output.result` through `nextStateFrom` and apply\n * `toFunctionCallOutput` when appending to history.\n */\nimport type { ToolResult } from \"./Outcome.js\"\n\nexport type ToolEvent =\n  | {\n      readonly _tag: \"ApprovalRequested\"\n      readonly call_id: string\n      readonly tool: string\n      readonly arguments: string\n    }\n  | {\n      readonly _tag: \"Intermediate\"\n      readonly call_id: string\n      readonly tool: string\n      readonly data: unknown\n    }\n  | { readonly _tag: \"Output\"; readonly result: ToolResult }\n\nexport const isApprovalRequested = (\n  e: ToolEvent,\n): e is Extract<ToolEvent, { _tag: \"ApprovalRequested\" }> => e._tag === \"ApprovalRequested\"\n\nexport const isIntermediate = (\n  e: ToolEvent,\n): e is Extract<ToolEvent, { _tag: \"Intermediate\" }> => e._tag === \"Intermediate\"\n\nexport const isOutput = (e: ToolEvent): e is Extract<ToolEvent, { _tag: \"Output\" }> =>\n  e._tag === \"Output\"\n"],"mappings":";AA2BA,MAAa,uBACX,MAC2D,EAAE,SAAS;AAExE,MAAa,kBACX,MACsD,EAAE,SAAS;AAEnE,MAAa,YAAY,MACvB,EAAE,SAAS"}
+{"version":3,"file":"ToolEvent.mjs","names":[],"sources":["../../src/tool/ToolEvent.ts"],"sourcesContent":["/**\n * The event type emitted while handling tool calls.\n *\n *   - ApprovalRequested : gated calls waiting for approval\n *   - Intermediate      : per-element passthrough from a streaming tool's run\n *   - Output            : terminal result (carries a structured ToolResult)\n *\n * Recipes thread `ToolEvent.Output.result` through `continueWith` and apply\n * `toFunctionCallOutput` when appending to history.\n */\nimport { Data } from \"effect\"\nimport type { ToolResult } from \"./Outcome.js\"\n\nexport type ToolEvent = Data.TaggedEnum<{\n  ApprovalRequested: {\n    readonly call_id: string\n    readonly tool: string\n    readonly arguments: string\n  }\n  Intermediate: {\n    readonly call_id: string\n    readonly tool: string\n    readonly data: unknown\n  }\n  Output: {\n    readonly result: ToolResult\n  }\n}>\n\n/**\n * Namespace of constructors, type guards, and matchers for `ToolEvent`,\n * provided by `Data.taggedEnum`. Use `ToolEvent.Output({ result })` to build\n * an event, `ToolEvent.$is(\"Output\")` for type narrowing,\n * `ToolEvent.$match({ ApprovalRequested, Intermediate, Output })` for\n * exhaustive pattern matching.\n */\nexport const ToolEvent = Data.taggedEnum<ToolEvent>()\n\nexport const isApprovalRequested = ToolEvent.$is(\"ApprovalRequested\")\nexport const isIntermediate = ToolEvent.$is(\"Intermediate\")\nexport const isOutput = ToolEvent.$is(\"Output\")\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,MAAa,YAAY,KAAK,YAAuB;AAErD,MAAa,sBAAsB,UAAU,IAAI,oBAAoB;AACrE,MAAa,iBAAiB,UAAU,IAAI,eAAe;AAC3D,MAAa,WAAW,UAAU,IAAI,SAAS"}

package/dist/tool/Toolkit.d.mts

@@ -1,19 +1,25 @@
-import { o as FunctionCall } from "../Items-D1C2686t.mjs";
-import { a as Tool, o as ToolDescriptor, t as AnyKindTool } from "../Tool-5wxOCuOh.mjs";
+import { o as FunctionCall } from "../Items-Hg5AsYxl.mjs";
+import { a as Tool, i as StreamingTool, o as ToolDescriptor, t as AnyKindTool } from "../Tool-B8B5qVEy.mjs";
 import { Event } from "../loop/Loop.mjs";
-import { t as ToolResult } from "../Outcome-GiaNvt7i.mjs";
-import { t as ToolEvent } from "../ToolEvent-wTMgb2GO.mjs";
+import { ToolResult } from "./Outcome.mjs";
+import { ToolEvent } from "./ToolEvent.mjs";
 import { Stream } from "effect";
 
 //#region src/tool/Toolkit.d.ts
 declare namespace Toolkit_d_exports {
-  export { AnyTool, ExecuteOptions, Toolkit, ToolsR, executeAll, make, nextStateFrom, outputEvent, outputEvents, toDescriptors };
+  export { AnyTool, ExecuteOptions, ToolKindR, Toolkit, ToolsR, continueWith, executeAll, make, outputEvent, outputEvents, toDescriptors };
 }
 type AnyTool = Tool<string, any, any, any>;
 type Toolkit<Tools extends ReadonlyArray<AnyTool>> = {
   readonly tools: Tools;
 };
 type ToolsR<Tools extends ReadonlyArray<AnyTool>> = Tools[number] extends Tool<any, any, any, infer R> ? R : never;
+/**
+ * Union of every tool's `R` requirements in a mixed plain + streaming array.
+ * Used by `executeAll` to surface the services tools need at the recipe
+ * level, so the loop's stream type carries them through to `Effect.provide`.
+ */
+type ToolKindR<Tools extends ReadonlyArray<AnyKindTool<any>>> = Tools[number] extends StreamingTool<any, any, any, any, infer R> ? R : Tools[number] extends Tool<any, any, any, infer R> ? R : never;
 declare const make: <const Tools extends ReadonlyArray<AnyTool>>(tools: Tools) => Toolkit<Tools>;
 /**
  * Render every tool in a toolkit to a provider-agnostic descriptor.
@@ -21,14 +27,17 @@ declare const make: <const Tools extends ReadonlyArray<AnyTool>>(tools: Tools) =
  * Standard Schema converter (draft 2020-12).
  */
 declare const toDescriptors: <Tools extends ReadonlyArray<AnyTool>>(toolkit: Toolkit<Tools>) => ReadonlyArray<ToolDescriptor>;
-interface ExecuteOptions {
+type ExecuteOptions = {
   readonly concurrency?: number | "unbounded";
-}
+};
 /** Execute every provided call. Approval/rejection policy belongs upstream. */
-declare const executeAll: (tools: ReadonlyArray<AnyKindTool>, calls: ReadonlyArray<FunctionCall>, options?: ExecuteOptions) => Stream.Stream<ToolEvent>;
+declare const executeAll: <Tools extends ReadonlyArray<AnyKindTool<any>>>(tools: Tools, calls: ReadonlyArray<FunctionCall>, options?: ExecuteOptions) => Stream.Stream<ToolEvent, never, ToolKindR<Tools>>;
 declare const outputEvent: (result: ToolResult) => ToolEvent;
 declare const outputEvents: (results: ReadonlyArray<ToolResult>) => Stream.Stream<ToolEvent>;
-declare const nextStateFrom: <S>(stream: Stream.Stream<ToolEvent>, build: (results: ReadonlyArray<ToolResult>) => S) => Stream.Stream<Event<ToolEvent, S>>;
+declare const continueWith: {
+  <S>(build: (results: ReadonlyArray<ToolResult>) => S): <R>(stream: Stream.Stream<ToolEvent, never, R>) => Stream.Stream<Event<ToolEvent, S>, never, R>;
+  <S, R>(stream: Stream.Stream<ToolEvent, never, R>, build: (results: ReadonlyArray<ToolResult>) => S): Stream.Stream<Event<ToolEvent, S>, never, R>;
+};
 //#endregion
-export { AnyTool, ExecuteOptions, Toolkit, ToolsR, executeAll, make, nextStateFrom, outputEvent, outputEvents, Toolkit_d_exports as t, toDescriptors };
+export { AnyTool, ExecuteOptions, ToolKindR, Toolkit, ToolsR, continueWith, executeAll, make, outputEvent, outputEvents, Toolkit_d_exports as t, toDescriptors };
 //# sourceMappingURL=Toolkit.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Toolkit.d.mts","names":[],"sources":["../../src/tool/Toolkit.ts"],"mappings":";;;;;;;;;;;KAmBY,OAAA,GAAU,IAAA;AAAA,KAEV,OAAA,eAAsB,aAAA,CAAc,OAAA;EAAA,SACrC,KAAA,EAAO,KAAA;AAAA;AAAA,KAGN,MAAA,eAAqB,aAAA,CAAc,OAAA,KAC7C,KAAA,iBAAsB,IAAA,2BAA+B,CAAA;AAAA,cAE1C,IAAA,uBAA4B,aAAA,CAAc,OAAA,GAAU,KAAA,EAAO,KAAA,KAAQ,OAAA,CAAQ,KAAA;;;;;;cAS3E,aAAA,iBAA+B,aAAA,CAAc,OAAA,GACxD,OAAA,EAAS,OAAA,CAAQ,KAAA,MAChB,aAAA,CAAc,cAAA;AAAA,UAgBA,cAAA;EAAA,SACN,WAAA;AAAA;AArCX;AAAA,cAyCa,UAAA,GACX,KAAA,EAAO,aAAA,CAAc,WAAA,GACrB,KAAA,EAAO,aAAA,CAAc,YAAA,GACrB,OAAA,GAAU,cAAA,KACT,MAAA,CAAO,MAAA,CAAO,SAAA;AAAA,cAOJ,WAAA,GAAe,MAAA,EAAQ,UAAA,KAAa,SAAA;AAAA,cAEpC,YAAA,GACX,OAAA,EAAS,aAAA,CAAc,UAAA,MACtB,MAAA,CAAO,MAAA,CAAO,SAAA;AAAA,cAqHJ,aAAA,MACX,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,SAAA,GACtB,KAAA,GAAQ,OAAA,EAAS,aAAA,CAAc,UAAA,MAAgB,CAAA,KAC9C,MAAA,CAAO,MAAA,CAAO,KAAA,CAAW,SAAA,EAAW,CAAA"}
+{"version":3,"file":"Toolkit.d.mts","names":[],"sources":["../../src/tool/Toolkit.ts"],"mappings":";;;;;;;;;;;KAgBY,OAAA,GAAU,IAAA;AAAA,KAEV,OAAA,eAAsB,aAAA,CAAc,OAAA;EAAA,SACrC,KAAA,EAAO,KAAA;AAAA;AAAA,KAGN,MAAA,eAAqB,aAAA,CAAc,OAAA,KAC7C,KAAA,iBAAsB,IAAA,2BAA+B,CAAA;;;;;;KAO3C,SAAA,eAAwB,aAAA,CAAc,WAAA,UAChD,KAAA,iBAAsB,aAAA,gCAClB,CAAA,GACA,KAAA,iBAAsB,IAAA,2BACpB,CAAA;AAAA,cAGK,IAAA,uBAA4B,aAAA,CAAc,OAAA,GAAU,KAAA,EAAO,KAAA,KAAQ,OAAA,CAAQ,KAAA;;;;;AArBxF;cA8Ba,aAAA,iBAA+B,aAAA,CAAc,OAAA,GACxD,OAAA,EAAS,OAAA,CAAQ,KAAA,MAChB,aAAA,CAAc,cAAA;AAAA,KAgBL,cAAA;EAAA,SACD,WAAA;AAAA;AA/CX;AAAA,cAmDa,UAAA,iBAA4B,aAAA,CAAc,WAAA,QACrD,KAAA,EAAO,KAAA,EACP,KAAA,EAAO,aAAA,CAAc,YAAA,GACrB,OAAA,GAAU,cAAA,KACT,MAAA,CAAO,MAAA,CAAO,SAAA,SAAkB,SAAA,CAAU,KAAA;AAAA,cAOhC,WAAA,GAAe,MAAA,EAAQ,UAAA,KAAa,SAAA;AAAA,cAEpC,YAAA,GAAgB,OAAA,EAAS,aAAA,CAAc,UAAA,MAAc,MAAA,CAAO,MAAA,CAAO,SAAA;AAAA,cAyHnE,YAAA;EAAA,IAET,KAAA,GAAQ,OAAA,EAAS,aAAA,CAAc,UAAA,MAAgB,CAAA,OAE/C,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,SAAA,SAAkB,CAAA,MACrC,MAAA,CAAO,MAAA,CAAO,KAAA,CAAW,SAAA,EAAW,CAAA,UAAW,CAAA;EAAA,OAElD,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,SAAA,SAAkB,CAAA,GACxC,KAAA,GAAQ,OAAA,EAAS,aAAA,CAAc,UAAA,MAAgB,CAAA,GAC9C,MAAA,CAAO,MAAA,CAAO,KAAA,CAAW,SAAA,EAAW,CAAA,UAAW,CAAA;AAAA"}

package/dist/tool/Toolkit.mjs

@@ -1,14 +1,14 @@
-import { t as __exportAll } from "../chunk-CfYAbeIz.mjs";
+import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
 import { nextAfterFold } from "../loop/Loop.mjs";
 import { isStreamingTool } from "./Tool.mjs";
 import { executionError, rejected } from "./Outcome.mjs";
 import { isOutput } from "./ToolEvent.mjs";
-import { Array, Effect, Ref, Stream } from "effect";
+import { Array, Effect, Function, Ref, Stream } from "effect";
 //#region src/tool/Toolkit.ts
 var Toolkit_exports = /* @__PURE__ */ __exportAll({
+	continueWith: () => continueWith,
 	executeAll: () => executeAll,
 	make: () => make,
-	nextStateFrom: () => nextStateFrom,
 	outputEvent: () => outputEvent,
 	outputEvents: () => outputEvents,
 	toDescriptors: () => toDescriptors
@@ -99,8 +99,8 @@ const runStreaming = (tool, call) => Stream.unwrap(Effect.gen(function* () {
 	_tag: "Output",
 	result: executionError(call, "Tool execution failed")
 })));
-const nextStateFrom = (stream, build) => nextAfterFold(stream, [], (acc, e) => isOutput(e) ? Array.append(acc, e.result) : acc, build);
+const continueWith = Function.dual(2, (stream, build) => nextAfterFold(stream, [], (acc, e) => isOutput(e) ? Array.append(acc, e.result) : acc, build));
 //#endregion
-export { executeAll, make, nextStateFrom, outputEvent, outputEvents, Toolkit_exports as t, toDescriptors };
+export { continueWith, executeAll, make, outputEvent, outputEvents, Toolkit_exports as t, toDescriptors };
 
 //# sourceMappingURL=Toolkit.mjs.map

package/dist/tool/Toolkit.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"Toolkit.mjs","names":["Arr","Loop.nextAfterFold"],"sources":["../../src/tool/Toolkit.ts"],"sourcesContent":["import { Array as Arr, Effect, Ref, Stream } from \"effect\"\nimport * as Loop from \"../loop/Loop.js\"\nimport type { FunctionCall } from \"../domain/Items.js\"\nimport {\n  type AnyKindTool,\n  type AnyPlainTool,\n  type AnyStreamingTool,\n  isStreamingTool,\n  type Tool,\n  type ToolDescriptor,\n} from \"./Tool.js\"\nimport {\n  type ToolResult,\n  executionError,\n  rejected,\n} from \"./Outcome.js\"\nimport type { ToolEvent } from \"./ToolEvent.js\"\nimport { isOutput } from \"./ToolEvent.js\"\n\nexport type AnyTool = Tool<string, any, any, any>\n\nexport type Toolkit<Tools extends ReadonlyArray<AnyTool>> = {\n  readonly tools: Tools\n}\n\nexport type ToolsR<Tools extends ReadonlyArray<AnyTool>> =\n  Tools[number] extends Tool<any, any, any, infer R> ? R : never\n\nexport const make = <const Tools extends ReadonlyArray<AnyTool>>(tools: Tools): Toolkit<Tools> => ({\n  tools,\n})\n\n/**\n * Render every tool in a toolkit to a provider-agnostic descriptor.\n * `inputSchema` is the JSON Schema document produced by the tool's\n * Standard Schema converter (draft 2020-12).\n */\nexport const toDescriptors = <Tools extends ReadonlyArray<AnyTool>>(\n  toolkit: Toolkit<Tools>,\n): ReadonlyArray<ToolDescriptor> =>\n  toolkit.tools.map((tool) => {\n    const inputSchema = tool.inputSchema[\"~standard\"].jsonSchema.input({\n      target: \"draft-2020-12\",\n    })\n    return tool.strict !== undefined\n      ? { name: tool.name, description: tool.description, inputSchema, strict: tool.strict }\n      : { name: tool.name, description: tool.description, inputSchema }\n  })\n\n// ---------------------------------------------------------------------------\n// Tool executor. Streams `ToolEvent`s in real time and dispatches streaming\n// and plain tools uniformly. Policy stays outside this module: callers pass\n// only the calls they have already decided should run.\n// ---------------------------------------------------------------------------\n\nexport interface ExecuteOptions {\n  readonly concurrency?: number | \"unbounded\"\n}\n\n/** Execute every provided call. Approval/rejection policy belongs upstream. */\nexport const executeAll = (\n  tools: ReadonlyArray<AnyKindTool>,\n  calls: ReadonlyArray<FunctionCall>,\n  options?: ExecuteOptions,\n): Stream.Stream<ToolEvent> =>\n  Stream.fromIterable(calls).pipe(\n    Stream.flatMap((call) => runOne(tools, call), {\n      concurrency: options?.concurrency ?? \"unbounded\",\n    }),\n  )\n\nexport const outputEvent = (result: ToolResult): ToolEvent => ({ _tag: \"Output\", result })\n\nexport const outputEvents = (\n  results: ReadonlyArray<ToolResult>,\n): Stream.Stream<ToolEvent> => Stream.fromIterable(results.map(outputEvent))\n\nconst valueResult = (call: FunctionCall, tool: string, value: unknown): ToolResult => ({\n  _tag: \"Value\",\n  call_id: call.call_id,\n  tool,\n  value,\n})\n\nconst runOne = (\n  tools: ReadonlyArray<AnyKindTool>,\n  call: FunctionCall,\n): Stream.Stream<ToolEvent> => {\n  const tool = tools.find((t) => t.name === call.name)\n  if (tool === undefined) {\n    // Graceful: emit a synthetic Failure so OTHER calls in this turn\n    // still execute. LLMs hallucinate tool names; MCP tools come and go.\n    return Stream.succeed<ToolEvent>({\n      _tag: \"Output\",\n      result: rejected(call, \"unknown_tool\", `No tool registered with name \"${call.name}\"`),\n    })\n  }\n  if (isStreamingTool(tool)) return runStreaming(tool, call)\n  return runPlain(tool, call)\n}\n\nconst runPlain = (\n  tool: AnyPlainTool,\n  call: FunctionCall,\n): Stream.Stream<ToolEvent> =>\n  Stream.fromEffect(\n    Effect.gen(function* () {\n      const parsed = yield* Effect.try({\n        try: () => JSON.parse(call.arguments) as unknown,\n        catch: () => \"json_parse_error\" as const,\n      })\n      const validated = yield* Effect.tryPromise({\n        try: () => Promise.resolve(tool.inputSchema[\"~standard\"].validate(parsed)),\n        catch: () => \"validation_threw\" as const,\n      })\n      if (validated.issues !== undefined) {\n        return executionError(call, \"Tool input failed schema validation\")\n      }\n      const output = yield* tool.run(validated.value)\n      return valueResult(call, tool.name, output)\n    }).pipe(\n      Effect.catchCause(() => Effect.succeed(executionError(call, \"Tool execution failed\"))),\n      Effect.map((result) => ({ _tag: \"Output\", result }) satisfies ToolEvent),\n    ),\n  )\n\nconst runStreaming = (\n  tool: AnyStreamingTool,\n  call: FunctionCall,\n): Stream.Stream<ToolEvent> =>\n  Stream.unwrap(\n    Effect.gen(function* () {\n      const parsed = yield* Effect.try({\n        try: () => JSON.parse(call.arguments) as unknown,\n        catch: () => \"json_parse_error\" as const,\n      })\n      const validated = yield* Effect.tryPromise({\n        try: () => Promise.resolve(tool.inputSchema[\"~standard\"].validate(parsed)),\n        catch: () => \"validation_threw\" as const,\n      })\n      if (validated.issues !== undefined) {\n        return Stream.succeed<ToolEvent>({\n          _tag: \"Output\",\n          result: executionError(call, \"Tool input failed schema validation\"),\n        })\n      }\n\n      // Real-time: tap each event into a Ref as it flows; emit one\n      // Intermediate per event; then concat one synthetic Output element\n      // built from the accumulated Ref via `finalize`.\n      const ref = yield* Ref.make<Array<unknown>>([])\n      const intermediates = tool.run(validated.value).pipe(\n        Stream.tap((event) => Ref.update(ref, Arr.append(event))),\n        Stream.map(\n          (data) =>\n            ({\n              _tag: \"Intermediate\",\n              call_id: call.call_id,\n              tool: tool.name,\n              data,\n            }) satisfies ToolEvent,\n        ),\n      )\n      const output = Stream.fromEffect(\n        Ref.get(ref).pipe(\n          Effect.map(\n            (events) =>\n              ({\n                _tag: \"Output\",\n                result: valueResult(call, tool.name, tool.finalize(events)),\n              }) satisfies ToolEvent,\n          ),\n        ),\n      )\n      return intermediates.pipe(Stream.concat(output))\n    }),\n  ).pipe(\n    Stream.catchCause(() =>\n      Stream.succeed<ToolEvent>({\n        _tag: \"Output\",\n        result: executionError(call, \"Tool execution failed\"),\n      }),\n    ),\n  )\n\n// ---------------------------------------------------------------------------\n// `nextStateFrom` - bridge from a `Stream<ToolEvent>` to the loop's emit\n// shape. Drains the stream to the consumer in real-time, taps every\n// `Output` into an internal Ref, and at end-of-stream emits\n// `Loop.next(build(results))`. Recipe never sees the Ref.\n// ---------------------------------------------------------------------------\n\nexport const nextStateFrom = <S>(\n  stream: Stream.Stream<ToolEvent>,\n  build: (results: ReadonlyArray<ToolResult>) => S,\n): Stream.Stream<Loop.Event<ToolEvent, S>> =>\n  Loop.nextAfterFold(\n    stream,\n    [] as ReadonlyArray<ToolResult>,\n    (acc, e) => (isOutput(e) ? Arr.append(acc, e.result) : acc),\n    build,\n  )\n"],"mappings":"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"}
+{"version":3,"file":"Toolkit.mjs","names":["Arr","Loop.nextAfterFold"],"sources":["../../src/tool/Toolkit.ts"],"sourcesContent":["import { Array as Arr, Effect, Function, Ref, Stream } from \"effect\"\nimport * as Loop from \"../loop/Loop.js\"\nimport type { FunctionCall } from \"../domain/Items.js\"\nimport {\n  type AnyKindTool,\n  type AnyPlainTool,\n  type AnyStreamingTool,\n  isStreamingTool,\n  type StreamingTool,\n  type Tool,\n  type ToolDescriptor,\n} from \"./Tool.js\"\nimport { type ToolResult, executionError, rejected } from \"./Outcome.js\"\nimport type { ToolEvent } from \"./ToolEvent.js\"\nimport { isOutput } from \"./ToolEvent.js\"\n\nexport type AnyTool = Tool<string, any, any, any>\n\nexport type Toolkit<Tools extends ReadonlyArray<AnyTool>> = {\n  readonly tools: Tools\n}\n\nexport type ToolsR<Tools extends ReadonlyArray<AnyTool>> =\n  Tools[number] extends Tool<any, any, any, infer R> ? R : never\n\n/**\n * Union of every tool's `R` requirements in a mixed plain + streaming array.\n * Used by `executeAll` to surface the services tools need at the recipe\n * level, so the loop's stream type carries them through to `Effect.provide`.\n */\nexport type ToolKindR<Tools extends ReadonlyArray<AnyKindTool<any>>> =\n  Tools[number] extends StreamingTool<any, any, any, any, infer R>\n    ? R\n    : Tools[number] extends Tool<any, any, any, infer R>\n      ? R\n      : never\n\nexport const make = <const Tools extends ReadonlyArray<AnyTool>>(tools: Tools): Toolkit<Tools> => ({\n  tools,\n})\n\n/**\n * Render every tool in a toolkit to a provider-agnostic descriptor.\n * `inputSchema` is the JSON Schema document produced by the tool's\n * Standard Schema converter (draft 2020-12).\n */\nexport const toDescriptors = <Tools extends ReadonlyArray<AnyTool>>(\n  toolkit: Toolkit<Tools>,\n): ReadonlyArray<ToolDescriptor> =>\n  toolkit.tools.map((tool) => {\n    const inputSchema = tool.inputSchema[\"~standard\"].jsonSchema.input({\n      target: \"draft-2020-12\",\n    })\n    return tool.strict !== undefined\n      ? { name: tool.name, description: tool.description, inputSchema, strict: tool.strict }\n      : { name: tool.name, description: tool.description, inputSchema }\n  })\n\n// ---------------------------------------------------------------------------\n// Tool executor. Streams `ToolEvent`s in real time and dispatches streaming\n// and plain tools uniformly. Policy stays outside this module: callers pass\n// only the calls they have already decided should run.\n// ---------------------------------------------------------------------------\n\nexport type ExecuteOptions = {\n  readonly concurrency?: number | \"unbounded\"\n}\n\n/** Execute every provided call. Approval/rejection policy belongs upstream. */\nexport const executeAll = <Tools extends ReadonlyArray<AnyKindTool<any>>>(\n  tools: Tools,\n  calls: ReadonlyArray<FunctionCall>,\n  options?: ExecuteOptions,\n): Stream.Stream<ToolEvent, never, ToolKindR<Tools>> =>\n  Stream.fromIterable(calls).pipe(\n    Stream.flatMap((call) => runOne(tools, call), {\n      concurrency: options?.concurrency ?? \"unbounded\",\n    }),\n  )\n\nexport const outputEvent = (result: ToolResult): ToolEvent => ({ _tag: \"Output\", result })\n\nexport const outputEvents = (results: ReadonlyArray<ToolResult>): Stream.Stream<ToolEvent> =>\n  Stream.fromIterable(results.map(outputEvent))\n\nconst valueResult = (call: FunctionCall, tool: string, value: unknown): ToolResult => ({\n  _tag: \"Value\",\n  call_id: call.call_id,\n  tool,\n  value,\n})\n\nconst runOne = <R>(\n  tools: ReadonlyArray<AnyKindTool<R>>,\n  call: FunctionCall,\n): Stream.Stream<ToolEvent, never, R> => {\n  const tool = tools.find((t) => t.name === call.name)\n  if (tool === undefined) {\n    // Graceful: emit a synthetic Failure so OTHER calls in this turn\n    // still execute. LLMs hallucinate tool names; MCP tools come and go.\n    return Stream.succeed<ToolEvent>({\n      _tag: \"Output\",\n      result: rejected(call, \"unknown_tool\", `No tool registered with name \"${call.name}\"`),\n    })\n  }\n  if (isStreamingTool(tool)) return runStreaming(tool, call)\n  return runPlain(tool, call)\n}\n\nconst runPlain = <R>(\n  tool: AnyPlainTool<R>,\n  call: FunctionCall,\n): Stream.Stream<ToolEvent, never, R> =>\n  Stream.fromEffect(\n    Effect.gen(function* () {\n      const parsed = yield* Effect.try({\n        try: () => JSON.parse(call.arguments) as unknown,\n        catch: () => \"json_parse_error\" as const,\n      })\n      const validated = yield* Effect.tryPromise({\n        try: () => Promise.resolve(tool.inputSchema[\"~standard\"].validate(parsed)),\n        catch: () => \"validation_threw\" as const,\n      })\n      if (validated.issues !== undefined) {\n        return executionError(call, \"Tool input failed schema validation\")\n      }\n      const output = yield* tool.run(validated.value)\n      return valueResult(call, tool.name, output)\n    }).pipe(\n      Effect.catchCause(() => Effect.succeed(executionError(call, \"Tool execution failed\"))),\n      Effect.map((result) => ({ _tag: \"Output\", result }) satisfies ToolEvent),\n    ),\n  )\n\nconst runStreaming = <R>(\n  tool: AnyStreamingTool<R>,\n  call: FunctionCall,\n): Stream.Stream<ToolEvent, never, R> =>\n  Stream.unwrap(\n    Effect.gen(function* () {\n      const parsed = yield* Effect.try({\n        try: () => JSON.parse(call.arguments) as unknown,\n        catch: () => \"json_parse_error\" as const,\n      })\n      const validated = yield* Effect.tryPromise({\n        try: () => Promise.resolve(tool.inputSchema[\"~standard\"].validate(parsed)),\n        catch: () => \"validation_threw\" as const,\n      })\n      if (validated.issues !== undefined) {\n        return Stream.succeed<ToolEvent>({\n          _tag: \"Output\",\n          result: executionError(call, \"Tool input failed schema validation\"),\n        })\n      }\n\n      // Real-time: tap each event into a Ref as it flows; emit one\n      // Intermediate per event; then concat one synthetic Output element\n      // built from the accumulated Ref via `finalize`.\n      const ref = yield* Ref.make<Array<unknown>>([])\n      const intermediates = tool.run(validated.value).pipe(\n        Stream.tap((event) => Ref.update(ref, Arr.append(event))),\n        Stream.map(\n          (data) =>\n            ({\n              _tag: \"Intermediate\",\n              call_id: call.call_id,\n              tool: tool.name,\n              data,\n            }) satisfies ToolEvent,\n        ),\n      )\n      const output = Stream.fromEffect(\n        Ref.get(ref).pipe(\n          Effect.map(\n            (events) =>\n              ({\n                _tag: \"Output\",\n                result: valueResult(call, tool.name, tool.finalize(events)),\n              }) satisfies ToolEvent,\n          ),\n        ),\n      )\n      return intermediates.pipe(Stream.concat(output))\n    }),\n  ).pipe(\n    Stream.catchCause(() =>\n      Stream.succeed<ToolEvent>({\n        _tag: \"Output\",\n        result: executionError(call, \"Tool execution failed\"),\n      }),\n    ),\n  )\n\n// ---------------------------------------------------------------------------\n// `continueWith` - bridge from a `Stream<ToolEvent>` to the loop's emit\n// shape. Drains the stream to the consumer in real-time, taps every\n// `Output` into an internal Ref, and at end-of-stream emits\n// `Loop.next(build(results))`. Recipe never sees the Ref.\n//\n// Dual: data-first `continueWith(stream, build)` and data-last\n// `stream.pipe(continueWith(build))` both work.\n// ---------------------------------------------------------------------------\n\nexport const continueWith: {\n  <S>(\n    build: (results: ReadonlyArray<ToolResult>) => S,\n  ): <R>(\n    stream: Stream.Stream<ToolEvent, never, R>,\n  ) => Stream.Stream<Loop.Event<ToolEvent, S>, never, R>\n  <S, R>(\n    stream: Stream.Stream<ToolEvent, never, R>,\n    build: (results: ReadonlyArray<ToolResult>) => S,\n  ): Stream.Stream<Loop.Event<ToolEvent, S>, never, R>\n} = Function.dual(\n  2,\n  <S, R>(\n    stream: Stream.Stream<ToolEvent, never, R>,\n    build: (results: ReadonlyArray<ToolResult>) => S,\n  ): Stream.Stream<Loop.Event<ToolEvent, S>, never, R> =>\n    Loop.nextAfterFold(\n      stream,\n      [] as ReadonlyArray<ToolResult>,\n      (acc, e) => (isOutput(e) ? Arr.append(acc, e.result) : acc),\n      build,\n    ),\n)\n"],"mappings":"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"}

package/dist/tool/Toolkit.test.d.mts

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

package/dist/tool/Toolkit.test.mjs

@@ -0,0 +1,113 @@
+import { fromEffectSchema, make } from "./Tool.mjs";
+import { isValue } from "./Outcome.mjs";
+import { isOutput } from "./ToolEvent.mjs";
+import { executeAll, make as make$1, toDescriptors } from "./Toolkit.mjs";
+import { i as it, n as globalExpect, r as describe, t as import_dist } from "../dist-DV5ISja1.mjs";
+import { Context, Effect, Layer, Schema, Stream } from "effect";
+//#region src/tool/Toolkit.test.ts
+describe("Toolkit.toDescriptors", () => {
+	const GetWeatherInput = Schema.Struct({ city: Schema.String });
+	const getWeather = make({
+		name: "get_weather",
+		description: "Look up the current temperature for a city.",
+		inputSchema: fromEffectSchema(GetWeatherInput),
+		run: ({ city }) => Effect.succeed({
+			city,
+			tempC: 18
+		})
+	});
+	it("renders the input schema as a JSON Schema document", () => {
+		const [desc] = toDescriptors(make$1([getWeather]));
+		globalExpect(desc?.name).toBe("get_weather");
+		globalExpect(desc?.description).toBe("Look up the current temperature for a city.");
+		globalExpect(desc?.inputSchema).toMatchObject({
+			type: "object",
+			properties: { city: { type: "string" } },
+			required: ["city"]
+		});
+	});
+	it("includes strict flag only when set on the tool", () => {
+		const [s, l] = toDescriptors(make$1([make({
+			name: "strict_one",
+			description: "",
+			inputSchema: fromEffectSchema(GetWeatherInput),
+			run: () => Effect.succeed({}),
+			strict: true
+		}), make({
+			name: "loose_one",
+			description: "",
+			inputSchema: fromEffectSchema(GetWeatherInput),
+			run: () => Effect.succeed({})
+		})]));
+		globalExpect(s?.strict).toBe(true);
+		globalExpect(l).not.toHaveProperty("strict");
+	});
+});
+describe("Toolkit.executeAll - tools with R requirements", () => {
+	class WeatherApiKey extends Context.Service()("test/WeatherApiKey") {}
+	class GeoApiKey extends Context.Service()("test/GeoApiKey") {}
+	const Empty = Schema.Struct({});
+	const getWeather = make({
+		name: "get_weather",
+		description: "",
+		inputSchema: fromEffectSchema(Empty),
+		run: () => Effect.gen(function* () {
+			const { key } = yield* WeatherApiKey;
+			return {
+				source: "weather",
+				key
+			};
+		})
+	});
+	const getCoords = make({
+		name: "get_coords",
+		description: "",
+		inputSchema: fromEffectSchema(Empty),
+		run: () => Effect.gen(function* () {
+			const { key } = yield* GeoApiKey;
+			return {
+				source: "geo",
+				key
+			};
+		})
+	});
+	const call = (name, id) => ({
+		type: "function_call",
+		call_id: id,
+		name,
+		arguments: "{}"
+	});
+	it("propagates each tool's R into the resulting Stream's requirements", () => {
+		(0, import_dist.expectTypeOf)(executeAll([getWeather, getCoords], [])).toEqualTypeOf();
+	});
+	it("runs each tool with its own service injected", async () => {
+		const layer = Layer.mergeAll(Layer.succeed(WeatherApiKey, { key: "weather-123" }), Layer.succeed(GeoApiKey, { key: "geo-456" }));
+		const program = executeAll([getWeather, getCoords], [call("get_weather", "c1"), call("get_coords", "c2")]).pipe(Stream.runCollect, Effect.provide(layer));
+		const events = await Effect.runPromise(program);
+		const outputs = Array.from(events).filter(isOutput);
+		const byCall = new Map(outputs.map((e) => [e.result.call_id, e.result]));
+		const w = byCall.get("c1");
+		const g = byCall.get("c2");
+		globalExpect(w !== void 0 && isValue(w) && w.value).toEqual({
+			source: "weather",
+			key: "weather-123"
+		});
+		globalExpect(g !== void 0 && isValue(g) && g.value).toEqual({
+			source: "geo",
+			key: "geo-456"
+		});
+	});
+	it("with no service-needing tools, R is never", () => {
+		const plain = make({
+			name: "plain",
+			description: "",
+			inputSchema: fromEffectSchema(Empty),
+			run: () => Effect.succeed(0)
+		});
+		(0, import_dist.expectTypeOf)(executeAll([plain], [])).toEqualTypeOf();
+	});
+});
+//#endregion
+export {};
+
+//# sourceMappingURL=Toolkit.test.mjs.map

package/dist/tool/Toolkit.test.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Toolkit.test.mjs","names":["Tool.make","Tool.fromEffectSchema","Toolkit.toDescriptors","Toolkit.make","Toolkit.executeAll"],"sources":["../../src/tool/Toolkit.test.ts"],"sourcesContent":["import { Context, Effect, Layer, Schema, Stream } from \"effect\"\nimport { describe, expect, expectTypeOf, it } from \"vitest\"\nimport type { FunctionCall } from \"../domain/Items.js\"\nimport { isOutput } from \"./ToolEvent.js\"\nimport { isValue } from \"./Outcome.js\"\nimport * as Tool from \"./Tool.js\"\nimport * as Toolkit from \"./Toolkit.js\"\n\ndescribe(\"Toolkit.toDescriptors\", () => {\n  const GetWeatherInput = Schema.Struct({ city: Schema.String })\n\n  const getWeather = Tool.make({\n    name: \"get_weather\",\n    description: \"Look up the current temperature for a city.\",\n    inputSchema: Tool.fromEffectSchema(GetWeatherInput),\n    run: ({ city }) => Effect.succeed({ city, tempC: 18 }),\n  })\n\n  it(\"renders the input schema as a JSON Schema document\", () => {\n    const [desc] = Toolkit.toDescriptors(Toolkit.make([getWeather]))\n    expect(desc?.name).toBe(\"get_weather\")\n    expect(desc?.description).toBe(\"Look up the current temperature for a city.\")\n    expect(desc?.inputSchema).toMatchObject({\n      type: \"object\",\n      properties: { city: { type: \"string\" } },\n      required: [\"city\"],\n    })\n  })\n\n  it(\"includes strict flag only when set on the tool\", () => {\n    const strictTool = Tool.make({\n      name: \"strict_one\",\n      description: \"\",\n      inputSchema: Tool.fromEffectSchema(GetWeatherInput),\n      run: () => Effect.succeed({}),\n      strict: true,\n    })\n    const looseTool = Tool.make({\n      name: \"loose_one\",\n      description: \"\",\n      inputSchema: Tool.fromEffectSchema(GetWeatherInput),\n      run: () => Effect.succeed({}),\n    })\n    const [s, l] = Toolkit.toDescriptors(Toolkit.make([strictTool, looseTool]))\n    expect(s?.strict).toBe(true)\n    expect(l).not.toHaveProperty(\"strict\")\n  })\n})\n\ndescribe(\"Toolkit.executeAll - tools with R requirements\", () => {\n  // Two distinct services, modelling the \"typed per-tool context\" use case\n  // (cf. AI SDK 7's `toolsContext`). In Effect each tool declares its R, the\n  // compiler enforces it, and `executeAll` surfaces the union for the caller\n  // to provide via Layer.\n  type WeatherApiKeyShape = { readonly key: string }\n  class WeatherApiKey extends Context.Service<WeatherApiKey, WeatherApiKeyShape>()(\n    \"test/WeatherApiKey\",\n  ) {}\n\n  type GeoApiKeyShape = { readonly key: string }\n  class GeoApiKey extends Context.Service<GeoApiKey, GeoApiKeyShape>()(\"test/GeoApiKey\") {}\n\n  const Empty = Schema.Struct({})\n\n  const getWeather = Tool.make({\n    name: \"get_weather\",\n    description: \"\",\n    inputSchema: Tool.fromEffectSchema(Empty),\n    run: () =>\n      Effect.gen(function* () {\n        const { key } = yield* WeatherApiKey\n        return { source: \"weather\", key }\n      }),\n  })\n\n  const getCoords = Tool.make({\n    name: \"get_coords\",\n    description: \"\",\n    inputSchema: Tool.fromEffectSchema(Empty),\n    run: () =>\n      Effect.gen(function* () {\n        const { key } = yield* GeoApiKey\n        return { source: \"geo\", key }\n      }),\n  })\n\n  const call = (name: string, id: string): FunctionCall => ({\n    type: \"function_call\",\n    call_id: id,\n    name,\n    arguments: \"{}\",\n  })\n\n  it(\"propagates each tool's R into the resulting Stream's requirements\", () => {\n    const stream = Toolkit.executeAll([getWeather, getCoords], [])\n    expectTypeOf(stream).toEqualTypeOf<\n      Stream.Stream<import(\"./ToolEvent.js\").ToolEvent, never, WeatherApiKey | GeoApiKey>\n    >()\n  })\n\n  it(\"runs each tool with its own service injected\", async () => {\n    const layer = Layer.mergeAll(\n      Layer.succeed(WeatherApiKey, { key: \"weather-123\" }),\n      Layer.succeed(GeoApiKey, { key: \"geo-456\" }),\n    )\n\n    const program = Toolkit.executeAll(\n      [getWeather, getCoords],\n      [call(\"get_weather\", \"c1\"), call(\"get_coords\", \"c2\")],\n    ).pipe(Stream.runCollect, Effect.provide(layer))\n\n    const events = await Effect.runPromise(program)\n    const outputs = Array.from(events).filter(isOutput)\n    const byCall = new Map(outputs.map((e) => [e.result.call_id, e.result]))\n\n    const w = byCall.get(\"c1\")\n    const g = byCall.get(\"c2\")\n    expect(w !== undefined && isValue(w) && w.value).toEqual({\n      source: \"weather\",\n      key: \"weather-123\",\n    })\n    expect(g !== undefined && isValue(g) && g.value).toEqual({\n      source: \"geo\",\n      key: \"geo-456\",\n    })\n  })\n\n  it(\"with no service-needing tools, R is never\", () => {\n    const plain = Tool.make({\n      name: \"plain\",\n      description: \"\",\n      inputSchema: Tool.fromEffectSchema(Empty),\n      run: () => Effect.succeed(0),\n    })\n    const stream = Toolkit.executeAll([plain], [])\n    expectTypeOf(stream).toEqualTypeOf<\n      Stream.Stream<import(\"./ToolEvent.js\").ToolEvent, never, never>\n    >()\n  })\n})\n"],"mappings":"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"}

package/dist/transcriber/Transcriber.d.mts

@@ -0,0 +1,101 @@
+import { t as AiError } from "../AiError-csR8Bhxx.mjs";
+import { a as AudioSource, r as AudioFormat } from "../Audio-BfCTGnH3.mjs";
+import { TranscriptEvent, TranscriptResult } from "../domain/Transcript.mjs";
+import { Context, Effect, Stream } from "effect";
+
+//#region src/transcriber/Transcriber.d.ts
+declare namespace Transcriber_d_exports {
+  export { CommonStreamTranscribeRequest, CommonTranscribeRequest, SttStreaming, Transcriber, TranscriberService, streamTranscriptionFrom, transcribe };
+}
+/**
+ * Cross-provider sync transcription request. Provider-specific
+ * extensions (Deepgram `keyterm[]`, ElevenLabs `diarize`, Google
+ * `adaptation`, …) live on each provider's typed request which extends
+ * this and narrows `model`.
+ */
+type CommonTranscribeRequest = {
+  readonly audio: AudioSource; /** Model identifier. Each provider narrows to its typed literal union. */
+  readonly model: string; /** ISO-639-1 / BCP-47. Omit for autodetection (where supported). */
+  readonly language?: string;
+  /**
+   * Vocab biasing. Single-string covers OpenAI/Whisper-style prompts;
+   * `terms[]` covers Deepgram `keyterm`, Google adaptation phrases, AWS
+   * `vocabularyName`. Providers ignore what they don't support.
+   */
+  readonly prompt?: string | {
+    readonly terms: ReadonlyArray<string>;
+  };
+  readonly diarization?: boolean;
+  readonly wordTimestamps?: boolean;
+};
+/**
+ * Streaming-transcription request. `inputFormat` declares what the
+ * bytes in the input stream will look like — providers reject
+ * mismatches at stream startup with `AiError.InvalidRequest`.
+ */
+type CommonStreamTranscribeRequest = Omit<CommonTranscribeRequest, "audio"> & {
+  readonly inputFormat: AudioFormat;
+  readonly interimResults?: boolean;
+  readonly vadEvents?: boolean;
+};
+type TranscriberService = {
+  /**
+   * One-shot transcription. Universal — AWS Transcribe (which has no
+   * native sync endpoint) emulates this by draining a streaming session
+   * internally.
+   */
+  readonly transcribe: (request: CommonTranscribeRequest) => Effect.Effect<TranscriptResult, AiError>;
+  /**
+   * Live transcription as a Stream transformer. Consumes audio bytes
+   * from `audioIn`; emits `TranscriptEvent`s as they arrive. The
+   * underlying WS / gRPC connection is acquired on first pull and
+   * released when the output stream is finalized (success, failure, or
+   * interruption) via `Stream.scoped` — no explicit Scope handling at
+   * the call site.
+   *
+   * Gated by the `SttStreaming` capability marker on the top-level
+   * helper — providers without streaming-STT support don't ship the
+   * marker, so calls fail at `Effect.provide` with a type error.
+   */
+  readonly streamTranscriptionFrom: <E, R>(audioIn: Stream.Stream<Uint8Array, E, R>, request: CommonStreamTranscribeRequest) => Stream.Stream<TranscriptEvent, AiError | E, R>;
+};
+declare const Transcriber_base: Context.ServiceClass<Transcriber, "@betalyra/effect-uai/Transcriber", TranscriberService>;
+declare class Transcriber extends Transcriber_base {}
+declare const SttStreaming_base: Context.ServiceClass<SttStreaming, "@betalyra/effect-uai/capability/SttStreaming", void>;
+/**
+ * Capability marker — provided by provider layers whose
+ * `streamTranscriptionFrom` is wired up at the wire level. Azure does
+ * not ship it (streaming-STT is SDK-internal). Calling
+ * `streamTranscriptionFrom` while only Azure's Layer is in scope fails
+ * at `Effect.provide` with a type error, not at runtime.
+ *
+ * Phantom — the value is `void`; providers register with
+ * `Layer.succeed(SttStreaming, undefined)`.
+ */
+declare class SttStreaming extends SttStreaming_base {}
+/** One-shot transcription. */
+declare const transcribe: (request: CommonTranscribeRequest) => Effect.Effect<TranscriptResult, AiError, Transcriber>;
+/**
+ * Live transcription. Dual-arity: pipeable (data-last) and direct
+ * (data-first). Requires `SttStreaming` in R — providers without
+ * streaming support are a type error at provide time.
+ *
+ * @example
+ * ```ts
+ * // Pipeable — composes with other Stream operators
+ * mic.frames.pipe(
+ *   Transcriber.streamTranscriptionFrom(req),
+ *   Stream.filter((e) => e._tag === "final"),
+ * )
+ *
+ * // Direct
+ * Transcriber.streamTranscriptionFrom(mic.frames, req)
+ * ```
+ */
+declare const streamTranscriptionFrom: {
+  (request: CommonStreamTranscribeRequest): <E, R>(audioIn: Stream.Stream<Uint8Array, E, R>) => Stream.Stream<TranscriptEvent, AiError | E, R | Transcriber | SttStreaming>;
+  <E, R>(audioIn: Stream.Stream<Uint8Array, E, R>, request: CommonStreamTranscribeRequest): Stream.Stream<TranscriptEvent, AiError | E, R | Transcriber | SttStreaming>;
+};
+//#endregion
+export { CommonStreamTranscribeRequest, CommonTranscribeRequest, SttStreaming, Transcriber, TranscriberService, streamTranscriptionFrom, Transcriber_d_exports as t, transcribe };
+//# sourceMappingURL=Transcriber.d.mts.map

package/dist/transcriber/Transcriber.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Transcriber.d.mts","names":[],"sources":["../../src/transcriber/Transcriber.ts"],"mappings":";;;;;;;;;;;;;;;KAWY,uBAAA;EAAA,SACD,KAAA,EAAO,WAAA;WAEP,KAAA;WAEA,QAAA;EALC;;;;;EAAA,SAWD,MAAA;IAAA,SAA6B,KAAA,EAAO,aAAA;EAAA;EAAA,SACpC,WAAA;EAAA,SACA,cAAA;AAAA;;;;;AAQX;KAAY,6BAAA,GAAgC,IAAA,CAAK,uBAAA;EAAA,SACtC,WAAA,EAAa,WAAA;EAAA,SACb,cAAA;EAAA,SACA,SAAA;AAAA;AAAA,KAGC,kBAAA;EALuB;;;;;EAAA,SAWxB,UAAA,GACP,OAAA,EAAS,uBAAA,KACN,MAAA,CAAO,MAAA,CAAO,gBAAA,EAAkB,OAAA;EAX5B;;;AAGX;;;;;;;;;EAHW,SAwBA,uBAAA,SACP,OAAA,EAAS,MAAA,CAAO,MAAA,CAAO,UAAA,EAAY,CAAA,EAAG,CAAA,GACtC,OAAA,EAAS,6BAAA,KACN,MAAA,CAAO,MAAA,CAAO,eAAA,EAAiB,OAAA,GAAkB,CAAA,EAAG,CAAA;AAAA;AAAA,cAC1D,gBAAA;cAEY,WAAA,SAAoB,gBAAA;AAAA,cAE7B,iBAAA;;;;;;;;;;;cAYS,YAAA,SAAqB,iBAAA;;cAKrB,UAAA,GACX,OAAA,EAAS,uBAAA,KACR,MAAA,CAAO,MAAA,CAAO,gBAAA,EAAkB,OAAA,EAAiB,WAAA;;;;;;;;;;;;;;;;;;cAoBvC,uBAAA;EAAA,CAET,OAAA,EAAS,6BAAA,UAET,OAAA,EAAS,MAAA,CAAO,MAAA,CAAO,UAAA,EAAY,CAAA,EAAG,CAAA,MACnC,MAAA,CAAO,MAAA,CAAO,eAAA,EAAiB,OAAA,GAAkB,CAAA,EAAG,CAAA,GAAI,WAAA,GAAc,YAAA;EAAA,OAEzE,OAAA,EAAS,MAAA,CAAO,MAAA,CAAO,UAAA,EAAY,CAAA,EAAG,CAAA,GACtC,OAAA,EAAS,6BAAA,GACR,MAAA,CAAO,MAAA,CAAO,eAAA,EAAiB,OAAA,GAAkB,CAAA,EAAG,CAAA,GAAI,WAAA,GAAc,YAAA;AAAA"}

package/dist/transcriber/Transcriber.mjs

@@ -0,0 +1,49 @@
+import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+import { Context, Effect, Function, Stream } from "effect";
+//#region src/transcriber/Transcriber.ts
+var Transcriber_exports = /* @__PURE__ */ __exportAll({
+	SttStreaming: () => SttStreaming,
+	Transcriber: () => Transcriber,
+	streamTranscriptionFrom: () => streamTranscriptionFrom,
+	transcribe: () => transcribe
+});
+var Transcriber = class extends Context.Service()("@betalyra/effect-uai/Transcriber") {};
+/**
+* Capability marker — provided by provider layers whose
+* `streamTranscriptionFrom` is wired up at the wire level. Azure does
+* not ship it (streaming-STT is SDK-internal). Calling
+* `streamTranscriptionFrom` while only Azure's Layer is in scope fails
+* at `Effect.provide` with a type error, not at runtime.
+*
+* Phantom — the value is `void`; providers register with
+* `Layer.succeed(SttStreaming, undefined)`.
+*/
+var SttStreaming = class extends Context.Service()("@betalyra/effect-uai/capability/SttStreaming") {};
+/** One-shot transcription. */
+const transcribe = (request) => Effect.flatMap(Transcriber.asEffect(), (t) => t.transcribe(request));
+/**
+* Live transcription. Dual-arity: pipeable (data-last) and direct
+* (data-first). Requires `SttStreaming` in R — providers without
+* streaming support are a type error at provide time.
+*
+* @example
+* ```ts
+* // Pipeable — composes with other Stream operators
+* mic.frames.pipe(
+*   Transcriber.streamTranscriptionFrom(req),
+*   Stream.filter((e) => e._tag === "final"),
+* )
+*
+* // Direct
+* Transcriber.streamTranscriptionFrom(mic.frames, req)
+* ```
+*/
+const streamTranscriptionFrom = Function.dual(2, (audioIn, request) => Stream.unwrap(Effect.gen(function* () {
+	const t = yield* Transcriber.asEffect();
+	yield* SttStreaming.asEffect();
+	return t.streamTranscriptionFrom(audioIn, request);
+})));
+//#endregion
+export { SttStreaming, Transcriber, streamTranscriptionFrom, Transcriber_exports as t, transcribe };
+
+//# sourceMappingURL=Transcriber.mjs.map

package/dist/transcriber/Transcriber.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Transcriber.mjs","names":[],"sources":["../../src/transcriber/Transcriber.ts"],"sourcesContent":["import { Context, Effect, Function, Stream } from \"effect\"\nimport * as AiError from \"../domain/AiError.js\"\nimport type { AudioFormat, AudioSource } from \"../domain/Audio.js\"\nimport type { TranscriptEvent, TranscriptResult } from \"../domain/Transcript.js\"\n\n/**\n * Cross-provider sync transcription request. Provider-specific\n * extensions (Deepgram `keyterm[]`, ElevenLabs `diarize`, Google\n * `adaptation`, …) live on each provider's typed request which extends\n * this and narrows `model`.\n */\nexport type CommonTranscribeRequest = {\n  readonly audio: AudioSource\n  /** Model identifier. Each provider narrows to its typed literal union. */\n  readonly model: string\n  /** ISO-639-1 / BCP-47. Omit for autodetection (where supported). */\n  readonly language?: string\n  /**\n   * Vocab biasing. Single-string covers OpenAI/Whisper-style prompts;\n   * `terms[]` covers Deepgram `keyterm`, Google adaptation phrases, AWS\n   * `vocabularyName`. Providers ignore what they don't support.\n   */\n  readonly prompt?: string | { readonly terms: ReadonlyArray<string> }\n  readonly diarization?: boolean\n  readonly wordTimestamps?: boolean\n}\n\n/**\n * Streaming-transcription request. `inputFormat` declares what the\n * bytes in the input stream will look like — providers reject\n * mismatches at stream startup with `AiError.InvalidRequest`.\n */\nexport type CommonStreamTranscribeRequest = Omit<CommonTranscribeRequest, \"audio\"> & {\n  readonly inputFormat: AudioFormat\n  readonly interimResults?: boolean\n  readonly vadEvents?: boolean\n}\n\nexport type TranscriberService = {\n  /**\n   * One-shot transcription. Universal — AWS Transcribe (which has no\n   * native sync endpoint) emulates this by draining a streaming session\n   * internally.\n   */\n  readonly transcribe: (\n    request: CommonTranscribeRequest,\n  ) => Effect.Effect<TranscriptResult, AiError.AiError>\n  /**\n   * Live transcription as a Stream transformer. Consumes audio bytes\n   * from `audioIn`; emits `TranscriptEvent`s as they arrive. The\n   * underlying WS / gRPC connection is acquired on first pull and\n   * released when the output stream is finalized (success, failure, or\n   * interruption) via `Stream.scoped` — no explicit Scope handling at\n   * the call site.\n   *\n   * Gated by the `SttStreaming` capability marker on the top-level\n   * helper — providers without streaming-STT support don't ship the\n   * marker, so calls fail at `Effect.provide` with a type error.\n   */\n  readonly streamTranscriptionFrom: <E, R>(\n    audioIn: Stream.Stream<Uint8Array, E, R>,\n    request: CommonStreamTranscribeRequest,\n  ) => Stream.Stream<TranscriptEvent, AiError.AiError | E, R>\n}\n\nexport class Transcriber extends Context.Service<Transcriber, TranscriberService>()(\n  \"@betalyra/effect-uai/Transcriber\",\n) {}\n\n/**\n * Capability marker — provided by provider layers whose\n * `streamTranscriptionFrom` is wired up at the wire level. Azure does\n * not ship it (streaming-STT is SDK-internal). Calling\n * `streamTranscriptionFrom` while only Azure's Layer is in scope fails\n * at `Effect.provide` with a type error, not at runtime.\n *\n * Phantom — the value is `void`; providers register with\n * `Layer.succeed(SttStreaming, undefined)`.\n */\nexport class SttStreaming extends Context.Service<SttStreaming, void>()(\n  \"@betalyra/effect-uai/capability/SttStreaming\",\n) {}\n\n/** One-shot transcription. */\nexport const transcribe = (\n  request: CommonTranscribeRequest,\n): Effect.Effect<TranscriptResult, AiError.AiError, Transcriber> =>\n  Effect.flatMap(Transcriber.asEffect(), (t) => t.transcribe(request))\n\n/**\n * Live transcription. Dual-arity: pipeable (data-last) and direct\n * (data-first). Requires `SttStreaming` in R — providers without\n * streaming support are a type error at provide time.\n *\n * @example\n * ```ts\n * // Pipeable — composes with other Stream operators\n * mic.frames.pipe(\n *   Transcriber.streamTranscriptionFrom(req),\n *   Stream.filter((e) => e._tag === \"final\"),\n * )\n *\n * // Direct\n * Transcriber.streamTranscriptionFrom(mic.frames, req)\n * ```\n */\nexport const streamTranscriptionFrom: {\n  (\n    request: CommonStreamTranscribeRequest,\n  ): <E, R>(\n    audioIn: Stream.Stream<Uint8Array, E, R>,\n  ) => Stream.Stream<TranscriptEvent, AiError.AiError | E, R | Transcriber | SttStreaming>\n  <E, R>(\n    audioIn: Stream.Stream<Uint8Array, E, R>,\n    request: CommonStreamTranscribeRequest,\n  ): Stream.Stream<TranscriptEvent, AiError.AiError | E, R | Transcriber | SttStreaming>\n} = Function.dual(\n  2,\n  <E, R>(audioIn: Stream.Stream<Uint8Array, E, R>, request: CommonStreamTranscribeRequest) =>\n    Stream.unwrap(\n      Effect.gen(function* () {\n        const t = yield* Transcriber.asEffect()\n        yield* SttStreaming.asEffect()\n        return t.streamTranscriptionFrom(audioIn, request)\n      }),\n    ),\n)\n"],"mappings":";;;;;;;;;AAiEA,IAAa,cAAb,cAAiC,QAAQ,SAA0C,CACjF,mCACD,CAAC;;;;;;;;;;;AAYF,IAAa,eAAb,cAAkC,QAAQ,SAA6B,CACrE,+CACD,CAAC;;AAGF,MAAa,cACX,YAEA,OAAO,QAAQ,YAAY,UAAU,GAAG,MAAM,EAAE,WAAW,QAAQ,CAAC;;;;;;;;;;;;;;;;;;AAmBtE,MAAa,0BAUT,SAAS,KACX,IACO,SAA0C,YAC/C,OAAO,OACL,OAAO,IAAI,aAAa;CACtB,MAAM,IAAI,OAAO,YAAY,UAAU;AACvC,QAAO,aAAa,UAAU;AAC9B,QAAO,EAAE,wBAAwB,SAAS,QAAQ;EAClD,CACH,CACJ"}

package/dist/transcriber/Transcriber.test.d.mts

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

package/dist/transcriber/Transcriber.test.mjs

@@ -0,0 +1,130 @@
+import { streamTranscriptionFrom, transcribe } from "./Transcriber.mjs";
+import { i as it, n as globalExpect, r as describe, t as import_dist } from "../dist-DV5ISja1.mjs";
+import { layer, layerSyncOnly } from "../testing/MockTranscriber.mjs";
+import { Effect, Stream } from "effect";
+//#region src/transcriber/Transcriber.test.ts
+describe("Transcriber.transcribe", () => {
+	it("returns the scripted TranscriptResult", async () => {
+		const mock = layer({ transcripts: [{
+			text: "hello world",
+			durationSeconds: 1.23
+		}] });
+		const program = transcribe({
+			audio: {
+				_tag: "bytes",
+				bytes: new Uint8Array([0]),
+				mimeType: "audio/wav"
+			},
+			model: "mock-stt"
+		});
+		const result = await Effect.runPromise(program.pipe(Effect.provide(mock.layer)));
+		globalExpect(result.text).toBe("hello world");
+		globalExpect(result.durationSeconds).toBe(1.23);
+	});
+	it("records each transcribe call", async () => {
+		const mock = layer({ transcripts: [{ text: "a" }, { text: "b" }] });
+		const program = Effect.gen(function* () {
+			yield* transcribe({
+				audio: {
+					_tag: "bytes",
+					bytes: new Uint8Array([1]),
+					mimeType: "audio/wav"
+				},
+				model: "m1"
+			});
+			yield* transcribe({
+				audio: {
+					_tag: "bytes",
+					bytes: new Uint8Array([2]),
+					mimeType: "audio/wav"
+				},
+				model: "m2"
+			});
+			return yield* mock.recorder;
+		});
+		globalExpect((await Effect.runPromise(program.pipe(Effect.provide(mock.layer)))).transcribeCalls.map((c) => c.model)).toEqual(["m1", "m2"]);
+	});
+});
+describe("Transcriber capability marker (compile-time)", () => {
+	const sttReq = {
+		model: "mock-stt",
+		inputFormat: {
+			container: "raw",
+			encoding: "pcm_s16le",
+			sampleRate: 16e3
+		}
+	};
+	it("requires `SttStreaming` on the R channel of streamTranscriptionFrom", () => {
+		(0, import_dist.expectTypeOf)(Stream.fromIterable([new Uint8Array([0])]).pipe(streamTranscriptionFrom(sttReq))).toEqualTypeOf();
+	});
+	it("does NOT require `SttStreaming` for sync `transcribe`", () => {
+		(0, import_dist.expectTypeOf)(transcribe({
+			audio: {
+				_tag: "bytes",
+				bytes: new Uint8Array([0]),
+				mimeType: "audio/wav"
+			},
+			model: "m"
+		})).toEqualTypeOf();
+	});
+	it("a sync-only layer leaves `SttStreaming` unsatisfied in R", () => {
+		const syncOnly = layerSyncOnly({});
+		const events = Stream.fromIterable([new Uint8Array([0])]).pipe(streamTranscriptionFrom(sttReq));
+		(0, import_dist.expectTypeOf)(Stream.runDrain(events).pipe(Effect.provide(syncOnly.layer))).toEqualTypeOf();
+	});
+	it("a full layer (with marker) clears R to never", () => {
+		const fullMock = layer({ streams: [[]] });
+		const events = Stream.fromIterable([new Uint8Array([0])]).pipe(streamTranscriptionFrom(sttReq));
+		(0, import_dist.expectTypeOf)(Stream.runDrain(events).pipe(Effect.provide(fullMock.layer))).toEqualTypeOf();
+	});
+});
+describe("Transcriber.streamTranscriptionFrom", () => {
+	const sttReq = {
+		model: "mock-stt",
+		inputFormat: {
+			container: "raw",
+			encoding: "pcm_s16le",
+			sampleRate: 16e3
+		}
+	};
+	it("emits scripted events after draining the input audio stream", async () => {
+		const mock = layer({ streams: [[{
+			_tag: "partial",
+			text: "hello"
+		}, {
+			_tag: "final",
+			text: "hello world"
+		}]] });
+		const events = Stream.fromIterable([new Uint8Array([
+			0,
+			1,
+			2
+		]), new Uint8Array([
+			3,
+			4,
+			5
+		])]).pipe(streamTranscriptionFrom(sttReq));
+		globalExpect(await Effect.runPromise(Stream.runCollect(events).pipe(Effect.provide(mock.layer)))).toEqual([{
+			_tag: "partial",
+			text: "hello"
+		}, {
+			_tag: "final",
+			text: "hello world"
+		}]);
+	});
+	it("works data-first (direct call) as well as pipeable (data-last)", async () => {
+		const mock = layer({ streams: [[{
+			_tag: "final",
+			text: "x"
+		}]] });
+		const events = streamTranscriptionFrom(Stream.fromIterable([new Uint8Array([0])]), sttReq);
+		globalExpect(await Effect.runPromise(Stream.runCollect(events).pipe(Effect.provide(mock.layer)))).toEqual([{
+			_tag: "final",
+			text: "x"
+		}]);
+	});
+});
+//#endregion
+export {};
+
+//# sourceMappingURL=Transcriber.test.mjs.map

package/dist/transcriber/Transcriber.test.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Transcriber.test.mjs","names":["MockTranscriber.layer","Transcriber.transcribe","Transcriber.streamTranscriptionFrom","MockTranscriber.layerSyncOnly"],"sources":["../../src/transcriber/Transcriber.test.ts"],"sourcesContent":["import { Effect, Stream } from \"effect\"\nimport { describe, expect, expectTypeOf, it } from \"vitest\"\nimport type * as AiError from \"../domain/AiError.js\"\nimport type { TranscriptEvent, TranscriptResult } from \"../domain/Transcript.js\"\nimport * as MockTranscriber from \"../testing/MockTranscriber.js\"\nimport * as Transcriber from \"./Transcriber.js\"\n\ndescribe(\"Transcriber.transcribe\", () => {\n  it(\"returns the scripted TranscriptResult\", async () => {\n    const mock = MockTranscriber.layer({\n      transcripts: [{ text: \"hello world\", durationSeconds: 1.23 }],\n    })\n    const program = Transcriber.transcribe({\n      audio: { _tag: \"bytes\", bytes: new Uint8Array([0]), mimeType: \"audio/wav\" },\n      model: \"mock-stt\",\n    })\n    const result = await Effect.runPromise(program.pipe(Effect.provide(mock.layer)))\n    expect(result.text).toBe(\"hello world\")\n    expect(result.durationSeconds).toBe(1.23)\n  })\n\n  it(\"records each transcribe call\", async () => {\n    const mock = MockTranscriber.layer({\n      transcripts: [{ text: \"a\" }, { text: \"b\" }],\n    })\n    const program = Effect.gen(function* () {\n      yield* Transcriber.transcribe({\n        audio: { _tag: \"bytes\", bytes: new Uint8Array([1]), mimeType: \"audio/wav\" },\n        model: \"m1\",\n      })\n      yield* Transcriber.transcribe({\n        audio: { _tag: \"bytes\", bytes: new Uint8Array([2]), mimeType: \"audio/wav\" },\n        model: \"m2\",\n      })\n      return yield* mock.recorder\n    })\n    const rec = await Effect.runPromise(program.pipe(Effect.provide(mock.layer)))\n    expect(rec.transcribeCalls.map((c) => c.model)).toEqual([\"m1\", \"m2\"])\n  })\n})\n\ndescribe(\"Transcriber capability marker (compile-time)\", () => {\n  const sttReq: Transcriber.CommonStreamTranscribeRequest = {\n    model: \"mock-stt\",\n    inputFormat: { container: \"raw\", encoding: \"pcm_s16le\", sampleRate: 16000 },\n  }\n\n  it(\"requires `SttStreaming` on the R channel of streamTranscriptionFrom\", () => {\n    const audio: Stream.Stream<Uint8Array> = Stream.fromIterable([new Uint8Array([0])])\n    const events = audio.pipe(Transcriber.streamTranscriptionFrom(sttReq))\n    expectTypeOf(events).toEqualTypeOf<\n      Stream.Stream<\n        TranscriptEvent,\n        AiError.AiError,\n        Transcriber.Transcriber | Transcriber.SttStreaming\n      >\n    >()\n  })\n\n  it(\"does NOT require `SttStreaming` for sync `transcribe`\", () => {\n    const eff = Transcriber.transcribe({\n      audio: { _tag: \"bytes\", bytes: new Uint8Array([0]), mimeType: \"audio/wav\" },\n      model: \"m\",\n    })\n    expectTypeOf(eff).toEqualTypeOf<\n      Effect.Effect<TranscriptResult, AiError.AiError, Transcriber.Transcriber>\n    >()\n  })\n\n  it(\"a sync-only layer leaves `SttStreaming` unsatisfied in R\", () => {\n    const syncOnly = MockTranscriber.layerSyncOnly({})\n    const audio: Stream.Stream<Uint8Array> = Stream.fromIterable([new Uint8Array([0])])\n    const events = audio.pipe(Transcriber.streamTranscriptionFrom(sttReq))\n    const program = Stream.runDrain(events).pipe(Effect.provide(syncOnly.layer))\n    // `Transcriber` is provided by syncOnly.layer; `SttStreaming` is not.\n    expectTypeOf(program).toEqualTypeOf<\n      Effect.Effect<void, AiError.AiError, Transcriber.SttStreaming>\n    >()\n  })\n\n  it(\"a full layer (with marker) clears R to never\", () => {\n    const fullMock = MockTranscriber.layer({ streams: [[]] })\n    const audio: Stream.Stream<Uint8Array> = Stream.fromIterable([new Uint8Array([0])])\n    const events = audio.pipe(Transcriber.streamTranscriptionFrom(sttReq))\n    const program = Stream.runDrain(events).pipe(Effect.provide(fullMock.layer))\n    expectTypeOf(program).toEqualTypeOf<Effect.Effect<void, AiError.AiError, never>>()\n  })\n})\n\ndescribe(\"Transcriber.streamTranscriptionFrom\", () => {\n  const sttReq: Transcriber.CommonStreamTranscribeRequest = {\n    model: \"mock-stt\",\n    inputFormat: { container: \"raw\", encoding: \"pcm_s16le\", sampleRate: 16000 },\n  }\n\n  it(\"emits scripted events after draining the input audio stream\", async () => {\n    const mock = MockTranscriber.layer({\n      streams: [\n        [\n          { _tag: \"partial\", text: \"hello\" },\n          { _tag: \"final\", text: \"hello world\" },\n        ],\n      ],\n    })\n    const audio = Stream.fromIterable([new Uint8Array([0, 1, 2]), new Uint8Array([3, 4, 5])])\n    const events = audio.pipe(Transcriber.streamTranscriptionFrom(sttReq))\n    const collected = await Effect.runPromise(\n      Stream.runCollect(events).pipe(Effect.provide(mock.layer)),\n    )\n    expect(collected).toEqual([\n      { _tag: \"partial\", text: \"hello\" },\n      { _tag: \"final\", text: \"hello world\" },\n    ])\n  })\n\n  it(\"works data-first (direct call) as well as pipeable (data-last)\", async () => {\n    const mock = MockTranscriber.layer({\n      streams: [[{ _tag: \"final\", text: \"x\" }]],\n    })\n    const audio = Stream.fromIterable([new Uint8Array([0])])\n    const events = Transcriber.streamTranscriptionFrom(audio, sttReq)\n    const out = await Effect.runPromise(Stream.runCollect(events).pipe(Effect.provide(mock.layer)))\n    expect(out).toEqual([{ _tag: \"final\", text: \"x\" }])\n  })\n})\n"],"mappings":"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"}