135 lines
3.5 KiB
TypeScript
135 lines
3.5 KiB
TypeScript
import { BashTool } from "./bash"
|
|
import { EditTool } from "./edit"
|
|
import { GlobTool } from "./glob"
|
|
import { GrepTool } from "./grep"
|
|
import { ListTool } from "./ls"
|
|
import { PatchTool } from "./patch"
|
|
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 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 ToolDefinition } from "@opencode-ai/plugin"
|
|
import z from "zod/v4"
|
|
import { Plugin } from "../plugin"
|
|
|
|
export namespace ToolRegistry {
|
|
// Built-in tools that ship with opencode
|
|
const BUILTIN = [
|
|
InvalidTool,
|
|
BashTool,
|
|
EditTool,
|
|
WebFetchTool,
|
|
GlobTool,
|
|
GrepTool,
|
|
ListTool,
|
|
PatchTool,
|
|
ReadTool,
|
|
WriteTool,
|
|
TodoWriteTool,
|
|
TodoReadTool,
|
|
TaskTool,
|
|
]
|
|
|
|
export const state = Instance.state(async () => {
|
|
const custom = [] as Tool.Info[]
|
|
const glob = new Bun.Glob("tool/*.{js,ts}")
|
|
|
|
for (const dir of await Config.directories()) {
|
|
for await (const match of glob.scan({ cwd: dir, absolute: true })) {
|
|
const namespace = path.basename(match, path.extname(match))
|
|
const mod = await import(match)
|
|
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))
|
|
}
|
|
}
|
|
|
|
return { custom }
|
|
})
|
|
|
|
function fromPlugin(id: string, def: ToolDefinition): Tool.Info {
|
|
return {
|
|
id,
|
|
init: async () => ({
|
|
parameters: z.object(def.args),
|
|
description: def.description,
|
|
execute: async (args, ctx) => {
|
|
const result = await def.execute(args as any, ctx)
|
|
return {
|
|
title: "",
|
|
output: result,
|
|
metadata: {},
|
|
}
|
|
},
|
|
}),
|
|
}
|
|
}
|
|
|
|
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)
|
|
return [...BUILTIN, ...custom]
|
|
}
|
|
|
|
export async function ids() {
|
|
return all().then((x) => x.map((t) => t.id))
|
|
}
|
|
|
|
export async function tools(_providerID: string, _modelID: string) {
|
|
const tools = await all()
|
|
const result = await Promise.all(
|
|
tools.map(async (t) => ({
|
|
id: t.id,
|
|
...(await t.init()),
|
|
})),
|
|
)
|
|
return result
|
|
}
|
|
|
|
export async function enabled(
|
|
_providerID: string,
|
|
_modelID: string,
|
|
agent: Agent.Info,
|
|
): Promise<Record<string, boolean>> {
|
|
const result: Record<string, boolean> = {}
|
|
result["patch"] = false
|
|
|
|
if (agent.permission.edit === "deny") {
|
|
result["edit"] = false
|
|
result["patch"] = false
|
|
result["write"] = false
|
|
}
|
|
if (agent.permission.bash["*"] === "deny" && Object.keys(agent.permission.bash).length === 1) {
|
|
result["bash"] = false
|
|
}
|
|
if (agent.permission.webfetch === "deny") {
|
|
result["webfetch"] = false
|
|
}
|
|
|
|
return result
|
|
}
|
|
}
|