woozlit 2.3.0 → 2.3.1

package/src/session/processor.ts

@@ -1,972 +0,0 @@
-import { Cause, Deferred, Effect, Layer, Context, Scope } from "effect"
-import * as Stream from "effect/Stream"
-import { Agent } from "@/agent/agent"
-import { SYSTEM_SPAWNED_AGENT_TYPES } from "@/agent/config"
-import { Bus } from "@/bus"
-import { Metrics } from "@/metrics"
-import { Config } from "@/config"
-import { Permission } from "@/permission"
-import { Plugin } from "@/plugin"
-import { Snapshot } from "@/snapshot"
-import * as Session from "./session"
-import { LLM } from "./llm"
-import { MessageV2 } from "./message-v2"
-import { isOverflow } from "./overflow"
-import { PartID } from "./schema"
-import type { SessionID } from "./schema"
-import { SessionRetry } from "./retry"
-import { SessionStatus } from "./status"
-import { SessionSummary } from "./summary"
-import type { Provider } from "@/provider"
-import { Question } from "@/question"
-import { errorMessage } from "@/util/error"
-import { Log } from "@/util"
-import { isRecord } from "@/util/record"
-
-const DOOM_LOOP_THRESHOLD = 3
-const log = Log.create({ service: "session.processor" })
-
-export type Result = "overflow" | "stop" | "continue"
-
-export type Event = LLM.Event
-
-/**
- * A proposed tool call captured from a candidate stream (max mode), before
- * any execution. `input` is the parsed tool arguments.
- */
-export type ProposedToolCall = {
-  toolCallId: string
-  toolName: string
-  input: Record<string, any>
-  providerMetadata?: Record<string, any>
-}
-
-/**
- * The winning candidate selected by the judge in max mode. Captures the full
- * reasoning + text + proposed tool calls of one candidate stream so the
- * processor can replay it: lay down the reasoning/text parts and actually
- * execute the tool calls via the execute-bearing tools.
- */
-export type ReplayInput = {
-  reasoning?: string
-  reasoningMetadata?: Record<string, any>
-  text?: string
-  textMetadata?: Record<string, any>
-  toolCalls: ProposedToolCall[]
-  finishReason: string
-  usage?: any
-  providerMetadata?: Record<string, any>
-  /** Execute-bearing tools (from resolveTools) used to run the winner's calls. */
-  tools: Record<string, { execute?: (input: any, options: any) => Promise<any> }>
-  /** Model messages passed to tool execute contexts. */
-  messages: any[]
-  /**
-   * Max-mode selection metadata. When set, a short note is prepended to the
-   * replayed reasoning so the user can see the ensemble happened and which
-   * candidate won. `winner` is 0-based.
-   */
-  selection?: { winner: number; total: number }
-  /**
-   * Real wall-clock duration (ms) the winning candidate spent thinking, so the
-   * replayed reasoning part shows a meaningful duration instead of the ~1ms
-   * synthetic replay time. Optional.
-   */
-  thinkingMs?: number
-  /**
-   * Max-mode ensemble overhead: the cost and token counts of the losing
-   * candidates + the judge call. These are real spend but consume NO context,
-   * so they are added to `cost` and the ModelCall metric ONLY — never to the
-   * message's `tokens`, which must stay the winner's real footprint so context
-   * overflow / prune estimation stays correct.
-   */
-  overhead?: { cost: number; tokensIn: number; tokensOut: number }
-}
-
-export interface Handle {
-  readonly message: MessageV2.Assistant
-  readonly updateToolCall: (
-    toolCallID: string,
-    update: (part: MessageV2.ToolPart) => MessageV2.ToolPart,
-  ) => Effect.Effect<MessageV2.ToolPart | undefined>
-  readonly completeToolCall: (
-    toolCallID: string,
-    output: {
-      title: string
-      metadata: Record<string, any>
-      output: string
-      attachments?: MessageV2.FilePart[]
-    },
-  ) => Effect.Effect<void>
-  readonly process: (streamInput: LLM.StreamInput) => Effect.Effect<Result>
-  /**
-   * Replay a pre-selected candidate (max mode): synthesize the stream events a
-   * real model call would have produced for the winner — reasoning, text, then
-   * each tool call (input-start → call → execute → result) — and run them
-   * through the same event handler used by `process`. Tool execution, snapshot
-   * tracking, permission asks and metrics are all reused. Returns the same
-   * Result contract as `process`.
-   */
-  readonly replay: (input: ReplayInput) => Effect.Effect<Result>
-}
-
-export type AgentMetrics = {
-  tokens_in: number
-  tokens_out: number
-  files_changed: number
-}
-
-type Input = {
-  assistantMessage: MessageV2.Assistant
-  sessionID: SessionID
-  model: Provider.Model
-  agentMetrics?: AgentMetrics
-}
-
-export interface Interface {
-  readonly create: (input: Input) => Effect.Effect<Handle>
-}
-
-type ToolCall = {
-  partID: MessageV2.ToolPart["id"]
-  messageID: MessageV2.ToolPart["messageID"]
-  sessionID: MessageV2.ToolPart["sessionID"]
-  done: Deferred.Deferred<void>
-}
-
-interface ProcessorContext extends Input {
-  toolcalls: Record<string, ToolCall>
-  shouldBreak: boolean
-  snapshot: string | undefined
-  blocked: boolean
-  needsOverflowHandling: boolean
-  currentText: MessageV2.TextPart | undefined
-  reasoningMap: Record<string, MessageV2.ReasoningPart>
-  stepStartedAt: number | undefined
-  firstTokenAt: number | undefined
-  stepPartIds: PartID[]
-}
-
-type StreamEvent = Event
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/SessionProcessor") {}
-
-export const layer: Layer.Layer<
-  Service,
-  never,
-  | Session.Service
-  | Config.Service
-  | Bus.Service
-  | Snapshot.Service
-  | Agent.Service
-  | LLM.Service
-  | Permission.Service
-  | Plugin.Service
-  | SessionSummary.Service
-  | SessionStatus.Service
-> = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const session = yield* Session.Service
-    const config = yield* Config.Service
-    const bus = yield* Bus.Service
-    const snapshot = yield* Snapshot.Service
-    const agents = yield* Agent.Service
-    const llm = yield* LLM.Service
-    const permission = yield* Permission.Service
-    const plugin = yield* Plugin.Service
-    const summary = yield* SessionSummary.Service
-    const scope = yield* Scope.Scope
-    const status = yield* SessionStatus.Service
-
-    const create = Effect.fn("SessionProcessor.create")(function* (input: Input) {
-      // Pre-capture snapshot before the LLM stream starts. The AI SDK
-      // may execute tools internally before emitting start-step events,
-      // so capturing inside the event handler can be too late.
-      const initialSnapshot = yield* snapshot.track()
-      const ctx: ProcessorContext = {
-        assistantMessage: input.assistantMessage,
-        sessionID: input.sessionID,
-        model: input.model,
-        agentMetrics: input.agentMetrics,
-        toolcalls: {},
-        shouldBreak: false,
-        snapshot: initialSnapshot,
-        blocked: false,
-        needsOverflowHandling: false,
-        currentText: undefined,
-        reasoningMap: {},
-        stepStartedAt: undefined,
-        firstTokenAt: undefined,
-        stepPartIds: [],
-      }
-      let aborted = false
-      // Only the main agent owns session-level status. Subagents (explore,
-      // general, checkpoint-writer, etc.) share the parent sessionID but their
-      // run-state onIdle deliberately does NOT reset status (run-state.ts) — so
-      // if a subagent's stream sets session status here, nothing ever clears it
-      // and the TUI spinner stays spinning after the main agent has finished.
-      const isMain = !ctx.assistantMessage.agentID || ctx.assistantMessage.agentID === "main"
-      const slog = log.clone().tag("session.id", input.sessionID).tag("messageID", input.assistantMessage.id)
-
-      const parse = (e: unknown) =>
-        MessageV2.fromError(e, {
-          providerID: input.model.providerID,
-          aborted,
-        })
-
-      const settleToolCall = Effect.fn("SessionProcessor.settleToolCall")(function* (toolCallID: string) {
-        const done = ctx.toolcalls[toolCallID]?.done
-        delete ctx.toolcalls[toolCallID]
-        if (done) yield* Deferred.succeed(done, undefined).pipe(Effect.ignore)
-      })
-
-      const readToolCall = Effect.fn("SessionProcessor.readToolCall")(function* (toolCallID: string) {
-        const call = ctx.toolcalls[toolCallID]
-        if (!call) return
-        const part = yield* session.getPart({
-          partID: call.partID,
-          messageID: call.messageID,
-          sessionID: call.sessionID,
-        })
-        if (!part || part.type !== "tool") {
-          delete ctx.toolcalls[toolCallID]
-          return
-        }
-        return { call, part }
-      })
-
-      const updateToolCall = Effect.fn("SessionProcessor.updateToolCall")(function* (
-        toolCallID: string,
-        update: (part: MessageV2.ToolPart) => MessageV2.ToolPart,
-      ) {
-        const match = yield* readToolCall(toolCallID)
-        if (!match) return
-        const part = yield* session.updatePart(update(match.part))
-        ctx.toolcalls[toolCallID] = {
-          ...match.call,
-          partID: part.id,
-          messageID: part.messageID,
-          sessionID: part.sessionID,
-        }
-        return part
-      })
-
-      const completeToolCall = Effect.fn("SessionProcessor.completeToolCall")(function* (
-        toolCallID: string,
-        output: {
-          title: string
-          metadata: Record<string, any>
-          output: string
-          attachments?: MessageV2.FilePart[]
-        },
-      ) {
-        const match = yield* readToolCall(toolCallID)
-        if (!match || match.part.state.status !== "running") return
-        yield* session.updatePart({
-          ...match.part,
-          state: {
-            status: "completed",
-            input: match.part.state.input,
-            output: output.output,
-            metadata: output.metadata,
-            title: output.title,
-            time: { start: match.part.state.time.start, end: Date.now() },
-            attachments: output.attachments,
-          },
-        })
-        yield* settleToolCall(toolCallID)
-      })
-
-      const failToolCall = Effect.fn("SessionProcessor.failToolCall")(function* (toolCallID: string, error: unknown) {
-        const match = yield* readToolCall(toolCallID)
-        if (!match || match.part.state.status !== "running") return false
-        yield* session.updatePart({
-          ...match.part,
-          state: {
-            status: "error",
-            input: match.part.state.input,
-            error: errorMessage(error),
-            time: { start: match.part.state.time.start, end: Date.now() },
-          },
-        })
-        if (error instanceof Permission.RejectedError || error instanceof Question.RejectedError) {
-          ctx.blocked = ctx.shouldBreak
-        }
-        yield* settleToolCall(toolCallID)
-        return true
-      })
-
-      const handleEvent = Effect.fnUntraced(function* (value: StreamEvent) {
-        switch (value.type) {
-          case "start":
-            if (isMain) yield* status.set(ctx.sessionID, { type: "busy" })
-            return
-
-          case "reasoning-start":
-            if (value.id in ctx.reasoningMap) return
-            ctx.reasoningMap[value.id] = {
-              id: PartID.ascending(),
-              messageID: ctx.assistantMessage.id,
-              sessionID: ctx.assistantMessage.sessionID,
-              type: "reasoning",
-              text: "",
-              // Replayed candidates (max mode) carry a backdated start so the
-              // displayed thinking duration reflects the real candidate latency
-              // instead of the ~1ms synthetic replay. Live streams omit `time`.
-              time: { start: (value as { time?: { start: number } }).time?.start ?? Date.now() },
-              metadata: value.providerMetadata,
-            }
-            yield* session.updatePart(ctx.reasoningMap[value.id])
-            ctx.stepPartIds.push(ctx.reasoningMap[value.id].id)
-            return
-
-          case "reasoning-delta":
-            if (!ctx.firstTokenAt) ctx.firstTokenAt = Date.now()
-            if (!(value.id in ctx.reasoningMap)) return
-            ctx.reasoningMap[value.id].text += value.text
-            if (value.providerMetadata) ctx.reasoningMap[value.id].metadata = value.providerMetadata
-            yield* session.updatePartDelta({
-              sessionID: ctx.reasoningMap[value.id].sessionID,
-              messageID: ctx.reasoningMap[value.id].messageID,
-              partID: ctx.reasoningMap[value.id].id,
-              field: "text",
-              delta: value.text,
-            })
-            return
-
-          case "reasoning-end":
-            if (!(value.id in ctx.reasoningMap)) return
-            // oxlint-disable-next-line no-self-assign -- reactivity trigger
-            ctx.reasoningMap[value.id].text = ctx.reasoningMap[value.id].text
-            ctx.reasoningMap[value.id].time = { ...ctx.reasoningMap[value.id].time, end: Date.now() }
-            if (value.providerMetadata) ctx.reasoningMap[value.id].metadata = value.providerMetadata
-            yield* session.updatePart(ctx.reasoningMap[value.id])
-            delete ctx.reasoningMap[value.id]
-            return
-
-          case "tool-input-start":
-            if (ctx.assistantMessage.summary) {
-              throw new Error(`Tool call not allowed while generating summary: ${value.toolName}`)
-            }
-            const part = yield* session.updatePart({
-              id: ctx.toolcalls[value.id]?.partID ?? PartID.ascending(),
-              messageID: ctx.assistantMessage.id,
-              sessionID: ctx.assistantMessage.sessionID,
-              type: "tool",
-              tool: value.toolName,
-              callID: value.id,
-              state: { status: "pending", input: {}, raw: "" },
-              metadata: value.providerExecuted ? { providerExecuted: true } : undefined,
-            } satisfies MessageV2.ToolPart)
-            ctx.stepPartIds.push(part.id)
-            ctx.toolcalls[value.id] = {
-              done: yield* Deferred.make<void>(),
-              partID: part.id,
-              messageID: part.messageID,
-              sessionID: part.sessionID,
-            }
-            return
-
-          case "tool-input-delta":
-            return
-
-          case "tool-input-end":
-            return
-
-          case "tool-call": {
-            if (ctx.assistantMessage.summary) {
-              throw new Error(`Tool call not allowed while generating summary: ${value.toolName}`)
-            }
-            yield* updateToolCall(value.toolCallId, (match) => ({
-              ...match,
-              tool: value.toolName,
-              state: {
-                ...match.state,
-                status: "running",
-                input: value.input,
-                time: { start: Date.now() },
-              },
-              metadata: match.metadata?.providerExecuted
-                ? { ...value.providerMetadata, providerExecuted: true }
-                : value.providerMetadata,
-            }))
-
-            const parts = MessageV2.parts(ctx.assistantMessage.id)
-            const recentParts = parts.slice(-DOOM_LOOP_THRESHOLD)
-
-            if (
-              recentParts.length !== DOOM_LOOP_THRESHOLD ||
-              !recentParts.every(
-                (part) =>
-                  part.type === "tool" &&
-                  part.tool === value.toolName &&
-                  part.state.status !== "pending" &&
-                  JSON.stringify(part.state.input) === JSON.stringify(value.input),
-              )
-            ) {
-              return
-            }
-
-            const agent = yield* agents.get(ctx.assistantMessage.agent)
-            yield* permission.ask({
-              permission: "doom_loop",
-              patterns: [value.toolName],
-              sessionID: ctx.assistantMessage.sessionID,
-              metadata: { tool: value.toolName, input: value.input },
-              always: [value.toolName],
-              ruleset: agent.permission,
-              // System-spawned background agents have no human to answer — fail clean.
-              interactive: !SYSTEM_SPAWNED_AGENT_TYPES.has(ctx.assistantMessage.agent),
-            })
-            return
-          }
-
-          case "tool-result": {
-            yield* completeToolCall(value.toolCallId, value.output)
-            return
-          }
-
-          case "tool-error": {
-            yield* failToolCall(value.toolCallId, value.error)
-            yield* bus
-              .publish(Metrics.ToolCall, {
-                sessionID: ctx.sessionID,
-                tool_name: value.toolName,
-                input_bytes: Metrics.jsonByteLength(value.input),
-                output_bytes: 0,
-                tool_call_id: value.toolCallId,
-                tool_call_status: "error",
-              })
-              .pipe(Effect.ignore)
-            return
-          }
-
-          case "error":
-            throw value.error
-
-          case "start-step":
-            ctx.stepStartedAt = Date.now()
-            ctx.firstTokenAt = undefined
-            if (!ctx.snapshot) ctx.snapshot = yield* snapshot.track()
-            const stepStartPartId = PartID.ascending()
-            yield* session.updatePart({
-              id: stepStartPartId,
-              messageID: ctx.assistantMessage.id,
-              sessionID: ctx.sessionID,
-              snapshot: ctx.snapshot,
-              type: "step-start",
-            })
-            ctx.stepPartIds.push(stepStartPartId)
-            return
-
-          case "finish-step": {
-            const usage = Session.getUsage({
-              model: ctx.model,
-              usage: value.usage,
-              metadata: value.providerMetadata,
-            })
-            ctx.assistantMessage.finish = value.finishReason
-            ctx.assistantMessage.cost += usage.cost
-            ctx.assistantMessage.tokens = usage.tokens
-            yield* session.updatePart({
-              id: PartID.ascending(),
-              reason: value.finishReason,
-              snapshot: yield* snapshot.track(),
-              messageID: ctx.assistantMessage.id,
-              sessionID: ctx.assistantMessage.sessionID,
-              type: "step-finish",
-              tokens: usage.tokens,
-              cost: usage.cost,
-            })
-            yield* session.updateMessage(ctx.assistantMessage)
-            let stepFilesChanged = 0
-            if (ctx.snapshot) {
-              const patch = yield* snapshot.patch(ctx.snapshot)
-              stepFilesChanged = patch.files.length
-              if (patch.files.length) {
-                yield* session.updatePart({
-                  id: PartID.ascending(),
-                  messageID: ctx.assistantMessage.id,
-                  sessionID: ctx.sessionID,
-                  type: "patch",
-                  hash: patch.hash,
-                  files: patch.files,
-                })
-              }
-              ctx.snapshot = undefined
-            }
-            const stepTokensIn = usage.tokens.input + usage.tokens.cache.read + usage.tokens.cache.write
-            const stepTokensOut = usage.tokens.output + usage.tokens.reasoning
-            if (ctx.agentMetrics) {
-              ctx.agentMetrics.tokens_in += stepTokensIn
-              ctx.agentMetrics.tokens_out += stepTokensOut
-              ctx.agentMetrics.files_changed += stepFilesChanged
-            }
-            yield* bus
-              .publish(Metrics.ModelCall, {
-                sessionID: ctx.sessionID,
-                finish_reason: value.finishReason,
-                ttft_ms:
-                  ctx.firstTokenAt && ctx.stepStartedAt ? ctx.firstTokenAt - ctx.stepStartedAt : undefined,
-                latency_ms: ctx.stepStartedAt ? Date.now() - ctx.stepStartedAt : 0,
-                cached_read_tokens: usage.tokens.cache.read,
-                model_id: ctx.model.id,
-                provider: ctx.model.providerID,
-                total_tokens_in: stepTokensIn,
-                total_tokens_out: stepTokensOut,
-              })
-              .pipe(Effect.ignore)
-            yield* summary
-              .summarize({
-                sessionID: ctx.sessionID,
-                messageID: ctx.assistantMessage.parentID,
-              })
-              .pipe(Effect.ignore, Effect.forkIn(scope))
-            if (
-              !ctx.assistantMessage.summary &&
-              isOverflow({ cfg: yield* config.get(), tokens: usage.tokens, model: ctx.model })
-            ) {
-              ctx.needsOverflowHandling = true
-            }
-            return
-          }
-
-          case "text-start":
-            ctx.currentText = {
-              id: PartID.ascending(),
-              messageID: ctx.assistantMessage.id,
-              sessionID: ctx.assistantMessage.sessionID,
-              type: "text",
-              text: "",
-              time: { start: Date.now() },
-              metadata: value.providerMetadata,
-            }
-            yield* session.updatePart(ctx.currentText)
-            ctx.stepPartIds.push(ctx.currentText.id)
-            return
-
-          case "text-delta":
-            if (!ctx.firstTokenAt) ctx.firstTokenAt = Date.now()
-            if (!ctx.currentText) return
-            ctx.currentText.text += value.text
-            if (value.providerMetadata) ctx.currentText.metadata = value.providerMetadata
-            yield* session.updatePartDelta({
-              sessionID: ctx.currentText.sessionID,
-              messageID: ctx.currentText.messageID,
-              partID: ctx.currentText.id,
-              field: "text",
-              delta: value.text,
-            })
-            return
-
-          case "text-end":
-            if (!ctx.currentText) return
-            // oxlint-disable-next-line no-self-assign -- reactivity trigger
-            ctx.currentText.text = ctx.currentText.text
-            ctx.currentText.text = (yield* plugin.trigger(
-              "experimental.text.complete",
-              {
-                sessionID: ctx.sessionID,
-                messageID: ctx.assistantMessage.id,
-                partID: ctx.currentText.id,
-              },
-              { text: ctx.currentText.text },
-            )).text
-            {
-              const end = Date.now()
-              ctx.currentText.time = { start: ctx.currentText.time?.start ?? end, end }
-            }
-            if (value.providerMetadata) ctx.currentText.metadata = value.providerMetadata
-            yield* session.updatePart(ctx.currentText)
-            ctx.currentText = undefined
-            return
-
-          case "finish":
-            return
-
-          default:
-            slog.info("unhandled", { event: value.type, value })
-            return
-        }
-      })
-
-      const cleanup = Effect.fn("SessionProcessor.cleanup")(function* () {
-        if (ctx.snapshot) {
-          const patch = yield* snapshot.patch(ctx.snapshot)
-          if (patch.files.length) {
-            yield* session.updatePart({
-              id: PartID.ascending(),
-              messageID: ctx.assistantMessage.id,
-              sessionID: ctx.sessionID,
-              type: "patch",
-              hash: patch.hash,
-              files: patch.files,
-            })
-          }
-          ctx.snapshot = undefined
-        }
-
-        if (ctx.currentText) {
-          const end = Date.now()
-          ctx.currentText.time = { start: ctx.currentText.time?.start ?? end, end }
-          yield* session.updatePart(ctx.currentText)
-          ctx.currentText = undefined
-        }
-
-        for (const part of Object.values(ctx.reasoningMap)) {
-          const end = Date.now()
-          yield* session.updatePart({
-            ...part,
-            time: { start: part.time.start ?? end, end },
-          })
-        }
-        ctx.reasoningMap = {}
-
-        yield* Effect.forEach(
-          Object.values(ctx.toolcalls),
-          (call) => Deferred.await(call.done).pipe(Effect.timeout("250 millis"), Effect.ignore),
-          { concurrency: "unbounded" },
-        )
-
-        for (const toolCallID of Object.keys(ctx.toolcalls)) {
-          const match = yield* readToolCall(toolCallID)
-          if (!match) continue
-          const part = match.part
-          const end = Date.now()
-          const metadata = "metadata" in part.state && isRecord(part.state.metadata) ? part.state.metadata : {}
-          yield* session.updatePart({
-            ...part,
-            state: {
-              ...part.state,
-              status: "error",
-              error: "Tool execution aborted",
-              metadata: { ...metadata, interrupted: true },
-              time: { start: "time" in part.state ? part.state.time.start : end, end },
-            },
-          })
-        }
-        ctx.toolcalls = {}
-        ctx.assistantMessage.time.completed = Date.now()
-        yield* session.updateMessage(ctx.assistantMessage)
-      })
-
-      const halt = Effect.fn("SessionProcessor.halt")(function* (e: unknown) {
-        slog.error("process", { error: errorMessage(e), stack: e instanceof Error ? e.stack : undefined })
-        const error = parse(e)
-        if (MessageV2.ContextOverflowError.isInstance(error)) {
-          ctx.needsOverflowHandling = true
-          yield* bus.publish(Session.Event.Error, { sessionID: ctx.sessionID, error })
-          return
-        }
-        ctx.assistantMessage.error = error
-        yield* bus.publish(Session.Event.Error, {
-          sessionID: ctx.assistantMessage.sessionID,
-          error: ctx.assistantMessage.error,
-        })
-        if (isMain) yield* status.set(ctx.sessionID, { type: "idle" })
-      })
-
-      const process = Effect.fn("SessionProcessor.process")(function* (streamInput: LLM.StreamInput) {
-        slog.info("process")
-        ctx.needsOverflowHandling = false
-        ctx.shouldBreak = (yield* config.get()).experimental?.continue_loop_on_deny !== true
-
-        return yield* Effect.gen(function* () {
-          yield* Effect.gen(function* () {
-            ctx.currentText = undefined
-            ctx.reasoningMap = {}
-            ctx.stepPartIds = []
-            ctx.toolcalls = {}
-            const stream = llm.stream(streamInput)
-
-            yield* stream.pipe(
-              Stream.tap((event) =>
-                Effect.gen(function* () {
-                  slog.info("received stream event", {
-                    type: event.type,
-                    finishReason: event.type === "finish-step" ? event.finishReason : undefined,
-                    toolName: "toolName" in event ? event.toolName : undefined,
-                    textLength: "text" in event ? event.text.length : undefined,
-                  })
-                  yield* handleEvent(event)
-                })
-              ),
-              Stream.takeUntil(() => ctx.needsOverflowHandling),
-              Stream.runDrain,
-            )
-          }).pipe(
-            Effect.onInterrupt(() =>
-              Effect.gen(function* () {
-                aborted = true
-                if (!ctx.assistantMessage.error) {
-                  yield* halt(new DOMException("Aborted", "AbortError"))
-                }
-              }),
-            ),
-            Effect.catchCauseIf(
-              (cause) => !Cause.hasInterruptsOnly(cause),
-              (cause) => Effect.fail(Cause.squash(cause)),
-            ),
-            Effect.tapError(() =>
-              Effect.gen(function* () {
-                for (const partId of ctx.stepPartIds) {
-                  yield* session.removePart({
-                    sessionID: ctx.sessionID,
-                    messageID: ctx.assistantMessage.id,
-                    partID: partId,
-                  })
-                }
-                ctx.stepPartIds = []
-              }),
-            ),
-            Effect.retry(
-              SessionRetry.policy({
-                parse,
-                set: (info) =>
-                  isMain
-                    ? status.set(ctx.sessionID, {
-                        type: "retry",
-                        attempt: info.attempt,
-                        message: info.message,
-                        next: info.next,
-                      })
-                    : Effect.void,
-              }),
-            ),
-            Effect.catch(halt),
-            Effect.ensuring(cleanup()),
-          )
-
-          if (ctx.needsOverflowHandling) return "overflow"
-          if (ctx.blocked || ctx.assistantMessage.error) return "stop"
-          return "continue"
-        })
-      })
-
-      const replay = Effect.fn("SessionProcessor.replay")(function* (input: ReplayInput) {
-        slog.info("replay", { toolCalls: input.toolCalls.length, finish: input.finishReason })
-        ctx.needsOverflowHandling = false
-        ctx.shouldBreak = (yield* config.get()).experimental?.continue_loop_on_deny !== true
-
-        const ctrl = new AbortController()
-
-        const emptyUsage = {
-          inputTokens: 0,
-          outputTokens: 0,
-          totalTokens: 0,
-        }
-
-        return yield* Effect.gen(function* () {
-          yield* Effect.gen(function* () {
-            ctx.currentText = undefined
-            ctx.reasoningMap = {}
-
-            // Mirror a real model call: start → start-step → reasoning → text →
-            // (tool-input-start → tool-call → execute → tool-result)* → finish-step
-            yield* handleEvent({ type: "start" } as StreamEvent)
-            yield* handleEvent({
-              type: "start-step",
-              request: {},
-              warnings: [],
-            } as unknown as StreamEvent)
-
-            const selectionNote = input.selection
-              ? `[max mode] selected candidate ${input.selection.winner + 1} of ${input.selection.total}`
-              : undefined
-            const reasoningText = [selectionNote, input.reasoning].filter(Boolean).join("\n\n")
-
-            if (reasoningText) {
-              const rid = "reasoning-replay"
-              const backdatedStart = input.thinkingMs ? Date.now() - input.thinkingMs : undefined
-              yield* handleEvent({
-                type: "reasoning-start",
-                id: rid,
-                providerMetadata: input.reasoningMetadata,
-                ...(backdatedStart ? { time: { start: backdatedStart } } : {}),
-              } as unknown as StreamEvent)
-              yield* handleEvent({
-                type: "reasoning-delta",
-                id: rid,
-                text: reasoningText,
-                providerMetadata: input.reasoningMetadata,
-              } as unknown as StreamEvent)
-              yield* handleEvent({
-                type: "reasoning-end",
-                id: rid,
-                providerMetadata: input.reasoningMetadata,
-              } as unknown as StreamEvent)
-            }
-
-            if (input.text) {
-              const tid = "text-replay"
-              yield* handleEvent({
-                type: "text-start",
-                id: tid,
-                providerMetadata: input.textMetadata,
-              } as unknown as StreamEvent)
-              yield* handleEvent({
-                type: "text-delta",
-                id: tid,
-                text: input.text,
-                providerMetadata: input.textMetadata,
-              } as unknown as StreamEvent)
-              yield* handleEvent({
-                type: "text-end",
-                id: tid,
-                providerMetadata: input.textMetadata,
-              } as unknown as StreamEvent)
-            }
-
-            for (const call of input.toolCalls) {
-              if (ctx.needsOverflowHandling) break
-              yield* handleEvent({
-                type: "tool-input-start",
-                id: call.toolCallId,
-                toolName: call.toolName,
-                providerMetadata: call.providerMetadata,
-              } as unknown as StreamEvent)
-              yield* handleEvent({
-                type: "tool-call",
-                toolCallId: call.toolCallId,
-                toolName: call.toolName,
-                input: call.input,
-                providerMetadata: call.providerMetadata,
-              } as unknown as StreamEvent)
-
-              const t = input.tools[call.toolName]
-              if (!t || !t.execute) {
-                yield* handleEvent({
-                  type: "tool-error",
-                  toolCallId: call.toolCallId,
-                  toolName: call.toolName,
-                  input: call.input,
-                  error: new Error(`Tool "${call.toolName}" has no executor`),
-                } as unknown as StreamEvent)
-                continue
-              }
-
-              const outcome = yield* Effect.tryPromise({
-                try: () =>
-                  t.execute!(call.input, {
-                    toolCallId: call.toolCallId,
-                    messages: input.messages,
-                    abortSignal: ctrl.signal,
-                  }),
-                catch: (e) => e,
-              }).pipe(
-                Effect.map((output) => ({ ok: true as const, output })),
-                Effect.catch((error) => Effect.succeed({ ok: false as const, error })),
-              )
-
-              if (!outcome.ok) {
-                yield* handleEvent({
-                  type: "tool-error",
-                  toolCallId: call.toolCallId,
-                  toolName: call.toolName,
-                  input: call.input,
-                  error: outcome.error,
-                } as unknown as StreamEvent)
-              } else {
-                // The execute closure resolves with { title, metadata, output, attachments }.
-                // Feeding it through the tool-result handler completes the part
-                // (unless execute already completed it on abort — completeToolCall
-                // is a no-op once the part is no longer "running").
-                yield* handleEvent({
-                  type: "tool-result",
-                  toolCallId: call.toolCallId,
-                  toolName: call.toolName,
-                  input: call.input,
-                  output: outcome.output,
-                } as unknown as StreamEvent)
-              }
-            }
-
-            yield* handleEvent({
-              type: "finish-step",
-              usage: input.usage ?? emptyUsage,
-              finishReason: input.finishReason,
-              providerMetadata: input.providerMetadata,
-            } as unknown as StreamEvent)
-
-            // Account for ensemble overhead (losing candidates + judge): real
-            // spend that consumed no context. Add it to cost + agent metrics +
-            // a supplementary ModelCall metric, but NOT to message.tokens (set
-            // by the finish-step above from the winner only) so context
-            // estimators stay honest.
-            if (input.overhead && (input.overhead.cost > 0 || input.overhead.tokensIn > 0 || input.overhead.tokensOut > 0)) {
-              ctx.assistantMessage.cost += input.overhead.cost
-              yield* session.updateMessage(ctx.assistantMessage)
-              if (ctx.agentMetrics) {
-                ctx.agentMetrics.tokens_in += input.overhead.tokensIn
-                ctx.agentMetrics.tokens_out += input.overhead.tokensOut
-              }
-              yield* bus
-                .publish(Metrics.ModelCall, {
-                  sessionID: ctx.sessionID,
-                  finish_reason: "max-mode-overhead",
-                  latency_ms: 0,
-                  cached_read_tokens: 0,
-                  model_id: ctx.model.id,
-                  provider: ctx.model.providerID,
-                  total_tokens_in: input.overhead.tokensIn,
-                  total_tokens_out: input.overhead.tokensOut,
-                })
-                .pipe(Effect.ignore)
-            }
-          }).pipe(
-            Effect.onInterrupt(() =>
-              Effect.gen(function* () {
-                aborted = true
-                // Propagate cancellation into the currently-executing tool so a
-                // long-running winner tool call is actually interrupted.
-                ctrl.abort()
-                if (!ctx.assistantMessage.error) {
-                  yield* halt(new DOMException("Aborted", "AbortError"))
-                }
-              }),
-            ),
-            Effect.catchCauseIf(
-              (cause) => !Cause.hasInterruptsOnly(cause),
-              (cause) => Effect.fail(Cause.squash(cause)),
-            ),
-            Effect.catch(halt),
-            Effect.ensuring(cleanup()),
-          )
-
-          if (ctx.needsOverflowHandling) return "overflow"
-          if (ctx.blocked || ctx.assistantMessage.error) return "stop"
-          return "continue"
-        })
-      })
-
-      return {
-        get message() {
-          return ctx.assistantMessage
-        },
-        updateToolCall,
-        completeToolCall,
-        process,
-        replay,
-      } satisfies Handle
-    })
-
-    return Service.of({ create })
-  }),
-)
-
-export const defaultLayer = Layer.suspend(() =>
-  layer.pipe(
-    Layer.provide(Session.defaultLayer),
-    Layer.provide(Snapshot.defaultLayer),
-    Layer.provide(Agent.defaultLayer),
-    Layer.provide(LLM.defaultLayer),
-    Layer.provide(Permission.defaultLayer),
-    Layer.provide(Plugin.defaultLayer),
-    Layer.provide(SessionSummary.defaultLayer),
-    Layer.provide(SessionStatus.defaultLayer),
-    Layer.provide(Bus.layer),
-    Layer.provide(Config.defaultLayer),
-  ),
-)
-
-export * as SessionProcessor from "./processor"