@effect-uai/core 0.5.2 → 0.7.0

package/src/tool/Toolkit.test.ts

@@ -1,12 +1,12 @@
 import { Context, Effect, Layer, Schema, Stream } from "effect"
 import { describe, expect, expectTypeOf, it } from "vitest"
-import type { FunctionCall } from "../domain/Items.js"
+import type { ToolCall } from "../domain/Items.js"
 import { isOutput } from "./ToolEvent.js"
-import { isValue } from "./Outcome.js"
+import { isOk } from "./ToolResult.js"
 import * as Tool from "./Tool.js"
 import * as Toolkit from "./Toolkit.js"
 
-describe("Toolkit.toDescriptors", () => {
+describe("Tool.toDescriptors", () => {
   const GetWeatherInput = Schema.Struct({ city: Schema.String })
 
   const getWeather = Tool.make({
@@ -17,7 +17,7 @@ describe("Toolkit.toDescriptors", () => {
   })
 
   it("renders the input schema as a JSON Schema document", () => {
-    const [desc] = Toolkit.toDescriptors(Toolkit.make([getWeather]))
+    const [desc] = Tool.toDescriptors([getWeather])
     expect(desc?.name).toBe("get_weather")
     expect(desc?.description).toBe("Look up the current temperature for a city.")
     expect(desc?.inputSchema).toMatchObject({
@@ -41,16 +41,16 @@ describe("Toolkit.toDescriptors", () => {
       inputSchema: Tool.fromEffectSchema(GetWeatherInput),
       run: () => Effect.succeed({}),
     })
-    const [s, l] = Toolkit.toDescriptors(Toolkit.make([strictTool, looseTool]))
+    const [s, l] = Tool.toDescriptors([strictTool, looseTool])
     expect(s?.strict).toBe(true)
     expect(l).not.toHaveProperty("strict")
   })
 })
 
-describe("Toolkit.executeAll - tools with R requirements", () => {
+describe("Toolkit.run - tools with R requirements", () => {
   // Two distinct services, modelling the "typed per-tool context" use case
   // (cf. AI SDK 7's `toolsContext`). In Effect each tool declares its R, the
-  // compiler enforces it, and `executeAll` surfaces the union for the caller
+  // compiler enforces it, and `run` surfaces the union for the caller
   // to provide via Layer.
   type WeatherApiKeyShape = { readonly key: string }
   class WeatherApiKey extends Context.Service<WeatherApiKey, WeatherApiKeyShape>()(
@@ -84,7 +84,7 @@ describe("Toolkit.executeAll - tools with R requirements", () => {
       }),
   })
 
-  const call = (name: string, id: string): FunctionCall => ({
+  const call = (name: string, id: string): ToolCall => ({
     type: "function_call",
     call_id: id,
     name,
@@ -92,7 +92,7 @@ describe("Toolkit.executeAll - tools with R requirements", () => {
   })
 
   it("propagates each tool's R into the resulting Stream's requirements", () => {
-    const stream = Toolkit.executeAll([getWeather, getCoords], [])
+    const stream = Toolkit.run([getWeather, getCoords], [])
     expectTypeOf(stream).toEqualTypeOf<
       Stream.Stream<import("./ToolEvent.js").ToolEvent, never, WeatherApiKey | GeoApiKey>
     >()
@@ -104,7 +104,7 @@ describe("Toolkit.executeAll - tools with R requirements", () => {
       Layer.succeed(GeoApiKey, { key: "geo-456" }),
     )
 
-    const program = Toolkit.executeAll(
+    const program = Toolkit.run(
       [getWeather, getCoords],
       [call("get_weather", "c1"), call("get_coords", "c2")],
     ).pipe(Stream.runCollect, Effect.provide(layer))
@@ -115,11 +115,11 @@ describe("Toolkit.executeAll - tools with R requirements", () => {
 
     const w = byCall.get("c1")
     const g = byCall.get("c2")
-    expect(w !== undefined && isValue(w) && w.value).toEqual({
+    expect(w !== undefined && isOk(w) && w.value).toEqual({
       source: "weather",
       key: "weather-123",
     })
-    expect(g !== undefined && isValue(g) && g.value).toEqual({
+    expect(g !== undefined && isOk(g) && g.value).toEqual({
       source: "geo",
       key: "geo-456",
     })
@@ -132,7 +132,7 @@ describe("Toolkit.executeAll - tools with R requirements", () => {
       inputSchema: Tool.fromEffectSchema(Empty),
       run: () => Effect.succeed(0),
     })
-    const stream = Toolkit.executeAll([plain], [])
+    const stream = Toolkit.run([plain], [])
     expectTypeOf(stream).toEqualTypeOf<
       Stream.Stream<import("./ToolEvent.js").ToolEvent, never, never>
     >()

package/src/tool/Toolkit.ts

@@ -1,66 +1,31 @@
 import { Array as Arr, Effect, Function, Ref, Schema, Stream } from "effect"
 import * as Loop from "../loop/Loop.js"
-import type { FunctionCall } from "../domain/Items.js"
+import type { ToolCall, HistoryItem } from "../domain/Items.js"
+import { appendToHistory, type Turn } from "../domain/Turn.js"
 import {
-  type AnyKindTool,
+  type AnyTool,
   type AnyPlainTool,
   type AnyStreamingTool,
   isStreamingTool,
   type StreamingTool,
   type Tool,
-  type ToolDescriptor,
 } from "./Tool.js"
-import { ToolResult, executionError, rejected } from "./Outcome.js"
+import { ToolResult, executionError, failed, toToolCallOutput } from "./ToolResult.js"
 import { ToolEvent } from "./ToolEvent.js"
 import { isOutput } from "./ToolEvent.js"
 
-export type AnyTool = Tool<string, any, any, any>
-
-export type Toolkit<Tools extends ReadonlyArray<AnyTool>> = {
-  readonly tools: Tools
-}
-
-export 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`.
+ * Used by `run` to surface the services tools need at the recipe level, so
+ * the loop's stream type carries them through to `Effect.provide`.
  */
-export type ToolKindR<Tools extends ReadonlyArray<AnyKindTool<any>>> =
+export type ToolKindR<Tools extends ReadonlyArray<AnyTool<any>>> =
   Tools[number] extends StreamingTool<any, any, any, any, infer R>
     ? R
     : Tools[number] extends Tool<any, any, any, infer R>
       ? R
       : never
 
-export const make = <const Tools extends ReadonlyArray<AnyTool>>(tools: Tools): Toolkit<Tools> => ({
-  tools,
-})
-
-/**
- * Render every tool in a toolkit to a provider-agnostic descriptor.
- * `inputSchema` is the JSON Schema document produced by the tool's
- * Standard Schema converter (draft 2020-12).
- */
-export const toDescriptors = <Tools extends ReadonlyArray<AnyTool>>(
-  toolkit: Toolkit<Tools>,
-): ReadonlyArray<ToolDescriptor> =>
-  toolkit.tools.map((tool) => {
-    const inputSchema = tool.inputSchema["~standard"].jsonSchema.input({
-      target: "draft-2020-12",
-    })
-    return tool.strict !== undefined
-      ? {
-          name: tool.name,
-          description: tool.description,
-          inputSchema,
-          strict: tool.strict,
-        }
-      : { name: tool.name, description: tool.description, inputSchema }
-  })
-
 // ---------------------------------------------------------------------------
 // Tool executor. Streams `ToolEvent`s in real time and dispatches streaming
 // and plain tools uniformly. Policy stays outside this module: callers pass
@@ -72,9 +37,9 @@ export type ExecuteOptions = {
 }
 
 /** Execute every provided call. Approval/rejection policy belongs upstream. */
-export const executeAll = <Tools extends ReadonlyArray<AnyKindTool<any>>>(
+export const run = <Tools extends ReadonlyArray<AnyTool<any>>>(
   tools: Tools,
-  calls: ReadonlyArray<FunctionCall>,
+  calls: ReadonlyArray<ToolCall>,
   options?: ExecuteOptions,
 ): Stream.Stream<ToolEvent, never, ToolKindR<Tools>> =>
   Stream.fromIterable(calls).pipe(
@@ -83,16 +48,16 @@ export const executeAll = <Tools extends ReadonlyArray<AnyKindTool<any>>>(
     }),
   )
 
-const valueResult = (call: FunctionCall, tool: string, value: unknown): ToolResult =>
-  ToolResult.Value({
+const okResult = (call: ToolCall, tool: string, value: unknown): ToolResult =>
+  ToolResult.Ok({
     call_id: call.call_id,
     tool,
     value,
   })
 
 const runOne = <R>(
-  tools: ReadonlyArray<AnyKindTool<R>>,
-  call: FunctionCall,
+  tools: ReadonlyArray<AnyTool<R>>,
+  call: ToolCall,
 ): Stream.Stream<ToolEvent, never, R> => {
   const tool = tools.find((t) => t.name === call.name)
   if (tool === undefined) {
@@ -100,7 +65,7 @@ const runOne = <R>(
     // still execute. LLMs hallucinate tool names; MCP tools come and go.
     return Stream.succeed(
       ToolEvent.Output({
-        result: rejected(call, "unknown_tool", `No tool registered with name "${call.name}"`),
+        result: failed(call, "unknown_tool", `No tool registered with name "${call.name}"`),
       }),
     )
   }
@@ -110,10 +75,7 @@ const runOne = <R>(
 
 const parseJsonUnknown = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown))
 
-const runPlain = <R>(
-  tool: AnyPlainTool<R>,
-  call: FunctionCall,
-): Stream.Stream<ToolEvent, never, R> =>
+const runPlain = <R>(tool: AnyPlainTool<R>, call: ToolCall): Stream.Stream<ToolEvent, never, R> =>
   Stream.fromEffect(
     Effect.gen(function* () {
       const parsed = yield* parseJsonUnknown(call.arguments).pipe(
@@ -127,7 +89,7 @@ const runPlain = <R>(
         return executionError(call, "Tool input failed schema validation")
       }
       const output = yield* tool.run(validated.value)
-      return valueResult(call, tool.name, output)
+      return okResult(call, tool.name, output)
     }).pipe(
       Effect.catchCause(() => Effect.succeed(executionError(call, "Tool execution failed"))),
       Effect.map((result) => ToolEvent.Output({ result })),
@@ -136,7 +98,7 @@ const runPlain = <R>(
 
 const runStreaming = <R>(
   tool: AnyStreamingTool<R>,
-  call: FunctionCall,
+  call: ToolCall,
 ): Stream.Stream<ToolEvent, never, R> =>
   Stream.unwrap(
     Effect.gen(function* () {
@@ -156,13 +118,13 @@ const runStreaming = <R>(
       }
 
       // Real-time: tap each event into a Ref as it flows; emit one
-      // Intermediate per event; then concat one synthetic Output element
+      // Progress per event; then concat one synthetic Output element
       // built from the accumulated Ref via `finalize`.
       const ref = yield* Ref.make<Array<unknown>>([])
-      const intermediates = tool.run(validated.value).pipe(
+      const progress = tool.run(validated.value).pipe(
         Stream.tap((event) => Ref.update(ref, Arr.append(event))),
         Stream.map((data) =>
-          ToolEvent.Intermediate({
+          ToolEvent.Progress({
             call_id: call.call_id,
             tool: tool.name,
             data,
@@ -173,12 +135,12 @@ const runStreaming = <R>(
         Ref.get(ref).pipe(
           Effect.map((events) =>
             ToolEvent.Output({
-              result: valueResult(call, tool.name, tool.finalize(events)),
+              result: okResult(call, tool.name, tool.finalize(events)),
             }),
           ),
         ),
       )
-      return intermediates.pipe(Stream.concat(output))
+      return progress.pipe(Stream.concat(output))
     }),
   ).pipe(
     Stream.catchCause(() =>
@@ -191,35 +153,97 @@ const runStreaming = <R>(
   )
 
 // ---------------------------------------------------------------------------
-// `continueWith` - bridge from a `Stream<ToolEvent>` to the loop's emit
-// shape. Drains the stream to the consumer in real-time, taps every
+// `continueWithResults` - bridge from a `Stream<ToolEvent>` to the loop's
+// emit shape. Drains the stream to the consumer in real-time, taps every
 // `Output` into an internal Ref, and at end-of-stream emits
 // `Loop.next(build(results))`. Recipe never sees the Ref.
 //
-// Dual: data-first `continueWith(stream, build)` and data-last
-// `stream.pipe(continueWith(build))` both work.
+// Dual: data-first `continueWithResults(stream, build)` and data-last
+// `stream.pipe(continueWithResults(build))` both work.
 // ---------------------------------------------------------------------------
 
-export const continueWith: {
+/**
+ * Append a completed turn plus tool results to a state's history, converting
+ * the results to wire-format `ToolCallOutput`s. Curried so it slots directly
+ * into `continueWithResults`:
+ *
+ *   Toolkit.run(tools, calls).pipe(
+ *     Toolkit.continueWithResults(Toolkit.appendToolResults(state, turn)),
+ *   )
+ *
+ * Equivalent to `appendToHistory(state, turn, results.map(toToolCallOutput))`
+ * — the helper just hides the wire-conversion step.
+ */
+export const appendToolResults =
+  <S extends { readonly history: ReadonlyArray<HistoryItem> }>(state: S, turn: Turn) =>
+  (results: ReadonlyArray<ToolResult>): S =>
+    appendToHistory(state, turn, results.map(toToolCallOutput))
+
+/**
+ * Drain a `Stream<ToolEvent>` and return the accumulated `ToolResult`s
+ * from every `Output` event. One-shot — the type is `Effect<results>`,
+ * not a one-element stream — so it composes naturally with `Effect.map`
+ * to build state.
+ *
+ * Counterpart to `continueWithResults`: `continueWithResults` bundles
+ * drain + emit Next into one bridge; this one is the right arm of a
+ * broadcast/fork-and-merge for callers that want to vary the left arm
+ * (e.g., filter/tap ToolEvents before forwarding).
+ */
+export const collectResults = <E, R>(
+  stream: Stream.Stream<ToolEvent, E, R>,
+): Effect.Effect<ReadonlyArray<ToolResult>, E, R> =>
+  stream.pipe(
+    Stream.filter(isOutput),
+    Stream.map((e) => e.result),
+    Stream.runCollect,
+  )
+
+/**
+ * Bridge from a `Stream<ToolEvent>` to the loop's emit shape. Forwards
+ * every ToolEvent downstream as a `Loop.value` and at end-of-stream emits
+ * one `Loop.next(build(results))` carrying the accumulated `ToolResult`s
+ * from terminal `Output` events.
+ *
+ * Conceptually a broadcast fork (one arm passes events through, the other
+ * drains them into a state). Implemented as a single-pass Ref tap + concat
+ * for zero buffering — the broadcast version is observationally equivalent
+ * but holds events in a PubSub until both arms drain. The public primitives
+ * (`Loop.value`, `collectResults`, `Loop.next`) compose the same pattern
+ * when you need to vary an arm.
+ *
+ * Dual: data-first `continueWithResults(stream, build)` and data-last
+ * `stream.pipe(continueWithResults(build))` both work.
+ */
+export const continueWithResults: {
   <S>(
     build: (results: ReadonlyArray<ToolResult>) => S,
   ): <R>(
     stream: Stream.Stream<ToolEvent, never, R>,
-  ) => Stream.Stream<Loop.Event<ToolEvent, S>, never, R>
+  ) => Stream.Stream<Loop.Step<ToolEvent, S>, never, R>
   <S, R>(
     stream: Stream.Stream<ToolEvent, never, R>,
     build: (results: ReadonlyArray<ToolResult>) => S,
-  ): Stream.Stream<Loop.Event<ToolEvent, S>, never, R>
+  ): Stream.Stream<Loop.Step<ToolEvent, S>, never, R>
 } = Function.dual(
   2,
   <S, R>(
     stream: Stream.Stream<ToolEvent, never, R>,
     build: (results: ReadonlyArray<ToolResult>) => S,
-  ): Stream.Stream<Loop.Event<ToolEvent, S>, never, R> =>
-    Loop.nextAfterFold(
-      stream,
-      [] as ReadonlyArray<ToolResult>,
-      (acc, e) => (isOutput(e) ? Arr.append(acc, e.result) : acc),
-      build,
+  ): Stream.Stream<Loop.Step<ToolEvent, S>, never, R> =>
+    Stream.unwrap(
+      Effect.gen(function* () {
+        const ref = yield* Ref.make<ReadonlyArray<ToolResult>>([])
+        const tapped = stream.pipe(
+          Stream.tap((e) =>
+            isOutput(e) ? Ref.update(ref, (acc) => Arr.append(acc, e.result)) : Effect.void,
+          ),
+          Stream.map(Loop.value),
+        )
+        const continuation = Stream.unwrap(
+          Ref.get(ref).pipe(Effect.map((acc) => Loop.next(build(acc)))),
+        )
+        return tapped.pipe(Stream.concat(continuation))
+      }),
     ),
 )

package/src/transcriber/Transcriber.test.ts

@@ -1,4 +1,4 @@
-import { Effect, Stream } from "effect"
+import { Duration, Effect, Stream } from "effect"
 import { describe, expect, expectTypeOf, it } from "vitest"
 import type * as AiError from "../domain/AiError.js"
 import type { TranscriptEvent, TranscriptResult } from "../domain/Transcript.js"
@@ -8,7 +8,7 @@ import * as Transcriber from "./Transcriber.js"
 describe("Transcriber.transcribe", () => {
   it("returns the scripted TranscriptResult", async () => {
     const mock = MockTranscriber.layer({
-      transcripts: [{ text: "hello world", durationSeconds: 1.23 }],
+      transcripts: [{ text: "hello world", duration: Duration.seconds(1.23) }],
     })
     const program = Transcriber.transcribe({
       audio: { _tag: "bytes", bytes: new Uint8Array([0]), mimeType: "audio/wav" },
@@ -16,7 +16,7 @@ describe("Transcriber.transcribe", () => {
     })
     const result = await Effect.runPromise(program.pipe(Effect.provide(mock.layer)))
     expect(result.text).toBe("hello world")
-    expect(result.durationSeconds).toBe(1.23)
+    expect(result.duration).toStrictEqual(Duration.seconds(1.23))
   })
 
   it("records each transcribe call", async () => {

package/src/transcriber/Transcriber.ts

@@ -15,12 +15,13 @@ export type CommonTranscribeRequest = {
   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> }
+  /** Free-form context / style hint (Whisper-style prose). OpenAI honors
+   *  it; providers without a prompt field `warnDropped`. */
+  readonly prompt?: string
+  /** Vocabulary biasing — discrete terms to boost (names, jargon). Maps to
+   *  Deepgram `keyterm`, ElevenLabs `keyterms`, Google `adaptation`,
+   *  Inworld `prompts`; others `warnDropped`. */
+  readonly biasingTerms?: ReadonlyArray<string>
   readonly diarization?: boolean
   readonly wordTimestamps?: boolean
 }
@@ -28,7 +29,9 @@ export type CommonTranscribeRequest = {
 /**
  * Streaming-transcription request. `inputFormat` declares what the
  * bytes in the input stream will look like — providers reject
- * mismatches at stream startup with `AiError.InvalidRequest`.
+ * formats they can't ingest at stream startup with
+ * `AiError.Unsupported` (a per-Layer capability gap, not a wire-shape
+ * mismatch).
  */
 export type CommonStreamTranscribeRequest = Omit<CommonTranscribeRequest, "audio"> & {
   readonly inputFormat: AudioFormat

package/dist/Audio-BfCTGnH3.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Audio-BfCTGnH3.d.mts","names":[],"sources":["../src/domain/Audio.ts"],"mappings":";;;;;;;;;;;;;;KAUY,aAAA;;;;;AAAZ;;;;;KA0BY,WAAA,GACR,QAAA,CAAS,aAAA,IACT,WAAA,CAAY,aAAA,IACZ,UAAA,CAAW,aAAA;AAAA,cAEF,UAAA,GAAc,CAAA,EAAG,WAAA,KAAc,CAAA,IAAK,QAAA,CAAS,aAAA;AAAA,cAC7C,aAAA,GAAiB,CAAA,EAAG,WAAA,KAAc,CAAA,IAAK,WAAA,CAAY,aAAA;AAAA,cAEnD,YAAA,GAAgB,CAAA,EAAG,WAAA,KAAc,CAAA,IAAK,UAAA,CAAW,aAAA;;;;;;;KAQlD,WAAA;EAAA,SACD,SAAA;EAAA,SACA,QAAA;EAAA,SAUA,UAAA,wDA1BK;EAAA,SA4BL,OAAA;EAAA,SACA,QAAA;AAAA;;AA1BX;;;;KAkCY,UAAA;EAAA,SACD,KAAA,EAAO,UAAA;AAAA;;;;;KAON,SAAA;EAAA,SACD,MAAA,EAAQ,WAAA;EAAA,SACR,KAAA,EAAO,UAAA;EAAA,SACP,eAAA;AAAA"}

package/dist/Items-BH8xUkoR.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Items-BH8xUkoR.d.mts","names":[],"sources":["../src/domain/Items.ts"],"mappings":"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"}