saeeol 1.1.1 → 1.2.1

package/src/session/core/shell-exec.ts

@@ -0,0 +1,205 @@
+import { ulid } from "ulid"
+import { Effect, Context, Layer, Exit, Cause, Latch } from "effect"
+import { MessageID, PartID } from "./schema"
+import { MessageV2 } from "../message/message-v2"
+import * as Session from "./session"
+import { Agent } from "../../agent/agent"
+import { Provider } from "@/provider/provider"
+import { ProviderID, ModelID } from "../../provider/schema"
+import { Bus } from "../../bus"
+import { Plugin } from "../../plugin"
+import { Config } from "@/config/config"
+import { Shell } from "@/shell/shell"
+import { SessionRevert } from "./revert"
+import { InstanceState } from "@/effect/instance-state"
+import { ChildProcess } from "effect/unstable/process"
+import { ChildProcessSpawner } from "effect/unstable/process"
+import { CrossSpawnSpawner } from "@saeeol/core/cross-spawn-spawner"
+import * as Stream from "effect/Stream"
+import { NamedError } from "@saeeol/core/util/error"
+import type { ShellInput } from "../prompt/prompt-schemas"
+
+export interface Interface {
+  readonly exec: (
+    input: ShellInput,
+        getModel: (p: ProviderID, m: ModelID, s: any) => Effect.Effect<Provider.Model>,
+        lastModel: (s: any) => Effect.Effect<any>,
+    ready?: Latch.Latch,
+  ) => Effect.Effect<MessageV2.WithParts>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@saeeol/SessionShell") {}
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const sessions = yield* Session.Service
+    const agents = yield* Agent.Service
+    const bus = yield* Bus.Service
+    const plugin = yield* Plugin.Service
+    const config = yield* Config.Service
+    const revert = yield* SessionRevert.Service
+    const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
+
+    const exec = Effect.fn("SessionShell.exec")(function* (
+      input: ShellInput,
+      getModel: (p: ProviderID, m: ModelID, s: any) => Effect.Effect<Provider.Model>,
+      lastModel: (s: any) => Effect.Effect<any>,
+      ready?: Latch.Latch,
+    ) {
+      return yield* Effect.uninterruptibleMask((restore) =>
+        Effect.gen(function* () {
+          const markReady = ready ? ready.open.pipe(Effect.asVoid) : Effect.void
+          const { msg, part, cwd } = yield* Effect.gen(function* () {
+            const ctx = yield* InstanceState.context
+            const session = yield* sessions.get(input.sessionID)
+            if (session.revert) {
+              yield* revert.cleanup(session)
+            }
+            const agent = yield* agents.get(input.agent)
+            if (!agent) {
+              const available = (yield* 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: "${input.agent}".${hint}` })
+              yield* bus.publish(Session.Event.Error, { sessionID: input.sessionID, error: error.toObject() })
+              throw error
+            }
+            const model = input.model ?? agent.model ?? (yield* lastModel(input.sessionID))!
+            const userMsg: MessageV2.User = {
+              id: input.messageID ?? MessageID.ascending(),
+              sessionID: input.sessionID,
+              time: { created: Date.now() },
+              role: "user",
+              agent: input.agent,
+              model: { providerID: model.providerID, modelID: model.modelID },
+            }
+            yield* sessions.updateMessage(userMsg)
+            const userPart: MessageV2.Part = {
+              type: "text",
+              id: PartID.ascending(),
+              messageID: userMsg.id,
+              sessionID: input.sessionID,
+              text: "The following tool was executed by the user",
+              synthetic: true,
+            }
+            yield* sessions.updatePart(userPart)
+
+            const msg: MessageV2.Assistant = {
+              id: MessageID.ascending(),
+              sessionID: input.sessionID,
+              parentID: userMsg.id,
+              mode: input.agent,
+              agent: input.agent,
+              cost: 0,
+              path: { cwd: ctx.directory, root: ctx.worktree },
+              time: { created: Date.now() },
+              role: "assistant",
+              tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+              modelID: model.modelID,
+              providerID: model.providerID,
+            }
+            yield* sessions.updateMessage(msg)
+            const part: MessageV2.ToolPart = {
+              type: "tool",
+              id: PartID.ascending(),
+              messageID: msg.id,
+              sessionID: input.sessionID,
+              tool: "bash",
+              callID: ulid(),
+              state: {
+                status: "running",
+                time: { start: Date.now() },
+                input: { command: input.command },
+              },
+            }
+            yield* sessions.updatePart(part)
+            return { msg, part, cwd: ctx.directory }
+          }).pipe(Effect.ensuring(markReady))
+
+          const cfg = yield* config.get()
+          const sh = Shell.preferred(cfg.shell)
+          const args = Shell.args(sh, input.command, cwd)
+          let output = ""
+          let aborted = false
+
+          const finish = Effect.uninterruptible(
+            Effect.gen(function* () {
+              if (aborted) {
+                output += "\n\n" + ["<metadata>", "User aborted the command", "</metadata>"].join("\n")
+              }
+              if (!msg.time.completed) {
+                msg.time.completed = Date.now()
+                yield* sessions.updateMessage(msg)
+              }
+              if (part.state.status === "running") {
+                part.state = {
+                  status: "completed",
+                  time: { ...part.state.time, end: Date.now() },
+                  input: part.state.input,
+                  title: "",
+                  metadata: { output, description: "" },
+                  output,
+                }
+                yield* sessions.updatePart(part)
+              }
+            }),
+          )
+
+          const exit = yield* restore(
+            Effect.gen(function* () {
+              const shellEnv = yield* plugin.trigger(
+                "shell.env",
+                { cwd, sessionID: input.sessionID, callID: part.callID },
+                { env: {} },
+              )
+              const cmd = ChildProcess.make(sh, args, {
+                cwd,
+                extendEnv: true,
+                env: { ...shellEnv.env, TERM: "dumb" },
+                stdin: "ignore",
+                forceKillAfter: "3 seconds",
+              })
+              const handle = yield* spawner.spawn(cmd)
+              yield* Stream.runForEach(Stream.decodeText(handle.all), (chunk) =>
+                Effect.gen(function* () {
+                  output += chunk
+                  if (part.state.status === "running") {
+                    part.state.metadata = { output, description: "" }
+                    yield* sessions.updatePart(part)
+                  }
+                }),
+              )
+              yield* handle.exitCode
+            }).pipe(Effect.scoped, Effect.orDie),
+          ).pipe(Effect.exit)
+
+          if (Exit.isFailure(exit) && Cause.hasInterrupts(exit.cause) && !Cause.hasDies(exit.cause)) {
+            aborted = true
+          }
+          yield* finish
+
+          if (Exit.isFailure(exit) && !aborted && !Cause.hasInterruptsOnly(exit.cause)) {
+            return yield* Effect.failCause(exit.cause)
+          }
+
+          return { info: msg, parts: [part] }
+        }),
+      )
+    })
+
+    return { exec }
+  }),
+)
+
+export const defaultLayer = Layer.suspend(() =>
+  layer.pipe(
+    Layer.provide(Session.defaultLayer),
+    Layer.provide(Agent.defaultLayer),
+    Layer.provide(Plugin.defaultLayer),
+    Layer.provide(Config.defaultLayer),
+    Layer.provide(SessionRevert.defaultLayer),
+    Layer.provide(Provider.defaultLayer),
+    Layer.provide(Bus.layer),
+    Layer.provide(CrossSpawnSpawner.defaultLayer),
+  ),
+)

package/src/session/core/status.ts

@@ -0,0 +1,100 @@
+import { BusEvent } from "@/bus/bus-event"
+import { Bus } from "@/bus"
+import { InstanceState } from "@/effect/instance-state"
+import { SessionID } from "./schema"
+import { QuestionID } from "@/question/schema" 
+import { makeRuntime } from "@/effect/run-service" 
+import { zod } from "@/util/effect-zod"
+import { NonNegativeInt, withStatics } from "@/util/schema"
+import { Effect, Layer, Context, Schema } from "effect"
+import z from "zod"
+
+export const Info = Schema.Union([
+  Schema.Struct({
+    type: Schema.Literal("idle"),
+  }),
+  Schema.Struct({
+    type: Schema.Literal("retry"),
+    attempt: NonNegativeInt,
+    message: Schema.String,
+    next: NonNegativeInt,
+  }),
+  Schema.Struct({
+    type: Schema.Literal("busy"),
+  }),
+  Schema.Struct({
+    type: Schema.Literal("offline"),
+    requestID: QuestionID,
+    message: Schema.String,
+  }),
+])
+  .annotate({ identifier: "SessionStatus" })
+  .pipe(withStatics((s) => ({ zod: zod(s) })))
+export type Info = Schema.Schema.Type<typeof Info>
+
+export const Event = {
+  Status: BusEvent.define(
+    "session.status",
+    Schema.Struct({
+      sessionID: SessionID,
+      status: Info,
+    }),
+  ),
+  // deprecated
+  Idle: BusEvent.define(
+    "session.idle",
+    Schema.Struct({
+      sessionID: SessionID,
+    }),
+  ),
+}
+
+export interface Interface {
+  readonly get: (sessionID: SessionID) => Effect.Effect<Info>
+  readonly list: () => Effect.Effect<Map<SessionID, Info>>
+  readonly set: (sessionID: SessionID, status: Info) => Effect.Effect<void>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@saeeol/SessionStatus") {}
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const bus = yield* Bus.Service
+
+    const state = yield* InstanceState.make(
+      Effect.fn("SessionStatus.state")(() => Effect.succeed(new Map<SessionID, Info>())),
+    )
+
+    const get = Effect.fn("SessionStatus.get")(function* (sessionID: SessionID) {
+      const data = yield* InstanceState.get(state)
+      return data.get(sessionID) ?? { type: "idle" as const }
+    })
+
+    const list = Effect.fn("SessionStatus.list")(function* () {
+      return new Map(yield* InstanceState.get(state))
+    })
+
+    const set = Effect.fn("SessionStatus.set")(function* (sessionID: SessionID, status: Info) {
+      const data = yield* InstanceState.get(state)
+      yield* bus.publish(Event.Status, { sessionID, status })
+      if (status.type === "idle") {
+        yield* bus.publish(Event.Idle, { sessionID })
+        data.delete(sessionID)
+        return
+      }
+      data.set(sessionID, status)
+    })
+
+    return Service.of({ get, list, set })
+  }),
+)
+
+export const defaultLayer = layer.pipe(Layer.provide(Bus.layer))
+const { runPromise } = makeRuntime(Service, defaultLayer)
+
+export const list = () => runPromise((svc) => svc.list())
+export const get = (sessionID: SessionID) => runPromise((svc) => svc.get(sessionID))
+export const set = (sessionID: SessionID, status: Info) => runPromise((svc) => svc.set(sessionID, status))
+
+export * as SessionStatus from "./status"

package/src/session/core/subtask.ts

@@ -0,0 +1,268 @@
+import { ulid } from "ulid"
+import { Effect, Context, Layer, Cause } from "effect"
+import { MessageID, PartID, SessionID } from "./schema"
+import { MessageV2 } from "../message/message-v2"
+import * as Session from "./session"
+import { Agent } from "../../agent/agent"
+import { Provider } from "@/provider/provider"
+import { ProviderID, ModelID } from "../../provider/schema"
+import { Bus } from "../../bus"
+import { Permission } from "@/permission"
+import { Plugin } from "../../plugin"
+import { ToolRegistry } from "@/tool/registry"
+import { TaskTool, type TaskPromptOps } from "@/tool/task"
+import { EffectBridge } from "@/effect/bridge"
+import { NamedError } from "@saeeol/core/util/error"
+import { InstanceState } from "@/effect/instance-state"
+import { SaeeolSessionPrompt } from "@/saeeol/session/prompt" 
+import { SaeeolCostPropagation } from "@/saeeol/session/cost-propagation" 
+import * as Log from "@saeeol/core/util/log"
+
+const log = Log.create({ service: "session.subtask" })
+
+export interface SubtaskInput {
+  task: MessageV2.SubtaskPart
+  model: Provider.Model
+  lastUser: MessageV2.User
+  sessionID: SessionID
+  session: Session.Info
+  msgs: MessageV2.WithParts[]
+  getModel: (p: ProviderID, m: ModelID, s: SessionID) => Effect.Effect<Provider.Model>
+  promptOps: TaskPromptOps
+}
+
+export interface Interface {
+  readonly handle: (input: SubtaskInput) => Effect.Effect<void>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@saeeol/SessionSubtask") {}
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const sessions = yield* Session.Service
+    const agents = yield* Agent.Service
+    const bus = yield* Bus.Service
+    const plugin = yield* Plugin.Service
+    const permission = yield* Permission.Service
+    const registry = yield* ToolRegistry.Service
+    const bridge = yield* EffectBridge.make()
+
+    const handle = Effect.fn("SessionSubtask.handle")(function* (input: SubtaskInput) {
+      const { task, model, lastUser, sessionID, session, msgs } = input
+      const ctx = yield* InstanceState.context
+      const { task: taskTool } = yield* registry.named()
+      const taskModel = task.model ? yield* input.getModel(task.model.providerID, task.model.modelID, sessionID) : model
+      const assistantMessage: MessageV2.Assistant = yield* sessions.updateMessage({
+        id: MessageID.ascending(),
+        role: "assistant",
+        parentID: lastUser.id,
+        sessionID,
+        mode: task.agent,
+        agent: task.agent,
+        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: taskModel.id,
+        providerID: taskModel.providerID,
+        time: { created: Date.now() },
+      })
+      let part: MessageV2.ToolPart = yield* sessions.updatePart({
+        id: PartID.ascending(),
+        messageID: assistantMessage.id,
+        sessionID: assistantMessage.sessionID,
+        type: "tool",
+        callID: ulid(),
+        tool: TaskTool.id,
+        state: {
+          status: "running",
+          input: {
+            prompt: task.prompt,
+            description: task.description,
+            subagent_type: task.agent,
+            command: task.command,
+          },
+          time: { start: Date.now() },
+        },
+      })
+      const taskArgs = {
+        prompt: task.prompt,
+        description: task.description,
+        subagent_type: task.agent,
+        command: task.command,
+      }
+      yield* plugin.trigger(
+        "tool.execute.before",
+        { tool: TaskTool.id, sessionID, callID: part.id },
+        { args: taskArgs },
+      )
+
+      const taskAgent = yield* agents.get(task.agent)
+      if (!taskAgent) {
+        const available = (yield* 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: "${task.agent}".${hint}` })
+        yield* bus.publish(Session.Event.Error, { sessionID, error: error.toObject() })
+        throw error
+      }
+
+      let error: Error | undefined
+      const taskAbort = new AbortController()
+      const childID = () => {
+        const meta = part.state.status !== "pending" ? part.state.metadata : undefined
+        return (meta as { sessionId?: string } | undefined)?.sessionId
+      }
+
+      const result = yield* taskTool
+        .execute(taskArgs, {
+          agent: task.agent,
+          messageID: assistantMessage.id,
+          sessionID,
+          abort: taskAbort.signal,
+          callID: part.callID,
+          extra: { bypassAgentCheck: true, promptOps: input.promptOps },
+          messages: msgs,
+          metadata: (val: any) =>
+            Effect.gen(function* () {
+              part = yield* sessions.updatePart({
+                ...part,
+                type: "tool",
+                state: { ...part.state, ...val },
+              } satisfies MessageV2.ToolPart)
+            }),
+          ask: (req: any) =>
+            permission
+              .ask({
+                ...req,
+                sessionID,
+                ruleset: Permission.merge(
+                  taskAgent.permission,
+                  SaeeolSessionPrompt.guardPermissions({ agent: taskAgent, session }),
+                ),
+                hardRuleset: SaeeolSessionPrompt.hardPermissions({ agent: taskAgent }),
+              })
+              .pipe(Effect.orDie),
+        })
+        .pipe(
+          Effect.catchCause((cause) => {
+            const defect = Cause.squash(cause)
+            error = defect instanceof Error ? defect : new Error(String(defect))
+            log.error("subtask execution failed", { error, agent: task.agent, description: task.description })
+            return Effect.void
+          }),
+          Effect.onInterrupt(() =>
+            Effect.gen(function* () {
+              taskAbort.abort()
+              assistantMessage.finish = "tool-calls"
+              assistantMessage.time.completed = Date.now()
+              const cid = childID()
+              if (cid) {
+                assistantMessage.cost = yield* SaeeolCostPropagation.childCost(sessions, SessionID.make(cid))
+              }
+              yield* sessions.updateMessage(assistantMessage)
+              if (part.state.status === "running") {
+                yield* sessions.updatePart({
+                  ...part,
+                  state: {
+                    status: "error",
+                    error: "Cancelled",
+                    time: { start: part.state.time.start, end: Date.now() },
+                    metadata: part.state.metadata,
+                    input: part.state.input,
+                  },
+                } satisfies MessageV2.ToolPart)
+              }
+            }),
+          ),
+        )
+
+      const attachments = result?.attachments?.map((attachment: any) => ({
+        ...attachment,
+        id: PartID.ascending(),
+        sessionID,
+        messageID: assistantMessage.id,
+      }))
+
+      yield* plugin.trigger(
+        "tool.execute.after",
+        { tool: TaskTool.id, sessionID, callID: part.id, args: taskArgs },
+        result,
+      )
+
+      assistantMessage.finish = "tool-calls"
+      assistantMessage.time.completed = Date.now()
+      const cid = result?.metadata?.sessionId ?? childID()
+      if (cid) {
+        assistantMessage.cost = yield* SaeeolCostPropagation.childCost(sessions, SessionID.make(cid))
+      }
+      yield* sessions.updateMessage(assistantMessage)
+
+      if (result && part.state.status === "running") {
+        yield* sessions.updatePart({
+          ...part,
+          state: {
+            status: "completed",
+            input: part.state.input,
+            title: result.title,
+            metadata: result.metadata,
+            output: result.output,
+            attachments,
+            time: { ...part.state.time, end: Date.now() },
+          },
+        } satisfies MessageV2.ToolPart)
+      }
+
+      if (!result) {
+        yield* sessions.updatePart({
+          ...part,
+          state: {
+            status: "error",
+            error: error ? `Tool execution failed: ${error.message}` : "Tool execution failed",
+            time: {
+              start: part.state.status === "running" ? part.state.time.start : Date.now(),
+              end: Date.now(),
+            },
+            metadata: part.state.status === "pending" ? undefined : part.state.metadata,
+            input: part.state.input,
+          },
+        } satisfies MessageV2.ToolPart)
+      }
+
+      if (!task.command) return
+
+      const summaryUserMsg: MessageV2.User = {
+        id: MessageID.ascending(),
+        sessionID,
+        role: "user",
+        time: { created: Date.now() },
+        agent: lastUser.agent,
+        model: lastUser.model,
+        editorContext: lastUser.editorContext,
+      }
+      yield* sessions.updateMessage(summaryUserMsg)
+      yield* sessions.updatePart({
+        id: PartID.ascending(),
+        messageID: summaryUserMsg.id,
+        sessionID,
+        type: "text",
+        text: "Summarize the task tool output above and continue with your task.",
+        synthetic: true,
+      } satisfies MessageV2.TextPart)
+    })
+
+    return { handle }
+  }),
+)
+
+export const defaultLayer = Layer.suspend(() =>
+  layer.pipe(
+    Layer.provide(Session.defaultLayer),
+    Layer.provide(Agent.defaultLayer),
+    Layer.provide(Plugin.defaultLayer),
+    Layer.provide(Permission.defaultLayer),
+    Layer.provide(ToolRegistry.defaultLayer),
+    Layer.provide(Provider.defaultLayer),
+    Layer.provide(Bus.layer),
+  ),
+)