@effect-uai/core 0.5.2 → 0.7.0

package/dist/tool/ToolEvent.d.mts

@@ -1,10 +1,10 @@
-import { ToolResult } from "./Outcome.mjs";
+import { ToolResult } from "./ToolResult.mjs";
 import { Data } from "effect";
 import * as _$effect_Unify0 from "effect/Unify";
 
 //#region src/tool/ToolEvent.d.ts
 declare namespace ToolEvent_d_exports {
-  export { ToolEvent, isApprovalRequested, isIntermediate, isOutput };
+  export { ToolEvent, isApprovalRequested, isOutput, isProgress };
 }
 type ToolEvent = Data.TaggedEnum<{
   ApprovalRequested: {
@@ -12,7 +12,7 @@ type ToolEvent = Data.TaggedEnum<{
     readonly tool: string;
     readonly arguments: string;
   };
-  Intermediate: {
+  Progress: {
     readonly call_id: string;
     readonly tool: string;
     readonly data: unknown;
@@ -25,7 +25,7 @@ type ToolEvent = Data.TaggedEnum<{
  * Namespace of constructors, type guards, and matchers for `ToolEvent`,
  * provided by `Data.taggedEnum`. Use `ToolEvent.Output({ result })` to build
  * an event, `ToolEvent.$is("Output")` for type narrowing,
- * `ToolEvent.$match({ ApprovalRequested, Intermediate, Output })` for
+ * `ToolEvent.$match({ ApprovalRequested, Progress, Output })` for
  * exhaustive pattern matching.
  */
 declare const ToolEvent: {
@@ -35,8 +35,8 @@ declare const ToolEvent: {
     readonly tool: string;
     readonly arguments: string;
   }, "_tag">;
-  readonly Intermediate: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Intermediate";
+  readonly Progress: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Progress";
     readonly call_id: string;
     readonly tool: string;
     readonly data: unknown;
@@ -45,7 +45,7 @@ declare const ToolEvent: {
     readonly _tag: "Output";
     readonly result: ToolResult;
   }, "_tag">;
-  readonly $is: <Tag extends "ApprovalRequested" | "Intermediate" | "Output">(tag: Tag) => (u: unknown) => u is Extract<{
+  readonly $is: <Tag extends "ApprovalRequested" | "Progress" | "Output">(tag: Tag) => (u: unknown) => u is Extract<{
     readonly _tag: "ApprovalRequested";
     readonly call_id: string;
     readonly tool: string;
@@ -53,7 +53,7 @@ declare const ToolEvent: {
   }, {
     readonly _tag: Tag;
   }> | Extract<{
-    readonly _tag: "Intermediate";
+    readonly _tag: "Progress";
     readonly call_id: string;
     readonly tool: string;
     readonly data: unknown;
@@ -73,8 +73,8 @@ declare const ToolEvent: {
         readonly tool: string;
         readonly arguments: string;
       }) => any;
-      readonly Intermediate: (args: {
-        readonly _tag: "Intermediate";
+      readonly Progress: (args: {
+        readonly _tag: "Progress";
         readonly call_id: string;
         readonly tool: string;
         readonly data: unknown;
@@ -89,14 +89,14 @@ declare const ToolEvent: {
       readonly tool: string;
       readonly arguments: string;
     } | {
-      readonly _tag: "Intermediate";
+      readonly _tag: "Progress";
       readonly call_id: string;
       readonly tool: string;
       readonly data: unknown;
     } | {
       readonly _tag: "Output";
       readonly result: ToolResult;
-    }) => _$effect_Unify0.Unify<ReturnType<Cases["ApprovalRequested" | "Intermediate" | "Output"]>>;
+    }) => _$effect_Unify0.Unify<ReturnType<Cases["ApprovalRequested" | "Progress" | "Output"]>>;
     <Cases extends {
       readonly ApprovalRequested: (args: {
         readonly _tag: "ApprovalRequested";
@@ -104,8 +104,8 @@ declare const ToolEvent: {
         readonly tool: string;
         readonly arguments: string;
       }) => any;
-      readonly Intermediate: (args: {
-        readonly _tag: "Intermediate";
+      readonly Progress: (args: {
+        readonly _tag: "Progress";
         readonly call_id: string;
         readonly tool: string;
         readonly data: unknown;
@@ -120,14 +120,14 @@ declare const ToolEvent: {
       readonly tool: string;
       readonly arguments: string;
     } | {
-      readonly _tag: "Intermediate";
+      readonly _tag: "Progress";
       readonly call_id: string;
       readonly tool: string;
       readonly data: unknown;
     } | {
       readonly _tag: "Output";
       readonly result: ToolResult;
-    }, cases: Cases): _$effect_Unify0.Unify<ReturnType<Cases["ApprovalRequested" | "Intermediate" | "Output"]>>;
+    }, cases: Cases): _$effect_Unify0.Unify<ReturnType<Cases["ApprovalRequested" | "Progress" | "Output"]>>;
   };
 };
 declare const isApprovalRequested: (u: unknown) => u is {
@@ -136,8 +136,8 @@ declare const isApprovalRequested: (u: unknown) => u is {
   readonly tool: string;
   readonly arguments: string;
 };
-declare const isIntermediate: (u: unknown) => u is {
-  readonly _tag: "Intermediate";
+declare const isProgress: (u: unknown) => u is {
+  readonly _tag: "Progress";
   readonly call_id: string;
   readonly tool: string;
   readonly data: unknown;
@@ -147,5 +147,5 @@ declare const isOutput: (u: unknown) => u is {
   readonly result: ToolResult;
 };
 //#endregion
-export { ToolEvent, isApprovalRequested, isIntermediate, isOutput, ToolEvent_d_exports as t };
+export { ToolEvent, isApprovalRequested, isOutput, isProgress, ToolEvent_d_exports as t };
 //# sourceMappingURL=ToolEvent.d.mts.map

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

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

package/dist/tool/ToolEvent.mjs

@@ -5,30 +5,30 @@ import { Data } from "effect";
 * The event type emitted while handling tool calls.
 *
 *   - ApprovalRequested : gated calls waiting for approval
-*   - Intermediate      : per-element passthrough from a streaming tool's run
+*   - Progress          : per-element passthrough from a streaming tool's run
 *   - Output            : terminal result (carries a structured ToolResult)
 *
-* Recipes thread `ToolEvent.Output.result` through `continueWith` and apply
-* `toFunctionCallOutput` when appending to history.
+* Recipes thread `ToolEvent.Output.result` through `continueWithResults` and
+* apply `toToolCallOutput` when appending to history.
 */
 var ToolEvent_exports = /* @__PURE__ */ __exportAll({
 	ToolEvent: () => ToolEvent,
 	isApprovalRequested: () => isApprovalRequested,
-	isIntermediate: () => isIntermediate,
-	isOutput: () => isOutput
+	isOutput: () => isOutput,
+	isProgress: () => isProgress
 });
 /**
 * Namespace of constructors, type guards, and matchers for `ToolEvent`,
 * provided by `Data.taggedEnum`. Use `ToolEvent.Output({ result })` to build
 * an event, `ToolEvent.$is("Output")` for type narrowing,
-* `ToolEvent.$match({ ApprovalRequested, Intermediate, Output })` for
+* `ToolEvent.$match({ ApprovalRequested, Progress, Output })` for
 * exhaustive pattern matching.
 */
 const ToolEvent = Data.taggedEnum();
 const isApprovalRequested = ToolEvent.$is("ApprovalRequested");
-const isIntermediate = ToolEvent.$is("Intermediate");
+const isProgress = ToolEvent.$is("Progress");
 const isOutput = ToolEvent.$is("Output");
 //#endregion
-export { ToolEvent, isApprovalRequested, isIntermediate, isOutput, ToolEvent_exports as t };
+export { ToolEvent, isApprovalRequested, isOutput, isProgress, ToolEvent_exports as t };
 
 //# sourceMappingURL=ToolEvent.mjs.map

package/dist/tool/ToolEvent.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"ToolEvent.mjs","names":[],"sources":["../../src/tool/ToolEvent.ts"],"sourcesContent":["/**\n * The event type emitted while handling tool calls.\n *\n *   - ApprovalRequested : gated calls waiting for approval\n *   - Intermediate      : per-element passthrough from a streaming tool's run\n *   - Output            : terminal result (carries a structured ToolResult)\n *\n * Recipes thread `ToolEvent.Output.result` through `continueWith` and apply\n * `toFunctionCallOutput` when appending to history.\n */\nimport { Data } from \"effect\"\nimport type { ToolResult } from \"./Outcome.js\"\n\nexport type ToolEvent = Data.TaggedEnum<{\n  ApprovalRequested: {\n    readonly call_id: string\n    readonly tool: string\n    readonly arguments: string\n  }\n  Intermediate: {\n    readonly call_id: string\n    readonly tool: string\n    readonly data: unknown\n  }\n  Output: {\n    readonly result: ToolResult\n  }\n}>\n\n/**\n * Namespace of constructors, type guards, and matchers for `ToolEvent`,\n * provided by `Data.taggedEnum`. Use `ToolEvent.Output({ result })` to build\n * an event, `ToolEvent.$is(\"Output\")` for type narrowing,\n * `ToolEvent.$match({ ApprovalRequested, Intermediate, Output })` for\n * exhaustive pattern matching.\n */\nexport const ToolEvent = Data.taggedEnum<ToolEvent>()\n\nexport const isApprovalRequested = ToolEvent.$is(\"ApprovalRequested\")\nexport const isIntermediate = ToolEvent.$is(\"Intermediate\")\nexport const isOutput = ToolEvent.$is(\"Output\")\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,MAAa,YAAY,KAAK,YAAuB;AAErD,MAAa,sBAAsB,UAAU,IAAI,oBAAoB;AACrE,MAAa,iBAAiB,UAAU,IAAI,eAAe;AAC3D,MAAa,WAAW,UAAU,IAAI,SAAS"}
+{"version":3,"file":"ToolEvent.mjs","names":[],"sources":["../../src/tool/ToolEvent.ts"],"sourcesContent":["/**\n * The event type emitted while handling tool calls.\n *\n *   - ApprovalRequested : gated calls waiting for approval\n *   - Progress          : per-element passthrough from a streaming tool's run\n *   - Output            : terminal result (carries a structured ToolResult)\n *\n * Recipes thread `ToolEvent.Output.result` through `continueWithResults` and\n * apply `toToolCallOutput` when appending to history.\n */\nimport { Data } from \"effect\"\nimport type { ToolResult } from \"./ToolResult.js\"\n\nexport type ToolEvent = Data.TaggedEnum<{\n  ApprovalRequested: {\n    readonly call_id: string\n    readonly tool: string\n    readonly arguments: string\n  }\n  Progress: {\n    readonly call_id: string\n    readonly tool: string\n    readonly data: unknown\n  }\n  Output: {\n    readonly result: ToolResult\n  }\n}>\n\n/**\n * Namespace of constructors, type guards, and matchers for `ToolEvent`,\n * provided by `Data.taggedEnum`. Use `ToolEvent.Output({ result })` to build\n * an event, `ToolEvent.$is(\"Output\")` for type narrowing,\n * `ToolEvent.$match({ ApprovalRequested, Progress, Output })` for\n * exhaustive pattern matching.\n */\nexport const ToolEvent = Data.taggedEnum<ToolEvent>()\n\nexport const isApprovalRequested = ToolEvent.$is(\"ApprovalRequested\")\nexport const isProgress = ToolEvent.$is(\"Progress\")\nexport const isOutput = ToolEvent.$is(\"Output\")\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,MAAa,YAAY,KAAK,YAAuB;AAErD,MAAa,sBAAsB,UAAU,IAAI,oBAAoB;AACrE,MAAa,aAAa,UAAU,IAAI,WAAW;AACnD,MAAa,WAAW,UAAU,IAAI,SAAS"}

package/dist/tool/{Outcome.d.mts → ToolResult.d.mts}

@@ -1,13 +1,13 @@
-import { o as FunctionCall, s as FunctionCallOutput } from "../Items-BH8xUkoR.mjs";
+import { v as ToolCall, y as ToolCallOutput } from "../Items-D8UaXQx_.mjs";
 import { Data } from "effect";
 import * as _$effect_Unify0 from "effect/Unify";
 
-//#region src/tool/Outcome.d.ts
-declare namespace Outcome_d_exports {
-  export { ToolResult, cancelled, denied, executionError, isFailure, isValue, rejected, toFunctionCallOutput };
+//#region src/tool/ToolResult.d.ts
+declare namespace ToolResult_d_exports {
+  export { ToolResult, cancelled, denied, executionError, failed, isFailure, isOk, toToolCallOutput };
 }
 type ToolResult = Data.TaggedEnum<{
-  Value: {
+  Ok: {
     readonly call_id: string;
     readonly tool: string;
     readonly value: unknown;
@@ -21,15 +21,15 @@ type ToolResult = Data.TaggedEnum<{
 }>;
 /**
  * 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
+ * provided by `Data.taggedEnum`. Use `ToolResult.$is("Ok")` for type
+ * narrowing and `ToolResult.$match({ Ok, Failure })` for exhaustive
  * pattern matching. Synthetic-result helpers (`denied`, `cancelled`,
- * `executionError`, `rejected`) below are kinder constructors than the
+ * `executionError`, `failed`) below are kinder constructors than the
  * raw `ToolResult.Failure(...)`.
  */
 declare const ToolResult: {
-  readonly Value: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Value";
+  readonly Ok: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Ok";
     readonly call_id: string;
     readonly tool: string;
     readonly value: unknown;
@@ -41,8 +41,8 @@ declare const ToolResult: {
     readonly kind: string;
     readonly reason?: string;
   }, "_tag">;
-  readonly $is: <Tag extends "Value" | "Failure">(tag: Tag) => (u: unknown) => u is Extract<{
-    readonly _tag: "Value";
+  readonly $is: <Tag extends "Ok" | "Failure">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Ok";
     readonly call_id: string;
     readonly tool: string;
     readonly value: unknown;
@@ -59,8 +59,8 @@ declare const ToolResult: {
   }>;
   readonly $match: {
     <Cases extends {
-      readonly Value: (args: {
-        readonly _tag: "Value";
+      readonly Ok: (args: {
+        readonly _tag: "Ok";
         readonly call_id: string;
         readonly tool: string;
         readonly value: unknown;
@@ -73,7 +73,7 @@ declare const ToolResult: {
         readonly reason?: string;
       }) => any;
     }>(cases: Cases): (value: {
-      readonly _tag: "Value";
+      readonly _tag: "Ok";
       readonly call_id: string;
       readonly tool: string;
       readonly value: unknown;
@@ -83,10 +83,10 @@ declare const ToolResult: {
       readonly tool: string;
       readonly kind: string;
       readonly reason?: string;
-    }) => _$effect_Unify0.Unify<ReturnType<Cases["Value" | "Failure"]>>;
+    }) => _$effect_Unify0.Unify<ReturnType<Cases["Ok" | "Failure"]>>;
     <Cases extends {
-      readonly Value: (args: {
-        readonly _tag: "Value";
+      readonly Ok: (args: {
+        readonly _tag: "Ok";
         readonly call_id: string;
         readonly tool: string;
         readonly value: unknown;
@@ -99,7 +99,7 @@ declare const ToolResult: {
         readonly reason?: string;
       }) => any;
     }>(value: {
-      readonly _tag: "Value";
+      readonly _tag: "Ok";
       readonly call_id: string;
       readonly tool: string;
       readonly value: unknown;
@@ -109,11 +109,11 @@ declare const ToolResult: {
       readonly tool: string;
       readonly kind: string;
       readonly reason?: string;
-    }, cases: Cases): _$effect_Unify0.Unify<ReturnType<Cases["Value" | "Failure"]>>;
+    }, cases: Cases): _$effect_Unify0.Unify<ReturnType<Cases["Ok" | "Failure"]>>;
   };
 };
-declare const isValue: (u: unknown) => u is {
-  readonly _tag: "Value";
+declare const isOk: (u: unknown) => u is {
+  readonly _tag: "Ok";
   readonly call_id: string;
   readonly tool: string;
   readonly value: unknown;
@@ -125,14 +125,14 @@ declare const isFailure: (u: unknown) => u is {
   readonly kind: string;
   readonly reason?: string;
 };
-declare const rejected: (call: FunctionCall, kind: string, reason?: string) => ToolResult;
+declare const failed: (call: ToolCall, kind: string, reason?: string) => ToolResult;
 /** Explicit user/policy rejection. */
-declare const denied: (call: FunctionCall, reason?: string) => ToolResult;
+declare const denied: (call: ToolCall, reason?: string) => ToolResult;
 /** Implicit non-answer (follow-up, inactivity, abort). */
-declare const cancelled: (call: FunctionCall, reason?: string) => ToolResult;
+declare const cancelled: (call: ToolCall, reason?: string) => ToolResult;
 /** Tool's own execution failed (parse error, schema, runtime crash). */
-declare const executionError: (call: FunctionCall, reason: string) => ToolResult;
-declare const toFunctionCallOutput: (r: ToolResult) => FunctionCallOutput;
+declare const executionError: (call: ToolCall, reason: string) => ToolResult;
+declare const toToolCallOutput: (r: ToolResult) => ToolCallOutput;
 //#endregion
-export { ToolResult, cancelled, denied, executionError, isFailure, isValue, rejected, Outcome_d_exports as t, toFunctionCallOutput };
-//# sourceMappingURL=Outcome.d.mts.map
+export { ToolResult, cancelled, denied, executionError, failed, isFailure, isOk, ToolResult_d_exports as t, toToolCallOutput };
+//# sourceMappingURL=ToolResult.d.mts.map

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

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

package/dist/tool/ToolResult.mjs

@@ -0,0 +1,61 @@
+import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+import { toolCallOutput } from "../domain/Items.mjs";
+import { Data } from "effect";
+//#region src/tool/ToolResult.ts
+/**
+* Post-execution and synthetic tool results.
+*
+*   - Executed tools emit ToolResult.Ok.
+*   - Approval/cancellation policy emits synthetic ToolResult.Failure.
+*
+* Wire conversion stays at the recipe boundary via `toToolCallOutput`
+* 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 ToolResult_exports = /* @__PURE__ */ __exportAll({
+	ToolResult: () => ToolResult,
+	cancelled: () => cancelled,
+	denied: () => denied,
+	executionError: () => executionError,
+	failed: () => failed,
+	isFailure: () => isFailure,
+	isOk: () => isOk,
+	toToolCallOutput: () => toToolCallOutput
+});
+/**
+* Namespace of constructors, type guards, and matchers for `ToolResult`,
+* provided by `Data.taggedEnum`. Use `ToolResult.$is("Ok")` for type
+* narrowing and `ToolResult.$match({ Ok, Failure })` for exhaustive
+* pattern matching. Synthetic-result helpers (`denied`, `cancelled`,
+* `executionError`, `failed`) below are kinder constructors than the
+* raw `ToolResult.Failure(...)`.
+*/
+const ToolResult = Data.taggedEnum();
+const isOk = ToolResult.$is("Ok");
+const isFailure = ToolResult.$is("Failure");
+const failed = (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) => failed(call, "denied", reason);
+/** Implicit non-answer (follow-up, inactivity, abort). */
+const cancelled = (call, reason) => failed(call, "cancelled", reason);
+/** Tool's own execution failed (parse error, schema, runtime crash). */
+const executionError = (call, reason) => failed(call, "execution_error", reason);
+const toToolCallOutput = (r) => ToolResult.$match(r, {
+	Ok: (v) => toolCallOutput(v.call_id, JSON.stringify(v.value)),
+	Failure: (f) => toolCallOutput(f.call_id, JSON.stringify(f.reason !== void 0 ? {
+		kind: f.kind,
+		reason: f.reason
+	} : { kind: f.kind }))
+});
+//#endregion
+export { ToolResult, cancelled, denied, executionError, failed, isFailure, isOk, ToolResult_exports as t, toToolCallOutput };
+
+//# sourceMappingURL=ToolResult.mjs.map

package/dist/tool/ToolResult.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolResult.mjs","names":[],"sources":["../../src/tool/ToolResult.ts"],"sourcesContent":["/**\n * Post-execution and synthetic tool results.\n *\n *   - Executed tools emit ToolResult.Ok.\n *   - Approval/cancellation policy emits synthetic ToolResult.Failure.\n *\n * Wire conversion stays at the recipe boundary via `toToolCallOutput`\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 { ToolCall, ToolCallOutput } from \"../domain/Items.js\"\nimport { toolCallOutput } from \"../domain/Items.js\"\n\n// ---------------------------------------------------------------------------\n// ToolResult\n// ---------------------------------------------------------------------------\n\nexport type ToolResult = Data.TaggedEnum<{\n  Ok: {\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(\"Ok\")` for type\n * narrowing and `ToolResult.$match({ Ok, Failure })` for exhaustive\n * pattern matching. Synthetic-result helpers (`denied`, `cancelled`,\n * `executionError`, `failed`) below are kinder constructors than the\n * raw `ToolResult.Failure(...)`.\n */\nexport const ToolResult = Data.taggedEnum<ToolResult>()\n\nexport const isOk = ToolResult.$is(\"Ok\")\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 `failed`.\n// ---------------------------------------------------------------------------\n\nexport const failed = (call: ToolCall, 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: ToolCall, reason?: string): ToolResult =>\n  failed(call, \"denied\", reason)\n\n/** Implicit non-answer (follow-up, inactivity, abort). */\nexport const cancelled = (call: ToolCall, reason?: string): ToolResult =>\n  failed(call, \"cancelled\", reason)\n\n/** Tool's own execution failed (parse error, schema, runtime crash). */\nexport const executionError = (call: ToolCall, reason: string): ToolResult =>\n  failed(call, \"execution_error\", reason)\n\n// ---------------------------------------------------------------------------\n// Wire conversion - the one place structured → string happens.\n// ---------------------------------------------------------------------------\n\nexport const toToolCallOutput = (r: ToolResult): ToolCallOutput =>\n  ToolResult.$match(r, {\n    Ok: (v) => toolCallOutput(v.call_id, JSON.stringify(v.value)),\n    Failure: (f) =>\n      toolCallOutput(\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,OAAO,WAAW,IAAI,KAAK;AACxC,MAAa,YAAY,WAAW,IAAI,UAAU;AAMlD,MAAa,UAAU,MAAgB,MAAc,WACnD,WAAW,QAAQ;CACjB,SAAS,KAAK;CACd,MAAM,KAAK;CACX;CACA,GAAI,WAAW,KAAA,IAAY,EAAE,QAAQ,GAAG,EAAE;CAC3C,CAAC;;AAGJ,MAAa,UAAU,MAAgB,WACrC,OAAO,MAAM,UAAU,OAAO;;AAGhC,MAAa,aAAa,MAAgB,WACxC,OAAO,MAAM,aAAa,OAAO;;AAGnC,MAAa,kBAAkB,MAAgB,WAC7C,OAAO,MAAM,mBAAmB,OAAO;AAMzC,MAAa,oBAAoB,MAC/B,WAAW,OAAO,GAAG;CACnB,KAAK,MAAM,eAAe,EAAE,SAAS,KAAK,UAAU,EAAE,MAAM,CAAC;CAC7D,UAAU,MACR,eACE,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/Toolkit.d.mts

@@ -1,41 +1,73 @@
-import { o as FunctionCall } from "../Items-BH8xUkoR.mjs";
-import { a as Tool, i as StreamingTool, o as ToolDescriptor, t as AnyKindTool } from "../Tool-87ViKCCO.mjs";
-import { Event } from "../loop/Loop.mjs";
-import { ToolResult } from "./Outcome.mjs";
+import { o as HistoryItem, v as ToolCall } from "../Items-D8UaXQx_.mjs";
+import { Turn } from "../domain/Turn.mjs";
+import { a as Tool, i as StreamingTool, r as AnyTool } from "../Tool-CiFXYjmR.mjs";
+import { Step } from "../loop/Loop.mjs";
+import { ToolResult } from "./ToolResult.mjs";
 import { ToolEvent } from "./ToolEvent.mjs";
-import { Stream } from "effect";
+import { Effect, Stream } from "effect";
 
 //#region src/tool/Toolkit.d.ts
 declare namespace Toolkit_d_exports {
-  export { AnyTool, ExecuteOptions, ToolKindR, Toolkit, ToolsR, continueWith, executeAll, make, toDescriptors };
+  export { ExecuteOptions, ToolKindR, appendToolResults, collectResults, continueWithResults, run };
 }
-type AnyTool = Tool<string, any, any, any>;
-type Toolkit<Tools extends ReadonlyArray<AnyTool>> = {
-  readonly tools: Tools;
-};
-type ToolsR<Tools extends ReadonlyArray<AnyTool>> = Tools[number] extends Tool<any, any, any, infer R> ? R : never;
 /**
  * Union of every tool's `R` requirements in a mixed plain + streaming array.
- * Used by `executeAll` to surface the services tools need at the recipe
- * level, so the loop's stream type carries them through to `Effect.provide`.
- */
-type ToolKindR<Tools extends ReadonlyArray<AnyKindTool<any>>> = Tools[number] extends StreamingTool<any, any, any, any, infer R> ? R : Tools[number] extends Tool<any, any, any, infer R> ? R : never;
-declare const make: <const Tools extends ReadonlyArray<AnyTool>>(tools: Tools) => Toolkit<Tools>;
-/**
- * Render every tool in a toolkit to a provider-agnostic descriptor.
- * `inputSchema` is the JSON Schema document produced by the tool's
- * Standard Schema converter (draft 2020-12).
+ * Used by `run` to surface the services tools need at the recipe level, so
+ * the loop's stream type carries them through to `Effect.provide`.
  */
-declare const toDescriptors: <Tools extends ReadonlyArray<AnyTool>>(toolkit: Toolkit<Tools>) => ReadonlyArray<ToolDescriptor>;
+type ToolKindR<Tools extends ReadonlyArray<AnyTool<any>>> = Tools[number] extends StreamingTool<any, any, any, any, infer R> ? R : Tools[number] extends Tool<any, any, any, infer R> ? R : never;
 type ExecuteOptions = {
   readonly concurrency?: number | "unbounded";
 };
 /** Execute every provided call. Approval/rejection policy belongs upstream. */
-declare const executeAll: <Tools extends ReadonlyArray<AnyKindTool<any>>>(tools: Tools, calls: ReadonlyArray<FunctionCall>, options?: ExecuteOptions) => Stream.Stream<ToolEvent, never, ToolKindR<Tools>>;
-declare const continueWith: {
-  <S>(build: (results: ReadonlyArray<ToolResult>) => S): <R>(stream: Stream.Stream<ToolEvent, never, R>) => Stream.Stream<Event<ToolEvent, S>, never, R>;
-  <S, R>(stream: Stream.Stream<ToolEvent, never, R>, build: (results: ReadonlyArray<ToolResult>) => S): Stream.Stream<Event<ToolEvent, S>, never, R>;
+declare const run: <Tools extends ReadonlyArray<AnyTool<any>>>(tools: Tools, calls: ReadonlyArray<ToolCall>, options?: ExecuteOptions) => Stream.Stream<ToolEvent, never, ToolKindR<Tools>>;
+/**
+ * Append a completed turn plus tool results to a state's history, converting
+ * the results to wire-format `ToolCallOutput`s. Curried so it slots directly
+ * into `continueWithResults`:
+ *
+ *   Toolkit.run(tools, calls).pipe(
+ *     Toolkit.continueWithResults(Toolkit.appendToolResults(state, turn)),
+ *   )
+ *
+ * Equivalent to `appendToHistory(state, turn, results.map(toToolCallOutput))`
+ * — the helper just hides the wire-conversion step.
+ */
+declare const appendToolResults: <S extends {
+  readonly history: ReadonlyArray<HistoryItem>;
+}>(state: S, turn: Turn) => (results: ReadonlyArray<ToolResult>) => S;
+/**
+ * Drain a `Stream<ToolEvent>` and return the accumulated `ToolResult`s
+ * from every `Output` event. One-shot — the type is `Effect<results>`,
+ * not a one-element stream — so it composes naturally with `Effect.map`
+ * to build state.
+ *
+ * Counterpart to `continueWithResults`: `continueWithResults` bundles
+ * drain + emit Next into one bridge; this one is the right arm of a
+ * broadcast/fork-and-merge for callers that want to vary the left arm
+ * (e.g., filter/tap ToolEvents before forwarding).
+ */
+declare const collectResults: <E, R>(stream: Stream.Stream<ToolEvent, E, R>) => Effect.Effect<ReadonlyArray<ToolResult>, E, R>;
+/**
+ * Bridge from a `Stream<ToolEvent>` to the loop's emit shape. Forwards
+ * every ToolEvent downstream as a `Loop.value` and at end-of-stream emits
+ * one `Loop.next(build(results))` carrying the accumulated `ToolResult`s
+ * from terminal `Output` events.
+ *
+ * Conceptually a broadcast fork (one arm passes events through, the other
+ * drains them into a state). Implemented as a single-pass Ref tap + concat
+ * for zero buffering — the broadcast version is observationally equivalent
+ * but holds events in a PubSub until both arms drain. The public primitives
+ * (`Loop.value`, `collectResults`, `Loop.next`) compose the same pattern
+ * when you need to vary an arm.
+ *
+ * Dual: data-first `continueWithResults(stream, build)` and data-last
+ * `stream.pipe(continueWithResults(build))` both work.
+ */
+declare const continueWithResults: {
+  <S>(build: (results: ReadonlyArray<ToolResult>) => S): <R>(stream: Stream.Stream<ToolEvent, never, R>) => Stream.Stream<Step<ToolEvent, S>, never, R>;
+  <S, R>(stream: Stream.Stream<ToolEvent, never, R>, build: (results: ReadonlyArray<ToolResult>) => S): Stream.Stream<Step<ToolEvent, S>, never, R>;
 };
 //#endregion
-export { AnyTool, ExecuteOptions, ToolKindR, Toolkit, ToolsR, continueWith, executeAll, make, Toolkit_d_exports as t, toDescriptors };
+export { ExecuteOptions, ToolKindR, appendToolResults, collectResults, continueWithResults, run, Toolkit_d_exports as t };
 //# sourceMappingURL=Toolkit.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Toolkit.d.mts","names":[],"sources":["../../src/tool/Toolkit.ts"],"mappings":";;;;;;;;;;;KAgBY,OAAA,GAAU,IAAA;AAAA,KAEV,OAAA,eAAsB,aAAA,CAAc,OAAA;EAAA,SACrC,KAAA,EAAO,KAAA;AAAA;AAAA,KAGN,MAAA,eAAqB,aAAA,CAAc,OAAA,KAC7C,KAAA,iBAAsB,IAAA,2BAA+B,CAAA;;;;;;KAO3C,SAAA,eAAwB,aAAA,CAAc,WAAA,UAChD,KAAA,iBAAsB,aAAA,gCAClB,CAAA,GACA,KAAA,iBAAsB,IAAA,2BACpB,CAAA;AAAA,cAGK,IAAA,uBAA4B,aAAA,CAAc,OAAA,GAAU,KAAA,EAAO,KAAA,KAAQ,OAAA,CAAQ,KAAA;;;AArBxF;;;cA8Ba,aAAA,iBAA+B,aAAA,CAAc,OAAA,GACxD,OAAA,EAAS,OAAA,CAAQ,KAAA,MAChB,aAAA,CAAc,cAAA;AAAA,KAqBL,cAAA;EAAA,SACD,WAAA;AAAA;;cAIE,UAAA,iBAA4B,aAAA,CAAc,WAAA,QACrD,KAAA,EAAO,KAAA,EACP,KAAA,EAAO,aAAA,CAAc,YAAA,GACrB,OAAA,GAAU,cAAA,KACT,MAAA,CAAO,MAAA,CAAO,SAAA,SAAkB,SAAA,CAAU,KAAA;AAAA,cA4HhC,YAAA;EAAA,IAET,KAAA,GAAQ,OAAA,EAAS,aAAA,CAAc,UAAA,MAAgB,CAAA,OAE/C,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,SAAA,SAAkB,CAAA,MACrC,MAAA,CAAO,MAAA,CAAO,KAAA,CAAW,SAAA,EAAW,CAAA,UAAW,CAAA;EAAA,OAElD,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,SAAA,SAAkB,CAAA,GACxC,KAAA,GAAQ,OAAA,EAAS,aAAA,CAAc,UAAA,MAAgB,CAAA,GAC9C,MAAA,CAAO,MAAA,CAAO,KAAA,CAAW,SAAA,EAAW,CAAA,UAAW,CAAA;AAAA"}
+{"version":3,"file":"Toolkit.d.mts","names":[],"sources":["../../src/tool/Toolkit.ts"],"mappings":";;;;;;;;;;;;;;;;;KAqBY,SAAA,eAAwB,aAAA,CAAc,OAAA,UAChD,KAAA,iBAAsB,aAAA,gCAClB,CAAA,GACA,KAAA,iBAAsB,IAAA,2BACpB,CAAA;AAAA,KASI,cAAA;EAAA,SACD,WAAA;AAAA;;cAIE,GAAA,iBAAqB,aAAA,CAAc,OAAA,QAC9C,KAAA,EAAO,KAAA,EACP,KAAA,EAAO,aAAA,CAAc,QAAA,GACrB,OAAA,GAAU,cAAA,KACT,MAAA,CAAO,MAAA,CAAO,SAAA,SAAkB,SAAA,CAAU,KAAA;AAtB7C;;;;;;;;;;;;AAAA,cA2Ja,iBAAA;EAAA,SACW,OAAA,EAAS,aAAA,CAAc,WAAA;AAAA,GAAgB,KAAA,EAAO,CAAA,EAAG,IAAA,EAAM,IAAA,MAC5E,OAAA,EAAS,aAAA,CAAc,UAAA,MAAc,CAAA;;;;;;;;;;AAhJxC;;cA8Ja,cAAA,SACX,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,SAAA,EAAW,CAAA,EAAG,CAAA,MACnC,MAAA,CAAO,MAAA,CAAO,aAAA,CAAc,UAAA,GAAa,CAAA,EAAG,CAAA;;;AA3J/C;;;;;;;;;;;;;;cAkLa,mBAAA;EAAA,IAET,KAAA,GAAQ,OAAA,EAAS,aAAA,CAAc,UAAA,MAAgB,CAAA,OAE/C,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,SAAA,SAAkB,CAAA,MACrC,MAAA,CAAO,MAAA,CAAO,IAAA,CAAU,SAAA,EAAW,CAAA,UAAW,CAAA;EAAA,OAEjD,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,SAAA,SAAkB,CAAA,GACxC,KAAA,GAAQ,OAAA,EAAS,aAAA,CAAc,UAAA,MAAgB,CAAA,GAC9C,MAAA,CAAO,MAAA,CAAO,IAAA,CAAU,SAAA,EAAW,CAAA,UAAW,CAAA;AAAA"}

package/dist/tool/Toolkit.mjs

@@ -1,45 +1,27 @@
 import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
-import { nextAfterFold } from "../loop/Loop.mjs";
+import { appendToHistory } from "../domain/Turn.mjs";
+import { next, value } from "../loop/Loop.mjs";
 import { isStreamingTool } from "./Tool.mjs";
-import { ToolResult, executionError, rejected } from "./Outcome.mjs";
+import { ToolResult, executionError, failed, toToolCallOutput } from "./ToolResult.mjs";
 import { ToolEvent, isOutput } from "./ToolEvent.mjs";
 import { Array, Effect, Function, Ref, Schema, Stream } from "effect";
 //#region src/tool/Toolkit.ts
 var Toolkit_exports = /* @__PURE__ */ __exportAll({
-	continueWith: () => continueWith,
-	executeAll: () => executeAll,
-	make: () => make,
-	toDescriptors: () => toDescriptors
-});
-const make = (tools) => ({ tools });
-/**
-* Render every tool in a toolkit to a provider-agnostic descriptor.
-* `inputSchema` is the JSON Schema document produced by the tool's
-* Standard Schema converter (draft 2020-12).
-*/
-const toDescriptors = (toolkit) => toolkit.tools.map((tool) => {
-	const inputSchema = tool.inputSchema["~standard"].jsonSchema.input({ target: "draft-2020-12" });
-	return tool.strict !== void 0 ? {
-		name: tool.name,
-		description: tool.description,
-		inputSchema,
-		strict: tool.strict
-	} : {
-		name: tool.name,
-		description: tool.description,
-		inputSchema
-	};
+	appendToolResults: () => appendToolResults,
+	collectResults: () => collectResults,
+	continueWithResults: () => continueWithResults,
+	run: () => run
 });
 /** Execute every provided call. Approval/rejection policy belongs upstream. */
-const executeAll = (tools, calls, options) => Stream.fromIterable(calls).pipe(Stream.flatMap((call) => runOne(tools, call), { concurrency: options?.concurrency ?? "unbounded" }));
-const valueResult = (call, tool, value) => ToolResult.Value({
+const run = (tools, calls, options) => Stream.fromIterable(calls).pipe(Stream.flatMap((call) => runOne(tools, call), { concurrency: options?.concurrency ?? "unbounded" }));
+const okResult = (call, tool, value) => ToolResult.Ok({
 	call_id: call.call_id,
 	tool,
 	value
 });
 const runOne = (tools, call) => {
 	const tool = tools.find((t) => t.name === call.name);
-	if (tool === void 0) return Stream.succeed(ToolEvent.Output({ result: rejected(call, "unknown_tool", `No tool registered with name "${call.name}"`) }));
+	if (tool === void 0) return Stream.succeed(ToolEvent.Output({ result: failed(call, "unknown_tool", `No tool registered with name "${call.name}"`) }));
 	if (isStreamingTool(tool)) return runStreaming(tool, call);
 	return runPlain(tool, call);
 };
@@ -52,7 +34,7 @@ const runPlain = (tool, call) => Stream.fromEffect(Effect.gen(function* () {
 	});
 	if (validated.issues !== void 0) return executionError(call, "Tool input failed schema validation");
 	const output = yield* tool.run(validated.value);
-	return valueResult(call, tool.name, output);
+	return okResult(call, tool.name, output);
 }).pipe(Effect.catchCause(() => Effect.succeed(executionError(call, "Tool execution failed"))), Effect.map((result) => ToolEvent.Output({ result }))));
 const runStreaming = (tool, call) => Stream.unwrap(Effect.gen(function* () {
 	const parsed = yield* parseJsonUnknown(call.arguments).pipe(Effect.mapError(() => "json_parse_error"));
@@ -62,16 +44,62 @@ const runStreaming = (tool, call) => Stream.unwrap(Effect.gen(function* () {
 	});
 	if (validated.issues !== void 0) return Stream.succeed(ToolEvent.Output({ result: executionError(call, "Tool input failed schema validation") }));
 	const ref = yield* Ref.make([]);
-	const intermediates = tool.run(validated.value).pipe(Stream.tap((event) => Ref.update(ref, Array.append(event))), Stream.map((data) => ToolEvent.Intermediate({
+	const progress = tool.run(validated.value).pipe(Stream.tap((event) => Ref.update(ref, Array.append(event))), Stream.map((data) => ToolEvent.Progress({
 		call_id: call.call_id,
 		tool: tool.name,
 		data
 	})));
-	const output = Stream.fromEffect(Ref.get(ref).pipe(Effect.map((events) => ToolEvent.Output({ result: valueResult(call, tool.name, tool.finalize(events)) }))));
-	return intermediates.pipe(Stream.concat(output));
+	const output = Stream.fromEffect(Ref.get(ref).pipe(Effect.map((events) => ToolEvent.Output({ result: okResult(call, tool.name, tool.finalize(events)) }))));
+	return progress.pipe(Stream.concat(output));
 })).pipe(Stream.catchCause(() => Stream.succeed(ToolEvent.Output({ result: executionError(call, "Tool execution failed") }))));
-const continueWith = Function.dual(2, (stream, build) => nextAfterFold(stream, [], (acc, e) => isOutput(e) ? Array.append(acc, e.result) : acc, build));
+/**
+* Append a completed turn plus tool results to a state's history, converting
+* the results to wire-format `ToolCallOutput`s. Curried so it slots directly
+* into `continueWithResults`:
+*
+*   Toolkit.run(tools, calls).pipe(
+*     Toolkit.continueWithResults(Toolkit.appendToolResults(state, turn)),
+*   )
+*
+* Equivalent to `appendToHistory(state, turn, results.map(toToolCallOutput))`
+* — the helper just hides the wire-conversion step.
+*/
+const appendToolResults = (state, turn) => (results) => appendToHistory(state, turn, results.map(toToolCallOutput));
+/**
+* Drain a `Stream<ToolEvent>` and return the accumulated `ToolResult`s
+* from every `Output` event. One-shot — the type is `Effect<results>`,
+* not a one-element stream — so it composes naturally with `Effect.map`
+* to build state.
+*
+* Counterpart to `continueWithResults`: `continueWithResults` bundles
+* drain + emit Next into one bridge; this one is the right arm of a
+* broadcast/fork-and-merge for callers that want to vary the left arm
+* (e.g., filter/tap ToolEvents before forwarding).
+*/
+const collectResults = (stream) => stream.pipe(Stream.filter(isOutput), Stream.map((e) => e.result), Stream.runCollect);
+/**
+* Bridge from a `Stream<ToolEvent>` to the loop's emit shape. Forwards
+* every ToolEvent downstream as a `Loop.value` and at end-of-stream emits
+* one `Loop.next(build(results))` carrying the accumulated `ToolResult`s
+* from terminal `Output` events.
+*
+* Conceptually a broadcast fork (one arm passes events through, the other
+* drains them into a state). Implemented as a single-pass Ref tap + concat
+* for zero buffering — the broadcast version is observationally equivalent
+* but holds events in a PubSub until both arms drain. The public primitives
+* (`Loop.value`, `collectResults`, `Loop.next`) compose the same pattern
+* when you need to vary an arm.
+*
+* Dual: data-first `continueWithResults(stream, build)` and data-last
+* `stream.pipe(continueWithResults(build))` both work.
+*/
+const continueWithResults = Function.dual(2, (stream, build) => Stream.unwrap(Effect.gen(function* () {
+	const ref = yield* Ref.make([]);
+	const tapped = stream.pipe(Stream.tap((e) => isOutput(e) ? Ref.update(ref, (acc) => Array.append(acc, e.result)) : Effect.void), Stream.map(value));
+	const continuation = Stream.unwrap(Ref.get(ref).pipe(Effect.map((acc) => next(build(acc)))));
+	return tapped.pipe(Stream.concat(continuation));
+})));
 //#endregion
-export { continueWith, executeAll, make, Toolkit_exports as t, toDescriptors };
+export { appendToolResults, collectResults, continueWithResults, run, Toolkit_exports as t };
 
 //# sourceMappingURL=Toolkit.mjs.map