@toolkit-cli/toolkode 1.3.7 → 1.3.9

package/src/tool/registry.ts

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

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

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

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

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

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