Booking Agent

   return {
        updates: {
          [cascadeId as string]: {
            history:    [assistantMessage as CanonicalMessage],
            status:     pendingToolCalls.length > 0 ? 'calling_tool' : 'complete',
            lastUpdate: Date.now(),
            //you can add more fields if you want, it will be written to the cascade state
            // what's mandatory is history and status
          },
        } as Updates,
        ...(isDifferent ? {
          uiUpdates: {
            [cascadeId as string]: { history: [uiAssistantMessage as CanonicalMessage], status: pendingToolCalls.length > 0 ? 'calling_tool' : 'complete' },
          },
        } : {}),
        spawns: undefined,
 
      };

export async function availabilityAgentNodePrep(context: WorkflowContext, initialContext: any) {
  const cascadeId = initialContext.cascadeId;
  const dataArray = context[cascadeId]
  const history = dataArray.flatMap(item => item.history || []);
  return { history };
}

export async function availabilityAgentNodeExec(prepOutput: any) {
  const { history} = prepOutput;
  const OpenAI = (await import('openai')).default;
  const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
 
const available_hotels = {
  type: 'function' as const,
  function: {
    name: 'available_hotels',
    description: 'Fetches a JSON List of hotels,rooms their prices nad other additional details',
    parameters: {
      type: 'object',
      properties: {},     
      required: [],
    },
  },
};
 
  try {
    const systemPrompt =`
### ROLE
You are the hotel retrieval Agent. Your sole purpose is to provide accurate information about available hotels and their prices.
 
### GOALS
1. When you receive a query, ALWAYS call the 'available_hotels' tool first to get the latest data.
2. Filter the results based on the user's specific request (e.g., if they ask for a specific suite or a price constraint).
3. If the user's request is general (e.g., "What is available?"), summarize the top options from the available data.
4. Always use return the image_urls of the hotels fetched along with the data
 
### RESPONSE GUIDELINES
- Be concise. 
- If a user asks for a hotel that doesn't exist in the data, politely inform them of the available hotels.
- Format your output so the Supervisor Agent can easily present it to the end user.
    `
    .trim();
    const conversationHistory = [
      { role: 'system' as const, content: systemPrompt },
      ...history,
    ];
 
    const stream = await openai.chat.completions.create({
      model: 'gpt-4.1-mini-2025-04-14',
      stream: true,
      messages: conversationHistory as any,
      tools: [available_hotels],
      tool_choice: 'auto',
      temperature: 1,
    });
 
    return { stream, provider: 'openai',isReasoning: false} as StreamConfig;
  } catch (error: any) {
    throw new Error(`Agent execution failed: ${error.message}`);
  }
}
 

export async function availabilityAgentNodePost(execOutput: any) {
  const { assistantMessage, cascadeId } = execOutput;  
  const pendingToolCalls = assistantMessage.tool_calls || [];
  const shouldSpawnNode = pendingToolCalls.length > 0 ;
  const updates = {
    [cascadeId]: {
      history: assistantMessage,
      status: pendingToolCalls.length > 0 ? 'calling_tool' : 'complete',
    },
  };
  const spawns: Record<string, any> = {};
  
  if (shouldSpawnNode) {
    spawns['availabilityToolNode'] = {
      history: assistantMessage,
      toolCallsToExecute: pendingToolCalls,
    };
  }
 
  return {
    updates,
    spawns: Object.keys(spawns).length > 0 ? spawns : undefined,
  };
}

export async function availabilityToolNodePrep(selectedData: any, initialContext: any) {
  const toolCallsToExecute = initialContext.toolCallsToExecute || [];
  if (toolCallsToExecute.length === 0) {
    if (!initialContext.hasOwnProperty('toolCallsToExecute')) {
         throw new Error('toolNodePrep Error: No specific toolCallsToExecute array was provided in the context.');
    }
  }
  return { toolCallsToExecute, cascadeId: initialContext.cascadeId};
}

export async function availabilityToolNodeExec(prepOutput: any) {
  'use server';
  const { toolCallsToExecute, cascadeId} = prepOutput; 
  const { executeTool } = await import('./availabilityTools');
 
  const results = await Promise.all(
    toolCallsToExecute.map(async (toolCall: ToolCall) => {
      try {
        const toolResult = await executeTool(toolCall);
        return { toolCall, toolResult };
      } catch (err: any) {
        return {
          toolCall,
          toolResult: {
            role: 'tool',
            tool_call_id: toolCall.id,
            content: JSON.stringify({ error: err.message || 'Tool execution failed' }),
          },
        };
      }
    })
  );
  return { results, cascadeId};
}
 
export type ToolCall = {
  id: string;
  type: 'function';
  function: {
    name: string;
    arguments: string; 
  };
};
 
export type ToolResult = {
  role: 'tool';
  tool_call_id: string;
  content: string; 
};
 
 
 
function getHardcodedHotelAvailability(): string {
  const hostelData = [
    {
      id: "t1",
      hotel: "Sunview Beach Resort",
      available_rooms: [{'room type':'deluxe suite','perNightCost':4000},{'room type':'double bed','perNightCost':2000}],
      description:"Close to Papanasam Beach, this opulent property features comfortable rooms, an azure swimming pool, a private beach and a host of modern amenities.There is a sauna room available to cater to your wellness needs.",
      image_url:"https://gos3.ibcdn.com/13f68fb5-1551-4b5b-9cff-64296e2f85e0.jpeg"
    },
    {
      id: "t2",
      hotel: "Elixir Cliff Beach Resort",
      available_rooms: [{'room type':'deluxe seaview suite','perNightCost':6000}],
      description:"Overlooking the majestic Arabian Sea, this lavish property features stunning rooms, an incredible dining spot, an infinity pool and an extensive range of facilities.",
      image_url:"https://gos3.ibcdn.com/f20a131c53ed11eb90830242ac110002.jpg"
    },
    {
      id: "t3",
      hotel: "WEST BAY MARISOL",
      available_rooms: [{'room type':'standard','perNightCost':4000},{'room type':'deluxe','perNightCost':6000},{'room type':'executive','perNightCost':9000}],
      description:"The property offers a welcoming and comfortable environment, featuring a range of well-appointed rooms designed for both relaxation and convenience. With modern amenities, exceptional service, and a prime location, it caters to both business and leisure travelers. Guests can enjoy various on-site facilities, including dining options, recreational areas, and more, ensuring a memorable stay.",
      image_url:"https://gos3.ibcdn.com/2a3a165f-ec99-4644-97e2-af49828123e3.jpg"
    },
    {
      id: "t4",
      hotel: "Zostel Varkala",
      available_rooms: [{'room type':'mixed dorm','perNightCost':1000},{'room type':'standard','perNightCost':2000},{'room type':'A-Frame Cottage','perNightCost':5000}],
      description:"Set amid swaying coconut palms and facing the Arabian Sea, this scenic property is a 5-minute stroll from Varkala’s famed Black Sand Beach.The rooftop is equipped with patio loungers and inviting spots to work, dine, paint, or simply soak in the panoramic sea vistas.",
      image_url:"https://dynamic-media-cdn.tripadvisor.com/media/photo-o/1a/23/20/5a/zostel-varkala-terrace.jpg?w=900&h=500&s=1"
    },
    {
      id: "t5",
      hotel: "Eva Beach Hotel",
      available_rooms: [{'room type':'DELUXE AC','perNightCost':4000},{'room type':'standard AC','perNightCost':3000}],
      description:"Located in Varkala Cliff, within 100 meters of Varkala Beach and 600 meters of Odayam Beach, Eva Beach Hotel provides accommodation with a terrace, free wifi throughout the property, and free private parking for guests who drive. Rooms are complete with a private bathroom, while certain rooms at the resort also offer a seating area.Popular points of interest near Eva Beach Hotel include Aaliyirakkm Beach, Varkala Cliff, and Janardhanaswamy Temple. The nearest airport is Thiruvananthapuram International, 41 km from the accommodation, and the property offers a paid airport shuttle service.",
      image_url:"https://gos3.ibcdn.com/0f02787c-de9e-493e-bf7f-ab0d50b8c17e.jpeg"
    }
  ];
 
  return JSON.stringify(hostelData, null, 2);
}
 
export const executeTool = async (toolCall: ToolCall): Promise<ToolResult> => {
  const { name, arguments: argsString } = toolCall.function;
 
 
  try {
    const args = JSON.parse(argsString);
    let toolResultData: any;
 
    switch (name) {
   
      case 'available_hotels':
        toolResultData = getHardcodedHotelAvailability();
        break;
         
      default:
        toolResultData = { error: `Unknown tool: ${name}` };
        break;
    }
 
    return {
      role: 'tool',
      tool_call_id: toolCall.id,
      content: JSON.stringify(toolResultData),
    };
  } catch (error: any) {
    return {
      role: 'tool',
      tool_call_id: toolCall.id,
      content: JSON.stringify({
        error: `Tool execution failed: ${error.message}`,
      }),
    };
  }
};

export async function availabilityToolNodePost(execOutput: any) {
  const { results, cascadeId } = execOutput;
  const toolResultsOnly = results.map((r: any) => r.toolResult);
  return {
    updates: {
      [cascadeId]: {
        history: toolResultsOnly,
        status: 'complete',
 
      },
    },
    spawns: {
      'availabilityAgentNode': { 
        history: toolResultsOnly, 
      },
    },
  };
}

export async function bookingAgentNodePrep(context: WorkflowContext, initialContext: any) {
  const cascadeId = initialContext.cascadeId;
  const dataArray = context[cascadeId]
  const history = dataArray.flatMap(item => item.history || []);
  return { history, cascadeId};
}

export async function bookingAgentNodeExec(prepOutput: any) {
  const { history, cascadeId } = prepOutput;
  const OpenAI = (await import('openai')).default;
  const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
 
  try {
 
    const conversationHistory = [
      { role: 'system' as const, content: systemPrompt },
      ...history,
    ];
 
    const stream = await openai.chat.completions.create({
      model: 'gpt-4.1-mini-2025-04-14',
      stream: true,
      messages: conversationHistory as any,
      tools: [
        processBookingPayment 
      ],
      tool_choice: 'auto',
      temperature: 0.7,
    });
 
    const assistantMessage: Message = { role: 'assistant', content: '', tool_calls: [] };
 
    for await (const chunk of stream) {
      const delta = chunk.choices?.[0]?.delta;
      if (!delta) continue;
 
      if (delta.content) {
        assistantMessage.content = (assistantMessage.content || '') + delta.content;
      }
 
      if (delta.tool_calls) {
        for (const toolCall of delta.tool_calls) {
          const index = toolCall.index;
          if (!assistantMessage.tool_calls![index]) {
            assistantMessage.tool_calls![index] = { id: '', type: 'function', function: { name: '', arguments: '' } };
          }
          if (toolCall.id) assistantMessage.tool_calls![index].id = toolCall.id;
          if (toolCall.function?.name) assistantMessage.tool_calls![index].function.name = toolCall.function.name;
          if (toolCall.function?.arguments) assistantMessage.tool_calls![index].function.arguments += toolCall.function.arguments;
        }
      }
    }
 
    if (!assistantMessage.content) assistantMessage.content = null;
    if (!assistantMessage.tool_calls || assistantMessage.tool_calls.length === 0) delete assistantMessage.tool_calls;
 
    return { assistantMessage, cascadeId};
  } catch (error: any) {
    throw new Error(`Agent execution failed: ${error.message}`);
  }
}

export async function bookingAgentNodePost(execOutput: any) {
  const { assistantMessage, cascadeId} = execOutput;
  const toolCallsToExecute = assistantMessage.tool_calls || [];
  const shouldSpawnNode = toolCallsToExecute.length > 0 ;
  const updates = {
    [cascadeId]: {
      history: assistantMessage,
      status: toolCallsToExecute.length > 0 ? 'calling_tool' : 'complete',
 
    },
  };
  const spawns: Record<string, any> = {};
  if (shouldSpawnNode) {
    spawns['bookingUiNode'] = {
      history: assistantMessage,
      toolCallsToExecute: toolCallsToExecute,
    };
  }
  return {
    updates,
    spawns: Object.keys(spawns).length > 0 ? spawns : undefined,
  };
}

await addActiveNode(subNodeName, {
                        cascadeId: newSubCascadeId,
                        history: [{ role: 'user', content: query.trim() }],
                        originalToolCallId: toolCall.id,
                        userId,
                    });
 

export type ToolComponentProps = {
    args: any;
    onComplete: (result: string) => void;
    isFinished: boolean;
    savedResult: string | null;
};
 
export const toolRegistry: Record<string, React.ComponentType<ToolComponentProps>> = {
    // ---
    // Example input tool: user selects a hotel, cascade continues with their choice.
    // Replace or extend this with your own tools.
    // ---
    present_hotel_options: HotelOptions,
};
 

import { ClientWorkflowGraph } from "@cascaide-ts/core";
 
export const clientWorkflowGraph: ClientWorkflowGraph = {
    chat: { name: 'chat', isUINode: true ,env:'client'},
    bookingUiNode: { name: 'bookingUiNode', isUINode: true,env:'client'},
    
    supervisorAgentNode: { name: 'supervisorAgentNode', isUINode: false,env:'server' },
    supervisorToolNode: { name: 'supervisorToolNode', isUINode: false,env:'server' },
    bookingAgentNode: { name: 'bookingAgentNode', isUINode: false,env:'server' },
    bookingToolNode: { name: 'bookingToolNode', isUINode: false,env:'server' },
    availabilityAgentNode: { name: 'availabilityAgentNode', isUINode: false,env:'server' },
    availabilityToolNode: { name: 'availabilityToolNode', isUINode: false,env:'server' },
}

import Chat from "@/components/cascaide-ui/chat/chat"
import { ClientWorkflowConfig } from '@cascaide-ts/react';
import BookingUi from "@/components/cascaide-ui/bookingUiNode";
import { clientWorkflowGraph } from "./graph";
 
export const clientWorkflowConfig: ClientWorkflowConfig = {
  clientWorkflowGraph: clientWorkflowGraph,
  uiComponentRegistry: {
    chat: Chat,
    bookingUiNode : BookingUi,
  },
};

import { supervisorAgentNodeExec, supervisorAgentNodePost,
 supervisorAgentNodePrep, supervisorToolNodeExec, supervisorToolNodePost,
supervisorToolNodePrep} from '@/bubbles/hotel-booking-agent/supervisorAgentNodes';
import {
  bookingAgentNodePrep,
  bookingAgentNodeExec,
  bookingAgentNodePost,
} from '@/bubbles/hotel-booking-agent/bookingAgentNodes';
import { availabilityAgentNodeExec, availabilityAgentNodePost, availabilityAgentNodePrep, availabilityToolNodeExec, availabilityToolNodePost, availabilityToolNodePrep} from '@/bubbles/hotel-booking-agent/availabilityAgentNodes';
import { ServerWorkflowGraph } from '@cascaide-ts/core'
 
export const serverWorkflowGraph: ServerWorkflowGraph = {
    supervisorAgentNode: {
      name: 'supervisorAgentNode',
      prep: supervisorAgentNodePrep ,
      exec: supervisorAgentNodeExec,
      post: supervisorAgentNodePost,
      isStreaming: false,
      isUINode:false,
      env:'server'
    },
    bookingAgentNode: {
      name: 'bookingAgentNode',
      prep: bookingAgentNodePrep ,
      exec: bookingAgentNodeExec,
      post: bookingAgentNodePost,
      isUINode:false,
      isStreaming:false,
      env:'server',
    },
    availabilityAgentNode: {
      name: 'availabilityAgentNode',
      prep: availabilityAgentNodePrep,
      exec: availabilityAgentNodeExec,
      post: availabilityAgentNodePost,
      isStreaming:true,
      env:'server',
      isUINode:false
    },
    availabilityToolNode: {
      name: 'availabilityToolNode',
      prep: availabilityToolNodePrep,
      exec: availabilityToolNodeExec,
      post: availabilityToolNodePost,
      isStreaming:false,
      env:'server',
      isUINode:false
    },
 
    searchAgentNode: {
      name: 'searchAgentNode',
      prep:  searchAgentNodePrep,
      exec: searchAgentNodeExec,
      post: searchAgentNodePost,
      isStreaming: true,
      isUINode:false,
      env:'server'
    },
    searchToolNode: {
      name: 'searchToolNode',
      prep: searchToolNodePrep,
      exec: searchToolNodeExec,
      post: searchToolNodePost,
      isUINode:false,
      isStreaming:false,
      env:'server'
    },
  };

import { WorkflowHandlerConfig } from '@cascaide-ts/server-next'
import { PostgresPersistor } from '@cascaide-ts/postgres-js';
import { sql } from '@/lib/connection';
import { serverWorkflowGraph } from './graph';
 
const workflowpersistor = new PostgresPersistor(sql);
const MAX_EXECUTION_TIME = 100000;
const SAFE_BUFFER = 6000;
 
export const serverWorkflowConfig: WorkflowHandlerConfig = {
  workflowGraph: serverWorkflowGraph,
  persistor: workflowpersistor, // The user passes their PostgresPersistor here
  maxExecutionTime: MAX_EXECUTION_TIME,
  safeBuffer: SAFE_BUFFER
}

import { serverWorkflowConfig } from '@/graphs/server/config'
import { createWorkflowHandler } from '@cascaide-ts/server-next'
 
export const POST = createWorkflowHandler(serverWorkflowConfig);

'use client'
import { clientWorkflowConfig } from '@/graphs/client/config';
import { WorkflowProvider, WorkflowRenderer } from '@cascaide-ts/react';
 
export default function HomePage() {
  return (
    <WorkflowProvider
      initialNodeId="chat_init"
      initialNodeName="chat"
      config={clientWorkflowConfig}
      actionRelayEndpoint='/api/workflow/action'
      hydrationEndpoint='/api/workflow/hydrate'
      persistenceEndpoint='/api/workflow/persistence'
    >
      <WorkflowRenderer />
    </WorkflowProvider>
  );
}