saeeol 1.2.0 → 1.2.2

package/src/session/prompt/prompt.ts

@@ -0,0 +1,211 @@
+// @ts-ignore
+globalThis.AI_SDK_LOG_WARNINGS = false
+
+import { Effect, Layer, Scope, Latch, Context } from "effect"
+import { ChildProcessSpawner } from "effect/unstable/process"
+import { CrossSpawnSpawner } from "@saeeol/core/cross-spawn-spawner"
+import { SaeeolSessionPrompt } from "@/saeeol/session/prompt"
+import { SaeeolSessionPromptQueue } from "@/saeeol/session/prompt-queue"
+import { SaeeolSession } from "@/saeeol/session"
+import { SaeeolSessionProcessor } from "@/saeeol/session/processor"
+import { Suggestion } from "@/saeeol/suggestion"
+import { Question } from "@/question"
+import { SessionID, MessageID } from "../core/schema"
+import { MessageV2 } from "../message/message-v2"
+import { makeRuntime } from "@/effect/run-service"
+import { InstanceState } from "@/effect/instance-state"
+import { EffectBridge } from "@/effect/bridge"
+import { SessionRunState } from "../core/run-state"
+import { SessionStatus } from "../core/status"
+import { SessionCompaction } from "../core/compaction/compaction"
+import { SessionProcessor } from "../core/processor"
+import { Command } from "../../command"
+import { Permission } from "@/permission"
+import { MCP } from "../../mcp"
+import { LSP } from "@/lsp/lsp"
+import { ToolRegistry } from "@/tool/registry"
+import { Truncate } from "@/tool/truncate"
+import { Provider } from "@/provider/provider"
+import { Config } from "@/config/config"
+import { Instruction } from "../core/instruction"
+import { AppFileSystem } from "@saeeol/core/filesystem"
+import { Plugin } from "../../plugin"
+import { Session as SessionMod } from "../core/session"
+import { SessionRevert } from "../core/revert"
+import { SessionSummary } from "../core/summary"
+import { Agent } from "../../agent/agent"
+import { SystemPrompt } from "../core/system"
+import { LLM } from "../core/llm"
+import { Bus } from "../../bus"
+import { Service as ResolveToolsService, defaultLayer as resolveToolsLayer } from "../core/resolve-tools"
+import { Service as UserPartService, defaultLayer as userPartLayer } from "../core/user-part"
+import { Service as SubtaskService, defaultLayer as subtaskLayer } from "../core/subtask"
+import { Service as ShellService, defaultLayer as shellLayer } from "../core/shell-exec"
+import { type PromptInput, type ShellInput, type CommandInput, LoopInput } from "./prompt-schemas"
+import { type Interface, Service } from "./prompt-types"
+import { resolvePromptParts } from "./prompt-resolve"
+import { getModel, lastModel, lastAssistant } from "./prompt-model"
+import { createUserMessage } from "./prompt-user-msg"
+import { ensureTitle } from "./prompt-title"
+import { insertReminders } from "./prompt-reminders"
+import { commandHandler } from "./prompt-command"
+import { createRunLoop } from "./prompt-loop"
+
+export const shouldAskPlanFollowup = SaeeolSessionPrompt.shouldAskPlanFollowup
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const bus = yield* Bus.Service
+    const status = yield* SessionStatus.Service
+    const sessions = yield* SessionMod.Service
+    const agents = yield* Agent.Service
+    const provider = yield* Provider.Service
+    const processor = yield* SessionProcessor.Service
+    const compaction = yield* SessionCompaction.Service
+    const plugin = yield* Plugin.Service
+    const commands = yield* Command.Service
+    const config = yield* Config.Service
+    const permission = yield* Permission.Service
+    const fsys = yield* AppFileSystem.Service
+    const mcp = yield* MCP.Service
+    const lsp = yield* LSP.Service
+    const registry = yield* ToolRegistry.Service
+    const truncate = yield* Truncate.Service
+    const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
+    const scope = yield* Scope.Scope
+    const instruction = yield* Instruction.Service
+    const state = yield* SessionRunState.Service
+    const revert = yield* SessionRevert.Service
+    const summary = yield* SessionSummary.Service
+    const sys = yield* SystemPrompt.Service
+    const llm = yield* LLM.Service
+    const resolveToolsSvc = yield* ResolveToolsService
+    const userPartSvc = yield* UserPartService
+    const subtaskSvc = yield* SubtaskService
+    const shellSvc = yield* ShellService
+
+    const deps = {
+      bus, status, sessions, agents, provider, processor, compaction, plugin,
+      commands, config, permission, fsys, mcp, lsp, registry, truncate,
+      spawner, scope, instruction, state, revert, summary, sys, llm,
+      resolveToolsSvc, userPartSvc, subtaskSvc, shellSvc,
+    }
+
+    const resolvePromptPartsFn = resolvePromptParts(deps as any)
+    const getModelFn = getModel(deps as any)
+    const lastModelFn = lastModel(deps as any)
+    const lastAssistantFn = lastAssistant(deps as any)
+    const createUserMessageFn = createUserMessage(deps as any)
+    const ensureTitleFn = ensureTitle(deps as any)
+    const insertRemindersFn = insertReminders(deps as any, SaeeolSessionPrompt)
+    const commandFn = commandHandler(deps as any, SaeeolSessionProcessor.markReviewTelemetry.bind(SaeeolSessionProcessor))
+
+    const cancel = Effect.fn("SessionPrompt.cancel")(function* (sessionID: SessionID) {
+      yield* SaeeolSessionPromptQueue.cancel(sessionID)
+      SaeeolSessionPrompt.abortPlanFollowup(sessionID)
+      yield* state.cancel(sessionID)
+    })
+
+    const { runLoop, loop, shell } = createRunLoop(
+      deps as any,
+      {
+        getModel: getModelFn,
+        lastModel: lastModelFn,
+        lastAssistant: lastAssistantFn,
+        createUserMessage: createUserMessageFn,
+        ensureTitle: ensureTitleFn,
+        insertReminders: insertRemindersFn,
+        resolvePromptParts: resolvePromptPartsFn,
+        commandHandler: commandFn,
+        SaeeolSessionPrompt,
+        SaeeolSessionPromptQueue,
+        SaeeolSession,
+        SaeeolSessionProcessor,
+      } as any,
+    )
+
+    let promptFn: any
+
+    const promptImpl = Effect.fn("SessionPrompt.prompt")(function* (input: PromptInput) {
+      return yield* promptFn(input)
+    })
+
+    promptFn = Effect.fn("SessionPrompt.prompt")(function* (input: PromptInput) {
+      const session = yield* sessions.get(input.sessionID)
+      yield* revert.cleanup(session)
+      yield* SaeeolSessionPrompt.recoverDanglingAssistant({ sessionID: input.sessionID, status, sessions })
+      yield* SaeeolSessionPrompt.recoverProviderFinishError({ sessionID: input.sessionID, status, sessions })
+      const message = yield* createUserMessageFn(input)
+      yield* sessions.touch(input.sessionID)
+      const permissions: Permission.Ruleset = []
+      for (const [t, enabled] of Object.entries(input.tools ?? {})) {
+        permissions.push({ permission: t, action: enabled ? "allow" : "deny", pattern: "*" })
+      }
+      if (permissions.length > 0) {
+        session.permission = permissions
+        yield* sessions.setPermission({ sessionID: session.id, permission: permissions })
+      }
+      yield* Effect.promise(() => Suggestion.dismissAll(input.sessionID))
+      yield* Effect.promise(() => Question.dismissAll(input.sessionID))
+      if (input.noReply === true) return message
+      return yield* (SaeeolSessionPromptQueue.enqueue as any)(
+        input.sessionID, message.info.id,
+        loop({ sessionID: input.sessionID }),
+        lastAssistantFn(input.sessionID),
+      )
+    })
+
+    return Service.of({
+      cancel,
+      prompt: promptFn,
+      loop: loop as any,
+      shell: shell as any,
+      command: commandFn as any,
+      resolvePromptParts: resolvePromptPartsFn as any,
+    })
+  }),
+)
+
+export const defaultLayer = Layer.suspend(() =>
+  layer.pipe(
+    Layer.provide(
+      Layer.mergeAll(
+        resolveToolsLayer, userPartLayer, subtaskLayer, shellLayer,
+        SessionRunState.defaultLayer, SessionStatus.defaultLayer,
+        SessionCompaction.defaultLayer, SessionProcessor.defaultLayer,
+        Command.defaultLayer, Permission.defaultLayer, MCP.defaultLayer,
+        LSP.defaultLayer, ToolRegistry.defaultLayer, Truncate.defaultLayer,
+        Provider.defaultLayer, Config.defaultLayer, Instruction.defaultLayer,
+        AppFileSystem.defaultLayer, Plugin.defaultLayer, SessionMod.defaultLayer,
+        SessionRevert.defaultLayer, SessionSummary.defaultLayer, Agent.defaultLayer,
+        SystemPrompt.defaultLayer, LLM.defaultLayer, Bus.layer,
+        CrossSpawnSpawner.defaultLayer,
+      ),
+    ),
+  ),
+)
+
+export { Service } from "./prompt-types"
+export type { Interface } from "./prompt-types"
+
+export {
+  PromptInput,
+  type PromptInput as PromptInputType,
+  ShellInput,
+  type ShellInput as ShellInputType,
+  CommandInput,
+  type CommandInput as CommandInputType,
+  LoopInput,
+  createStructuredOutputTool,
+  STRUCTURED_OUTPUT_DESCRIPTION, STRUCTURED_OUTPUT_SYSTEM_PROMPT,
+  REQUEST_PRUNE_BYTES,
+  bashRegex, argsRegex, placeholderRegex, quoteTrimRegex,
+} from "./prompt-schemas"
+
+const { runPromise } = makeRuntime(Service, defaultLayer)
+export const prompt = (input: PromptInput) => runPromise((svc) => svc.prompt(input))
+export const loopExport = (input: LoopInput) => runPromise((svc) => svc.loop(input))
+export const cancel = (sessionID: SessionID) => runPromise((svc) => svc.cancel(sessionID))
+
+export * as SessionPrompt from "./prompt"

package/src/session/prompt-command.ts

@@ -1,93 +1 @@
-import { Effect } from "effect"
-import { NamedError } from "@saeeol/core/util/error"
-import * as EffectLogger from "@saeeol/core/effect/logger"
-import { ConfigMarkdown } from "@/config/markdown"
-import { Shell } from "@/shell/shell"
-import { Provider } from "@/provider/provider"
-import { Process } from "@/util/process"
-import { SessionID } from "./schema"
-import * as Session from "./session"
-import { resolvePromptParts } from "./prompt-resolve"
-import { getModel, lastModel } from "./prompt-model"
-import type { CommandInput } from "./prompt-schemas"
-import type { PromptDeps } from "./prompt-types"
-
-const elog = EffectLogger.create({ service: "session.prompt" })
-
-export const commandHandler = (deps: PromptDeps, markReviewTelemetry?: (parts: any, cmd: string) => void) => {
-  const resolveParts = resolvePromptParts(deps)
-
-  return Effect.fn("SessionPrompt.command")(function* (input: CommandInput) {
-    yield* elog.info("command", { sessionID: input.sessionID, command: input.command, agent: input.agent })
-    const cmd = yield* deps.commands.get(input.command)
-    if (!cmd) {
-      const available = (yield* deps.commands.list()).map((c: any) => c.name)
-      const hint = available.length ? ` Available commands: ${available.join(", ")}` : ""
-      const error = new NamedError.Unknown({ message: `Command not found: "${input.command}".${hint}` })
-      yield* deps.bus.publish(Session.Event.Error, { sessionID: input.sessionID, error: error.toObject() })
-      throw error
-    }
-    const argsRegex = /\S+|"[^"]*"|'[^']*'/g
-    const quoteTrimRegex = /^["']|["']$/g
-    const placeholderRegex = /\$(\d+)/g
-    const agentName = cmd.agent ?? input.agent ?? (yield* deps.agents.defaultAgent())
-    const raw = input.arguments.match(argsRegex) ?? []
-    const args = raw.map((arg: string) => arg.replace(quoteTrimRegex, ""))
-    const templateCommand = yield* Effect.promise(async () => cmd.template)
-    const placeholders = templateCommand.match(placeholderRegex) ?? []
-    let last = 0
-    for (const item of placeholders) { const value = Number(item.slice(1)); if (value > last) last = value }
-    const withArgs = templateCommand.replaceAll(placeholderRegex, (_: string, index: string) => {
-      const position = Number(index)
-      const argIndex = position - 1
-      if (argIndex >= args.length) return ""
-      if (position === last) return args.slice(argIndex).join(" ")
-      return args[argIndex]
-    })
-    const usesArgumentsPlaceholder = templateCommand.includes("$ARGUMENTS")
-    let template = withArgs.replaceAll("$ARGUMENTS", input.arguments)
-    if (placeholders.length === 0 && !usesArgumentsPlaceholder && input.arguments.trim()) {
-      template = template + "\n\n" + input.arguments
-    }
-    const bashRegex = /```bash\n([\s\S]*?)```/g
-    const shellMatches = ConfigMarkdown.shell(template)
-    if (shellMatches.length > 0) {
-      const cfg = yield* deps.config.get()
-      const sh = Shell.preferred(cfg.shell)
-      const results = yield* Effect.promise(() =>
-        Promise.all(shellMatches.map(async (match: RegExpExecArray) => (await Process.text([match[1]], { shell: sh, nothrow: true })).text)),
-      )
-      let index = 0
-      template = template.replace(bashRegex, () => results[index++])
-    }
-    template = template.trim()
-    const taskModel = yield* Effect.gen(function* () {
-      if (cmd.model) return Provider.parseModel(cmd.model)
-      if (cmd.agent) { const cmdAgent = yield* deps.agents.get(cmd.agent); if (cmdAgent?.model) return cmdAgent.model }
-      if (input.model) return Provider.parseModel(input.model)
-      return yield* lastModel(deps)(input.sessionID)
-    })
-    yield* getModel(deps)(taskModel.providerID, taskModel.modelID, input.sessionID)
-    const agent = yield* deps.agents.get(agentName)
-    if (!agent) {
-      const available = (yield* deps.agents.list()).filter((a: any) => !a.hidden).map((a: any) => a.name)
-      const hint = available.length ? ` Available agents: ${available.join(", ")}` : ""
-      const error = new NamedError.Unknown({ message: `Agent not found: "${agentName}".${hint}` })
-      yield* deps.bus.publish(Session.Event.Error, { sessionID: input.sessionID, error: error.toObject() })
-      throw error
-    }
-    const templateParts = yield* resolveParts(template)
-    markReviewTelemetry?.(templateParts, input.command)
-    const isSubtask = (agent.mode === "subagent" && cmd.subtask !== false) || cmd.subtask === true
-    const parts = isSubtask
-      ? [{ type: "subtask" as const, agent: agent.name, description: cmd.description ?? "",
-          command: input.command, model: { providerID: taskModel.providerID, modelID: taskModel.modelID },
-          prompt: (templateParts.find((y: any) => y.type === "text") as any)?.text ?? "" }]
-      : [...templateParts, ...(input.parts ?? [])]
-    const userAgent = isSubtask ? (input.agent ?? (yield* deps.agents.defaultAgent())) : agentName
-    const userModel = isSubtask ? input.model ? Provider.parseModel(input.model) : yield* lastModel(deps)(input.sessionID) : taskModel
-    yield* deps.plugin.trigger("command.execute.before",
-      { command: input.command, sessionID: input.sessionID, arguments: input.arguments }, { parts })
-    return { sessionID: input.sessionID, messageID: input.messageID, model: userModel, agent: userAgent, parts, variant: input.variant, command: input.command, arguments: input.arguments }
-  })
-}
+export * from "./prompt/prompt-command"

package/src/session/prompt-loop.ts

@@ -1,299 +1 @@
-import { Effect, Latch, Option } from "effect"
-import * as EffectLogger from "@saeeol/core/effect/logger"
-import * as Log from "@saeeol/core/util/log"
-import { SessionID, MessageID } from "./schema"
-import { MessageV2 } from "./message-v2"
-import * as Session from "./session"
-import { SaeeolSession } from "@/saeeol/session"
-import { SaeeolSessionPrompt } from "@/saeeol/session/prompt"
-import { SaeeolSessionPromptQueue } from "@/saeeol/session/prompt-queue"
-import { SaeeolSessionProcessor } from "@/saeeol/session/processor"
-import { InstanceState } from "@/effect/instance-state"
-import { EffectBridge } from "@/effect/bridge"
-import { type TaskPromptOps } from "@/tool/task"
-import { NamedError } from "@saeeol/core/util/error"
-import MAX_STEPS from "./prompt/max-steps.txt"
-import { type PromptInput, type ShellInput, LoopInput, STRUCTURED_OUTPUT_SYSTEM_PROMPT, REQUEST_PRUNE_BYTES, createStructuredOutputTool } from "./prompt-schemas"
-import type { PromptDeps } from "./prompt-types"
-const elog = EffectLogger.create({ service: "session.prompt" })
-const log = Log.create({ service: "session.prompt" })
-
-export interface LoopHelpers {
-  getModel: (...args: any[]) => any
-  lastModel: (...args: any[]) => any
-  lastAssistant: (...args: any[]) => any
-  createUserMessage: (...args: any[]) => any
-  ensureTitle: (...args: any[]) => any
-  insertReminders: (...args: any[]) => any
-  resolvePromptParts: (...args: any[]) => any
-  commandHandler: (...args: any[]) => any
-  prompt: (...args: any[]) => any
-  cancel: (...args: any[]) => any
-}
-
-export function createRunLoop(deps: PromptDeps, helpers: LoopHelpers) {
-  const closeReasons = new Map<string, any>()
-  const resolveTools = (input: any) => deps.resolveToolsSvc.resolve(input)
-  const runner = Effect.fn("SessionPrompt.runner")(function* () { return yield* EffectBridge.make() })
-  const ops = Effect.fn("SessionPrompt.ops")(function* () {
-    const run = yield* runner()
-    return {
-      cancel: (id: SessionID) => run.fork(helpers.cancel(id)),
-      resolvePromptParts: (t: string) => helpers.resolvePromptParts(t),
-      prompt: (input: PromptInput) => helpers.prompt(input),
-    } satisfies TaskPromptOps
-  })
-  const handleSubtask = (input: any) => Effect.gen(function* () {
-    const ops_ = yield* ops()
-    return yield* deps.subtaskSvc.handle({ ...input, getModel: helpers.getModel, promptOps: ops_ })
-  })
-  const shellImpl = (input: ShellInput, ready?: Latch.Latch) =>
-    deps.shellSvc.exec(input, helpers.getModel, helpers.lastModel as any, ready)
-  const runLoop = Effect.fn("SessionPrompt.run")(function* (sessionID: SessionID) {
-    const envCache: SaeeolSessionPrompt.EnvCache = {}
-    closeReasons.delete(sessionID)
-    let compactionAttempts = 0
-    const ctx = yield* InstanceState.context
-    const slog = elog.with({ sessionID })
-    let structured: unknown | undefined
-    let step = 0
-    const session = yield* deps.sessions.get(sessionID)
-    while (true) {
-      yield* deps.status.set(sessionID, { type: "busy" })
-      yield* slog.info("loop", { step })
-      let msgs: MessageV2.WithParts[] = yield* MessageV2.filterCompactedEffect(sessionID)
-      msgs = SaeeolSessionPromptQueue.scope(sessionID, msgs)
-      msgs = SaeeolSessionPrompt.trimBeforeLastSummary(msgs)
-      let lastUser: MessageV2.User | undefined, lastAssistant: MessageV2.Assistant | undefined, lastFinished: MessageV2.Assistant | undefined
-      let tasks: (MessageV2.CompactionPart | MessageV2.SubtaskPart)[] = []
-      for (let i = msgs.length - 1; i >= 0; i--) {
-        const msg = msgs[i]
-        if (!lastUser && msg.info.role === "user") lastUser = msg.info
-        if (!lastAssistant && msg.info.role === "assistant") lastAssistant = msg.info
-        if (!lastFinished && msg.info.role === "assistant" && msg.info.finish) lastFinished = msg.info
-        if (lastUser && lastFinished) break
-        const task = msg.parts.filter((part) => part.type === "compaction" || part.type === "subtask")
-        if (task && !lastFinished) tasks.push(...task)
-      }
-      if (!lastUser) throw new Error("No user message found in stream.")
-      const telemetry = SaeeolSessionProcessor.extractReviewTelemetry(
-        msgs.findLast((m) => m.info.role === "user" && m.info.id === lastUser.id)?.parts ?? [],
-      )
-      const lastAssistantMsg = msgs.findLast(
-        (msg) => msg.info.role === "assistant" && msg.info.id === lastAssistant?.id,
-      )
-      const hasToolCalls = lastAssistantMsg?.parts.some((part) => part.type === "tool" && !part.metadata?.providerExecuted) ?? false
-      if (lastAssistant?.finish && hasToolCalls && lastAssistant.parentID === lastUser.id &&
-        lastUser.id < lastAssistant.id &&
-        SaeeolSessionPrompt.shouldAskPlanFollowup({ messages: msgs, abort: AbortSignal.any([]) })
-      ) {
-        const action = yield* Effect.promise((signal) =>
-          SaeeolSessionPrompt.askPlanFollowup({ sessionID, messages: msgs, abort: signal }),
-        )
-        if (action === "continue") continue
-        yield* slog.info("exiting loop")
-        break
-      }
-      if (lastAssistant?.finish && !["tool-calls"].includes(lastAssistant.finish) &&
-        !hasToolCalls && lastAssistant.parentID === lastUser.id && lastUser.id < lastAssistant.id
-      ) {
-        const action = yield* Effect.promise((signal) =>
-          SaeeolSessionPrompt.askPlanFollowup({ sessionID, messages: msgs, abort: signal }),
-        )
-        if (action === "continue") continue
-        yield* slog.info("exiting loop")
-        break
-      }
-      step++
-      if (step === 1)
-        yield* helpers.ensureTitle({
-          session, modelID: lastUser.model.modelID, providerID: lastUser.model.providerID, history: msgs,
-        }).pipe(Effect.ignore, Effect.forkIn(deps.scope))
-      const model = yield* helpers.getModel(lastUser.model.providerID, lastUser.model.modelID, sessionID)
-      const task = tasks.pop()
-      if (task?.type === "subtask") {
-        yield* handleSubtask({ task, model, lastUser, sessionID, session, msgs })
-        continue
-      }
-      if (task?.type === "compaction") {
-        const result = yield* deps.compaction.process({
-          messages: msgs, parentID: lastUser.id, sessionID, auto: task.auto, overflow: task.overflow,
-        })
-        if (result === "stop") { closeReasons.set(sessionID, "error"); break }
-        continue
-      }
-      if (lastFinished && lastFinished.summary !== true &&
-        (yield* deps.compaction.isOverflow({ tokens: lastFinished.tokens, model }))
-      ) {
-        const guard = SaeeolSessionPrompt.guardCompactionAttempt({
-          sessionID, attempts: compactionAttempts, closeReasons, message: lastFinished,
-        })
-        if (guard.exhausted) {
-          yield* deps.sessions.updateMessage(lastFinished)
-          yield* deps.bus.publish(Session.Event.Error, { sessionID, error: guard.error })
-          break
-        }
-        compactionAttempts++
-        yield* deps.compaction.create({ sessionID, agent: lastUser.agent, model: lastUser.model, auto: true })
-        continue
-      }
-      const agent = yield* deps.agents.get(lastUser.agent)
-      if (!agent) {
-        const available = (yield* deps.agents.list()).filter((a: any) => !a.hidden).map((a: any) => a.name)
-        const hint = available.length ? ` Available agents: ${available.join(", ")}` : ""
-        const error = new NamedError.Unknown({ message: `Agent not found: "${lastUser.agent}".${hint}` })
-        yield* deps.bus.publish(Session.Event.Error, { sessionID, error: error.toObject() })
-        throw error
-      }
-      const maxSteps = agent.steps ?? Infinity
-      const isLastStep = step >= maxSteps
-      msgs = yield* helpers.insertReminders({ messages: msgs, agent, session })
-      const msg: MessageV2.Assistant = {
-        id: MessageID.ascending(), parentID: lastUser.id, role: "assistant", mode: agent.name,
-        agent: agent.name, variant: lastUser.model.variant, path: { cwd: ctx.directory, root: ctx.worktree },
-        cost: 0, tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-        modelID: model.id, providerID: model.providerID, time: { created: Date.now() }, sessionID,
-      }
-      yield* deps.sessions.updateMessage(msg)
-      const handle = yield* deps.processor.create({ assistantMessage: msg, sessionID, model, telemetry })
-      const outcome: "break" | "continue" = yield* Effect.gen(function* () {
-        const lastUserMsg = msgs.findLast((m) => m.info.role === "user")
-        const bypassAgentCheck = lastUserMsg?.parts.some((p) => p.type === "agent") ?? false
-        const tools = yield* resolveTools({
-          agent, session, model, tools: lastUser.tools, processor: handle,
-          bypassAgentCheck, messages: msgs,
-        })
-        if (lastUser.format?.type === "json_schema") {
-          tools["StructuredOutput"] = createStructuredOutputTool({
-            schema: lastUser.format.schema,
-            onSuccess(output: unknown) { structured = output },
-          })
-        }
-        if (step === 1)
-          yield* deps.summary.summarize({ sessionID, messageID: lastUser.id }).pipe(Effect.ignore, Effect.forkIn(deps.scope))
-        if (step > 1 && lastFinished) {
-          for (const m of msgs) {
-            if (m.info.role !== "user" || m.info.id <= lastFinished.id) continue
-            for (const p of m.parts) {
-              if (p.type !== "text" || p.ignored || p.synthetic || !p.text.trim()) continue
-              p.text = ["<system-reminder>", "The user sent the following message:", p.text, "",
-                "Please address this message and continue with your tasks.", "</system-reminder>"].join("\n")
-            }
-          }
-        }
-        yield* deps.plugin.trigger("experimental.chat.messages.transform", {}, { messages: msgs })
-        SaeeolSessionPrompt.injectEditorContext({ msgs, lastUser, sessionID, cache: envCache })
-        msgs = SaeeolSessionPrompt.maybeStripHistoricalMedia(msgs)
-        const allResult: any = yield* Effect.all([
-          deps.sys.skills(agent), deps.sys.environment(model, lastUser.editorContext),
-          deps.instruction.system().pipe(Effect.orDie),
-        ])
-        const skills: any = allResult[0], env: any[] = allResult[1], instructions: any[] = allResult[2]
-        let modelMsgs = yield* MessageV2.toModelMessagesEffect(msgs, model)
-        const size = Buffer.byteLength(JSON.stringify(modelMsgs))
-        if (size > REQUEST_PRUNE_BYTES) {
-          yield* deps.compaction.prune({ sessionID, reason: "payload-limit" })
-          msgs = yield* MessageV2.filterCompactedEffect(sessionID)
-          msgs = SaeeolSessionPromptQueue.scope(sessionID, msgs)
-          msgs = SaeeolSessionPrompt.trimBeforeLastSummary(msgs)
-          yield* deps.plugin.trigger("experimental.chat.messages.transform", {}, { messages: msgs })
-          SaeeolSessionPrompt.injectEditorContext({ msgs, lastUser, sessionID, cache: envCache })
-          msgs = SaeeolSessionPrompt.maybeStripHistoricalMedia(msgs)
-          modelMsgs = yield* MessageV2.toModelMessagesEffect(msgs, model)
-          const nextSize = Buffer.byteLength(JSON.stringify(modelMsgs))
-          if (nextSize > REQUEST_PRUNE_BYTES) log.warn("payload still large after pruning", { size: nextSize })
-        }
-        const system = [...env, ...instructions, ...(skills ? [skills] : [])]
-        const format = lastUser.format ?? { type: "text" as const }
-        if (format.type === "json_schema") system.push(STRUCTURED_OUTPUT_SYSTEM_PROMPT)
-        const result = yield* handle.process({
-          user: lastUser, agent, permission: SaeeolSessionPrompt.guardPermissions({ agent, session }),
-          sessionID, parentSessionID: session.parentID, system,
-          messages: [...modelMsgs, ...(isLastStep ? [{ role: "assistant" as const, content: MAX_STEPS }] : [])],
-          tools, model, toolChoice: format.type === "json_schema" ? "required" : undefined,
-        })
-        if (structured !== undefined) {
-          handle.message.structured = structured
-          handle.message.finish = handle.message.finish ?? "stop"
-          yield* deps.sessions.updateMessage(handle.message)
-          return "break" as const
-        }
-        const finished = handle.message.finish && !["tool-calls", "unknown"].includes(handle.message.finish)
-        if (finished && !handle.message.error) {
-          if (format.type === "json_schema") {
-            handle.message.error = new MessageV2.StructuredOutputError({
-              message: "Model did not produce structured output", retries: 0,
-            }).toObject()
-            yield* deps.sessions.updateMessage(handle.message)
-            return "break" as const
-          }
-          if (handle.message.finish === "error") {
-            SaeeolSessionProcessor.providerFinishError(handle.message)
-            yield* deps.sessions.updateMessage(handle.message)
-            closeReasons.set(sessionID, "error")
-            return "break" as const
-          }
-        }
-        if (result === "stop") {
-          if (handle.message.error) closeReasons.set(sessionID, "error")
-          return "break" as const
-        }
-        if (result === "compact") {
-          const guard = SaeeolSessionPrompt.guardCompactionAttempt({
-            sessionID, attempts: compactionAttempts, closeReasons, message: handle.message,
-          })
-          if (guard.exhausted) {
-            yield* deps.sessions.updateMessage(handle.message)
-            yield* deps.bus.publish(Session.Event.Error, { sessionID, error: guard.error })
-            return "break" as const
-          }
-          compactionAttempts++
-          yield* deps.compaction.create({
-            sessionID, agent: lastUser.agent, model: lastUser.model, auto: true,
-            overflow: !handle.message.finish,
-          })
-        }
-        if (SaeeolSessionPromptQueue.hasFollowup(sessionID)) {
-          closeReasons.set(sessionID, "interrupted")
-          return "break" as const
-        }
-        if (result !== "compact" && !handle.message.finish) {
-          handle.message.finish = "unknown"
-          yield* deps.sessions.updateMessage(handle.message)
-        }
-        return "continue" as const
-      }).pipe(Effect.ensuring(deps.instruction.clear(handle.message.id)))
-      if (outcome === "break") break
-      continue
-    }
-    yield* deps.compaction.prune({ sessionID, reason: "normal" }).pipe(Effect.ignore, Effect.forkIn(deps.scope))
-    return yield* helpers.lastAssistant(sessionID)
-  })
-  const loop = Effect.fn("SessionPrompt.loop")(function* (input: LoopInput) {
-    yield* SaeeolSessionPrompt.recoverDanglingAssistant({
-      sessionID: input.sessionID, status: deps.status, sessions: deps.sessions,
-    })
-    yield* SaeeolSessionPrompt.recoverProviderFinishError({
-      sessionID: input.sessionID, status: deps.status, sessions: deps.sessions,
-    })
-    yield* deps.bus.publish(SaeeolSession.Event.TurnOpen, { sessionID: input.sessionID })
-    return yield* Effect.onExit(
-      deps.state.ensureRunning(input.sessionID, helpers.lastAssistant(input.sessionID), runLoop(input.sessionID)),
-      Effect.fnUntraced(function* (exit) {
-        yield* deps.bus.publish(SaeeolSession.Event.TurnClose, {
-          sessionID: input.sessionID,
-          reason: SaeeolSessionPrompt.resolveCloseReason({
-            sessionID: input.sessionID, closeReasons, exit,
-          }),
-        })
-      }),
-    )
-  })
-  const shell = Effect.fn("SessionPrompt.shell")(function* (input: ShellInput) {
-    const ready = yield* Latch.make()
-    return yield* deps.state.startShell(
-      input.sessionID, helpers.lastAssistant(input.sessionID), shellImpl(input, ready), ready,
-    )
-  })
-  return { runLoop, loop, shell, closeReasons }
-}
+export * from "./prompt/prompt-loop"

package/src/session/prompt-model.ts

@@ -1,44 +1 @@
-import { Effect, Exit, Cause, Option, Types } from "effect"
-import { SessionID, MessageID, PartID } from "./schema"
-import { MessageV2 } from "./message-v2"
-import { NamedError } from "@saeeol/core/util/error"
-import * as Log from "@saeeol/core/util/log"
-import type { PromptInput } from "./prompt-schemas"
-import type { ModelID, ProviderID } from "../provider/schema"
-import type { PromptDeps } from "./prompt-types"
-
-const log = Log.create({ service: "session.prompt" })
-
-export const getModel = (deps: PromptDeps) =>
-  Effect.fn("SessionPrompt.getModel")(function* (providerID: ProviderID, modelID: ModelID, sessionID: SessionID) {
-    const exit = yield* deps.provider.getModel(providerID, modelID).pipe(Effect.exit)
-    if (Exit.isSuccess(exit)) return exit.value
-    const err = Cause.squash(exit.cause)
-    if (deps.provider.ModelNotFoundError?.isInstance?.(err) ?? (err as any).constructor?.name === "ModelNotFoundError") {
-      const hint = (err as any).data?.suggestions?.length ? ` Did you mean: ${(err as any).data.suggestions.join(", ")}?` : ""
-      yield* deps.bus.publish(deps.sessions.constructor?.Event?.Error ?? { type: "session.error" }, {
-        sessionID,
-        error: new NamedError.Unknown({ message: `Model not found: ${providerID}/${modelID}.${hint}` }).toObject(),
-      })
-    }
-    return yield* Effect.failCause(exit.cause)
-  })
-
-export const lastModel = (deps: PromptDeps) =>
-  Effect.fnUntraced(function* (sessionID: SessionID) {
-    const match = yield* deps.sessions.findMessage(sessionID, (m: any) => m.info.role === "user" && !!m.info.model) as any
-    if (Option.isSome(match) && (match.value as any).info.role === "user") return (match.value as any).info.model
-    return yield* deps.provider.defaultModel()
-  })
-
-export const lastAssistant = (deps: PromptDeps) =>
-  Effect.fnUntraced(function* (sessionID: SessionID) {
-    for (let attempt = 0; attempt < 10; attempt++) {
-      const match = yield* deps.sessions.findMessage(sessionID, (m: any) => m.info.role !== "user")
-      if (Option.isSome(match)) return match.value
-      const msgs = yield* deps.sessions.messages({ sessionID, limit: 1 })
-      if (msgs.length > 0) return msgs[0]
-      yield* Effect.sleep("50 millis")
-    }
-    throw new Error("Impossible")
-  })
+export * from "./prompt/prompt-model"