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

package/dist/tool/Toolkit.mjs

@@ -1,224 +1,289 @@
 import { n as __exportAll } from "../rolldown-runtime-EAsCxrDo.mjs";
-import { ToolResult, failed, nonLocalTool, toToolCallOutput, validationError } from "./ToolResult.mjs";
-import { ToolFailed, decodeCallInput, toDescriptors } from "./Tool.mjs";
-import { appendToHistory } from "../domain/Turn.mjs";
-import { next, value } from "../loop/Loop.mjs";
-import { ToolEvent, isOutput } from "./ToolEvent.mjs";
-import { Array, Cause, Data, Effect, Fiber, Function, Match, Option, Queue, Record, Ref, Stream } from "effect";
+import { ToolFailed, decodeCallInput, isStreamed, toDescriptors, toStream, withFailures as withFailures$1 } from "./Tool.mjs";
+import { appendToHistory, getToolCalls } from "../domain/Turn.mjs";
+import { next as next$1, value } from "../loop/Loop.mjs";
+import { Value } from "./Content.mjs";
+import { CoreError, InputInvalid, OutputInvalid, UnknownTool, encoded, failure, success, value as value$1 } from "./ToolOutput.mjs";
+import { Array, Cause, Data, Effect, Function, Match, Option, Predicate, Record, Ref, Result, Schema, Stream } from "effect";
 //#region src/tool/Toolkit.ts
 var Toolkit_exports = /* @__PURE__ */ __exportAll({
 	DuplicateToolName: () => DuplicateToolName,
-	appendToolResults: () => appendToolResults,
-	collectResults: () => collectResults,
+	UndeclaredFailure: () => UndeclaredFailure,
+	appendResults: () => appendResults,
+	close: () => close,
+	complete: () => complete,
 	compose: () => compose,
-	continueWithResults: () => continueWithResults,
+	continueWith: () => continueWith,
+	decode: () => decode,
 	describeFailures: () => describeFailures,
 	descriptors: () => descriptors,
 	fromArray: () => fromArray,
+	isOutcome: () => isOutcome,
 	make: () => make,
 	makeNamespaced: () => makeNamespaced,
 	namespace: () => namespace,
+	next: () => next,
+	output: () => output,
 	run: () => run,
+	split: () => split,
+	withFailures: () => withFailures,
 	wrap: () => wrap
 });
 const indexByName = (tools) => Object.fromEntries(tools.map((tool) => [tool.name, tool]));
-/**
-* Index literal tools by their `name`. Duplicate names are a compile error
-* (`UniqueTools`). Names are not otherwise checked: a malformed name is a
-* developer typo in a literal that the provider rejects clearly on first use,
-* and there is no single cross-provider name rule to enforce here anyway.
-*/
 const buildStatic = (tools) => indexByName(tools);
+/** Index tools by `name`. A repeated literal name is a compile error. */
 const make = (...tools) => buildStatic(tools);
-/**
-* Build a toolkit from a dynamically-sourced array (MCP server, plugin). Names
-* are not validated (MCP legitimately uses dots / >64 chars — sanitize at the
-* provider adapter); same-named tools resolve last-wins. Cross-source clashes
-* are caught by `compose`.
-*/
+/** A toolkit from a dynamic source (MCP server, plugin). Same-named tools: last wins. */
 const fromArray = (tools) => indexByName(tools);
-/** Render the provider-facing descriptors for a toolkit on demand. */
 const descriptors = (toolkit) => toDescriptors(Object.values(toolkit));
-/**
-* Two composed toolkits resolved to the same final name. Carries the colliding
-* `sources` (the positions of the clashing toolkits) so the error says *which*
-* inputs collided. Raised at runtime by `compose` for dynamic sources; static
-* collisions are caught earlier at compile time.
-*/
+/** Two composed toolkits share a final name; `sources` are their positions. */
 var DuplicateToolName = class extends Data.TaggedError("DuplicateToolName") {};
-/**
-* Prefix every tool name with `<namespace>__`, returning a new toolkit. Use it
-* to keep generic names (`search`) from two sources distinct before `compose`.
-* If two namespaces collide at the `__` separator, the duplicate final name
-* surfaces from `compose` as a `DuplicateToolName`.
-*/
-const namespace = (prefix, toolkit) => {
-	const renamed = Array.map(Record.values(toolkit), (tool) => ({
-		...tool,
-		name: `${prefix}__${tool.name}`
-	}));
-	return indexByName(renamed);
-};
-/** `namespace(prefix, make(...tools))` in one step, for static namespaced tools. */
+/** Prefix every tool name with `<namespace>__`, e.g. to keep two `search` tools apart. */
+const namespace = (prefix, toolkit) => indexByName(Array.map(Record.values(toolkit), (tool) => ({
+	...tool,
+	name: `${prefix}__${tool.name}`
+})));
+/** `namespace(prefix, make(...tools))` in one step. */
 const makeNamespaced = (prefix, ...tools) => namespace(prefix, buildStatic(tools));
 /**
-* Combine independently-built toolkits into one. This is where names from
-* separate sources can collide, so it is the one effectful constructor: a
-* duplicate final name fails with `DuplicateToolName` (naming the colliding
-* input positions) instead of silently overwriting or 400-ing later at the
-* provider. Statically-known collisions are additionally a compile error.
+* Join independently built toolkits. A duplicate final name fails with
+* `DuplicateToolName`; statically known duplicates are a compile error too.
 */
-const compose = (...toolkits) => Effect.gen(function* () {
+const compose = (...toolkits) => {
 	const kits = toolkits;
 	const labelled = Array.flatMap(kits, (kit, i) => Array.map(Record.keys(kit), (name) => ({
 		name,
 		source: `toolkit-${i}`
 	})));
-	const collision = Array.findFirst(Record.toEntries(Array.groupBy(labelled, (entry) => entry.name)), ([, group]) => group.length > 1);
-	if (Option.isSome(collision)) {
-		const [name, group] = collision.value;
-		return yield* new DuplicateToolName({
+	return Array.findFirst(Record.toEntries(Array.groupBy(labelled, (entry) => entry.name)), ([, group]) => group.length > 1).pipe(Option.match({
+		onNone: () => Effect.succeed(Array.reduce(kits, {}, (acc, kit) => ({
+			...acc,
+			...kit
+		}))),
+		onSome: ([name, group]) => Effect.fail(new DuplicateToolName({
 			name,
 			sources: Array.map(group, (e) => e.source)
-		});
-	}
-	return Array.reduce(kits, {}, (acc, kit) => ({
-		...acc,
-		...kit
+		}))
 	}));
-});
+};
+const mapLocal = (toolkit, f) => Record.map(toolkit, (tool) => tool._tag === "LocalTool" ? f(tool) : tool);
 /**
-* Wrap every local tool's `run` with a middleware, preserving each tool's
-* `Input`/`Output` and unioning the middleware's requirement `R2` into the
-* toolkit's `ToolkitR`. Non-local kinds pass through unchanged. Stack with
-* `pipe` - inner-first, so the last `wrap` applied is the outermost and runs
-* first:
+* Wrap every local tool's `run`. Stacks with `pipe`, inner first: the last
+* `wrap` runs first. The middleware sees a stream; an `Effect` tool stays one,
+* with the stream's last value.
 *
 *   const observed = pipe(toolkit, Toolkit.wrap(logging), Toolkit.wrap(authz))
-*   Toolkit.run(observed, calls) // authz runs, then logging, then the tool
-*
-* A middleware that fails with `string` / `ToolFailed` is absorbed by the
-* executor into a `ToolResult.Failure`; any other error propagates typed. Use
-* `describeFailures` for the total "everything to the model" case, or the
-* `Approval` flow for a distinct "denied" verdict.
 */
-const wrap = Function.dual(2, (toolkit, middleware) => Record.map(toolkit, (tool) => tool._tag === "LocalTool" ? {
-	...tool,
-	run: middleware(tool.run, tool.name)
-} : tool));
+const wrap = Function.dual(2, (toolkit, middleware) => mapLocal(toolkit, (tool) => {
+	const wrapped = middleware((input) => toStream(tool.run(input)), tool.name);
+	return {
+		...tool,
+		run: (input) => isStreamed(tool.run(input)) ? wrapped(input) : lastOf(tool.name, wrapped(input))
+	};
+}));
+const lastOf = (name, values) => Effect.flatMap(Stream.runLast(values), Option.match({
+	onSome: Effect.succeed,
+	onNone: () => Effect.die(`A middleware left the Effect tool "${name}" without a value`)
+}));
 /**
-* Map every local tool's error to a `string`, so `Toolkit.run` absorbs those
-* failures into `ToolResult.Failure` the model reads and adapts to. Pairs
-* with the domain `describe` helpers (`AiError.describe`,
-* `BrowserError.describe`). Non-local kinds pass through.
-*
-*   const kit = yield* Toolkit.compose(
-*     Toolkit.describeFailures(searchKit, AiError.describe),
-*     browserToolkit(session), // failures stay typed
-*   )
+* `Tool.withFailures` for every local tool, e.g. a whole MCP toolkit that needs
+* approval. Prefer it per tool when only some tools are gated.
 */
-const describeFailures = Function.dual(2, (toolkit, describe) => Record.map(toolkit, (tool) => tool._tag === "LocalTool" ? {
-	...tool,
-	run: (input, emit) => tool.run(input, emit).pipe(Effect.mapError(describe))
-} : tool));
+const withFailures = Function.dual(2, (toolkit, failures) => mapLocal(toolkit, (tool) => withFailures$1(tool, failures)));
 /**
-* Execute every provided call. Approval/rejection policy belongs upstream.
-*
-* String and `ToolFailed` failures are absorbed into `ToolResult.Failure`
-* (the model reads and adapts to them); every other tool error propagates
-* typed on the stream, so `Exclude<ToolkitE<T>, string | ToolFailed>` is
-* what a caller catches or lets end the run. If one call in a concurrent
-* batch fails the stream, siblings may go unanswered: a loop that catches
-* and continues must reconcile history first (`HistoryCheck.cancelAllPending`).
+* Undeclared errors become a `ToolFailed` the model reads, e.g. with
+* `AiError.describe`. Declared failures pass through unchanged. Return
+* `undefined` for an error that should still fail the run (a dead session).
+*/
+const describeFailures = Function.dual(2, (toolkit, describe) => mapLocal(toolkit, (tool) => {
+	const isDeclared = isDeclaredBy(tool);
+	const toFailed = (e) => isDeclared(e) ? e : Option.match(Option.fromNullishOr(describe(e)), {
+		onNone: () => e,
+		onSome: (message) => new ToolFailed({ message })
+	});
+	return {
+		...tool,
+		failureSchema: tool.failureSchema === void 0 ? ToolFailed : Schema.Union([tool.failureSchema, ToolFailed]),
+		run: (input) => {
+			const out = tool.run(input);
+			return isStreamed(out) ? Stream.mapError(out, toFailed) : Effect.mapError(out, toFailed);
+		}
+	};
+}));
+/**
+* Run the calls, emitting each one's partials and its `Output`, typed per tool
+* and decoded. An error matching the tool's `failureSchema` becomes a `Failure`;
+* any other error fails the stream (siblings of a failed batch may then stay
+* unanswered: see `HistoryCheck.cancelAllPending`). Which calls run is the caller's call.
 */
 const run = (toolkit, calls, options) => Stream.fromIterable(calls).pipe(Stream.flatMap((call) => runOne(toolkit, call), { concurrency: options?.concurrency ?? "unbounded" }));
-const okResult = (call, tool, value) => ToolResult.Ok({
+const lookup = (toolkit, name) => Object.hasOwn(toolkit, name) ? toolkit[name] : void 0;
+const local = (toolkit, name) => {
+	const tool = lookup(toolkit, name);
+	return tool === void 0 || tool._tag === "ProviderTool" ? void 0 : tool;
+};
+const done = (call, result) => ({
+	_tag: "Output",
 	call_id: call.call_id,
-	tool,
-	value
+	tool: call.name,
+	result
 });
-const outputEvent = (result) => Stream.succeed(ToolEvent.Output({ result }));
-const runOne = (toolkit, call) => {
-	const tool = Object.hasOwn(toolkit, call.name) ? toolkit[call.name] : void 0;
-	return Match.value(tool).pipe(Match.when(Match.undefined, () => outputEvent(failed(call, "unknown_tool", `No tool registered with name "${call.name}"`))), Match.tag("LocalTool", (local) => runTool(local, call)), Match.orElse(() => outputEvent(nonLocalTool(call))));
-};
+const failWith = (call, error) => Stream.succeed(done(call, Result.fail(error)));
+const runOne = (toolkit, call) => Match.value(lookup(toolkit, call.name)).pipe(Match.when(Match.undefined, () => failWith(call, new UnknownTool({ message: `No tool named "${call.name}"` }))), Match.discriminatorsExhaustive("_tag")({
+	LocalTool: (tool) => runTool(tool, call),
+	DeclaredTool: () => failWith(call, new UnknownTool({ message: `"${call.name}" has no run; the app handles its calls` })),
+	ProviderTool: () => failWith(call, new UnknownTool({ message: `"${call.name}" is run by the provider` }))
+}));
 const describeIssues = (issues) => issues.map((issue) => {
 	const path = (issue.path ?? []).map((seg) => typeof seg === "object" && seg !== null ? String(seg.key) : String(seg)).join(".");
 	return path === "" ? issue.message : `${path}: ${issue.message}`;
 }).join("; ").slice(0, 500);
-const runTool = (tool, call) => Stream.unwrap(decodeCallInput(tool, call).pipe(Effect.map(Match.type().pipe(Match.tag("parseError", () => outputEvent(validationError(call, "arguments are not valid JSON"))), Match.tag("invalid", ({ issues }) => outputEvent(validationError(call, describeIssues(issues)))), Match.tag("ok", ({ input }) => runValidated(tool, call, input)), Match.exhaustive))));
-const runValidated = (tool, call, input) => Stream.unwrap(Effect.gen(function* () {
-	const queue = yield* Queue.make({ capacity: tool.emitBufferSize });
-	const emit = (event) => Effect.asVoid(Queue.offer(queue, event));
-	const fiber = yield* tool.run(input, emit).pipe(Effect.ensuring(Queue.end(queue)), Effect.forkScoped);
-	const progress = Stream.fromQueue(queue).pipe(Stream.map((data) => ToolEvent.Progress({
+const decodeInput = (tool, call) => Effect.map(decodeCallInput(tool, call), Match.type().pipe(Match.tag("parseError", () => Result.fail(new InputInvalid({ message: "arguments are not valid JSON" }))), Match.tag("invalid", ({ issues }) => Result.fail(new InputInvalid({ message: describeIssues(issues) }))), Match.tag("ok", ({ input }) => Result.succeed(input)), Match.exhaustive));
+const runTool = (tool, call) => Stream.unwrap(Effect.map(decodeInput(tool, call), Result.match({
+	onFailure: (error) => failWith(call, error),
+	onSuccess: (input) => execute(tool, call, input)
+})));
+const execute = (tool, call, input) => {
+	const out = tool.run(input);
+	const events = isStreamed(out) ? streamed(tool, call, out) : Stream.fromEffect(Effect.map(Effect.tap(out, (value) => check(tool, value)), (value) => done(call, Result.succeed(value))));
+	return Stream.catchCause(events, (cause) => Stream.fromEffect(Effect.map(declared(tool, cause), (error) => done(call, Result.fail(error)))));
+};
+const streamed = (tool, call, values) => values.pipe(Stream.mapEffect((value) => Effect.as(check(tool, value), Option.some(value))), Stream.concat(Stream.succeed(Option.none())), Stream.mapAccum(() => Option.none(), (last, next) => Option.match(next, {
+	onSome: (value) => [Option.some(value), [{
+		_tag: "Partial",
 		call_id: call.call_id,
 		tool: tool.name,
-		data
-	})));
-	const output = Stream.fromEffect(Fiber.join(fiber).pipe(Effect.matchCauseEffect({
-		onSuccess: (value) => Effect.succeed(ToolEvent.Output({ result: okResult(call, tool.name, value) })),
-		onFailure: (cause) => routeCause(call, cause)
-	})));
-	return progress.pipe(Stream.concat(output));
+		value
+	}]],
+	onNone: () => [last, [done(call, Option.match(last, {
+		onNone: () => Result.fail(new OutputInvalid({ message: "The tool produced no value" })),
+		onSome: Result.succeed
+	}))]]
+})));
+var EncodeFailed = class extends Data.TaggedError("EncodeFailed") {};
+const check = (tool, value) => tool.outputSchema === void 0 ? Effect.void : Schema.encodeUnknownEffect(tool.outputSchema)(value).pipe(Effect.mapError((e) => new EncodeFailed({ message: e.message.slice(0, 500) })));
+const isDeclaredBy = (tool) => tool.failureSchema === void 0 ? () => false : Schema.is(tool.failureSchema);
+const soleError = (cause) => Option.fromNullishOr(cause.reasons.length === 1 ? cause.reasons[0] : void 0).pipe(Option.filter(Cause.isFailReason), Option.map((reason) => reason.error));
+const declared = (tool, cause) => soleError(cause).pipe(Option.flatMap((error) => Match.value(error).pipe(Match.when(Match.instanceOf(EncodeFailed), (e) => Option.some(new OutputInvalid({ message: e.message }))), Match.when(isDeclaredBy(tool), Option.some), Match.orElse(() => Option.none()))), Option.match({
+	onNone: () => Effect.failCause(cause),
+	onSome: Effect.succeed
 }));
-const routeCause = (call, cause) => {
-	const only = cause.reasons.length === 1 ? cause.reasons[0] : void 0;
-	if (only !== void 0 && Cause.isFailReason(only)) {
-		const error = only.error;
-		if (typeof error === "string") return Effect.succeed(ToolEvent.Output({ result: failed(call, "tool_failed", error) }));
-		if (error instanceof ToolFailed) return Effect.succeed(ToolEvent.Output({ result: failed(call, error.kind ?? "tool_failed", error.message) }));
-	}
-	return Effect.failCause(cause);
-};
+const outputs = (tool) => tool?.outputSchema ?? Value;
+const failures = (tool) => tool?.failureSchema === void 0 ? CoreError : Schema.Union([tool.failureSchema, CoreError]);
+/** `Toolkit.close` got an error the call's tool doesn't declare: a bug in the app. */
+var UndeclaredFailure = class extends Data.TaggedError("UndeclaredFailure") {};
+const describeError = (error) => Predicate.hasProperty(error, "_tag") && Predicate.isString(error._tag) ? error._tag : String(error);
+function close(toolkit, ...args) {
+	const [name, call, error] = args.length === 3 ? args : [args[0].name, ...args];
+	return Match.value({
+		name,
+		call,
+		error
+	}).pipe(Match.when(({ call }) => call.name !== name, () => Effect.fail(new UndeclaredFailure({
+		tool: name,
+		message: `the call is for "${call.name}", not "${name}"`
+	}))), Match.when(({ error }) => !Schema.is(failures(local(toolkit, name)))(error), () => Effect.fail(new UndeclaredFailure({
+		tool: name,
+		message: `"${name}" does not declare ${describeError(error)} in its failureSchema`
+	}))), Match.orElse(() => Effect.succeed({
+		_tag: "Output",
+		call_id: call.call_id,
+		tool: name,
+		result: Result.fail(error)
+	})));
+}
 /**
-* Append a completed turn plus tool results to a state's history, converting
-* the results to wire-format `ToolCallOutput`s. Curried so it slots directly
-* into `continueWithResults`:
-*
-*   Toolkit.run(toolkit, calls).pipe(
-*     Toolkit.continueWithResults(Toolkit.appendToolResults(state, turn)),
-*   )
-*
-* Equivalent to `appendToHistory(state, turn, results.map(toToolCallOutput))`
-* — the helper just hides the wire-conversion step.
+* A call the app answers itself (`ask_user`, a signal's acknowledgement), as
+* the outcome `run` would emit: `close`'s success side. `value` is typed by the
+* tool's `outputSchema`; a value it rejects ends the call with `OutputInvalid`,
+* as from `run`. Fails with `UndeclaredFailure` if `call` is for another tool.
 */
-const appendToolResults = (state, turn) => (results) => appendToHistory(state, turn, results.map(toToolCallOutput));
+const complete = (toolkit, name, call, value) => Option.match(Option.fromNullishOr(call.name === name ? local(toolkit, name) : void 0), {
+	onNone: () => Effect.fail(new UndeclaredFailure({
+		tool: name,
+		message: call.name === name ? `"${name}" is not a tool of this toolkit` : `the call is for "${call.name}", not "${name}"`
+	})),
+	onSome: (tool) => check(tool, value).pipe(Effect.match({
+		onFailure: (e) => Result.fail(new OutputInvalid({ message: e.message })),
+		onSuccess: () => Result.succeed(value)
+	}), Effect.map((result) => ({
+		_tag: "Output",
+		call_id: call.call_id,
+		tool: name,
+		result
+	})))
+});
+const sortCall = (toolkit, call) => {
+	const tool = lookup(toolkit, call.name);
+	return tool?._tag === "DeclaredTool" ? Effect.map(decodeInput(tool, call), Result.match({
+		onFailure: (error) => ({
+			_tag: "invalid",
+			output: {
+				_tag: "Output",
+				call_id: call.call_id,
+				tool: call.name,
+				result: Result.fail(error)
+			}
+		}),
+		onSuccess: (input) => ({
+			_tag: "declared",
+			declared: {
+				tool: call.name,
+				call,
+				input
+			}
+		})
+	})) : Effect.succeed({
+		_tag: "run",
+		call
+	});
+};
 /**
-* 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.
+* The turn's tool calls, sorted: `run` for `Toolkit.run`, and the calls to
+* declared tools decoded and typed per tool. Handling `declared` with
+* `Match.discriminatorsExhaustive("tool")` makes a new declared tool a compile
+* error until the loop handles it:
 *
-* 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 { run, declared, invalid } = yield* Toolkit.split(toolkit, turn)
+*   declared.map(Match.discriminatorsExhaustive("tool")({ ask_user: ..., escalate: ... }))
 */
-const collectResults = (stream) => stream.pipe(Stream.filter(isOutput), Stream.map((e) => e.result), Stream.runCollect);
+const split = (toolkit, turn) => Effect.map(Effect.forEach(getToolCalls(turn), (call) => sortCall(toolkit, call)), (sorted) => ({
+	run: sorted.flatMap((s) => s._tag === "run" ? [s.call] : []),
+	declared: sorted.flatMap((s) => s._tag === "declared" ? [s.declared] : []),
+	invalid: sorted.flatMap((s) => s._tag === "invalid" ? [s.output] : [])
+}));
+/** Narrows to the `Output` members (also in a loop's mixed stream), keeping the per-tool types. */
+const isOutcome = (e) => e._tag === "Output";
+const toOutput = (toolkit, event) => {
+	const tool = local(toolkit, event.tool);
+	return Result.match(event.result, {
+		onSuccess: (value) => success(event, outputs(tool), value),
+		onFailure: (error) => failure(event, failures(tool), error)
+	});
+};
+function output(toolkit, event) {
+	return event === void 0 ? (e) => toOutput(toolkit, e) : toOutput(toolkit, event);
+}
+function decode(toolkit, name, item) {
+	const tool = local(toolkit, name);
+	const decodeWith = (schema) => Effect.flatMap(encoded(item.output), Schema.decodeUnknownEffect(schema));
+	return Match.value(item).pipe(Match.when({ isError: true }, () => Effect.map(decodeWith(failures(tool)), Result.fail)), Match.orElse(() => Option.match(Option.fromNullishOr(tool?.outputSchema), {
+		onNone: () => Effect.succeed(Result.succeed(value$1(item.output))),
+		onSome: (schema) => Effect.map(decodeWith(schema), Result.succeed)
+	})));
+}
+const isOutcomeOf = (e) => e._tag === "Output";
 /**
-* 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.
+* Forward every event as a `Loop.value`, then continue the loop with
+* `build(outcomes)`. `build` is an Effect, so it can encode. The stream may
+* carry the app's own tagged events too (any tag but `Output`).
 */
-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));
-})));
+const continueWith = Function.dual(2, (stream, build) => Stream.unwrap(Effect.map(Ref.make([]), (outcomes) => Stream.concat(stream.pipe(Stream.tap((e) => isOutcomeOf(e) ? Ref.update(outcomes, Array.append(e)) : Effect.void), Stream.map(value)), Stream.unwrap(Ref.get(outcomes).pipe(Effect.flatMap(build), Effect.map(next$1)))))));
+/** Encode each outcome with `output` and append the turn plus the outputs to history. */
+const appendResults = (toolkit, state, turn) => (outcomes) => Effect.map(Effect.forEach(outcomes, output(toolkit)), (items) => appendToHistory(state, turn, items));
+/** `continueWith(appendResults(toolkit, state, turn))`. */
+const next = (toolkit, state, turn) => continueWith(appendResults(toolkit, state, turn));
 //#endregion
-export { DuplicateToolName, appendToolResults, collectResults, compose, continueWithResults, describeFailures, descriptors, fromArray, make, makeNamespaced, namespace, run, Toolkit_exports as t, wrap };
+export { DuplicateToolName, UndeclaredFailure, appendResults, close, complete, compose, continueWith, decode, describeFailures, descriptors, fromArray, isOutcome, make, makeNamespaced, namespace, next, output, run, split, Toolkit_exports as t, withFailures, wrap };
 
 //# sourceMappingURL=Toolkit.mjs.map