TypeScript SDK for runtime authorization

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_000123' };
    },
  },
];

// Add an explicit authorization check
const guardedTools = await protect(tools);

import OpenAI from 'openai';
import { Veto, fromOpenAIToolCall, toOpenAI } from 'veto-sdk';

const client = new OpenAI();
const veto = await Veto.init();

const toolDefinitions = [
  {
    name: 'search_database',
    description: 'Query the customer database',
    inputSchema: {
      type: 'object',
      properties: {
        query: { type: 'string' },
        include_pii: { type: 'boolean' },
      },
      required: ['query'],
    },
  },
];

const response = await client.chat.completions.create({
  model: process.env.OPENAI_MODEL!,
  messages: [{ role: 'user', content: 'Look up order #4521 and notify the customer' }],
  tools: toolDefinitions.map(toOpenAI),
});

for (const toolCall of response.choices[0]?.message.tool_calls ?? []) {
  const call = fromOpenAIToolCall(toolCall);
  const decision = await veto.guard(call.name, call.arguments);
  if (decision.decision !== 'allow') throw new Error(decision.reason);
}

import Anthropic from '@anthropic-ai/sdk';
import { Veto, fromAnthropicToolUse, toAnthropic } from 'veto-sdk';

const client = new Anthropic();
const veto = await Veto.init();

const toolDefinitions = [
  {
    name: 'execute_sql',
    description: 'Run a SQL query against the database',
    inputSchema: {
      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: process.env.ANTHROPIC_MODEL!,
  max_tokens: 1024,
  messages: [{ role: 'user', content: 'Get last month revenue from analytics' }],
  tools: toolDefinitions.map(toAnthropic),
});

for (const block of response.content) {
  if (block.type === 'tool_use') {
    const call = fromAnthropicToolUse(block);
    const decision = await veto.guard(call.name, call.arguments);
    if (decision.decision !== 'allow') throw new Error(decision.reason);
  }
}

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(process.env.OPENAI_MODEL!),
  tools: {
    weather: tool({
      description: 'Get weather for a location',
      inputSchema: 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',
      inputSchema: 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@approved.example',
});

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

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

import { ToolCallDeniedError } from 'veto-sdk';

try {
  await guardedTools[0].execute({ amount: 50000, recipient: 'vendor@approved.example' });
} catch (error) {
  if (error instanceof ToolCallDeniedError) {
    console.log('Tool:', error.toolName);
    console.log('Reason:', error.reason);
    // Return a concise denial to the agent or UI.
  }
}

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

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

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