app.js

// <complete_code>
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.

// <imports>
import { OpenAI } from "openai";
import { FoundryLocalManager } from "foundry-local-sdk";
// </imports>

// By using an alias, the most suitable model will be downloaded 
// to your end-user's device.
// TIP: You can find a list of available models by running the 
// following command in your terminal: `foundry model list`.
const alias = "qwen2.5-0.5b";

// <tool_definitions>
function multiplyNumbers(first, second) {
  return first * second;
}
// </tool_definitions>

async function runToolCallingExample() {
  let manager = null;
  let model = null;

  try {
    // <init>
    console.log("Initializing Foundry Local SDK...");
    manager = FoundryLocalManager.create({
      appName: "foundry_local_samples",
      serviceEndpoint: "http://localhost:5000",
      logLevel: "info"
    });
    // </init>

    // Download and register all execution providers.
    let currentEp = '';
    await manager.downloadAndRegisterEps((epName, percent) => {
      if (epName !== currentEp) {
        if (currentEp !== '') process.stdout.write('\n');
        currentEp = epName;
      }
      process.stdout.write(`\r  ${epName.padEnd(30)}  ${percent.toFixed(1).padStart(5)}%`);
    });
    if (currentEp !== '') process.stdout.write('\n');

    // <model_setup>
    const catalog = manager.catalog;
    model = await catalog.getModel(alias);
    if (!model) {
      throw new Error(`Model ${alias} not found`);
    }

    console.log(`Loading model ${model.id}...`);
    await model.download();
    await model.load();
    console.log('✓ Model loaded');

    manager.startWebService();
    const endpoint = manager.urls[0];
    if (!endpoint) {
      throw new Error("Foundry Local web service did not return an endpoint.");
    }

    const openai = new OpenAI({
      baseURL: `${endpoint.replace(/\/$/, "")}/v1`,
      apiKey: "local"
    });
    // </model_setup>

    // <tool_loop>
    // Prepare messages
    const messages = [
      {
        role: "system",
        content: "You are a helpful AI assistant. If necessary, you can use any provided tools to answer the question."
      },
      { role: "user", content: "What is the answer to 7 multiplied by 6?" }
    ];

    // Prepare tools
    const tools = [
      {
        type: "function",
        function: {
          name: "multiply_numbers",
          description: "A tool for multiplying two numbers.",
          parameters: {
            type: "object",
            properties: {
              first: {
                type: "integer",
                description: "The first number in the operation"
              },
              second: {
                type: "integer",
                description: "The second number in the operation"
              }
            },
            required: ["first", "second"]
          }
        }
      }
    ];

    // Start the conversation
    console.log("Chat completion response:");
    const toolCallResponses = [];

    const firstStream = await openai.chat.completions.create({
      model: model.id,
      messages,
      tools,
      tool_choice: "required",
      stream: true
    });

    for await (const chunk of firstStream) {
      const content = chunk.choices?.[0]?.delta?.content;
      if (content) {
        process.stdout.write(content);
      }

      if (chunk.choices?.[0]?.finish_reason === "tool_calls") {
        toolCallResponses.push(chunk);
      }
    }
    console.log();

    // Invoke tools called and append responses to the chat
    for (const chunk of toolCallResponses) {
      const toolCalls = chunk.choices?.[0]?.message?.tool_calls ?? chunk.choices?.[0]?.delta?.tool_calls ?? [];
      for (const toolCall of toolCalls) {
        if (toolCall.function?.name === "multiply_numbers") {
          const args = JSON.parse(toolCall.function.arguments || "{}");
          const first = args.first;
          const second = args.second;

          console.log(`\nInvoking tool: ${toolCall.function.name} with arguments ${first} and ${second}`);
          const result = multiplyNumbers(first, second);
          console.log(`Tool response: ${result}`);

          messages.push({
            role: "tool",
            tool_call_id: toolCall.id,
            content: result.toString()
          });
        }
      }
    }

    console.log("\nTool calls completed. Prompting model to continue conversation...\n");

    // Prompt the model to continue the conversation after the tool call
    messages.push({
      role: "system",
      content: "Respond only with the answer generated by the tool."
    });

    // Run the next turn of the conversation
    console.log("Chat completion response:");
    const secondStream = await openai.chat.completions.create({
      model: model.id,
      messages,
      tools,
      tool_choice: "auto",
      stream: true
    });

    for await (const chunk of secondStream) {
      const content = chunk.choices?.[0]?.delta?.content;
      if (content) {
        process.stdout.write(content);
      }
    }

    console.log();
    // </tool_loop>
  } finally {
    // <cleanup>
    if (model) {
      try {
        if (await model.isLoaded()) {
          await model.unload();
        }
      } catch (cleanupError) {
        console.warn("Cleanup warning while unloading model:", cleanupError);
      }
    }

    if (manager) {
      try {
        manager.stopWebService();
      } catch (cleanupError) {
        console.warn("Cleanup warning while stopping service:", cleanupError);
      }
    }
    // </cleanup>
  }
}

await runToolCallingExample().catch((error) => {
  console.error("Error running sample:", error);
  process.exitCode = 1;
});
// </complete_code>