DeepSeek Harness: Tool Usage

// Agent's file_edit call parameters
{
  action: "read",
  path: "src/config.ts",
  encoding: "utf-8"
}

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

This configuration file exports three settings:
- DATABASE_URL: Database connection string
- PORT: Service port (default 3000)
- LOG_LEVEL: Log level (default info)

// Agent calls file_edit to create a file
{
  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 calls file_edit to edit a file
{
  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');"
    }
  ]
}

⚠️ Approval Required: Edit file src/app.ts

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

  [Allow] [Always] [Deny]

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

// Agent executes npm view (view package info, moderate risk)
{
  command: "npm view jsonwebtoken",
  cwd: "/home/alice/project",
  timeout: 120000
}

⚠️ Approval Required: Execute shell command

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

  [Allow] [Always for npm] [Deny]

// Shell tool parameters
interface ShellParams {
  command: string;
  cwd?: string;
  timeout?: number;      // Timeout in milliseconds, default 30000
  env?: Record<string, string>;  // Additional environment variables
}

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

⏱️ Build completed in 45s
  → Output: Build successful. 15 files generated.

// Search for all test files
{
  pattern: "*.test.ts",
  type: "file",
  maxResults: 50
}

// Search for all import statements
{
  pattern: "import.*from 'express'",
  type: "content",
  filePattern: "*.ts",
  maxResults: 100
}

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

Found in:
  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';
  ...

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

// Create a plan
{
  action: "create",
  steps: [
    { id: 1, desc: "Install dependencies", tool: "shell" },
    { id: 2, desc: "Create auth module", tool: "file_edit" },
    { id: 3, desc: "Update app.ts", tool: "file_edit" },
    { id: 4, desc: "Write tests", tool: "file_edit" },
    { id: 5, desc: "Run tests", tool: "shell" }
  ]
}

// Mark step as complete
{
  action: "update",
  stepId: 1,
  status: "completed",
  result: "Installed jsonwebtoken, bcryptjs"
}

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

  // Stage 2: execute
  const result = await tool.execute(params);

  // Stage 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;           // Record to session log
  emit: boolean;          // Emit event
  updateTrajectory: boolean;  // Update Trajectory
  notifyUI: boolean;      // Notify Web UI update
}

# dsh.config.yaml
approval:
  # Global default policy
  default: ask

  # Per-tool settings
  tools:
    file_edit:
      read: always          # Reads always allowed
      create: ask           # Creates require approval
      edit: ask             # Edits require approval
      delete: ask_with_confirm  # Deletes require double confirmation
    
    shell:
      safe: always          # Safe commands always allowed
      moderate: ask         # Moderate commands require approval
      dangerous: deny       # Dangerous commands auto-denied
    
    search:
      default: always       # Search always allowed
    
    skills:
      default: ask          # Skill calls require approval
    
    plan:
      default: always       # Plans always allowed

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',     // Default requires approval
    rules: [
      { match: { method: 'GET' }, level: 'always' },     // GET requests auto-allowed
      { match: { method: 'POST' }, level: 'ask' },       // POST requires approval
      { match: { method: 'DELETE' }, level: 'deny' }     // DELETE auto-denied
    ]
  }
});