saeeol 1.0.9 → 1.1.0

package/src/session/prompt-loop.ts

@@ -1,299 +0,0 @@
-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 }
-}

package/src/session/prompt-model.ts

@@ -1,44 +0,0 @@
-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")
-  })

package/src/session/prompt-reminders.ts

@@ -1,91 +0,0 @@
-import { Effect } from "effect"
-import path from "path"
-import { Flag } from "@saeeol/core/flag/flag"
-import { PartID } from "./schema"
-import { MessageV2 } from "./message-v2"
-import * as Session from "./session"
-import { InstanceState } from "@/effect/instance-state"
-import CODE_SWITCH from "./prompt/code-switch.txt"
-import type { PromptDeps } from "./prompt-types"
-
-const PLAN_REMINDER = `<system-reminder>
-Plan mode is active. The user indicated that they do not want you to execute yet -- you MUST NOT make any edits (with the exception of the plan file mentioned below), run any non-readonly tools (including changing configs or making commits), or otherwise make any changes to the system. This supersedes any other instructions you have received.
-
-## Plan File Info:
-{{PLAN_INFO}}
-You should build your plan incrementally by writing to or editing this file. NOTE that this is the only file you are allowed to edit -- you are only allowed to take READ-ONLY actions.
-
-## Plan Workflow
-
-### Phase 1: Initial Understanding
-Goal: Gain a comprehensive understanding of the user's request by reading through code and asking them questions. Critical to In this phase you should only use the explore subagent type.
-
-1. Focus on understanding the user's request and the code associated with their request
-2. **Launch up to 3 explore agents IN PARALLEL** to efficiently explore the codebase.
-3. After exploring the code, use the question tool to clarify ambiguities in the user request up front.
-
-### Phase 2: Design
-Goal: Design an implementation approach. Launch general agent(s) based on exploration results.
-
-### Phase 3: Review
-Goal: Review the plan(s) and ensure alignment with the user's intentions.
-
-### Phase 4: Final Plan
-Goal: Write your final plan to the plan file. Include recommended approach, critical file paths, and verification steps.
-
-### Phase 5: Call plan_exit tool
-At the end, call plan_exit to indicate you are done planning. Do NOT stop unless asking a question or calling plan_exit.
-</system-reminder>`
-
-export const insertReminders = (deps: PromptDeps, SaeeolSessionPrompt: any) =>
-  Effect.fn("SessionPrompt.insertReminders")(function* (input: {
-    messages: MessageV2.WithParts[]
-    agent: any
-    session: Session.Info
-  }) {
-    const userMessage = input.messages.findLast((msg) => msg.info.role === "user")
-    if (!userMessage) return input.messages
-
-    if (!Flag.SAEEOL_EXPERIMENTAL_PLAN_MODE) {
-      yield* Effect.promise(() =>
-        SaeeolSessionPrompt.insertPlanReminders({ agent: input.agent, session: input.session, userMessage }),
-      )
-      const wasPlan = input.messages.some((msg) => msg.info.role === "assistant" && msg.info.agent === "plan")
-      if (wasPlan && input.agent.name === "code") {
-        userMessage.parts.push({
-          id: PartID.ascending(), messageID: userMessage.info.id,
-          sessionID: userMessage.info.sessionID, type: "text", text: CODE_SWITCH, synthetic: true,
-        })
-      }
-      return input.messages
-    }
-
-    const assistantMessage = input.messages.findLast((msg) => msg.info.role === "assistant")
-    if (input.agent.name !== "plan" && assistantMessage?.info.agent === "plan") {
-      const ctx = yield* InstanceState.context
-      const plan = Session.plan(input.session, ctx)
-      if (!(yield* deps.fsys.existsSafe(plan))) return input.messages
-      const part = yield* deps.sessions.updatePart({
-        id: PartID.ascending(), messageID: userMessage.info.id, sessionID: userMessage.info.sessionID,
-        type: "text", text: `${CODE_SWITCH}\n\nA plan file exists at ${plan}. You should execute on the plan defined within it`, synthetic: true,
-      })
-      userMessage.parts.push(part)
-      return input.messages
-    }
-
-    if (input.agent.name !== "plan" || assistantMessage?.info.agent === "plan") return input.messages
-
-    const ctx = yield* InstanceState.context
-    const plan = Session.plan(input.session, ctx)
-    const exists = yield* deps.fsys.existsSafe(plan)
-    if (!exists) yield* deps.fsys.ensureDir(path.dirname(plan)).pipe(Effect.catch(Effect.die))
-    const planInfo = exists
-      ? `A plan file already exists at ${plan}. You can read it and make incremental edits using the edit tool.`
-      : `No plan file exists yet. You should create your plan at ${plan} using the write tool.`
-    const part = yield* deps.sessions.updatePart({
-      id: PartID.ascending(), messageID: userMessage.info.id, sessionID: userMessage.info.sessionID,
-      type: "text", text: PLAN_REMINDER.replace("{{PLAN_INFO}}", planInfo), synthetic: true,
-    })
-    userMessage.parts.push(part)
-    return input.messages
-  })

package/src/session/prompt-resolve.ts

@@ -1,42 +0,0 @@
-import { Effect, Types, Option } from "effect"
-import path from "path"
-import os from "os"
-import { ConfigMarkdown } from "@/config/markdown"
-import { pathToFileURL } from "url"
-import { InstanceState } from "@/effect/instance-state"
-import type { PromptInput } from "./prompt-schemas"
-import type { PromptDeps } from "./prompt-types"
-
-export const resolvePromptParts = (deps: PromptDeps) =>
-  Effect.fn("SessionPrompt.resolvePromptParts")(function* (template: string) {
-    const ctx = yield* InstanceState.context
-    const parts: Types.DeepMutable<PromptInput["parts"]> = [{ type: "text", text: template }]
-    const files = ConfigMarkdown.files(template)
-    const seen = new Set<string>()
-    yield* Effect.forEach(
-      files,
-      Effect.fnUntraced(function* (match: RegExpExecArray) {
-        const name = match[1]
-        if (seen.has(name)) return
-        seen.add(name)
-        const filepath = name.startsWith("~/")
-          ? path.join(os.homedir(), name.slice(2))
-          : path.resolve(ctx.worktree, name)
-        const info = yield* deps.fsys.stat(filepath).pipe(Effect.option)
-        if (Option.isNone(info)) {
-          const found = yield* deps.agents.get(name)
-          if (found) parts.push({ type: "agent", name: found.name })
-          return
-        }
-        const stat = info.value
-        parts.push({
-          type: "file",
-          url: pathToFileURL(filepath).href,
-          filename: name,
-          mime: stat.type === "Directory" ? "application/x-directory" : "text/plain",
-        })
-      }),
-      { concurrency: "unbounded", discard: true },
-    )
-    return parts
-  })

package/src/session/prompt-schemas.ts

@@ -1,128 +0,0 @@
-import z from "zod"
-import { SessionID, MessageID, PartID } from "./schema"
-import { MessageV2 } from "./message-v2"
-import { ModelID, ProviderID } from "../provider/schema"
-import { type Tool as AITool, tool, jsonSchema } from "ai"
-import type { JSONSchema7 } from "@ai-sdk/provider"
-import { Schema } from "effect"
-import { zod } from "@/util/effect-zod"
-import { withStatics } from "@/util/schema"
-
-export const STRUCTURED_OUTPUT_DESCRIPTION = `Use this tool to return your final response in the requested structured format.
-
-IMPORTANT:
-- You MUST call this tool exactly once at the end of your response
-- The input must be valid JSON matching the required schema
-- Complete all necessary research and tool calls BEFORE calling this tool
-- This tool provides your final answer - no further actions are taken after calling it`
-
-export const STRUCTURED_OUTPUT_SYSTEM_PROMPT = `IMPORTANT: The user has requested structured output. You MUST use the StructuredOutput tool to provide your final response. Do NOT respond with plain text - you MUST call the StructuredOutput tool with your answer formatted according to the schema.`
-
-export const REQUEST_PRUNE_BYTES = 1_250_000
-
-const ModelRef = Schema.Struct({
-  providerID: ProviderID,
-  modelID: ModelID,
-})
-
-export const PromptInput = Schema.Struct({
-  sessionID: SessionID,
-  messageID: Schema.optional(MessageID),
-  model: Schema.optional(ModelRef),
-  agent: Schema.optional(Schema.String),
-  noReply: Schema.optional(Schema.Boolean),
-  tools: Schema.optional(Schema.Record(Schema.String, Schema.Boolean)).annotate({
-    description:
-      "@deprecated tools and permissions have been merged, you can set permissions on the session itself now",
-  }),
-  format: Schema.optional(MessageV2.Format),
-  system: Schema.optional(Schema.String),
-  variant: Schema.optional(Schema.String),
-  editorContext: Schema.optional(MessageV2.EditorContext),
-  parts: Schema.Array(
-    Schema.Union([
-      MessageV2.TextPartInput,
-      MessageV2.FilePartInput,
-      MessageV2.AgentPartInput,
-      MessageV2.SubtaskPartInput,
-    ]).annotate({ discriminator: "type" }),
-  ),
-}).pipe(withStatics((s) => ({ zod: zod(s) })))
-
-type PartInputUnion =
-  | MessageV2.TextPartInput
-  | MessageV2.FilePartInput
-  | MessageV2.AgentPartInput
-  | MessageV2.SubtaskPartInput
-export type PromptInput = Omit<Schema.Schema.Type<typeof PromptInput>, "parts" | "editorContext"> & {
-  parts: PartInputUnion[]
-  editorContext?: MessageV2.EditorContext
-}
-
-export class LoopInput extends Schema.Class<LoopInput>("SessionPrompt.LoopInput")({
-  sessionID: SessionID,
-}) {
-  static readonly zod = zod(this)
-}
-
-export const ShellInput = Schema.Struct({
-  sessionID: SessionID,
-  messageID: Schema.optional(MessageID),
-  agent: Schema.String,
-  model: Schema.optional(ModelRef),
-  command: Schema.String,
-}).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type ShellInput = Schema.Schema.Type<typeof ShellInput>
-
-export const CommandInput = Schema.Struct({
-  messageID: Schema.optional(MessageID),
-  sessionID: SessionID,
-  agent: Schema.optional(Schema.String),
-  model: Schema.optional(Schema.String),
-  arguments: Schema.String,
-  command: Schema.String,
-  variant: Schema.optional(Schema.String),
-  parts: Schema.optional(
-    Schema.Array(
-      Schema.Union([
-        Schema.Struct({
-          id: Schema.optional(PartID),
-          type: Schema.Literal("file"),
-          mime: Schema.String,
-          filename: Schema.optional(Schema.String),
-          url: Schema.String,
-          source: Schema.optional(MessageV2.FilePartSource),
-        }),
-      ]).annotate({ discriminator: "type" }),
-    ),
-  ),
-}).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type CommandInput = Schema.Schema.Type<typeof CommandInput>
-
-export const bashRegex = /!`([^`]+)`/g
-export const argsRegex = /(?:\[Image\s+\d+\]|"[^"]*"|'[^']*'|[^\s"']+)/gi
-export const placeholderRegex = /\$(\d+)/g
-export const quoteTrimRegex = /^["']|["']$/g
-
-/** @internal Exported for testing */
-export function createStructuredOutputTool(input: {
-  schema: Record<string, any>
-  onSuccess: (output: unknown) => void
-}): AITool {
-  const { $schema: _, ...toolSchema } = input.schema
-  return tool({
-    description: STRUCTURED_OUTPUT_DESCRIPTION,
-    inputSchema: jsonSchema(toolSchema as JSONSchema7),
-    async execute(args) {
-      input.onSuccess(args)
-      return {
-        output: "Structured output captured successfully.",
-        title: "Structured Output",
-        metadata: { valid: true },
-      }
-    },
-    toModelOutput({ output }) {
-      return { type: "text", value: output.output }
-    },
-  })
-}

package/src/session/prompt-title.ts

@@ -1,55 +0,0 @@
-import { Effect, Cause, Stream } from "effect"
-import * as Log from "@saeeol/core/util/log"
-import * as EffectLogger from "@saeeol/core/effect/logger"
-import * as Session from "./session"
-import { MessageV2 } from "./message-v2"
-import type { PromptDeps } from "./prompt-types"
-
-const elog = EffectLogger.create({ service: "session.prompt" })
-
-export const ensureTitle = (deps: PromptDeps) =>
-  Effect.fn("SessionPrompt.ensureTitle")(function* (input: {
-    session: Session.Info
-    history: MessageV2.WithParts[]
-    providerID: any
-    modelID: any
-  }) {
-    if (input.session.parentID) return
-    if (!Session.isDefaultTitle(input.session.title)) return
-    const real = (m: MessageV2.WithParts) =>
-      m.info.role === "user" && !m.parts.every((p) => "synthetic" in p && p.synthetic)
-    const idx = input.history.findIndex(real)
-    if (idx === -1) return
-    if (input.history.filter(real).length !== 1) return
-    const context = input.history.slice(0, idx + 1)
-    const firstUser = context[idx]
-    if (!firstUser || firstUser.info.role !== "user") return
-    const firstInfo = firstUser.info
-    const subtasks = firstUser.parts.filter((p): p is MessageV2.SubtaskPart => p.type === "subtask")
-    const onlySubtasks = subtasks.length > 0 && firstUser.parts.every((p) => p.type === "subtask")
-    const ag = yield* deps.agents.get("title")
-    if (!ag) return
-    const mdl = ag.model
-      ? yield* deps.provider.getModel(ag.model.providerID, ag.model.modelID)
-      : ((yield* deps.provider.getSmallModel(input.providerID)) ??
-        (yield* deps.provider.getModel(input.providerID, input.modelID)))
-    const msgs = onlySubtasks
-      ? [{ role: "user" as const, content: subtasks.map((p) => p.prompt).join("\n") }]
-      : yield* MessageV2.toModelMessagesEffect(context, mdl)
-    const text = yield* deps.llm.stream({
-      agent: ag, user: firstInfo, system: [], small: true, tools: {}, model: mdl,
-      sessionID: input.session.id, retries: 2,
-      messages: [{ role: "user", content: "Generate a title for this conversation:\n" }, ...msgs],
-    }).pipe(
-      Stream.filter((e: any): e is Extract<any, { type: "text-delta" }> => e.type === "text-delta"),
-      Stream.map((e: any) => e.text),
-      Stream.mkString,
-      Effect.orDie,
-    )
-    const cleaned = text.replace(/<think[\s\S]*?<\/think>\s*/g, "")
-      .split("\n").map((l: string) => l.trim()).find((l: string) => l.length > 0)
-    if (!cleaned) return
-    const t = cleaned.length > 100 ? cleaned.substring(0, 97) + "..." : cleaned
-    yield* deps.sessions.setTitle({ sessionID: input.session.id, title: t })
-      .pipe(Effect.catchCause((cause) => elog.error("failed to generate title", { error: Cause.squash(cause) })))
-  })