saeeol 1.1.0 → 1.2.0

package/src/session/prompt-title.ts

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

package/src/session/prompt-types.ts

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

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

@@ -0,0 +1,80 @@
+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)

package/src/session/prompt.ts

@@ -0,0 +1,211 @@
+// @ts-ignore
+globalThis.AI_SDK_LOG_WARNINGS = false
+
+import { Effect, Layer, Scope, Latch, Context } from "effect"
+import { ChildProcessSpawner } from "effect/unstable/process"
+import { CrossSpawnSpawner } from "@saeeol/core/cross-spawn-spawner"
+import { SaeeolSessionPrompt } from "@/saeeol/session/prompt"
+import { SaeeolSessionPromptQueue } from "@/saeeol/session/prompt-queue"
+import { SaeeolSession } from "@/saeeol/session"
+import { SaeeolSessionProcessor } from "@/saeeol/session/processor"
+import { Suggestion } from "@/saeeol/suggestion"
+import { Question } from "@/question"
+import { SessionID, MessageID } from "./schema"
+import { MessageV2 } from "./message-v2"
+import { makeRuntime } from "@/effect/run-service"
+import { InstanceState } from "@/effect/instance-state"
+import { EffectBridge } from "@/effect/bridge"
+import { SessionRunState } from "./run-state"
+import { SessionStatus } from "./status"
+import { SessionCompaction } from "./compaction"
+import { SessionProcessor } from "./processor"
+import { Command } from "../command"
+import { Permission } from "@/permission"
+import { MCP } from "../mcp"
+import { LSP } from "@/lsp/lsp"
+import { ToolRegistry } from "@/tool/registry"
+import { Truncate } from "@/tool/truncate"
+import { Provider } from "@/provider/provider"
+import { Config } from "@/config/config"
+import { Instruction } from "./instruction"
+import { AppFileSystem } from "@saeeol/core/filesystem"
+import { Plugin } from "../plugin"
+import { Session as SessionMod } from "./session"
+import { SessionRevert } from "./revert"
+import { SessionSummary } from "./summary"
+import { Agent } from "../agent/agent"
+import { SystemPrompt } from "./system"
+import { LLM } from "./llm"
+import { Bus } from "../bus"
+import { Service as ResolveToolsService, defaultLayer as resolveToolsLayer } from "./resolve-tools"
+import { Service as UserPartService, defaultLayer as userPartLayer } from "./user-part"
+import { Service as SubtaskService, defaultLayer as subtaskLayer } from "./subtask"
+import { Service as ShellService, defaultLayer as shellLayer } from "./shell-exec"
+import { type PromptInput, type ShellInput, type CommandInput, LoopInput } from "./prompt-schemas"
+import { type Interface, Service } from "./prompt-types"
+import { resolvePromptParts } from "./prompt-resolve"
+import { getModel, lastModel, lastAssistant } from "./prompt-model"
+import { createUserMessage } from "./prompt-user-msg"
+import { ensureTitle } from "./prompt-title"
+import { insertReminders } from "./prompt-reminders"
+import { commandHandler } from "./prompt-command"
+import { createRunLoop } from "./prompt-loop"
+
+export const shouldAskPlanFollowup = SaeeolSessionPrompt.shouldAskPlanFollowup
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const bus = yield* Bus.Service
+    const status = yield* SessionStatus.Service
+    const sessions = yield* SessionMod.Service
+    const agents = yield* Agent.Service
+    const provider = yield* Provider.Service
+    const processor = yield* SessionProcessor.Service
+    const compaction = yield* SessionCompaction.Service
+    const plugin = yield* Plugin.Service
+    const commands = yield* Command.Service
+    const config = yield* Config.Service
+    const permission = yield* Permission.Service
+    const fsys = yield* AppFileSystem.Service
+    const mcp = yield* MCP.Service
+    const lsp = yield* LSP.Service
+    const registry = yield* ToolRegistry.Service
+    const truncate = yield* Truncate.Service
+    const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
+    const scope = yield* Scope.Scope
+    const instruction = yield* Instruction.Service
+    const state = yield* SessionRunState.Service
+    const revert = yield* SessionRevert.Service
+    const summary = yield* SessionSummary.Service
+    const sys = yield* SystemPrompt.Service
+    const llm = yield* LLM.Service
+    const resolveToolsSvc = yield* ResolveToolsService
+    const userPartSvc = yield* UserPartService
+    const subtaskSvc = yield* SubtaskService
+    const shellSvc = yield* ShellService
+
+    const deps = {
+      bus, status, sessions, agents, provider, processor, compaction, plugin,
+      commands, config, permission, fsys, mcp, lsp, registry, truncate,
+      spawner, scope, instruction, state, revert, summary, sys, llm,
+      resolveToolsSvc, userPartSvc, subtaskSvc, shellSvc,
+    }
+
+    const resolvePromptPartsFn = resolvePromptParts(deps as any)
+    const getModelFn = getModel(deps as any)
+    const lastModelFn = lastModel(deps as any)
+    const lastAssistantFn = lastAssistant(deps as any)
+    const createUserMessageFn = createUserMessage(deps as any)
+    const ensureTitleFn = ensureTitle(deps as any)
+    const insertRemindersFn = insertReminders(deps as any, SaeeolSessionPrompt)
+    const commandFn = commandHandler(deps as any, SaeeolSessionProcessor.markReviewTelemetry.bind(SaeeolSessionProcessor))
+
+    const cancel = Effect.fn("SessionPrompt.cancel")(function* (sessionID: SessionID) {
+      yield* SaeeolSessionPromptQueue.cancel(sessionID)
+      SaeeolSessionPrompt.abortPlanFollowup(sessionID)
+      yield* state.cancel(sessionID)
+    })
+
+    const { runLoop, loop, shell } = createRunLoop(
+      deps as any,
+      {
+        getModel: getModelFn,
+        lastModel: lastModelFn,
+        lastAssistant: lastAssistantFn,
+        createUserMessage: createUserMessageFn,
+        ensureTitle: ensureTitleFn,
+        insertReminders: insertRemindersFn,
+        resolvePromptParts: resolvePromptPartsFn,
+        commandHandler: commandFn,
+        SaeeolSessionPrompt,
+        SaeeolSessionPromptQueue,
+        SaeeolSession,
+        SaeeolSessionProcessor,
+      } as any,
+    )
+
+    let promptFn: any
+
+    const promptImpl = Effect.fn("SessionPrompt.prompt")(function* (input: PromptInput) {
+      return yield* promptFn(input)
+    })
+
+    promptFn = Effect.fn("SessionPrompt.prompt")(function* (input: PromptInput) {
+      const session = yield* sessions.get(input.sessionID)
+      yield* revert.cleanup(session)
+      yield* SaeeolSessionPrompt.recoverDanglingAssistant({ sessionID: input.sessionID, status, sessions })
+      yield* SaeeolSessionPrompt.recoverProviderFinishError({ sessionID: input.sessionID, status, sessions })
+      const message = yield* createUserMessageFn(input)
+      yield* sessions.touch(input.sessionID)
+      const permissions: Permission.Ruleset = []
+      for (const [t, enabled] of Object.entries(input.tools ?? {})) {
+        permissions.push({ permission: t, action: enabled ? "allow" : "deny", pattern: "*" })
+      }
+      if (permissions.length > 0) {
+        session.permission = permissions
+        yield* sessions.setPermission({ sessionID: session.id, permission: permissions })
+      }
+      yield* Effect.promise(() => Suggestion.dismissAll(input.sessionID))
+      yield* Effect.promise(() => Question.dismissAll(input.sessionID))
+      if (input.noReply === true) return message
+      return yield* (SaeeolSessionPromptQueue.enqueue as any)(
+        input.sessionID, message.info.id,
+        loop({ sessionID: input.sessionID }),
+        lastAssistantFn(input.sessionID),
+      )
+    })
+
+    return Service.of({
+      cancel,
+      prompt: promptFn,
+      loop: loop as any,
+      shell: shell as any,
+      command: commandFn as any,
+      resolvePromptParts: resolvePromptPartsFn as any,
+    })
+  }),
+)
+
+export const defaultLayer = Layer.suspend(() =>
+  layer.pipe(
+    Layer.provide(
+      Layer.mergeAll(
+        resolveToolsLayer, userPartLayer, subtaskLayer, shellLayer,
+        SessionRunState.defaultLayer, SessionStatus.defaultLayer,
+        SessionCompaction.defaultLayer, SessionProcessor.defaultLayer,
+        Command.defaultLayer, Permission.defaultLayer, MCP.defaultLayer,
+        LSP.defaultLayer, ToolRegistry.defaultLayer, Truncate.defaultLayer,
+        Provider.defaultLayer, Config.defaultLayer, Instruction.defaultLayer,
+        AppFileSystem.defaultLayer, Plugin.defaultLayer, SessionMod.defaultLayer,
+        SessionRevert.defaultLayer, SessionSummary.defaultLayer, Agent.defaultLayer,
+        SystemPrompt.defaultLayer, LLM.defaultLayer, Bus.layer,
+        CrossSpawnSpawner.defaultLayer,
+      ),
+    ),
+  ),
+)
+
+export { Service } from "./prompt-types"
+export type { Interface } from "./prompt-types"
+
+export {
+  PromptInput,
+  type PromptInput as PromptInputType,
+  ShellInput,
+  type ShellInput as ShellInputType,
+  CommandInput,
+  type CommandInput as CommandInputType,
+  LoopInput,
+  createStructuredOutputTool,
+  STRUCTURED_OUTPUT_DESCRIPTION, STRUCTURED_OUTPUT_SYSTEM_PROMPT,
+  REQUEST_PRUNE_BYTES,
+  bashRegex, argsRegex, placeholderRegex, quoteTrimRegex,
+} from "./prompt-schemas"
+
+const { runPromise } = makeRuntime(Service, defaultLayer)
+export const prompt = (input: PromptInput) => runPromise((svc) => svc.prompt(input))
+export const loopExport = (input: LoopInput) => runPromise((svc) => svc.loop(input))
+export const cancel = (sessionID: SessionID) => runPromise((svc) => svc.cancel(sessionID))
+
+export * as SessionPrompt from "./prompt"

package/src/session/resolve-tools.ts

@@ -0,0 +1,241 @@
+import { type Tool as AITool, tool, jsonSchema, type ToolExecutionOptions, asSchema } from "ai"
+import { Effect, Context, Layer } from "effect"
+import * as EffectZod from "@/util/effect-zod"
+import { ModelID, ProviderID } from "../provider/schema"
+import { SessionID, PartID } from "./schema"
+import { MessageV2 } from "./message-v2"
+import * as Session from "./session"
+import { Agent } from "../agent/agent"
+import { Provider } from "@/provider/provider"
+import { ProviderTransform } from "@/provider/transform"
+import { ToolRegistry } from "@/tool/registry"
+import { MCP } from "../mcp"
+import { Plugin } from "../plugin"
+import { Permission } from "@/permission"
+import { Truncate } from "@/tool/truncate"
+import { SessionProcessor } from "./processor"
+import { SaeeolSessionPrompt } from "@/saeeol/session/prompt" 
+import { EffectBridge } from "@/effect/bridge"
+import { Tool } from "@/tool/tool"
+import { type TaskPromptOps } from "@/tool/task"
+import * as Log from "@saeeol/core/util/log"
+
+const log = Log.create({ service: "session.resolve-tools" })
+
+export interface ResolveToolsInput {
+  agent: Agent.Info
+  model: Provider.Model
+  session: Session.Info
+  tools?: Record<string, boolean>
+  processor: Pick<SessionProcessor.Handle, "message" | "updateToolCall" | "completeToolCall">
+  bypassAgentCheck: boolean
+  messages: MessageV2.WithParts[]
+}
+
+export interface Interface {
+  readonly resolve: (input: ResolveToolsInput) => Effect.Effect<Record<string, AITool>>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@saeeol/SessionResolveTools") {}
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const registry = yield* ToolRegistry.Service
+    const plugin = yield* Plugin.Service
+    const permission = yield* Permission.Service
+    const mcp = yield* MCP.Service
+    const truncate = yield* Truncate.Service
+
+    const resolve = Effect.fn("SessionResolveTools.resolve")(function* (input: ResolveToolsInput) {
+      using _ = log.time("resolveTools")
+      const tools: Record<string, AITool> = {}
+      const bridge = yield* EffectBridge.make()
+      const promptOps: TaskPromptOps = {
+        cancel: (sessionID: SessionID) => Effect.void,
+        resolvePromptParts: (template: string) => Effect.succeed([{ type: "text" as const, text: template }]) as any,
+        prompt: (_input: any) => Effect.fail(new Error("not available")) as any,
+      }
+
+      const context = (args: any, options: ToolExecutionOptions): Tool.Context => ({
+        sessionID: input.session.id,
+        abort: options.abortSignal!,
+        messageID: input.processor.message.id,
+        callID: options.toolCallId,
+        extra: { model: input.model, bypassAgentCheck: input.bypassAgentCheck, promptOps },
+        agent: input.agent.name,
+        messages: input.messages,
+        metadata: (val: any) =>
+          input.processor.updateToolCall(options.toolCallId, (match) => {
+            if (!["running", "pending"].includes(match.state.status)) return match
+            return {
+              ...match,
+              state: {
+                title: val.title,
+                metadata: val.metadata,
+                status: "running",
+                input: args,
+                time: { start: Date.now() },
+              },
+            }
+          }),
+        ask: (req: any) =>
+          permission
+            .ask({
+              ...req,
+              sessionID: input.session.id,
+              tool: { messageID: input.processor.message.id, callID: options.toolCallId },
+              ruleset: Permission.merge(
+                input.agent.permission,
+                SaeeolSessionPrompt.guardPermissions({ agent: input.agent, session: input.session }),
+              ),
+              hardRuleset: SaeeolSessionPrompt.hardPermissions({ agent: input.agent }),
+            })
+            .pipe(Effect.orDie),
+      })
+
+      for (const item of yield* registry.tools({
+        modelID: ModelID.make(input.model.api.id),
+        providerID: input.model.providerID,
+        agent: input.agent,
+      })) {
+        const schema = ProviderTransform.schema(input.model, EffectZod.toJsonSchema(item.parameters))
+        tools[item.id] = tool({
+          description: item.description,
+          inputSchema: jsonSchema(schema),
+          execute(args, options) {
+            return bridge.promise(
+              Effect.gen(function* () {
+                const ctx = context(args, options)
+                yield* plugin.trigger(
+                  "tool.execute.before",
+                  { tool: item.id, sessionID: ctx.sessionID, callID: ctx.callID },
+                  { args },
+                )
+                const result = yield* item.execute(args, ctx)
+                const output = {
+                  ...result,
+                  attachments: result.attachments?.map((attachment) => ({
+                    ...attachment,
+                    id: PartID.ascending(),
+                    sessionID: ctx.sessionID,
+                    messageID: input.processor.message.id,
+                  })),
+                }
+                yield* plugin.trigger(
+                  "tool.execute.after",
+                  { tool: item.id, sessionID: ctx.sessionID, callID: ctx.callID, args },
+                  output,
+                )
+                if (options.abortSignal?.aborted) {
+                  yield* input.processor.completeToolCall(options.toolCallId, output)
+                }
+                return output
+              }),
+            )
+          },
+        })
+      }
+
+      for (const [key, item] of Object.entries(yield* mcp.tools())) {
+        const execute = item.execute
+        if (!execute) continue
+        const schema = yield* Effect.promise(() => Promise.resolve(asSchema(item.inputSchema).jsonSchema))
+        const transformed = ProviderTransform.schema(input.model, schema)
+        item.inputSchema = jsonSchema(transformed)
+        item.execute = (args, opts) =>
+          bridge.promise(
+            Effect.gen(function* () {
+              const ctx = context(args, opts)
+              yield* plugin.trigger(
+                "tool.execute.before",
+                { tool: key, sessionID: ctx.sessionID, callID: opts.toolCallId },
+                { args },
+              )
+              const result: Awaited<ReturnType<NonNullable<typeof execute>>> = yield* Effect.gen(function* () {
+                yield* ctx.ask({ permission: key, metadata: {}, patterns: ["*"], always: ["*"] })
+                return yield* Effect.promise(() => execute(args, opts))
+              }).pipe(
+                Effect.withSpan("Tool.execute", {
+                  attributes: {
+                    "tool.name": key,
+                    "tool.call_id": opts.toolCallId,
+                    "session.id": ctx.sessionID,
+                    "message.id": input.processor.message.id,
+                  },
+                }),
+              )
+              yield* plugin.trigger(
+                "tool.execute.after",
+                { tool: key, sessionID: ctx.sessionID, callID: opts.toolCallId, args },
+                result,
+              )
+
+              const textParts: string[] = []
+              const attachments: Omit<MessageV2.FilePart, "id" | "sessionID" | "messageID">[] = []
+              for (const contentItem of result.content) {
+                if (contentItem.type === "text") textParts.push(contentItem.text)
+                else if (contentItem.type === "image") {
+                  attachments.push({
+                    type: "file",
+                    mime: contentItem.mimeType,
+                    url: `data:${contentItem.mimeType};base64,${contentItem.data}`,
+                  })
+                } else if (contentItem.type === "resource") {
+                  const { resource } = contentItem
+                  if (resource.text) textParts.push(resource.text)
+                  if (resource.blob) {
+                    attachments.push({
+                      type: "file",
+                      mime: resource.mimeType ?? "application/octet-stream",
+                      url: `data:${resource.mimeType ?? "application/octet-stream"};base64,${resource.blob}`,
+                      filename: resource.uri,
+                    })
+                  }
+                }
+              }
+
+              const truncated = yield* truncate.output(textParts.join("\n\n"), {}, input.agent)
+              const metadata = {
+                ...result.metadata,
+                truncated: truncated.truncated,
+                ...(truncated.truncated && { outputPath: truncated.outputPath }),
+              }
+              const output = {
+                title: "",
+                metadata,
+                output: truncated.content,
+                attachments: attachments.map((attachment) => ({
+                  ...attachment,
+                  id: PartID.ascending(),
+                  sessionID: ctx.sessionID,
+                  messageID: input.processor.message.id,
+                })),
+                content: result.content,
+              }
+              if (opts.abortSignal?.aborted) {
+                yield* input.processor.completeToolCall(opts.toolCallId, output)
+              }
+              return output
+            }),
+          )
+        tools[key] = item
+      }
+
+      return tools
+    })
+
+    return { resolve }
+  }),
+)
+
+export const defaultLayer = Layer.suspend(() =>
+  layer.pipe(
+    Layer.provide(ToolRegistry.defaultLayer),
+    Layer.provide(MCP.defaultLayer),
+    Layer.provide(Plugin.defaultLayer),
+    Layer.provide(Permission.defaultLayer),
+    Layer.provide(Truncate.defaultLayer),
+    Layer.provide(Provider.defaultLayer),
+  ),
+)