{
  "toolCallId": "call_weather_123",
  "toolName": "weatherTool",
  "args": {
    "location": "Tokyo"
  }
}

{
  "toolCallId": "call_weather_123",
  "toolName": "weatherTool",
  "result": {
    "temperature": 22,
    "feelsLike": 25,
    "humidity": 65,
    "windSpeed": 5,
    "windGust": 8,
    "conditions": "Partly cloudy",
    "location": "Tokyo"
  }
}

class MeditationPlanner {
  constructor(chat) {
    this.chat = chat;
  }

  async planOutdoorMeditation(location) {
    const response = await this.chat.sendMessage(
      `What's the weather like in ${location} for outdoor meditation?`,
      'friend'
    );

    const weatherData = this.extractWeatherFromResponse(response);
    return this.evaluateMeditationConditions(weatherData);
  }

  extractWeatherFromResponse(response) {
    // Extract weather data from tool results in the response
    const toolResults = response.toolResults || [];
    const weatherResult = toolResults.find(r => r.toolName === 'weatherTool');

    return weatherResult ? weatherResult.result : null;
  }

  evaluateMeditationConditions(weather) {
    if (!weather) return { suitable: false, reason: 'Weather data unavailable' };

    const { temperature, conditions, windSpeed, humidity } = weather;

    // Ideal conditions for outdoor meditation
    if (temperature < 10 || temperature > 30) {
      return {
        suitable: false,
        reason: `Temperature (${temperature}°C) is not ideal for outdoor meditation`
      };
    }

    if (windSpeed > 15) {
      return {
        suitable: false,
        reason: `Wind speed (${windSpeed} km/h) is too high for peaceful meditation`
      };
    }

    if (conditions.toLowerCase().includes('rain') ||
        conditions.toLowerCase().includes('storm')) {
      return {
        suitable: false,
        reason: `Weather conditions (${conditions}) are not suitable for outdoor meditation`
      };
    }

    return {
      suitable: true,
      reason: `Perfect weather for meditation: ${temperature}°C, ${conditions}`,
      weather
    };
  }
}

// Usage
const planner = new MeditationPlanner(chat);
const plan = await planner.planOutdoorMeditation('Kyoto');

if (plan.suitable) {
  console.log('Great weather for meditation!', plan.reason);
} else {
  console.log('Consider indoor meditation:', plan.reason);
}

class SpiritualTravelPlanner {
  constructor(chat) {
    this.chat = chat;
  }

  async planTempleVisit(location, activity) {
    const query = `What's the weather like in ${location} for ${activity}?`;
    const response = await this.chat.sendMessage(query, 'wanderer');

    return this.createTravelPlan(response, location, activity);
  }

  createTravelPlan(response, location, activity) {
    const weather = this.extractWeatherFromResponse(response);

    if (!weather) {
      return {
        recommendation: 'indoor',
        reason: 'Weather data unavailable',
        alternatives: ['Indoor meditation', 'Temple visits']
      };
    }

    const { temperature, conditions, humidity } = weather;
    let recommendation = 'outdoor';
    let notes = [];

    // Weather-based recommendations
    if (temperature < 15) {
      notes.push('Bring warm clothing for comfort');
    }

    if (humidity > 70) {
      notes.push('High humidity - stay hydrated');
    }

    if (conditions.toLowerCase().includes('sunny')) {
      notes.push('Perfect sunny weather for temple exploration');
    }

    if (conditions.toLowerCase().includes('cloudy')) {
      notes.push('Cloudy skies create serene atmosphere');
    }

    return {
      location,
      activity,
      weather,
      recommendation,
      notes,
      timestamp: new Date().toISOString()
    };
  }

  extractWeatherFromResponse(response) {
    const toolResults = response.toolResults || [];
    return toolResults.find(r => r.toolName === 'weatherTool')?.result || null;
  }
}

// Usage
const travelPlanner = new SpiritualTravelPlanner(chat);
const plan = await travelPlanner.planTempleVisit('Bodh Gaya', 'meditating at the Bodhi tree');

console.log('Travel Plan:', plan);

async function getWeatherWithFallback(location) {
  try {
    const response = await chat.sendMessage(
      `What's the weather like in ${location}?`,
      'friend'
    );

    const weather = extractWeatherFromResponse(response);
    if (weather) {
      return weather;
    } else {
      throw new Error('Weather data not available');
    }
  } catch (error) {
    console.warn('Weather tool failed, using fallback');
    // Implement fallback weather service or cached data
    return await getCachedWeather(location);
  }
}