@xandreed/plugin-agent-loop 0.4.0 → 0.11.0

package/README.md

@@ -1,5 +1,5 @@
 # @xandreed/plugin-agent-loop
 
-Efferent composable agent framework, 0.4.0. Bun on Linux.
+Efferent composable agent framework, 0.11.0. Node 24 or Bun.
 
 Documentation: https://github.com/xandreeddev/efferent

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./loop.js";
 export * from "./runAgent.js";
 export { agentLoopPlugin, default } from "./plugin.adapter.js";
+export { runSteps, STEP_LOOP, StepLoopLive, stepLoopPlugin } from "./step-loop.adapter.js";

package/dist/index.js

@@ -1,3 +1,4 @@
 export * from "./loop.js";
 export * from "./runAgent.js";
 export { agentLoopPlugin, default } from "./plugin.adapter.js";
+export { runSteps, STEP_LOOP, StepLoopLive, stepLoopPlugin } from "./step-loop.adapter.js";

package/dist/loop.d.ts

@@ -1,9 +1,10 @@
-import { AiError, LanguageModel, Prompt } from "@effect/ai";
-import type { Tool, Toolkit } from "@effect/ai";
+import { AiError, LanguageModel, Prompt } from "effect/ai";
+import type { Tool, Toolkit } from "effect/ai";
 import { Effect, Option } from "effect";
 import type { LoopEvent } from "@xandreed/core";
 import type { AgentMessage } from "@xandreed/core";
 import type { TokenUsage } from "@xandreed/core";
+import type { ModelDispatch } from "@xandreed/core";
 /**
  * A mid-run fold the `compact` callback hands back: everything before
  * `keepFrom` is replaced by `handoffToMessage(summary)`; `messages[keepFrom..]`
@@ -23,7 +24,7 @@ export interface CompactionPlan {
  * `LanguageModel.generateText`, appends the response as the new tail, and
  * re-invokes until the model stops requesting tools, `maxSteps` is hit, or
  * the degenerate-loop breaker fires. State is an immutable fold through
- * `Effect.iterate` — the same discipline as foundry's forge loop.
+ * a recursive step — the same discipline as foundry's forge loop.
  */
 export interface RunLoopOptions<Tools extends Record<string, Tool.Any>, R> {
     /** A host-validated first batch. Runs as step zero through the ordinary
@@ -40,24 +41,40 @@ export interface RunLoopOptions<Tools extends Record<string, Tool.Any>, R> {
         readonly messages: ReadonlyArray<AgentMessage>;
         readonly activeTools: ReadonlyArray<string>;
     }) => Effect.Effect<{
-        readonly model: LanguageModel.Service;
+        readonly model: LanguageModel.LanguageModel;
         readonly system: Prompt.Prompt;
     }, AiError.AiError, R>;
+    /** Validate independently reconstructed durable input immediately before a provider dispatch. */
+    readonly beforeDispatch?: (step: number, request: ModelDispatch) => Effect.Effect<void, never, R>;
     readonly system: string | Prompt.Prompt;
+    /** The READ side of memory: when present, each provider step sends these
+     * messages instead of the loop's own buffer. Persistence still flows through
+     * `onTail`, so a memory plugin can rebuild every request from its log. */
+    readonly render?: (step: StepView) => Effect.Effect<ReadonlyArray<AgentMessage>, never, R>;
+    /** Per-step tool choice (e.g. force a delivery tool without removing others). */
+    readonly stepDirective?: (step: StepView) => Effect.Effect<{
+        readonly toolChoice: Option.Option<LoopToolChoice>;
+    }, never, R>;
+    /** Host wording for the loop's own corrective turns. */
+    readonly correctives?: {
+        readonly malformed?: (tools: ReadonlyArray<string>, description: string) => string;
+        readonly incomplete?: string;
+    };
     /** Explicit opt-in: export prompt and result content on step spans.
      * Hosts own consent, redaction and exporter retention. Disabled by default. */
     readonly captureTraceContent?: boolean;
     readonly messages: ReadonlyArray<AgentMessage>;
     readonly toolkit: Toolkit.Toolkit<Tools>;
-    /** Run-pinned deterministic capability selection, refreshed between steps.
-     * A capability-expansion tool can update this selection for the next call.
-     * Handlers must still enforce their own principal/action policy. */
     /** Host completion condition, checked after settled tools/events. Avoids a
      * paid final prose call when a tool already delivered the complete result. */
     readonly isComplete?: () => Effect.Effect<boolean, never, R>;
     /** When true, a model stop cannot substitute for host completion. A bounded
      * corrective turn asks for the missing actions; maxSteps still applies. */
     readonly requireCompletion?: boolean;
+    /** Run-pinned deterministic capability selection, refreshed between steps
+     * and sent in the order returned (append new tools to keep the prefix stable).
+     * A capability-expansion tool can update this selection for the next call.
+     * Handlers must still enforce their own principal/action policy. */
     readonly activeTools?: () => Effect.Effect<ReadonlyArray<keyof Tools>, never, R>;
     /** A ceiling, not a target — a normal run ends when the model stops
      *  calling tools. Default {@link DEFAULT_MAX_STEPS}. */
@@ -104,6 +121,16 @@ export interface RunLoopOptions<Tools extends Record<string, Tool.Any>, R> {
      */
     readonly pendingInput?: () => Effect.Effect<Option.Option<string>, never, R>;
 }
+/** What the loop knows about the step it is about to take. */
+export interface StepView {
+    readonly stepIndex: number;
+    /** Active tool names, in activation order. */
+    readonly activeTools: ReadonlyArray<string>;
+    readonly lastUsage: Option.Option<TokenUsage>;
+}
+export type LoopToolChoice = "required" | {
+    readonly tool: string;
+};
 export declare const DEFAULT_MAX_STEPS = 100;
 export declare const DEFAULT_TOOL_CONCURRENCY = 4;
 export declare const DEGENERATE_REPEAT_NUDGE: string;
@@ -136,11 +163,10 @@ export declare const nextPhase: (facts: {
 export declare const runLoop: <Tools extends Record<string, Tool.Any>, R = never>(options: RunLoopOptions<Tools, R>) => Effect.Effect<{
     finalText: string;
     messages: readonly ({
-        readonly providerOptions?: unknown;
         readonly role: "user";
         readonly content: string;
-    } | {
         readonly providerOptions?: unknown;
+    } | {
         readonly role: "assistant";
         readonly content: readonly ({
             readonly type: "text";
@@ -152,30 +178,30 @@ export declare const runLoop: <Tools extends Record<string, Tool.Any>, R = never
             readonly providerOptions?: unknown;
         } | {
             readonly type: "tool-call";
-            readonly providerOptions?: unknown;
             readonly toolCallId: string & import("effect/Brand").Brand<"ToolCallId">;
             readonly toolName: string;
             readonly input: unknown;
+            readonly providerOptions?: unknown;
             readonly providerExecuted?: boolean | undefined;
         })[];
-    } | {
         readonly providerOptions?: unknown;
+    } | {
         readonly role: "tool";
         readonly content: readonly {
             readonly type: "tool-result";
-            readonly providerOptions?: unknown;
             readonly toolCallId: string & import("effect/Brand").Brand<"ToolCallId">;
             readonly toolName: string;
             readonly output: unknown;
+            readonly providerOptions?: unknown;
             readonly isError?: boolean | undefined;
         }[];
+        readonly providerOptions?: unknown;
     })[];
     newTail: readonly ({
-        readonly providerOptions?: unknown;
         readonly role: "user";
         readonly content: string;
-    } | {
         readonly providerOptions?: unknown;
+    } | {
         readonly role: "assistant";
         readonly content: readonly ({
             readonly type: "text";
@@ -187,23 +213,24 @@ export declare const runLoop: <Tools extends Record<string, Tool.Any>, R = never
             readonly providerOptions?: unknown;
         } | {
             readonly type: "tool-call";
-            readonly providerOptions?: unknown;
             readonly toolCallId: string & import("effect/Brand").Brand<"ToolCallId">;
             readonly toolName: string;
             readonly input: unknown;
+            readonly providerOptions?: unknown;
             readonly providerExecuted?: boolean | undefined;
         })[];
-    } | {
         readonly providerOptions?: unknown;
+    } | {
         readonly role: "tool";
         readonly content: readonly {
             readonly type: "tool-result";
-            readonly providerOptions?: unknown;
             readonly toolCallId: string & import("effect/Brand").Brand<"ToolCallId">;
             readonly toolName: string;
             readonly output: unknown;
+            readonly providerOptions?: unknown;
             readonly isError?: boolean | undefined;
         }[];
+        readonly providerOptions?: unknown;
     })[];
     outcome: "ok" | "partial";
     reason: "completed" | "step-cap" | "degenerate-loop";

package/dist/loop.js

@@ -1,6 +1,6 @@
-import { AiError, LanguageModel, Prompt } from "@effect/ai";
+import { AiError, LanguageModel, Prompt } from "effect/ai";
 import { Cause, Effect, Exit, Match, Metric, Option, Ref, Stream } from "effect";
-import { foldStreamParts } from "@xandreed/core";
+import { foldStreamParts, freezeModelRequest } from "@xandreed/core";
 import { CurrentAgentStep } from "@xandreed/core";
 import { CurrentEmptyResponseTolerance } from "@xandreed/core";
 import { addUsage, zeroUsage } from "@xandreed/core";
@@ -15,7 +15,7 @@ const engineRuns = Metric.counter("engine.runs", {
 }), engineCorrections = Metric.counter("engine.corrections", {
   description: "self-corrections by kind (malformed recovery, degenerate nudge)",
   incremental: !0
-}), tagged = (metric, tags) => Object.entries(tags).reduce((m, [key, value]) => Metric.tagged(m, key, value), metric), MAX_MALFORMED = 3, REPEAT_NUDGE_AT = 3, REPEAT_BREAK_AT = 5;
+}), tagged = (metric, tags) => Metric.withAttributes(metric, tags), malformedReasons = new Set(["InvalidOutputError", "ToolParameterValidationError", "ToolNotFoundError"]), isMalformed = (error) => AiError.isAiError(error) && malformedReasons.has(error.reason._tag), MAX_MALFORMED = 3, REPEAT_NUDGE_AT = 3, REPEAT_BREAK_AT = 5;
 export const DEGENERATE_REPEAT_NUDGE = "You've called the same tool(s) and gotten the same result several times in " + "a row \u2014 you're looping without making progress. STOP repeating that call. " + "Take a DIFFERENT concrete action toward the task; if you're genuinely stuck, say what's blocking you and stop.", DEGENERATE_LOOP_STOP = "[stopped: repeated the same tool call with no progress \u2014 the run was looping]";
 const clip = (s, max) => s.length <= max ? s : `${s.slice(0, max)}\u2026`, progressSignature = (content, pollable) => {
   const calls = responseToolCalls(content);
@@ -40,40 +40,48 @@ export const foldProgress = (state, sig) => {
     yield* (options.onEvent?.(event) ?? Effect.void).pipe(Effect.withParentSpan(parent), Effect.provide(eventContext));
   }), toolkit = yield* options.toolkit, step = (state) => Effect.gen(function* () {
     yield* onEvent({ type: "turn_start", turnIndex: state.turnIndex });
-    const active = options.activeTools === void 0 ? Object.keys(toolkit.tools) : yield* options.activeTools().pipe(Effect.provide(eventContext)), selectedTools = Object.fromEntries(Object.entries(toolkit.tools).filter(([name]) => active.includes(name))), toolNames = Object.keys(selectedTools);
+    const active = options.activeTools === void 0 ? Object.keys(toolkit.tools) : (yield* options.activeTools().pipe(Effect.provide(eventContext))).map(String), selectedTools = Object.fromEntries(active.flatMap((name) => Object.hasOwn(toolkit.tools, name) ? [[name, toolkit.tools[name]]] : [])), toolNames = Object.keys(selectedTools), planned = state.turnIndex === 0 && options.initialStep !== void 0, stepView = { stepIndex: state.turnIndex, activeTools: toolNames, lastUsage: state.lastUsage };
     yield* Effect.annotateCurrentSpan({ "engine.tools.active": toolNames });
-    const prepared = state.turnIndex === 0 && options.initialStep !== void 0 ? Option.none() : options.prepareModel === void 0 ? Option.none() : Option.some(yield* options.prepareModel({ stepIndex: state.turnIndex, messages: state.messages, activeTools: toolNames }).pipe(Effect.provide(eventContext))), baseSystem = Option.match(prepared, { onNone: () => options.system, onSome: (value) => value.system }), instructions = typeof baseSystem === "string" ? Prompt.make([{ role: "system", content: baseSystem }]) : baseSystem, prompt = Prompt.merge(instructions, Prompt.make(toPromptMessages(state.messages)));
+    const prepared = state.turnIndex === 0 && options.initialStep !== void 0 ? Option.none() : options.prepareModel === void 0 ? Option.none() : Option.some(yield* options.prepareModel({ stepIndex: state.turnIndex, messages: state.messages, activeTools: toolNames }).pipe(Effect.provide(eventContext))), baseSystem = Option.match(prepared, { onNone: () => options.system, onSome: (value) => value.system }), instructions = typeof baseSystem === "string" ? Prompt.make([{ role: "system", content: baseSystem }]) : baseSystem, visible = options.render === void 0 ? state.messages : yield* options.render(stepView).pipe(Effect.provide(eventContext)), prompt = freezeModelRequest(Prompt.concat(instructions, Prompt.make(toPromptMessages(visible)))), directive = options.stepDirective === void 0 ? Option.none() : (yield* options.stepDirective(stepView).pipe(Effect.provide(eventContext))).toolChoice;
     if (options.captureTraceContent === !0)
       yield* Effect.annotateCurrentSpan({
         "engine.step.input": JSON.stringify({ messages: prompt.content, activeTools: toolNames })
       });
-    const toolSequence = yield* Ref.make(0), callOptions = {
+    const toolSequence = yield* Ref.make(0), callOptions = Object.freeze({
       prompt,
       toolkit: {
         tools: selectedTools,
-        handle: (name, params) => Effect.gen(function* () {
+        handle: (name, params, providerCallId, parseOptions) => Effect.gen(function* () {
           const sequence = yield* Ref.getAndUpdate(toolSequence, (value) => value + 1), toolCallId = `execution:${state.turnIndex}:${sequence}`;
           yield* onEvent({ type: "tool_start", turnIndex: state.turnIndex, toolCallId, toolName: String(name), args: params });
-          return yield* toolkit.handle(name, params).pipe(Effect.tap((result) => onEvent({
+          return (yield* toolkit.handle(name, params, providerCallId, parseOptions)).pipe(Stream.mapEffect((result) => result.isFailure && result.failureOrigin === "parameters" ? Effect.fail(result.result) : Effect.succeed(result)), Stream.tap((result) => result.preliminary ? Effect.void : onEvent({
             type: "tool_end",
             turnIndex: state.turnIndex,
             toolCallId,
             toolName: String(name),
             args: params,
             ok: !result.isFailure,
-            result: result.result
+            result: result.result,
+            encoded: result.encodedResult
           })));
         })
       },
-      concurrency: options.toolConcurrency ?? DEFAULT_TOOL_CONCURRENCY
-    }, settled = (streamingHealthy) => (Option.isSome(prepared) ? prepared.value.model.generateText(callOptions) : LanguageModel.generateText(callOptions)).pipe(Effect.map((res) => ({
+      concurrency: options.toolConcurrency ?? DEFAULT_TOOL_CONCURRENCY,
+      ...Option.match(directive, { onNone: () => ({}), onSome: (toolChoice) => ({ toolChoice }) })
+    }), dispatchModel = Option.isSome(prepared) ? prepared.value.model : yield* LanguageModel.LanguageModel, beforeDispatch = options.beforeDispatch === void 0 ? Effect.void : options.beforeDispatch(state.turnIndex, {
+      prompt,
+      tools: Object.values(selectedTools),
+      toolChoice: Option.getOrElse(directive, () => "auto"),
+      model: dispatchModel
+    }).pipe(Effect.provide(eventContext)), generated = planned ? LanguageModel.generateText(callOptions) : beforeDispatch.pipe(Effect.andThen(Effect.suspend(() => dispatchModel.generateText(callOptions)))), settled = (streamingHealthy) => generated.pipe(Effect.map((res) => ({
       _tag: "ok",
       content: res.content,
       finishReason: res.finishReason,
       usage: res.usage,
       streamingHealthy
     }))), streamed = Effect.gen(function* () {
-      const partSeen = yield* Ref.make(!1), folded = yield* foldStreamParts((Option.isSome(prepared) ? prepared.value.model.streamText(callOptions) : LanguageModel.streamText(callOptions)).pipe(Stream.tap(() => Ref.set(partSeen, !0))), (delta) => onEvent({
+      yield* beforeDispatch;
+      const partSeen = yield* Ref.make(!1), folded = yield* foldStreamParts(Stream.unwrap(Effect.sync(() => dispatchModel.streamText(callOptions))).pipe(Stream.tap(() => Ref.set(partSeen, !0))), (delta) => onEvent({
         type: "assistant_delta",
         turnIndex: state.turnIndex,
         channel: delta.channel,
@@ -86,12 +94,12 @@ export const foldProgress = (state, sig) => {
         finishReason: turn.finishReason,
         usage: turn.usage,
         streamingHealthy: !0
-      })), Effect.catchAll((err) => Ref.get(partSeen).pipe(Effect.flatMap((armed) => armed ? Effect.fail(err) : Effect.succeed(Option.none())))), Effect.catchAllDefect((defect) => Ref.get(partSeen).pipe(Effect.flatMap((armed) => armed ? Effect.die(defect) : Effect.succeed(Option.none())))));
+      })), Effect.catch((err) => Ref.get(partSeen).pipe(Effect.flatMap((armed) => armed ? Effect.fail(err) : Effect.succeed(Option.none())))), Effect.catchDefect((defect) => Ref.get(partSeen).pipe(Effect.flatMap((armed) => armed ? Effect.die(defect) : Effect.succeed(Option.none())))));
       return yield* Option.match(folded, {
         onSome: Effect.succeed,
-        onNone: () => Effect.logWarning("streaming failed before any part arrived \u2014 falling back to generateText for this run").pipe(Effect.zipRight(settled(!1)))
+        onNone: () => Effect.logWarning("streaming failed before any part arrived \u2014 falling back to generateText for this run").pipe(Effect.andThen(settled(!1)))
       });
-    }), planned = state.turnIndex === 0 && options.initialStep !== void 0, initial = Effect.gen(function* () {
+    }), initial = Effect.gen(function* () {
       const provider = yield* LanguageModel.make({
         generateText: () => Effect.succeed([...(options.initialStep ?? []).map((call, index) => ({
           type: "tool-call",
@@ -99,22 +107,22 @@ export const foldProgress = (state, sig) => {
           name: call.name,
           params: call.params,
           providerExecuted: !1
-        })), { type: "finish", reason: "tool-calls", usage: { inputTokens: void 0, outputTokens: void 0, totalTokens: void 0 } }]),
+        })), { type: "finish", reason: "tool-calls", usage: { inputTokens: {}, outputTokens: {} } }]),
         streamText: () => Stream.empty
       });
       yield* Effect.annotateCurrentSpan("engine.step.host_planned", !0);
       return yield* settled(state.streamingHealthy).pipe(Effect.provideService(LanguageModel.LanguageModel, provider));
-    }), useStreaming = options.streaming === !0 && state.streamingHealthy, outcome = yield* (planned ? initial : useStreaming ? streamed : settled(state.streamingHealthy)).pipe(Effect.catchAll((err) => err?._tag === "MalformedOutput" ? Effect.succeed({ _tag: "malformed", err }) : Effect.fail(err)), Effect.locally(CurrentEmptyResponseTolerance, state.toolCalls > 0));
+    }), useStreaming = options.streaming === !0 && state.streamingHealthy, outcome = yield* (planned ? initial : useStreaming ? streamed : settled(state.streamingHealthy)).pipe(Effect.catch((err) => isMalformed(err) ? Effect.succeed({ _tag: "malformed", err }) : Effect.fail(err)), Effect.provideService(CurrentEmptyResponseTolerance, state.toolCalls > 0));
     if (outcome._tag === "malformed") {
       const streak = state.malformedStreak + 1;
       if (streak >= MAX_MALFORMED)
         return yield* Effect.fail(outcome.err);
-      const desc = clip(String(outcome.err.description ?? "the response could not be parsed"), 600);
+      const reason = outcome.err.reason, desc = clip("description" in reason ? reason.description : reason.message, 600);
       yield* Effect.logWarning(`recovering from a malformed response: ${desc}`);
-      yield* Metric.increment(tagged(engineCorrections, { "engine.kind": "malformed" }));
+      yield* Metric.update(tagged(engineCorrections, { "engine.kind": "malformed" }), 1);
       const corrective = {
         role: "user",
-        content: `Your previous reply could not be parsed: ${desc}
+        content: options.correctives?.malformed?.(toolNames, desc) ?? `Your previous reply could not be parsed: ${desc}
 
 This usually means you called a tool that doesn't exist or used the wrong argument shape. The only tools available are: ${toolNames.join(", ")}. Reply again using one of those tools, or plain text if you're done.`
       };
@@ -138,7 +146,7 @@ This usually means you called a tool that doesn't exist or used the wrong argume
       ...!planned ? { "engine.step.usage": JSON.stringify(usage) } : {},
       ...options.captureTraceContent === !0 ? { "engine.step.output": JSON.stringify({ content, usage, finishReason: outcome.finishReason }) } : {}
     });
-    const model = extractModel(content), tail = planned ? responseToAgentMessages(content) : withUsageOnAssistant(responseToAgentMessages(content), usage, model), positions = yield* options.onTail?.(tail) ?? Effect.succeed([]), assistantAt = tail.findIndex((m) => m.role === "assistant"), assistantPosition = assistantAt >= 0 ? Option.fromNullable(positions[assistantAt]) : Option.none(), text = responseText(content), toolCalls = responseToolCalls(content);
+    const model = extractModel(content), tail = planned ? responseToAgentMessages(content) : withUsageOnAssistant(responseToAgentMessages(content), usage, model), positions = yield* options.onTail?.(tail) ?? Effect.succeed([]), assistantAt = tail.findIndex((m) => m.role === "assistant"), assistantPosition = assistantAt >= 0 ? Option.fromNullishOr(positions[assistantAt]) : Option.none(), text = responseText(content), toolCalls = responseToolCalls(content);
     yield* onEvent({
       type: "assistant_message",
       turnIndex: state.turnIndex,
@@ -153,14 +161,14 @@ This usually means you called a tool that doesn't exist or used the wrong argume
       })
     });
     const toolResults = responseToolResults(content);
-    yield* Effect.forEach(toolResults, (tr) => Metric.increment(tagged(engineToolCalls, {
+    yield* Effect.forEach(toolResults, (tr) => Metric.update(tagged(engineToolCalls, {
       "engine.tool": tr.toolName,
       "engine.ok": tr.ok ? "true" : "false"
-    })));
+    }), 1));
     const sig = progressSignature(content, pollable), progress = foldProgress(state, sig), { stale, seen } = progress, nudge = progress.nudge ? [{ role: "user", content: DEGENERATE_REPEAT_NUDGE }] : [];
     yield* nudge.length > 0 ? options.onTail?.(nudge) ?? Effect.void : Effect.void;
-    yield* nudge.length > 0 ? Metric.increment(tagged(engineCorrections, { "engine.kind": "degenerate-nudge" })) : Effect.void;
-    const finalText = text.length > 0 ? text : state.finalText, turnIndex = state.turnIndex + 1, completed = yield* options.isComplete?.() ?? Effect.succeed(!1), requireMore = !completed && options.requireCompletion === !0, completionNudge = requireMore && toolCalls.length === 0 ? [{ role: "user", content: "The host reports that required actions are incomplete. Your ordinary text is not a delivered result. Complete the requested work using the available tools, or use an explicit supported failure/clarification action if the evidence is missing." }] : [];
+    yield* nudge.length > 0 ? Metric.update(tagged(engineCorrections, { "engine.kind": "degenerate-nudge" }), 1) : Effect.void;
+    const finalText = text.length > 0 ? text : state.finalText, turnIndex = state.turnIndex + 1, completed = yield* options.isComplete?.() ?? Effect.succeed(!1), requireMore = !completed && options.requireCompletion === !0, completionNudge = requireMore && toolCalls.length === 0 ? [{ role: "user", content: options.correctives?.incomplete ?? "The host reports that required actions are incomplete. Your ordinary text is not a delivered result. Complete the requested work using the available tools, or use an explicit supported failure/clarification action if the evidence is missing." }] : [];
     yield* completionNudge.length > 0 ? options.onTail?.(completionNudge) ?? Effect.void : Effect.void;
     const wantsMore = !completed && (requireMore || outcome.finishReason === "tool-calls" && toolCalls.length > 0), broke = progress.broke, phase = nextPhase({ broke, wantsMore, turnIndex, maxSteps });
     yield* broke ? Effect.logWarning(`breaking a degenerate tool-call loop after ${stale} stale turns`) : Effect.void;
@@ -194,15 +202,16 @@ This usually means you called a tool that doesn't exist or used the wrong argume
       seen,
       staleTurns: stale,
       usage: addUsage(state.usage, usage),
+      lastUsage: planned ? state.lastUsage : Option.some(usage),
       phase,
       toolCalls: state.toolCalls + toolCalls.length,
       toolFailures: state.toolFailures + toolResults.filter((tr) => !tr.ok).length,
       corrections: state.corrections + (nudge.length > 0 ? 1 : 0),
       streamingHealthy: outcome.streamingHealthy
     };
-  }).pipe(Effect.onExit((exit) => onEvent({ type: "turn_end", turnIndex: state.turnIndex, status: Exit.isSuccess(exit) ? "completed" : Cause.isInterruptedOnly(exit.cause) ? "cancelled" : "failed" })), Effect.locally(CurrentAgentStep, Option.some(state.turnIndex)), Effect.withSpan("engine.turn", {
+  }).pipe(Effect.onExit((exit) => onEvent({ type: "turn_end", turnIndex: state.turnIndex, status: Exit.isSuccess(exit) ? "completed" : Cause.hasInterruptsOnly(exit.cause) ? "cancelled" : "failed" })), Effect.provideService(CurrentAgentStep, Option.some(state.turnIndex)), Effect.withSpan("engine.turn", {
     attributes: { "engine.turn": state.turnIndex, "engine.step": state.turnIndex + 1 }
-  })), final = yield* Effect.iterate({
+  })), runSteps = (state) => state.phase === "continue" ? Effect.flatMap(step(state), runSteps) : Effect.succeed(state), initial = {
     messages: options.messages,
     newTail: [],
     finalText: "",
@@ -211,20 +220,21 @@ This usually means you called a tool that doesn't exist or used the wrong argume
     seen: new Set,
     staleTurns: 0,
     usage: zeroUsage,
+    lastUsage: Option.none(),
     phase: "continue",
     toolCalls: 0,
     toolFailures: 0,
     corrections: 0,
     streamingHealthy: !0
-  }, { while: (state) => state.phase === "continue", body: step }), { outcome, reason } = Match.value(final.phase).pipe(Match.when("completed", () => ({ outcome: "ok", reason: "completed" })), Match.when("step-cap", () => ({
+  }, final = yield* runSteps(initial), { outcome, reason } = Match.value(final.phase).pipe(Match.when("completed", () => ({ outcome: "ok", reason: "completed" })), Match.when("step-cap", () => ({
     outcome: "partial",
     reason: "step-cap"
   })), Match.when("degenerate-loop", () => ({
     outcome: "partial",
     reason: "degenerate-loop"
-  })), Match.when("continue", () => ({ outcome: "ok", reason: "completed" })), Match.exhaustive);
+  })), Match.exhaustive);
   yield* onEvent({ type: "agent_end", outcome, reason, finalText: final.finalText });
-  yield* Metric.increment(tagged(engineRuns, { "engine.outcome": outcome, "engine.reason": reason }));
+  yield* Metric.update(tagged(engineRuns, { "engine.outcome": outcome, "engine.reason": reason }), 1);
   yield* Effect.annotateCurrentSpan({
     "engine.outcome": outcome,
     "engine.reason": reason,

package/dist/plugin.adapter.d.ts

@@ -1,2 +1,12 @@
-export declare const agentLoopPlugin: import("@xandreed/core").Plugin;
+import { LanguageModel } from "effect/ai";
+import { AgentLoop, AgentTools, ContextManager, Memory, SessionStore } from "@xandreed/core";
+export declare const agentLoopPlugin: import("@xandreed/core").TypedPlugin<{
+    readonly maxSteps: number;
+    readonly toolConcurrency: number;
+    readonly streaming: boolean;
+}, {
+    readonly maxSteps: number;
+    readonly toolConcurrency: number;
+    readonly streaming: boolean;
+}, AgentLoop, never, LanguageModel.LanguageModel | SessionStore | AgentTools | ContextManager | Memory>;
 export default agentLoopPlugin;

package/dist/plugin.adapter.js

@@ -1,11 +1,11 @@
-import { LanguageModel } from "@effect/ai";
+import { LanguageModel } from "effect/ai";
 import { Effect, Layer, Option, Ref, Schema } from "effect";
 import { AgentLoop, AgentMessage, AgentTools, ContextManager, definePlugin, handoffToMessage, HarnessError, Memory, SessionStore } from "@xandreed/core";
 import { runLoop } from "./loop.js";
-const Config = Schema.Struct({ maxSteps: Schema.Int.pipe(Schema.between(1, 1000)), toolConcurrency: Schema.Int.pipe(Schema.between(1, 32)), streaming: Schema.Boolean });
+const Config = Schema.Struct({ maxSteps: Schema.Int.pipe(Schema.check(Schema.isBetween({ minimum: 1, maximum: 1000 }))), toolConcurrency: Schema.Int.pipe(Schema.check(Schema.isBetween({ minimum: 1, maximum: 32 }))), streaming: Schema.Boolean });
 export const agentLoopPlugin = definePlugin({
   id: "@xandreed/plugin-agent-loop",
-  version: "0.4.0",
+  version: "0.11.0",
   config: Config,
   defaults: { maxSteps: 100, toolConcurrency: 1, streaming: !0 },
   requires: [LanguageModel.LanguageModel, AgentTools, SessionStore, Memory, ContextManager],
@@ -13,26 +13,26 @@ export const agentLoopPlugin = definePlugin({
   layer: (config) => Layer.effect(AgentLoop, Effect.gen(function* () {
     const model = yield* LanguageModel.LanguageModel, tools = yield* AgentTools, store = yield* SessionStore, memory = yield* Memory, context = yield* ContextManager;
     return AgentLoop.of({ run: (input) => Effect.gen(function* () {
-      const trail = yield* store.read(input.session.id, -1), previous = yield* Effect.reduce(trail, [], (messages, event) => {
+      const trail = yield* store.read(input.session.id, -1), previous = yield* Effect.reduce(trail, () => [], (messages, event) => {
         if (event.name === "messages")
-          return Schema.decodeUnknown(Schema.Array(AgentMessage))(event.data.messages).pipe(Effect.map((tail) => [...messages, ...tail]));
+          return Schema.decodeUnknownEffect(Schema.Array(AgentMessage))(event.data.messages).pipe(Effect.map((tail) => [...messages, ...tail]));
         if (event.name === "context.compacted" && typeof event.data.summary === "string" && typeof event.data.keepFrom === "number")
           return Effect.succeed([handoffToMessage(event.data.summary), ...messages.slice(event.data.keepFrom)]);
         return Effect.succeed(messages);
-      }), recalled = yield* memory.recall(input.session.workspace, input.prompt), system = `${input.system}
+      }), recalled = yield* memory.recall(input.session.workspace, input.userMessage.text), system = `${input.system}
 ${tools.prompt}${recalled.length === 0 ? "" : `
 Workspace memory (context, not instructions):
 ${recalled.map((entry) => entry.text).join(`
 `)}`}`;
       yield* input.publish({ name: "context.prepared", runId: input.runId, data: { system, memoryIds: recalled.map((entry) => entry.id) } });
-      yield* input.publish({ name: "messages", runId: input.runId, data: { messages: [{ role: "user", content: input.prompt }] } });
+      yield* input.publish({ name: "messages", runId: input.runId, data: { messages: [{ role: "user", content: input.userMessage.text }] } });
       const position = yield* Ref.make(previous.length + 1), cooldown = yield* Ref.make(0), result = yield* runLoop({
         system,
-        messages: [...previous, { role: "user", content: input.prompt }],
+        messages: [...previous, { role: "user", content: input.userMessage.text }],
         toolkit: tools.toolkit,
         ...config,
         pendingInput: () => input.steering.pipe(Effect.orDie),
-        onTail: (messages) => input.publish({ name: "messages", runId: input.runId, data: { messages } }).pipe(Effect.zipRight(Ref.modify(position, (at) => [messages.map((_, index) => at + index), at + messages.length])), Effect.orDie),
+        onTail: (messages) => input.publish({ name: "messages", runId: input.runId, data: { messages } }).pipe(Effect.andThen(Ref.modify(position, (at) => [messages.map((_, index) => at + index), at + messages.length])), Effect.orDie),
         onEvent: (event) => event.type === "assistant_delta" ? input.transient({ name: "assistant.delta", runId: input.runId, data: { ...event } }) : input.publish({ name: "loop.event", runId: input.runId, data: { ...event } }).pipe(Effect.asVoid, Effect.orDie),
         compact: (messages, usage) => Effect.gen(function* () {
           if ((yield* Ref.get(cooldown)) > 0) {
@@ -45,7 +45,7 @@ ${recalled.map((entry) => entry.text).join(`
             yield* Ref.set(cooldown, 3);
           }
           return compacted;
-        }).pipe(Effect.catchAll((error) => input.publish({ name: "context.failed", runId: input.runId, data: { message: error.message } }).pipe(Effect.as(Option.none()), Effect.orDie)))
+        }).pipe(Effect.catch((error) => input.publish({ name: "context.failed", runId: input.runId, data: { message: error.message } }).pipe(Effect.as(Option.none()), Effect.orDie)))
       }).pipe(Effect.provideService(LanguageModel.LanguageModel, model), Effect.provide(tools.handlers));
       return { text: result.finalText, outcome: result.outcome === "ok" ? "completed" : "partial" };
     }).pipe(Effect.mapError((error) => new HarnessError({ code: "loop.failed", message: String(error) }))) });

package/dist/runAgent.d.ts

@@ -1,9 +1,10 @@
-import type { Prompt, Tool, Toolkit } from "@effect/ai";
+import type { Prompt, Tool, Toolkit } from "effect/ai";
 import { Effect, Option } from "effect";
 import type { LoopEvent } from "@xandreed/core";
 import type { AgentMessage, ConversationId } from "@xandreed/core";
 import { ConversationStore } from "@xandreed/core";
 import type { ModelCallPolicy } from "@xandreed/core";
+import type { UserMessage } from "@xandreed/core";
 /**
  * WITHIN-RUN compaction policy: when a finished turn's `inputTokens` exceeds
  * the threshold, the buffer's older turns fold into a summary and the run
@@ -44,7 +45,7 @@ export interface AgentConfig<Tools extends Record<string, Tool.Any>> {
     readonly promptCacheKey?: string;
 }
 /**
- * One user turn over a persisted conversation: append the prompt, load the
+ * One user turn over a persisted conversation: append the user message, load the
  * active window (prepending the latest fold's summary when one exists), run
  * the loop with incremental tail persistence, return the result. Store
  * failures are defects (`orDie`) — persistence breaking mid-run is
@@ -56,21 +57,20 @@ export interface AgentConfig<Tools extends Record<string, Tool.Any>> {
  * on the last covered position — so `listActive` for the NEXT run returns
  * exactly the kept rows and folded events are never resent.
  */
-export declare const runAgent: <Tools extends Record<string, Tool.Any>, R = never>(config: AgentConfig<Tools>, conversationId: ConversationId, prompt: string, options?: {
+export declare const runAgent: <Tools extends Record<string, Tool.Any>, R = never>(config: AgentConfig<Tools>, conversationId: ConversationId, userMessage: UserMessage, options?: {
     readonly onEvent?: (event: LoopEvent) => Effect.Effect<void, never, R>;
     /** The mid-turn steering seam — see `RunLoopOptions.pendingInput`. */
     readonly pendingInput?: () => Effect.Effect<Option.Option<string>, never, R>;
-    /** Prompt content is redacted from traces by default. Trusted local
+    /** The user message is redacted from traces by default. Trusted local
      *  drivers may opt in explicitly for debugging. */
     readonly traceContent?: boolean;
 }) => Effect.Effect<{
     finalText: string;
     messages: readonly ({
-        readonly providerOptions?: unknown;
         readonly role: "user";
         readonly content: string;
-    } | {
         readonly providerOptions?: unknown;
+    } | {
         readonly role: "assistant";
         readonly content: readonly ({
             readonly type: "text";
@@ -82,30 +82,30 @@ export declare const runAgent: <Tools extends Record<string, Tool.Any>, R = neve
             readonly providerOptions?: unknown;
         } | {
             readonly type: "tool-call";
-            readonly providerOptions?: unknown;
             readonly toolCallId: string & import("effect/Brand").Brand<"ToolCallId">;
             readonly toolName: string;
             readonly input: unknown;
+            readonly providerOptions?: unknown;
             readonly providerExecuted?: boolean | undefined;
         })[];
-    } | {
         readonly providerOptions?: unknown;
+    } | {
         readonly role: "tool";
         readonly content: readonly {
             readonly type: "tool-result";
-            readonly providerOptions?: unknown;
             readonly toolCallId: string & import("effect/Brand").Brand<"ToolCallId">;
             readonly toolName: string;
             readonly output: unknown;
+            readonly providerOptions?: unknown;
             readonly isError?: boolean | undefined;
         }[];
+        readonly providerOptions?: unknown;
     })[];
     newTail: readonly ({
-        readonly providerOptions?: unknown;
         readonly role: "user";
         readonly content: string;
-    } | {
         readonly providerOptions?: unknown;
+    } | {
         readonly role: "assistant";
         readonly content: readonly ({
             readonly type: "text";
@@ -117,24 +117,25 @@ export declare const runAgent: <Tools extends Record<string, Tool.Any>, R = neve
             readonly providerOptions?: unknown;
         } | {
             readonly type: "tool-call";
-            readonly providerOptions?: unknown;
             readonly toolCallId: string & import("effect/Brand").Brand<"ToolCallId">;
             readonly toolName: string;
             readonly input: unknown;
+            readonly providerOptions?: unknown;
             readonly providerExecuted?: boolean | undefined;
         })[];
-    } | {
         readonly providerOptions?: unknown;
+    } | {
         readonly role: "tool";
         readonly content: readonly {
             readonly type: "tool-result";
-            readonly providerOptions?: unknown;
             readonly toolCallId: string & import("effect/Brand").Brand<"ToolCallId">;
             readonly toolName: string;
             readonly output: unknown;
+            readonly providerOptions?: unknown;
             readonly isError?: boolean | undefined;
         }[];
+        readonly providerOptions?: unknown;
     })[];
     outcome: "ok" | "partial";
     reason: "completed" | "step-cap" | "degenerate-loop";
-}, import("@effect/ai/AiError").AiError, ConversationStore | import("@effect/ai/LanguageModel").LanguageModel | Exclude<Exclude<R, import("effect/Tracer").ParentSpan>, import("effect/Tracer").ParentSpan> | Exclude<Exclude<Tool.HandlersFor<Tools>, import("effect/Tracer").ParentSpan>, import("effect/Tracer").ParentSpan>>;
+}, import("effect/ai/AiError").AiError, ConversationStore | import("effect/ai/LanguageModel").LanguageModel | Exclude<Exclude<Exclude<Exclude<R, import("effect/Tracer").ParentSpan>, never>, import("effect/Tracer").ParentSpan>, never> | Exclude<Exclude<Exclude<Exclude<Tool.HandlersFor<Tools>, import("effect/Tracer").ParentSpan>, never>, import("effect/Tracer").ParentSpan>, never>>;

package/dist/runAgent.js

@@ -5,9 +5,9 @@ import { CurrentModelCallPolicy } from "@xandreed/core";
 import { handoffToMessage, safeKeepFrom } from "@xandreed/core";
 import { runLoop } from "./loop.js";
 const COMPACT_COOLDOWN_TURNS = 3;
-export const runAgent = (config, conversationId, prompt, options) => Effect.gen(function* () {
+export const runAgent = (config, conversationId, userMessage, options) => Effect.gen(function* () {
   const store = yield* ConversationStore;
-  yield* store.append(conversationId, { role: "user", content: prompt }).pipe(Effect.orDie);
+  yield* store.append(conversationId, { role: "user", content: userMessage.text }).pipe(Effect.orDie);
   const fold = yield* store.latestCheckpoint(conversationId).pipe(Effect.orDie), active = yield* store.listActive(conversationId).pipe(Effect.orDie), messages = Option.match(fold, {
     onNone: () => active.map((row) => row.message),
     onSome: (checkpoint) => [
@@ -38,7 +38,7 @@ export const runAgent = (config, conversationId, prompt, options) => Effect.gen(
     yield* Ref.set(mirrorRef, [Option.none(), ...mirror.slice(cut.value)]);
     yield* Ref.set(cooldownRef, COMPACT_COOLDOWN_TURNS);
     return Option.some({ summary, keepFrom: cut.value });
-  }).pipe(Effect.withSpan("engine.compact"), Effect.catchAll(() => Effect.succeed(Option.none()))), result = yield* runLoop({
+  }).pipe(Effect.withSpan("engine.compact"), Effect.catch(() => Effect.succeed(Option.none()))), result = yield* runLoop({
     system: config.system,
     messages,
     toolkit: config.toolkit,
@@ -50,14 +50,14 @@ export const runAgent = (config, conversationId, prompt, options) => Effect.gen(
     ...config.compaction !== void 0 ? { compact: compactWith(config.compaction) } : {},
     ...config.streaming !== void 0 ? { streaming: config.streaming } : {},
     onTail
-  }).pipe(Effect.locally(CurrentPromptCacheKey, Option.some(config.promptCacheKey ?? String(conversationId))));
-  yield* store.recordOutcome(conversationId, result.outcome, result.reason).pipe(Effect.catchAll((error) => Effect.logWarning(`the run's outcome was not recorded: ${error.message}`)));
+  }).pipe(Effect.provideService(CurrentPromptCacheKey, Option.some(config.promptCacheKey ?? String(conversationId))));
+  yield* store.recordOutcome(conversationId, result.outcome, result.reason).pipe(Effect.catch((error) => Effect.logWarning(`the run's outcome was not recorded: ${error.message}`)));
   return result;
 }).pipe(Effect.withSpan("agent.run", {
   attributes: {
     "agent.kind": "run",
     "agent.conversation_id": String(conversationId),
-    "agent.prompt": options?.traceContent === !0 ? prompt.slice(0, 500) : "[redacted]",
-    "agent.prompt_chars": prompt.length
+    "agent.userMessage": options?.traceContent === !0 ? userMessage.text.slice(0, 500) : "[redacted]",
+    "agent.userMessage_chars": userMessage.text.length
   }
-}), Effect.locally(CurrentModelCallPolicy, Option.fromNullable(config.modelPolicy)));
+}), Effect.provideService(CurrentModelCallPolicy, Option.fromNullishOr(config.modelPolicy)));

package/dist/step-loop.adapter.d.ts

@@ -0,0 +1,20 @@
+import { Effect, Layer } from "effect";
+import { HarnessError, StepLoop } from "@xandreed/core";
+import type { RunResult, StepRequest } from "@xandreed/core";
+export declare const STEP_LOOP: {
+    readonly id: "steps";
+    readonly version: "1";
+};
+/**
+ * The step loop over `runLoop`. Per step it publishes `step.started` (with
+ * the active tools), lets the registry publish `tool.*` as calls settle,
+ * records the tail, publishes `step.ended` with the recorded results, then
+ * evaluates the host's completion (`completion.evaluated`). A verdict that
+ * awaits tasks joins them and is evaluated once more. The plan for a step is
+ * computed once and serves the model, the messages and the tool choice; a
+ * host-planned first batch runs without a provider call or a plan.
+ */
+export declare const runSteps: (request: StepRequest) => Effect.Effect<RunResult, HarnessError>;
+export declare const StepLoopLive: Layer.Layer<StepLoop, never, never>;
+/** The step loop as a runtime plugin; the turn supplies everything per run. */
+export declare const stepLoopPlugin: import("@xandreed/core").TypedPlugin<{}, {}, StepLoop, never, never>;

package/dist/step-loop.adapter.js

@@ -0,0 +1,92 @@
+import { LanguageModel, Prompt } from "effect/ai";
+import { Context, Effect, Layer, Option, Ref, Schema } from "effect";
+import { CurrentAgentStep, CurrentPromptCacheKey, definePlugin, harnessDefectsAsFailures, HarnessError, StepLoop } from "@xandreed/core";
+import { runLoop } from "./loop.js";
+export const STEP_LOOP = { id: "steps", version: "1" };
+const resultsOf = (entries) => entries.flatMap((entry) => entry.body._tag === "ToolResult" ? [{ entry: entry.id, toolCallId: entry.body.toolCallId, tool: entry.body.toolName, ok: !entry.body.isError }] : []);
+export const runSteps = (request) => Effect.gen(function* () {
+  const model = yield* Option.match(Context.getOption(request.handlers, LanguageModel.LanguageModel), {
+    onNone: () => Effect.fail(new HarnessError({ code: "loop.model", message: "The turn's services carry no LanguageModel" })),
+    onSome: Effect.succeed
+  }), hasInitial = Option.isSome(request.initial), isPlanned = (step) => hasInitial && step === 0, cached = yield* Ref.make(Option.none()), lastUsage = yield* Ref.make(Option.none()), results = yield* Ref.make(new Map), ended = yield* Ref.make(new Set), steps = yield* Ref.make(0), currentStep = Effect.service(CurrentAgentStep).pipe(Effect.map(Option.getOrElse(() => 0))), infoOf = (step, activeTools) => Ref.get(lastUsage).pipe(Effect.map((usage) => ({ stepIndex: step, activeTools, lastUsage: usage }))), planFor = (info) => Ref.get(cached).pipe(Effect.flatMap((current) => Option.isSome(current) && current.value.step === info.stepIndex ? Effect.succeed(current.value.plan) : request.plan(info).pipe(Effect.tap((plan) => Ref.set(cached, Option.some({ step: info.stepIndex, plan })))))), endStep = (step, status) => Effect.gen(function* () {
+    const done = yield* Ref.get(ended);
+    if (done.has(step))
+      return;
+    yield* Ref.set(ended, new Set([...done, step]));
+    const recorded = (yield* Ref.get(results)).get(step) ?? [];
+    yield* request.events.publish({ _tag: "step.ended", step, status, results: recorded });
+  }), evaluate = (info) => request.completion(info).pipe(Effect.tap((verdict) => request.events.publish({ _tag: "completion.evaluated", step: info.stepIndex, verdict }))), isComplete = () => Effect.gen(function* () {
+    const step = yield* currentStep;
+    yield* endStep(step, "completed");
+    const info = yield* infoOf(step, yield* request.tools.active), first = yield* evaluate(info);
+    if (first.complete || first.awaiting.length === 0)
+      return first.complete;
+    yield* request.tasks.await(first.awaiting);
+    return (yield* evaluate(info)).complete;
+  }).pipe(Effect.orDie), onEvent = (event) => {
+    if (event.type === "assistant_delta")
+      return request.events.publish({ _tag: "assistant.delta", step: event.turnIndex, channel: event.channel, id: event.id, delta: event.delta }).pipe(Effect.orDie);
+    if (event.type === "assistant_message")
+      return Effect.gen(function* () {
+        if (!isPlanned(event.turnIndex))
+          yield* Ref.set(lastUsage, Option.some(event.usage));
+        yield* request.events.publish({
+          _tag: "assistant.message",
+          step: event.turnIndex,
+          text: event.text,
+          reasoning: event.reasoning,
+          model: Option.fromNullishOr(event.model),
+          toolCalls: event.toolCalls.map((call) => ({ id: call.id, tool: call.toolName, input: call.args })),
+          usage: event.usage
+        });
+      }).pipe(Effect.orDie);
+    if (event.type === "turn_end") {
+      const ending = endStep(event.turnIndex, event.status);
+      return event.status === "completed" ? ending.pipe(Effect.orDie) : ending.pipe(Effect.catchCause(() => Effect.void));
+    }
+    return Effect.void;
+  }, loop = runLoop({
+    system: "",
+    messages: [],
+    toolkit: request.tools.toolkit,
+    maxSteps: request.limits.maxSteps,
+    toolConcurrency: request.limits.toolConcurrency,
+    streaming: request.limits.streaming,
+    requireCompletion: request.limits.requireCompletion,
+    pollableTools: request.tools.pollable,
+    ...Option.match(request.correctives, { onNone: () => ({}), onSome: (correctives) => ({ correctives }) }),
+    ...Option.match(request.initial, { onNone: () => ({}), onSome: (batch) => ({ initialStep: batch.calls }) }),
+    activeTools: () => Effect.gen(function* () {
+      const step = yield* currentStep, active = yield* request.tools.active;
+      yield* Ref.update(steps, (count) => Math.max(count, step + 1));
+      yield* request.events.publish({ _tag: "step.started", step, planned: isPlanned(step), activeTools: active });
+      return active;
+    }).pipe(Effect.orDie),
+    prepareModel: (step) => infoOf(step.stepIndex, step.activeTools).pipe(Effect.flatMap(planFor), Effect.map((plan) => ({ model: Option.getOrElse(plan.model, () => model), system: Prompt.make([{ role: "system", content: plan.system }]) })), Effect.orDie),
+    render: (view) => isPlanned(view.stepIndex) ? Effect.succeed([]) : planFor(view).pipe(Effect.map((plan) => plan.messages), Effect.orDie),
+    stepDirective: (view) => isPlanned(view.stepIndex) ? Effect.succeed({ toolChoice: Option.none() }) : planFor(view).pipe(Effect.map((plan) => ({ toolChoice: plan.toolChoice })), Effect.orDie),
+    beforeDispatch: (step, actual) => request.dispatch(step, actual).pipe(Effect.orDie),
+    isComplete,
+    pendingInput: () => request.steering.pipe(Effect.orDie),
+    onTail: (messages) => Effect.gen(function* () {
+      const step = yield* currentStep, entries = yield* request.record(step, messages), recorded = resultsOf(entries);
+      yield* recorded.length === 0 ? Effect.void : Ref.update(results, (all) => new Map([...all, [step, [...all.get(step) ?? [], ...recorded]]]));
+      return [];
+    }).pipe(Effect.orDie),
+    onEvent
+  }), handlers = request.handlers, result = yield* harnessDefectsAsFailures(loop.pipe(Effect.provide(handlers), Effect.provideService(LanguageModel.LanguageModel, model), Effect.provideService(CurrentPromptCacheKey, request.cacheKey), Effect.mapError((error) => error instanceof HarnessError ? error : new HarnessError({ code: "loop.failed", message: String(error) }))));
+  return {
+    outcome: result.outcome === "ok" ? "completed" : "partial",
+    reason: result.reason,
+    text: result.finalText,
+    steps: yield* Ref.get(steps)
+  };
+}), StepLoopLive = Layer.succeed(StepLoop, StepLoop.of({ ...STEP_LOOP, run: runSteps })), stepLoopPlugin = definePlugin({
+  id: "@xandreed/plugin-agent-loop/steps",
+  version: "0.11.0",
+  scope: "runtime",
+  config: Schema.Struct({}),
+  defaults: {},
+  provides: [StepLoop],
+  layer: () => StepLoopLive
+});

package/dist/step-loop.adapter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xandreed/plugin-agent-loop",
-  "version": "0.4.0",
+  "version": "0.11.0",
   "type": "module",
   "main": "./dist/index.js",
   "exports": {
@@ -10,9 +10,8 @@
     }
   },
   "dependencies": {
-    "@xandreed/core": "0.4.0",
-    "@effect/ai": "0.35.0",
-    "effect": "3.21.4"
+    "@xandreed/core": "0.11.0",
+    "effect": "4.0.0-rc.118"
   },
   "private": false,
   "types": "./dist/index.d.ts",
@@ -24,6 +23,7 @@
     "LICENSE"
   ],
   "engines": {
+    "node": ">=24",
     "bun": ">=1.3.0"
   },
   "license": "MIT"