@toolkit-cli/toolkode 1.3.7

package/src/tool/registry.ts

@@ -0,0 +1,232 @@
+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 } 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 { Config } from "../config/config"
+import path from "path"
+import { type ToolContext as PluginToolContext, type ToolDefinition } from "@toolkit-cli/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 { CronCreateTool } from "./cron-create"
+import { CronListTool } from "./cron-list"
+import { CronDeleteTool } from "./cron-delete"
+import { Cron } from "../cron"
+import { SendMessageTool } from "./send-message"
+import { TeamTool } from "./team"
+import { Glob } from "../util/glob"
+import { pathToFileURL } from "url"
+import { Effect, Layer, ServiceMap } from "effect"
+import { InstanceState } from "@/effect/instance-state"
+import { makeRuntime } from "@/effect/run-service"
+
+export namespace ToolRegistry {
+  const log = Log.create({ service: "tool.registry" })
+
+  type State = {
+    custom: 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 })[]>
+  }
+
+  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/ToolRegistry") {}
+
+  export const layer = Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const config = yield* Config.Service
+      const plugin = yield* Plugin.Service
+
+      const cache = yield* InstanceState.make<State>(
+        Effect.fn("ToolRegistry.state")(function* (ctx) {
+          const custom: Tool.Info[] = []
+
+          function fromPlugin(id: string, def: ToolDefinition): Tool.Info {
+            return {
+              id,
+              init: async (initCtx) => ({
+                parameters: z.object(def.args),
+                description: def.description,
+                execute: async (args, toolCtx) => {
+                  const pluginCtx = {
+                    ...toolCtx,
+                    directory: ctx.directory,
+                    worktree: ctx.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 dirs = yield* config.directories()
+          const matches = dirs.flatMap((dir) =>
+            Glob.scanSync("{tool,tools}/*.{js,ts}", { cwd: dir, absolute: true, dot: true, symlink: true }),
+          )
+          if (matches.length) yield* config.waitForDependencies()
+          for (const match of matches) {
+            const namespace = path.basename(match, path.extname(match))
+            const mod = yield* Effect.promise(
+              () => 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 = yield* plugin.list()
+          for (const p of plugins) {
+            for (const [id, def] of Object.entries(p.tool ?? {})) {
+              custom.push(fromPlugin(id, def))
+            }
+          }
+
+          return { custom }
+        }),
+      )
+
+      const all = Effect.fn("ToolRegistry.all")(function* (custom: Tool.Info[]) {
+        const cfg = yield* 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,
+          WebSearchTool,
+          CodeSearchTool,
+          SkillTool,
+          ApplyPatchTool,
+          SendMessageTool,
+          TeamTool,
+          ...(!Cron.isDisabled() ? [CronCreateTool, CronListTool, CronDeleteTool] : []),
+          ...(Flag.OPENCODE_EXPERIMENTAL_LSP_TOOL ? [LspTool] : []),
+          ...(cfg.experimental?.batch_tool === true ? [BatchTool] : []),
+          ...(Flag.OPENCODE_EXPERIMENTAL_PLAN_MODE && Flag.OPENCODE_CLIENT === "cli" ? [PlanExitTool] : []),
+          ...custom,
+        ]
+      })
+
+      const register = Effect.fn("ToolRegistry.register")(function* (tool: Tool.Info) {
+        const state = yield* InstanceState.get(cache)
+        const idx = state.custom.findIndex((t) => t.id === tool.id)
+        if (idx >= 0) {
+          state.custom.splice(idx, 1, tool)
+          return
+        }
+        state.custom.push(tool)
+      })
+
+      const ids = Effect.fn("ToolRegistry.ids")(function* () {
+        const state = yield* InstanceState.get(cache)
+        const tools = yield* all(state.custom)
+        return tools.map((t) => t.id)
+      })
+
+      const tools = Effect.fn("ToolRegistry.tools")(function* (
+        model: { providerID: ProviderID; modelID: ModelID },
+        agent?: Agent.Info,
+      ) {
+        const state = yield* InstanceState.get(cache)
+        const allTools = yield* all(state.custom)
+        const filtered = allTools.filter((tool) => {
+          if (tool.id === "codesearch" || tool.id === "websearch") {
+            return model.providerID === ProviderID.opencode || Flag.OPENCODE_ENABLE_EXA
+          }
+
+          const usePatch =
+            model.modelID.includes("gpt-") && !model.modelID.includes("oss") && !model.modelID.includes("gpt-4")
+          if (tool.id === "apply_patch") return usePatch
+          if (tool.id === "edit" || tool.id === "write") return !usePatch
+
+          return true
+        })
+        return yield* Effect.forEach(
+          filtered,
+          Effect.fnUntraced(function* (tool) {
+            using _ = log.time(tool.id)
+            const next = yield* Effect.promise(() => tool.init({ agent }))
+            const output = {
+              description: next.description,
+              parameters: next.parameters,
+            }
+            yield* plugin.trigger("tool.definition", { toolID: tool.id }, output)
+            return {
+              id: tool.id,
+              ...next,
+              description: output.description,
+              parameters: output.parameters,
+            } as Awaited<ReturnType<Tool.Info["init"]>> & { id: string }
+          }),
+          { concurrency: "unbounded" },
+        )
+      })
+
+      return Service.of({ register, ids, tools })
+    }),
+  )
+
+  export const defaultLayer = Layer.unwrap(
+    Effect.sync(() => layer.pipe(Layer.provide(Config.defaultLayer), Layer.provide(Plugin.defaultLayer))),
+  )
+
+  const { runPromise } = makeRuntime(Service, defaultLayer)
+
+  export async function register(tool: Tool.Info) {
+    return runPromise((svc) => svc.register(tool))
+  }
+
+  export async function ids() {
+    return runPromise((svc) => svc.ids())
+  }
+
+  export async function tools(
+    model: {
+      providerID: ProviderID
+      modelID: ModelID
+    },
+    agent?: Agent.Info,
+  ): Promise<(Awaited<ReturnType<Tool.Info["init"]>> & { id: string })[]> {
+    return runPromise((svc) => svc.tools(model, agent))
+  }
+}

package/src/tool/schema.ts

@@ -0,0 +1,17 @@
+import { Schema } from "effect"
+import z from "zod"
+
+import { Identifier } from "@/id/id"
+import { withStatics } from "@/util/schema"
+
+const toolIdSchema = Schema.String.pipe(Schema.brand("ToolID"))
+
+export type ToolID = typeof toolIdSchema.Type
+
+export const ToolID = toolIdSchema.pipe(
+  withStatics((schema: typeof toolIdSchema) => ({
+    make: (id: string) => schema.makeUnsafe(id),
+    ascending: (id?: string) => schema.makeUnsafe(Identifier.ascending("tool", id)),
+    zod: Identifier.schema("tool").pipe(z.custom<ToolID>()),
+  })),
+)

package/src/tool/send-message.ts

@@ -0,0 +1,59 @@
+import z from "zod"
+import { Tool } from "./tool"
+import { Session } from "../session"
+import { SessionID, MessageID } from "../session/schema"
+import { SessionPrompt } from "../session/prompt"
+import { Log } from "../util/log"
+import DESCRIPTION from "./send-message.txt"
+
+const log = Log.create({ service: "tool.send-message" })
+
+export const SendMessageTool = Tool.define("send_message", {
+  description: DESCRIPTION,
+  parameters: z.object({
+    to: z.string().describe("The task_id (session ID) of the subagent to send the message to"),
+    message: z.string().describe("The message to send to the subagent"),
+  }),
+  async execute(params, ctx) {
+    const sessionID = SessionID.make(params.to)
+
+    // Verify the target session exists
+    const session = await Session.get(sessionID).catch(() => null)
+    if (!session) {
+      return {
+        title: "Agent not found",
+        output: `No subagent found with ID "${params.to}". Check the task_id from the original Agent invocation.`,
+        metadata: {},
+      }
+    }
+
+    const messageID = MessageID.ascending()
+    const promptParts = await SessionPrompt.resolvePromptParts(params.message)
+
+    // Resume the subagent in the background
+    SessionPrompt.prompt({
+      messageID,
+      sessionID,
+      parts: promptParts,
+    })
+      .then((result) => {
+        const text = result.parts.findLast((x) => x.type === "text")?.text ?? ""
+        log.info("resumed agent completed", { sessionID: params.to, resultLength: text.length })
+      })
+      .catch((err) => {
+        log.error("resumed agent failed", { sessionID: params.to, error: err })
+      })
+
+    return {
+      title: `Message sent to ${params.to}`,
+      output: [
+        `Message sent to subagent ${params.to}.`,
+        `The subagent is resuming in the background with its full context preserved.`,
+        `Session: ${session.title}`,
+      ].join("\n"),
+      metadata: {
+        sessionId: params.to,
+      },
+    }
+  },
+})

package/src/tool/send-message.txt

@@ -0,0 +1,7 @@
+Send a message to a running or stopped subagent to continue its work.
+
+Use this tool to resume a previously spawned subagent by its session ID. The subagent resumes with its full context preserved — all previous tool calls, results, and reasoning are retained.
+
+The "to" field should be the task_id (session ID) returned when the subagent was originally created. Each Agent invocation returns this ID.
+
+If the subagent has stopped, it auto-resumes in the background. If it's still running, the message is queued.

package/src/tool/skill.ts

@@ -0,0 +1,105 @@
+import path from "path"
+import { pathToFileURL } from "url"
+import z from "zod"
+import { Tool } from "./tool"
+import { Skill } from "../skill"
+import { Ripgrep } from "../file/ripgrep"
+import { iife } from "@/util/iife"
+
+export const SkillTool = Tool.define("skill", async (ctx) => {
+  const list = await Skill.available(ctx?.agent)
+
+  const description =
+    list.length === 0
+      ? "Load a specialized skill that provides domain-specific instructions and workflows. No skills are currently available."
+      : [
+          "Load a specialized skill that provides domain-specific instructions and workflows.",
+          "",
+          "When you recognize that a task matches one of the available skills listed below, use this tool to load the full skill instructions.",
+          "",
+          "The skill will inject detailed instructions, workflows, and access to bundled resources (scripts, references, templates) into the conversation context.",
+          "",
+          'Tool output includes a `<skill_content name="...">` block with the loaded content.',
+          "",
+          "The following skills provide specialized sets of instructions for particular tasks",
+          "Invoke this tool to load a skill when a task matches one of the available skills listed below:",
+          "",
+          Skill.fmt(list, { verbose: false }),
+        ].join("\n")
+
+  const examples = list
+    .map((skill) => `'${skill.name}'`)
+    .slice(0, 3)
+    .join(", ")
+  const hint = examples.length > 0 ? ` (e.g., ${examples}, ...)` : ""
+
+  const parameters = z.object({
+    name: z.string().describe(`The name of the skill from available_skills${hint}`),
+  })
+
+  return {
+    description,
+    parameters,
+    async execute(params: z.infer<typeof parameters>, ctx) {
+      const skill = await Skill.get(params.name)
+
+      if (!skill) {
+        const available = await Skill.all().then((x) => x.map((skill) => skill.name).join(", "))
+        throw new Error(`Skill "${params.name}" not found. Available skills: ${available || "none"}`)
+      }
+
+      await ctx.ask({
+        permission: "skill",
+        patterns: [params.name],
+        always: [params.name],
+        metadata: {},
+      })
+
+      const dir = path.dirname(skill.location)
+      const base = pathToFileURL(dir).href
+
+      const limit = 10
+      const files = await iife(async () => {
+        const arr = []
+        for await (const file of Ripgrep.files({
+          cwd: dir,
+          follow: false,
+          hidden: true,
+          signal: ctx.abort,
+        })) {
+          if (file.includes("SKILL.md")) {
+            continue
+          }
+          arr.push(path.resolve(dir, file))
+          if (arr.length >= limit) {
+            break
+          }
+        }
+        return arr
+      }).then((f) => f.map((file) => `<file>${file}</file>`).join("\n"))
+
+      return {
+        title: `Loaded skill: ${skill.name}`,
+        output: [
+          `<skill_content name="${skill.name}">`,
+          `# Skill: ${skill.name}`,
+          "",
+          skill.content.trim(),
+          "",
+          `Base directory for this skill: ${base}`,
+          "Relative paths in this skill (e.g., scripts/, reference/) are relative to this base directory.",
+          "Note: file list is sampled.",
+          "",
+          "<skill_files>",
+          files,
+          "</skill_files>",
+          "</skill_content>",
+        ].join("\n"),
+        metadata: {
+          name: skill.name,
+          dir,
+        },
+      }
+    },
+  }
+})

package/src/tool/task.ts

@@ -0,0 +1,230 @@
+import { Tool } from "./tool"
+import DESCRIPTION from "./task.txt"
+import z from "zod"
+import { Session } from "../session"
+import { SessionID, MessageID } from "../session/schema"
+import { MessageV2 } from "../session/message-v2"
+import { Identifier } from "../id/id"
+import { Agent } from "../agent/agent"
+import { SessionPrompt } from "../session/prompt"
+import { iife } from "@/util/iife"
+import { defer } from "@/util/defer"
+import { Config } from "../config/config"
+import { Permission } from "@/permission"
+import { Worktree } from "../worktree"
+import { Instance } from "../project/instance"
+import { Log } from "../util/log"
+
+const log = Log.create({ service: "tool.task" })
+
+const parameters = z.object({
+  description: z.string().describe("A short (3-5 words) description of the task"),
+  prompt: z.string().describe("The task for the agent to perform"),
+  subagent_type: z.string().describe("The type of specialized agent to use for this task"),
+  task_id: z
+    .string()
+    .describe(
+      "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)",
+    )
+    .optional(),
+  command: z.string().describe("The command that triggered this task").optional(),
+  run_in_background: z
+    .boolean()
+    .describe("Set to true to run this agent in the background. You will be notified when it completes.")
+    .optional(),
+  isolation: z
+    .enum(["worktree"])
+    .describe('Isolation mode. "worktree" creates a temporary git worktree so the agent works on an isolated copy of the repo.')
+    .optional(),
+  model: z
+    .enum(["sonnet", "opus", "haiku"])
+    .describe("Optional model override for this agent. If omitted, uses the agent definition's model, or inherits from the parent.")
+    .optional(),
+})
+
+export const TaskTool = Tool.define("task", async (ctx) => {
+  const agents = await Agent.list().then((x) => x.filter((a) => a.mode !== "primary"))
+
+  // Filter agents by permissions if agent provided
+  const caller = ctx?.agent
+  const accessibleAgents = caller
+    ? agents.filter((a) => Permission.evaluate("task", a.name, caller.permission).action !== "deny")
+    : agents
+  const list = accessibleAgents.toSorted((a, b) => a.name.localeCompare(b.name))
+
+  const description = DESCRIPTION.replace(
+    "{agents}",
+    list
+      .map((a) => `- ${a.name}: ${a.description ?? "This subagent should only be called manually by the user."}`)
+      .join("\n"),
+  )
+  return {
+    description,
+    parameters,
+    async execute(params: z.infer<typeof parameters>, ctx) {
+      const config = await Config.get()
+
+      // Skip permission check when user explicitly invoked via @ or command subtask
+      if (!ctx.extra?.bypassAgentCheck) {
+        await ctx.ask({
+          permission: "task",
+          patterns: [params.subagent_type],
+          always: ["*"],
+          metadata: {
+            description: params.description,
+            subagent_type: params.subagent_type,
+          },
+        })
+      }
+
+      const agent = await Agent.get(params.subagent_type)
+      if (!agent) throw new Error(`Unknown agent type: ${params.subagent_type} is not a valid agent type`)
+
+      const hasTaskPermission = agent.permission.some((rule) => rule.permission === "task")
+      const hasTodoWritePermission = agent.permission.some((rule) => rule.permission === "todowrite")
+
+      const session = await iife(async () => {
+        if (params.task_id) {
+          const found = await Session.get(SessionID.make(params.task_id)).catch(() => {})
+          if (found) return found
+        }
+
+        return await Session.create({
+          parentID: ctx.sessionID,
+          title: params.description + ` (@${agent.name} subagent)`,
+          permission: [
+            ...(hasTodoWritePermission
+              ? []
+              : [
+                  {
+                    permission: "todowrite" as const,
+                    pattern: "*" as const,
+                    action: "deny" as const,
+                  },
+                ]),
+            ...(hasTaskPermission
+              ? []
+              : [
+                  {
+                    permission: "task" as const,
+                    pattern: "*" as const,
+                    action: "deny" as const,
+                  },
+                ]),
+            ...(config.experimental?.primary_tools?.map((t) => ({
+              pattern: "*",
+              action: "allow" as const,
+              permission: t,
+            })) ?? []),
+          ],
+        })
+      })
+      const msg = await MessageV2.get({ sessionID: ctx.sessionID, messageID: ctx.messageID })
+      if (msg.info.role !== "assistant") throw new Error("Not an assistant message")
+
+      // Resolve model: CLI param > agent definition > parent model
+      const model = iife(() => {
+        if (params.model) {
+          // Map alias to provider/model — uses Toolkit models by default
+          const modelMap: Record<string, { providerID: string; modelID: string }> = {
+            haiku: { providerID: "toolkit", modelID: "toolkit-code-fast" },
+            sonnet: { providerID: "toolkit", modelID: "toolkit-base" },
+            opus: { providerID: "toolkit", modelID: "toolkit-code-backend" },
+          }
+          const mapped = modelMap[params.model]
+          if (mapped) return { providerID: mapped.providerID as any, modelID: mapped.modelID as any }
+        }
+        return agent.model ?? { modelID: msg.info.modelID, providerID: msg.info.providerID }
+      })
+
+      ctx.metadata({
+        title: params.description,
+        metadata: {
+          sessionId: session.id,
+          model,
+          background: params.run_in_background ?? false,
+          isolation: params.isolation,
+        },
+      })
+
+      // Build the prompt function
+      async function runPrompt() {
+        const messageID = MessageID.ascending()
+        const promptParts = await SessionPrompt.resolvePromptParts(params.prompt)
+
+        return SessionPrompt.prompt({
+          messageID,
+          sessionID: session.id,
+          model: {
+            modelID: model.modelID,
+            providerID: model.providerID,
+          },
+          agent: agent.name,
+          tools: {
+            ...(hasTodoWritePermission ? {} : { todowrite: false }),
+            ...(hasTaskPermission ? {} : { task: false }),
+            ...Object.fromEntries((config.experimental?.primary_tools ?? []).map((t) => [t, false])),
+          },
+          parts: promptParts,
+        })
+      }
+
+      // Background execution: fire and return immediately
+      if (params.run_in_background) {
+        runPrompt()
+          .then((result) => {
+            const text = result.parts.findLast((x) => x.type === "text")?.text ?? ""
+            log.info("background agent completed", { taskId: session.id, agent: agent.name, resultLength: text.length })
+          })
+          .catch((err) => {
+            log.error("background agent failed", { taskId: session.id, error: err })
+          })
+
+        return {
+          title: params.description,
+          metadata: {
+            sessionId: session.id,
+            model,
+            background: true,
+          },
+          output: [
+            `Background agent launched.`,
+            `task_id: ${session.id}`,
+            `agent: ${agent.name}`,
+            `model: ${model.providerID}/${model.modelID}`,
+            ``,
+            `The agent is working in the background. Use SendMessage with to: '${session.id}' to continue this agent.`,
+          ].join("\n"),
+        }
+      }
+
+      // Foreground execution
+      function cancel() {
+        SessionPrompt.cancel(session.id)
+      }
+      ctx.abort.addEventListener("abort", cancel)
+      using _ = defer(() => ctx.abort.removeEventListener("abort", cancel))
+
+      const result = await runPrompt()
+
+      const text = result.parts.findLast((x) => x.type === "text")?.text ?? ""
+
+      const output = [
+        `task_id: ${session.id} (for resuming to continue this task if needed)`,
+        "",
+        "<task_result>",
+        text,
+        "</task_result>",
+      ].join("\n")
+
+      return {
+        title: params.description,
+        metadata: {
+          sessionId: session.id,
+          model,
+        },
+        output,
+      }
+    },
+  }
+})