Function Calling in Production: Patterns and Pitfalls

import { z } from 'zod';
import OpenAI from 'openai';

// Define function schemas with Zod
const functions = {
  search_products: {
    schema: z.object({
      query: z.string().min(1).max(200),
      category: z.enum(['electronics', 'clothing', 'home', 'all']).default('all'),
      limit: z.number().min(1).max(50).default(10),
      price_max: z.number().positive().optional(),
    }),
    description: 'Search the product catalog',
    handler: async (params, context) => {
      // Permission check
      if (!context.user.hasPermission('products:read')) {
        return { error: 'PERMISSION_DENIED', message: 'Cannot access products' };
      }
      
      const results = await db.products.search({
        query: params.query,
        category: params.category === 'all' ? undefined : params.category,
        limit: params.limit,
        priceMax: params.price_max,
      });
      
      return { products: results, count: results.length };
    },
  },
  
  create_order: {
    schema: z.object({
      product_id: z.string().uuid(),
      quantity: z.number().int().min(1).max(100),
      shipping_address: z.object({
        street: z.string(),
        city: z.string(),
        country: z.string(),
        postal_code: z.string(),
      }),
    }),
    description: 'Create a new order',
    handler: async (params, context) => {
      // Check product exists
      const product = await db.products.findById(params.product_id);
      if (!product) {
        return { error: 'NOT_FOUND', message: 'Product not found' };
      }
      
      // Check inventory
      if (product.stock < params.quantity) {
        return { error: 'INSUFFICIENT_STOCK', message: `Only ${product.stock} available` };
      }
      
      // Create order
      const order = await db.orders.create({
        userId: context.user.id,
        productId: params.product_id,
        quantity: params.quantity,
        shippingAddress: params.shipping_address,
        total: product.price * params.quantity,
      });
      
      return { order_id: order.id, total: order.total, status: 'created' };
    },
  },
};

// Convert Zod schemas to OpenAI function format
function zodToOpenAI(name: string, schema: z.ZodObject<any>, description: string) {
  return {
    type: 'function' as const,
    function: {
      name,
      description,
      parameters: zodToJsonSchema(schema),
    },
  };
}

// Execute with validation
async function executeFunction(
  name: string,
  args: unknown,
  context: { user: User }
): Promise<{ success: boolean; result?: any; error?: any }> {
  const fn = functions[name as keyof typeof functions];
  
  if (!fn) {
    return { success: false, error: { code: 'UNKNOWN_FUNCTION', message: `Unknown: ${name}` } };
  }
  
  // Validate with Zod
  const validation = fn.schema.safeParse(args);
  if (!validation.success) {
    return {
      success: false,
      error: {
        code: 'VALIDATION_ERROR',
        message: 'Invalid parameters',
        details: validation.error.issues,
      },
    };
  }
  
  try {
    const result = await fn.handler(validation.data, context);
    
    if (result.error) {
      return { success: false, error: result };
    }
    
    return { success: true, result };
  } catch (error) {
    return {
      success: false,
      error: { code: 'EXECUTION_ERROR', message: error.message },
    };
  }
}