@fungi.computer/mule 0.0.0-stage → 0.0.1

package/dist/effect.js

@@ -0,0 +1,762 @@
+import { nanoid } from "@fungi.computer/cairn";
+import { isContextOverflow as piIsContextOverflow, normalizeContext, retryAssistantCall, } from "@earendil-works/pi-ai";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Cause from "effect/Cause";
+import * as Result from "effect/Result";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import * as Option from "effect/Option";
+import * as Semaphore from "effect/Semaphore";
+import * as Stream from "effect/Stream";
+export { Type } from "@earendil-works/pi-ai";
+/**
+ * Pi coding-agent's retry defaults (`settings-manager.js` `getRetrySettings()`,
+ * `@earendil-works/pi-ai` 0.99.0, the version pinned in the lockfile). Pi-ai's
+ * own `RetryPolicy` has no default — an undefined policy means no retry — so
+ * a host that wants Pi coding-agent's numbers passes this explicitly.
+ */
+export const piCodingAgentRetryDefaults = {
+    enabled: true,
+    maxRetries: 3,
+    baseDelayMs: 2000,
+    maxAgentDelayMs: 60_000,
+};
+/**
+ * Pi coding-agent's default stream idle timeout (`DEFAULT_HTTP_IDLE_TIMEOUT_MS`,
+ * `settings-manager.js`). A host that wants Pi's number for
+ * `modelStreamIdleTimeoutMs` passes this explicitly.
+ */
+export const piHttpIdleTimeoutMs = 300_000;
+/**
+ * Grace period a release waits for a provider iterator that ignores abort,
+ * so a timed-out run's scope close never hangs. This is a Mule transport
+ * detail with no Pi equivalent, so it stays a constant, not host config.
+ */
+const providerIteratorReleaseGraceMs = 1_000;
+/** Apply Pi's maintained context-overflow semantics to an exact Pi message. */
+export function isContextOverflow(message, contextWindow) {
+    return piIsContextOverflow(message, contextWindow);
+}
+const failure = (phase, message, cause) => ({ _tag: "MuleError", phase, message, cause });
+const muleErrorSchema = Schema.Struct({
+    _tag: Schema.Literal("MuleError"),
+    phase: Schema.Literals(["model", "tool", "control", "listener"]),
+    message: Schema.String,
+    cause: Schema.optionalKey(Schema.Unknown),
+});
+const isMuleError = (value) => Schema.is(muleErrorSchema)(value);
+const identity = (kind, parent) => ({ kind, value: `mule_${kind}_${nanoid()}`, parent });
+const noListener = () => Effect.void;
+function resultMessage(call, result) {
+    const message = {
+        role: "toolResult",
+        toolCallId: call.id,
+        toolName: call.name,
+        content: result.content,
+        isError: result.isError,
+        timestamp: Date.now(),
+    };
+    if (result.details !== undefined)
+        message.details = result.details;
+    if (result.usage !== undefined)
+        message.usage = result.usage;
+    return message;
+}
+const errorResult = (message, terminate) => ({
+    content: [{ type: "text", text: message }],
+    isError: true,
+    terminate,
+});
+function selectedTool(tools, call) {
+    return tools.find((tool) => tool.descriptor.name === call.name);
+}
+function emitToolEnd(finalized, run, turn, emit) {
+    return emit({
+        type: "tool_execution_end",
+        run,
+        turn,
+        toolCall: finalized.identity,
+        call: finalized.call,
+        result: finalized.result,
+    });
+}
+function prepareTool(tool, call, run, turn, emit) {
+    const toolCall = identity("tool_call", turn);
+    return Effect.gen(function* () {
+        yield* emit({
+            type: "tool_execution_start",
+            replay: tool?.replay ?? "unsafe",
+            run,
+            turn,
+            toolCall,
+            call,
+        });
+        if (tool === undefined) {
+            const result = errorResult(`Tool "${call.name}" not found`);
+            const finalized = { call, identity: toolCall, result };
+            yield* emitToolEnd(finalized, run, turn, emit);
+            return { kind: "finalized", value: finalized };
+        }
+        const preparation = yield* Effect.result(tool.prepare(call));
+        if (Result.isFailure(preparation)) {
+            const result = errorResult(preparation.failure.message, preparation.failure.terminate);
+            const finalized = { call, identity: toolCall, result };
+            yield* emitToolEnd(finalized, run, turn, emit);
+            return { kind: "finalized", value: finalized };
+        }
+        return {
+            kind: "prepared",
+            call,
+            identity: toolCall,
+            tool: preparation.success,
+        };
+    });
+}
+function executePreparedTool(prepared, run, turn, emit) {
+    return Effect.gen(function* () {
+        let terminal;
+        let toolFailure;
+        // Only the tool stream's own failure becomes a model-visible error result.
+        // A listener failure while reporting progress fails the run.
+        yield* Stream.runForEach(Stream.result(prepared.tool.execute()), (part) => {
+            if (Result.isFailure(part)) {
+                toolFailure = part.failure;
+                return Effect.void;
+            }
+            if (terminal !== undefined)
+                return Effect.void;
+            if (part.success.type === "result") {
+                terminal = part.success.result;
+                return Effect.void;
+            }
+            return emit({
+                type: "tool_execution_update",
+                run,
+                turn,
+                toolCall: prepared.identity,
+                call: prepared.call,
+                result: part.success.result,
+            });
+        });
+        const result = toolFailure !== undefined
+            ? errorResult(toolFailure.message)
+            : (terminal ??
+                errorResult(`Tool "${prepared.call.name}" returned no result`));
+        const finalized = {
+            call: prepared.call,
+            identity: prepared.identity,
+            result,
+        };
+        yield* emitToolEnd(finalized, run, turn, emit);
+        return finalized;
+    });
+}
+function emitToolResult(executed, run, turn, emit) {
+    const message = resultMessage(executed.call, executed.result);
+    const messageIdentity = identity("tool_result", executed.identity);
+    return Effect.gen(function* () {
+        yield* emit({
+            type: "message_start",
+            run,
+            turn,
+            message: messageIdentity,
+            value: message,
+        });
+        yield* emit({
+            type: "message_end",
+            run,
+            turn,
+            message: messageIdentity,
+            value: message,
+        });
+        return message;
+    });
+}
+function executeToolBatch(calls, input, run, turn, emit) {
+    const tools = input.tools ?? [];
+    const sequential = input.toolExecution === "sequential" ||
+        calls.some((call) => selectedTool(tools, call)?.executionMode === "sequential");
+    return Effect.gen(function* () {
+        const executeEntry = (entry) => entry.kind === "finalized"
+            ? Effect.succeed(entry.value)
+            : executePreparedTool(entry, run, turn, emit);
+        const finalized = sequential
+            ? yield* Effect.forEach(calls, (call) => Effect.flatMap(prepareTool(selectedTool(tools, call), call, run, turn, emit), executeEntry))
+            : yield* Effect.gen(function* () {
+                const entries = yield* Effect.forEach(calls, (call) => prepareTool(selectedTool(tools, call), call, run, turn, emit));
+                return yield* Effect.all(entries.map(executeEntry), {
+                    concurrency: "unbounded",
+                });
+            });
+        const messages = yield* Effect.forEach(finalized, (result) => emitToolResult(result, run, turn, emit));
+        return {
+            messages,
+            terminate: finalized.length > 0 &&
+                finalized.every((result) => result.result.terminate === true),
+        };
+    });
+}
+const truncatedToolResult = (call) => errorResult(`Tool call "${call.name}" was not executed: the response hit the output token limit, so its arguments may be truncated. Re-issue the tool call with complete arguments.`);
+function failTruncatedToolCalls(calls, run, turn, emit) {
+    return Effect.gen(function* () {
+        const finalized = yield* Effect.forEach(calls, (call) => Effect.gen(function* () {
+            const toolCall = identity("tool_call", turn);
+            const result = truncatedToolResult(call);
+            const value = { call, identity: toolCall, result };
+            yield* emit({
+                type: "tool_execution_start",
+                replay: "unsafe",
+                run,
+                turn,
+                toolCall,
+                call,
+            });
+            yield* emitToolEnd(value, run, turn, emit);
+            return value;
+        }));
+        return yield* Effect.forEach(finalized, (result) => emitToolResult(result, run, turn, emit));
+    });
+}
+function pullPiEvent(iterator, controller) {
+    return Effect.tryPromise({
+        try: (signal) => {
+            const abort = () => {
+                controller.abort(signal.reason);
+            };
+            if (signal.aborted)
+                abort();
+            else
+                signal.addEventListener("abort", abort, { once: true });
+            return Promise.resolve(iterator.next()).finally(() => {
+                signal.removeEventListener("abort", abort);
+            });
+        },
+        catch: (cause) => failure("model", "Pi model stream failed", cause),
+    });
+}
+function withModelStreamDeadline(effect, timeoutMs) {
+    if (timeoutMs === undefined)
+        return effect;
+    return effect.pipe(Effect.timeoutOrElse({
+        duration: timeoutMs,
+        orElse: () => Effect.fail(failure("model", `Model stream was idle for ${String(timeoutMs)} ms; the provider connection stopped responding. Retry the run.`)),
+    }));
+}
+function streamTurn(input, context, run, turn, emit, attempt) {
+    const messageIdentity = identity("message", turn);
+    return Effect.scoped(Effect.gen(function* () {
+        const controller = new AbortController();
+        yield* Effect.addFinalizer(() => Effect.sync(() => {
+            controller.abort("Mule model scope closed");
+        }));
+        const resolvedApiKey = (input.resolveApiKey === undefined
+            ? undefined
+            : yield* input.resolveApiKey(input.model.provider)) ??
+            input.streamOptions?.apiKey;
+        const options = {
+            ...input.streamOptions,
+            signal: controller.signal,
+        };
+        if (resolvedApiKey !== undefined)
+            options.apiKey = resolvedApiKey;
+        const systemPrompt = input.prepareSystemPrompt === undefined
+            ? input.systemPrompt
+            : yield* input.prepareSystemPrompt();
+        if (input.prepareSystemPrompt !== undefined)
+            yield* emit({ type: "model_prompt", run, turn, attempt, systemPrompt });
+        const piContext = {
+            systemPrompt,
+            messages: context,
+        };
+        const descriptors = (input.tools ?? []).map((tool) => tool.descriptor);
+        if (descriptors.length > 0)
+            piContext.tools = descriptors;
+        const response = yield* withModelStreamDeadline(Effect.tryPromise({
+            try: async () => {
+                const stream = input.stream ??
+                    (await import("@earendil-works/pi-ai/compat")).streamSimple;
+                return stream(input.model, normalizeContext(piContext), options);
+            },
+            catch: (cause) => failure("model", "Pi model stream could not start", cause),
+        }), input.modelStreamIdleTimeoutMs);
+        const streamState = {
+            started: false,
+            terminal: undefined,
+        };
+        const iterator = yield* Effect.acquireRelease(Effect.sync(() => response[Symbol.asyncIterator]()), (active) => Effect.tryPromise({
+            try: () => {
+                controller.abort("Mule model stream closed");
+                // Provider iterators can ignore abort while a read is pending.
+                // Releasing a timed-out run must not await that iterator forever.
+                return new Promise((resolve) => {
+                    const timer = setTimeout(resolve, providerIteratorReleaseGraceMs);
+                    Promise.resolve(active.return?.()).then(() => {
+                        clearTimeout(timer);
+                        resolve();
+                    }, () => {
+                        clearTimeout(timer);
+                        resolve();
+                    });
+                });
+            },
+            catch: (cause) => failure("model", "Pi model stream failed", cause),
+        }).pipe(Effect.ignore));
+        const observeEvent = (event) => {
+            switch (event.type) {
+                case "start": {
+                    context.push(event.partial);
+                    streamState.started = true;
+                    return emit({
+                        type: "message_start",
+                        run,
+                        turn,
+                        message: messageIdentity,
+                        value: event.partial,
+                    });
+                }
+                case "text_start":
+                case "text_delta":
+                case "text_end":
+                case "thinking_start":
+                case "thinking_delta":
+                case "thinking_end":
+                case "toolcall_start":
+                case "toolcall_delta":
+                case "toolcall_end": {
+                    if (streamState.started)
+                        context[context.length - 1] = event.partial;
+                    return emit({
+                        type: "message_update",
+                        run,
+                        turn,
+                        message: messageIdentity,
+                        value: event.partial,
+                        event,
+                    });
+                }
+                case "done": {
+                    streamState.terminal = event.message;
+                    return Effect.void;
+                }
+                case "error": {
+                    streamState.terminal = event.error;
+                    return Effect.void;
+                }
+            }
+        };
+        const pull = () => withModelStreamDeadline(pullPiEvent(iterator, controller), input.modelStreamIdleTimeoutMs);
+        let next = yield* pull();
+        while (!next.done) {
+            yield* observeEvent(next.value);
+            next = yield* pull();
+        }
+        const completed = streamState.terminal ??
+            (yield* withModelStreamDeadline(Effect.tryPromise({
+                try: () => response.result(),
+                catch: (cause) => failure("model", "Pi model stream did not settle", cause),
+            }), input.modelStreamIdleTimeoutMs));
+        if (streamState.started)
+            context[context.length - 1] = completed;
+        else {
+            context.push(completed);
+            yield* emit({
+                type: "message_start",
+                run,
+                turn,
+                message: messageIdentity,
+                value: completed,
+            });
+        }
+        yield* emit({
+            type: "message_end",
+            run,
+            turn,
+            message: messageIdentity,
+            value: completed,
+        });
+        return { identity: messageIdentity, message: completed };
+    }));
+}
+/**
+ * Run one assistant call with Pi's bounded retry (`retryAssistantCall`)
+ * around it. `input.retry` undefined or disabled means `retryAssistantCall`
+ * calls `streamTurn` exactly once and returns its result unchanged.
+ *
+ * Each attempt streams and is recorded exactly like any other turn (so a
+ * failed attempt stays in the retained event log for inspection), but a
+ * failed attempt's message is removed from `context` before the next
+ * attempt runs, so it is never replayed into the model's next call.
+ */
+function streamTurnWithRetry(input, context, run, turn, emit) {
+    return Effect.gen(function* () {
+        const services = yield* Effect.context();
+        const runFork = Effect.runForkWith(services);
+        const runPromise = Effect.runPromiseWith(services);
+        let latest;
+        let attempt = 0;
+        let retrySignal;
+        const reportRetry = (event) => input.onRetry === undefined
+            ? undefined
+            : runPromise(input.onRetry(event));
+        const callbacks = {
+            onRetryScheduled: async (attempt, maxAttempts, delayMs, errorMessage) => {
+                // Pi owns the only retry loop and its exponential schedule. A clean
+                // gateway 429 can request a longer delay; extend that same scheduled
+                // sleep (capped), never dispatch a second transport-level retry.
+                const after = latest === undefined
+                    ? undefined
+                    : input.retryAfterMs?.(latest.message);
+                const extra = after !== undefined &&
+                    Number.isSafeInteger(after) &&
+                    after >= 0 &&
+                    after <= 60_000
+                    ? Math.max(0, after - delayMs)
+                    : 0;
+                await reportRetry({
+                    type: "retry_scheduled",
+                    run,
+                    turn,
+                    attempt,
+                    maxAttempts,
+                    delayMs: delayMs + extra,
+                    errorMessage,
+                });
+                if (extra > 0)
+                    await new Promise((resolve) => {
+                        const timer = setTimeout(() => {
+                            retrySignal?.removeEventListener("abort", abort);
+                            resolve();
+                        }, extra);
+                        const abort = () => {
+                            clearTimeout(timer);
+                            resolve();
+                        };
+                        retrySignal?.addEventListener("abort", abort, { once: true });
+                        if (retrySignal?.aborted)
+                            abort();
+                    });
+            },
+            onRetryAttemptStart: () => reportRetry({ type: "retry_attempt_started", run, turn, attempt }),
+            onRetryFinished: (success, attempt, finalError) => reportRetry(finalError === undefined
+                ? { type: "retry_finished", run, turn, attempt, success }
+                : {
+                    type: "retry_finished",
+                    run,
+                    turn,
+                    attempt,
+                    success,
+                    finalError,
+                }),
+        };
+        const result = yield* Effect.tryPromise({
+            try: (signal) => {
+                retrySignal = signal;
+                // `retryAssistantCall` only threads `signal` through its own
+                // backoff sleep, never into an in-flight `produce`. Fork `streamTurn`
+                // as its own fiber and interrupt it on `signal` so a cancellation
+                // reaches an active call too, exactly like interrupting this fiber
+                // reached `streamTurn` before retry wrapped it.
+                const produce = async () => {
+                    if (latest !== undefined) {
+                        const index = context.indexOf(latest.message);
+                        if (index !== -1)
+                            context.splice(index, 1);
+                    }
+                    const fiber = runFork(streamTurn(input, context, run, turn, emit, ++attempt));
+                    const interrupt = () => {
+                        runFork(Fiber.interrupt(fiber));
+                    };
+                    if (signal.aborted)
+                        interrupt();
+                    else
+                        signal.addEventListener("abort", interrupt, { once: true });
+                    const exit = await runPromise(Fiber.await(fiber));
+                    signal.removeEventListener("abort", interrupt);
+                    // `streamTurn`'s own Effect failures (a transport exception, a
+                    // listener failure, or this fiber's own interruption) are not
+                    // Pi-protocol error messages for `retryAssistantCall` to classify:
+                    // unwrap and rethrow the original so the surrounding
+                    // `Effect.tryPromise` reports it unchanged, not behind a new
+                    // "Pi retry loop failed" layer.
+                    if (Exit.isFailure(exit)) {
+                        const error = Cause.findErrorOption(exit.cause);
+                        throw Option.isSome(error) ? error.value : Cause.squash(exit.cause);
+                    }
+                    latest = exit.value;
+                    return latest.message;
+                };
+                return retryAssistantCall(produce, input.retry, signal, callbacks);
+            },
+            catch: (cause) => isMuleError(cause)
+                ? cause
+                : failure("model", "Pi retry loop failed", cause),
+        });
+        // `produce` always runs at least once before `retryAssistantCall`
+        // settles, so `latest` is always set here.
+        if (latest === undefined)
+            return yield* Effect.die("streamTurnWithRetry: retryAssistantCall settled without calling produce");
+        const settled = latest;
+        if (result !== settled.message) {
+            // Pi normalizes an abort during backoff sleep into a fresh
+            // AssistantMessage (the failed attempt's content, `stopReason`
+            // forced to "aborted") instead of replaying `produce`. Reconcile the
+            // dangling failed entry `context` is still holding with that value.
+            const index = context.indexOf(settled.message);
+            if (index !== -1)
+                context[index] = result;
+        }
+        return { identity: settled.identity, message: result };
+    });
+}
+const statusFor = (message) => message.stopReason === "aborted"
+    ? "cancelled"
+    : message.stopReason === "error"
+        ? "failed"
+        : "completed";
+function emitPendingMessages(messages, context, newMessages, run, turn, emit) {
+    return Effect.forEach(messages, (message) => Effect.gen(function* () {
+        const messageIdentity = identity("message", turn);
+        context.push(message);
+        newMessages.push(message);
+        yield* emit({
+            type: "message_start",
+            run,
+            turn,
+            message: messageIdentity,
+            value: message,
+        });
+        yield* emit({
+            type: "message_end",
+            run,
+            turn,
+            message: messageIdentity,
+            value: message,
+        });
+    })).pipe(Effect.asVoid);
+}
+function completeLoopTurn(input, context, newMessages, run, turn, pending, emit) {
+    return Effect.gen(function* () {
+        yield* emit({ type: "turn_start", run, turn });
+        yield* emitPendingMessages(pending, context, newMessages, run, turn, emit);
+        const streamed = yield* streamTurnWithRetry(input, context, run, turn, emit);
+        // Pi keeps partially streamed tool calls on an aborted or errored message.
+        // Like Pi's loop, the turn ends there: nothing executes and no tool result
+        // pretends a call ran. The run then settles with the honest terminal.
+        const interrupted = statusFor(streamed.message) !== "completed";
+        const calls = streamed.message.content.filter((content) => content.type === "toolCall");
+        const batch = calls.length === 0 || interrupted
+            ? { messages: [], terminate: false }
+            : streamed.message.stopReason === "length"
+                ? {
+                    messages: yield* failTruncatedToolCalls(calls, run, turn, emit),
+                    terminate: false,
+                }
+                : yield* executeToolBatch(calls, input, run, turn, emit);
+        context.push(...batch.messages);
+        newMessages.push(streamed.message, ...batch.messages);
+        yield* emit({
+            type: "turn_end",
+            run,
+            turn,
+            message: streamed.message,
+            toolResults: batch.messages,
+        });
+        return {
+            message: streamed.message,
+            toolResults: batch.messages,
+            terminate: batch.terminate,
+        };
+    });
+}
+/** Resolve only missing results. A stored and current safe policy are both required. */
+function resumeTurn(input, resume, context, newMessages, run, emit) {
+    const turn = identity("turn", run);
+    return Effect.gen(function* () {
+        // Do not emit turn_start: the assistant response is already durable and
+        // no new model request is being dispatched for this recovered boundary.
+        if (statusFor(resume.message) !== "completed")
+            return {
+                message: resume.message,
+                toolResults: [],
+                terminate: true,
+            };
+        const recovered = yield* Effect.forEach(resume.tools, (checkpoint) => Effect.gen(function* () {
+            if (checkpoint.state === "completed" &&
+                checkpoint.message !== undefined)
+                return {
+                    message: checkpoint.message,
+                    terminate: checkpoint.result.terminate === true,
+                    recorded: true,
+                };
+            const tool = selectedTool(input.tools ?? [], checkpoint.call);
+            let finalized;
+            if (resume.message.stopReason !== "length" &&
+                (checkpoint.state === "pending" ||
+                    (checkpoint.state === "started" &&
+                        checkpoint.replay === "safe" &&
+                        tool?.replay === "safe"))) {
+                const prepared = yield* prepareTool(tool, checkpoint.call, run, turn, emit);
+                finalized =
+                    prepared.kind === "finalized"
+                        ? prepared.value
+                        : yield* executePreparedTool(prepared, run, turn, emit);
+            }
+            else {
+                finalized = {
+                    call: checkpoint.call,
+                    identity: identity("tool_call", turn),
+                    result: checkpoint.state === "completed"
+                        ? checkpoint.result
+                        : checkpoint.state === "pending" &&
+                            resume.message.stopReason === "length"
+                            ? truncatedToolResult(checkpoint.call)
+                            : errorResult("Interrupted by a restart; it may or may not have completed; check before retrying."),
+                };
+                yield* emit({
+                    type: "tool_execution_start",
+                    replay: "unsafe",
+                    run,
+                    turn,
+                    toolCall: finalized.identity,
+                    call: finalized.call,
+                });
+                yield* emitToolEnd(finalized, run, turn, emit);
+            }
+            return {
+                message: yield* emitToolResult(finalized, run, turn, emit),
+                terminate: finalized.result.terminate === true,
+                recorded: false,
+            };
+        }));
+        const messages = recovered
+            .filter(({ recorded }) => !recorded)
+            .map(({ message }) => message);
+        context.push(...messages);
+        newMessages.push(...messages);
+        return {
+            message: resume.message,
+            toolResults: recovered.map(({ message }) => message),
+            terminate: recovered.length > 0 && recovered.every(({ terminate }) => terminate),
+        };
+    });
+}
+function selectNextTurn(input, turn, context, newMessages) {
+    return Effect.gen(function* () {
+        if (input.shouldStopAfterTurn !== undefined &&
+            (yield* input.shouldStopAfterTurn({
+                message: turn.message,
+                toolResults: turn.toolResults,
+                context,
+                newMessages,
+            })))
+            return { continue: false, pending: [] };
+        const steering = input.getSteeringMessages === undefined
+            ? []
+            : [...(yield* input.getSteeringMessages())];
+        const hasToolCalls = turn.message.content.some((content) => content.type === "toolCall");
+        if ((hasToolCalls && !turn.terminate) || steering.length > 0)
+            return { continue: true, pending: steering };
+        const followUps = input.getFollowUpMessages === undefined
+            ? []
+            : [...(yield* input.getFollowUpMessages())];
+        return { continue: followUps.length > 0, pending: followUps };
+    });
+}
+function finishRun(run, terminal, message, messages, status, emit) {
+    return Effect.gen(function* () {
+        yield* emit({ type: "run_end", run, terminal, outcome: status });
+        return { status, run, terminal, message, messages };
+    });
+}
+/** Run Pi's model/tool loop inside Effect without changing Pi's values. */
+export function run(input, listener = noListener) {
+    return Effect.gen(function* () {
+        const semaphore = yield* Semaphore.make(1);
+        const lifecycle = { started: false, ended: false };
+        const emit = (event) => Effect.suspend(() => {
+            if (event.type === "run_end")
+                lifecycle.ended = true;
+            return semaphore.withPermits(1)(listener(event));
+        }).pipe(Effect.tap(() => Effect.sync(() => {
+            if (event.type === "run_start")
+                lifecycle.started = true;
+        })));
+        const runIdentity = identity("run");
+        const terminalIdentity = identity("terminal", runIdentity);
+        return yield* runLoop(input, emit, runIdentity, terminalIdentity).pipe(Effect.onExit((exit) => {
+            const outcome = abnormalOutcome(exit);
+            if (!lifecycle.started || lifecycle.ended || outcome === undefined)
+                return Effect.void;
+            // The exit is already decided; a listener failure here cannot change it.
+            return emit({
+                type: "run_end",
+                run: runIdentity,
+                terminal: terminalIdentity,
+                outcome,
+            }).pipe(Effect.ignore);
+        }));
+    });
+}
+/** Terminal outcome owed to the listener for an exit that produced no outcome. */
+function abnormalOutcome(exit) {
+    if (Exit.isSuccess(exit))
+        return undefined;
+    if (Cause.hasInterruptsOnly(exit.cause))
+        return "cancelled";
+    const error = Cause.findErrorOption(exit.cause);
+    // A failed listener cannot be trusted to record its own terminal.
+    if (Option.isSome(error) && error.value.phase === "listener")
+        return undefined;
+    return "failed";
+}
+function runLoop(input, emit, runIdentity, terminalIdentity) {
+    return Effect.gen(function* () {
+        const context = [...input.messages];
+        const newMessages = [];
+        let pending = input.getSteeringMessages === undefined
+            ? []
+            : [...(yield* input.getSteeringMessages())];
+        let finalMessage;
+        let continueLoop;
+        yield* emit({ type: "run_start", run: runIdentity });
+        if (input.resume !== undefined) {
+            const resumed = yield* resumeTurn(input, input.resume, context, newMessages, runIdentity, emit);
+            const status = statusFor(resumed.message);
+            const next = status === "completed"
+                ? yield* selectNextTurn(input, resumed, context, newMessages)
+                : { continue: false, pending: [] };
+            if (!next.continue && pending.length === 0)
+                return yield* finishRun(runIdentity, terminalIdentity, resumed.message, newMessages, status, emit);
+            pending.push(...next.pending);
+        }
+        do {
+            const completed = yield* completeLoopTurn(input, context, newMessages, runIdentity, identity("turn", runIdentity), pending, emit);
+            finalMessage = completed.message;
+            const status = statusFor(completed.message);
+            if (status !== "completed") {
+                return yield* finishRun(runIdentity, terminalIdentity, completed.message, newMessages, status, emit);
+            }
+            // Tool results always continue the run: this is where Pi checks its
+            // context before the next assistant response (Pi 0.84.4+).
+            if (input.prepareNextTurn !== undefined &&
+                !completed.terminate &&
+                completed.message.content.some((part) => part.type === "toolCall")) {
+                const replaced = yield* input.prepareNextTurn({
+                    message: completed.message,
+                    toolResults: completed.toolResults,
+                    context,
+                    newMessages,
+                });
+                if (replaced !== undefined)
+                    context.splice(0, context.length, ...replaced);
+            }
+            const next = yield* selectNextTurn(input, completed, context, newMessages);
+            pending = [...next.pending];
+            continueLoop = next.continue;
+        } while (continueLoop);
+        return yield* finishRun(runIdentity, terminalIdentity, finalMessage, newMessages, "completed", emit);
+    });
+}
+/** Canonical Effect-native Mule value. */
+export const muleEffect = { run };