Tool Calling

import { Sudo } from "sudo-ai";

const sudo = new Sudo({
  serverURL: "https://sudoapp.dev/api",
  apiKey: process.env.SUDO_API_KEY ?? "",
});

function getWeather(location: string): string {
  // This would normally call a real weather API
  return `The weather in ${location} is sunny and 75°F`;
}

// Define the tool for the AI
const tools = [
  {
    type: "function" as const,
    function: {
      name: "get_weather",
      description: "Get current weather information for a location",
      parameters: {
        type: "object",
        properties: {
          location: {
            type: "string",
            description: "The city and state, e.g. San Francisco, CA"
          }
        },
        required: ["location"]
      }
    }
  }
];

async function basicToolCalling() {
  try {
    const response = await sudo.router.create({
      model: "gpt-4o",
      messages: [
        { role: "user", content: "What's the weather like in New York?" }
      ],
      tools: tools,
      toolChoice: "auto"
    });
    
    const message = response.choices[0].message;
    
    // Check if the model wants to call a function
    if (message.toolCalls) {
      for (const toolCall of message.toolCalls) {
        if (toolCall.function.name === "get_weather") {
          const args = JSON.parse(toolCall.function.arguments);
          const weatherResult = getWeather(args.location);
          console.log(`Weather result: ${weatherResult}`);
        }
      }
    } else {
      console.log(`Response: ${message.content}`);
    }
  } catch (error) {
    console.error("Tool calling error:", error);
  }
}

basicToolCalling();

import { Sudo } from "sudo-ai";

const sudo = new Sudo({
  serverURL: "https://sudoapp.dev/api",
  apiKey: process.env.SUDO_API_KEY ?? "",
});

async function streamWithToolCalls() {
  const tools = [
    {
      type: "function" as const,
      function: {
        name: "search_database",
        description: "Search for information in the database",
        parameters: {
          type: "object",
          properties: {
            query: { 
              type: "string", 
              description: "Search query" 
            }
          },
          required: ["query"]
        }
      }
    }
  ];
  
  try {
    const stream = await sudo.router.createStreaming({
      model: "gpt-4o",
      messages: [
        { role: "user", content: "Find information about TypeScript frameworks" }
      ],
      tools: tools,
      toolChoice: "auto"
    });
    
    const toolCalls: any[] = [];
    const contentParts: string[] = [];
    
    for await (const chunk of stream) {
      if (chunk.data?.choices) {
        for (const choice of chunk.data.choices) {
          if (choice.delta) {
            // Regular content
            if (choice.delta.content) {
              const content = choice.delta.content;
              contentParts.push(content);
              process.stdout.write(content);
            }
            
            // Tool calls
            if (choice.delta.toolCalls) {
              for (const toolCallDelta of choice.delta.toolCalls) {
                // Handle streaming tool calls
                console.log(`\n[Tool Call: ${toolCallDelta.function?.name}]`);
                if (toolCallDelta.function?.arguments) {
                  console.log(`[Args: ${toolCallDelta.function.arguments}]`);
                }
              }
            }
          }
        }
      }
    }
    
    console.log();
  } catch (error) {
    console.error("Streaming tool calling error:", error);
  }
}

streamWithToolCalls();