// cooking-agent.js
import "dotenv/config";
import { Agent, tool } from "@openai/agents";
import { z } from "zod";
 
// Create a specialized Cooking Agent
const getCurrentTimeTool = tool({
  name: "get_current_time",
  description: "This tool returns the current date and time as a string.",
  parameters: z.object({}),
  execute: async () => {
    return new Date().toString();
  },
});
 
const getMenuTool = tool({
  name: "get_menu",
  description:
    "This tool fethes and returns the menu of a restaurant given its name.",
  parameters: z.object({
    restaurant_name: z.string().describe("The name of the restaurant"),
  }),
  execute: async ({ restaurant_name }) => {
    const menu = {
      "restaurant a": [
        {
          Drinks: {
            Chai: "INR 50",
            Coffee: "INR 70",
          },
          Veg: {
            DalMakhni: "INR 250",
            Panner: "INR 400",
          },
        },
      ],
      "restaurant b": [
        {
          Drinks: {
            Lemonade: "INR 40",
            Mojito: "INR 120",
            Lahori: "INR 150",
          },
          NonVeg: {
            ChickenCurry: "INR 350",
            MuttonBiryani: "INR 500",
          },
          Veg: {
            VegBiryani: "INR 300",
            MixVeg: "INR 200",
          },
        },
      ],
    };
    return (
      menu[restaurant_name.toLowerCase()] ||
      "Menu not found for this restaurant."
    );
  },
});
 
export const cookingAgent = new Agent({
  name: "Cooking Agent",
  model: "gpt-4.1-mini",
  tools: [getCurrentTimeTool, getMenuTool],
  instructions: `
    You are a cooking assistant who is speacialized in cooking food. 
    Help users with recipes, cooking tips, and meal ideas. Always help them to cook the 
    foods they want to cook.
 
    Your Responsibilities for Cooking-Related Queries:
    If the user asks for a recipe, provide a detailed recipe with ingredients 
    and step-by-step instructions.
    If the user asks for cooking tips, provide useful and practical advice.
    If the user asks for meal ideas, suggest creative and delicious meal options based 
    on their preferences and dietary restrictions.
 
    Your Responsibilities for Restaurant Menu Queries:
    If the user asks for the menu of a restaurant, use the get_menu tool to fetch the 
    menu.
    If the user asks for the price of a specific dish or drink in a restaurant, use the 
    get_menu tool to fetch the menu and provide the price.
    If the user asks for recommendations based on the menu, use the get_menu tool to 
    fetch the menu and suggest dishes or drinks.
    If the user asks for the current time to suggest a meal, use the get_current_time 
    tool to fetch the current time and suggest a meal accordingly.
 
    Important Notes:
    If the user asks for something unrelated to cooking or restaurant 
    menus, politely inform them that you can only assist with cooking 
    and restaurant menu-related queries.
    Always use the provided tools to fetch real-time information when needed.
 
    Tone and Style:
    Always respond in a friendly and helpful manner.
    Use clear and concise language that is easy to understand.
    `,
});

// coding-agent.js
import "dotenv/config";
import { Agent, webSearchTool } from "@openai/agents";
 
// Create a specialized Coding Agent
export const codingAgent = newAgent({
name: "Coding Agent",
tools: [webSearchTool("https://developer.mozilla.org/en-US")],
instructions: `
    You are a coding assistant particularly skilled in JavaScript. You help users with
    coding-related queries such as writing code snippets, debugging, and explaining concepts.
 
    Responsibilities:
    - Answer only coding-related questions
    - Use MDN Web Docs for accurate references when needed
    - Explain concepts in simple language
 
    Output Format:
    {
      code: "your code snippet here",
      explanation: "your explanation here",
      references: ["list of references"]
    }
 
    If the query is not coding-related, respond politely that you can only help with coding.
  `,
});

// gatway-agent.js
import "dotenv/config";
import { Agent } from "@openai/agents";
import { cookingAgent } from "./cooking-agent.js";
import { codingAgent } from "./coding-agent.js";
 
// Create a Gateway (Receptionist) Agent using handoffs
export const getewayAgent = Agent.create({
name: "Gateway Agent",
handoffs: [cookingAgent, codingAgent],
instructions: `
    You are a gateway agent that routes user queries to the correct specialized agent.
 
    Available agents:
    1. Cooking Agent – handles food, recipes, and restaurant-related queries
    2. Coding Agent – handles JavaScript and coding-related queries
 
    Your job is to analyze the user query and forward it to the most suitable agent.
    If the query is ambiguous, choose the best possible agent.
  `,
});

// index.js
import "dotenv/config";
import { run } from "@openai/agents";
import { getewayAgent } from "./gateway-agent.js";
 
// Run the agent with runner (text input/chat input)
const chatWithAgent = async (query) => {
  const result = await run(getewayAgent, query);
  console.log("History :", result.history);
  console.log("Last Agent :", result.lastAgent.name);
  console.log("Final Output :", result.finalOutput);
};
 
// Example usage
chatWithAgent(
  `I am a biginner in JavaScript. Can you help me understand 
   closures with a simple example?`
);