saeeol 1.2.0 → 1.2.2

package/src/session/prompt-reminders.ts

@@ -1,120 +1 @@
-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"
-import * as LTM from "@/ltm"
-
-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,
-        })
-      }
-
-      // LTM retrieval — inject relevant long-term memories into the prompt
-      const cfg = yield* deps.config.get()
-      if (cfg?.ltm?.enabled) {
-        const userText = userMessage.parts
-          .filter((p) => p.type === "text")
-          .map((p) => (p as any).text ?? "")
-          .join(" ")
-          .slice(0, 500)
-        if (userText.length > 10) {
-          const ltmCfg = {
-            ...LTM.Config.DEFAULT_LTM_CONFIG,
-            ...cfg.ltm,
-            episodic: { ...LTM.Config.DEFAULT_LTM_CONFIG.episodic, ...cfg.ltm.episodic },
-            semantic: { ...LTM.Config.DEFAULT_LTM_CONFIG.semantic, ...cfg.ltm.semantic },
-            procedural: { ...LTM.Config.DEFAULT_LTM_CONFIG.procedural, ...cfg.ltm.procedural },
-            retrieval: { ...LTM.Config.DEFAULT_LTM_CONFIG.retrieval, ...cfg.ltm.retrieval },
-          }
-          const context = yield* Effect.promise(() => LTM.Retrieval.inject(userText, ltmCfg))
-          if (context) {
-            userMessage.parts.push({
-              id: PartID.ascending(), messageID: userMessage.info.id,
-              sessionID: userMessage.info.sessionID, type: "text", text: `\n${context}`, 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
-  })
+export * from "./prompt/prompt-reminders"

package/src/session/prompt-resolve.ts

@@ -1,42 +1 @@
-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
-  })
+export * from "./prompt/prompt-resolve"

package/src/session/prompt-schemas.ts

@@ -1,128 +1 @@
-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 }
-    },
-  })
-}
+export * from "./prompt/prompt-schemas"

package/src/session/prompt-title.ts

@@ -1,55 +1 @@
-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) })))
-  })
+export * from "./prompt/prompt-title"

package/src/session/prompt-types.ts

@@ -1,47 +1 @@
-import { Effect, Context, Types, Option, Scope, Exit, Cause, Latch, Layer } from "effect"
-import { SessionID, MessageID, PartID } from "./schema"
-import { MessageV2 } from "./message-v2"
-import type { PromptInput, ShellInput, CommandInput, LoopInput } from "./prompt-schemas"
-import type { ModelID, ProviderID } from "../provider/schema"
-
-export interface Interface {
-  readonly cancel: (sessionID: SessionID) => Effect.Effect<void>
-  readonly prompt: (input: PromptInput) => Effect.Effect<MessageV2.WithParts>
-  readonly loop: (input: LoopInput) => Effect.Effect<MessageV2.WithParts>
-  readonly shell: (input: ShellInput) => Effect.Effect<MessageV2.WithParts>
-  readonly command: (input: CommandInput) => Effect.Effect<MessageV2.WithParts>
-  readonly resolvePromptParts: (template: string) => Effect.Effect<PromptInput["parts"]>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@saeeol/SessionPrompt") {}
-
-export interface PromptDeps {
-  bus: any
-  status: any
-  sessions: any
-  agents: any
-  provider: any
-  processor: any
-  compaction: any
-  plugin: any
-  commands: any
-  config: any
-  permission: any
-  fsys: any
-  mcp: any
-  lsp: any
-  registry: any
-  truncate: any
-  spawner: any
-  scope: Scope.Scope
-  instruction: any
-  state: any
-  revert: any
-  summary: any
-  sys: any
-  llm: any
-  resolveToolsSvc: any
-  userPartSvc: any
-  subtaskSvc: any
-  shellSvc: any
-}
+export * from "./prompt/prompt-types"

package/src/session/prompt-user-msg.ts

@@ -1,80 +1 @@
-import { Effect, Types } from "effect"
-import { 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 { PromptDeps } from "./prompt-types"
-import { getModel, lastModel } from "./prompt-model"
-
-const log = Log.create({ service: "session.prompt" })
-
-export const createUserMessage = (deps: PromptDeps) =>
-  Effect.fn("SessionPrompt.createUserMessage")(function* (input: PromptInput) {
-    const agentName = input.agent || (yield* deps.agents.defaultAgent())
-    const ag = yield* deps.agents.get(agentName)
-    if (!ag) {
-      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(deps.sessions.Event?.Error ?? { type: "session.error" }, { sessionID: input.sessionID, error: error.toObject() })
-      throw error
-    }
-    const model = input.model ?? ag.model ?? (yield* lastModel(deps)(input.sessionID))
-    const same = ag.model && model.providerID === ag.model.providerID && model.modelID === ag.model.modelID
-    const full = !input.variant && ag.variant && same
-      ? yield* deps.provider.getModel(model.providerID, model.modelID).pipe(Effect.catchDefect(() => Effect.void))
-      : undefined
-    const variant = input.variant ?? (ag.variant && full?.variants?.[ag.variant] ? ag.variant : undefined)
-    const info: MessageV2.User = {
-      id: input.messageID ?? MessageID.ascending(),
-      role: "user",
-      sessionID: input.sessionID,
-      time: { created: Date.now() },
-      tools: input.tools,
-      agent: ag.name,
-      model: { providerID: model.providerID, modelID: model.modelID, variant },
-      system: input.system,
-      format: input.format,
-      editorContext: input.editorContext,
-    }
-    yield* Effect.addFinalizer(() => deps.instruction.clear(info.id))
-    type Draft<T> = T extends MessageV2.Part ? Omit<T, "id"> & { id?: string } : never
-    const assign = (part: Draft<MessageV2.Part>): MessageV2.Part => ({
-      ...part,
-      id: part.id ? PartID.make(part.id) : PartID.ascending(),
-    })
-    const resolvePart = (part: PromptInput["parts"][number]) =>
-      deps.userPartSvc.resolve(part, {
-        sessionID: input.sessionID,
-        messageID: info.id,
-        agent: input.agent!,
-        agentPermission: ag.permission,
-        model: info.model,
-      })
-    const parts = yield* Effect.forEach(input.parts, resolvePart, { concurrency: "unbounded" }).pipe(
-      Effect.map((x: any) => x.flat().map(assign)),
-    )
-    yield* deps.plugin.trigger("chat.message", {
-      sessionID: input.sessionID, agent: input.agent, model: input.model,
-      messageID: input.messageID, variant: input.variant,
-    }, { message: info, parts })
-    const parsed = (MessageV2 as any).Info?.zod?.safeParse?.(info) ?? { success: true }
-    if (!parsed.success) {
-      log.error("invalid user message before save", {
-        sessionID: input.sessionID, messageID: info.id, agent: info.agent,
-        model: info.model, issues: parsed.error?.issues,
-      })
-    }
-    parts.forEach((part: any, index: number) => {
-      const p = (MessageV2 as any).Part?.zod?.safeParse?.(part) ?? { success: true }
-      if (p.success) return
-      log.error("invalid user part before save", {
-        sessionID: input.sessionID, messageID: info.id, partID: part.id,
-        partType: part.type, index, issues: p.error?.issues, part,
-      })
-    })
-    yield* deps.sessions.updateMessage(info)
-    for (const part of parts) yield* deps.sessions.updatePart(part)
-    return { info, parts }
-  }, Effect.scoped)
+export * from "./prompt/prompt-user-msg"