saeeol 1.1.1 → 1.2.1

package/src/session/projectors.ts

@@ -1,139 +1,2 @@
-import { NotFoundError } from "@/storage/storage"
-import { eq } from "drizzle-orm"
-import { and } from "drizzle-orm"
-import { SyncEvent } from "@/sync"
-import * as Session from "./session"
-import { MessageV2 } from "./message-v2"
-import { SessionTable, MessageTable, PartTable } from "./session.sql"
-import * as Log from "@saeeol/core/util/log"
-
-const log = Log.create({ service: "session.projector" })
-
-function foreign(err: unknown) {
-  if (typeof err !== "object" || err === null) return false
-  if ("code" in err && err.code === "SQLITE_CONSTRAINT_FOREIGNKEY") return true
-  return "message" in err && typeof err.message === "string" && err.message.includes("FOREIGN KEY constraint failed")
-}
-
-export type DeepPartial<T> = T extends object ? { [K in keyof T]?: DeepPartial<T[K]> | null } : T
-
-function grab<T extends object, K1 extends keyof T, X>(
-  obj: T,
-  field1: K1,
-  cb?: (val: NonNullable<T[K1]>) => X,
-): X | undefined {
-  if (obj == undefined || !(field1 in obj)) return undefined
-
-  const val = obj[field1]
-  if (val && typeof val === "object" && cb) {
-    return cb(val)
-  }
-  if (val === undefined) {
-    throw new Error(
-      "Session update failure: pass `null` to clear a field instead of `undefined`: " + JSON.stringify(obj),
-    )
-  }
-  return val as X | undefined
-}
-
-export function toPartialRow(info: DeepPartial<Session.Info>) {
-  const obj = {
-    id: grab(info, "id"),
-    project_id: grab(info, "projectID"),
-    workspace_id: grab(info, "workspaceID"),
-    parent_id: grab(info, "parentID"),
-    slug: grab(info, "slug"),
-    directory: grab(info, "directory"),
-    path: grab(info, "path"),
-    title: grab(info, "title"),
-    version: grab(info, "version"),
-    share_url: grab(info, "share", (v) => grab(v, "url")),
-    summary_additions: grab(info, "summary", (v) => grab(v, "additions")),
-    summary_deletions: grab(info, "summary", (v) => grab(v, "deletions")),
-    summary_files: grab(info, "summary", (v) => grab(v, "files")),
-    summary_diffs: grab(info, "summary", (v) => grab(v, "diffs")),
-    revert: grab(info, "revert"),
-    permission: grab(info, "permission"),
-    time_created: grab(info, "time", (v) => grab(v, "created")),
-    time_updated: grab(info, "time", (v) => grab(v, "updated")),
-    time_compacting: grab(info, "time", (v) => grab(v, "compacting")),
-    time_archived: grab(info, "time", (v) => grab(v, "archived")),
-  }
-
-  return Object.fromEntries(Object.entries(obj).filter(([_, val]) => val !== undefined))
-}
-
-export default [
-  SyncEvent.project(Session.Event.Created, (db, data) => {
-    db.insert(SessionTable)
-      .values(Session.toRow(data.info as Session.Info))
-      .run()
-  }),
-
-  SyncEvent.project(Session.Event.Updated, (db, data) => {
-    const info = data.info
-    const row = db
-      .update(SessionTable)
-      .set(toPartialRow(info as Session.Patch))
-      .where(eq(SessionTable.id, data.sessionID))
-      .returning()
-      .get()
-    if (!row) throw new NotFoundError({ message: `Session not found: ${data.sessionID}` })
-  }),
-
-  SyncEvent.project(Session.Event.Deleted, (db, data) => {
-    db.delete(SessionTable).where(eq(SessionTable.id, data.sessionID)).run()
-  }),
-
-  SyncEvent.project(MessageV2.Event.Updated, (db, data) => {
-    const time_created = data.info.time.created
-    const { id, sessionID, ...rest } = data.info
-
-    try {
-      db.insert(MessageTable)
-        .values({
-          id,
-          session_id: sessionID,
-          time_created,
-          data: rest,
-        })
-        .onConflictDoUpdate({ target: MessageTable.id, set: { data: rest } })
-        .run()
-    } catch (err) {
-      if (!foreign(err)) throw err
-      log.warn("ignored late message update", { messageID: id, sessionID })
-    }
-  }),
-
-  SyncEvent.project(MessageV2.Event.Removed, (db, data) => {
-    db.delete(MessageTable)
-      .where(and(eq(MessageTable.id, data.messageID), eq(MessageTable.session_id, data.sessionID)))
-      .run()
-  }),
-
-  SyncEvent.project(MessageV2.Event.PartRemoved, (db, data) => {
-    db.delete(PartTable)
-      .where(and(eq(PartTable.id, data.partID), eq(PartTable.session_id, data.sessionID)))
-      .run()
-  }),
-
-  SyncEvent.project(MessageV2.Event.PartUpdated, (db, data) => {
-    const { id, messageID, sessionID, ...rest } = data.part
-
-    try {
-      db.insert(PartTable)
-        .values({
-          id,
-          message_id: messageID,
-          session_id: sessionID,
-          time_created: data.time,
-          data: rest,
-        })
-        .onConflictDoUpdate({ target: PartTable.id, set: { data: rest } })
-        .run()
-    } catch (err) {
-      if (!foreign(err)) throw err
-      log.warn("ignored late part update", { partID: id, messageID, sessionID })
-    }
-  }),
-]
+export * from "./core/projectors"
+export { default } from "./core/projectors"

package/src/session/prompt/prompt-command.ts

@@ -0,0 +1,93 @@
+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 "../core/schema"
+import * as Session from "../core/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 }
+  })
+}

package/src/session/prompt/prompt-loop.ts

@@ -0,0 +1,299 @@
+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 "../core/schema"
+import { MessageV2 } from "../message/message-v2"
+import * as Session from "../core/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 "./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 }
+}

package/src/session/prompt/prompt-model.ts

@@ -0,0 +1,44 @@
+import { Effect, Exit, Cause, Option, Types } from "effect"
+import { SessionID, MessageID, PartID } from "../core/schema"
+import { MessageV2 } from "../message/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")
+  })