saeeol 1.2.0 → 1.2.2

package/src/tool/task.ts

@@ -1,197 +1 @@
-import * as Tool from "./tool"
-import DESCRIPTION from "./task.txt"
-import { Session } from "@/session/session"
-import { SessionID, MessageID } from "../session/schema"
-import { MessageV2 } from "../session/message-v2"
-import { Agent } from "../agent/agent"
-import type { SessionPrompt } from "../session/prompt"
-import { Config } from "@/config/config"
-import { SaeeolTask } from "../overlay/tool/task" 
-import { SaeeolCostPropagation } from "../overlay/session/cost-propagation" 
-import { SaeeolSessionProcessor } from "../overlay/session/processor" 
-import { Effect, Schema } from "effect"
-
-export interface TaskPromptOps {
-  cancel(sessionID: SessionID): void
-  resolvePromptParts(template: string): Effect.Effect<SessionPrompt.PromptInput["parts"]>
-  prompt(input: SessionPrompt.PromptInput): Effect.Effect<MessageV2.WithParts>
-}
-
-const id = "task"
-
-export const Parameters = Schema.Struct({
-  description: Schema.String.annotate({ description: "A short (3-5 words) description of the task" }),
-  prompt: Schema.String.annotate({ description: "The task for the agent to perform" }),
-  subagent_type: Schema.String.annotate({ description: "The type of specialized agent to use for this task" }),
-  task_id: Schema.optional(Schema.String).annotate({
-    description:
-      "This should only be set if you mean to resume a previous task (you can pass a prior task_id and the task will continue the same subagent session as before instead of creating a fresh one)",
-  }),
-  command: Schema.optional(Schema.String).annotate({ description: "The command that triggered this task" }),
-})
-
-export const TaskTool = Tool.define(
-  id,
-  Effect.gen(function* () {
-    const agent = yield* Agent.Service
-    const config = yield* Config.Service
-    const sessions = yield* Session.Service
-
-    const run = Effect.fn("TaskTool.execute")(function* (
-      params: Schema.Schema.Type<typeof Parameters>,
-      ctx: Tool.Context,
-    ) {
-      const cfg = yield* config.get()
-
-      if (!ctx.extra?.bypassAgentCheck) {
-        yield* ctx.ask({
-          permission: id,
-          patterns: [params.subagent_type],
-          always: ["*"],
-          metadata: {
-            description: params.description,
-            subagent_type: params.subagent_type,
-          },
-        })
-      }
-
-      const next = yield* agent.get(params.subagent_type)
-      if (!next) {
-        return yield* Effect.fail(new Error(`Unknown agent type: ${params.subagent_type} is not a valid agent type`))
-      }
-      SaeeolTask.validate(next, params.subagent_type)
-
-      const canTask = SaeeolTask.nestedTask() 
-      const canTodo = next.permission.some((rule) => rule.permission === "todowrite")
-
-      const parent = yield* sessions.get(ctx.sessionID)
-      const caller = yield* agent.get(ctx.agent)
-      const rules = SaeeolTask.inherited({ caller, session: parent, mcp: cfg.mcp })
-
-      const taskID = params.task_id
-      const session = taskID
-        ? yield* sessions.get(SessionID.make(taskID)).pipe(Effect.catchCause(() => Effect.succeed(undefined)))
-        : undefined
-      const nextSession =
-        session ??
-        (yield* sessions.create({
-          parentID: ctx.sessionID,
-          title: params.description + ` (@${next.name} subagent)`,
-          permission: [
-            ...(parent.permission ?? []).filter(
-              (rule) => rule.permission === "external_directory" || rule.action === "deny",
-            ),
-            ...(canTodo
-              ? []
-              : [
-                  {
-                    permission: "todowrite" as const,
-                    pattern: "*" as const,
-                    action: "deny" as const,
-                  },
-                ]),
-            ...(canTask
-              ? []
-              : [
-                  {
-                    permission: id,
-                    pattern: "*" as const,
-                    action: "deny" as const,
-                  },
-                ]),
-            ...(cfg.experimental?.primary_tools?.map((item) => ({
-              pattern: "*",
-              action: "allow" as const,
-              permission: item,
-            })) ?? []),
-            ...SaeeolTask.permissions(rules),
-          ],
-        }))
-
-      const msg = yield* Effect.sync(() => MessageV2.get({ sessionID: ctx.sessionID, messageID: ctx.messageID }))
-      if (msg.info.role !== "assistant") return yield* Effect.fail(new Error("Not an assistant message"))
-      const saved = yield* SaeeolTask.resolveModel(next.name)
-      const model = saved ??
-        next.model ?? {
-          modelID: msg.info.modelID,
-          providerID: msg.info.providerID,
-        }
-      const variant = saved?.variant ?? (saved ? undefined : next.variant)
-
-      yield* ctx.metadata({
-        title: params.description,
-        metadata: {
-          sessionId: nextSession.id,
-          model,
-          variant, 
-        },
-      })
-
-      const ops = ctx.extra?.promptOps as TaskPromptOps
-      if (!ops) return yield* Effect.fail(new Error("TaskTool requires promptOps in ctx.extra"))
-
-      const messageID = MessageID.ascending()
-
-      function cancel() {
-        ops.cancel(nextSession.id)
-      }
-
-      return yield* Effect.acquireUseRelease(
-        Effect.gen(function* () {
-          ctx.abort.addEventListener("abort", cancel)
-          return yield* SaeeolCostPropagation.childCost(sessions, nextSession.id)
-        }),
-        () =>
-          Effect.gen(function* () {
-            const parts = yield* ops.resolvePromptParts(params.prompt)
-            SaeeolSessionProcessor.markReviewTelemetry(parts, params.command) 
-            const result = yield* ops.prompt({
-              messageID,
-              sessionID: nextSession.id,
-              model: {
-                modelID: model.modelID,
-                providerID: model.providerID,
-              },
-              variant, 
-              agent: next.name,
-              tools: {
-                ...(canTodo ? {} : { todowrite: false }),
-                ...(canTask ? {} : { task: false }),
-                ...Object.fromEntries((cfg.experimental?.primary_tools ?? []).map((item) => [item, false])),
-              },
-              parts,
-            })
-
-            return {
-              title: params.description,
-              metadata: {
-                sessionId: nextSession.id,
-                model,
-                variant, 
-              },
-              output: [
-                `task_id: ${nextSession.id} (for resuming to continue this task if needed)`,
-                "",
-                "<task_result>",
-                result.parts.findLast((item) => item.type === "text")?.text ?? "",
-                "</task_result>",
-              ].join("\n"),
-            }
-          }),
-        (costBefore) =>
-          Effect.gen(function* () {
-            ctx.abort.removeEventListener("abort", cancel)
-            const costAfter = yield* SaeeolCostPropagation.childCost(sessions, nextSession.id)
-            yield* SaeeolCostPropagation.propagate(sessions, ctx.sessionID, ctx.messageID, costAfter - costBefore)
-          }),
-      )
-    })
-
-    return {
-      description: DESCRIPTION,
-      parameters: Parameters,
-      execute: (params: Schema.Schema.Type<typeof Parameters>, ctx: Tool.Context) =>
-        run(params, ctx).pipe(Effect.orDie),
-    }
-  }),
-)
+export * from "./workflow/task"

package/src/tool/todo.ts

@@ -1,62 +1 @@
-import { Effect, Schema } from "effect"
-import * as Tool from "./tool"
-import DESCRIPTION_WRITE from "./todowrite.txt"
-import { Todo } from "../session/todo"
-import { TodoView } from "../overlay/todo-view"
-
-// Todo.Info is still a zod schema (session/todo.ts). Inline the field shape
-// here rather than referencing its `.shape` — the LLM-visible JSON Schema is
-// identical, and it removes the last zod dependency from this tool.
-const TodoItem = Schema.Struct({
-  content: Schema.String.annotate({ description: "Brief description of the task" }),
-  status: Schema.String.annotate({
-    description: "Current status of the task: pending, in_progress, completed, cancelled",
-  }),
-  priority: Schema.String.annotate({ description: "Priority level of the task: high, medium, low" }),
-})
-
-export const Parameters = Schema.Struct({
-  todos: Schema.mutable(Schema.Array(TodoItem)).annotate({ description: "The updated todo list" }),
-})
-
-type Metadata = {
-  todos: Todo.Info[]
-  view?: TodoView.Info
-}
-
-export const TodoWriteTool = Tool.define<typeof Parameters, Metadata, Todo.Service>(
-  "todowrite",
-  Effect.gen(function* () {
-    const todo = yield* Todo.Service
-
-    return {
-      description: DESCRIPTION_WRITE,
-      parameters: Parameters,
-      execute: (params: Schema.Schema.Type<typeof Parameters>, ctx: Tool.Context<Metadata>) =>
-        Effect.gen(function* () {
-          yield* ctx.ask({
-            permission: "todowrite",
-            patterns: ["*"],
-            always: ["*"],
-            metadata: {},
-          })
-          const before = yield* todo.get(ctx.sessionID)
-          const view = TodoView.calculate(before, params.todos)
-
-          yield* todo.update({
-            sessionID: ctx.sessionID,
-            todos: params.todos,
-          })
-
-          return {
-            title: `${params.todos.filter((x) => x.status !== "completed").length} todos`,
-            output: JSON.stringify(params.todos, null, 2),
-            metadata: {
-              todos: params.todos,
-              view,
-            },
-          }
-        }),
-    } satisfies Tool.DefWithoutID<typeof Parameters, Metadata>
-  }),
-)
+export * from "./workflow/todo"

package/src/tool/tool.ts

@@ -1,162 +1 @@
-import { Effect, Schema } from "effect"
-import type { MessageV2 } from "../session/message-v2"
-import type { Permission } from "../permission"
-import type { SessionID, MessageID } from "../session/schema"
-import * as Truncate from "./truncate"
-import { Agent } from "@/agent/agent"
-
-interface Metadata {
-  [key: string]: any
-}
-
-// TODO: remove this hack
-export type DynamicDescription = (agent: Agent.Info) => Effect.Effect<string>
-
-export type Context<M extends Metadata = Metadata> = {
-  sessionID: SessionID
-  messageID: MessageID
-  agent: string
-  abort: AbortSignal
-  callID?: string
-  extra?: { [key: string]: unknown }
-  messages: MessageV2.WithParts[]
-  metadata(input: { title?: string; metadata?: M }): Effect.Effect<void>
-  ask(input: Omit<Permission.Request, "id" | "sessionID" | "tool">): Effect.Effect<void>
-}
-
-export interface ExecuteResult<M extends Metadata = Metadata> {
-  title: string
-  metadata: M
-  output: string
-  attachments?: Omit<MessageV2.FilePart, "id" | "sessionID" | "messageID">[]
-}
-
-export interface Def<
-  Parameters extends Schema.Decoder<unknown> = Schema.Decoder<unknown>,
-  M extends Metadata = Metadata,
-> {
-  id: string
-  description: string
-  parameters: Parameters
-  execute(args: Schema.Schema.Type<Parameters>, ctx: Context): Effect.Effect<ExecuteResult<M>>
-  formatValidationError?(error: unknown): string
-}
-export type DefWithoutID<
-  Parameters extends Schema.Decoder<unknown> = Schema.Decoder<unknown>,
-  M extends Metadata = Metadata,
-> = Omit<Def<Parameters, M>, "id">
-
-export interface Info<
-  Parameters extends Schema.Decoder<unknown> = Schema.Decoder<unknown>,
-  M extends Metadata = Metadata,
-> {
-  id: string
-  init: () => Effect.Effect<DefWithoutID<Parameters, M>>
-}
-
-type Init<Parameters extends Schema.Decoder<unknown>, M extends Metadata> =
-  | DefWithoutID<Parameters, M>
-  | (() => Effect.Effect<DefWithoutID<Parameters, M>>)
-
-export type InferParameters<T> =
-  T extends Info<infer P, any>
-    ? Schema.Schema.Type<P>
-    : T extends Effect.Effect<Info<infer P, any>, any, any>
-      ? Schema.Schema.Type<P>
-      : never
-export type InferMetadata<T> =
-  T extends Info<any, infer M> ? M : T extends Effect.Effect<Info<any, infer M>, any, any> ? M : never
-
-export type InferDef<T> =
-  T extends Info<infer P, infer M>
-    ? Def<P, M>
-    : T extends Effect.Effect<Info<infer P, infer M>, any, any>
-      ? Def<P, M>
-      : never
-
-function wrap<Parameters extends Schema.Decoder<unknown>, Result extends Metadata>(
-  id: string,
-  init: Init<Parameters, Result>,
-  truncate: Truncate.Interface,
-  agents: Agent.Interface,
-) {
-  return () =>
-    Effect.gen(function* () {
-      const toolInfo = typeof init === "function" ? { ...(yield* init()) } : { ...init }
-      // Compile the parser closure once per tool init; `decodeUnknownEffect`
-      // allocates a new closure per call, so hoisting avoids re-closing it for
-      // every LLM tool invocation.
-      const decode = Schema.decodeUnknownEffect(toolInfo.parameters)
-      const execute = toolInfo.execute
-      toolInfo.execute = (args, ctx) => {
-        const attrs = {
-          "tool.name": id,
-          "session.id": ctx.sessionID,
-          "message.id": ctx.messageID,
-          ...(ctx.callID ? { "tool.call_id": ctx.callID } : {}),
-        }
-        return Effect.gen(function* () {
-          const decoded = yield* decode(args).pipe(
-            Effect.mapError((error) =>
-              toolInfo.formatValidationError
-                ? new Error(toolInfo.formatValidationError(error), { cause: error })
-                : new Error(
-                    `The ${id} tool was called with invalid arguments: ${error}.\nPlease rewrite the input so it satisfies the expected schema.`,
-                    { cause: error },
-                  ),
-            ),
-          )
-          const result = yield* execute(decoded as Schema.Schema.Type<Parameters>, ctx)
-          if (result.metadata.truncated !== undefined) {
-            return result
-          }
-          const agent = yield* agents.get(ctx.agent)
-          const truncated = yield* truncate.output(result.output, {}, agent)
-          return {
-            ...result,
-            output: truncated.content,
-            metadata: {
-              ...result.metadata,
-              truncated: truncated.truncated,
-              ...(truncated.truncated && { outputPath: truncated.outputPath }),
-            },
-          }
-        }).pipe(Effect.orDie, Effect.withSpan("Tool.execute", { attributes: attrs }))
-      }
-      return toolInfo
-    })
-}
-
-export function define<
-  Parameters extends Schema.Decoder<unknown>,
-  Result extends Metadata,
-  R,
-  ID extends string = string,
->(
-  id: ID,
-  init: Effect.Effect<Init<Parameters, Result>, never, R>,
-): Effect.Effect<Info<Parameters, Result>, never, R | Truncate.Service | Agent.Service> & { id: ID } {
-  return Object.assign(
-    Effect.gen(function* () {
-      const resolved = yield* init
-      const truncate = yield* Truncate.Service
-      const agents = yield* Agent.Service
-      return { id, init: wrap(id, resolved, truncate, agents) }
-    }),
-    { id },
-  )
-}
-
-export function init<P extends Schema.Decoder<unknown>, M extends Metadata>(
-  info: Info<P, M>,
-): Effect.Effect<Def<P, M>> {
-  return Effect.gen(function* () {
-    const init = yield* info.init()
-    return {
-      ...init,
-      id: info.id,
-    }
-  })
-}
-
-export * as Tool from "./tool"
+export * from "./core/tool"

package/src/tool/truncate.ts

@@ -1,160 +1 @@
-import { NodePath } from "@effect/platform-node"
-import { Cause, Duration, Effect, Layer, Option, Schedule, Context } from "effect"
-import path from "path"
-import type { Agent } from "../agent/agent"
-import { AppFileSystem } from "@saeeol/core/filesystem"
-import { evaluate } from "@/permission/evaluate"
-import { Config } from "@/config/config"
-import { Identifier } from "../id/id"
-import * as Log from "@saeeol/core/util/log"
-import { ToolID } from "./schema"
-import { TRUNCATION_DIR } from "./truncation-dir"
-
-const log = Log.create({ service: "truncation" })
-const RETENTION = Duration.days(7)
-
-export const MAX_LINES = 2000
-export const MAX_BYTES = 50 * 1024
-export const DIR = TRUNCATION_DIR
-export const GLOB = path.join(TRUNCATION_DIR, "*")
-
-export type Result = { content: string; truncated: false } | { content: string; truncated: true; outputPath: string }
-
-export interface Options {
-  maxLines?: number
-  maxBytes?: number
-  direction?: "head" | "tail"
-}
-
-function hasTaskTool(agent?: Agent.Info) {
-  if (!agent?.permission) return false
-  return evaluate("task", "*", agent.permission).action !== "deny"
-}
-
-export interface Interface {
-  readonly cleanup: () => Effect.Effect<void>
-  readonly write: (text: string) => Effect.Effect<string>
-  /**
-   * Returns output unchanged when it fits within the limits, otherwise writes the full text
-   * to the truncation directory and returns a preview plus a hint to inspect the saved file.
-   */
-  readonly output: (text: string, options?: Options, agent?: Agent.Info) => Effect.Effect<Result>
-  /**
-   * Resolved truncation limits: values from `tool_output` in saeeol config, or MAX_LINES / MAX_BYTES if unset.
-   */
-  readonly limits: () => Effect.Effect<{ maxLines: number; maxBytes: number }>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@saeeol/Truncate") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const fs = yield* AppFileSystem.Service
-
-    const cleanup = Effect.fn("Truncate.cleanup")(function* () {
-      const cutoff = Identifier.timestamp(
-        Identifier.create("tool", "ascending", Date.now() - Duration.toMillis(RETENTION)),
-      )
-      const entries = yield* fs.readDirectory(TRUNCATION_DIR).pipe(
-        Effect.map((all) => all.filter((name) => name.startsWith("tool_"))),
-        Effect.catch(() => Effect.succeed([])),
-      )
-      for (const entry of entries) {
-        if (Identifier.timestamp(entry) >= cutoff) continue
-        yield* fs.remove(path.join(TRUNCATION_DIR, entry)).pipe(Effect.catch(() => Effect.void))
-      }
-    })
-
-    const write = Effect.fn("Truncate.write")(function* (text: string) {
-      const file = path.join(TRUNCATION_DIR, ToolID.ascending())
-      yield* fs.ensureDir(TRUNCATION_DIR).pipe(Effect.orDie)
-      yield* fs.writeFileString(file, text).pipe(Effect.orDie)
-      return file
-    })
-
-    const limits = Effect.fn("Truncate.limits")(function* () {
-      const configSvc = yield* Effect.serviceOption(Config.Service)
-      if (Option.isNone(configSvc)) return { maxLines: MAX_LINES, maxBytes: MAX_BYTES }
-      const cfg = yield* configSvc.value.get().pipe(Effect.catch(() => Effect.succeed(undefined)))
-      return {
-        maxLines: cfg?.tool_output?.max_lines ?? MAX_LINES,
-        maxBytes: cfg?.tool_output?.max_bytes ?? MAX_BYTES,
-      }
-    })
-
-    const output = Effect.fn("Truncate.output")(function* (text: string, options: Options = {}, agent?: Agent.Info) {
-      const resolved = yield* limits()
-      const maxLines = options.maxLines ?? resolved.maxLines
-      const maxBytes = options.maxBytes ?? resolved.maxBytes
-      const direction = options.direction ?? "head"
-      const lines = text.split("\n")
-      const totalBytes = Buffer.byteLength(text, "utf-8")
-
-      if (lines.length <= maxLines && totalBytes <= maxBytes) {
-        return { content: text, truncated: false } as const
-      }
-
-      const out: string[] = []
-      let i = 0
-      let bytes = 0
-      let hitBytes = false
-
-      if (direction === "head") {
-        for (i = 0; i < lines.length && i < maxLines; i++) {
-          const size = Buffer.byteLength(lines[i], "utf-8") + (i > 0 ? 1 : 0)
-          if (bytes + size > maxBytes) {
-            hitBytes = true
-            break
-          }
-          out.push(lines[i])
-          bytes += size
-        }
-      } else {
-        for (i = lines.length - 1; i >= 0 && out.length < maxLines; i--) {
-          const size = Buffer.byteLength(lines[i], "utf-8") + (out.length > 0 ? 1 : 0)
-          if (bytes + size > maxBytes) {
-            hitBytes = true
-            break
-          }
-          out.unshift(lines[i])
-          bytes += size
-        }
-      }
-
-      const removed = hitBytes ? totalBytes - bytes : lines.length - out.length
-      const unit = hitBytes ? "bytes" : "lines"
-      const preview = out.join("\n")
-      const file = yield* write(text)
-
-      const hint = hasTaskTool(agent)
-        ? `The tool call succeeded but the output was truncated. Full output saved to: ${file}\nUse the Task tool to have explore agent process this file with Grep and Read (with offset/limit). Do NOT read the full file yourself - delegate to save context.`
-        : `The tool call succeeded but the output was truncated. Full output saved to: ${file}\nUse Grep to search the full content or Read with offset/limit to view specific sections.`
-
-      return {
-        content:
-          direction === "head"
-            ? `${preview}\n\n...${removed} ${unit} truncated...\n\n${hint}`
-            : `...${removed} ${unit} truncated...\n\n${hint}\n\n${preview}`,
-        truncated: true,
-        outputPath: file,
-      } as const
-    })
-
-    yield* cleanup().pipe(
-      Effect.catchCause((cause) => {
-        log.error("truncation cleanup failed", { cause: Cause.pretty(cause) })
-        return Effect.void
-      }),
-      Effect.repeat(Schedule.spaced(Duration.hours(1))),
-      Effect.delay(Duration.minutes(1)),
-      Effect.forkScoped,
-    )
-
-    return Service.of({ cleanup, write, output, limits })
-  }),
-)
-
-export const defaultLayer = layer.pipe(Layer.provide(AppFileSystem.defaultLayer), Layer.provide(NodePath.layer))
-
-export * as Truncate from "./truncate"
+export * from "./core/truncate"

package/src/tool/truncation-dir.ts

@@ -1,4 +1 @@
-import path from "path"
-import { Global } from "@saeeol/core/global"
-
-export const TRUNCATION_DIR = path.join(Global.Path.data, "tool-output")
+export * from "./core/truncation-dir"