ToolsLearn.js

import 'dotenv/config';
import * as z from 'zod';
import { tool } from '@langchain/core/tools';
import { ChatOpenRouter } from '@langchain/openrouter';
import { HumanMessage, SystemMessage, ToolMessage } from '@langchain/core/messages';

const getCoordinates = tool(
  async ({ location }) => {
    const url =
      `https://geocoding-api.open-meteo.com/v1/search` +
      `?name=${encodeURIComponent(location)}` +
      `&count=1&language=en&format=json`;

    const res = await fetch(url);
    if (!res.ok) throw new Error(`Geocoding failed: ${res.status}`);

    const data = await res.json();
    const place = data.results?.[0];

    if (!place) {
      return `No coordinates found for "${location}".`;
    }

    return JSON.stringify({
      name: place.name,
      country: place.country,
      latitude: place.latitude,
      longitude: place.longitude,
    });
  },
  {
    name: 'get_coordinates',
    description: 'Convert a location name into latitude and longitude.',
    schema: z.object({
      location: z.string().describe('The name of a place'),
    }),
  }
);

const getWeather = tool(
  async ({ latitude, longitude }) => {
    const url =
      `https://api.open-meteo.com/v1/forecast` +
      `?latitude=${latitude}&longitude=${longitude}` +
      `&current=temperature_2m,wind_speed_10m,precipitation,rain,showers,snowfall` +
      `&daily=temperature_2m_max,temperature_2m_min,precipitation_probability_max` +
      `&temperature_unit=fahrenheit&wind_speed_unit=mph&forecast_days=1`;

    const res = await fetch(url);
    if (!res.ok) throw new Error(`Weather request failed: ${res.status}`);

    const data = await res.json();

    return JSON.stringify({
      current: data.current,
      today: {
        maxTempF: data.daily.temperature_2m_max[0],
        minTempF: data.daily.temperature_2m_min[0],
        precipitationChance: data.daily.precipitation_probability_max[0],
      },
    });
  },
  {
    name: 'get_weather',
    description: 'Get current weather and today’s forecast for coordinates.',
    schema: z.object({
      latitude: z.number().describe('Latitude'),
      longitude: z.number().describe('Longitude'),
    }),
  }
);

const tools = [getCoordinates, getWeather];

const toolsByName = {
  get_coordinates: getCoordinates,
  get_weather: getWeather,
};

const model = new ChatOpenRouter({
  model: 'cohere/north-mini-code:free',
  apiKey: process.env.OPENROUTER_API_KEY,
});

const modelWithTools = model.bindTools(tools);

const messages = [
  new SystemMessage(`
You are a hiking expert.

When the user asks what to wear for a hike use the get_coordinates tool to convert the location into coordinates.
Then ese get_weather tool with those coordinates.  Recommend clothing based on temperature, wind, precipitation, and hiking comfort. Note any additional things you determinte would be important to the user and summarize your answer in roughly 5 sentances maximum.
`),
  new HumanMessage('What should I wear on a hike in Santa Cruz today?'),
];

let response = await modelWithTools.invoke(messages);
messages.push(response);

while (response.tool_calls?.length) {
  for (const toolCall of response.tool_calls) {
    const selectedTool = toolsByName[toolCall.name];

    if (!selectedTool) {
      throw new Error(`Unknown tool requested: ${toolCall.name}`);
    }

    const result = await selectedTool.invoke(toolCall.args);

    messages.push(
      new ToolMessage({
        content: String(result),
        tool_call_id: toolCall.id,
        name: toolCall.name,
      })
    );
  }

  response = await modelWithTools.invoke(messages);
  messages.push(response);
}

// Stream the final response after all tools have been executed.
const stream = await modelWithTools.streamEvents(messages, {
  version: "v2",
});

process.stdout.write("\nFinal answer:\n\n");

for await (const event of stream) {
  if (event.event === "on_chat_model_stream") {
    const chunk = event.data?.chunk?.content;

    if (typeof chunk === "string") {
      process.stdout.write(chunk);
    } else if (Array.isArray(chunk)) {
      // Some models stream arrays of content blocks
      for (const block of chunk) {
        if (block.type === "text") {
          process.stdout.write(block.text);
        }
      }
    }
  }
}

process.stdout.write("\n");