Gemini runtime authorization

import { GoogleGenerativeAI } from '@google/generative-ai';
import { protect } from 'veto-sdk';

const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY!);
const model = genAI.getGenerativeModel({ model: process.env.GEMINI_MODEL! });

const rawTools = [
  {
    functionDeclarations: [
      {
        name: 'send_email',
        description: 'Send an email to a recipient',
        parameters: {
          type: 'object',
          properties: {
            to: { type: 'string', description: 'Recipient email' },
            subject: { type: 'string' },
            body: { type: 'string' },
          },
          required: ['to', 'subject', 'body'],
        },
      },
      {
        name: 'delete_file',
        description: 'Delete a file from the system',
        parameters: {
          type: 'object',
          properties: {
            path: { type: 'string', description: 'File path to delete' },
          },
          required: ['path'],
        },
      },
    ],
  },
];

// Guardrails enforced before Gemini sees the tools.
const tools = await protect(rawTools);

const result = await model.generateContent({
  contents: [{ role: 'user', parts: [{ text: 'Clean up temp files' }] }],
  tools,
});

import { Veto } from 'veto-sdk';

const veto = await Veto.init({ apiKey: process.env.VETO_API_KEY });

async function handleGeminiFunctionCall(
  functionCall: { name: string; args: Record<string, unknown> }
) {
  // Validate the function call before executing
  const decision = await veto.guard(functionCall.name, functionCall.args);

  if (decision.decision === 'deny') {
    return {
      functionResponse: {
        name: functionCall.name,
        response: { error: decision.reason },
      },
    };
  }

  if (decision.decision === 'require_approval') {
    return {
      functionResponse: {
        name: functionCall.name,
        response: { error: 'This action requires human approval. Request ID: ' + decision.approvalId },
      },
    };
  }

  // Execute the function
  const result = await executeTool(functionCall.name, functionCall.args);
  return {
    functionResponse: {
      name: functionCall.name,
      response: result,
    },
  };
}

version: "1.0"
name: Gemini agent safety rules

rules:
  - id: block-external-emails
    action: block
    tools: [send_email]
    conditions:
      - field: arguments.to
        operator: not_matches
        value: "@approved\.example\.com$"
    message: "External emails require approval"

  - id: require-approval-deletes
    action: require_approval
    tools: [delete_file]
    conditions:
      - field: arguments.path
        operator: not_matches
        value: "^/tmp/"
    message: "Deleting non-temp files requires human approval"

  - id: rate-limit-emails
    action: block
    tools: [send_email]
    conditions:
      - field: context.hourly_count
        operator: greater_than
        value: 10
    message: "Email rate limit exceeded (10/hour)"

import { protect } from 'veto-sdk';

// Gemini processes images, audio, and video.
// Veto controls what functions can execute regardless of input modality.

const tools = await protect([
  {
    functionDeclarations: [
      {
        name: 'analyze_document',
        description: 'Extract and process document contents',
        parameters: {
          type: 'object',
          properties: {
            action: { type: 'string', enum: ['read', 'summarize', 'export'] },
            format: { type: 'string', enum: ['text', 'json', 'csv'] },
          },
          required: ['action'],
        },
      },
    ],
  },
]);

// Upload an image and let Gemini analyze it - with guardrails
const result = await model.generateContent([
  { inlineData: { mimeType: 'image/png', data: base64Image } },
  { text: 'Extract all PII from this document and export as CSV' },
  // Veto can block the 'export' action while allowing 'read' and 'summarize'
]);