@effect-uai/core 0.5.2 → 0.6.0

package/dist/Turn-0CwCAyVe.d.mts

@@ -1,388 +0,0 @@
-import { i as ImageSource } from "./Image-HNmMpMTh.mjs";
-import { d as Item, g as Reasoning, o as FunctionCall, p as Message, s as FunctionCallOutput, x as Usage } from "./Items-BH8xUkoR.mjs";
-import { i as StructuredFormat, n as JsonParseError, r as StructuredDecodeError } from "./StructuredFormat-BbN4dosH.mjs";
-import { Data, Effect, Schema, Stream } from "effect";
-import * as _$effect_Types0 from "effect/Types";
-import * as _$effect_Cause0 from "effect/Cause";
-import * as _$effect_Unify0 from "effect/Unify";
-
-//#region src/domain/Turn.d.ts
-declare namespace Turn_d_exports {
-  export { InteractionEvent, RefusalRejected, Turn, TurnEvent, appendTurn, assistantMessages, assistantText, assistantTexts, functionCalls, isTurnComplete, reasonings, textDeltas, toStructured };
-}
-/**
- * The result of a single LLM generation. A turn produces zero or more items
- * (typically one assistant message and zero or more function_call items)
- * and reports usage + a stop reason.
- */
-declare const Turn: Schema.Struct<{
-  readonly items: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-    readonly type: Schema.Literal<"message">;
-    readonly role: Schema.Literals<readonly ["user", "assistant", "system"]>;
-    readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-      readonly type: Schema.Literal<"input_text">;
-      readonly text: Schema.String;
-    }>, Schema.Struct<{
-      readonly type: Schema.Literal<"input_image">;
-      readonly source: Schema.Schema<ImageSource>;
-    }>, Schema.Struct<{
-      readonly type: Schema.Literal<"output_text">;
-      readonly text: Schema.String;
-      readonly annotations: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-        readonly type: Schema.Literal<"url_citation">;
-        readonly url: Schema.String;
-        readonly start_index: Schema.Number;
-        readonly end_index: Schema.Number;
-        readonly title: Schema.String;
-      }>, Schema.Struct<{
-        readonly type: Schema.Literal<"file_citation">;
-        readonly file_id: Schema.String;
-        readonly index: Schema.Number;
-      }>, Schema.Struct<{
-        readonly type: Schema.Literal<"container_file_citation">;
-        readonly container_id: Schema.String;
-        readonly file_id: Schema.String;
-        readonly start_index: Schema.Number;
-        readonly end_index: Schema.Number;
-      }>, Schema.Struct<{
-        readonly type: Schema.Literal<"file_path">;
-        readonly file_id: Schema.String;
-        readonly index: Schema.Number;
-      }>]>>>;
-    }>, Schema.Struct<{
-      readonly type: Schema.Literal<"refusal">;
-      readonly text: Schema.String;
-    }>]>>;
-    readonly providerData: Schema.optional<Schema.Unknown>;
-  }>, Schema.Struct<{
-    readonly type: Schema.Literal<"function_call">;
-    readonly call_id: Schema.String;
-    readonly name: Schema.String;
-    readonly arguments: Schema.String;
-    readonly providerData: Schema.optional<Schema.Unknown>;
-  }>, Schema.Struct<{
-    readonly type: Schema.Literal<"function_call_output">;
-    readonly call_id: Schema.String;
-    readonly output: Schema.String;
-    readonly providerData: Schema.optional<Schema.Unknown>;
-  }>, Schema.Struct<{
-    readonly type: Schema.Literal<"reasoning">;
-    readonly id: Schema.optional<Schema.String>;
-    readonly summary: Schema.optional<Schema.String>;
-    readonly signature: Schema.optional<Schema.String>;
-    readonly providerData: Schema.optional<Schema.Unknown>;
-  }>]>>;
-  readonly usage: Schema.Struct<{
-    readonly input_tokens: Schema.optional<Schema.Number>;
-    readonly output_tokens: Schema.optional<Schema.Number>;
-    readonly total_tokens: Schema.optional<Schema.Number>;
-    readonly input_tokens_details: Schema.optional<Schema.Struct<{
-      readonly cached_tokens: Schema.optional<Schema.Number>;
-    }>>;
-    readonly output_tokens_details: Schema.optional<Schema.Struct<{
-      readonly reasoning_tokens: Schema.optional<Schema.Number>;
-    }>>;
-  }>;
-  readonly stop_reason: Schema.Literals<readonly ["stop", "tool_calls", "max_tokens", "refusal", "content_filter", "max_tool_calls"]>;
-}>;
-type Turn = typeof Turn.Type;
-/**
- * Canonical events emitted while a single turn is being generated. Most
- * variants are streaming deltas (text, reasoning, tool-call args); the
- * terminal `TurnComplete` carries the assembled `Turn`. Lifecycle members
- * aren't deltas, hence the union name.
- *
- * `ReasoningDelta.kind`: `trace` is the model's raw chain-of-thought;
- * `summary` is a model-written summary intended for display. OpenAI
- * Responses emits both; Anthropic and Gemini only emit `trace`.
- *
- * `RefusalDelta`: the model declined to answer. OpenAI Responses emits
- * this as its own event; Anthropic surfaces refusals via `stop_reason`
- * and Gemini collapses them into `finishReason: SAFETY` — both go
- * without a `RefusalDelta`.
- *
- * `UsageUpdate`: mid-stream cumulative usage. Anthropic emits this on
- * `message_start` and `message_delta`; other providers may only deliver
- * usage via `TurnComplete.turn.usage`.
- */
-type TurnEvent = Data.TaggedEnum<{
-  TextDelta: {
-    readonly text: string;
-  };
-  ReasoningDelta: {
-    readonly text: string;
-    readonly kind: "trace" | "summary";
-  };
-  RefusalDelta: {
-    readonly text: string;
-  };
-  ToolCallStart: {
-    readonly call_id: string;
-    readonly name: string;
-  };
-  ToolCallArgsDelta: {
-    readonly call_id: string;
-    readonly delta: string;
-  };
-  UsageUpdate: {
-    readonly usage: Usage;
-  };
-  TurnComplete: {
-    readonly turn: Turn;
-  };
-}>;
-declare const TurnEvent: {
-  readonly TextDelta: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "TextDelta";
-    readonly text: string;
-  }, "_tag">;
-  readonly ReasoningDelta: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "ReasoningDelta";
-    readonly text: string;
-    readonly kind: "trace" | "summary";
-  }, "_tag">;
-  readonly RefusalDelta: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "RefusalDelta";
-    readonly text: string;
-  }, "_tag">;
-  readonly ToolCallStart: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "ToolCallStart";
-    readonly call_id: string;
-    readonly name: string;
-  }, "_tag">;
-  readonly ToolCallArgsDelta: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "ToolCallArgsDelta";
-    readonly call_id: string;
-    readonly delta: string;
-  }, "_tag">;
-  readonly UsageUpdate: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "UsageUpdate";
-    readonly usage: Usage;
-  }, "_tag">;
-  readonly TurnComplete: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "TurnComplete";
-    readonly turn: Turn;
-  }, "_tag">;
-  readonly $is: <Tag extends "TextDelta" | "ReasoningDelta" | "RefusalDelta" | "ToolCallStart" | "ToolCallArgsDelta" | "UsageUpdate" | "TurnComplete">(tag: Tag) => (u: unknown) => u is Extract<{
-    readonly _tag: "TextDelta";
-    readonly text: string;
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "ReasoningDelta";
-    readonly text: string;
-    readonly kind: "trace" | "summary";
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "RefusalDelta";
-    readonly text: string;
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "ToolCallStart";
-    readonly call_id: string;
-    readonly name: string;
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "ToolCallArgsDelta";
-    readonly call_id: string;
-    readonly delta: string;
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "UsageUpdate";
-    readonly usage: Usage;
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "TurnComplete";
-    readonly turn: Turn;
-  }, {
-    readonly _tag: Tag;
-  }>;
-  readonly $match: {
-    <Cases extends {
-      readonly TextDelta: (args: {
-        readonly _tag: "TextDelta";
-        readonly text: string;
-      }) => any;
-      readonly ReasoningDelta: (args: {
-        readonly _tag: "ReasoningDelta";
-        readonly text: string;
-        readonly kind: "trace" | "summary";
-      }) => any;
-      readonly RefusalDelta: (args: {
-        readonly _tag: "RefusalDelta";
-        readonly text: string;
-      }) => any;
-      readonly ToolCallStart: (args: {
-        readonly _tag: "ToolCallStart";
-        readonly call_id: string;
-        readonly name: string;
-      }) => any;
-      readonly ToolCallArgsDelta: (args: {
-        readonly _tag: "ToolCallArgsDelta";
-        readonly call_id: string;
-        readonly delta: string;
-      }) => any;
-      readonly UsageUpdate: (args: {
-        readonly _tag: "UsageUpdate";
-        readonly usage: Usage;
-      }) => any;
-      readonly TurnComplete: (args: {
-        readonly _tag: "TurnComplete";
-        readonly turn: Turn;
-      }) => any;
-    }>(cases: Cases): (value: {
-      readonly _tag: "TextDelta";
-      readonly text: string;
-    } | {
-      readonly _tag: "ReasoningDelta";
-      readonly text: string;
-      readonly kind: "trace" | "summary";
-    } | {
-      readonly _tag: "RefusalDelta";
-      readonly text: string;
-    } | {
-      readonly _tag: "ToolCallStart";
-      readonly call_id: string;
-      readonly name: string;
-    } | {
-      readonly _tag: "ToolCallArgsDelta";
-      readonly call_id: string;
-      readonly delta: string;
-    } | {
-      readonly _tag: "UsageUpdate";
-      readonly usage: Usage;
-    } | {
-      readonly _tag: "TurnComplete";
-      readonly turn: Turn;
-    }) => _$effect_Unify0.Unify<ReturnType<Cases["TextDelta" | "ReasoningDelta" | "RefusalDelta" | "ToolCallStart" | "ToolCallArgsDelta" | "UsageUpdate" | "TurnComplete"]>>;
-    <Cases extends {
-      readonly TextDelta: (args: {
-        readonly _tag: "TextDelta";
-        readonly text: string;
-      }) => any;
-      readonly ReasoningDelta: (args: {
-        readonly _tag: "ReasoningDelta";
-        readonly text: string;
-        readonly kind: "trace" | "summary";
-      }) => any;
-      readonly RefusalDelta: (args: {
-        readonly _tag: "RefusalDelta";
-        readonly text: string;
-      }) => any;
-      readonly ToolCallStart: (args: {
-        readonly _tag: "ToolCallStart";
-        readonly call_id: string;
-        readonly name: string;
-      }) => any;
-      readonly ToolCallArgsDelta: (args: {
-        readonly _tag: "ToolCallArgsDelta";
-        readonly call_id: string;
-        readonly delta: string;
-      }) => any;
-      readonly UsageUpdate: (args: {
-        readonly _tag: "UsageUpdate";
-        readonly usage: Usage;
-      }) => any;
-      readonly TurnComplete: (args: {
-        readonly _tag: "TurnComplete";
-        readonly turn: Turn;
-      }) => any;
-    }>(value: {
-      readonly _tag: "TextDelta";
-      readonly text: string;
-    } | {
-      readonly _tag: "ReasoningDelta";
-      readonly text: string;
-      readonly kind: "trace" | "summary";
-    } | {
-      readonly _tag: "RefusalDelta";
-      readonly text: string;
-    } | {
-      readonly _tag: "ToolCallStart";
-      readonly call_id: string;
-      readonly name: string;
-    } | {
-      readonly _tag: "ToolCallArgsDelta";
-      readonly call_id: string;
-      readonly delta: string;
-    } | {
-      readonly _tag: "UsageUpdate";
-      readonly usage: Usage;
-    } | {
-      readonly _tag: "TurnComplete";
-      readonly turn: Turn;
-    }, cases: Cases): _$effect_Unify0.Unify<ReturnType<Cases["TextDelta" | "ReasoningDelta" | "RefusalDelta" | "ToolCallStart" | "ToolCallArgsDelta" | "UsageUpdate" | "TurnComplete"]>>;
-  };
-};
-/**
- * What flows out of an agent loop body to its consumer per turn: every
- * `TurnEvent` the provider emits (including the terminal `TurnComplete`
- * carrying the assembled `Turn`), plus the output of any tool the loop ran.
- * Both variants carry a `_tag` discriminator.
- */
-type InteractionEvent = TurnEvent | FunctionCallOutput;
-declare const isTurnComplete: (u: unknown) => u is {
-  readonly _tag: "TurnComplete";
-  readonly turn: Turn;
-};
-declare const functionCalls: (turn: Turn) => ReadonlyArray<FunctionCall>;
-declare const reasonings: (turn: Turn) => ReadonlyArray<Reasoning>;
-declare const assistantMessages: (turn: Turn) => ReadonlyArray<Message>;
-/**
- * Every `output_text` payload across every assistant message in the turn,
- * preserving order. Refusals and other content blocks are dropped — use
- * `assistantMessages` if you need to inspect them. The primitive for
- * "give me the assistant's text"; callers decide how to combine
- * (typically `.join("")` for prose or `.join(" ")` for log strings).
- */
-declare const assistantTexts: (turn: Turn) => ReadonlyArray<string>;
-/**
- * Sugar over `assistantTexts(turn).join("")` — the common case for
- * summarizers, classifiers, judge calls, and structured-output backstops
- * that want one concatenated string.
- */
-declare const assistantText: (turn: Turn) => string;
-/**
- * Append a completed turn and optional follow-up items to a state record's
- * history. Recipes use this at the point where structured tool results are
- * converted to model-facing `FunctionCallOutput`s.
- */
-declare const appendTurn: <S extends {
-  readonly history: ReadonlyArray<Item>;
-}>(state: S, turn: Turn, items?: ReadonlyArray<Item>) => S;
-/**
- * Project a `TurnEvent` stream onto its `TextDelta` payloads. Other
- * variants are dropped. Composes with `Lines.lines` +
- * `decodeJsonLines` for prompted-JSONL streaming.
- */
-declare const textDeltas: <E, R>(self: Stream.Stream<TurnEvent, E, R>) => Stream.Stream<string, E, R>;
-declare const RefusalRejected_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
-  readonly _tag: "RefusalRejected";
-} & Readonly<A>;
-/**
- * The assistant message on the just-completed turn was a refusal block,
- * not an `output_text` payload. Returned by `toStructured` to short-circuit
- * decoding before `JSON.parse` / schema validation runs.
- */
-declare class RefusalRejected extends RefusalRejected_base<{
-  readonly turn: Turn;
-}> {}
-/**
- * Validate a completed `Turn` against a `StructuredFormat`. Concatenates
- * `output_text` blocks on the last assistant message, then runs
- * `JSON.parse` + the format's schema validation.
- *
- * Three failure modes:
- * - `RefusalRejected` — the assistant emitted a refusal block.
- * - `JsonParseError` — the assembled text wasn't valid JSON.
- * - `StructuredDecodeError` — the JSON didn't match the schema.
- */
-declare const toStructured: <A>(turn: Turn, format: StructuredFormat<A>) => Effect.Effect<A, RefusalRejected | JsonParseError | StructuredDecodeError>;
-//#endregion
-export { Turn_d_exports as a, assistantText as c, isTurnComplete as d, reasonings as f, TurnEvent as i, assistantTexts as l, toStructured as m, RefusalRejected as n, appendTurn as o, textDeltas as p, Turn as r, assistantMessages as s, InteractionEvent as t, functionCalls as u };
-//# sourceMappingURL=Turn-0CwCAyVe.d.mts.map

package/dist/Turn-0CwCAyVe.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Turn-0CwCAyVe.d.mts","names":[],"sources":["../src/domain/Turn.ts"],"mappings":";;;;;;;;;;;;;;;;;cAmBa,IAAA,EAAI,MAAA,CAAA,MAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAKL,IAAA,UAAc,IAAA,CAAK,IAAA;;;;;;;;;;;;;;;;;;;;KAqBnB,SAAA,GAAY,IAAA,CAAK,UAAA;EAC3B,SAAA;IAAA,SAAsB,IAAA;EAAA;EACtB,cAAA;IAAA,SAA2B,IAAA;IAAA,SAAuB,IAAA;EAAA;EAClD,YAAA;IAAA,SAAyB,IAAA;EAAA;EACzB,aAAA;IAAA,SAA0B,OAAA;IAAA,SAA0B,IAAA;EAAA;EACpD,iBAAA;IAAA,SAA8B,OAAA;IAAA,SAA0B,KAAA;EAAA;EACxD,WAAA;IAAA,SAAwB,KAAA,EAAO,KAAA;EAAA;EAC/B,YAAA;IAAA,SAAyB,IAAA,EAAM,IAAA;EAAA;AAAA;AAAA,cAGpB,SAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;oBAJoB,KAAA;EAAA;EAAA;;mBACA,IAAA;EAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBADA,KAAA;EAAA;IAAA;;;mBACA,IAAA;EAAA;IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBADA,KAAA;MAAA;MAAA;;uBACA,IAAA;MAAA;IAAA;;;;;;;;;;;;;;;;;;;;sBADA,KAAA;IAAA;MAAA;qBACA,IAAA;IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;wBADA,KAAA;MAAA;MAAA;;uBACA,IAAA;MAAA;IAAA;;;;;;;;;;;;;;;;;;;;sBADA,KAAA;IAAA;MAAA;qBACA,IAAA;IAAA;;;;;;;;;KAWrB,gBAAA,GAAmB,SAAA,GAAY,kBAAA;AAAA,cAE9B,cAAA,GAAc,CAAA,cAAA,CAAA;EAAA;iBAbM,IAAA;AAAA;AAAA,cAepB,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;;;;;;;;cAUhD,cAAA,GAAkB,IAAA,EAAM,IAAA,KAAO,aAAA;;;;;;cAW/B,aAAA,GAAiB,IAAA,EAAM,IAAA;;;;;AAjDpC;cAwDa,UAAA;EAAA,SAAmC,OAAA,EAAS,aAAA,CAAc,IAAA;AAAA,GACrE,KAAA,EAAO,CAAA,EACP,IAAA,EAAM,IAAA,EACN,KAAA,GAAO,aAAA,CAAc,IAAA,MACpB,CAAA;;;;;;cAcU,UAAA,SACX,IAAA,EAAM,MAAA,CAAO,MAAA,CAAO,SAAA,EAAW,CAAA,EAAG,CAAA,MACjC,MAAA,CAAO,MAAA,SAAe,CAAA,EAAG,CAAA;AAAA,cAGzB,oBAAA;;;;;;;;cAWU,eAAA,SAAwB,oBAAA;EAAA,SAC1B,IAAA,EAAM,IAAA;AAAA;;;;;;;;;;AAjFjB;cA0Ga,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/tool/Outcome.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Outcome.d.mts","names":[],"sources":["../../src/tool/Outcome.ts"],"mappings":";;;;;;;;KAqBY,UAAA,GAAa,IAAA,CAAK,UAAA;EAC5B,KAAA;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,OAAA,GAAO,CAAA,cAAA,CAAA;EAAA;;;;;cACP,SAAA,GAAS,CAAA,cAAA,CAAA;EAAA;;;;;;cAMT,QAAA,GAAY,IAAA,EAAM,YAAA,EAAc,IAAA,UAAc,MAAA,cAAkB,UAAA;;cAShE,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/tool/Outcome.mjs

@@ -1,61 +0,0 @@
-import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
-import { functionCallOutput } from "../domain/Items.mjs";
-import { Data } from "effect";
-//#region src/tool/Outcome.ts
-/**
-* Post-execution and synthetic tool results.
-*
-*   - Executed tools emit ToolResult.Value.
-*   - Approval/cancellation policy emits synthetic ToolResult.Failure.
-*
-* Wire conversion stays at the recipe boundary via `toFunctionCallOutput`
-* so recipes can inspect, redact, or audit values before serialization.
-*
-* `output` and `reason` are `string`, not `unknown`: the wire wants strings,
-* and `unknown` would invite non-serializable values (Date, Map, BigInt,
-* fn). Recipes that want structured detail JSON.stringify themselves.
-*/
-var Outcome_exports = /* @__PURE__ */ __exportAll({
-	ToolResult: () => ToolResult,
-	cancelled: () => cancelled,
-	denied: () => denied,
-	executionError: () => executionError,
-	isFailure: () => isFailure,
-	isValue: () => isValue,
-	rejected: () => rejected,
-	toFunctionCallOutput: () => toFunctionCallOutput
-});
-/**
-* Namespace of constructors, type guards, and matchers for `ToolResult`,
-* provided by `Data.taggedEnum`. Use `ToolResult.$is("Value")` for type
-* narrowing and `ToolResult.$match({ Value, Failure })` for exhaustive
-* pattern matching. Synthetic-result helpers (`denied`, `cancelled`,
-* `executionError`, `rejected`) below are kinder constructors than the
-* raw `ToolResult.Failure(...)`.
-*/
-const ToolResult = Data.taggedEnum();
-const isValue = ToolResult.$is("Value");
-const isFailure = ToolResult.$is("Failure");
-const rejected = (call, kind, reason) => ToolResult.Failure({
-	call_id: call.call_id,
-	tool: call.name,
-	kind,
-	...reason !== void 0 ? { reason } : {}
-});
-/** Explicit user/policy rejection. */
-const denied = (call, reason) => rejected(call, "denied", reason);
-/** Implicit non-answer (follow-up, inactivity, abort). */
-const cancelled = (call, reason) => rejected(call, "cancelled", reason);
-/** Tool's own execution failed (parse error, schema, runtime crash). */
-const executionError = (call, reason) => rejected(call, "execution_error", reason);
-const toFunctionCallOutput = (r) => ToolResult.$match(r, {
-	Value: (v) => functionCallOutput(v.call_id, JSON.stringify(v.value)),
-	Failure: (f) => functionCallOutput(f.call_id, JSON.stringify(f.reason !== void 0 ? {
-		kind: f.kind,
-		reason: f.reason
-	} : { kind: f.kind }))
-});
-//#endregion
-export { ToolResult, cancelled, denied, executionError, isFailure, isValue, rejected, Outcome_exports as t, toFunctionCallOutput };
-
-//# sourceMappingURL=Outcome.mjs.map

package/dist/tool/Outcome.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"Outcome.mjs","names":[],"sources":["../../src/tool/Outcome.ts"],"sourcesContent":["/**\n * Post-execution and synthetic tool results.\n *\n *   - Executed tools emit ToolResult.Value.\n *   - Approval/cancellation policy emits synthetic ToolResult.Failure.\n *\n * Wire conversion stays at the recipe boundary via `toFunctionCallOutput`\n * so recipes can inspect, redact, or audit values before serialization.\n *\n * `output` and `reason` are `string`, not `unknown`: the wire wants strings,\n * and `unknown` would invite non-serializable values (Date, Map, BigInt,\n * fn). Recipes that want structured detail JSON.stringify themselves.\n */\nimport { Data } from \"effect\"\nimport type { FunctionCall, FunctionCallOutput } from \"../domain/Items.js\"\nimport { functionCallOutput } from \"../domain/Items.js\"\n\n// ---------------------------------------------------------------------------\n// ToolResult\n// ---------------------------------------------------------------------------\n\nexport type ToolResult = Data.TaggedEnum<{\n  Value: {\n    readonly call_id: string\n    readonly tool: string\n    readonly value: unknown\n  }\n  Failure: {\n    readonly call_id: string\n    readonly tool: string\n    readonly kind: string\n    readonly reason?: string\n  }\n}>\n\n/**\n * Namespace of constructors, type guards, and matchers for `ToolResult`,\n * provided by `Data.taggedEnum`. Use `ToolResult.$is(\"Value\")` for type\n * narrowing and `ToolResult.$match({ Value, Failure })` for exhaustive\n * pattern matching. Synthetic-result helpers (`denied`, `cancelled`,\n * `executionError`, `rejected`) below are kinder constructors than the\n * raw `ToolResult.Failure(...)`.\n */\nexport const ToolResult = Data.taggedEnum<ToolResult>()\n\nexport const isValue = ToolResult.$is(\"Value\")\nexport const isFailure = ToolResult.$is(\"Failure\")\n\n// Synthesizers. `denied` and `cancelled` are operationally distinct;\n// anything else is just a recipe-chosen `kind` via `rejected`.\n// ---------------------------------------------------------------------------\n\nexport const rejected = (call: FunctionCall, kind: string, reason?: string): ToolResult =>\n  ToolResult.Failure({\n    call_id: call.call_id,\n    tool: call.name,\n    kind,\n    ...(reason !== undefined ? { reason } : {}),\n  })\n\n/** Explicit user/policy rejection. */\nexport const denied = (call: FunctionCall, reason?: string): ToolResult =>\n  rejected(call, \"denied\", reason)\n\n/** Implicit non-answer (follow-up, inactivity, abort). */\nexport const cancelled = (call: FunctionCall, reason?: string): ToolResult =>\n  rejected(call, \"cancelled\", reason)\n\n/** Tool's own execution failed (parse error, schema, runtime crash). */\nexport const executionError = (call: FunctionCall, reason: string): ToolResult =>\n  rejected(call, \"execution_error\", reason)\n\n// ---------------------------------------------------------------------------\n// Wire conversion - the one place structured → string happens.\n// ---------------------------------------------------------------------------\n\nexport const toFunctionCallOutput = (r: ToolResult): FunctionCallOutput =>\n  ToolResult.$match(r, {\n    Value: (v) => functionCallOutput(v.call_id, JSON.stringify(v.value)),\n    Failure: (f) =>\n      functionCallOutput(\n        f.call_id,\n        JSON.stringify(\n          f.reason !== undefined ? { kind: f.kind, reason: f.reason } : { kind: f.kind },\n        ),\n      ),\n  })\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CA,MAAa,aAAa,KAAK,YAAwB;AAEvD,MAAa,UAAU,WAAW,IAAI,QAAQ;AAC9C,MAAa,YAAY,WAAW,IAAI,UAAU;AAMlD,MAAa,YAAY,MAAoB,MAAc,WACzD,WAAW,QAAQ;CACjB,SAAS,KAAK;CACd,MAAM,KAAK;CACX;CACA,GAAI,WAAW,KAAA,IAAY,EAAE,QAAQ,GAAG,EAAE;CAC3C,CAAC;;AAGJ,MAAa,UAAU,MAAoB,WACzC,SAAS,MAAM,UAAU,OAAO;;AAGlC,MAAa,aAAa,MAAoB,WAC5C,SAAS,MAAM,aAAa,OAAO;;AAGrC,MAAa,kBAAkB,MAAoB,WACjD,SAAS,MAAM,mBAAmB,OAAO;AAM3C,MAAa,wBAAwB,MACnC,WAAW,OAAO,GAAG;CACnB,QAAQ,MAAM,mBAAmB,EAAE,SAAS,KAAK,UAAU,EAAE,MAAM,CAAC;CACpE,UAAU,MACR,mBACE,EAAE,SACF,KAAK,UACH,EAAE,WAAW,KAAA,IAAY;EAAE,MAAM,EAAE;EAAM,QAAQ,EAAE;EAAQ,GAAG,EAAE,MAAM,EAAE,MAAM,CAC/E,CACF;CACJ,CAAC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"Resolvers.d.mts","names":[],"sources":["../../src/tool/Resolvers.ts"],"mappings":";;;;;;;;;;KAYY,YAAA;EAAA,SACD,QAAA,EAAU,aAAA,CAAc,YAAA;EAAA,SACxB,QAAA,EAAU,aAAA,CAAc,UAAA;AAAA;AAAA,KAGvB,gBAAA,GAAmB,IAAA,CAAK,UAAA;EAClC,QAAA;IAAA,SAAqB,IAAA,EAAM,YAAA;EAAA;EAC3B,QAAA;IAAA,SAAqB,MAAA,EAAQ,UAAA;EAAA;AAAA;AAAA,cAGlB,gBAAA;EAAA;;mBAJgB,YAAA;EAAA;EAAA;;qBACE,UAAA;EAAA;EAAA;;mBADF,YAAA;EAAA;IAAA;;;qBACE,UAAA;EAAA;IAAA;;;;;;uBADF,YAAA;MAAA;MAAA;;yBACE,UAAA;MAAA;IAAA;;qBADF,YAAA;IAAA;MAAA;uBACE,UAAA;IAAA;;;;uBADF,YAAA;MAAA;MAAA;;yBACE,UAAA;MAAA;IAAA;;qBADF,YAAA;IAAA;MAAA;uBACE,UAAA;IAAA;;;cAKlB,OAAA,GAAW,IAAA,EAAM,YAAA,KAAe,gBAAA;AAAA,cAEhC,MAAA,GAAU,MAAA,EAAQ,UAAA,KAAa,gBAAA;AAAA,cAG/B,sBAAA,GAA0B,SAAA,EAAW,aAAA,CAAc,gBAAA,MAAoB,YAAA;AAAA,cASvE,iBAAA,GAAqB,IAAA,EAAM,YAAA,KAAe,SAAA;AAAA,KAW3C,OAAA;EAAA,SACD,OAAA;EAAA,SACA,QAAA;EAAA,SACA,MAAA;AAAA;;;;;;cAQE,gBAAA,GACV,SAAA,GAAY,IAAA,EAAM,YAAA,cAA0B,QAAA,EAAU,KAAA,CAAM,OAAA,CAAQ,OAAA,OAEnE,KAAA,EAAO,aAAA,CAAc,YAAA,MACpB,MAAA,CAAO,MAAA;EAAA,SAEG,QAAA,EAAU,aAAA,CAAc,YAAA;EAAA,SACxB,SAAA,EAAW,MAAA,CAAO,MAAA,CAAO,gBAAA;EAAA,SACzB,QAAA,EAAU,MAAA,CAAO,MAAA,CAAO,SAAA;AAAA,UAGnC,KAAA,CAAM,KAAA;AAAA,KAkDE,gBAAA;EAAA,SACG,QAAA;AAAA;EAAA,SACA,QAAA;EAAA,SAA2B,MAAA;AAAA;AAAA,cAE7B,eAAA,GACV,SAAA,GAAY,IAAA,EAAM,YAAA,cAA0B,SAAA,EAAW,WAAA,SAAoB,gBAAA,OAC3E,KAAA,EAAO,aAAA,CAAc,YAAA,MAAgB,YAAA"}

package/dist/tool/Resolvers.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"Resolvers.mjs","names":[],"sources":["../../src/tool/Resolvers.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.executeAll`.\n */\nimport { Data, Deferred, Effect, Queue, Scope, Stream } from \"effect\"\nimport type { FunctionCall } from \"../domain/Items.js\"\nimport { type ToolResult, cancelled, denied } from \"./Outcome.js\"\nimport { ToolEvent } from \"./ToolEvent.js\"\n\nexport type ToolCallPlan = {\n  readonly approved: ReadonlyArray<FunctionCall>\n  readonly rejected: ReadonlyArray<ToolResult>\n}\n\nexport type ToolCallDecision = Data.TaggedEnum<{\n  Approved: { readonly call: FunctionCall }\n  Rejected: { readonly result: ToolResult }\n}>\n\nexport const ToolCallDecision = Data.taggedEnum<ToolCallDecision>()\n\nexport const approve = (call: FunctionCall): ToolCallDecision => ToolCallDecision.Approved({ call })\n\nexport const reject = (result: ToolResult): ToolCallDecision =>\n  ToolCallDecision.Rejected({ result })\n\nexport const splitToolCallDecisions = (decisions: ReadonlyArray<ToolCallDecision>): 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: FunctionCall): 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\n/**\n * Queue-backed approval planner. Safe calls are returned immediately in\n * `approved`; gated calls emit `ApprovalRequested` events and later produce\n * one `ToolCallDecision` when their matching verdict arrives.\n */\nexport const fromVerdictQueue =\n  (predicate: (call: FunctionCall) => boolean, verdicts: Queue.Dequeue<Verdict>) =>\n  (\n    calls: ReadonlyArray<FunctionCall>,\n  ): Effect.Effect<\n    {\n      readonly approved: ReadonlyArray<FunctionCall>\n      readonly decisions: Stream.Stream<ToolCallDecision>\n      readonly announce: 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<Verdict>().pipe(Effect.map((d) => [call.call_id, d] as const)),\n      )\n      const deferreds: ReadonlyMap<string, Deferred.Deferred<Verdict>> = new Map(entries)\n\n      // Router is forked into the surrounding Scope so it lives as long\n      // as the consumer is pulling events. Recipes typically supply the\n      // scope by wrapping the events construction in `Stream.unwrap`.\n      yield* Effect.forkScoped(\n        Effect.forever(\n          Effect.gen(function* () {\n            const v = yield* Queue.take(verdicts)\n            const d = deferreds.get(v.call_id)\n            if (d !== undefined) yield* Deferred.succeed(d, v)\n          }),\n        ),\n      )\n\n      const decisions = Stream.fromIterable(gated).pipe(\n        Stream.flatMap(\n          (call) => {\n            const d = deferreds.get(call.call_id)!\n            return Stream.fromEffect(\n              Deferred.await(d).pipe(\n                Effect.map((v) =>\n                  v.decision === \"approve\" ? approve(call) : reject(denied(call, v.reason)),\n                ),\n              ),\n            )\n          },\n          { concurrency: \"unbounded\" },\n        ),\n      )\n\n      const announce = Stream.fromIterable<ToolEvent>(gated.map(approvalRequested))\n\n      return { approved, decisions, announce }\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 fromApprovalMap =\n  (predicate: (call: FunctionCall) => boolean, approvals: ReadonlyMap<string, ApprovalMapEntry>) =>\n  (calls: ReadonlyArray<FunctionCall>): ToolCallPlan =>\n    splitToolCallDecisions(\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":";;;;;;;;;;;;;;;;;;;;;AAsBA,MAAa,mBAAmB,KAAK,YAA8B;AAEnE,MAAa,WAAW,SAAyC,iBAAiB,SAAS,EAAE,MAAM,CAAC;AAEpG,MAAa,UAAU,WACrB,iBAAiB,SAAS,EAAE,QAAQ,CAAC;AAEvC,MAAa,0BAA0B,cACrC,UAAU,QACP,KAAK,aACJ,SAAS,SAAS,aACd;CAAE,GAAG;CAAK,UAAU,CAAC,GAAG,IAAI,UAAU,SAAS,KAAK;CAAE,GACtD;CAAE,GAAG;CAAK,UAAU,CAAC,GAAG,IAAI,UAAU,SAAS,OAAO;CAAE,EAC9D;CAAE,UAAU,EAAE;CAAE,UAAU,EAAE;CAAE,CAC/B;AAEH,MAAa,qBAAqB,SAChC,UAAU,kBAAkB;CAC1B,SAAS,KAAK;CACd,MAAM,KAAK;CACX,WAAW,KAAK;CACjB,CAAC;;;;;;AAiBJ,MAAa,oBACV,WAA4C,cAE3C,UAUA,OAAO,IAAI,aAAa;CACtB,MAAM,QAAQ,MAAM,OAAO,UAAU;CACrC,MAAM,WAAW,MAAM,QAAQ,SAAS,CAAC,UAAU,KAAK,CAAC;CAEzD,MAAM,UAAU,OAAO,OAAO,QAAQ,QAAQ,SAC5C,SAAS,MAAe,CAAC,KAAK,OAAO,KAAK,MAAM,CAAC,KAAK,SAAS,EAAE,CAAU,CAAC,CAC7E;CACD,MAAM,YAA6D,IAAI,IAAI,QAAQ;AAKnF,QAAO,OAAO,WACZ,OAAO,QACL,OAAO,IAAI,aAAa;EACtB,MAAM,IAAI,OAAO,MAAM,KAAK,SAAS;EACrC,MAAM,IAAI,UAAU,IAAI,EAAE,QAAQ;AAClC,MAAI,MAAM,KAAA,EAAW,QAAO,SAAS,QAAQ,GAAG,EAAE;GAClD,CACH,CACF;AAoBD,QAAO;EAAE;EAAU,WAlBD,OAAO,aAAa,MAAM,CAAC,KAC3C,OAAO,SACJ,SAAS;GACR,MAAM,IAAI,UAAU,IAAI,KAAK,QAAQ;AACrC,UAAO,OAAO,WACZ,SAAS,MAAM,EAAE,CAAC,KAChB,OAAO,KAAK,MACV,EAAE,aAAa,YAAY,QAAQ,KAAK,GAAG,OAAO,OAAO,MAAM,EAAE,OAAO,CAAC,CAC1E,CACF,CACF;KAEH,EAAE,aAAa,aAAa,CAC7B,CAKyB;EAAE,UAFb,OAAO,aAAwB,MAAM,IAAI,kBAAkB,CAEtC;EAAE;EACxC;AAWN,MAAa,mBACV,WAA4C,eAC5C,UACC,uBACE,MAAM,KAAK,SAAS;AAClB,KAAI,CAAC,UAAU,KAAK,CAAE,QAAO,QAAQ,KAAK;CAC1C,MAAM,IAAI,UAAU,IAAI,KAAK,QAAQ;AACrC,KAAI,MAAM,KAAA,EAAW,QAAO,OAAO,UAAU,KAAK,CAAC;AACnD,QAAO,EAAE,aAAa,YAAY,QAAQ,KAAK,GAAG,OAAO,OAAO,MAAM,EAAE,OAAO,CAAC;EAChF,CACH"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"Resolvers.test.mjs","names":["makeTool","Items.functionCallOutput","Items.userText"],"sources":["../../src/tool/Resolvers.test.ts"],"sourcesContent":["/**\n * Tests for approval planners + history-reconciliation primitives. Exercises\n * the full HITL + streaming-tool stack end-to-end by composing approval plans\n * with `executeAll`, with the four wire-shaped scenarios:\n *\n *   1. Approval        : gated calls approved → tools execute, structured Values\n *   2. Denial          : gated calls denied   → Failure(denied) results\n *   3. Cancellation    : missing verdicts     → Failure(cancelled) results\n *   4. Mixed + history : reconciliation via cancelAllPending\n *\n * Plus: hallucinated tool name (graceful Failure), unknown_tool kind.\n */\nimport { Effect, Queue, Schema, Stream } from \"effect\"\nimport { describe, expect, it } from \"vitest\"\nimport * as Items from \"../domain/Items.js\"\nimport { findUnansweredCalls, cancelAllPending, isReconciled } from \"./HistoryCheck.js\"\nimport { type ToolResult, isFailure, isValue, toFunctionCallOutput } from \"./Outcome.js\"\nimport {\n  type ApprovalMapEntry,\n  type ToolCallDecision,\n  fromApprovalMap,\n  fromVerdictQueue,\n} from \"./Resolvers.js\"\nimport { fromEffectSchema, make as makeTool, streaming } from \"./Tool.js\"\nimport { executeAll } from \"./Toolkit.js\"\nimport { ToolEvent, isApprovalRequested, isIntermediate, isOutput } from \"./ToolEvent.js\"\n\n// ---------------------------------------------------------------------------\n// Three demo tools covering the matrix:\n//   - web_search      : streaming, no approval\n//   - bulk_email      : streaming, requires approval\n//   - delete_database : non-streaming, requires approval\n// ---------------------------------------------------------------------------\n\nconst webSearch = streaming({\n  name: \"web_search\",\n  description: \"search\",\n  inputSchema: fromEffectSchema(Schema.Struct({ query: Schema.String })),\n  run: ({ query }) =>\n    Stream.fromIterable([\n      { url: \"a\", title: `${query} 1` },\n      { url: \"b\", title: `${query} 2` },\n      { url: \"c\", title: `${query} 3` },\n    ]),\n  finalize: (hits) => ({ count: hits.length }),\n})\n\nconst bulkEmail = streaming({\n  name: \"bulk_email\",\n  description: \"send\",\n  inputSchema: fromEffectSchema(\n    Schema.Struct({ recipients: Schema.Array(Schema.String), subject: Schema.String }),\n  ),\n  run: ({ recipients }) =>\n    Stream.fromIterable(\n      recipients.map((_, i) => ({\n        type: \"progress\" as const,\n        sent: i + 1,\n        total: recipients.length,\n      })),\n    ),\n  finalize: (events) => ({ status: \"sent\" as const, delivered: events.length }),\n})\n\nconst deleteDatabase = makeTool({\n  name: \"delete_database\",\n  description: \"drop\",\n  inputSchema: fromEffectSchema(Schema.Struct({ name: Schema.String })),\n  run: ({ name }) => Effect.succeed({ status: \"dropped\", name }),\n})\n\nconst allTools = [webSearch, bulkEmail, deleteDatabase]\nconst SENSITIVE = new Set([\"bulk_email\", \"delete_database\"])\nconst isSensitive = (call: Items.FunctionCall) => SENSITIVE.has(call.name)\n\nconst fc = (call_id: string, name: string, args: unknown): Items.FunctionCall => ({\n  type: \"function_call\",\n  call_id,\n  name,\n  arguments: JSON.stringify(args),\n})\n\nconst calls = [\n  fc(\"c1\", \"web_search\", { query: \"effect\" }),\n  fc(\"c2\", \"bulk_email\", { recipients: [\"a@x\", \"b@x\"], subject: \"Hi\" }),\n  fc(\"c3\", \"delete_database\", { name: \"prod\" }),\n]\n\nconst resultsFrom = (collected: ReadonlyArray<ToolEvent>): ReadonlyArray<ToolResult> =>\n  collected.filter(isOutput).map((e) => e.result)\n\nconst byCallId = (results: ReadonlyArray<ToolResult>) => new Map(results.map((r) => [r.call_id, r]))\n\nconst rejectedStream = (rejected: ReadonlyArray<ToolResult>) =>\n  Stream.fromIterable(rejected.map((result) => ToolEvent.Output({ result })))\n\nconst eventsFromApprovalMap = (approvals: ReadonlyMap<string, ApprovalMapEntry>) => {\n  const plan = fromApprovalMap(isSensitive, approvals)(calls)\n  return Stream.merge(executeAll(allTools, plan.approved), rejectedStream(plan.rejected))\n}\n\nconst eventsFromDecision = (decision: ToolCallDecision): Stream.Stream<ToolEvent> =>\n  decision._tag === \"Approved\"\n    ? executeAll(allTools, [decision.call])\n    : Stream.succeed(ToolEvent.Output({ result: decision.result }))\n\n// ---------------------------------------------------------------------------\n// fromApprovalMap: HTTP-style scenarios\n// ---------------------------------------------------------------------------\n\ndescribe(\"fromApprovalMap + executeAll\", () => {\n  it(\"approval: all gated approved → tools execute, structured Values\", async () => {\n    const approvals = new Map<string, ApprovalMapEntry>([\n      [\"c2\", { decision: \"approve\" }],\n      [\"c3\", { decision: \"approve\" }],\n    ])\n    const collected = await Effect.runPromise(Stream.runCollect(eventsFromApprovalMap(approvals)))\n    const by = byCallId(resultsFrom(collected))\n    expect(by.get(\"c1\")).toMatchObject({ _tag: \"Value\", value: { count: 3 } })\n    expect(by.get(\"c2\")).toMatchObject({\n      _tag: \"Value\",\n      value: { status: \"sent\", delivered: 2 },\n    })\n    expect(by.get(\"c3\")).toMatchObject({\n      _tag: \"Value\",\n      value: { status: \"dropped\", name: \"prod\" },\n    })\n\n    // No ApprovalRequested events from the pure HTTP flow.\n    expect(collected.filter(isApprovalRequested)).toHaveLength(0)\n  })\n\n  it(\"denial: gated denied → Failure(denied), no execution\", async () => {\n    const approvals = new Map<string, ApprovalMapEntry>([\n      [\"c2\", { decision: \"deny\", reason: \"spam concern\" }],\n      [\"c3\", { decision: \"deny\", reason: \"prod is sacred\" }],\n    ])\n    const collected = await Effect.runPromise(Stream.runCollect(eventsFromApprovalMap(approvals)))\n\n    // bulk_email never ran.\n    expect(collected.filter(isIntermediate).filter((e) => e.tool === \"bulk_email\")).toHaveLength(0)\n\n    const by = byCallId(resultsFrom(collected))\n    expect(by.get(\"c2\")).toMatchObject({\n      _tag: \"Failure\",\n      kind: \"denied\",\n      reason: \"spam concern\",\n    })\n    expect(by.get(\"c3\")).toMatchObject({\n      _tag: \"Failure\",\n      kind: \"denied\",\n      reason: \"prod is sacred\",\n    })\n  })\n\n  it(\"cancellation: missing verdicts → Failure(cancelled)\", async () => {\n    const collected = await Effect.runPromise(Stream.runCollect(eventsFromApprovalMap(new Map())))\n    const by = byCallId(resultsFrom(collected))\n    expect(by.get(\"c1\")).toMatchObject({ _tag: \"Value\", value: { count: 3 } })\n    expect(by.get(\"c2\")).toMatchObject({ _tag: \"Failure\", kind: \"cancelled\" })\n    expect(by.get(\"c3\")).toMatchObject({ _tag: \"Failure\", kind: \"cancelled\" })\n  })\n\n  it(\"mixed: approve + deny + omit → all three kinds\", async () => {\n    const approvals = new Map<string, ApprovalMapEntry>([\n      [\"c2\", { decision: \"approve\" }],\n      // c3 omitted → cancelled\n    ])\n    const collected = await Effect.runPromise(Stream.runCollect(eventsFromApprovalMap(approvals)))\n    const by = byCallId(resultsFrom(collected))\n    expect(by.get(\"c1\")).toMatchObject({ _tag: \"Value\", value: { count: 3 } })\n    expect(by.get(\"c2\")).toMatchObject({ _tag: \"Value\", value: { status: \"sent\" } })\n    expect(by.get(\"c3\")).toMatchObject({ _tag: \"Failure\", kind: \"cancelled\" })\n  })\n})\n\n// ---------------------------------------------------------------------------\n// Graceful degradation: hallucinated tool name doesn't kill the turn.\n// ---------------------------------------------------------------------------\n\ndescribe(\"executeAll: graceful degradation\", () => {\n  it(\"unknown tool name → Failure(unknown_tool); other calls still execute\", async () => {\n    const callsWithBogus = [\n      fc(\"c1\", \"web_search\", { query: \"x\" }),\n      fc(\"c2\", \"does_not_exist\", {}),\n      fc(\"c3\", \"delete_database\", { name: \"prod\" }),\n    ]\n    const collected = await Effect.runPromise(\n      Stream.runCollect(\n        (() => {\n          const plan = fromApprovalMap(\n            isSensitive,\n            new Map([[\"c3\", { decision: \"approve\" }]]),\n          )(callsWithBogus)\n          return Stream.merge(executeAll(allTools, plan.approved), rejectedStream(plan.rejected))\n        })(),\n      ),\n    )\n    const by = byCallId(resultsFrom(collected))\n    expect(by.get(\"c1\")).toMatchObject({ _tag: \"Value\" })\n    expect(by.get(\"c2\")).toMatchObject({ _tag: \"Failure\", kind: \"unknown_tool\" })\n    expect(by.get(\"c3\")).toMatchObject({ _tag: \"Value\", value: { status: \"dropped\" } })\n  })\n})\n\n// ---------------------------------------------------------------------------\n// fromVerdictQueue: WebSocket-style scenarios\n// ---------------------------------------------------------------------------\n\ndescribe(\"fromVerdictQueue + executeAll\", () => {\n  it(\"queue-driven: approve + deny resolve correctly with ApprovalRequested events\", async () => {\n    const collected = await Effect.runPromise(\n      Effect.gen(function* () {\n        const verdicts = yield* Queue.unbounded<{\n          readonly call_id: string\n          readonly decision: \"approve\" | \"deny\"\n          readonly reason?: string\n        }>()\n        yield* Queue.offer(verdicts, { call_id: \"c2\", decision: \"approve\" })\n        yield* Queue.offer(verdicts, {\n          call_id: \"c3\",\n          decision: \"deny\",\n          reason: \"too risky\",\n        })\n\n        // Stream.unwrap supplies the Scope for fromVerdictQueue's router.\n        const events = Stream.unwrap(\n          Effect.gen(function* () {\n            const { approved, decisions, announce } = yield* fromVerdictQueue(\n              isSensitive,\n              verdicts,\n            )(calls)\n            return Stream.merge(\n              announce,\n              Stream.merge(\n                executeAll(allTools, approved),\n                decisions.pipe(Stream.flatMap(eventsFromDecision)),\n              ),\n            )\n          }),\n        )\n        return yield* Stream.runCollect(events)\n      }),\n    )\n\n    expect(collected.filter(isApprovalRequested)).toHaveLength(2)\n\n    const by = byCallId(resultsFrom(collected))\n    expect(by.get(\"c2\")).toMatchObject({ _tag: \"Value\", value: { status: \"sent\" } })\n    expect(by.get(\"c3\")).toMatchObject({\n      _tag: \"Failure\",\n      kind: \"denied\",\n      reason: \"too risky\",\n    })\n  })\n})\n\n// ---------------------------------------------------------------------------\n// History reconciliation\n// ---------------------------------------------------------------------------\n\ndescribe(\"findUnansweredCalls / cancelAllPending / isReconciled\", () => {\n  const orphan = fc(\"c99\", \"delete_database\", { name: \"prod\" })\n  const answered = fc(\"c98\", \"web_search\", { query: \"x\" })\n  const answeredOutput = Items.functionCallOutput(\"c98\", JSON.stringify({ count: 0 }))\n\n  it(\"findUnansweredCalls returns only orphans\", () => {\n    const history = [Items.userText(\"hi\"), answered, orphan, answeredOutput]\n    const unanswered = findUnansweredCalls(history)\n    expect(unanswered).toHaveLength(1)\n    expect(unanswered[0]!.call_id).toBe(\"c99\")\n  })\n\n  it(\"isReconciled is false when orphans exist, true otherwise\", () => {\n    const stale = [Items.userText(\"hi\"), orphan]\n    expect(isReconciled(stale)).toBe(false)\n    const reconciled = [...stale, ...cancelAllPending(stale).map(toFunctionCallOutput)]\n    expect(isReconciled(reconciled)).toBe(true)\n  })\n\n  it(\"cancelAllPending synthesizes one Failure(cancelled) per orphan\", () => {\n    const history = [Items.userText(\"hi\"), answered, orphan, answeredOutput]\n    const closures = cancelAllPending(history, \"user moved on\")\n    expect(closures).toHaveLength(1)\n    const c = closures[0]!\n    expect(isFailure(c)).toBe(true)\n    expect(c).toMatchObject({\n      _tag: \"Failure\",\n      call_id: \"c99\",\n      kind: \"cancelled\",\n      reason: \"user moved on\",\n    })\n  })\n\n  it(\"follow-up: map closures to FunctionCallOutput before appending new user message\", () => {\n    const stale = [Items.userText(\"first request\"), orphan]\n    const closures = cancelAllPending(stale, \"user redirected\")\n    const reconciled = [\n      ...stale,\n      ...closures.map(toFunctionCallOutput),\n      Items.userText(\"never mind\"),\n    ]\n    expect(findUnansweredCalls(reconciled)).toHaveLength(0)\n  })\n})\n\n// ---------------------------------------------------------------------------\n// Wire conversion\n// ---------------------------------------------------------------------------\n\ndescribe(\"toFunctionCallOutput\", () => {\n  it(\"round-trips a Value result\", () => {\n    const r: ToolResult = {\n      _tag: \"Value\",\n      call_id: \"c1\",\n      tool: \"web_search\",\n      value: { count: 3 },\n    }\n    const out = toFunctionCallOutput(r)\n    expect(out.call_id).toBe(\"c1\")\n    expect(JSON.parse(out.output)).toEqual({ count: 3 })\n  })\n\n  it(\"round-trips a Failure result with reason\", () => {\n    const r: ToolResult = {\n      _tag: \"Failure\",\n      call_id: \"c2\",\n      tool: \"bulk_email\",\n      kind: \"denied\",\n      reason: \"spam concern\",\n    }\n    const out = toFunctionCallOutput(r)\n    expect(JSON.parse(out.output)).toEqual({ kind: \"denied\", reason: \"spam concern\" })\n  })\n\n  it(\"round-trips a Failure result without reason (omits the field)\", () => {\n    const r: ToolResult = {\n      _tag: \"Failure\",\n      call_id: \"c3\",\n      tool: \"delete_database\",\n      kind: \"cancelled\",\n    }\n    const out = toFunctionCallOutput(r)\n    expect(JSON.parse(out.output)).toEqual({ kind: \"cancelled\" })\n  })\n})\n\n// ---------------------------------------------------------------------------\n// executeAll\n// ---------------------------------------------------------------------------\n\ndescribe(\"executeAll\", () => {\n  it(\"runs all calls passed to it\", async () => {\n    const collected = await Effect.runPromise(Stream.runCollect(executeAll(allTools, calls)))\n    expect(collected.filter(isOutput)).toHaveLength(3)\n    expect(collected.filter(isOutput).every((e) => isValue(e.result))).toBe(true)\n  })\n})\n"],"mappings":"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"}