@effect-uai/core 0.1.0 → 0.3.0

package/src/tool/Toolkit.test.ts

@@ -1,5 +1,8 @@
-import { Effect, Schema } from "effect"
-import { describe, expect, it } from "vitest"
+import { Context, Effect, Layer, Schema, Stream } from "effect"
+import { describe, expect, expectTypeOf, it } from "vitest"
+import type { FunctionCall } from "../domain/Items.js"
+import { isOutput } from "./ToolEvent.js"
+import { isValue } from "./Outcome.js"
 import * as Tool from "./Tool.js"
 import * as Toolkit from "./Toolkit.js"
 
@@ -43,3 +46,95 @@ describe("Toolkit.toDescriptors", () => {
     expect(l).not.toHaveProperty("strict")
   })
 })
+
+describe("Toolkit.executeAll - 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
+  // to provide via Layer.
+  type WeatherApiKeyShape = { readonly key: string }
+  class WeatherApiKey extends Context.Service<WeatherApiKey, WeatherApiKeyShape>()(
+    "test/WeatherApiKey",
+  ) {}
+
+  type GeoApiKeyShape = { readonly key: string }
+  class GeoApiKey extends Context.Service<GeoApiKey, GeoApiKeyShape>()("test/GeoApiKey") {}
+
+  const Empty = Schema.Struct({})
+
+  const getWeather = Tool.make({
+    name: "get_weather",
+    description: "",
+    inputSchema: Tool.fromEffectSchema(Empty),
+    run: () =>
+      Effect.gen(function* () {
+        const { key } = yield* WeatherApiKey
+        return { source: "weather", key }
+      }),
+  })
+
+  const getCoords = Tool.make({
+    name: "get_coords",
+    description: "",
+    inputSchema: Tool.fromEffectSchema(Empty),
+    run: () =>
+      Effect.gen(function* () {
+        const { key } = yield* GeoApiKey
+        return { source: "geo", key }
+      }),
+  })
+
+  const call = (name: string, id: string): FunctionCall => ({
+    type: "function_call",
+    call_id: id,
+    name,
+    arguments: "{}",
+  })
+
+  it("propagates each tool's R into the resulting Stream's requirements", () => {
+    const stream = Toolkit.executeAll([getWeather, getCoords], [])
+    expectTypeOf(stream).toEqualTypeOf<
+      Stream.Stream<import("./ToolEvent.js").ToolEvent, never, WeatherApiKey | GeoApiKey>
+    >()
+  })
+
+  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 = Toolkit.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")
+    expect(w !== undefined && isValue(w) && w.value).toEqual({
+      source: "weather",
+      key: "weather-123",
+    })
+    expect(g !== undefined && isValue(g) && g.value).toEqual({
+      source: "geo",
+      key: "geo-456",
+    })
+  })
+
+  it("with no service-needing tools, R is never", () => {
+    const plain = Tool.make({
+      name: "plain",
+      description: "",
+      inputSchema: Tool.fromEffectSchema(Empty),
+      run: () => Effect.succeed(0),
+    })
+    const stream = Toolkit.executeAll([plain], [])
+    expectTypeOf(stream).toEqualTypeOf<
+      Stream.Stream<import("./ToolEvent.js").ToolEvent, never, never>
+    >()
+  })
+})

package/src/tool/Toolkit.ts

@@ -1,4 +1,4 @@
-import { Array as Arr, Effect, Match, Ref, Stream } from "effect"
+import { Array as Arr, Effect, Function, Ref, Stream } from "effect"
 import * as Loop from "../loop/Loop.js"
 import type { FunctionCall } from "../domain/Items.js"
 import {
@@ -6,16 +6,11 @@ import {
   type AnyPlainTool,
   type AnyStreamingTool,
   isStreamingTool,
+  type StreamingTool,
   type Tool,
   type ToolDescriptor,
 } from "./Tool.js"
-import {
-  type ToolDecision,
-  type ToolResult,
-  execute as executeDecision,
-  executionError,
-  rejected,
-} from "./Outcome.js"
+import { type ToolResult, executionError, rejected } from "./Outcome.js"
 import type { ToolEvent } from "./ToolEvent.js"
 import { isOutput } from "./ToolEvent.js"
 
@@ -28,6 +23,18 @@ export type Toolkit<Tools extends ReadonlyArray<AnyTool>> = {
 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`.
+ */
+export 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
+
 export const make = <const Tools extends ReadonlyArray<AnyTool>>(tools: Tools): Toolkit<Tools> => ({
   tools,
 })
@@ -50,56 +57,31 @@ export const toDescriptors = <Tools extends ReadonlyArray<AnyTool>>(
   })
 
 // ---------------------------------------------------------------------------
-// Resolver-based executor. Streams `ToolEvent`s in real time, dispatches
-// streaming and plain tools uniformly, and lets the caller decide what
-// happens to each call (Execute or Reject) before execution.
-//
-// `executeAllWithResolver` is the general primitive. `executeAllStream` is
-// the no-resolver shortcut.
+// Tool executor. Streams `ToolEvent`s in real time and dispatches streaming
+// and plain tools uniformly. Policy stays outside this module: callers pass
+// only the calls they have already decided should run.
 // ---------------------------------------------------------------------------
 
-export type Resolver = (call: FunctionCall) => Effect.Effect<ToolDecision>
-
-export interface ExecuteOptions {
+export type ExecuteOptions = {
   readonly concurrency?: number | "unbounded"
 }
 
-export const executeAllWithResolver = (
-  tools: ReadonlyArray<AnyKindTool>,
+/** Execute every provided call. Approval/rejection policy belongs upstream. */
+export const executeAll = <Tools extends ReadonlyArray<AnyKindTool<any>>>(
+  tools: Tools,
   calls: ReadonlyArray<FunctionCall>,
-  resolve: Resolver,
   options?: ExecuteOptions,
-): Stream.Stream<ToolEvent> =>
+): Stream.Stream<ToolEvent, never, ToolKindR<Tools>> =>
   Stream.fromIterable(calls).pipe(
-    Stream.flatMap(
-      (call) =>
-        Stream.unwrap(
-          resolve(call).pipe(Effect.map((decision) => dispatch(tools, call, decision))),
-        ),
-      { concurrency: options?.concurrency ?? "unbounded" },
-    ),
+    Stream.flatMap((call) => runOne(tools, call), {
+      concurrency: options?.concurrency ?? "unbounded",
+    }),
   )
 
-/** No-resolver shortcut: every call gets `Execute`. */
-export const executeAll = (
-  tools: ReadonlyArray<AnyKindTool>,
-  calls: ReadonlyArray<FunctionCall>,
-  options?: ExecuteOptions,
-): Stream.Stream<ToolEvent> =>
-  executeAllWithResolver(tools, calls, () => Effect.succeed(executeDecision), options)
+export const outputEvent = (result: ToolResult): ToolEvent => ({ _tag: "Output", result })
 
-const dispatch = (
-  tools: ReadonlyArray<AnyKindTool>,
-  call: FunctionCall,
-  decision: ToolDecision,
-): Stream.Stream<ToolEvent> =>
-  Match.value(decision).pipe(
-    Match.tag("Execute", () => runOne(tools, call)),
-    Match.tag("Reject", (d) =>
-      Stream.succeed<ToolEvent>({ _tag: "Output", result: d.result }),
-    ),
-    Match.exhaustive,
-  )
+export const outputEvents = (results: ReadonlyArray<ToolResult>): Stream.Stream<ToolEvent> =>
+  Stream.fromIterable(results.map(outputEvent))
 
 const valueResult = (call: FunctionCall, tool: string, value: unknown): ToolResult => ({
   _tag: "Value",
@@ -108,10 +90,10 @@ const valueResult = (call: FunctionCall, tool: string, value: unknown): ToolResu
   value,
 })
 
-const runOne = (
-  tools: ReadonlyArray<AnyKindTool>,
+const runOne = <R>(
+  tools: ReadonlyArray<AnyKindTool<R>>,
   call: FunctionCall,
-): Stream.Stream<ToolEvent> => {
+): Stream.Stream<ToolEvent, never, R> => {
   const tool = tools.find((t) => t.name === call.name)
   if (tool === undefined) {
     // Graceful: emit a synthetic Failure so OTHER calls in this turn
@@ -125,10 +107,10 @@ const runOne = (
   return runPlain(tool, call)
 }
 
-const runPlain = (
-  tool: AnyPlainTool,
+const runPlain = <R>(
+  tool: AnyPlainTool<R>,
   call: FunctionCall,
-): Stream.Stream<ToolEvent> =>
+): Stream.Stream<ToolEvent, never, R> =>
   Stream.fromEffect(
     Effect.gen(function* () {
       const parsed = yield* Effect.try({
@@ -150,10 +132,10 @@ const runPlain = (
     ),
   )
 
-const runStreaming = (
-  tool: AnyStreamingTool,
+const runStreaming = <R>(
+  tool: AnyStreamingTool<R>,
   call: FunctionCall,
-): Stream.Stream<ToolEvent> =>
+): Stream.Stream<ToolEvent, never, R> =>
   Stream.unwrap(
     Effect.gen(function* () {
       const parsed = yield* Effect.try({
@@ -210,19 +192,35 @@ const runStreaming = (
   )
 
 // ---------------------------------------------------------------------------
-// `nextStateFrom` - bridge from a `Stream<ToolEvent>` to the loop's emit
+// `continueWith` - 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.
 // ---------------------------------------------------------------------------
 
-export const nextStateFrom = <S>(
-  stream: Stream.Stream<ToolEvent>,
-  build: (results: ReadonlyArray<ToolResult>) => S,
-): Stream.Stream<Loop.Event<ToolEvent, S>> =>
-  Loop.nextAfterFold(
-    stream,
-    [] as ReadonlyArray<ToolResult>,
-    (acc, e) => (isOutput(e) ? Arr.append(acc, e.result) : acc),
-    build,
-  )
+export const continueWith: {
+  <S>(
+    build: (results: ReadonlyArray<ToolResult>) => S,
+  ): <R>(
+    stream: Stream.Stream<ToolEvent, never, R>,
+  ) => Stream.Stream<Loop.Event<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>
+} = 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,
+    ),
+)

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

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

package/dist/Loop-CzSJo1h8.d.mts

@@ -1,87 +0,0 @@
-import { l as IncompleteTurn } from "./AiError-CqmYjXyx.mjs";
-import { a as TurnEvent, i as Turn } from "./Turn-rlTfuHaQ.mjs";
-import { Data, Effect, Stream } from "effect";
-
-//#region src/loop/Loop.d.ts
-declare namespace Loop_d_exports {
-  export { Event, loop, next, nextAfter, nextAfterFold, stop, stopAfter, stopEvent, streamUntilComplete, value };
-}
-/**
- * The tagged union a body emits per pull. `Value` carries a payload that
- * flows downstream. `Next` ends the current iteration and continues with a
- * new state. `Stop` ends the loop entirely.
- */
-type Event<A, S> = Data.TaggedEnum<{
-  Value: {
-    readonly value: A;
-  };
-  Next: {
-    readonly state: S;
-  };
-  Stop: {};
-}>;
-/** Wrap a value so it flows through the loop to downstream consumers. */
-declare const value: <A>(a: A) => Event<A, never>;
-/** End the current iteration and continue with a new state. */
-declare const next: <S>(state: S) => Event<never, S>;
-/** The terminal `Stop` event. Use `stop` (the Stream) to end a loop body. */
-declare const stopEvent: Event<never, never>;
-/**
- * A single-element stream that ends the loop. Return this from a body when
- * there's nothing else to emit; equivalent to `stopAfter(Stream.empty)` but
- * named for the common case.
- */
-declare const stop: Stream.Stream<Event<never, never>>;
-/**
- * Pipe a raw `Stream<A>` into the loop's emit shape, then terminate the
- * iteration with `next(state)`. Common shape for "stream this turn's
- * deltas, then continue with updated history."
- */
-declare const nextAfter: <S, A, E, R>(stream: Stream.Stream<A, E, R>, state: S) => Stream.Stream<Event<A, S>, E, R>;
-/**
- * Pipe a raw `Stream<A>` into the loop's emit shape, then terminate the
- * loop. Common shape for "stream this turn's deltas, then we're done."
- */
-declare const stopAfter: <A, E, R>(stream: Stream.Stream<A, E, R>) => Stream.Stream<Event<A, never>, E, R>;
-/**
- * General `nextAfter` variant: drain `stream` to the consumer, fold elements
- * into an accumulator, and at end-of-stream emit one `next(build(finalAcc))`.
- *
- * Subsumes `nextAfter` when state is constant (`reduce: (s, _) => s`,
- * `build: (s) => s`). Used by `Toolkit.nextStateFrom` to collect tool
- * results and build next state without exposing a Ref to recipes.
- */
-declare const nextAfterFold: <A, B, S, E, R>(stream: Stream.Stream<A, E, R>, initial: B, reduce: (acc: B, a: A) => B, build: (b: B) => S) => Stream.Stream<Event<A, S>, E, R>;
-/**
- * Lift a provider's `Stream<TurnEvent>` into a loop body's `Stream<Event<TurnEvent | A, S>>`.
- * Each delta passes through as `value(delta)` (including the terminal
- * `turn_complete`, so the consumer sees turn boundaries naturally). Once
- * the terminal arrives, `then(turn)` runs and its returned stream of loop
- * events (typically tool outputs followed by `next(state)` or `stop`) is
- * concatenated.
- *
- * Pre-pipe transforms (`Stream.tap` / `Stream.map` / `Stream.filter`) on
- * the raw delta stream cover anything an `emit`-style callback would do.
- *
- * If the upstream ends without a `turn_complete`, the resulting stream
- * fails with `AiError.IncompleteTurn`. Catch it via `Stream.catchTag` if
- * you want to recover.
- */
-declare const streamUntilComplete: <S, A, E2 = never, R2 = never>(then: (turn: Turn) => Effect.Effect<Stream.Stream<Event<A, S>, E2, R2>, E2, R2>) => <E, R>(deltas: Stream.Stream<TurnEvent, E, R>) => Stream.Stream<Event<TurnEvent | A, S>, E | E2 | IncompleteTurn, R | R2>;
-type LoopBody<S, A, E, R> = (state: S) => Stream.Stream<Event<A, S>, E, R> | Effect.Effect<Stream.Stream<Event<A, S>, E, R>, E, R>;
-/**
- * Drive a state-threaded loop body. Each iteration runs `body(state)` to get
- * a `Stream<Event<A, S>>`; values flow downstream, `next(s)` continues with
- * a new state, `stop` ends the loop. See the file header for the full
- * pull-based execution model.
- *
- * Dual: data-first `loop(initial, body)` and data-last `loop(body)(initial)`
- * (or `pipe(initial, loop(body))`) both work.
- */
-declare const loop: {
-  <S, A, E, R>(body: LoopBody<S, A, E, R>): (initial: S) => Stream.Stream<A, E, R>;
-  <S, A, E, R>(initial: S, body: LoopBody<S, A, E, R>): Stream.Stream<A, E, R>;
-};
-//#endregion
-export { nextAfter as a, stopAfter as c, value as d, next as i, stopEvent as l, Loop_d_exports as n, nextAfterFold as o, loop as r, stop as s, Event as t, streamUntilComplete as u };
-//# sourceMappingURL=Loop-CzSJo1h8.d.mts.map

package/dist/Loop-CzSJo1h8.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Loop-CzSJo1h8.d.mts","names":[],"sources":["../src/loop/Loop.ts"],"mappings":";;;;;;;;;;;;;KAgCY,KAAA,SAAc,IAAA,CAAK,UAAA;EAC7B,KAAA;IAAA,SAAkB,KAAA,EAAO,CAAA;EAAA;EACzB,IAAA;IAAA,SAAiB,KAAA,EAAO,CAAA;EAAA;EACxB,IAAA;AAAA;;cAUW,KAAA,MAAY,CAAA,EAAG,CAAA,KAAI,KAAA,CAAM,CAAA;;cAGzB,IAAA,MAAW,KAAA,EAAO,CAAA,KAAI,KAAA,QAAa,CAAA;;cAGnC,SAAA,EAAW,KAAA;;;;;;cAOX,IAAA,EAAM,MAAA,CAAO,MAAA,CAAO,KAAA;;;;;;cAOpB,SAAA,eACX,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA,EAAG,CAAA,GAC5B,KAAA,EAAO,CAAA,KACN,MAAA,CAAO,MAAA,CAAO,KAAA,CAAM,CAAA,EAAG,CAAA,GAAI,CAAA,EAAG,CAAA;AApBjC;;;;AAAA,cA2Ba,SAAA,YACX,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA,EAAG,CAAA,MAC3B,MAAA,CAAO,MAAA,CAAO,KAAA,CAAM,CAAA,UAAW,CAAA,EAAG,CAAA;;;;;;;;;cAWxB,aAAA,kBACX,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA,EAAG,CAAA,GAC5B,OAAA,EAAS,CAAA,EACT,MAAA,GAAS,GAAA,EAAK,CAAA,EAAG,CAAA,EAAG,CAAA,KAAM,CAAA,EAC1B,KAAA,GAAQ,CAAA,EAAG,CAAA,KAAM,CAAA,KAChB,MAAA,CAAO,MAAA,CAAO,KAAA,CAAM,CAAA,EAAG,CAAA,GAAI,CAAA,EAAG,CAAA;;AA1CjC;;;;;AAOA;;;;;;;;;cAqEa,mBAAA,iCAET,IAAA,GAAO,IAAA,EAAM,IAAA,KAAS,MAAA,CAAO,MAAA,CAAO,MAAA,CAAO,MAAA,CAAO,KAAA,CAAM,CAAA,EAAG,CAAA,GAAI,EAAA,EAAI,EAAA,GAAK,EAAA,EAAI,EAAA,aAG5E,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,SAAA,EAAW,CAAA,EAAG,CAAA,MACnC,MAAA,CAAO,MAAA,CAAO,KAAA,CAAM,SAAA,GAAY,CAAA,EAAG,CAAA,GAAI,CAAA,GAAI,EAAA,GAAK,cAAA,EAAgB,CAAA,GAAI,EAAA;AAAA,KAkEpE,QAAA,gBACH,KAAA,EAAO,CAAA,KACJ,MAAA,CAAO,MAAA,CAAO,KAAA,CAAM,CAAA,EAAG,CAAA,GAAI,CAAA,EAAG,CAAA,IAAK,MAAA,CAAO,MAAA,CAAO,MAAA,CAAO,MAAA,CAAO,KAAA,CAAM,CAAA,EAAG,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,CAAA,EAAG,CAAA;;;;;;;;;;cAW9E,IAAA;EAAA,aACE,IAAA,EAAM,QAAA,CAAS,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,CAAA,KAAM,OAAA,EAAS,CAAA,KAAM,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA,EAAG,CAAA;EAAA,aACjE,OAAA,EAAS,CAAA,EAAG,IAAA,EAAM,QAAA,CAAS,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,CAAA,IAAK,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA,EAAG,CAAA;AAAA"}

package/dist/Outcome-C2JYknCu.d.mts

@@ -1,40 +0,0 @@
-import { o as FunctionCall, s as FunctionCallOutput } from "./Items-D1C2686t.mjs";
-
-//#region src/tool/Outcome.d.ts
-type ToolResult = {
-  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;
-};
-declare const isValue: (r: ToolResult) => r is Extract<ToolResult, {
-  _tag: "Value";
-}>;
-declare const isFailure: (r: ToolResult) => r is Extract<ToolResult, {
-  _tag: "Failure";
-}>;
-type ToolDecision = {
-  readonly _tag: "Execute";
-} | {
-  readonly _tag: "Reject";
-  readonly result: ToolResult;
-};
-declare const execute: ToolDecision;
-declare const reject: (result: ToolResult) => ToolDecision;
-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 { execute as a, isValue as c, toFunctionCallOutput as d, denied as i, reject as l, ToolResult as n, executionError as o, cancelled as r, isFailure as s, ToolDecision as t, rejected as u };
-//# sourceMappingURL=Outcome-C2JYknCu.d.mts.map

package/dist/Outcome-C2JYknCu.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Outcome-C2JYknCu.d.mts","names":[],"sources":["../src/tool/Outcome.ts"],"mappings":";;;KAsBY,UAAA;EAAA,SAEG,IAAA;EAAA,SACA,OAAA;EAAA,SACA,IAAA;EAAA,SACA,KAAA;AAAA;EAAA,SAGA,IAAA;EAAA,SACA,OAAA;EAAA,SACA,IAAA;EAAA,SACA,IAAA;EAAA,SACA,MAAA;AAAA;AAAA,cAGF,OAAA,GAAW,CAAA,EAAG,UAAA,KAAa,CAAA,IAAK,OAAA,CAAQ,UAAA;EAAc,IAAA;AAAA;AAAA,cAGtD,SAAA,GAAa,CAAA,EAAG,UAAA,KAAa,CAAA,IAAK,OAAA,CAAQ,UAAA;EAAc,IAAA;AAAA;AAAA,KAOzD,YAAA;EAAA,SACG,IAAA;AAAA;EAAA,SACA,IAAA;EAAA,SAAyB,MAAA,EAAQ,UAAA;AAAA;AAAA,cAEnC,OAAA,EAAS,YAAA;AAAA,cAET,MAAA,GAAU,MAAA,EAAQ,UAAA,KAAa,YAAA;AAAA,cAO/B,QAAA,GACX,IAAA,EAAM,YAAA,EACN,IAAA,UACA,MAAA,cACC,UAAA;;cASU,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/StructuredFormat-B5ueioNr.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"StructuredFormat-B5ueioNr.d.mts","names":[],"sources":["../src/structured-format/StructuredFormat.ts"],"mappings":";;;;;;;;;;;;;;;KAaY,gBAAA,qBAAqC,gBAAA,UAA0B,MAAA,IACzE,oBAAA,UAA8B,MAAA;;;;;;UAOf,gBAAA;EAAA,SACN,IAAA;EAAA,SACA,WAAA;EAAA,SACA,MAAA,EAAQ,gBAAA,CAAiB,CAAA;EAXxB;;;;EAAA,SAgBD,MAAA;AAAA;;UAIM,WAAA;EAAA,SACN,IAAA,EAAM,aAAA;EAAA,SACN,OAAA;AAAA;AAAA,cACV,0BAAA;;;;;AAfD;;cAyBa,qBAAA,SAA8B,0BAAA;EAAA,SAChC,GAAA;EAAA,SACA,MAAA,EAAQ,aAAA,CAAc,WAAA;AAAA;AAAA,cAC5B,mBAAA;;;;;;AAhBL;cAsBa,cAAA,SAAuB,mBAAA;EAAA,SACzB,GAAA;EAAA,SACA,KAAA;AAAA;;;;AArBV;;cAiCY,gBAAA,aAA8B,MAAA,CAAO,KAAA,wBAChD,MAAA,EAAQ,CAAA,EACR,OAAA;EAAA,SACW,IAAA;EAAA,SACA,WAAA;EAAA,SACA,MAAA;AAAA,MAEV,gBAAA,CAAiB,CAAA;;;;;;cAyCP,MAAA,MACP,MAAA,EAAQ,gBAAA,CAAiB,CAAA,OAC5B,GAAA,cAAe,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,qBAAA;;;;;;cAoBtB,SAAA,MACP,MAAA,EAAQ,gBAAA,CAAiB,CAAA,OAC5B,GAAA,aAAc,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,cAAA,GAAiB,qBAAA;;;;;cAatC,eAAA,MACP,MAAA,EAAQ,gBAAA,CAAiB,CAAA,aAE3B,IAAA,EAAM,MAAA,CAAO,MAAA,SAAe,CAAA,EAAG,CAAA,MAC9B,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA,GAAI,cAAA,GAAiB,qBAAA,EAAuB,CAAA"}

package/dist/Tool-5wxOCuOh.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Tool-5wxOCuOh.d.mts","names":[],"sources":["../src/tool/Tool.ts"],"mappings":";;;;;;;;;cAE0E,cAAA;;;;;;cAG7D,SAAA,SAAkB,cAAA;;;;;;;;;;KAmBnB,eAAA,oBAAmC,gBAAA,UAA0B,KAAA,IACvE,oBAAA,UAA8B,KAAA;;;AAvB0C;;;cA8B7D,gBAAA,aAA8B,MAAA,CAAO,KAAA,wBAChD,MAAA,EAAQ,CAAA,KACP,CAAA,GAAI,eAAA,CAAgB,CAAA;AAAA,UAIN,IAAA;EAAA,SACN,IAAA,EAAM,IAAA;EAAA,SACN,WAAA;EAAA,SACA,WAAA,EAAa,eAAA,CAAgB,KAAA;EAAA,SAC7B,GAAA,GAAM,KAAA,EAAO,KAAA,KAAU,MAAA,CAAO,MAAA,CAAO,MAAA,WAAiB,CAAA;;;;;;;WAOtD,MAAA;AAAA;;;;;;UAQM,cAAA;EAAA,SACN,IAAA;EAAA,SACA,WAAA;EAAA,SACA,WAAA,EAAa,MAAA;EAAA,SACb,MAAA;AAAA;AAAA,cAGE,IAAA,kDACX,IAAA,EAAM,IAAA,CAAK,IAAA,EAAM,KAAA,EAAO,MAAA,EAAQ,CAAA,MAC/B,IAAA,CAAK,IAAA,EAAM,KAAA,EAAO,MAAA,EAAQ,CAAA;AAAA,UAWZ,aAAA;EAAA,SACN,KAAA;EAAA,SACA,IAAA,EAAM,IAAA;EAAA,SACN,WAAA;EAAA,SACA,WAAA,EAAa,eAAA,CAAgB,KAAA;EAAA,SAC7B,GAAA,GAAM,KAAA,EAAO,KAAA,KAAU,MAAA,CAAO,MAAA,CAAO,KAAA,WAAgB,CAAA;EAAA,SACrD,QAAA,GAAW,MAAA,EAAQ,aAAA,CAAc,KAAA,MAAW,MAAA;EAAA,SAC5C,MAAA;AAAA;AAAA,cAGE,SAAA,yDACX,IAAA,EAAM,IAAA,CAAK,aAAA,CAAc,IAAA,EAAM,KAAA,EAAO,KAAA,EAAO,MAAA,EAAQ,CAAA,gBACpD,aAAA,CAAc,IAAA,EAAM,KAAA,EAAO,KAAA,EAAO,MAAA,EAAQ,CAAA;AAAA,KAEjC,gBAAA,GAAmB,aAAA;AAAA,KACnB,YAAA,GAAe,IAAA;AAAA,KACf,WAAA,GAAc,gBAAA,GAAmB,YAAA;AAAA,cAEhC,eAAA,GAAmB,CAAA,EAAG,WAAA,KAAc,CAAA,IAAK,gBAAA;;;;;;cAQzC,aAAA,GACX,KAAA,EAAO,aAAA,CAAc,WAAA,MACpB,aAAA,CAAc,cAAA;;;;;;cAkBJ,OAAA,0CACX,IAAA,EAAM,IAAA,CAAK,IAAA,EAAM,KAAA,EAAO,MAAA,EAAQ,CAAA,GAChC,IAAA,EAAM,YAAA,KACL,MAAA,CAAO,MAAA,CAAO,kBAAA,EAAoB,SAAA,EAAW,CAAA"}

package/dist/ToolEvent-B2N10hr3.d.mts

@@ -1,29 +0,0 @@
-import { n as ToolResult } from "./Outcome-C2JYknCu.mjs";
-
-//#region src/tool/ToolEvent.d.ts
-type ToolEvent = {
-  readonly _tag: "ApprovalRequested";
-  readonly call_id: string;
-  readonly tool: string;
-  readonly arguments: string;
-} | {
-  readonly _tag: "Intermediate";
-  readonly call_id: string;
-  readonly tool: string;
-  readonly data: unknown;
-} | {
-  readonly _tag: "Output";
-  readonly result: ToolResult;
-};
-declare const isApprovalRequested: (e: ToolEvent) => e is Extract<ToolEvent, {
-  _tag: "ApprovalRequested";
-}>;
-declare const isIntermediate: (e: ToolEvent) => e is Extract<ToolEvent, {
-  _tag: "Intermediate";
-}>;
-declare const isOutput: (e: ToolEvent) => e is Extract<ToolEvent, {
-  _tag: "Output";
-}>;
-//#endregion
-export { isOutput as i, isApprovalRequested as n, isIntermediate as r, ToolEvent as t };
-//# sourceMappingURL=ToolEvent-B2N10hr3.d.mts.map

package/dist/ToolEvent-B2N10hr3.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ToolEvent-B2N10hr3.d.mts","names":[],"sources":["../src/tool/ToolEvent.ts"],"mappings":";;;KAYY,SAAA;EAAA,SAEG,IAAA;EAAA,SACA,OAAA;EAAA,SACA,IAAA;EAAA,SACA,SAAA;AAAA;EAAA,SAGA,IAAA;EAAA,SACA,OAAA;EAAA,SACA,IAAA;EAAA,SACA,IAAA;AAAA;EAAA,SAEA,IAAA;EAAA,SAAyB,MAAA,EAAQ,UAAA;AAAA;AAAA,cAEnC,mBAAA,GACX,CAAA,EAAG,SAAA,KACF,CAAA,IAAK,OAAA,CAAQ,SAAA;EAAa,IAAA;AAAA;AAAA,cAEhB,cAAA,GACX,CAAA,EAAG,SAAA,KACF,CAAA,IAAK,OAAA,CAAQ,SAAA;EAAa,IAAA;AAAA;AAAA,cAEhB,QAAA,GAAY,CAAA,EAAG,SAAA,KAAY,CAAA,IAAK,OAAA,CAAQ,SAAA;EAAa,IAAA;AAAA"}

package/dist/Turn-rlTfuHaQ.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Turn-rlTfuHaQ.d.mts","names":[],"sources":["../src/domain/Turn.ts"],"mappings":";;;;;;;;;;;;;;;cAmBa,IAAA,EAAI,MAAA,CAAA,MAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAKL,IAAA,UAAc,IAAA,CAAK,IAAA;;;;;;;KAQnB,SAAA;EAAA,SACG,IAAA;EAAA,SAA6B,IAAA;AAAA;EAAA,SAE7B,IAAA;EAAA,SACA,IAAA;;;;;;;;WAQA,IAAA;AAAA;;;;;;;;;WASA,IAAA;EAAA,SAAgC,IAAA;AAAA;EAAA,SAChC,IAAA;EAAA,SAAkC,OAAA;EAAA,SAA0B,IAAA;AAAA;EAAA,SAC5D,IAAA;EAAA,SAAuC,OAAA;EAAA,SAA0B,KAAA;AAAA;;;;;;;;;;WASjE,IAAA;EAAA,SAA+B,KAAA,EAAO,KAAA;AAAA;EAAA,SACtC,IAAA;EAAA,SAAgC,IAAA,EAAM,IAAA;AAAA;;;;;;;KAQzC,gBAAA,GAAmB,SAAA,GAAY,kBAAA;AAAA,cAE9B,cAAA,GAAkB,CAAA,EAAG,SAAA,KAAY,CAAA,IAAK,OAAA,CAAQ,SAAA;EAAa,IAAA;AAAA;AAAA,cAG3D,aAAA,GAAiB,IAAA,EAAM,IAAA,KAAO,aAAA,CAAc,YAAA;AAAA,cAG5C,UAAA,GAAc,IAAA,EAAM,IAAA,KAAO,aAAA,CAAc,SAAA;AAAA,cAGzC,iBAAA,GAAqB,IAAA,EAAM,IAAA,KAAO,aAAA,CAAc,OAAA;;;;;;;;;;KAYjD,MAAA,MAAY,CAAA;EAAA,SAAe,IAAA,EAAM,IAAA;AAAA;;;;;cAMhC,MAAA;EAAA,SAA+B,OAAA,EAAS,aAAA,CAAc,IAAA;AAAA,GACjE,KAAA,EAAO,CAAA,EACP,IAAA,EAAM,IAAA,KACL,MAAA,CAAO,CAAA;;;;;;cAeG,UAAA,SACX,IAAA,EAAM,MAAA,CAAO,MAAA,CAAO,SAAA,EAAW,CAAA,EAAG,CAAA,MACjC,MAAA,CAAO,MAAA,SAAe,CAAA,EAAG,CAAA;AAAA,cAKzB,oBAAA;;;;;;;;cAWU,eAAA,SAAwB,oBAAA;EAAA,SAC1B,IAAA,EAAM,IAAA;AAAA;;;;;;;;;;;cAyBJ,YAAA,MACX,IAAA,EAAM,IAAA,EACN,MAAA,EAAQ,gBAAA,CAAkC,CAAA,MACzC,MAAA,CAAO,MAAA,CACR,CAAA,EACA,eAAA,GAAkB,cAAA,GAAkC,qBAAA"}

package/dist/match/Match.d.mts

@@ -1,16 +0,0 @@
-import { Match } from "effect";
-
-//#region src/match/Match.d.ts
-declare namespace Match_d_exports {
-  export { matchType };
-}
-/**
- * Dispatch on the `type` discriminator of a tagged union. Equivalent to
- * `Match.discriminator("type")`, exposed as a named helper because the
- * `type` field is the framework's convention for `Item`, `TurnEvent`,
- * `ContentBlock`, and most provider wire types.
- */
-declare const matchType: <R, P extends Match.Types.Tags<"type", R> & string, Ret, Fn extends (_: Extract<R, Record<"type", P>>) => Ret>(...pattern: [first: P, ...values: P[], f: Fn]) => <I, F, A, Pr>(self: Match.Matcher<I, F, R, A, Pr, Ret>) => Match.Matcher<I, Match.Types.AddWithout<F, Extract<R, Record<"type", P>>>, Match.Types.ApplyFilters<I, Match.Types.AddWithout<F, Extract<R, Record<"type", P>>>>, A | ReturnType<Fn>, Pr, Ret>;
-//#endregion
-export { matchType, Match_d_exports as t };
-//# sourceMappingURL=Match.d.mts.map

package/dist/match/Match.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Match.d.mts","names":[],"sources":["../../src/match/Match.ts"],"mappings":";;;;;;;;;;AAQA;;cAAa,SAAA,gBAAS,KAAA,CAAA,KAAA,CAAA,IAAA,SAAA,CAAA,6BAAA,CAAA,EAAA,OAAA,CAAA,CAAA,EAAA,MAAA,SAAA,CAAA,OAAA,GAAA,KAAA,OAAA,GAAA,KAAA,EAAA,CAAA,KAAA,MAAA,EAAA,CAAA,IAAA,CAAA,EAAA,EAAA,oBAAA,IAAA,EAAA,KAAA,CAAA,OAAA,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,EAAA,EAAA,GAAA,MAAA,KAAA,CAAA,OAAA,CAAA,CAAA,EAAA,KAAA,CAAA,KAAA,CAAA,UAAA,CAAA,CAAA,EAAA,OAAA,CAAA,CAAA,EAAA,MAAA,SAAA,CAAA,KAAA,KAAA,CAAA,KAAA,CAAA,YAAA,CAAA,CAAA,EAAA,KAAA,CAAA,KAAA,CAAA,UAAA,CAAA,CAAA,EAAA,OAAA,CAAA,CAAA,EAAA,MAAA,SAAA,CAAA,MAAA,CAAA,GAAA,UAAA,CAAA,EAAA,GAAA,EAAA,EAAA,GAAA"}

package/dist/match/Match.mjs

@@ -1,15 +0,0 @@
-import { t as __exportAll } from "../chunk-CfYAbeIz.mjs";
-import { Match } from "effect";
-//#region src/match/Match.ts
-var Match_exports = /* @__PURE__ */ __exportAll({ matchType: () => matchType });
-/**
-* Dispatch on the `type` discriminator of a tagged union. Equivalent to
-* `Match.discriminator("type")`, exposed as a named helper because the
-* `type` field is the framework's convention for `Item`, `TurnEvent`,
-* `ContentBlock`, and most provider wire types.
-*/
-const matchType = Match.discriminator("type");
-//#endregion
-export { matchType, Match_exports as t };
-
-//# sourceMappingURL=Match.mjs.map

package/dist/match/Match.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"Match.mjs","names":[],"sources":["../../src/match/Match.ts"],"sourcesContent":["import { Match } from \"effect\"\n\n/**\n * Dispatch on the `type` discriminator of a tagged union. Equivalent to\n * `Match.discriminator(\"type\")`, exposed as a named helper because the\n * `type` field is the framework's convention for `Item`, `TurnEvent`,\n * `ContentBlock`, and most provider wire types.\n */\nexport const matchType = Match.discriminator(\"type\")\n"],"mappings":";;;;;;;;;;AAQA,MAAa,YAAY,MAAM,cAAc,OAAO"}

package/src/match/Match.ts

@@ -1,9 +0,0 @@
-import { Match } from "effect"
-
-/**
- * Dispatch on the `type` discriminator of a tagged union. Equivalent to
- * `Match.discriminator("type")`, exposed as a named helper because the
- * `type` field is the framework's convention for `Item`, `TurnEvent`,
- * `ContentBlock`, and most provider wire types.
- */
-export const matchType = Match.discriminator("type")