@effect-uai/core 0.7.0 → 0.9.0

package/dist/ToolEvent-DYrAUJGs.d.mts

@@ -0,0 +1,151 @@
+import { t as ToolResult } from "./ToolResult-BZd-cEWW.mjs";
+import { Data } from "effect";
+import * as _$effect_Unify0 from "effect/Unify";
+
+//#region src/tool/ToolEvent.d.ts
+declare namespace ToolEvent_d_exports {
+  export { ToolEvent, isApprovalRequested, isOutput, isProgress };
+}
+type ToolEvent = Data.TaggedEnum<{
+  ApprovalRequested: {
+    readonly call_id: string;
+    readonly tool: string;
+    readonly arguments: string;
+  };
+  Progress: {
+    readonly call_id: string;
+    readonly tool: string;
+    readonly data: unknown;
+  };
+  Output: {
+    readonly result: ToolResult;
+  };
+}>;
+/**
+ * Namespace of constructors, type guards, and matchers for `ToolEvent`,
+ * provided by `Data.taggedEnum`. Use `ToolEvent.Output({ result })` to build
+ * an event, `ToolEvent.$is("Output")` for type narrowing,
+ * `ToolEvent.$match({ ApprovalRequested, Progress, Output })` for
+ * exhaustive pattern matching.
+ */
+declare const ToolEvent: {
+  readonly ApprovalRequested: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "ApprovalRequested";
+    readonly call_id: string;
+    readonly tool: string;
+    readonly arguments: string;
+  }, "_tag">;
+  readonly Progress: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Progress";
+    readonly call_id: string;
+    readonly tool: string;
+    readonly data: unknown;
+  }, "_tag">;
+  readonly Output: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Output";
+    readonly result: ToolResult;
+  }, "_tag">;
+  readonly $is: <Tag extends "ApprovalRequested" | "Progress" | "Output">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "ApprovalRequested";
+    readonly call_id: string;
+    readonly tool: string;
+    readonly arguments: string;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Progress";
+    readonly call_id: string;
+    readonly tool: string;
+    readonly data: unknown;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Output";
+    readonly result: ToolResult;
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends {
+      readonly ApprovalRequested: (args: {
+        readonly _tag: "ApprovalRequested";
+        readonly call_id: string;
+        readonly tool: string;
+        readonly arguments: string;
+      }) => any;
+      readonly Progress: (args: {
+        readonly _tag: "Progress";
+        readonly call_id: string;
+        readonly tool: string;
+        readonly data: unknown;
+      }) => any;
+      readonly Output: (args: {
+        readonly _tag: "Output";
+        readonly result: ToolResult;
+      }) => any;
+    }>(cases: Cases): (value: {
+      readonly _tag: "ApprovalRequested";
+      readonly call_id: string;
+      readonly tool: string;
+      readonly arguments: string;
+    } | {
+      readonly _tag: "Progress";
+      readonly call_id: string;
+      readonly tool: string;
+      readonly data: unknown;
+    } | {
+      readonly _tag: "Output";
+      readonly result: ToolResult;
+    }) => _$effect_Unify0.Unify<ReturnType<Cases["ApprovalRequested" | "Progress" | "Output"]>>;
+    <Cases extends {
+      readonly ApprovalRequested: (args: {
+        readonly _tag: "ApprovalRequested";
+        readonly call_id: string;
+        readonly tool: string;
+        readonly arguments: string;
+      }) => any;
+      readonly Progress: (args: {
+        readonly _tag: "Progress";
+        readonly call_id: string;
+        readonly tool: string;
+        readonly data: unknown;
+      }) => any;
+      readonly Output: (args: {
+        readonly _tag: "Output";
+        readonly result: ToolResult;
+      }) => any;
+    }>(value: {
+      readonly _tag: "ApprovalRequested";
+      readonly call_id: string;
+      readonly tool: string;
+      readonly arguments: string;
+    } | {
+      readonly _tag: "Progress";
+      readonly call_id: string;
+      readonly tool: string;
+      readonly data: unknown;
+    } | {
+      readonly _tag: "Output";
+      readonly result: ToolResult;
+    }, cases: Cases): _$effect_Unify0.Unify<ReturnType<Cases["ApprovalRequested" | "Progress" | "Output"]>>;
+  };
+};
+declare const isApprovalRequested: (u: unknown) => u is {
+  readonly _tag: "ApprovalRequested";
+  readonly call_id: string;
+  readonly tool: string;
+  readonly arguments: string;
+};
+declare const isProgress: (u: unknown) => u is {
+  readonly _tag: "Progress";
+  readonly call_id: string;
+  readonly tool: string;
+  readonly data: unknown;
+};
+declare const isOutput: (u: unknown) => u is {
+  readonly _tag: "Output";
+  readonly result: ToolResult;
+};
+//#endregion
+export { isProgress as a, isOutput as i, ToolEvent_d_exports as n, isApprovalRequested as r, ToolEvent as t };
+//# sourceMappingURL=ToolEvent-DYrAUJGs.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ToolEvent-DYrAUJGs.d.mts","names":[],"sources":["../src/tool/ToolEvent.ts"],"mappings":";;;;;;;;KAaY,SAAA,GAAY,IAAA,CAAK,UAAA;EAC3B,iBAAA;IAAA,SACW,OAAA;IAAA,SACA,IAAA;IAAA,SACA,SAAA;EAAA;EAEX,QAAA;IAAA,SACW,OAAA;IAAA,SACA,IAAA;IAAA,SACA,IAAA;EAAA;EAEX,MAAA;IAAA,SACW,MAAA,EAAQ,UAAA;EAAA;AAAA;;;;;AAWrB;;;cAAa,SAAA;EAAA;;;;;;;;;;;;;;qBAXQ,UAAA;EAAA;EAAA;;;;;;;;;;;;;;;;qBAAA,UAAA;EAAA;IAAA;;;;;;;;;;;;;;;;;;yBAAA,UAAA;MAAA;IAAA;;;;;;;;;;;;uBAAA,UAAA;IAAA;;;;;;;;;;;;;;;;yBAAA,UAAA;MAAA;IAAA;;;;;;;;;;;;uBAAA,UAAA;IAAA;;;cAaR,mBAAA,GAAmB,CAAA,cAAA,CAAA;EAAA;;;;;cACnB,UAAA,GAAU,CAAA,cAAA,CAAA;EAAA;;;;;cACV,QAAA,GAAQ,CAAA,cAAA,CAAA;EAAA;mBAfA,UAAA;AAAA"}

package/dist/ToolResult-BZd-cEWW.d.mts

@@ -0,0 +1,151 @@
+import { v as ToolCall, y as ToolCallOutput } from "./Items-CgKD6Npw.mjs";
+import { Data } from "effect";
+import * as _$effect_Unify0 from "effect/Unify";
+
+//#region src/tool/ToolResult.d.ts
+declare namespace ToolResult_d_exports {
+  export { ToolResult, cancelled, denied, executionError, failed, isFailure, isOk, nonLocalTool, toToolCallOutput, validationError };
+}
+type ToolResult = Data.TaggedEnum<{
+  Ok: {
+    readonly call_id: string;
+    readonly tool: string;
+    readonly value: unknown;
+  };
+  Failure: {
+    readonly call_id: string;
+    readonly tool: string;
+    readonly kind: string;
+    readonly reason?: string;
+  };
+}>;
+/**
+ * Namespace of constructors, type guards, and matchers for `ToolResult`,
+ * provided by `Data.taggedEnum`. Use `ToolResult.$is("Ok")` for type
+ * narrowing and `ToolResult.$match({ Ok, Failure })` for exhaustive
+ * pattern matching. Synthetic-result helpers (`denied`, `cancelled`,
+ * `executionError`, `failed`) below are kinder constructors than the
+ * raw `ToolResult.Failure(...)`.
+ */
+declare const ToolResult: {
+  readonly Ok: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Ok";
+    readonly call_id: string;
+    readonly tool: string;
+    readonly value: unknown;
+  }, "_tag">;
+  readonly Failure: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Failure";
+    readonly call_id: string;
+    readonly tool: string;
+    readonly kind: string;
+    readonly reason?: string;
+  }, "_tag">;
+  readonly $is: <Tag extends "Ok" | "Failure">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Ok";
+    readonly call_id: string;
+    readonly tool: string;
+    readonly value: unknown;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Failure";
+    readonly call_id: string;
+    readonly tool: string;
+    readonly kind: string;
+    readonly reason?: string;
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends {
+      readonly Ok: (args: {
+        readonly _tag: "Ok";
+        readonly call_id: string;
+        readonly tool: string;
+        readonly value: unknown;
+      }) => any;
+      readonly Failure: (args: {
+        readonly _tag: "Failure";
+        readonly call_id: string;
+        readonly tool: string;
+        readonly kind: string;
+        readonly reason?: string;
+      }) => any;
+    }>(cases: Cases): (value: {
+      readonly _tag: "Ok";
+      readonly call_id: string;
+      readonly tool: string;
+      readonly value: unknown;
+    } | {
+      readonly _tag: "Failure";
+      readonly call_id: string;
+      readonly tool: string;
+      readonly kind: string;
+      readonly reason?: string;
+    }) => _$effect_Unify0.Unify<ReturnType<Cases["Ok" | "Failure"]>>;
+    <Cases extends {
+      readonly Ok: (args: {
+        readonly _tag: "Ok";
+        readonly call_id: string;
+        readonly tool: string;
+        readonly value: unknown;
+      }) => any;
+      readonly Failure: (args: {
+        readonly _tag: "Failure";
+        readonly call_id: string;
+        readonly tool: string;
+        readonly kind: string;
+        readonly reason?: string;
+      }) => any;
+    }>(value: {
+      readonly _tag: "Ok";
+      readonly call_id: string;
+      readonly tool: string;
+      readonly value: unknown;
+    } | {
+      readonly _tag: "Failure";
+      readonly call_id: string;
+      readonly tool: string;
+      readonly kind: string;
+      readonly reason?: string;
+    }, cases: Cases): _$effect_Unify0.Unify<ReturnType<Cases["Ok" | "Failure"]>>;
+  };
+};
+declare const isOk: (u: unknown) => u is {
+  readonly _tag: "Ok";
+  readonly call_id: string;
+  readonly tool: string;
+  readonly value: unknown;
+};
+declare const isFailure: (u: unknown) => u is {
+  readonly _tag: "Failure";
+  readonly call_id: string;
+  readonly tool: string;
+  readonly kind: string;
+  readonly reason?: string;
+};
+declare const failed: (call: ToolCall, kind: string, reason?: string) => ToolResult;
+/** Explicit user/policy rejection. */
+declare const denied: (call: ToolCall, reason?: string) => ToolResult;
+/** Implicit non-answer (follow-up, inactivity, abort). */
+declare const cancelled: (call: ToolCall, reason?: string) => ToolResult;
+/** Tool's own execution failed (JSON parse error, runtime crash). */
+declare const executionError: (call: ToolCall, reason: string) => ToolResult;
+/**
+ * The model called a tool that is visible to it but has no local executor — a
+ * provider-hosted, signal, or interaction tool routed through `Toolkit.run`.
+ * Distinct from `unknown_tool` (no such tool at all): the loop is expected to
+ * intercept these kinds before execution, so this kind flags a missing handler.
+ */
+declare const nonLocalTool: (call: ToolCall, reason?: string) => ToolResult;
+/**
+ * The model's `arguments` failed the tool's input schema. Distinct kind from
+ * `execution_error` so recipes can tell a contract violation apart from a
+ * runtime crash.
+ */
+declare const validationError: (call: ToolCall, reason?: string) => ToolResult;
+declare const toToolCallOutput: (r: ToolResult) => ToolCallOutput;
+//#endregion
+export { executionError as a, isOk as c, validationError as d, denied as i, nonLocalTool as l, ToolResult_d_exports as n, failed as o, cancelled as r, isFailure as s, ToolResult as t, toToolCallOutput as u };
+//# sourceMappingURL=ToolResult-BZd-cEWW.d.mts.map

package/dist/ToolResult-BZd-cEWW.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolResult-BZd-cEWW.d.mts","names":[],"sources":["../src/tool/ToolResult.ts"],"mappings":";;;;;;;;KAqBY,UAAA,GAAa,IAAA,CAAK,UAAA;EAC5B,EAAA;IAAA,SACW,OAAA;IAAA,SACA,IAAA;IAAA,SACA,KAAA;EAAA;EAEX,OAAA;IAAA,SACW,OAAA;IAAA,SACA,IAAA;IAAA,SACA,IAAA;IAAA,SACA,MAAA;EAAA;AAAA;;;;;;;;AAYb;cAAa,UAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAEA,IAAA,GAAI,CAAA,cAAA,CAAA;EAAA;;;;;cACJ,SAAA,GAAS,CAAA,cAAA,CAAA;EAAA;;;;;;cAMT,MAAA,GAAU,IAAA,EAAM,QAAA,EAAU,IAAA,UAAc,MAAA,cAAkB,UAAA;;cAS1D,MAAA,GAAU,IAAA,EAAM,QAAA,EAAU,MAAA,cAAkB,UAAA;;cAI5C,SAAA,GAAa,IAAA,EAAM,QAAA,EAAU,MAAA,cAAkB,UAAA;;cAI/C,cAAA,GAAkB,IAAA,EAAM,QAAA,EAAU,MAAA,aAAiB,UAAA;;;;;;;cASnD,YAAA,GAAgB,IAAA,EAAM,QAAA,EAAU,MAAA,cAAkB,UAAA;;;;;;cAYlD,eAAA,GAAmB,IAAA,EAAM,QAAA,EAAU,MAAA,cAAkB,UAAA;AAAA,cAOrD,gBAAA,GAAoB,CAAA,EAAG,UAAA,KAAa,cAAA"}

package/dist/Toolkit-BKC8b8Xo.d.mts

@@ -0,0 +1,155 @@
+import { o as HistoryItem, v as ToolCall } from "./Items-CgKD6Npw.mjs";
+import { Turn } from "./domain/Turn.mjs";
+import { r as Step } from "./Loop-B5_cqumi.mjs";
+import { a as InteractionTool, c as Tool, f as ToolR, i as Emit, l as ToolDescriptor, n as AnyTool, o as ProviderTool, s as SignalTool } from "./Tool-0XUIT2A2.mjs";
+import { t as ToolResult } from "./ToolResult-BZd-cEWW.mjs";
+import { t as ToolEvent } from "./ToolEvent-DYrAUJGs.mjs";
+import { Cause, Effect, Stream } from "effect";
+import * as _$effect_Types0 from "effect/Types";
+
+//#region src/tool/Toolkit.d.ts
+declare namespace Toolkit_d_exports {
+  export { DuplicateToolName, ExecuteOptions, Middleware, NoDuplicateNames, ToolMap, Toolkit, ToolkitR, UniqueTools, appendToolResults, collectResults, compose, continueWithResults, descriptors, fromArray, make, makeNamespaced, namespace, run, wrap };
+}
+type ToolMap = Record<string, AnyTool>;
+type Toolkit<Tools extends ToolMap = ToolMap> = Tools;
+declare const make: <const Tools extends ReadonlyArray<AnyTool>>(...tools: UniqueTools<Tools>) => Toolkit<{ [T in Tools[number] as T["name"]]: T }>;
+/**
+ * Build a toolkit from a dynamically-sourced array (MCP server, plugin). Names
+ * are not validated (MCP legitimately uses dots / >64 chars — sanitize at the
+ * provider adapter); same-named tools resolve last-wins. Cross-source clashes
+ * are caught by `compose`.
+ */
+declare const fromArray: (tools: ReadonlyArray<AnyTool>) => Toolkit;
+/** Render the provider-facing descriptors for a toolkit on demand. */
+declare const descriptors: (toolkit: Toolkit) => ReadonlyArray<ToolDescriptor>;
+/**
+ * Union of every tool's `R` requirements in a toolkit. Surfaced by `run` so the
+ * loop's stream type carries the services tools need through to `Effect.provide`.
+ *
+ * The `ToolMap extends T` guard yields `never` for the wide `Toolkit` type (a
+ * toolkit passed through an untyped boundary, where the requirements aren't
+ * statically known) instead of `any`, which would otherwise poison the
+ * resulting stream's `R`. Concrete toolkits from `make` keep their precise R.
+ */
+type ToolkitR<T extends Toolkit> = ToolMap extends T ? never : ToolR<T[keyof T]>;
+type DuplicateName<Tools extends ReadonlyArray<AnyTool>, Seen extends string = never> = Tools extends readonly [infer Head extends AnyTool, ...infer Tail extends ReadonlyArray<AnyTool>] ? Head["name"] extends Seen ? Head["name"] : DuplicateName<Tail, Seen | Head["name"]> : never;
+type DuplicateNameError<Name extends string> = {
+  readonly __error: `Duplicate tool name: ${Name}`;
+};
+type NoDuplicateNames<Tools extends ReadonlyArray<AnyTool>> = [DuplicateName<Tools>] extends [never] ? unknown : DuplicateNameError<DuplicateName<Tools>>;
+/** `Tools` constrained so a repeated literal name is a compile error in `make`. */
+type UniqueTools<Tools extends ReadonlyArray<AnyTool>> = Tools & NoDuplicateNames<Tools>;
+type ComposeDuplicateKey<Kits extends ReadonlyArray<Toolkit>, Seen extends string = never> = Kits extends readonly [infer Head extends Toolkit, ...infer Tail extends ReadonlyArray<Toolkit>] ? string extends keyof Head ? ComposeDuplicateKey<Tail, Seen> : Extract<keyof Head & string, Seen> extends never ? ComposeDuplicateKey<Tail, Seen | (keyof Head & string)> : Extract<keyof Head & string, Seen> : never;
+type NoDuplicateComposedKeys<Kits extends ReadonlyArray<Toolkit>> = [ComposeDuplicateKey<Kits>] extends [never] ? unknown : DuplicateNameError<ComposeDuplicateKey<Kits>>;
+type UnionToIntersection<U> = (U extends unknown ? (x: U) => void : never) extends ((x: infer I) => void) ? I : never;
+type Composed<Kits extends ReadonlyArray<Toolkit>> = UnionToIntersection<Kits[number]> extends infer M ? (M extends ToolMap ? M : ToolMap) : ToolMap;
+declare const DuplicateToolName_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => Cause.YieldableError & {
+  readonly _tag: "DuplicateToolName";
+} & Readonly<A>;
+/**
+ * Two composed toolkits resolved to the same final name. Carries the colliding
+ * `sources` (the positions of the clashing toolkits) so the error says *which*
+ * inputs collided. Raised at runtime by `compose` for dynamic sources; static
+ * collisions are caught earlier at compile time.
+ */
+declare class DuplicateToolName extends DuplicateToolName_base<{
+  readonly name: string;
+  readonly sources: ReadonlyArray<string>;
+}> {}
+type PrefixName<Prefix extends string, Name extends string> = `${Prefix}__${Name}`;
+type PrefixTool<Prefix extends string, T extends AnyTool> = T extends Tool<infer N, infer I, infer Ev, infer O, infer R> ? Tool<PrefixName<Prefix, N>, I, Ev, O, R> : T extends ProviderTool<infer N, infer I, infer P, infer C> ? ProviderTool<PrefixName<Prefix, N>, I, P, C> : T extends SignalTool<infer N, infer I> ? SignalTool<PrefixName<Prefix, N>, I> : T extends InteractionTool<infer N, infer I> ? InteractionTool<PrefixName<Prefix, N>, I> : T;
+type Namespaced<Prefix extends string, T extends ToolMap> = { readonly [K in keyof T & string as PrefixName<Prefix, K>]: T[K] extends AnyTool ? PrefixTool<Prefix, T[K]> : never };
+/**
+ * Prefix every tool name with `<namespace>__`, returning a new toolkit. Use it
+ * to keep generic names (`search`) from two sources distinct before `compose`.
+ * If two namespaces collide at the `__` separator, the duplicate final name
+ * surfaces from `compose` as a `DuplicateToolName`.
+ */
+declare const namespace: <const Prefix extends string, const T extends ToolMap>(prefix: Prefix, toolkit: Toolkit<T>) => Toolkit<Namespaced<Prefix, T>>;
+/** `namespace(prefix, make(...tools))` in one step, for static namespaced tools. */
+declare const makeNamespaced: <const Prefix extends string, const Tools extends ReadonlyArray<AnyTool>>(prefix: Prefix, ...tools: UniqueTools<Tools>) => Toolkit<Namespaced<Prefix, { [T in Tools[number] as T["name"]]: T }>>;
+/**
+ * Combine independently-built toolkits into one. This is where names from
+ * separate sources can collide, so it is the one effectful constructor: a
+ * duplicate final name fails with `DuplicateToolName` (naming the colliding
+ * input positions) instead of silently overwriting or 400-ing later at the
+ * provider. Statically-known collisions are additionally a compile error.
+ */
+declare const compose: <const Kits extends ReadonlyArray<Toolkit>>(...toolkits: Kits & NoDuplicateComposedKeys<Kits>) => Effect.Effect<Toolkit<Composed<Kits>>, DuplicateToolName>;
+type Handler<Input, Event, Output, R> = (input: Input, emit: Emit<Event>) => Effect.Effect<Output, unknown, R>;
+type Middleware<R2 = never> = <Input, Event, Output, R>(run: Handler<Input, Event, Output, R>, name: string) => Handler<Input, Event, Output, R | R2>;
+type WrapTool<T extends AnyTool, R2> = T extends Tool<infer N, infer I, infer Ev, infer O, infer R> ? Tool<N, I, Ev, O, R | R2> : T;
+type WrapToolkit<T extends ToolMap, R2> = { readonly [K in keyof T]: T[K] extends AnyTool ? WrapTool<T[K], R2> : T[K] };
+/**
+ * Wrap every local tool's `run` with a middleware, preserving each tool's
+ * `Input`/`Output` and unioning the middleware's requirement `R2` into the
+ * toolkit's `ToolkitR`. Non-local kinds pass through unchanged. Stack with
+ * `pipe`:
+ *
+ *   const observed = pipe(toolkit, Toolkit.wrap(logging), Toolkit.wrap(authz))
+ *   Toolkit.run(observed, calls) // R = ToolkitR<typeof toolkit> | <authz R>
+ *
+ * A middleware that `Effect.fail`s surfaces as a `ToolResult.Failure` from the
+ * executor like any run failure; use the `Approval` flow for a distinct
+ * "denied" verdict.
+ */
+declare const wrap: {
+  <R2>(middleware: Middleware<R2>): <T extends Toolkit>(toolkit: T) => WrapToolkit<T, R2>;
+  <T extends Toolkit, R2>(toolkit: T, middleware: Middleware<R2>): WrapToolkit<T, R2>;
+};
+type ExecuteOptions = {
+  readonly concurrency?: number | "unbounded";
+};
+/** Execute every provided call. Approval/rejection policy belongs upstream. */
+declare const run: <T extends Toolkit>(toolkit: T, calls: ReadonlyArray<ToolCall>, options?: ExecuteOptions) => Stream.Stream<ToolEvent, never, ToolkitR<T>>;
+/**
+ * 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(toolkit, calls).pipe(
+ *     Toolkit.continueWithResults(Toolkit.appendToolResults(state, turn)),
+ *   )
+ *
+ * Equivalent to `appendToHistory(state, turn, results.map(toToolCallOutput))`
+ * — the helper just hides the wire-conversion step.
+ */
+declare const appendToolResults: <S extends {
+  readonly history: ReadonlyArray<HistoryItem>;
+}>(state: S, turn: Turn) => (results: ReadonlyArray<ToolResult>) => S;
+/**
+ * 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).
+ */
+declare const collectResults: <E, R>(stream: Stream.Stream<ToolEvent, E, R>) => Effect.Effect<ReadonlyArray<ToolResult>, E, R>;
+/**
+ * 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.
+ */
+declare const continueWithResults: {
+  <S>(build: (results: ReadonlyArray<ToolResult>) => S): <R>(stream: Stream.Stream<ToolEvent, never, R>) => Stream.Stream<Step<ToolEvent, S>, never, R>;
+  <S, R>(stream: Stream.Stream<ToolEvent, never, R>, build: (results: ReadonlyArray<ToolResult>) => S): Stream.Stream<Step<ToolEvent, S>, never, R>;
+};
+//#endregion
+export { makeNamespaced as _, ToolMap as a, wrap as b, Toolkit_d_exports as c, collectResults as d, compose as f, make as g, fromArray as h, NoDuplicateNames as i, UniqueTools as l, descriptors as m, ExecuteOptions as n, Toolkit as o, continueWithResults as p, Middleware as r, ToolkitR as s, DuplicateToolName as t, appendToolResults as u, namespace as v, run as y };
+//# sourceMappingURL=Toolkit-BKC8b8Xo.d.mts.map

package/dist/Toolkit-BKC8b8Xo.d.mts.map

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

package/dist/{dist-DV5ISja1.mjs → dist-B04dlFHg.mjs}

@@ -10243,7 +10243,7 @@ function memo(fn) {
 	};
 }
 async function saveInlineSnapshots(environment, snapshots) {
-	const MagicString = (await import("./magic-string.es-BgIV5Mu3.mjs")).default;
+	const MagicString = (await import("./magic-string.es-Dk-MMA0F.mjs")).default;
 	const files = new Set(snapshots.map((i) => i.file));
 	await Promise.all(Array.from(files).map(async (file) => {
 		const snaps = snapshots.filter((i) => i.file === file);
@@ -13777,6 +13777,6 @@ var import_dist = (/* @__PURE__ */ __commonJSMin(((exports) => {
 	exports.expectTypeOf = expectTypeOf;
 })))();
 //#endregion
-export { it as i, globalExpect as n, describe as r, import_dist as t };
+export { describe as a, beforeAll as i, globalExpect as n, it as o, afterAll as r, import_dist as t };
 
-//# sourceMappingURL=dist-DV5ISja1.mjs.map
+//# sourceMappingURL=dist-B04dlFHg.mjs.map