Merge branch 'dev' into kit/effectify-tool-registry

Replace the legacy Instance.state() lazy init with an Effect Layer that
yields InstanceContext, defines Interface/Service/layer, and exposes
promise facades for backward compat. Register ToolRegistry.Service in
the Instances layer map.

packages/opencode/specs/effect-migration.md

@@ -127,12 +127,12 @@ Done now:
 Still open and likely worth migrating:
 
 - [ ] `Plugin`
-- [ ] `ToolRegistry`
+- [x] `ToolRegistry`
 - [ ] `Pty`
 - [ ] `Worktree`
 - [ ] `Installation`
 - [ ] `Bus`
-- [x] `Command`
+- [ ] `Command`
 - [ ] `Config`
 - [ ] `Session`
 - [ ] `SessionProcessor`

packages/opencode/src/cli/cmd/tui/routes/session/index.tsx

@@ -1667,6 +1667,7 @@ function InlineTool(props: {
 
   const denied = createMemo(
     () =>
+      error()?.includes("QuestionRejectedError") ||
       error()?.includes("rejected permission") ||
       error()?.includes("specified a rule") ||
       error()?.includes("user dismissed"),

packages/opencode/src/command/index.ts

@@ -1,18 +1,15 @@
 import { BusEvent } from "@/bus/bus-event"
-import { InstanceContext } from "@/effect/instance-context"
-import { runPromiseInstance } from "@/effect/runtime"
 import { SessionID, MessageID } from "@/session/schema"
-import { Effect, Fiber, Layer, ServiceMap } from "effect"
 import z from "zod"
 import { Config } from "../config/config"
+import { Instance } from "../project/instance"
+import { Identifier } from "../id/id"
 import PROMPT_INITIALIZE from "./template/initialize.txt"
 import PROMPT_REVIEW from "./template/review.txt"
 import { MCP } from "../mcp"
 import { Skill } from "../skill"
-import { Log } from "../util/log"
 
 export namespace Command {
-  const log = Log.create({ service: "command" })
   export const Event = {
     Executed: BusEvent.define(
       "command.executed",
@@ -60,126 +57,95 @@ export namespace Command {
     REVIEW: "review",
   } as const
 
-  export interface Interface {
-    readonly get: (name: string) => Effect.Effect<Info | undefined>
-    readonly list: () => Effect.Effect<Info[]>
-  }
+  const state = Instance.state(async () => {
+    const cfg = await Config.get()
 
-  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/Command") {}
+    const result: Record<string, Info> = {
+      [Default.INIT]: {
+        name: Default.INIT,
+        description: "create/update AGENTS.md",
+        source: "command",
+        get template() {
+          return PROMPT_INITIALIZE.replace("${path}", Instance.worktree)
+        },
+        hints: hints(PROMPT_INITIALIZE),
+      },
+      [Default.REVIEW]: {
+        name: Default.REVIEW,
+        description: "review changes [commit|branch|pr], defaults to uncommitted",
+        source: "command",
+        get template() {
+          return PROMPT_REVIEW.replace("${path}", Instance.worktree)
+        },
+        subtask: true,
+        hints: hints(PROMPT_REVIEW),
+      },
+    }
 
-  export const layer = Layer.effect(
-    Service,
-    Effect.gen(function* () {
-      const instance = yield* InstanceContext
+    for (const [name, command] of Object.entries(cfg.command ?? {})) {
+      result[name] = {
+        name,
+        agent: command.agent,
+        model: command.model,
+        description: command.description,
+        source: "command",
+        get template() {
+          return command.template
+        },
+        subtask: command.subtask,
+        hints: hints(command.template),
+      }
+    }
+    for (const [name, prompt] of Object.entries(await MCP.prompts())) {
+      result[name] = {
+        name,
+        source: "mcp",
+        description: prompt.description,
+        get template() {
+          // since a getter can't be async we need to manually return a promise here
+          return new Promise<string>(async (resolve, reject) => {
+            const template = await MCP.getPrompt(
+              prompt.client,
+              prompt.name,
+              prompt.arguments
+                ? // substitute each argument with $1, $2, etc.
+                  Object.fromEntries(prompt.arguments?.map((argument, i) => [argument.name, `$${i + 1}`]))
+                : {},
+            ).catch(reject)
+            resolve(
+              template?.messages
+                .map((message) => (message.content.type === "text" ? message.content.text : ""))
+                .join("\n") || "",
+            )
+          })
+        },
+        hints: prompt.arguments?.map((_, i) => `$${i + 1}`) ?? [],
+      }
+    }
 
-      const commands: Record<string, Info> = {}
+    // Add skills as invokable commands
+    for (const skill of await Skill.all()) {
+      // Skip if a command with this name already exists
+      if (result[skill.name]) continue
+      result[skill.name] = {
+        name: skill.name,
+        description: skill.description,
+        source: "skill",
+        get template() {
+          return skill.content
+        },
+        hints: [],
+      }
+    }
 
-      const load = Effect.fn("Command.load")(function* () {
-        yield* Effect.promise(async () => {
-          const cfg = await Config.get()
-
-          commands[Default.INIT] = {
-            name: Default.INIT,
-            description: "create/update AGENTS.md",
-            source: "command",
-            get template() {
-              return PROMPT_INITIALIZE.replace("${path}", instance.worktree)
-            },
-            hints: hints(PROMPT_INITIALIZE),
-          }
-          commands[Default.REVIEW] = {
-            name: Default.REVIEW,
-            description: "review changes [commit|branch|pr], defaults to uncommitted",
-            source: "command",
-            get template() {
-              return PROMPT_REVIEW.replace("${path}", instance.worktree)
-            },
-            subtask: true,
-            hints: hints(PROMPT_REVIEW),
-          }
-
-          for (const [name, command] of Object.entries(cfg.command ?? {})) {
-            commands[name] = {
-              name,
-              agent: command.agent,
-              model: command.model,
-              description: command.description,
-              source: "command",
-              get template() {
-                return command.template
-              },
-              subtask: command.subtask,
-              hints: hints(command.template),
-            }
-          }
-          for (const [name, prompt] of Object.entries(await MCP.prompts())) {
-            commands[name] = {
-              name,
-              source: "mcp",
-              description: prompt.description,
-              get template() {
-                // since a getter can't be async we need to manually return a promise here
-                return new Promise<string>(async (resolve, reject) => {
-                  const template = await MCP.getPrompt(
-                    prompt.client,
-                    prompt.name,
-                    prompt.arguments
-                      ? // substitute each argument with $1, $2, etc.
-                        Object.fromEntries(prompt.arguments?.map((argument, i) => [argument.name, `$${i + 1}`]))
-                      : {},
-                  ).catch(reject)
-                  resolve(
-                    template?.messages
-                      .map((message) => (message.content.type === "text" ? message.content.text : ""))
-                      .join("\n") || "",
-                  )
-                })
-              },
-              hints: prompt.arguments?.map((_, i) => `$${i + 1}`) ?? [],
-            }
-          }
-
-          // Add skills as invokable commands
-          for (const skill of await Skill.all()) {
-            // Skip if a command with this name already exists
-            if (commands[skill.name]) continue
-            commands[skill.name] = {
-              name: skill.name,
-              description: skill.description,
-              source: "skill",
-              get template() {
-                return skill.content
-              },
-              hints: [],
-            }
-          }
-        })
-      })
-
-      const loadFiber = yield* load().pipe(
-        Effect.catchCause((cause) => Effect.sync(() => log.error("init failed", { cause }))),
-        Effect.forkScoped,
-      )
-
-      const get = Effect.fn("Command.get")(function* (name: string) {
-        yield* Fiber.join(loadFiber)
-        return commands[name]
-      })
-
-      const list = Effect.fn("Command.list")(function* () {
-        yield* Fiber.join(loadFiber)
-        return Object.values(commands)
-      })
-
-      return Service.of({ get, list })
-    }),
-  )
+    return result
+  })
 
   export async function get(name: string) {
-    return runPromiseInstance(Service.use((svc) => svc.get(name)))
+    return state().then((x) => x[name])
   }
 
   export async function list() {
-    return runPromiseInstance(Service.use((svc) => svc.list()))
+    return state().then((x) => Object.values(x))
   }
 }

packages/opencode/src/effect/instances.ts

@@ -1,5 +1,4 @@
 import { Effect, Layer, LayerMap, ServiceMap } from "effect"
-import { Command } from "@/command"
 import { File } from "@/file/service"
 import { FileTime } from "@/file/time-service"
 import { FileWatcher } from "@/file/watcher"
@@ -11,13 +10,13 @@ import { ProviderAuth } from "@/provider/auth-service"
 import { Question } from "@/question/service"
 import { Skill } from "@/skill/service"
 import { Snapshot } from "@/snapshot/service"
+import { ToolRegistry } from "@/tool/registry"
 import { InstanceContext } from "./instance-context"
 import { registerDisposer } from "./instance-registry"
 
 export { InstanceContext } from "./instance-context"
 
 export type InstanceServices =
-  | Command.Service
   | Question.Service
   | Permission.Service
   | ProviderAuth.Service
@@ -28,6 +27,7 @@ export type InstanceServices =
   | File.Service
   | Skill.Service
   | Snapshot.Service
+  | ToolRegistry.Service
 
 // NOTE: LayerMap only passes the key (directory string) to lookup, but we need
 // the full instance context (directory, worktree, project). We read from the
@@ -38,7 +38,6 @@ export type InstanceServices =
 function lookup(_key: string) {
   const ctx = Layer.sync(InstanceContext, () => InstanceContext.of(Instance.current))
   return Layer.mergeAll(
-    Command.layer,
     Question.layer,
     Permission.layer,
     ProviderAuth.defaultLayer,
@@ -49,6 +48,7 @@ function lookup(_key: string) {
     File.layer,
     Skill.defaultLayer,
     Snapshot.defaultLayer,
+    ToolRegistry.layer,
   ).pipe(Layer.provide(ctx))
 }
 

packages/opencode/src/session/prompt.ts

@@ -1782,9 +1782,6 @@ NOTE: At any point in time through this workflow you should feel free to ask the
   export async function command(input: CommandInput) {
     log.info("command", input)
     const command = await Command.get(input.command)
-    if (!command) {
-      throw new NamedError.Unknown({ message: `Command not found: "${input.command}"` })
-    }
     const agentName = command.agent ?? input.agent ?? (await Agent.defaultAgent())
 
     const raw = input.arguments.match(argsRegex) ?? []

packages/opencode/src/tool/registry.ts

@@ -1,132 +1,240 @@
-import { PlanExitTool } from "./plan"
-import { QuestionTool } from "./question"
-import { BashTool } from "./bash"
-import { EditTool } from "./edit"
-import { GlobTool } from "./glob"
-import { GrepTool } from "./grep"
-import { BatchTool } from "./batch"
-import { ReadTool } from "./read"
-import { TaskTool } from "./task"
-import { TodoWriteTool, TodoReadTool } from "./todo"
-import { WebFetchTool } from "./webfetch"
-import { WriteTool } from "./write"
-import { InvalidTool } from "./invalid"
-import { SkillTool } from "./skill"
 import type { Agent } from "../agent/agent"
 import { Tool } from "./tool"
-import { Instance } from "../project/instance"
-import { Config } from "../config/config"
 import path from "path"
 import { type ToolContext as PluginToolContext, type ToolDefinition } from "@opencode-ai/plugin"
 import z from "zod"
-import { Plugin } from "../plugin"
 import { ProviderID, type ModelID } from "../provider/schema"
-import { WebSearchTool } from "./websearch"
-import { CodeSearchTool } from "./codesearch"
 import { Flag } from "@/flag/flag"
 import { Log } from "@/util/log"
-import { LspTool } from "./lsp"
 import { Truncate } from "./truncate"
-
-import { ApplyPatchTool } from "./apply_patch"
 import { Glob } from "../util/glob"
 import { pathToFileURL } from "url"
+import { Effect, Layer, ServiceMap } from "effect"
+import { InstanceContext } from "@/effect/instance-context"
 
 export namespace ToolRegistry {
   const log = Log.create({ service: "tool.registry" })
 
-  export const state = Instance.state(async () => {
-    const custom = [] as Tool.Info[]
+  export interface Interface {
+    readonly register: (tool: Tool.Info) => Effect.Effect<void>
+    readonly ids: () => Effect.Effect<string[]>
+    readonly tools: (
+      model: { providerID: ProviderID; modelID: ModelID },
+      agent?: Agent.Info,
+    ) => Effect.Effect<(Awaited<ReturnType<Tool.Info["init"]>> & { id: string })[]>
+  }
 
-    const matches = await Config.directories().then((dirs) =>
-      dirs.flatMap((dir) =>
-        Glob.scanSync("{tool,tools}/*.{js,ts}", { cwd: dir, absolute: true, dot: true, symlink: true }),
-      ),
-    )
-    if (matches.length) await Config.waitForDependencies()
-    for (const match of matches) {
-      const namespace = path.basename(match, path.extname(match))
-      const mod = await import(process.platform === "win32" ? match : pathToFileURL(match).href)
-      for (const [id, def] of Object.entries<ToolDefinition>(mod)) {
-        custom.push(fromPlugin(id === "default" ? namespace : `${namespace}_${id}`, def))
-      }
-    }
+  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/ToolRegistry") {}
 
-    const plugins = await Plugin.list()
-    for (const plugin of plugins) {
-      for (const [id, def] of Object.entries(plugin.tool ?? {})) {
-        custom.push(fromPlugin(id, def))
-      }
-    }
+  export const layer = Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const instance = yield* InstanceContext
 
-    return { custom }
-  })
+      const custom: Tool.Info[] = []
+      let task: Promise<void> | undefined
 
-  function fromPlugin(id: string, def: ToolDefinition): Tool.Info {
-    return {
-      id,
-      init: async (initCtx) => ({
-        parameters: z.object(def.args),
-        description: def.description,
-        execute: async (args, ctx) => {
-          const pluginCtx = {
-            ...ctx,
-            directory: Instance.directory,
-            worktree: Instance.worktree,
-          } as unknown as PluginToolContext
-          const result = await def.execute(args as any, pluginCtx)
-          const out = await Truncate.output(result, {}, initCtx?.agent)
-          return {
-            title: "",
-            output: out.truncated ? out.content : result,
-            metadata: { truncated: out.truncated, outputPath: out.truncated ? out.outputPath : undefined },
+      const load = Effect.fn("ToolRegistry.load")(function* () {
+        yield* Effect.promise(async () => {
+          const [{ Config }, { Plugin }] = await Promise.all([import("../config/config"), import("../plugin")])
+          const matches = await Config.directories().then((dirs) =>
+            dirs.flatMap((dir) =>
+              Glob.scanSync("{tool,tools}/*.{js,ts}", { cwd: dir, absolute: true, dot: true, symlink: true }),
+            ),
+          )
+          if (matches.length) await Config.waitForDependencies()
+          for (const match of matches) {
+            const namespace = path.basename(match, path.extname(match))
+            const mod = await import(process.platform === "win32" ? match : pathToFileURL(match).href)
+            for (const [id, def] of Object.entries<ToolDefinition>(mod)) {
+              custom.push(fromPlugin(id === "default" ? namespace : `${namespace}_${id}`, def))
+            }
           }
-        },
-      }),
-    }
+
+          const plugins = await Plugin.list()
+          for (const plugin of plugins) {
+            for (const [id, def] of Object.entries(plugin.tool ?? {})) {
+              custom.push(fromPlugin(id, def))
+            }
+          }
+        })
+      })
+
+      const ensure = Effect.fn("ToolRegistry.ensure")(function* () {
+        yield* Effect.promise(() => {
+          task ??= Effect.runPromise(
+            load().pipe(Effect.catchCause((cause) => Effect.sync(() => log.error("init failed", { cause })))),
+          )
+          return task
+        })
+      })
+
+      function fromPlugin(id: string, def: ToolDefinition): Tool.Info {
+        return {
+          id,
+          init: async (initCtx) => ({
+            parameters: z.object(def.args),
+            description: def.description,
+            execute: async (args, ctx) => {
+              const pluginCtx = {
+                ...ctx,
+                directory: instance.directory,
+                worktree: instance.worktree,
+              } as unknown as PluginToolContext
+              const result = await def.execute(args as any, pluginCtx)
+              const out = await Truncate.output(result, {}, initCtx?.agent)
+              return {
+                title: "",
+                output: out.truncated ? out.content : result,
+                metadata: { truncated: out.truncated, outputPath: out.truncated ? out.outputPath : undefined },
+              }
+            },
+          }),
+        }
+      }
+
+      async function all(): Promise<Tool.Info[]> {
+        const { Config } = await import("../config/config")
+        const config = await Config.get()
+        const question = ["app", "cli", "desktop"].includes(Flag.OPENCODE_CLIENT) || Flag.OPENCODE_ENABLE_QUESTION_TOOL
+        const [
+          invalid,
+          questionMod,
+          bash,
+          read,
+          glob,
+          grep,
+          edit,
+          write,
+          task,
+          webfetch,
+          todo,
+          websearch,
+          codesearch,
+          skill,
+          applyPatch,
+          lsp,
+          batch,
+          plan,
+        ] = await Promise.all([
+          import("./invalid"),
+          import("./question"),
+          import("./bash"),
+          import("./read"),
+          import("./glob"),
+          import("./grep"),
+          import("./edit"),
+          import("./write"),
+          import("./task"),
+          import("./webfetch"),
+          import("./todo"),
+          import("./websearch"),
+          import("./codesearch"),
+          import("./skill"),
+          import("./apply_patch"),
+          import("./lsp"),
+          import("./batch"),
+          import("./plan"),
+        ])
+
+        return [
+          invalid.InvalidTool,
+          ...(question ? [questionMod.QuestionTool] : []),
+          bash.BashTool,
+          read.ReadTool,
+          glob.GlobTool,
+          grep.GrepTool,
+          edit.EditTool,
+          write.WriteTool,
+          task.TaskTool,
+          webfetch.WebFetchTool,
+          todo.TodoWriteTool,
+          // TodoReadTool,
+          websearch.WebSearchTool,
+          codesearch.CodeSearchTool,
+          skill.SkillTool,
+          applyPatch.ApplyPatchTool,
+          ...(Flag.OPENCODE_EXPERIMENTAL_LSP_TOOL ? [lsp.LspTool] : []),
+          ...(config.experimental?.batch_tool === true ? [batch.BatchTool] : []),
+          ...(Flag.OPENCODE_EXPERIMENTAL_PLAN_MODE && Flag.OPENCODE_CLIENT === "cli" ? [plan.PlanExitTool] : []),
+          ...custom,
+        ]
+      }
+
+      const register = Effect.fn("ToolRegistry.register")(function* (tool: Tool.Info) {
+        yield* ensure()
+        const idx = custom.findIndex((t) => t.id === tool.id)
+        if (idx >= 0) {
+          custom.splice(idx, 1, tool)
+          return
+        }
+        custom.push(tool)
+      })
+
+      const ids = Effect.fn("ToolRegistry.ids")(function* () {
+        yield* ensure()
+        const tools = yield* Effect.promise(() => all())
+        return tools.map((t) => t.id)
+      })
+
+      const tools = Effect.fn("ToolRegistry.tools")(function* (
+        model: { providerID: ProviderID; modelID: ModelID },
+        agent?: Agent.Info,
+      ) {
+        yield* ensure()
+        const allTools = yield* Effect.promise(() => all())
+        return yield* Effect.promise(() =>
+          Promise.all(
+            allTools
+              .filter((t) => {
+                // Enable websearch/codesearch for zen users OR via enable flag
+                if (t.id === "codesearch" || t.id === "websearch") {
+                  return model.providerID === ProviderID.opencode || Flag.OPENCODE_ENABLE_EXA
+                }
+
+                // use apply tool in same format as codex
+                const usePatch =
+                  model.modelID.includes("gpt-") && !model.modelID.includes("oss") && !model.modelID.includes("gpt-4")
+                if (t.id === "apply_patch") return usePatch
+                if (t.id === "edit" || t.id === "write") return !usePatch
+
+                return true
+              })
+              .map(async (t) => {
+                using _ = log.time(t.id)
+                const tool = await t.init({ agent })
+                const output = {
+                  description: tool.description,
+                  parameters: tool.parameters,
+                }
+                const { Plugin } = await import("../plugin")
+                await Plugin.trigger("tool.definition", { toolID: t.id }, output)
+                return {
+                  id: t.id,
+                  ...tool,
+                  description: output.description,
+                  parameters: output.parameters,
+                }
+              }),
+          ),
+        )
+      })
+
+      return Service.of({ register, ids, tools })
+    }),
+  ).pipe(Layer.fresh)
+
+  async function run<A, E>(effect: Effect.Effect<A, E, Service>) {
+    const { runPromiseInstance } = await import("@/effect/runtime")
+    return runPromiseInstance(effect)
   }
 
   export async function register(tool: Tool.Info) {
-    const { custom } = await state()
-    const idx = custom.findIndex((t) => t.id === tool.id)
-    if (idx >= 0) {
-      custom.splice(idx, 1, tool)
-      return
-    }
-    custom.push(tool)
-  }
-
-  async function all(): Promise<Tool.Info[]> {
-    const custom = await state().then((x) => x.custom)
-    const config = await Config.get()
-    const question = ["app", "cli", "desktop"].includes(Flag.OPENCODE_CLIENT) || Flag.OPENCODE_ENABLE_QUESTION_TOOL
-
-    return [
-      InvalidTool,
-      ...(question ? [QuestionTool] : []),
-      BashTool,
-      ReadTool,
-      GlobTool,
-      GrepTool,
-      EditTool,
-      WriteTool,
-      TaskTool,
-      WebFetchTool,
-      TodoWriteTool,
-      // TodoReadTool,
-      WebSearchTool,
-      CodeSearchTool,
-      SkillTool,
-      ApplyPatchTool,
-      ...(Flag.OPENCODE_EXPERIMENTAL_LSP_TOOL ? [LspTool] : []),
-      ...(config.experimental?.batch_tool === true ? [BatchTool] : []),
-      ...(Flag.OPENCODE_EXPERIMENTAL_PLAN_MODE && Flag.OPENCODE_CLIENT === "cli" ? [PlanExitTool] : []),
-      ...custom,
-    ]
+    return run(Service.use((svc) => svc.register(tool)))
   }
 
   export async function ids() {
-    return all().then((x) => x.map((t) => t.id))
+    return run(Service.use((svc) => svc.ids()))
   }
 
   export async function tools(
@@ -136,39 +244,6 @@ export namespace ToolRegistry {
     },
     agent?: Agent.Info,
   ) {
-    const tools = await all()
-    const result = await Promise.all(
-      tools
-        .filter((t) => {
-          // Enable websearch/codesearch for zen users OR via enable flag
-          if (t.id === "codesearch" || t.id === "websearch") {
-            return model.providerID === ProviderID.opencode || Flag.OPENCODE_ENABLE_EXA
-          }
-
-          // use apply tool in same format as codex
-          const usePatch =
-            model.modelID.includes("gpt-") && !model.modelID.includes("oss") && !model.modelID.includes("gpt-4")
-          if (t.id === "apply_patch") return usePatch
-          if (t.id === "edit" || t.id === "write") return !usePatch
-
-          return true
-        })
-        .map(async (t) => {
-          using _ = log.time(t.id)
-          const tool = await t.init({ agent })
-          const output = {
-            description: tool.description,
-            parameters: tool.parameters,
-          }
-          await Plugin.trigger("tool.definition", { toolID: t.id }, output)
-          return {
-            id: t.id,
-            ...tool,
-            description: output.description,
-            parameters: output.parameters,
-          }
-        }),
-    )
-    return result
+    return run(Service.use((svc) => svc.tools(model, agent)))
   }
 }