Veto TypeScript SDK

npm install veto-sdk

import { protect } from 'veto-sdk';

const tools = [
  {
    name: 'transfer_funds',
    description: 'Transfer money between accounts',
    parameters: {
      type: 'object',
      properties: {
        amount: { type: 'number' },
        recipient: { type: 'string' },
      },
      required: ['amount', 'recipient'],
    },
    execute: async (args: { amount: number; recipient: string }) => {
      // Your transfer logic
      return { success: true, txId: 'tx_...' };
    },
  },
];

// Add guardrails in one line
const safeTools = await protect(tools);

import OpenAI from 'openai';
import { protect } from 'veto-sdk';

const client = new OpenAI();

const tools = await protect([
  {
    type: 'function',
    function: {
      name: 'search_database',
      description: 'Query the customer database',
      parameters: {
        type: 'object',
        properties: {
          query: { type: 'string' },
          include_pii: { type: 'boolean' },
        },
        required: ['query'],
      },
    },
  },
  {
    type: 'function',
    function: {
      name: 'send_notification',
      description: 'Send a push notification to a user',
      parameters: {
        type: 'object',
        properties: {
          user_id: { type: 'string' },
          message: { type: 'string' },
        },
        required: ['user_id', 'message'],
      },
    },
  },
]);

const response = await client.chat.completions.create({
  model: 'gpt-5.4',
  messages: [{ role: 'user', content: 'Look up order #4521 and notify the customer' }],
  tools,
});

import Anthropic from '@anthropic-ai/sdk';
import { protect } from 'veto-sdk';

const client = new Anthropic();

const tools = await protect([
  {
    name: 'execute_sql',
    description: 'Run a SQL query against the database',
    input_schema: {
      type: 'object',
      properties: {
        query: { type: 'string', description: 'SQL query to execute' },
        database: { type: 'string', enum: ['analytics', 'production'] },
      },
      required: ['query', 'database'],
    },
  },
]);

const response = await client.messages.create({
  model: 'claude-sonnet-4-6',
  max_tokens: 1024,
  messages: [{ role: 'user', content: 'Get last month revenue from analytics' }],
  tools,
});

// Handle tool use blocks
for (const block of response.content) {
  if (block.type === 'tool_use') {
    // Veto already validated this call. Execute safely.
    const result = await executeQuery(block.input);
  }
}

import { openai } from '@ai-sdk/openai';
import { generateText, tool } from 'ai';
import { Veto } from 'veto-sdk';
import { z } from 'zod';

const veto = await Veto.init();

const result = await generateText({
  model: openai('gpt-5.4'),
  tools: {
    weather: tool({
      description: 'Get weather for a location',
      parameters: z.object({
        location: z.string(),
      }),
      execute: async ({ location }) => {
        // Pre-flight check before execution
        const decision = await veto.guard('weather', { location });
        if (decision.decision === 'deny') {
          return { error: decision.reason };
        }
        return fetchWeather(location);
      },
    }),
    sendEmail: tool({
      description: 'Send an email',
      parameters: z.object({
        to: z.string().email(),
        subject: z.string(),
        body: z.string(),
      }),
      execute: async (args) => {
        const decision = await veto.guard('sendEmail', args);
        if (decision.decision === 'deny') {
          return { error: decision.reason };
        }
        return sendEmail(args);
      },
    }),
  },
  prompt: 'Check weather in NYC and email the report to team@company.com',
});

import { Veto } from 'veto-sdk';

const veto = await Veto.init();

// Pre-flight validation without wrapping
const result = await veto.guard('transfer_funds', {
  amount: 25000,
  recipient: 'vendor-123',
});

if (result.decision === 'deny') {
  console.log('Blocked:', result.reason);
  console.log('Rule:', result.ruleId);
  console.log('Severity:', result.severity);
}

if (result.decision === 'require_approval') {
  console.log('Needs approval:', result.approvalId);
  // Poll or webhook for approval status
}

import { ToolCallDeniedError, BudgetExceededError } from 'veto-sdk';

try {
  await safeTools[0].execute({ amount: 50000, recipient: '...' });
} catch (error) {
  if (error instanceof ToolCallDeniedError) {
    console.log('Tool:', error.toolName);
    console.log('Reason:', error.reason);
    console.log('Rule:', error.ruleId);
    // Return error to the LLM so it can retry with different params
  }

  if (error instanceof BudgetExceededError) {
    console.log('Budget:', error.spent, '/', error.limit);
    // Agent should stop spending operations
  }
}

// Works in Node.js, Deno, Bun, Cloudflare Workers, Vercel Edge
import { protect } from 'veto-sdk';

export default {
  async fetch(request: Request): Promise<Response> {
    const safeTools = await protect(myTools);

    // Process the request with guarded tools
    const result = await runAgent(safeTools, request);
    return new Response(JSON.stringify(result));
  },
};