Dropstone Docs

Outils personnalisés

Créez des outils que l'LLM peut appeler dans dropstone.

Les outils personnalisés sont des fonctions que vous créez et que l'LLM peut appeler lors des conversations. Ils fonctionnent aux côtés des outils intégrés de Dropstone comme read, write et bash.

Créer un outil

Les outils sont définis comme des fichiers TypeScript ou JavaScript. La définition de l'outil elle-même est en TS/JS, mais le travail qu'il effectue peut être implémenté dans n'importe quel langage : scripts shell, Python, Go, tout ce que vous pouvez générer à partir des assistants shell de Bun.

Emplacement

Ils peuvent être définis :

  • Localement en les plaçant dans le répertoire .dropstone/tools/ de votre projet.
  • Ou globalement, en les plaçant dans ~/.config/dropstone/tools/.

Structure

Le moyen le plus facile de créer des outils est d'utiliser l'assistant tool() qui fournit la sécurité des types et la validation.

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}`
  },
})

Le nom du fichier devient le nom de l'outil. Ce qui précède crée un outil database.

Plusieurs outils par fichier

Vous pouvez également exporter plusieurs outils à partir d'un seul fichier. Chaque export devient un outil séparé avec le nom <filename>_<exportname> :

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
  },
})

Cela crée deux outils : math_add et math_multiply.

Collisions de noms avec les outils intégrés

Les outils personnalisés sont indexés par nom d'outil. Si un outil personnalisé utilise le même nom qu'un outil intégré, l'outil personnalisé a la priorité.

Par exemple, ce fichier remplace l'outil intégré 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:

Préférez les noms uniques sauf si vous souhaitez intentionnellement remplacer un outil intégré. Si vous souhaitez désactiver un outil intégré sans le remplacer, utilisez les permissions.

Arguments

Vous pouvez utiliser tool.schema, qui est simplement Zod, pour définir les types d'arguments.

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

Vous pouvez également importer Zod directement et retourner un objet 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"
  },
}

Contexte

Les outils reçoivent le contexte de la session actuelle :

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}`
  },
})

Utilisez context.directory pour le répertoire de travail de la session. Utilisez context.worktree pour la racine du worktree git.

Exemples

Écrire un outil en Python

Vous pouvez écrire vos outils dans n'importe quel langage. Voici un exemple qui ajoute deux nombres en utilisant Python.

Commencez par créer l'outil en tant que script Python :

import sys

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

Ensuite, créez la définition de l'outil qui l'invoque :

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()
  },
})

Ici, nous utilisons l'utilitaire Bun.$ pour exécuter le script Python.

Ctrl+I