DeepSeek Harness: Uso de Ferramentas

// Parâmetros de chamada de file_edit do Agent
{
  action: "read",
  path: "src/config.ts",
  encoding: "utf-8"
}

🤖 Agent:
🔍 Using tool: file_edit (read)
  → Path: src/config.ts
  → Size: 1.2KB

Este arquivo de configuração exporta três definições:
- DATABASE_URL: String de conexão com banco de dados
- PORT: Porta do serviço (padrão 3000)
- LOG_LEVEL: Nível de log (padrão info)

// Agent chama file_edit para criar um arquivo
{
  action: "create",
  path: "src/utils/logger.ts",
  content: "export function log(level: string, msg: string) {\n  const ts = new Date().toISOString();\n  console.log(`[${ts}] [${level}] ${msg}`);\n}"
}

// Agent chama file_edit para editar um arquivo
{
  action: "edit",
  path: "src/app.ts",
  changes: [
    {
      type: "insert",
      line: 5,
      content: "import { log } from './utils/logger';"
    },
    {
      type: "replace",
      line: 23,
      oldContent: "console.log('Server started');",
      newContent: "log('info', 'Server started');"
    }
  ]
}

⚠️ Aprovação Necessária: Editar arquivo src/app.ts

  +5 | import { log } from './utils/logger';
  
  -23| console.log('Server started');
  +23| log('info', 'Server started');

  [Permitir] [Sempre] [Negar]

// Agent executa comando ls
{
  command: "ls -la src/",
  cwd: "/home/alice/project",
  timeout: 30000
}

// Agent executa npm view (ver info do pacote, risco moderado)
{
  command: "npm view jsonwebtoken",
  cwd: "/home/alice/project",
  timeout: 120000
}

⚠️ Aprovação Necessária: Executar comando shell

  Command: npm view jsonwebtoken
  Working directory: /home/alice/project
  Estimated packages: 1

  [Permitir] [Sempre para npm] [Negar]

// Parâmetros da ferramenta shell
interface ShellParams {
  command: string;
  cwd?: string;
  timeout?: number;      // Timeout em milissegundos, padrão 30000
  env?: Record<string, string>;  // Variáveis de ambiente adicionais
}

🤖 Agent:
🔧 Using tool: shell
  → Command: npm run build
  → Timeout: 120000ms

⏱️ Build completado em 45s
  → Output: Build successful. 15 files generated.

// Buscar todos os arquivos de teste
{
  pattern: "*.test.ts",
  type: "file",
  maxResults: 50
}

// Buscar todas as declarações de import
{
  pattern: "import.*from 'express'",
  type: "content",
  filePattern: "*.ts",
  maxResults: 100
}

🤖 Agent:
🔍 Using tool: search
  → Pattern: import.*from 'express'
  → Type: content
  → Results: 8 matches

Encontrado em:
  src/app.ts:1         — import express from 'express';
  src/routes/users.ts:3 — import express from 'express';
  src/routes/auth.ts:2  — import express from 'express';
  ...

// Invocar skill add-test
{
  skill: "add-test",
  params: {
    target: "src/utils/format.ts::formatDate",
    framework: "jest"
  }
}

// Criar um plano
{
  action: "create",
  steps: [
    { id: 1, desc: "Instalar dependências", tool: "shell" },
    { id: 2, desc: "Criar módulo de autenticação", tool: "file_edit" },
    { id: 3, desc: "Atualizar app.ts", tool: "file_edit" },
    { id: 4, desc: "Escrever testes", tool: "file_edit" },
    { id: 5, desc: "Executar testes", tool: "shell" }
  ]
}

// Marcar passo como completo
{
  action: "update",
  stepId: 1,
  status: "completed",
  result: "Installed jsonwebtoken, bcryptjs"
}

async function executeToolPipeline(tool: Tool, params: Params): Promise<Result> {
  // Estágio 1: pre-execute
  const preResult = await preExecute(tool, params);
  if (preResult.denied) {
    throw new ToolDeniedError(preResult.reason);
  }

  // Estágio 2: execute
  const result = await tool.execute(params);

  // Estágio 3: post-execute
  await postExecute(tool, params, result);
  ctx.emit('tool.executed', { tool: tool.name, params, result });

  return result;
}

interface PreExecuteResult {
  allowed: boolean;
  reason?: string;
  modifiedParams?: Params;
}

interface PostExecuteAction {
  log: boolean;           // Registrar no log de sessão
  emit: boolean;          // Emitir evento
  updateTrajectory: boolean;  // Atualizar Trajectory
  notifyUI: boolean;      // Notificar atualização da Web UI
}

# dsh.config.yaml
approval:
  # Política padrão global
  default: ask

  # Configurações por ferramenta
  tools:
    file_edit:
      read: always          # Leituras sempre permitidas
      create: ask           # Criações requerem aprovação
      edit: ask             # Edições requerem aprovação
      delete: ask_with_confirm  # Exclusões requerem dupla confirmação
    
    shell:
      safe: always          # Comandos seguros sempre permitidos
      moderate: ask         # Comandos moderados requerem aprovação
      dangerous: deny       # Comandos perigosos auto-negados
    
    search:
      default: always       # Busca sempre permitida
    
    skills:
      default: ask          # Chamadas de skill requerem aprovação
    
    plan:
      default: always       # Planos sempre permitidos

import { definePlugin } from '@deepseek-ai/dsh';

export default definePlugin({
  name: 'tool-http-request',
  version: '1.0.0',
  contribute(ctx) {
    ctx.registerTool({
      name: 'http_request',
      description: 'Make HTTP requests to external APIs',
      parameters: {
        type: 'object',
        properties: {
          url: { type: 'string', description: 'Request URL' },
          method: { type: 'string', enum: ['GET', 'POST', 'PUT', 'DELETE'] },
          headers: { type: 'object', description: 'Request headers' },
          body: { type: 'string', description: 'Request body' }
        },
        required: ['url', 'method']
      },
      async execute(params) {
        const response = await fetch(params.url, {
          method: params.method,
          headers: params.headers,
          body: params.body
        });
        return {
          status: response.status,
          body: await response.text()
        };
      }
    });
  }
});

.dsh/
└── plugins/
    └── tool-http-request/
        ├── index.ts
        └── package.json

# dsh.config.yaml
plugins:
  - path: "./custom-tools/http-request"
  - path: "./custom-tools/database-query"

ctx.registerTool({
  name: 'http_request',
  // ...
  approval: {
    level: 'ask',     // Padrão requer aprovação
    rules: [
      { match: { method: 'GET' }, level: 'always' },     // Requisições GET auto-permitidas
      { match: { method: 'POST' }, level: 'ask' },       // POST requer aprovação
      { match: { method: 'DELETE' }, level: 'deny' }     // DELETE auto-negado
    ]
  }
});