@effect-uai/core 0.1.0 → 0.2.0

package/README.md

@@ -35,7 +35,7 @@ ESM-only. Requires `effect@4.x` as a peer.
 
 Full docs: <https://effect-uai.betalyra.com>
 
-Start with the [Quickstart](https://effect-uai.betalyra.com/start/getting-started/)
+Start with [One turn is a stream](https://effect-uai.betalyra.com/start/getting-started/)
 and then [Basic usage](https://effect-uai.betalyra.com/recipes/basic-usage/).
 
 ## License

package/dist/{Outcome-C2JYknCu.d.mts → Outcome-GiaNvt7i.d.mts}

@@ -19,14 +19,6 @@ declare const isValue: (r: ToolResult) => r is Extract<ToolResult, {
 declare const isFailure: (r: ToolResult) => r is Extract<ToolResult, {
   _tag: "Failure";
 }>;
-type ToolDecision = {
-  readonly _tag: "Execute";
-} | {
-  readonly _tag: "Reject";
-  readonly result: ToolResult;
-};
-declare const execute: ToolDecision;
-declare const reject: (result: ToolResult) => ToolDecision;
 declare const rejected: (call: FunctionCall, kind: string, reason?: string) => ToolResult;
 /** Explicit user/policy rejection. */
 declare const denied: (call: FunctionCall, reason?: string) => ToolResult;
@@ -36,5 +28,5 @@ declare const cancelled: (call: FunctionCall, reason?: string) => ToolResult;
 declare const executionError: (call: FunctionCall, reason: string) => ToolResult;
 declare const toFunctionCallOutput: (r: ToolResult) => FunctionCallOutput;
 //#endregion
-export { execute as a, isValue as c, toFunctionCallOutput as d, denied as i, reject as l, ToolResult as n, executionError as o, cancelled as r, isFailure as s, ToolDecision as t, rejected as u };
-//# sourceMappingURL=Outcome-C2JYknCu.d.mts.map
+export { isFailure as a, toFunctionCallOutput as c, executionError as i, cancelled as n, isValue as o, denied as r, rejected as s, ToolResult as t };
+//# sourceMappingURL=Outcome-GiaNvt7i.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Outcome-GiaNvt7i.d.mts","names":[],"sources":["../src/tool/Outcome.ts"],"mappings":";;;KAqBY,UAAA;EAAA,SAEG,IAAA;EAAA,SACA,OAAA;EAAA,SACA,IAAA;EAAA,SACA,KAAA;AAAA;EAAA,SAGA,IAAA;EAAA,SACA,OAAA;EAAA,SACA,IAAA;EAAA,SACA,IAAA;EAAA,SACA,MAAA;AAAA;AAAA,cAGF,OAAA,GAAW,CAAA,EAAG,UAAA,KAAa,CAAA,IAAK,OAAA,CAAQ,UAAA;EAAc,IAAA;AAAA;AAAA,cAGtD,SAAA,GAAa,CAAA,EAAG,UAAA,KAAa,CAAA,IAAK,OAAA,CAAQ,UAAA;EAAc,IAAA;AAAA;AAAA,cAOxD,QAAA,GACX,IAAA,EAAM,YAAA,EACN,IAAA,UACA,MAAA,cACC,UAAA;;cASU,MAAA,GAAU,IAAA,EAAM,YAAA,EAAc,MAAA,cAAkB,UAAA;;cAIhD,SAAA,GAAa,IAAA,EAAM,YAAA,EAAc,MAAA,cAAkB,UAAA;;cAInD,cAAA,GAAkB,IAAA,EAAM,YAAA,EAAc,MAAA,aAAiB,UAAA;AAAA,cAOvD,oBAAA,GAAwB,CAAA,EAAG,UAAA,KAAa,kBAAA"}

package/dist/{ToolEvent-B2N10hr3.d.mts → ToolEvent-wTMgb2GO.d.mts}

@@ -1,4 +1,4 @@
-import { n as ToolResult } from "./Outcome-C2JYknCu.mjs";
+import { t as ToolResult } from "./Outcome-GiaNvt7i.mjs";
 
 //#region src/tool/ToolEvent.d.ts
 type ToolEvent = {
@@ -26,4 +26,4 @@ declare const isOutput: (e: ToolEvent) => e is Extract<ToolEvent, {
 }>;
 //#endregion
 export { isOutput as i, isApprovalRequested as n, isIntermediate as r, ToolEvent as t };
-//# sourceMappingURL=ToolEvent-B2N10hr3.d.mts.map
+//# sourceMappingURL=ToolEvent-wTMgb2GO.d.mts.map

package/dist/{ToolEvent-B2N10hr3.d.mts.map → ToolEvent-wTMgb2GO.d.mts.map}

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

package/dist/{Turn-rlTfuHaQ.d.mts → Turn-Bi83du4I.d.mts}

@@ -6,7 +6,7 @@ import * as _$effect_Cause0 from "effect/Cause";
 
 //#region src/domain/Turn.d.ts
 declare namespace Turn_d_exports {
-  export { Cursor, InteractionEvent, RefusalRejected, Turn, TurnEvent, assistantMessages, cursor, functionCalls, isTurnComplete, reasonings, textDeltas, toStructured };
+  export { InteractionEvent, RefusalRejected, Turn, TurnEvent, appendTurn, assistantMessages, functionCalls, isTurnComplete, reasonings, textDeltas, toStructured };
 }
 /**
  * The result of a single LLM generation. A turn produces zero or more items
@@ -160,24 +160,13 @@ declare const functionCalls: (turn: Turn) => ReadonlyArray<FunctionCall>;
 declare const reasonings: (turn: Turn) => ReadonlyArray<Reasoning>;
 declare const assistantMessages: (turn: Turn) => ReadonlyArray<Message>;
 /**
- * State stamped with the just-completed `Turn`. Recipes use this as the
- * intermediate value between "turn lands" and "compute next state": extend
- * `state.history` with the turn's items, and keep the assembled turn
- * around for stop-reason / usage / function-call inspection.
- *
- * Generic over the recipe's state shape - any record carrying a
- * `history: ReadonlyArray<Item>` field works.
- */
-type Cursor<S> = S & {
-  readonly turn: Turn;
-};
-/**
- * Build a `Cursor<S>` from a state record and the just-completed turn.
- * Extends `state.history` with `turn.items` and stamps the turn.
+ * 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 cursor: <S extends {
+declare const appendTurn: <S extends {
   readonly history: ReadonlyArray<Item>;
-}>(state: S, turn: Turn) => Cursor<S>;
+}>(state: S, turn: Turn, items?: ReadonlyArray<Item>) => S;
 /**
  * Project a `TurnEvent` stream onto its `text_delta` payloads. Other
  * variants are dropped. Composes with `Lines.lines` +
@@ -207,5 +196,5 @@ declare class RefusalRejected extends RefusalRejected_base<{
  */
 declare const toStructured: <A>(turn: Turn, format: StructuredFormat<A>) => Effect.Effect<A, RefusalRejected | JsonParseError | StructuredDecodeError>;
 //#endregion
-export { TurnEvent as a, cursor as c, reasonings as d, textDeltas as f, Turn as i, functionCalls as l, InteractionEvent as n, Turn_d_exports as o, toStructured as p, RefusalRejected as r, assistantMessages as s, Cursor as t, isTurnComplete as u };
-//# sourceMappingURL=Turn-rlTfuHaQ.d.mts.map
+export { Turn_d_exports as a, functionCalls as c, textDeltas as d, toStructured as f, TurnEvent as i, isTurnComplete as l, RefusalRejected as n, appendTurn as o, Turn as r, assistantMessages as s, InteractionEvent as t, reasonings as u };
+//# sourceMappingURL=Turn-Bi83du4I.d.mts.map

package/dist/{Turn-rlTfuHaQ.d.mts.map → Turn-Bi83du4I.d.mts.map}

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

package/dist/domain/Turn.d.mts

@@ -1,2 +1,2 @@
-import { a as TurnEvent, c as cursor, d as reasonings, f as textDeltas, i as Turn, l as functionCalls, n as InteractionEvent, p as toStructured, r as RefusalRejected, s as assistantMessages, t as Cursor, u as isTurnComplete } from "../Turn-rlTfuHaQ.mjs";
-export { Cursor, InteractionEvent, RefusalRejected, Turn, TurnEvent, assistantMessages, cursor, functionCalls, isTurnComplete, reasonings, textDeltas, toStructured };
+import { c as functionCalls, d as textDeltas, f as toStructured, i as TurnEvent, l as isTurnComplete, n as RefusalRejected, o as appendTurn, r as Turn, s as assistantMessages, t as InteractionEvent, u as reasonings } from "../Turn-Bi83du4I.mjs";
+export { InteractionEvent, RefusalRejected, Turn, TurnEvent, appendTurn, assistantMessages, functionCalls, isTurnComplete, reasonings, textDeltas, toStructured };

package/dist/domain/Turn.mjs

@@ -6,8 +6,8 @@ import { Data, Effect, Result, Schema, Stream, pipe } from "effect";
 var Turn_exports = /* @__PURE__ */ __exportAll({
 	RefusalRejected: () => RefusalRejected,
 	Turn: () => Turn,
+	appendTurn: () => appendTurn,
 	assistantMessages: () => assistantMessages,
-	cursor: () => cursor,
 	functionCalls: () => functionCalls,
 	isTurnComplete: () => isTurnComplete,
 	reasonings: () => reasonings,
@@ -29,13 +29,17 @@ const functionCalls = (turn) => turn.items.filter((i) => i.type === "function_ca
 const reasonings = (turn) => turn.items.filter((i) => i.type === "reasoning");
 const assistantMessages = (turn) => turn.items.filter((i) => i.type === "message" && i.role === "assistant");
 /**
-* Build a `Cursor<S>` from a state record and the just-completed turn.
-* Extends `state.history` with `turn.items` and stamps the turn.
+* 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.
 */
-const cursor = (state, turn) => ({
+const appendTurn = (state, turn, items = []) => ({
 	...state,
-	history: [...state.history, ...turn.items],
-	turn
+	history: [
+		...state.history,
+		...turn.items,
+		...items
+	]
 });
 /**
 * Project a `TurnEvent` stream onto its `text_delta` payloads. Other
@@ -77,6 +81,6 @@ const lastAssistantContent = (turn) => {
 */
 const toStructured = (turn, format) => pipe(lastAssistantContent(turn), ({ text, refused }) => refused ? Effect.fail(new RefusalRejected({ turn })) : parseJson(format)(text));
 //#endregion
-export { RefusalRejected, Turn, assistantMessages, cursor, functionCalls, isTurnComplete, reasonings, Turn_exports as t, textDeltas, toStructured };
+export { RefusalRejected, Turn, appendTurn, assistantMessages, functionCalls, isTurnComplete, reasonings, Turn_exports as t, textDeltas, toStructured };
 
 //# sourceMappingURL=Turn.mjs.map

package/dist/domain/Turn.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"Turn.mjs","names":["StructuredFormat.parseJson"],"sources":["../../src/domain/Turn.ts"],"sourcesContent":["import { Data, Effect, Result, Schema, Stream, pipe } from \"effect\"\nimport * as StructuredFormat from \"../structured-format/StructuredFormat.js\"\nimport {\n  FunctionCall,\n  FunctionCallOutput,\n  Item,\n  isOutputText,\n  isRefusal,\n  Message,\n  Reasoning,\n  StopReason,\n  Usage,\n} from \"./Items.js\"\n\n/**\n * The result of a single LLM generation. A turn produces zero or more items\n * (typically one assistant message and zero or more function_call items)\n * and reports usage + a stop reason.\n */\nexport const Turn = Schema.Struct({\n  items: Schema.Array(Item),\n  usage: Usage,\n  stop_reason: StopReason,\n})\nexport type Turn = typeof Turn.Type\n\n/**\n * Canonical events emitted while a single turn is being generated. Most\n * variants are streaming deltas (text, reasoning, tool-call args); the\n * terminal `turn_complete` carries the assembled `Turn`. Lifecycle members\n * aren't deltas, hence the union name.\n */\nexport type TurnEvent =\n  | { readonly type: \"text_delta\"; readonly text: string }\n  | {\n      readonly type: \"reasoning_delta\"\n      readonly text: string\n      /**\n       * `trace` is the model's raw chain-of-thought; `summary` is a\n       * model-written summary intended for display. OpenAI Responses emits\n       * both as separate wire events; Anthropic and Gemini only emit\n       * `trace`. Consumers who just want any reasoning text match once;\n       * those who want only summaries filter `kind === \"summary\"`.\n       */\n      readonly kind: \"trace\" | \"summary\"\n    }\n  /**\n   * The model declined to answer. `text` is the (streamed) explanation.\n   * Distinct from the failure channel: a refusal is normal model output and\n   * the stream still completes with `turn_complete`. OpenAI Responses emits\n   * this; Anthropic surfaces refusals via `stop_reason`, and Gemini collapses\n   * them into `finishReason: SAFETY` - both go without a `refusal_delta`.\n   */\n  | { readonly type: \"refusal_delta\"; readonly text: string }\n  | { readonly type: \"tool_call_start\"; readonly call_id: string; readonly name: string }\n  | { readonly type: \"tool_call_args_delta\"; readonly call_id: string; readonly delta: string }\n  /**\n   * Mid-stream cumulative usage. Carries the full `Usage` (including cache\n   * token fields when the provider surfaces them) so consumers can drive\n   * live budget / cost tracking without waiting for `turn_complete`.\n   * Anthropic emits this on `message_start` and `message_delta`; other\n   * providers may not emit any `usage_update` and only deliver usage via\n   * `turn_complete.turn.usage`.\n   */\n  | { readonly type: \"usage_update\"; readonly usage: Usage }\n  | { readonly type: \"turn_complete\"; readonly turn: Turn }\n\n/**\n * What flows out of an agent loop body to its consumer per turn: every\n * `TurnEvent` the provider emits (including the terminal `turn_complete`\n * carrying the assembled `Turn`), plus the output of any tool the loop ran.\n * Both variants carry a `type` discriminator.\n */\nexport type InteractionEvent = TurnEvent | FunctionCallOutput\n\nexport const isTurnComplete = (d: TurnEvent): d is Extract<TurnEvent, { type: \"turn_complete\" }> =>\n  d.type === \"turn_complete\"\n\nexport const functionCalls = (turn: Turn): ReadonlyArray<FunctionCall> =>\n  turn.items.filter((i): i is FunctionCall => i.type === \"function_call\")\n\nexport const reasonings = (turn: Turn): ReadonlyArray<Reasoning> =>\n  turn.items.filter((i): i is Reasoning => i.type === \"reasoning\")\n\nexport const assistantMessages = (turn: Turn): ReadonlyArray<Message> =>\n  turn.items.filter((i): i is Message => i.type === \"message\" && i.role === \"assistant\")\n\n/**\n * State stamped with the just-completed `Turn`. Recipes use this as the\n * intermediate value between \"turn lands\" and \"compute next state\": extend\n * `state.history` with the turn's items, and keep the assembled turn\n * around for stop-reason / usage / function-call inspection.\n *\n * Generic over the recipe's state shape - any record carrying a\n * `history: ReadonlyArray<Item>` field works.\n */\nexport type Cursor<S> = S & { readonly turn: Turn }\n\n/**\n * Build a `Cursor<S>` from a state record and the just-completed turn.\n * Extends `state.history` with `turn.items` and stamps the turn.\n */\nexport const cursor = <S extends { readonly history: ReadonlyArray<Item> }>(\n  state: S,\n  turn: Turn,\n): Cursor<S> => ({\n  ...state,\n  history: [...state.history, ...turn.items],\n  turn,\n})\n\n// ---------------------------------------------------------------------------\n// Stream operators\n// ---------------------------------------------------------------------------\n\n/**\n * Project a `TurnEvent` stream onto its `text_delta` payloads. Other\n * variants are dropped. Composes with `Lines.lines` +\n * `decodeJsonLines` for prompted-JSONL streaming.\n */\nexport const textDeltas = <E, R>(\n  self: Stream.Stream<TurnEvent, E, R>,\n): Stream.Stream<string, E, R> =>\n  self.pipe(\n    Stream.filterMap((ev) =>\n      ev.type === \"text_delta\" ? Result.succeed(ev.text) : Result.failVoid,\n    ),\n  )\n\n// ---------------------------------------------------------------------------\n// Structured-output integration\n// ---------------------------------------------------------------------------\n\n/**\n * The assistant message on the just-completed turn was a refusal block,\n * not an `output_text` payload. Returned by `toStructured` to short-circuit\n * decoding before `JSON.parse` / schema validation runs.\n */\nexport class RefusalRejected extends Data.TaggedError(\"RefusalRejected\")<{\n  readonly turn: Turn\n}> {}\n\nconst lastAssistantContent = (turn: Turn): { readonly text: string; readonly refused: boolean } => {\n  const assistants = assistantMessages(turn)\n  const last = assistants[assistants.length - 1]\n  if (last === undefined) return { text: \"\", refused: false }\n  if (last.content.some(isRefusal)) return { text: \"\", refused: true }\n  const text = last.content\n    .filter(isOutputText)\n    .map((b) => b.text)\n    .join(\"\")\n  return { text, refused: false }\n}\n\n/**\n * Validate a completed `Turn` against a `StructuredFormat`. Concatenates\n * `output_text` blocks on the last assistant message, then runs\n * `JSON.parse` + the format's schema validation.\n *\n * Three failure modes:\n * - `RefusalRejected` — the assistant emitted a refusal block.\n * - `JsonParseError` — the assembled text wasn't valid JSON.\n * - `StructuredDecodeError` — the JSON didn't match the schema.\n */\nexport const toStructured = <A>(\n  turn: Turn,\n  format: StructuredFormat.StructuredFormat<A>,\n): Effect.Effect<\n  A,\n  RefusalRejected | StructuredFormat.JsonParseError | StructuredFormat.StructuredDecodeError\n> =>\n  pipe(lastAssistantContent(turn), ({ text, refused }) =>\n    refused ? Effect.fail(new RefusalRejected({ turn })) : StructuredFormat.parseJson(format)(text),\n  )\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAmBA,MAAa,OAAO,OAAO,OAAO;CAChC,OAAO,OAAO,MAAM,KAAK;CACzB,OAAO;CACP,aAAa;CACd,CAAC;AAoDF,MAAa,kBAAkB,MAC7B,EAAE,SAAS;AAEb,MAAa,iBAAiB,SAC5B,KAAK,MAAM,QAAQ,MAAyB,EAAE,SAAS,gBAAgB;AAEzE,MAAa,cAAc,SACzB,KAAK,MAAM,QAAQ,MAAsB,EAAE,SAAS,YAAY;AAElE,MAAa,qBAAqB,SAChC,KAAK,MAAM,QAAQ,MAAoB,EAAE,SAAS,aAAa,EAAE,SAAS,YAAY;;;;;AAiBxF,MAAa,UACX,OACA,UACe;CACf,GAAG;CACH,SAAS,CAAC,GAAG,MAAM,SAAS,GAAG,KAAK,MAAM;CAC1C;CACD;;;;;;AAWD,MAAa,cACX,SAEA,KAAK,KACH,OAAO,WAAW,OAChB,GAAG,SAAS,eAAe,OAAO,QAAQ,GAAG,KAAK,GAAG,OAAO,SAC7D,CACF;;;;;;AAWH,IAAa,kBAAb,cAAqC,KAAK,YAAY,kBAAkB,CAErE;AAEH,MAAM,wBAAwB,SAAqE;CACjG,MAAM,aAAa,kBAAkB,KAAK;CAC1C,MAAM,OAAO,WAAW,WAAW,SAAS;AAC5C,KAAI,SAAS,KAAA,EAAW,QAAO;EAAE,MAAM;EAAI,SAAS;EAAO;AAC3D,KAAI,KAAK,QAAQ,KAAK,UAAU,CAAE,QAAO;EAAE,MAAM;EAAI,SAAS;EAAM;AAKpE,QAAO;EAAE,MAJI,KAAK,QACf,OAAO,aAAa,CACpB,KAAK,MAAM,EAAE,KAAK,CAClB,KAAK,GACK;EAAE,SAAS;EAAO;;;;;;;;;;;;AAajC,MAAa,gBACX,MACA,WAKA,KAAK,qBAAqB,KAAK,GAAG,EAAE,MAAM,cACxC,UAAU,OAAO,KAAK,IAAI,gBAAgB,EAAE,MAAM,CAAC,CAAC,GAAGA,UAA2B,OAAO,CAAC,KAAK,CAChG"}
+{"version":3,"file":"Turn.mjs","names":["StructuredFormat.parseJson"],"sources":["../../src/domain/Turn.ts"],"sourcesContent":["import { Data, Effect, Result, Schema, Stream, pipe } from \"effect\"\nimport * as StructuredFormat from \"../structured-format/StructuredFormat.js\"\nimport {\n  FunctionCall,\n  FunctionCallOutput,\n  Item,\n  isOutputText,\n  isRefusal,\n  Message,\n  Reasoning,\n  StopReason,\n  Usage,\n} from \"./Items.js\"\n\n/**\n * The result of a single LLM generation. A turn produces zero or more items\n * (typically one assistant message and zero or more function_call items)\n * and reports usage + a stop reason.\n */\nexport const Turn = Schema.Struct({\n  items: Schema.Array(Item),\n  usage: Usage,\n  stop_reason: StopReason,\n})\nexport type Turn = typeof Turn.Type\n\n/**\n * Canonical events emitted while a single turn is being generated. Most\n * variants are streaming deltas (text, reasoning, tool-call args); the\n * terminal `turn_complete` carries the assembled `Turn`. Lifecycle members\n * aren't deltas, hence the union name.\n */\nexport type TurnEvent =\n  | { readonly type: \"text_delta\"; readonly text: string }\n  | {\n      readonly type: \"reasoning_delta\"\n      readonly text: string\n      /**\n       * `trace` is the model's raw chain-of-thought; `summary` is a\n       * model-written summary intended for display. OpenAI Responses emits\n       * both as separate wire events; Anthropic and Gemini only emit\n       * `trace`. Consumers who just want any reasoning text match once;\n       * those who want only summaries filter `kind === \"summary\"`.\n       */\n      readonly kind: \"trace\" | \"summary\"\n    }\n  /**\n   * The model declined to answer. `text` is the (streamed) explanation.\n   * Distinct from the failure channel: a refusal is normal model output and\n   * the stream still completes with `turn_complete`. OpenAI Responses emits\n   * this; Anthropic surfaces refusals via `stop_reason`, and Gemini collapses\n   * them into `finishReason: SAFETY` - both go without a `refusal_delta`.\n   */\n  | { readonly type: \"refusal_delta\"; readonly text: string }\n  | { readonly type: \"tool_call_start\"; readonly call_id: string; readonly name: string }\n  | { readonly type: \"tool_call_args_delta\"; readonly call_id: string; readonly delta: string }\n  /**\n   * Mid-stream cumulative usage. Carries the full `Usage` (including cache\n   * token fields when the provider surfaces them) so consumers can drive\n   * live budget / cost tracking without waiting for `turn_complete`.\n   * Anthropic emits this on `message_start` and `message_delta`; other\n   * providers may not emit any `usage_update` and only deliver usage via\n   * `turn_complete.turn.usage`.\n   */\n  | { readonly type: \"usage_update\"; readonly usage: Usage }\n  | { readonly type: \"turn_complete\"; readonly turn: Turn }\n\n/**\n * What flows out of an agent loop body to its consumer per turn: every\n * `TurnEvent` the provider emits (including the terminal `turn_complete`\n * carrying the assembled `Turn`), plus the output of any tool the loop ran.\n * Both variants carry a `type` discriminator.\n */\nexport type InteractionEvent = TurnEvent | FunctionCallOutput\n\nexport const isTurnComplete = (d: TurnEvent): d is Extract<TurnEvent, { type: \"turn_complete\" }> =>\n  d.type === \"turn_complete\"\n\nexport const functionCalls = (turn: Turn): ReadonlyArray<FunctionCall> =>\n  turn.items.filter((i): i is FunctionCall => i.type === \"function_call\")\n\nexport const reasonings = (turn: Turn): ReadonlyArray<Reasoning> =>\n  turn.items.filter((i): i is Reasoning => i.type === \"reasoning\")\n\nexport const assistantMessages = (turn: Turn): ReadonlyArray<Message> =>\n  turn.items.filter((i): i is Message => i.type === \"message\" && i.role === \"assistant\")\n\n/**\n * Append a completed turn and optional follow-up items to a state record's\n * history. Recipes use this at the point where structured tool results are\n * converted to model-facing `FunctionCallOutput`s.\n */\nexport const appendTurn = <S extends { readonly history: ReadonlyArray<Item> }>(\n  state: S,\n  turn: Turn,\n  items: ReadonlyArray<Item> = [],\n): S => ({\n  ...state,\n  history: [...state.history, ...turn.items, ...items],\n})\n\n// ---------------------------------------------------------------------------\n// Stream operators\n// ---------------------------------------------------------------------------\n\n/**\n * Project a `TurnEvent` stream onto its `text_delta` payloads. Other\n * variants are dropped. Composes with `Lines.lines` +\n * `decodeJsonLines` for prompted-JSONL streaming.\n */\nexport const textDeltas = <E, R>(\n  self: Stream.Stream<TurnEvent, E, R>,\n): Stream.Stream<string, E, R> =>\n  self.pipe(\n    Stream.filterMap((ev) =>\n      ev.type === \"text_delta\" ? Result.succeed(ev.text) : Result.failVoid,\n    ),\n  )\n\n// ---------------------------------------------------------------------------\n// Structured-output integration\n// ---------------------------------------------------------------------------\n\n/**\n * The assistant message on the just-completed turn was a refusal block,\n * not an `output_text` payload. Returned by `toStructured` to short-circuit\n * decoding before `JSON.parse` / schema validation runs.\n */\nexport class RefusalRejected extends Data.TaggedError(\"RefusalRejected\")<{\n  readonly turn: Turn\n}> {}\n\nconst lastAssistantContent = (turn: Turn): { readonly text: string; readonly refused: boolean } => {\n  const assistants = assistantMessages(turn)\n  const last = assistants[assistants.length - 1]\n  if (last === undefined) return { text: \"\", refused: false }\n  if (last.content.some(isRefusal)) return { text: \"\", refused: true }\n  const text = last.content\n    .filter(isOutputText)\n    .map((b) => b.text)\n    .join(\"\")\n  return { text, refused: false }\n}\n\n/**\n * Validate a completed `Turn` against a `StructuredFormat`. Concatenates\n * `output_text` blocks on the last assistant message, then runs\n * `JSON.parse` + the format's schema validation.\n *\n * Three failure modes:\n * - `RefusalRejected` — the assistant emitted a refusal block.\n * - `JsonParseError` — the assembled text wasn't valid JSON.\n * - `StructuredDecodeError` — the JSON didn't match the schema.\n */\nexport const toStructured = <A>(\n  turn: Turn,\n  format: StructuredFormat.StructuredFormat<A>,\n): Effect.Effect<\n  A,\n  RefusalRejected | StructuredFormat.JsonParseError | StructuredFormat.StructuredDecodeError\n> =>\n  pipe(lastAssistantContent(turn), ({ text, refused }) =>\n    refused ? Effect.fail(new RefusalRejected({ turn })) : StructuredFormat.parseJson(format)(text),\n  )\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAmBA,MAAa,OAAO,OAAO,OAAO;CAChC,OAAO,OAAO,MAAM,KAAK;CACzB,OAAO;CACP,aAAa;CACd,CAAC;AAoDF,MAAa,kBAAkB,MAC7B,EAAE,SAAS;AAEb,MAAa,iBAAiB,SAC5B,KAAK,MAAM,QAAQ,MAAyB,EAAE,SAAS,gBAAgB;AAEzE,MAAa,cAAc,SACzB,KAAK,MAAM,QAAQ,MAAsB,EAAE,SAAS,YAAY;AAElE,MAAa,qBAAqB,SAChC,KAAK,MAAM,QAAQ,MAAoB,EAAE,SAAS,aAAa,EAAE,SAAS,YAAY;;;;;;AAOxF,MAAa,cACX,OACA,MACA,QAA6B,EAAE,MACxB;CACP,GAAG;CACH,SAAS;EAAC,GAAG,MAAM;EAAS,GAAG,KAAK;EAAO,GAAG;EAAM;CACrD;;;;;;AAWD,MAAa,cACX,SAEA,KAAK,KACH,OAAO,WAAW,OAChB,GAAG,SAAS,eAAe,OAAO,QAAQ,GAAG,KAAK,GAAG,OAAO,SAC7D,CACF;;;;;;AAWH,IAAa,kBAAb,cAAqC,KAAK,YAAY,kBAAkB,CAErE;AAEH,MAAM,wBAAwB,SAAqE;CACjG,MAAM,aAAa,kBAAkB,KAAK;CAC1C,MAAM,OAAO,WAAW,WAAW,SAAS;AAC5C,KAAI,SAAS,KAAA,EAAW,QAAO;EAAE,MAAM;EAAI,SAAS;EAAO;AAC3D,KAAI,KAAK,QAAQ,KAAK,UAAU,CAAE,QAAO;EAAE,MAAM;EAAI,SAAS;EAAM;AAKpE,QAAO;EAAE,MAJI,KAAK,QACf,OAAO,aAAa,CACpB,KAAK,MAAM,EAAE,KAAK,CAClB,KAAK,GACK;EAAE,SAAS;EAAO;;;;;;;;;;;;AAajC,MAAa,gBACX,MACA,WAKA,KAAK,qBAAqB,KAAK,GAAG,EAAE,MAAM,cACxC,UAAU,OAAO,KAAK,IAAI,gBAAgB,EAAE,MAAM,CAAC,CAAC,GAAGA,UAA2B,OAAO,CAAC,KAAK,CAChG"}

package/dist/index.d.mts

@@ -1,10 +1,10 @@
 import { n as AiError_d_exports } from "./AiError-CqmYjXyx.mjs";
 import { h as Items_d_exports } from "./Items-D1C2686t.mjs";
 import { a as StructuredFormat_d_exports } from "./StructuredFormat-B5ueioNr.mjs";
-import { o as Turn_d_exports } from "./Turn-rlTfuHaQ.mjs";
+import { a as Turn_d_exports } from "./Turn-Bi83du4I.mjs";
 import { l as Tool_d_exports } from "./Tool-5wxOCuOh.mjs";
 import { t as LanguageModel_d_exports } from "./language-model/LanguageModel.mjs";
-import { n as Loop_d_exports } from "./Loop-CzSJo1h8.mjs";
+import { t as Loop_d_exports } from "./loop/Loop.mjs";
 import { t as Match_d_exports } from "./match/Match.mjs";
 import { t as Toolkit_d_exports } from "./tool/Toolkit.mjs";
 import { t as JSONL_d_exports } from "./streaming/JSONL.mjs";

package/dist/language-model/LanguageModel.d.mts

@@ -1,7 +1,7 @@
 import { t as AiError } from "../AiError-CqmYjXyx.mjs";
 import { m as Item } from "../Items-D1C2686t.mjs";
 import { i as StructuredFormat } from "../StructuredFormat-B5ueioNr.mjs";
-import { a as TurnEvent, i as Turn } from "../Turn-rlTfuHaQ.mjs";
+import { i as TurnEvent, r as Turn } from "../Turn-Bi83du4I.mjs";
 import { o as ToolDescriptor } from "../Tool-5wxOCuOh.mjs";
 import { Context, Effect, Stream } from "effect";
 

package/dist/loop/Loop.d.mts

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

package/dist/loop/Loop.d.mts.map

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

package/dist/testing/MockProvider.d.mts

@@ -1,5 +1,5 @@
 import { m as Item } from "../Items-D1C2686t.mjs";
-import { i as Turn } from "../Turn-rlTfuHaQ.mjs";
+import { r as Turn } from "../Turn-Bi83du4I.mjs";
 import { LanguageModel, LanguageModelService } from "../language-model/LanguageModel.mjs";
 import { Duration, Effect, Layer } from "effect";
 

package/dist/tool/HistoryCheck.d.mts

@@ -1,5 +1,5 @@
 import { m as Item, o as FunctionCall } from "../Items-D1C2686t.mjs";
-import { n as ToolResult } from "../Outcome-C2JYknCu.mjs";
+import { t as ToolResult } from "../Outcome-GiaNvt7i.mjs";
 
 //#region src/tool/HistoryCheck.d.ts
 /**

package/dist/tool/Outcome.d.mts

@@ -1,2 +1,2 @@
-import { a as execute, c as isValue, d as toFunctionCallOutput, i as denied, l as reject, n as ToolResult, o as executionError, r as cancelled, s as isFailure, t as ToolDecision, u as rejected } from "../Outcome-C2JYknCu.mjs";
-export { ToolDecision, ToolResult, cancelled, denied, execute, executionError, isFailure, isValue, reject, rejected, toFunctionCallOutput };
+import { a as isFailure, c as toFunctionCallOutput, i as executionError, n as cancelled, o as isValue, r as denied, s as rejected, t as ToolResult } from "../Outcome-GiaNvt7i.mjs";
+export { ToolResult, cancelled, denied, executionError, isFailure, isValue, rejected, toFunctionCallOutput };

package/dist/tool/Outcome.mjs

@@ -2,11 +2,10 @@ import { functionCallOutput } from "../domain/Items.mjs";
 import { Match } from "effect";
 //#region src/tool/Outcome.ts
 /**
-* Pre-execution decision (`ToolDecision`) and post-execution result
-* (`ToolResult`) for the resolver-based executor.
+* Post-execution and synthetic tool results.
 *
-*   - Resolver returns ToolDecision (Execute | Reject(result)) per call.
-*   - Executor emits ToolResult (Value | Failure) per call.
+*   - 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.
@@ -17,11 +16,6 @@ import { Match } from "effect";
 */
 const isValue = (r) => r._tag === "Value";
 const isFailure = (r) => r._tag === "Failure";
-const execute = { _tag: "Execute" };
-const reject = (result) => ({
-	_tag: "Reject",
-	result
-});
 const rejected = (call, kind, reason) => ({
 	_tag: "Failure",
 	call_id: call.call_id,
@@ -40,6 +34,6 @@ const toFunctionCallOutput = (r) => Match.value(r).pipe(Match.tag("Value", (v) =
 	reason: f.reason
 } : { kind: f.kind }))), Match.exhaustive);
 //#endregion
-export { cancelled, denied, execute, executionError, isFailure, isValue, reject, rejected, toFunctionCallOutput };
+export { cancelled, denied, executionError, isFailure, isValue, rejected, toFunctionCallOutput };
 
 //# sourceMappingURL=Outcome.mjs.map

package/dist/tool/Outcome.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"Outcome.mjs","names":[],"sources":["../../src/tool/Outcome.ts"],"sourcesContent":["/**\n * Pre-execution decision (`ToolDecision`) and post-execution result\n * (`ToolResult`) for the resolver-based executor.\n *\n *   - Resolver returns ToolDecision (Execute | Reject(result)) per call.\n *   - Executor emits ToolResult (Value | Failure) per call.\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 { Match } 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 =\n  | {\n      readonly _tag: \"Value\"\n      readonly call_id: string\n      readonly tool: string\n      readonly value: unknown\n    }\n  | {\n      readonly _tag: \"Failure\"\n      readonly call_id: string\n      readonly tool: string\n      readonly kind: string\n      readonly reason?: string\n    }\n\nexport const isValue = (r: ToolResult): r is Extract<ToolResult, { _tag: \"Value\" }> =>\n  r._tag === \"Value\"\n\nexport const isFailure = (r: ToolResult): r is Extract<ToolResult, { _tag: \"Failure\" }> =>\n  r._tag === \"Failure\"\n\n// ---------------------------------------------------------------------------\n// ToolDecision\n// ---------------------------------------------------------------------------\n\nexport type ToolDecision =\n  | { readonly _tag: \"Execute\" }\n  | { readonly _tag: \"Reject\"; readonly result: ToolResult }\n\nexport const execute: ToolDecision = { _tag: \"Execute\" }\n\nexport const reject = (result: ToolResult): ToolDecision => ({ _tag: \"Reject\", result })\n\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 = (\n  call: FunctionCall,\n  kind: string,\n  reason?: string,\n): ToolResult => ({\n  _tag: \"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  Match.value(r).pipe(\n    Match.tag(\"Value\", (v) => functionCallOutput(v.call_id, JSON.stringify(v.value))),\n    Match.tag(\"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    Match.exhaustive,\n  )\n"],"mappings":";;;;;;;;;;;;;;;;;AAqCA,MAAa,WAAW,MACtB,EAAE,SAAS;AAEb,MAAa,aAAa,MACxB,EAAE,SAAS;AAUb,MAAa,UAAwB,EAAE,MAAM,WAAW;AAExD,MAAa,UAAU,YAAsC;CAAE,MAAM;CAAU;CAAQ;AAOvF,MAAa,YACX,MACA,MACA,YACgB;CAChB,MAAM;CACN,SAAS,KAAK;CACd,MAAM,KAAK;CACX;CACA,GAAI,WAAW,KAAA,IAAY,EAAE,QAAQ,GAAG,EAAE;CAC3C;;AAGD,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,MAAM,MAAM,EAAE,CAAC,KACb,MAAM,IAAI,UAAU,MAAM,mBAAmB,EAAE,SAAS,KAAK,UAAU,EAAE,MAAM,CAAC,CAAC,EACjF,MAAM,IAAI,YAAY,MACpB,mBACE,EAAE,SACF,KAAK,UACH,EAAE,WAAW,KAAA,IAAY;CAAE,MAAM,EAAE;CAAM,QAAQ,EAAE;CAAQ,GAAG,EAAE,MAAM,EAAE,MAAM,CAC/E,CACF,CACF,EACD,MAAM,WACP"}
+{"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 { Match } 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 =\n  | {\n      readonly _tag: \"Value\"\n      readonly call_id: string\n      readonly tool: string\n      readonly value: unknown\n    }\n  | {\n      readonly _tag: \"Failure\"\n      readonly call_id: string\n      readonly tool: string\n      readonly kind: string\n      readonly reason?: string\n    }\n\nexport const isValue = (r: ToolResult): r is Extract<ToolResult, { _tag: \"Value\" }> =>\n  r._tag === \"Value\"\n\nexport const isFailure = (r: ToolResult): r is Extract<ToolResult, { _tag: \"Failure\" }> =>\n  r._tag === \"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 = (\n  call: FunctionCall,\n  kind: string,\n  reason?: string,\n): ToolResult => ({\n  _tag: \"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  Match.value(r).pipe(\n    Match.tag(\"Value\", (v) => functionCallOutput(v.call_id, JSON.stringify(v.value))),\n    Match.tag(\"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    Match.exhaustive,\n  )\n"],"mappings":";;;;;;;;;;;;;;;;AAoCA,MAAa,WAAW,MACtB,EAAE,SAAS;AAEb,MAAa,aAAa,MACxB,EAAE,SAAS;AAMb,MAAa,YACX,MACA,MACA,YACgB;CAChB,MAAM;CACN,SAAS,KAAK;CACd,MAAM,KAAK;CACX;CACA,GAAI,WAAW,KAAA,IAAY,EAAE,QAAQ,GAAG,EAAE;CAC3C;;AAGD,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,MAAM,MAAM,EAAE,CAAC,KACb,MAAM,IAAI,UAAU,MAAM,mBAAmB,EAAE,SAAS,KAAK,UAAU,EAAE,MAAM,CAAC,CAAC,EACjF,MAAM,IAAI,YAAY,MACpB,mBACE,EAAE,SACF,KAAK,UACH,EAAE,WAAW,KAAA,IAAY;CAAE,MAAM,EAAE;CAAM,QAAQ,EAAE;CAAQ,GAAG,EAAE,MAAM,EAAE,MAAM,CAC/E,CACF,CACF,EACD,MAAM,WACP"}

package/dist/tool/Resolvers.d.mts

@@ -1,23 +1,37 @@
 import { o as FunctionCall } from "../Items-D1C2686t.mjs";
-import { n as ToolResult, t as ToolDecision } from "../Outcome-C2JYknCu.mjs";
-import { t as ToolEvent } from "../ToolEvent-B2N10hr3.mjs";
-import { Resolver } from "./Toolkit.mjs";
+import { t as ToolResult } from "../Outcome-GiaNvt7i.mjs";
+import { t as ToolEvent } from "../ToolEvent-wTMgb2GO.mjs";
 import { Effect, Queue, Scope, Stream } from "effect";
 
 //#region src/tool/Resolvers.d.ts
+interface ToolCallPlan {
+  readonly approved: ReadonlyArray<FunctionCall>;
+  readonly rejected: ReadonlyArray<ToolResult>;
+}
+type ToolCallDecision = {
+  readonly _tag: "Approved";
+  readonly call: FunctionCall;
+} | {
+  readonly _tag: "Rejected";
+  readonly result: ToolResult;
+};
+declare const approve: (call: FunctionCall) => ToolCallDecision;
+declare const reject: (result: ToolResult) => ToolCallDecision;
+declare const splitToolCallDecisions: (decisions: ReadonlyArray<ToolCallDecision>) => ToolCallPlan;
+declare const approvalRequested: (call: FunctionCall) => ToolEvent;
 interface Verdict {
   readonly call_id: string;
   readonly decision: "approve" | "deny";
   readonly reason?: string;
 }
 /**
- * Queue-backed resolver. The router fiber drains verdicts and resolves
- * pre-registered Deferreds keyed by `call_id`. Returns the resolver and
- * a stream of `ApprovalRequested` events for the gated calls; the recipe
- * merges the announce stream into its consumer view.
+ * Queue-backed approval planner. Safe calls are returned immediately in
+ * `approved`; gated calls emit `ApprovalRequested` events and later produce
+ * one `ToolCallDecision` when their matching verdict arrives.
  */
 declare const fromVerdictQueue: (predicate: (call: FunctionCall) => boolean, verdicts: Queue.Dequeue<Verdict>) => (calls: ReadonlyArray<FunctionCall>) => Effect.Effect<{
-  readonly resolve: Resolver;
+  readonly approved: ReadonlyArray<FunctionCall>;
+  readonly decisions: Stream.Stream<ToolCallDecision>;
   readonly announce: Stream.Stream<ToolEvent>;
 }, never, Scope.Scope>;
 type ApprovalMapEntry = {
@@ -26,19 +40,7 @@ type ApprovalMapEntry = {
   readonly decision: "deny";
   readonly reason?: string;
 };
-declare const fromApprovalMap: (predicate: (call: FunctionCall) => boolean, approvals: ReadonlyMap<string, ApprovalMapEntry>) => Resolver;
-/**
- * Authz gate. `canApprove` runs BEFORE the inner resolver; failures
- * short-circuit to a `permission_denied` rejection. Override `onForbidden`
- * if your audit format wants a different kind or reason.
- */
-declare const withPermissions: (inner: Resolver, canApprove: (call: FunctionCall) => Effect.Effect<boolean>, onForbidden?: (call: FunctionCall) => ToolResult) => Resolver;
-/**
- * Fallback gate. If `inner` returns a Reject whose result matches the
- * `recoverable` predicate, run `fallback(call)` instead and use that
- * decision. Otherwise pass the original Reject through.
- */
-declare const withFallback: (inner: Resolver, recoverable: (result: ToolResult) => boolean, fallback: (call: FunctionCall) => Effect.Effect<ToolDecision>) => Resolver;
+declare const fromApprovalMap: (predicate: (call: FunctionCall) => boolean, approvals: ReadonlyMap<string, ApprovalMapEntry>) => (calls: ReadonlyArray<FunctionCall>) => ToolCallPlan;
 //#endregion
-export { ApprovalMapEntry, Verdict, fromApprovalMap, fromVerdictQueue, withFallback, withPermissions };
+export { ApprovalMapEntry, ToolCallDecision, ToolCallPlan, Verdict, approvalRequested, approve, fromApprovalMap, fromVerdictQueue, reject, splitToolCallDecisions };
 //# sourceMappingURL=Resolvers.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Resolvers.d.mts","names":[],"sources":["../../src/tool/Resolvers.ts"],"mappings":";;;;;;;UA8BiB,OAAA;EAAA,SACN,OAAA;EAAA,SACA,QAAA;EAAA,SACA,MAAA;AAAA;;;;;;;cASE,gBAAA,GAET,SAAA,GAAY,IAAA,EAAM,YAAA,cAClB,QAAA,EAAU,KAAA,CAAM,OAAA,CAAQ,OAAA,OAGxB,KAAA,EAAO,aAAA,CAAc,YAAA,MACpB,MAAA,CAAO,MAAA;EAAA,SAEG,OAAA,EAAS,QAAA;EAAA,SACT,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,GAET,SAAA,GAAY,IAAA,EAAM,YAAA,cAClB,SAAA,EAAW,WAAA,SAAoB,gBAAA,MAC9B,QAAA;;;;;;cAmBQ,eAAA,GAET,KAAA,EAAO,QAAA,EACP,UAAA,GAAa,IAAA,EAAM,YAAA,KAAiB,MAAA,CAAO,MAAA,WAC3C,WAAA,IAAc,IAAA,EAAM,YAAA,KAAiB,UAAA,KAEpC,QAAA;;;;;;cAaQ,YAAA,GAET,KAAA,EAAO,QAAA,EACP,WAAA,GAAc,MAAA,EAAQ,UAAA,cACtB,QAAA,GAAW,IAAA,EAAM,YAAA,KAAiB,MAAA,CAAO,MAAA,CAAO,YAAA,MAC/C,QAAA"}
+{"version":3,"file":"Resolvers.d.mts","names":[],"sources":["../../src/tool/Resolvers.ts"],"mappings":";;;;;;UAYiB,YAAA;EAAA,SACN,QAAA,EAAU,aAAA,CAAc,YAAA;EAAA,SACxB,QAAA,EAAU,aAAA,CAAc,UAAA;AAAA;AAAA,KAGvB,gBAAA;EAAA,SACG,IAAA;EAAA,SAA2B,IAAA,EAAM,YAAA;AAAA;EAAA,SACjC,IAAA;EAAA,SAA2B,MAAA,EAAQ,UAAA;AAAA;AAAA,cAErC,OAAA,GAAW,IAAA,EAAM,YAAA,KAAe,gBAAA;AAAA,cAKhC,MAAA,GAAU,MAAA,EAAQ,UAAA,KAAa,gBAAA;AAAA,cAK/B,sBAAA,GACX,SAAA,EAAW,aAAA,CAAc,gBAAA,MACxB,YAAA;AAAA,cASU,iBAAA,GAAqB,IAAA,EAAM,YAAA,KAAe,SAAA;AAAA,UAWtC,OAAA;EAAA,SACN,OAAA;EAAA,SACA,QAAA;EAAA,SACA,MAAA;AAAA;;;;;AAnCX;cA2Ca,gBAAA,GAET,SAAA,GAAY,IAAA,EAAM,YAAA,cAClB,QAAA,EAAU,KAAA,CAAM,OAAA,CAAQ,OAAA,OAGxB,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,GAET,SAAA,GAAY,IAAA,EAAM,YAAA,cAClB,SAAA,EAAW,WAAA,SAAoB,gBAAA,OAEhC,KAAA,EAAO,aAAA,CAAc,YAAA,MAAgB,YAAA"}

package/dist/tool/Resolvers.mjs

@@ -1,26 +1,45 @@
-import { cancelled, denied, execute, reject, rejected } from "./Outcome.mjs";
+import { cancelled, denied } from "./Outcome.mjs";
 import { Deferred, Effect, Queue, Stream } from "effect";
 //#region src/tool/Resolvers.ts
 /**
-* Ready-made `Resolver`s for the two transport flavors plus combinators
-* for layering policy on top.
+* Approval helpers for the two transport flavors.
 *
-*   - `fromVerdictQueue` : long-lived channel (WebSocket / SSE).
-*   - `fromApprovalMap`  : request-shaped (HTTP chat).
-*   - `withPermissions`  : authz wrapper.
-*   - `withFallback`     : recovery wrapper.
-*
-* None of these know about the executor's stream shape; they just produce
-* `Effect<ToolDecision>`s a `Resolver` can return.
+* 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.executeAll`.
 */
+const approve = (call) => ({
+	_tag: "Approved",
+	call
+});
+const reject = (result) => ({
+	_tag: "Rejected",
+	result
+});
+const splitToolCallDecisions = (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) => ({
+	_tag: "ApprovalRequested",
+	call_id: call.call_id,
+	tool: call.name,
+	arguments: call.arguments
+});
 /**
-* Queue-backed resolver. The router fiber drains verdicts and resolves
-* pre-registered Deferreds keyed by `call_id`. Returns the resolver and
-* a stream of `ApprovalRequested` events for the gated calls; the recipe
-* merges the announce stream into its consumer view.
+* Queue-backed approval planner. Safe calls are returned immediately in
+* `approved`; gated calls emit `ApprovalRequested` events and later produce
+* one `ToolCallDecision` when their matching verdict arrives.
 */
 const fromVerdictQueue = (predicate, verdicts) => (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);
 	yield* Effect.forkScoped(Effect.forever(Effect.gen(function* () {
@@ -28,40 +47,22 @@ const fromVerdictQueue = (predicate, verdicts) => (calls) => Effect.gen(function
 		const d = deferreds.get(v.call_id);
 		if (d !== void 0) yield* Deferred.succeed(d, v);
 	})));
-	const resolve = (call) => {
-		if (!predicate(call)) return Effect.succeed(execute);
-		const d = deferreds.get(call.call_id);
-		return Deferred.await(d).pipe(Effect.map((v) => v.decision === "approve" ? execute : reject(denied(call, v.reason))));
-	};
 	return {
-		resolve,
-		announce: Stream.fromIterable(gated.map((call) => ({
-			_tag: "ApprovalRequested",
-			call_id: call.call_id,
-			tool: call.name,
-			arguments: call.arguments
-		})))
+		approved,
+		decisions: Stream.fromIterable(gated).pipe(Stream.flatMap((call) => {
+			const d = deferreds.get(call.call_id);
+			return Stream.fromEffect(Deferred.await(d).pipe(Effect.map((v) => v.decision === "approve" ? approve(call) : reject(denied(call, v.reason)))));
+		}, { concurrency: "unbounded" })),
+		announce: Stream.fromIterable(gated.map(approvalRequested))
 	};
 });
-const fromApprovalMap = (predicate, approvals) => (call) => {
-	if (!predicate(call)) return Effect.succeed(execute);
+const fromApprovalMap = (predicate, approvals) => (calls) => splitToolCallDecisions(calls.map((call) => {
+	if (!predicate(call)) return approve(call);
 	const v = approvals.get(call.call_id);
-	if (v === void 0) return Effect.succeed(reject(cancelled(call)));
-	return Effect.succeed(v.decision === "approve" ? execute : reject(denied(call, v.reason)));
-};
-/**
-* Authz gate. `canApprove` runs BEFORE the inner resolver; failures
-* short-circuit to a `permission_denied` rejection. Override `onForbidden`
-* if your audit format wants a different kind or reason.
-*/
-const withPermissions = (inner, canApprove, onForbidden = (call) => rejected(call, "permission_denied", "missing permissions")) => (call) => canApprove(call).pipe(Effect.flatMap((allowed) => allowed ? inner(call) : Effect.succeed(reject(onForbidden(call)))));
-/**
-* Fallback gate. If `inner` returns a Reject whose result matches the
-* `recoverable` predicate, run `fallback(call)` instead and use that
-* decision. Otherwise pass the original Reject through.
-*/
-const withFallback = (inner, recoverable, fallback) => (call) => inner(call).pipe(Effect.flatMap((decision) => decision._tag === "Reject" && recoverable(decision.result) ? fallback(call) : Effect.succeed(decision)));
+	if (v === void 0) return reject(cancelled(call));
+	return v.decision === "approve" ? approve(call) : reject(denied(call, v.reason));
+}));
 //#endregion
-export { fromApprovalMap, fromVerdictQueue, withFallback, withPermissions };
+export { approvalRequested, approve, fromApprovalMap, fromVerdictQueue, reject, splitToolCallDecisions };
 
 //# sourceMappingURL=Resolvers.mjs.map