Tool Approval & State Persistence

import { tool } from '@modelgates/agent';import { z } from 'zod'; const sendEmailTool = tool({  name: 'send_email',  description: 'Send an email to a recipient',  inputSchema: z.object({    to: z.string().email(),    subject: z.string(),    body: z.string(),  }),  outputSchema: z.object({ sent: z.boolean() }),  requireApproval: true,  execute: async (params) => {    await sendEmail(params);    return { sent: true };  },});

const deleteRecordTool = tool({  name: 'delete_record',  description: 'Delete a record from the database',  inputSchema: z.object({    id: z.string(),    environment: z.enum(['staging', 'production']),  }),  outputSchema: z.object({ deleted: z.boolean() }),  requireApproval: (params, context) => {    // Only require approval for production deletions    return params.environment === 'production';  },  execute: async (params) => {    await deleteRecord(params.id);    return { deleted: true };  },});

const result = modelgates.callModel({  model: 'openai/gpt-4o',  input: 'Send an email and search for documents',  tools: [sendEmailTool, searchTool],  state: myStateAccessor,  requireApproval: (toolCall, context) => {    // Require approval for any tool that modifies data    return toolCall.name === 'send_email' || toolCall.name === 'delete_record';  },});

import type { StateAccessor, ConversationState } from '@modelgates/agent'; interface StateAccessor<TTools> {  /** Load the current conversation state, or null if none exists */  load: () => Promise<ConversationState<TTools> | null>;  /** Save the conversation state */  save: (state: ConversationState<TTools>) => Promise<void>;}

const conversations = new Map<string, ConversationState>(); function createStateAccessor(conversationId: string): StateAccessor {  return {    load: async () => conversations.get(conversationId) ?? null,    save: async (state) => {      conversations.set(conversationId, state);    },  };}

import { ModelGates, tool } from '@modelgates/agent';import type { ConversationState, StateAccessor } from '@modelgates/agent';import { z } from 'zod'; // 1. Define a tool with approval requiredconst sendEmailTool = tool({  name: 'send_email',  description: 'Send an email',  inputSchema: z.object({    to: z.string().email(),    subject: z.string(),    body: z.string(),  }),  outputSchema: z.object({ sent: z.boolean(), messageId: z.string() }),  requireApproval: true,  execute: async (params) => {    const result = await sendEmail(params);    return { sent: true, messageId: result.id };  },}); // 2. Create a state accessor (in-memory for this example)const store = new Map<string, ConversationState>();const conversationId = 'conv-123'; const state: StateAccessor = {  load: async () => store.get(conversationId) ?? null,  save: async (s) => { store.set(conversationId, s); },}; const modelgates = new ModelGates({ apiKey: process.env.MODELGATES_API_KEY }); // 3. First callModel — model will try to call the toolconst result = modelgates.callModel({  model: 'openai/gpt-4o',  input: 'Send a welcome email to alice@example.com',  tools: [sendEmailTool] as const,  state,}); // 4. Check if approval is neededif (await result.requiresApproval()) {  const pending = await result.getPendingToolCalls();   for (const call of pending) {    console.log(`Tool: ${call.name}`);    console.log(`To: ${call.arguments.to}`);    console.log(`Subject: ${call.arguments.subject}`);    console.log(`ID: ${call.id}`);  }   // 5. Present to user for decision, then resume  const approved = await askUserForApproval(pending);   const approvedIds = approved.filter(a => a.decision === 'approve').map(a => a.id);  const rejectedIds = approved.filter(a => a.decision === 'reject').map(a => a.id);   // 6. Second callModel — resume with approval decisions  const resumed = modelgates.callModel({    model: 'openai/gpt-4o',    input: [], // No new user input needed for resumption    tools: [sendEmailTool] as const,    state,    approveToolCalls: approvedIds,    rejectToolCalls: rejectedIds,  });   // 7. Get the final response  const text = await resumed.getText();  console.log(text);  // "I've sent the welcome email to alice@example.com."} else {  // No approval needed — tool ran automatically  const text = await result.getText();  console.log(text);}

// Load existing stateconst loaded = await state.load(); if (loaded?.status === 'awaiting_approval') {  const pending = loaded.pendingToolCalls ?? [];   // Approve all pending calls  const result = modelgates.callModel({    model: 'openai/gpt-4o',    input: [],    tools: [sendEmailTool] as const,    state,    approveToolCalls: pending.map(c => c.id),  });   const text = await result.getText();}

const loaded = await state.load(); if (loaded?.status === 'interrupted') {  // Resume — the SDK picks up from the interruption point  const result = modelgates.callModel({    model: 'openai/gpt-4o',    input: 'Continue where you left off',    tools: myTools,    state,  });   const text = await result.getText();}

const state: StateAccessor = createStateAccessor('conv-456'); // Turn 1const r1 = modelgates.callModel({  model: 'openai/gpt-4o',  input: 'What is the weather in Tokyo?',  tools: [weatherTool] as const,  state,});console.log(await r1.getText());// "The weather in Tokyo is 22°C and sunny." // Turn 2 — state has full history from turn 1const r2 = modelgates.callModel({  model: 'openai/gpt-4o',  input: 'And in Paris?',  tools: [weatherTool] as const,  state,});console.log(await r2.getText());// "The weather in Paris is 15°C and cloudy." // Turn 3 — state has history from both prior turnsconst r3 = modelgates.callModel({  model: 'openai/gpt-4o',  input: 'Which city is warmer?',  tools: [weatherTool] as const,  state,});console.log(await r3.getText());// "Tokyo is warmer at 22°C compared to Paris at 15°C."