saeeol 1.1.1 → 1.2.1

package/src/session/shell-exec.ts

@@ -1,205 +1 @@
-import { ulid } from "ulid"
-import { Effect, Context, Layer, Exit, Cause, Latch } from "effect"
-import { MessageID, PartID } from "./schema"
-import { MessageV2 } from "./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-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),
-  ),
-)
+export * from "./core/shell-exec"

package/src/session/status.ts

@@ -1,100 +1 @@
-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"
+export * from "./core/status"

package/src/session/subtask.ts

@@ -1,268 +1 @@
-import { ulid } from "ulid"
-import { Effect, Context, Layer, Cause } from "effect"
-import { MessageID, PartID, SessionID } from "./schema"
-import { MessageV2 } from "./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),
-  ),
-)
+export * from "./core/subtask"