Dropstone Docs

Herramientas Personalizadas

Crea herramientas que el LLM puede llamar en dropstone.

Las herramientas personalizadas son funciones que creas y que el LLM puede llamar durante las conversaciones. Funcionan junto con las herramientas integradas de Dropstone como read, write y bash.

Crear una herramienta

Las herramientas se definen como archivos TypeScript o JavaScript. La definición de la herramienta en sí es TS/JS, pero el trabajo que realiza puede implementarse en cualquier lenguaje: scripts de shell, Python, Go, cualquier cosa que puedas ejecutar desde los helpers de shell de Bun.

Ubicación

Se pueden definir:

  • Localmente colocándolas en el directorio .dropstone/tools/ de tu proyecto.
  • O globalmente, colocándolas en ~/.config/dropstone/tools/.

Estructura

La forma más fácil de crear herramientas es usar el helper tool() que proporciona seguridad de tipos y validación.

import { tool } from "@blankline/dropstone-plugin"

export default tool({
  description: "Query the project database",
  args: {
    query: tool.schema.string().describe("SQL query to execute"),
  },
  async execute(args) {
    // Your database logic here
    return `Executed query: ${args.query}`
  },
})

El nombre del archivo se convierte en el nombre de la herramienta. Lo anterior crea una herramienta database.

Múltiples herramientas por archivo

También puedes exportar múltiples herramientas desde un único archivo. Cada exportación se convierte en una herramienta separada con el nombre <nombre_archivo>_<nombre_exportación>:

import { tool } from "@blankline/dropstone-plugin"

export const add = tool({
  description: "Add two numbers",
  args: {
    a: tool.schema.number().describe("First number"),
    b: tool.schema.number().describe("Second number"),
  },
  async execute(args) {
    return args.a + args.b
  },
})

export const multiply = tool({
  description: "Multiply two numbers",
  args: {
    a: tool.schema.number().describe("First number"),
    b: tool.schema.number().describe("Second number"),
  },
  async execute(args) {
    return args.a * args.b
  },
})

Esto crea dos herramientas: math_add y math_multiply.

Colisiones de nombres con herramientas integradas

Las herramientas personalizadas se indexan por nombre de herramienta. Si una herramienta personalizada usa el mismo nombre que una herramienta integrada, la herramienta personalizada tiene prioridad.

Por ejemplo, este archivo reemplaza la herramienta integrada bash:

import { tool } from "@blankline/dropstone-plugin"

export default tool({
  description: "Restricted bash wrapper",
  args: {
    command: tool.schema.string(),
  },
  async execute(args) {
    return `blocked: ${args.command}`
  },
})

Note:

Prefiere nombres únicos a menos que quieras reemplazar intencionalmente una herramienta integrada. Si quieres desactivar una herramienta integrada pero no reemplazarla, usa permissions.

Argumentos

Puedes usar tool.schema, que es simplemente Zod, para definir tipos de argumentos.

args: {
  query: tool.schema.string().describe("SQL query to execute")
}

También puedes importar Zod directamente y devolver un objeto simple:

import { z } from "zod"

export default {
  description: "Tool description",
  args: {
    param: z.string().describe("Parameter description"),
  },
  async execute(args, context) {
    // Tool implementation
    return "result"
  },
}

Contexto

Las herramientas reciben contexto sobre la sesión actual:

import { tool } from "@blankline/dropstone-plugin"

export default tool({
  description: "Get project information",
  args: {},
  async execute(args, context) {
    // Access context information
    const { agent, sessionID, messageID, directory, worktree } = context
    return `Agent: ${agent}, Session: ${sessionID}, Message: ${messageID}, Directory: ${directory}, Worktree: ${worktree}`
  },
})

Usa context.directory para el directorio de trabajo de la sesión. Usa context.worktree para la raíz del worktree de git.

Ejemplos

Escribir una herramienta en Python

Puedes escribir tus herramientas en cualquier lenguaje que desees. Aquí hay un ejemplo que suma dos números usando Python.

Primero, crea la herramienta como un script de Python:

import sys

a = int(sys.argv[1])
b = int(sys.argv[2])
print(a + b)

Luego crea la definición de la herramienta que la invoca:

import { tool } from "@blankline/dropstone-plugin"
import path from "path"

export default tool({
  description: "Add two numbers using Python",
  args: {
    a: tool.schema.number().describe("First number"),
    b: tool.schema.number().describe("Second number"),
  },
  async execute(args, context) {
    const script = path.join(context.worktree, ".dropstone/tools/add.py")
    const result = await Bun.$`python3 ${script} ${args.a} ${args.b}`.text()
    return result.trim()
  },
})

Aquí estamos usando la utilidad Bun.$ para ejecutar el script de Python.

Ctrl+I