@effect-uai/core 0.18.0 → 0.19.0-dev-20261109183959

package/dist/ToolResult-BsYQRjmW.d.mts

@@ -1,152 +0,0 @@
-import { b as ToolCallOutput, y as ToolCall } from "./Items-C7MyrYPX.mjs";
-import { Data } from "effect";
-declare namespace ToolResult_d_exports {
-  export { ToolResult, cancelled, denied, executionError, failed, isFailure, isOk, nonLocalTool, serializeValue, 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 $is: <Tag extends "Failure" | "Ok">(tag: Tag) => (u: unknown) => u is Extract<{
-    readonly _tag: "Failure";
-    readonly call_id: string;
-    readonly tool: string;
-    readonly kind: string;
-    readonly reason?: string;
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "Ok";
-    readonly call_id: string;
-    readonly tool: string;
-    readonly value: unknown;
-  }, {
-    readonly _tag: Tag;
-  }>;
-  readonly $match: {
-    <Cases extends { readonly [Tag in "Failure" | "Ok"]: (args: Extract<{
-      readonly _tag: "Failure";
-      readonly call_id: string;
-      readonly tool: string;
-      readonly kind: string;
-      readonly reason?: string;
-    } | {
-      readonly _tag: "Ok";
-      readonly call_id: string;
-      readonly tool: string;
-      readonly value: unknown;
-    }, {
-      readonly _tag: Tag;
-    }>) => any; }>(cases: Cases): (value: {
-      readonly _tag: "Failure";
-      readonly call_id: string;
-      readonly tool: string;
-      readonly kind: string;
-      readonly reason?: string;
-    } | {
-      readonly _tag: "Ok";
-      readonly call_id: string;
-      readonly tool: string;
-      readonly value: unknown;
-    }) => import("effect/Unify").Unify<ReturnType<Cases["Failure" | "Ok"]>>;
-    <Cases extends { readonly [Tag in "Failure" | "Ok"]: (args: Extract<{
-      readonly _tag: "Failure";
-      readonly call_id: string;
-      readonly tool: string;
-      readonly kind: string;
-      readonly reason?: string;
-    } | {
-      readonly _tag: "Ok";
-      readonly call_id: string;
-      readonly tool: string;
-      readonly value: unknown;
-    }, {
-      readonly _tag: Tag;
-    }>) => any; }>(value: {
-      readonly _tag: "Failure";
-      readonly call_id: string;
-      readonly tool: string;
-      readonly kind: string;
-      readonly reason?: string;
-    } | {
-      readonly _tag: "Ok";
-      readonly call_id: string;
-      readonly tool: string;
-      readonly value: unknown;
-    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Failure" | "Ok"]>>;
-  };
-  readonly Failure: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Failure";
-    readonly call_id: string;
-    readonly tool: string;
-    readonly kind: string;
-    readonly reason?: string;
-  }, "_tag">;
-  readonly Ok: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Ok";
-    readonly call_id: string;
-    readonly tool: string;
-    readonly value: unknown;
-  }, "_tag">;
-};
-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;
-/**
- * Serialize a success value for the wire. A `string` passes through raw
- * (models read plain text best; JSON.stringify would quote and escape it);
- * `undefined` becomes `"null"`; anything else is JSON.
- */
-declare const serializeValue: (value: unknown) => string;
-declare const toToolCallOutput: (r: ToolResult) => ToolCallOutput;
-//#endregion
-export { executionError as a, isOk as c, toToolCallOutput as d, validationError as f, denied as i, nonLocalTool as l, ToolResult_d_exports as n, failed as o, cancelled as r, isFailure as s, ToolResult as t, serializeValue as u };
-//# sourceMappingURL=ToolResult-BsYQRjmW.d.mts.map

package/dist/ToolResult-BsYQRjmW.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ToolResult-BsYQRjmW.d.mts","names":[],"sources":["../src/tool/ToolResult.ts"],"mappings":";;;;;KAqBY,aAAa,KAAK;EAC5B;aACW;aACA;aACA;;EAEX;aACW;aACA;aACA;aACA;;;;;;;;;;;cAYA;;;aAfS;aACH;aACA;aACG;;;;;aARA;aACH;aACC;;;;;;;eAGE;eACH;eACA;eACG;;;eARA;eACH;eACC;;;;;;;;;;;;;;;;;eAGE;eACH;eACA;eACG;;;eARA;eACH;eACC;;;;;;;;;;;;;;;;;;aAGE;aACH;aACA;aACG;;;;aARA;aACH;aACC;;;cAoBP,OAAI,eAAA;;WAtBK;WACH;WACC;;cAqBP,YAAS,eAAA;;WAlBA;WACH;WACA;WACG;;cAqBT,SAAM,MAAU,UAAQ,cAAc,oBAAoB;;cAS1D,SAAM,MAAU,UAAQ,oBAAoB;;cAI5C,YAAS,MAAU,UAAQ,oBAAoB;;cAI/C,iBAAc,MAAU,UAAQ,mBAAmB;;;;;;;cASnD,eAAY,MAAU,UAAQ,oBAAoB;;;;;;cAYlD,kBAAe,MAAU,UAAQ,oBAAoB;;;;;;cAYrD,iBAAc;cAOd,mBAAgB,GAAO,eAAa"}

package/dist/Toolkit-tlL0F2YR.d.mts

@@ -1,193 +0,0 @@
-import { o as HistoryItem, y as ToolCall } from "./Items-C7MyrYPX.mjs";
-import { a as Emit, c as SignalTool, d as ToolE, h as ToolR, l as Tool, n as AnyTool, o as InteractionTool, p as ToolFailed, s as ProviderTool, u as ToolDescriptor } from "./Tool-BF78QWtn.mjs";
-import { Turn } from "./domain/Turn.mjs";
-import { r as Step } from "./Loop-ChpaO-ya.mjs";
-import { t as ToolResult } from "./ToolResult-BsYQRjmW.mjs";
-import { t as ToolEvent } from "./ToolEvent-Di4a723B.mjs";
-import { Cause, Effect, Stream } from "effect";
-declare namespace Toolkit_d_exports {
-  export { DuplicateToolName, ExecuteOptions, Middleware, NoDuplicateNames, ToolMap, Toolkit, ToolkitE, ToolkitR, UniqueTools, appendToolResults, collectResults, compose, continueWithResults, describeFailures, 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]>;
-/**
- * Union of every tool's `E` error type in a toolkit. `Toolkit.run` reports
- * `Exclude<ToolkitE<T>, string | ToolFailed>` on its stream: the sentinel
- * failures are absorbed into results, everything else propagates typed. The
- * same `ToolMap extends T` guard as `ToolkitR` keeps a wide toolkit at
- * `never` rather than `any`.
- */
-type ToolkitE<T extends Toolkit> = ToolMap extends T ? never : ToolE<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: import("effect/Types").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 E, infer R> ? Tool<PrefixName<Prefix, N>, I, Ev, O, E, 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, E, R> = (input: Input, emit: Emit<Event>) => Effect.Effect<Output, E, R>;
-/**
- * A `run` transform, tracking an added requirement `R2` and optional added
- * error `E2`. The tool's own `E` is preserved; `describeFailures` is the
- * combinator that *replaces* it (mapping every error to `string`).
- */
-type Middleware<R2 = never, E2 = never> = <Input, Event, Output, E, R>(run: Handler<Input, Event, Output, E, R>, name: string) => Handler<Input, Event, Output, E | E2, R | R2>;
-type WrapTool<T extends AnyTool, R2, E2> = T extends Tool<infer N, infer I, infer Ev, infer O, infer E, infer R> ? Tool<N, I, Ev, O, E | E2, R | R2> : T;
-type WrapToolkit<T extends ToolMap, R2, E2> = { readonly [K in keyof T]: T[K] extends AnyTool ? WrapTool<T[K], R2, E2> : 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` - inner-first, so the last `wrap` applied is the outermost and runs
- * first:
- *
- *   const observed = pipe(toolkit, Toolkit.wrap(logging), Toolkit.wrap(authz))
- *   Toolkit.run(observed, calls) // authz runs, then logging, then the tool
- *
- * A middleware that fails with `string` / `ToolFailed` is absorbed by the
- * executor into a `ToolResult.Failure`; any other error propagates typed. Use
- * `describeFailures` for the total "everything to the model" case, or the
- * `Approval` flow for a distinct "denied" verdict.
- */
-declare const wrap: {
-  <R2, E2>(middleware: Middleware<R2, E2>): <T extends Toolkit>(toolkit: T) => WrapToolkit<T, R2, E2>;
-  <T extends Toolkit, R2, E2>(toolkit: T, middleware: Middleware<R2, E2>): WrapToolkit<T, R2, E2>;
-};
-type DescribeTool<T extends AnyTool> = T extends Tool<infer N, infer I, infer Ev, infer O, any, infer R> ? Tool<N, I, Ev, O, string, R> : T;
-type DescribeToolkit<T extends ToolMap> = { readonly [K in keyof T]: T[K] extends AnyTool ? DescribeTool<T[K]> : T[K]; };
-/**
- * Map every local tool's error to a `string`, so `Toolkit.run` absorbs those
- * failures into `ToolResult.Failure` the model reads and adapts to. Pairs
- * with the domain `describe` helpers (`AiError.describe`,
- * `BrowserError.describe`). Non-local kinds pass through.
- *
- *   const kit = yield* Toolkit.compose(
- *     Toolkit.describeFailures(searchKit, AiError.describe),
- *     browserToolkit(session), // failures stay typed
- *   )
- */
-declare const describeFailures: {
-  <E>(describe: (e: E) => string): <T extends Toolkit>(toolkit: T) => DescribeToolkit<T>;
-  <T extends Toolkit>(toolkit: T, describe: (e: ToolkitE<T>) => string): DescribeToolkit<T>;
-};
-type ExecuteOptions = {
-  readonly concurrency?: number | "unbounded";
-};
-/**
- * Execute every provided call. Approval/rejection policy belongs upstream.
- *
- * String and `ToolFailed` failures are absorbed into `ToolResult.Failure`
- * (the model reads and adapts to them); every other tool error propagates
- * typed on the stream, so `Exclude<ToolkitE<T>, string | ToolFailed>` is
- * what a caller catches or lets end the run. If one call in a concurrent
- * batch fails the stream, siblings may go unanswered: a loop that catches
- * and continues must reconcile history first (`HistoryCheck.cancelAllPending`).
- */
-declare const run: <T extends Toolkit>(toolkit: T, calls: ReadonlyArray<ToolCall>, options?: ExecuteOptions) => Stream.Stream<ToolEvent, Exclude<ToolkitE<T>, string | ToolFailed>, 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): <E, R>(stream: Stream.Stream<ToolEvent, E, R>) => Stream.Stream<Step<ToolEvent, S>, E, R>;
-  <S, E, R>(stream: Stream.Stream<ToolEvent, E, R>, build: (results: ReadonlyArray<ToolResult>) => S): Stream.Stream<Step<ToolEvent, S>, E, R>;
-};
-//#endregion
-export { wrap as S, fromArray as _, ToolMap as a, namespace as b, ToolkitR as c, appendToolResults as d, collectResults as f, descriptors as g, describeFailures as h, NoDuplicateNames as i, Toolkit_d_exports as l, continueWithResults as m, ExecuteOptions as n, Toolkit as o, compose as p, Middleware as r, ToolkitE as s, DuplicateToolName as t, UniqueTools as u, make as v, run as x, makeNamespaced as y };
-//# sourceMappingURL=Toolkit-tlL0F2YR.d.mts.map

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

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

package/dist/dist-C8RmtoR8.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"dist-C8RmtoR8.mjs","names":["V.describe","it","V.it","internal.it"],"sources":["../../../node_modules/.pnpm/@effect+vitest@4.0.1_effect@4.0.1_vitest@5.0.3_@types+node@26.2.0_vite@7.3.2_@types+nod_65816e3353e20bfeb9b2e1494bdddeef/node_modules/@effect/vitest/dist/internal/internal.js","../../../node_modules/.pnpm/@effect+vitest@4.0.1_effect@4.0.1_vitest@5.0.3_@types+node@26.2.0_vite@7.3.2_@types+nod_65816e3353e20bfeb9b2e1494bdddeef/node_modules/@effect/vitest/dist/index.js"],"sourcesContent":["/**\n * @since 4.0.0\n */\nimport * as Arbitrary from \"effect/Arbitrary\";\nimport * as Cause from \"effect/Cause\";\nimport * as Duration from \"effect/Duration\";\nimport * as Effect from \"effect/Effect\";\nimport * as Exit from \"effect/Exit\";\nimport { constVoid, flow, pipe } from \"effect/Function\";\nimport * as Layer from \"effect/Layer\";\nimport * as Schedule from \"effect/Schedule\";\nimport * as Scope from \"effect/Scope\";\nimport * as TestClock from \"effect/testing/TestClock\";\nimport * as TestConsole from \"effect/testing/TestConsole\";\nimport * as V from \"vitest\";\nconst getCurrentSuite = V.TestRunner.getCurrentSuite;\nconst runPromise = /*#__PURE__*/Effect.fnUntraced(function* (effect, _ctx) {\n  const exit = yield* Effect.exit(effect);\n  if (Exit.isFailure(exit)) {\n    const errors = Cause.prettyErrors(exit.cause);\n    for (let i = 0; i < errors.length; i++) {\n      yield* Effect.logError(errors[i]);\n    }\n  }\n  return yield* exit;\n}, (effect, _, ctx) => Effect.runPromise(effect, {\n  signal: ctx?.signal\n}));\n/** @internal */\nconst runTest = ctx => effect => {\n  const promise = runPromise(effect, ctx);\n  if (ctx) {\n    // Vitest stops awaiting the test promise once the signal aborts (timeout or\n    // cancellation), so only then add a hook that waits for the finalizers.\n    // Registering it unconditionally would change the teardown of every test.\n    const onAbort = () => ctx.onTestFinished(() => promise.then(constVoid, constVoid));\n    ctx.signal.addEventListener(\"abort\", onAbort, {\n      once: true\n    });\n    const cleanup = () => ctx.signal.removeEventListener(\"abort\", onAbort);\n    promise.then(cleanup, cleanup);\n    // A retry after a timed-out attempt reuses the aborted signal, so no event fires.\n    if (ctx.signal.aborted) onAbort();\n  }\n  return promise;\n};\nconst TestEnv = /*#__PURE__*/Layer.mergeAll(TestConsole.layer, /*#__PURE__*/TestClock.layer());\n/** @internal */\nexport const addEqualityTesters = () => {\n  V.expect.addEqualityTesters([]);\n};\n/** @internal */\nconst testOptions = timeout => typeof timeout === \"number\" ? {\n  timeout\n} : timeout ?? {};\nconst hookTimeout = timeout => timeout === undefined ? undefined : Duration.toMillis(Duration.fromInputUnsafe(timeout));\nconst propertyTestOptions = timeout => typeof timeout === \"number\" ? undefined : timeout;\nconst checkOptions = timeout => propertyTestOptions(timeout)?.arbitrary;\nconst compileArbitraryInput = input => Arbitrary.isArbitrary(input) ? input : Arbitrary.schema(input);\nconst makeArbitrary = arbitraries => Arbitrary.all(Array.isArray(arbitraries) ? arbitraries.map(compileArbitraryInput) : Object.fromEntries(Object.entries(arbitraries).map(([key, input]) => [key, compileArbitraryInput(input)])));\nconst normalizeProperty = (property, value) => Effect.catchCause(Effect.suspend(() => {\n  const output = property(value);\n  return Effect.isEffect(output) ? output : Effect.succeed(output);\n}), cause => Cause.hasInterrupts(cause) ? Effect.failCause(cause) : Effect.fail(cause));\nconst runCheck = (ctx, arbitrary, property, options) => runTest(ctx)(Effect.flatMapEager(Arbitrary.checkEffect(arbitrary, value => normalizeProperty(property, value), options), result => {\n  const failure = Arbitrary.formatCheckFailure(result);\n  return failure === undefined ? Effect.void : Effect.die(new Error(failure));\n}));\n// Vitest decides which fixtures to set up by parsing the source of a test\n// function's context parameter, and there is no public API to supply the names\n// for a wrapper, so wrappers expose the source of the function they call.\nconst withFixturesOf = (source, f) => Object.defineProperty(f, \"toString\", {\n  value: () => source.toString()\n});\nconst makeItProxy = (it, overrides) => new Proxy(it, {\n  apply(target, thisArg, argArray) {\n    return Reflect.apply(target, thisArg, argArray);\n  },\n  get(target, property, receiver) {\n    if (Object.hasOwn(overrides, property)) {\n      return Reflect.get(overrides, property);\n    }\n    // do not bind: binding would strip vitest's static helpers (e.g. `describe.each`)\n    return Reflect.get(target, property, receiver);\n  }\n});\nconst collectTasks = (tasks, acc = []) => {\n  for (let i = 0; i < tasks.length; i++) {\n    const task = tasks[i];\n    if (task.type === \"test\" && task.mode !== \"skip\" && task.mode !== \"todo\") {\n      acc.push(task);\n    } else if (task.tasks !== undefined) {\n      collectTasks(task.tasks, acc);\n    }\n  }\n  return acc;\n};\nconst registerProp = (it, name, arbitraries, property, timeout) => {\n  const arbitrary = makeArbitrary(arbitraries);\n  // Property callbacks receive only the base context; the empty source requests no fixtures.\n  it(name, testOptions(timeout), withFixturesOf(() => {}, ctx => runCheck(ctx, arbitrary, values => property(values, ctx), checkOptions(timeout))));\n};\nconst makeTester = (mapEffect, it) => {\n  const run = (ctx, args, self) => pipe(Effect.suspend(() => self(...args)), mapEffect, runTest(ctx));\n  const register = test => (name, self, timeout) => test(name, testOptions(timeout), withFixturesOf(self, ctx => run(ctx, [ctx], self)));\n  const each = cases => (name, self, timeout) => it.for(cases)(name, testOptions(timeout), withFixturesOf(self, (args, ctx) => run(ctx, [args, ctx], self).then(constVoid)));\n  const prop = (name, arbitraries, self, timeout) => registerProp(it, name, arbitraries, (values, ctx) => Effect.mapEager(mapEffect(Effect.suspend(() => self(values, ctx))), value => value !== false), timeout);\n  return Object.assign(register(it), {\n    skip: register(it.skip),\n    skipIf: condition => register(it.skipIf(condition)),\n    runIf: condition => register(it.runIf(condition)),\n    only: register(it.only),\n    each,\n    fails: register(it.fails),\n    prop\n  });\n};\nconst makeProp = it => (name, arbitraries, self, timeout) => registerProp(it, name, arbitraries, (values, ctx) => self(values, ctx) !== false, timeout);\nconst makeLayer = it => (layer_, options) => (...args) => {\n  const excludeTestServices = options?.excludeTestServices ?? false;\n  const withTestEnv = excludeTestServices ? layer_ : Layer.provideMerge(layer_, TestEnv);\n  const memoMap = options?.memoMap ?? Effect.runSync(Layer.makeMemoMap);\n  const scope = Effect.runSync(Scope.make());\n  const contextEffect = Layer.buildWithMemoMap(withTestEnv, memoMap, scope).pipe(Effect.orDie, Effect.cached, Effect.runSync);\n  let closed = false;\n  const closeScope = () => {\n    if (closed) {\n      return Promise.resolve();\n    }\n    closed = true;\n    // Layer cleanup must outlive the last test's already-aborted signal.\n    return runPromise(Scope.close(scope, Exit.void));\n  };\n  const methods = makeItProxy(it, {\n    effect: makeTester(effect => Effect.flatMap(contextEffect, context => effect.pipe(Effect.scoped, Effect.provide(context))), it),\n    prop: makeProp(it),\n    flakyTest,\n    layer(nestedLayer, options) {\n      return makeLayer(it)(Layer.provideMerge(nestedLayer, withTestEnv), {\n        ...options,\n        memoMap: Layer.forkMemoMapUnsafe(memoMap),\n        excludeTestServices\n      });\n    }\n  });\n  if (args.length === 1) {\n    const currentSuite = getCurrentSuite();\n    const previousTasks = new Set(currentSuite.tasks);\n    args[0](methods);\n    const blockTasks = collectTasks(currentSuite.tasks.filter(task => !previousTasks.has(task)));\n    if (blockTasks.length === 0) {\n      V.afterAll(() => closeScope(), hookTimeout(options?.timeout));\n      return;\n    }\n    const blockTaskSet = new Set(blockTasks);\n    let remaining = blockTasks.length;\n    V.beforeEach(\n    // Destructured so Vitest can parse the hook once the suite defines fixtures.\n    ({\n      onTestFinished,\n      signal,\n      task\n    }) => {\n      if (!blockTaskSet.has(task)) {\n        return;\n      }\n      onTestFinished(() => {\n        remaining--;\n        if (remaining === 0) {\n          return closeScope();\n        }\n      });\n      return runPromise(Effect.asVoid(contextEffect), {\n        signal\n      });\n    }, hookTimeout(options?.timeout));\n    V.afterAll(() => closeScope(), hookTimeout(options?.timeout));\n    return;\n  }\n  const suiteOptions = options?.concurrent === undefined ? {} : {\n    concurrent: options.concurrent\n  };\n  return V.describe(args[0], suiteOptions, () => {\n    V.beforeAll(() => runPromise(Effect.asVoid(contextEffect)), hookTimeout(options?.timeout));\n    V.afterAll(() => closeScope(), hookTimeout(options?.timeout));\n    return args[1](methods);\n  });\n};\n/** @internal */\nexport const flakyTest = (self, timeout = Duration.seconds(30)) => pipe(self, Effect.scoped, Effect.sandbox, Effect.retry(pipe(Schedule.recurs(10), Schedule.while(_ => Effect.succeed(Duration.isLessThanOrEqualTo(Duration.fromInputUnsafe(_.elapsed), Duration.fromInputUnsafe(timeout)))))), Effect.orDie);\n/** @internal */\nexport const makeMethods = it => makeItProxy(it, {\n  effect: makeTester(flow(Effect.scoped, Effect.provide(TestEnv)), it),\n  live: makeTester(Effect.scoped, it),\n  flakyTest,\n  layer: makeLayer(it),\n  prop: makeProp(it)\n});\n/** @internal */\nexport const it = /*#__PURE__*/makeMethods(V.it);\n/** @internal */\nexport const {\n  /** @internal */\n  effect,\n  /** @internal */\n  layer,\n  /** @internal */\n  live,\n  /** @internal */\n  prop\n} = it;\n/** @internal */\nexport const describeWrapped = (name, f) => V.describe(name, () => f(it));\n//# sourceMappingURL=internal.js.map","import * as internal from \"./internal/internal.js\";\n/**\n * Re-exports the `vitest` API unchanged.\n *\n * @stability unstable\n * @since 4.0.0\n */\nexport * from \"vitest\";\n/**\n * @since 4.0.0\n */\nexport const addEqualityTesters = internal.addEqualityTesters;\n/**\n * @since 4.0.0\n */\nexport const effect = internal.effect;\n/**\n * @since 4.0.0\n */\nexport const live = internal.live;\n/**\n * Share a `Layer` between multiple tests, optionally wrapping\n * the tests in a `describe` block if a name is provided.\n *\n * Named layers accept `concurrent` to override inherited suite concurrency.\n * Anonymous layers always inherit the enclosing suite's concurrency.\n * Use `ctx.expect` in concurrent tests for test-local snapshots and assertion counts.\n *\n * @since 4.0.0\n *\n * ```ts\n * import { assert, layer } from \"@effect/vitest\"\n * import { Effect, Layer, Context } from \"effect\"\n *\n * class Foo extends Context.Service<Foo, \"foo\">()(\"Foo\") {\n *   static layer = Layer.succeed(Foo, \"foo\")\n * }\n *\n * class Bar extends Context.Service<Bar, \"bar\">()(\"Bar\") {\n *   static layer = Layer.effect(\n *     Bar,\n *     Effect.map(Foo, () => \"bar\" as const)\n *   )\n * }\n *\n * layer(Foo.layer)(\"layer\", (it) => {\n *   it.effect(\"adds context\", () =>\n *     Effect.gen(function*() {\n *       const foo = yield* Foo\n *       assert.strictEqual(foo, \"foo\")\n *     }))\n *\n *   it.layer(Bar.layer)(\"nested\", (it) => {\n *     it.effect(\"adds context\", () =>\n *       Effect.gen(function*() {\n *         const foo = yield* Foo\n *         const bar = yield* Bar\n *         assert.strictEqual(foo, \"foo\")\n *         assert.strictEqual(bar, \"bar\")\n *       }))\n *   })\n * })\n * ```\n */\nexport const layer = internal.layer;\n/**\n * @since 4.0.0\n */\nexport const flakyTest = internal.flakyTest;\n/**\n * @since 4.0.0\n */\nexport const prop = internal.prop;\n/**\n * @since 4.0.0\n */\n/**\n * @since 4.0.0\n */\nexport const it = internal.it;\n/**\n * Creates the Effect test helpers for a Vitest test API, such as one extended with fixtures.\n *\n * **Details**\n *\n * Tests receive the fixtures they destructure from their context. Vitest sets them up before the test and tears\n * them down after the test's scope closes, as it does for its own tests. `it.effect.each` passes the context\n * after the test case, and named and anonymous `it.layer` blocks keep the fixtures.\n *\n * **Gotchas**\n *\n * Vitest reads the destructured names to decide which fixtures to set up. Once any fixture is defined, a test that\n * takes the whole context as a plain parameter, such as `(ctx) =>`, fails with a `FixtureParseError`. Property\n * tests receive only the base test context and cannot request fixtures; auto fixtures still run.\n *\n * **Example** (Using a Vitest fixture in an Effect test)\n *\n * ```ts\n * import { assert, makeMethods, test } from \"@effect/vitest\"\n * import { Effect } from \"effect\"\n *\n * const it = makeMethods(\n *   test.extend(\"config\", { scope: \"file\" }, () => ({ port: 3000 }))\n * )\n *\n * it.effect(\"reads the config fixture\", ({ config }) =>\n *   Effect.sync(() => {\n *     assert.strictEqual(config.port, 3000)\n *   }))\n * ```\n *\n * @since 4.0.0\n */\nexport const makeMethods = internal.makeMethods;\n/**\n * @since 4.0.0\n */\nexport const describeWrapped = internal.describeWrapped;\n//# sourceMappingURL=index.js.map"],"x_google_ignoreList":[0,1],"mappings":"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"}

package/dist/tool/Approval.d.mts

@@ -1,113 +0,0 @@
-import { y as ToolCall } from "../Items-C7MyrYPX.mjs";
-import { t as ToolResult } from "../ToolResult-BsYQRjmW.mjs";
-import { t as ToolEvent } from "../ToolEvent-Di4a723B.mjs";
-import { Data, Duration, Effect, Queue, Scope, Stream } from "effect";
-declare namespace Approval_d_exports {
-  export { ApprovalDecision, ApprovalMapEntry, FromQueueOptions, ToolCallPlan, Verdict, approvalRequested, approve, fromMap, fromQueue, reject, splitApprovalDecisions };
-}
-type ToolCallPlan = {
-  readonly approved: ReadonlyArray<ToolCall>;
-  readonly rejected: ReadonlyArray<ToolResult>;
-};
-type ApprovalDecision = Data.TaggedEnum<{
-  Approved: {
-    readonly call: ToolCall;
-  };
-  Rejected: {
-    readonly result: ToolResult;
-  };
-}>;
-declare const ApprovalDecision: {
-  readonly $is: <Tag extends "Approved" | "Rejected">(tag: Tag) => (u: unknown) => u is Extract<{
-    readonly _tag: "Approved";
-    readonly call: ToolCall;
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "Rejected";
-    readonly result: ToolResult;
-  }, {
-    readonly _tag: Tag;
-  }>;
-  readonly $match: {
-    <Cases extends { readonly [Tag in "Approved" | "Rejected"]: (args: Extract<{
-      readonly _tag: "Approved";
-      readonly call: ToolCall;
-    } | {
-      readonly _tag: "Rejected";
-      readonly result: ToolResult;
-    }, {
-      readonly _tag: Tag;
-    }>) => any; }>(cases: Cases): (value: {
-      readonly _tag: "Approved";
-      readonly call: ToolCall;
-    } | {
-      readonly _tag: "Rejected";
-      readonly result: ToolResult;
-    }) => import("effect/Unify").Unify<ReturnType<Cases["Approved" | "Rejected"]>>;
-    <Cases extends { readonly [Tag in "Approved" | "Rejected"]: (args: Extract<{
-      readonly _tag: "Approved";
-      readonly call: ToolCall;
-    } | {
-      readonly _tag: "Rejected";
-      readonly result: ToolResult;
-    }, {
-      readonly _tag: Tag;
-    }>) => any; }>(value: {
-      readonly _tag: "Approved";
-      readonly call: ToolCall;
-    } | {
-      readonly _tag: "Rejected";
-      readonly result: ToolResult;
-    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Approved" | "Rejected"]>>;
-  };
-  readonly Approved: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Approved";
-    readonly call: ToolCall;
-  }, "_tag">;
-  readonly Rejected: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Rejected";
-    readonly result: ToolResult;
-  }, "_tag">;
-};
-declare const approve: (call: ToolCall) => ApprovalDecision;
-declare const reject: (result: ToolResult) => ApprovalDecision;
-declare const splitApprovalDecisions: (decisions: ReadonlyArray<ApprovalDecision>) => ToolCallPlan;
-declare const approvalRequested: (call: ToolCall) => ToolEvent;
-type Verdict = {
-  readonly call_id: string;
-  readonly decision: "approve" | "deny";
-  readonly reason?: string;
-};
-type FromQueueOptions = {
-  /**
-   * Resolve any still-pending gated call as `cancelled` once this elapses,
-   * so a lost or never-sent verdict cannot hang the decisions stream
-   * forever. Omit to wait indefinitely.
-   */
-  readonly timeout?: Duration.Input;
-};
-/**
- * Queue-backed approval planner. Safe calls are returned immediately in
- * `approved`; gated calls emit `ApprovalRequested` events and later produce
- * one `ApprovalDecision` when their matching verdict arrives.
- *
- * The verdict queue is a single-consumer transport: run one approval round
- * at a time (the router retires once every gated call of the round is
- * resolved). For overlapping rounds, use one queue per round.
- */
-declare const fromQueue: (predicate: (call: ToolCall) => boolean, verdicts: Queue.Dequeue<Verdict>, options?: FromQueueOptions) => (calls: ReadonlyArray<ToolCall>) => Effect.Effect<{
-  readonly approved: ReadonlyArray<ToolCall>;
-  readonly decisions: Stream.Stream<ApprovalDecision>;
-  readonly approvalRequests: Stream.Stream<ToolEvent>;
-}, never, Scope.Scope>;
-type ApprovalMapEntry = {
-  readonly decision: "approve";
-} | {
-  readonly decision: "deny";
-  readonly reason?: string;
-};
-declare const fromMap: (predicate: (call: ToolCall) => boolean, approvals: ReadonlyMap<string, ApprovalMapEntry>) => (calls: ReadonlyArray<ToolCall>) => ToolCallPlan;
-//#endregion
-export { ApprovalDecision, ApprovalMapEntry, FromQueueOptions, ToolCallPlan, Verdict, approvalRequested, approve, fromMap, fromQueue, reject, splitApprovalDecisions, Approval_d_exports as t };
-//# sourceMappingURL=Approval.d.mts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"Approval.d.mts","names":[],"sources":["../../src/tool/Approval.ts"],"mappings":";;;;;;;KAYY;WACD,UAAU,cAAc;WACxB,UAAU,cAAc;;KAGvB,mBAAmB,KAAK;EAClC;aAAqB,MAAM;;EAC3B;aAAqB,QAAQ;;;cAGlB;;;aAJgB,MAAA;;;;;aACE,QAAA;;;;;;;eADF,MAAA;;;eACE,QAAA;;;;;;;;;;;;eADF,MAAA;;;eACE,QAAA;;;;;;;;;;;;;aADF,MAAA;;;;aACE,QAAA;;;cAKlB,UAAO,MAAU,aAAW;cAE5B,SAAM,QAAY,eAAa;cAG/B,yBAAsB,WAAe,cAAc,sBAAoB;cASvE,oBAAiB,MAAU,aAAW;KAWvC;WACD;WACA;WACA;;KAGC;;;;;;WAMD,UAAU,SAAS;;;;;;;;;;;cAYjB,YAAS,YAEN,MAAM,sBAAoB,UAC5B,MAAM,QAAQ,UAAQ,UACtB,sBAAgB,OAGnB,cAAc,cACpB,OAAO;WAEG,UAAU,cAAc;WACxB,WAAW,OAAO,OAAO;WACzB,kBAAkB,OAAO,OAAO;UAG3C,MAAM;KA8EE;WACG;;WACA;WAA2B;;cAE7B,UAAO,YACL,MAAM,sBAAoB,WAAa,oBAAoB,uBAAiB,OACjF,cAAc,cAAY"}

package/dist/tool/Approval.mjs

@@ -1,80 +0,0 @@
-import { n as __exportAll } from "../rolldown-runtime-EAsCxrDo.mjs";
-import { cancelled, denied } from "./ToolResult.mjs";
-import { ToolEvent } from "./ToolEvent.mjs";
-import { Data, Deferred, Effect, Queue, Ref, Stream } from "effect";
-//#region src/tool/Approval.ts
-/**
-* Approval helpers for the two transport flavors.
-*
-* These helpers only decide which calls are approved and which synthetic
-* results must be returned to the model. Tool execution stays explicit at
-* the recipe boundary via `Toolkit.run`.
-*/
-var Approval_exports = /* @__PURE__ */ __exportAll({
-	ApprovalDecision: () => ApprovalDecision,
-	approvalRequested: () => approvalRequested,
-	approve: () => approve,
-	fromMap: () => fromMap,
-	fromQueue: () => fromQueue,
-	reject: () => reject,
-	splitApprovalDecisions: () => splitApprovalDecisions
-});
-const ApprovalDecision = Data.taggedEnum();
-const approve = (call) => ApprovalDecision.Approved({ call });
-const reject = (result) => ApprovalDecision.Rejected({ result });
-const splitApprovalDecisions = (decisions) => decisions.reduce((acc, decision) => decision._tag === "Approved" ? {
-	...acc,
-	approved: [...acc.approved, decision.call]
-} : {
-	...acc,
-	rejected: [...acc.rejected, decision.result]
-}, {
-	approved: [],
-	rejected: []
-});
-const approvalRequested = (call) => ToolEvent.ApprovalRequested({
-	call_id: call.call_id,
-	tool: call.name,
-	arguments: call.arguments
-});
-/**
-* Queue-backed approval planner. Safe calls are returned immediately in
-* `approved`; gated calls emit `ApprovalRequested` events and later produce
-* one `ApprovalDecision` when their matching verdict arrives.
-*
-* The verdict queue is a single-consumer transport: run one approval round
-* at a time (the router retires once every gated call of the round is
-* resolved). For overlapping rounds, use one queue per round.
-*/
-const fromQueue = (predicate, verdicts, options) => (calls) => Effect.gen(function* () {
-	const gated = calls.filter(predicate);
-	const approved = calls.filter((call) => !predicate(call));
-	const entries = yield* Effect.forEach(gated, (call) => Deferred.make().pipe(Effect.map((d) => [call.call_id, d])));
-	const deferreds = new Map(entries);
-	const callById = new Map(gated.map((c) => [c.call_id, c]));
-	const outstanding = yield* Ref.make(gated.length);
-	const resolve = (call, decision) => Deferred.succeed(deferreds.get(call.call_id), decision).pipe(Effect.flatMap((won) => won ? Ref.update(outstanding, (n) => n - 1) : Effect.void));
-	const route = Effect.suspend(() => Ref.get(outstanding).pipe(Effect.flatMap((n) => n <= 0 ? Effect.void : Queue.take(verdicts).pipe(Effect.flatMap((v) => {
-		const call = callById.get(v.call_id);
-		return (call === void 0 ? Effect.void : resolve(call, v.decision === "approve" ? approve(call) : reject(denied(call, v.reason)))).pipe(Effect.andThen(route));
-	})))));
-	if (gated.length > 0) {
-		yield* Effect.forkScoped(route);
-		if (options?.timeout !== void 0) yield* Effect.forkScoped(Effect.sleep(options.timeout).pipe(Effect.andThen(Effect.forEach(gated, (call) => resolve(call, reject(cancelled(call, "approval timed out")))))));
-	}
-	return {
-		approved,
-		decisions: Stream.fromIterable(gated).pipe(Stream.flatMap((call) => Stream.fromEffect(Deferred.await(deferreds.get(call.call_id))), { concurrency: "unbounded" })),
-		approvalRequests: Stream.fromIterable(gated.map(approvalRequested))
-	};
-});
-const fromMap = (predicate, approvals) => (calls) => splitApprovalDecisions(calls.map((call) => {
-	if (!predicate(call)) return approve(call);
-	const v = approvals.get(call.call_id);
-	if (v === void 0) return reject(cancelled(call));
-	return v.decision === "approve" ? approve(call) : reject(denied(call, v.reason));
-}));
-//#endregion
-export { ApprovalDecision, approvalRequested, approve, fromMap, fromQueue, reject, splitApprovalDecisions, Approval_exports as t };
-
-//# sourceMappingURL=Approval.mjs.map

package/dist/tool/Approval.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"Approval.mjs","names":[],"sources":["../../src/tool/Approval.ts"],"sourcesContent":["/**\n * Approval helpers for the two transport flavors.\n *\n * These helpers only decide which calls are approved and which synthetic\n * results must be returned to the model. Tool execution stays explicit at\n * the recipe boundary via `Toolkit.run`.\n */\nimport { Data, Deferred, type Duration, Effect, Queue, Ref, Scope, Stream } from \"effect\"\nimport type { ToolCall } from \"../domain/Items.js\"\nimport { type ToolResult, cancelled, denied } from \"./ToolResult.js\"\nimport { ToolEvent } from \"./ToolEvent.js\"\n\nexport type ToolCallPlan = {\n  readonly approved: ReadonlyArray<ToolCall>\n  readonly rejected: ReadonlyArray<ToolResult>\n}\n\nexport type ApprovalDecision = Data.TaggedEnum<{\n  Approved: { readonly call: ToolCall }\n  Rejected: { readonly result: ToolResult }\n}>\n\nexport const ApprovalDecision = Data.taggedEnum<ApprovalDecision>()\n\nexport const approve = (call: ToolCall): ApprovalDecision => ApprovalDecision.Approved({ call })\n\nexport const reject = (result: ToolResult): ApprovalDecision =>\n  ApprovalDecision.Rejected({ result })\n\nexport const splitApprovalDecisions = (decisions: ReadonlyArray<ApprovalDecision>): ToolCallPlan =>\n  decisions.reduce<ToolCallPlan>(\n    (acc, decision) =>\n      decision._tag === \"Approved\"\n        ? { ...acc, approved: [...acc.approved, decision.call] }\n        : { ...acc, rejected: [...acc.rejected, decision.result] },\n    { approved: [], rejected: [] },\n  )\n\nexport const approvalRequested = (call: ToolCall): ToolEvent =>\n  ToolEvent.ApprovalRequested({\n    call_id: call.call_id,\n    tool: call.name,\n    arguments: call.arguments,\n  })\n\n// ---------------------------------------------------------------------------\n// Verdict queue (WebSocket-style transport).\n// ---------------------------------------------------------------------------\n\nexport type Verdict = {\n  readonly call_id: string\n  readonly decision: \"approve\" | \"deny\"\n  readonly reason?: string\n}\n\nexport type FromQueueOptions = {\n  /**\n   * Resolve any still-pending gated call as `cancelled` once this elapses,\n   * so a lost or never-sent verdict cannot hang the decisions stream\n   * forever. Omit to wait indefinitely.\n   */\n  readonly timeout?: Duration.Input\n}\n\n/**\n * Queue-backed approval planner. Safe calls are returned immediately in\n * `approved`; gated calls emit `ApprovalRequested` events and later produce\n * one `ApprovalDecision` when their matching verdict arrives.\n *\n * The verdict queue is a single-consumer transport: run one approval round\n * at a time (the router retires once every gated call of the round is\n * resolved). For overlapping rounds, use one queue per round.\n */\nexport const fromQueue =\n  (\n    predicate: (call: ToolCall) => boolean,\n    verdicts: Queue.Dequeue<Verdict>,\n    options?: FromQueueOptions,\n  ) =>\n  (\n    calls: ReadonlyArray<ToolCall>,\n  ): Effect.Effect<\n    {\n      readonly approved: ReadonlyArray<ToolCall>\n      readonly decisions: Stream.Stream<ApprovalDecision>\n      readonly approvalRequests: Stream.Stream<ToolEvent>\n    },\n    never,\n    Scope.Scope\n  > =>\n    Effect.gen(function* () {\n      const gated = calls.filter(predicate)\n      const approved = calls.filter((call) => !predicate(call))\n\n      const entries = yield* Effect.forEach(gated, (call) =>\n        Deferred.make<ApprovalDecision>().pipe(Effect.map((d) => [call.call_id, d] as const)),\n      )\n      const deferreds: ReadonlyMap<string, Deferred.Deferred<ApprovalDecision>> = new Map(entries)\n      const callById: ReadonlyMap<string, ToolCall> = new Map(gated.map((c) => [c.call_id, c]))\n      const outstanding = yield* Ref.make(gated.length)\n\n      // Complete a deferred once; decrement only on the winning transition so\n      // a late verdict for an already-resolved call is a no-op.\n      const resolve = (call: ToolCall, decision: ApprovalDecision) =>\n        Deferred.succeed(deferreds.get(call.call_id)!, decision).pipe(\n          Effect.flatMap((won) => (won ? Ref.update(outstanding, (n) => n - 1) : Effect.void)),\n        )\n\n      // Router retires once every gated call is resolved (by verdict or\n      // timeout), so sequential rounds over one queue do not accumulate\n      // racing routers. Recursive + suspended: stack-safe, no imperative loop.\n      const route: Effect.Effect<void> = Effect.suspend(() =>\n        Ref.get(outstanding).pipe(\n          Effect.flatMap((n) =>\n            n <= 0\n              ? Effect.void\n              : Queue.take(verdicts).pipe(\n                  Effect.flatMap((v) => {\n                    const call = callById.get(v.call_id)\n                    return (\n                      call === undefined\n                        ? Effect.void\n                        : resolve(\n                            call,\n                            v.decision === \"approve\"\n                              ? approve(call)\n                              : reject(denied(call, v.reason)),\n                          )\n                    ).pipe(Effect.andThen(route))\n                  }),\n                ),\n          ),\n        ),\n      )\n\n      if (gated.length > 0) {\n        yield* Effect.forkScoped(route)\n        if (options?.timeout !== undefined) {\n          yield* Effect.forkScoped(\n            Effect.sleep(options.timeout).pipe(\n              Effect.andThen(\n                Effect.forEach(gated, (call) =>\n                  resolve(call, reject(cancelled(call, \"approval timed out\"))),\n                ),\n              ),\n            ),\n          )\n        }\n      }\n\n      const decisions = Stream.fromIterable(gated).pipe(\n        Stream.flatMap((call) => Stream.fromEffect(Deferred.await(deferreds.get(call.call_id)!)), {\n          concurrency: \"unbounded\",\n        }),\n      )\n\n      const approvalRequests = Stream.fromIterable<ToolEvent>(gated.map(approvalRequested))\n\n      return { approved, decisions, approvalRequests }\n    })\n\n// ---------------------------------------------------------------------------\n// Approval map (HTTP-style transport). Verdicts arrive synchronously\n// bundled in the request payload. Missing entries → cancelled.\n// ---------------------------------------------------------------------------\n\nexport type ApprovalMapEntry =\n  | { readonly decision: \"approve\" }\n  | { readonly decision: \"deny\"; readonly reason?: string }\n\nexport const fromMap =\n  (predicate: (call: ToolCall) => boolean, approvals: ReadonlyMap<string, ApprovalMapEntry>) =>\n  (calls: ReadonlyArray<ToolCall>): ToolCallPlan =>\n    splitApprovalDecisions(\n      calls.map((call) => {\n        if (!predicate(call)) return approve(call)\n        const v = approvals.get(call.call_id)\n        if (v === undefined) return reject(cancelled(call))\n        return v.decision === \"approve\" ? approve(call) : reject(denied(call, v.reason))\n      }),\n    )\n"],"mappings":"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"}