Tool Integration

import { tool } from 'ai';
import { z } from 'zod';

const weatherTool = tool({
  description: 'Get current weather for a location',
  parameters: z.object({
    location: z.string().describe('City name or coordinates'),
    units: z.enum(['celsius', 'fahrenheit']).default('celsius'),
  }),
  execute: async ({ location, units }) => {
    const response = await fetch(
      `https://api.weather.com/v1/current?location=${location}&units=${units}`
    );
    return await response.json();
  },
});

import { toState } from '@deepagents/agent';

interface AppContext {
  userId: string;
  apiKey: string;
}

const saveNoteTool = tool({
  description: 'Save a note for the user',
  parameters: z.object({
    title: z.string(),
    content: z.string(),
  }),
  execute: async ({ title, content }, options) => {
    const ctx = toState<AppContext>(options);
    
    await saveToDatabase({
      userId: ctx.userId,
      title,
      content,
      apiKey: ctx.apiKey,
    });
    
    return { success: true, id: '...' };
  },
});

import { dynamicTool } from 'ai';

function createDatabaseTool(tableName: string) {
  return dynamicTool({
    description: `Query the ${tableName} table`,
    parameters: z.object({
      query: z.string(),
    }),
    execute: async ({ query }) => {
      return await db.query(`SELECT * FROM ${tableName} WHERE ${query}`);
    },
  });
}

const tools = {
  queryUsers: createDatabaseTool('users'),
  queryOrders: createDatabaseTool('orders'),
};

import { agent, execute } from '@deepagents/agent';
import { openai } from '@ai-sdk/openai';

const assistant = agent({
  name: 'assistant',
  model: openai('gpt-4o'),
  prompt: 'You help users with weather and time information.',
  tools: {
    getWeather: weatherTool,
    getCurrentTime: timeTool,
  },
});

const stream = execute(
  assistant,
  'What is the weather in Tokyo?',
  {}
);

console.log(await stream.text);

const searchTool = tool({
  description: 'Search for information online',
  parameters: z.object({
    query: z
      .string()
      .describe('The search query, use specific keywords'),
    maxResults: z
      .number()
      .int()
      .min(1)
      .max(20)
      .default(5)
      .describe('Maximum number of results to return'),
    dateRange: z
      .enum(['day', 'week', 'month', 'year', 'all'])
      .optional()
      .describe('Filter results by date'),
  }),
  execute: async ({ query, maxResults, dateRange }) => {
    return performSearch(query, maxResults, dateRange);
  },
});

const createOrderTool = tool({
  description: 'Create a new order',
  parameters: z.object({
    customer: z.object({
      name: z.string(),
      email: z.string().email(),
    }),
    items: z.array(
      z.object({
        productId: z.string(),
        quantity: z.number().int().min(1),
        price: z.number().positive(),
      })
    ),
    shippingAddress: z.object({
      street: z.string(),
      city: z.string(),
      postalCode: z.string(),
      country: z.string(),
    }),
  }),
  execute: async (params) => {
    return await createOrder(params);
  },
});

const agent = agent({
  name: 'assistant',
  model: openai('gpt-4o'),
  prompt: 'You are helpful.',
  tools: { search: searchTool },
  toolChoice: 'auto', // Agent decides
});

const agent = agent({
  name: 'assistant',
  model: openai('gpt-4o'),
  prompt: 'You must use tools.',
  tools: { search: searchTool },
  toolChoice: 'required', // Must use a tool
});

const agent = agent({
  name: 'assistant',
  model: openai('gpt-4o'),
  prompt: 'You respond directly.',
  tools: { search: searchTool },
  toolChoice: 'none', // Never use tools
});

const agent = agent({
  name: 'assistant',
  model: openai('gpt-4o'),
  prompt: 'You search for information.',
  tools: { search: searchTool, weather: weatherTool },
  toolChoice: { type: 'tool', name: 'search' }, // Force search tool
});

const apiTool = tool({
  description: 'Call external API',
  parameters: z.object({ endpoint: z.string() }),
  execute: async ({ endpoint }) => {
    try {
      const response = await fetch(`https://api.example.com/${endpoint}`);
      if (!response.ok) {
        return {
          error: true,
          message: `API returned ${response.status}`,
        };
      }
      return await response.json();
    } catch (error) {
      return {
        error: true,
        message: error.message,
      };
    }
  },
});

const dbQueryTool = tool({
  description: 'Query database',
  parameters: z.object({ query: z.string() }),
  execute: async ({ query }) => {
    // Validate query is read-only
    const lowerQuery = query.toLowerCase();
    if (
      lowerQuery.includes('delete') ||
      lowerQuery.includes('update') ||
      lowerQuery.includes('insert') ||
      lowerQuery.includes('drop')
    ) {
      return {
        error: true,
        message: 'Only SELECT queries are allowed',
      };
    }
    
    return await db.query(query);
  },
});

import { ddgSearch, hackernewsSearch, weather } from '@deepagents/toolbox';

const agent = agent({
  name: 'assistant',
  model: openai('gpt-4o'),
  prompt: 'You help users find information.',
  tools: {
    search: ddgSearch,
    news: hackernewsSearch,
    weather: weather,
  },
});

function withLogging<T extends CoreTool>(tool: T, name: string): T {
  const originalExecute = tool.execute;
  
  return {
    ...tool,
    execute: async (params, options) => {
      console.log(`[${name}] Executing with:`, params);
      const start = Date.now();
      try {
        const result = await originalExecute(params, options);
        console.log(`[${name}] Completed in ${Date.now() - start}ms`);
        return result;
      } catch (error) {
        console.error(`[${name}] Failed:`, error);
        throw error;
      }
    },
  };
}

const loggedSearch = withLogging(searchTool, 'search');

const weatherAndNewsTool = tool({
  description: 'Get weather and local news for a location',
  parameters: z.object({ location: z.string() }),
  execute: async ({ location }) => {
    const [weather, news] = await Promise.all([
      weatherTool.execute({ location }),
      searchTool.execute({ query: `${location} news` }),
    ]);
    
    return { weather, news };
  },
});