haroo 1.0.0

package/src/application/graph/nodes/addEvent.ts

@@ -0,0 +1,113 @@
+import { AIMessage, HumanMessage, SystemMessage } from "@langchain/core/messages";
+import { z } from "zod";
+import type { GraphStateType } from "../../../domain/state/AgentState";
+import type { Event } from "../../../domain/entities/Event";
+import type { ILanguageModel } from "../../../domain/interfaces/ILanguageModel";
+import type { EventService } from "../../services/EventService";
+
+const ParsedEventSchema = z.object({
+  title: z.string().min(1).describe("The event title/name"),
+  datetime: z.string().describe("ISO 8601 datetime string for when the event starts"),
+  endTime: z.string().optional().describe("ISO 8601 datetime string for when the event ends"),
+  notes: z.string().optional().describe("Additional notes or description"),
+  tags: z.array(z.string()).optional().describe("Tags or categories for the event"),
+});
+
+type ParsedEvent = z.infer<typeof ParsedEventSchema>;
+
+const EVENT_PARSER_SYSTEM_PROMPT = `You are an event parser for a calendar assistant. Extract event details from the user's message.
+
+Current date and time context will be provided. Use this to interpret relative dates like "tomorrow", "next week", "in 2 hours", etc.
+
+You must respond with a JSON object containing:
+- title: A clear, concise name for the event
+- datetime: ISO 8601 format (e.g., "2024-01-15T14:30:00")
+- endTime: (optional) ISO 8601 format for event end
+- notes: (optional) Any additional details mentioned
+- tags: (optional) Relevant categories like ["work", "meeting"] or ["personal", "health"]
+
+If the user doesn't specify a time, default to 9:00 AM for morning events, 12:00 PM for afternoon events, or use reasonable defaults.`;
+
+export interface AddEventNodeDeps {
+  llm: ILanguageModel;
+  eventService: EventService;
+}
+
+export async function addEventNode(
+  state: GraphStateType,
+  deps: AddEventNodeDeps
+): Promise<Partial<GraphStateType>> {
+  const lastMessage = state.messages[state.messages.length - 1];
+
+  if (!lastMessage || !(lastMessage instanceof HumanMessage)) {
+    return {
+      response: "I couldn't understand the event request. Please try again.",
+      pendingEvent: null,
+    };
+  }
+
+  const userMessage =
+    typeof lastMessage.content === "string"
+      ? lastMessage.content
+      : JSON.stringify(lastMessage.content);
+
+  const now = new Date();
+  const contextMessage = `Current date/time: ${now.toISOString()} (${now.toLocaleDateString("en-US", { weekday: "long", year: "numeric", month: "long", day: "numeric" })})
+
+User request: ${userMessage}`;
+
+  try {
+    const structuredLlm = deps.llm.withStructuredOutput<ParsedEvent>(ParsedEventSchema);
+
+    const response = await structuredLlm.generate([
+      new SystemMessage(EVENT_PARSER_SYSTEM_PROMPT),
+      new HumanMessage(contextMessage),
+    ]);
+
+    const parsed = ParsedEventSchema.safeParse(JSON.parse(response.content));
+
+    if (!parsed.success) {
+      return {
+        response: `I had trouble parsing the event details: ${parsed.error.message}. Could you please rephrase?`,
+        pendingEvent: null,
+      };
+    }
+
+    const eventData = parsed.data;
+
+    console.log("[AddEvent] Saving event:", eventData);
+    const newEvent = await deps.eventService.add({
+      title: eventData.title,
+      datetime: new Date(eventData.datetime),
+      endTime: eventData.endTime ? new Date(eventData.endTime) : undefined,
+      notes: eventData.notes,
+      tags: eventData.tags ?? [],
+    });
+    console.log("[AddEvent] Event saved:", newEvent);
+
+    const formattedDate = newEvent.datetime.toLocaleDateString("en-US", {
+      weekday: "long",
+      year: "numeric",
+      month: "long",
+      day: "numeric",
+    });
+    const formattedTime = newEvent.datetime.toLocaleTimeString("en-US", {
+      hour: "numeric",
+      minute: "2-digit",
+    });
+
+    const responseMessage = `I've added "${newEvent.title}" to your calendar for ${formattedDate} at ${formattedTime}.`;
+
+    return {
+      pendingEvent: newEvent,
+      response: responseMessage,
+      messages: [new AIMessage(responseMessage)],
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    return {
+      response: `Failed to add the event: ${errorMessage}. Please try again.`,
+      pendingEvent: null,
+    };
+  }
+}

package/src/application/graph/nodes/chat.ts

@@ -0,0 +1,128 @@
+import {
+  HumanMessage,
+  AIMessage,
+  SystemMessage,
+  ToolMessage,
+  BaseMessage,
+} from "@langchain/core/messages";
+import type { GraphStateType } from "../../../domain/state/AgentState";
+import type { ILanguageModel } from "../../../domain/interfaces/ILanguageModel";
+import type { Memory } from "../../../domain/entities/Memory";
+import type { ToolRegistry } from "./types";
+import { calendarToolDefinitions } from "../../tools/calendarTool";
+import { diaryToolDefinitions } from "../../tools/diaryTool";
+
+const CHAT_SYSTEM_PROMPT = `You are a helpful, friendly assistant integrated with a calendar/scheduling system. You approach conversations with warmth and emotional awareness.
+
+**Therapeutic Communication Style:**
+- Listen actively and acknowledge emotions when the user expresses them
+- Offer gentle encouragement and validation when appropriate
+- If the user seems stressed or overwhelmed, offer brief supportive statements
+- Maintain a calm, reassuring tone without being overly clinical
+- Respect boundaries - don't push for emotional disclosure
+
+When relevant memories about the user are provided, use them to personalize your responses and maintain continuity in the conversation.
+
+You have access to calendar tools to add events and query the calendar, as well as diary tools to review past journal entries and mood trends.
+
+Be concise but warm in your responses. If you notice emotional patterns (from diary entries or current conversation), you may gently acknowledge them when appropriate.`;
+
+const allToolDefinitions = [...calendarToolDefinitions, ...diaryToolDefinitions];
+
+export interface ChatNodeDeps {
+  llm: ILanguageModel;
+  tools?: ToolRegistry;
+}
+
+function formatMemoriesContext(memories: Memory[]): string {
+  if (memories.length === 0) {
+    return "";
+  }
+
+  const memoryLines = memories.map((m) => `- [${m.type}] ${m.content}`);
+  return `\nRelevant context about the user:\n${memoryLines.join("\n")}\n`;
+}
+
+function formatTodayEventsContext(events: { title: string; datetime: Date }[]): string {
+  if (events.length === 0) {
+    return "";
+  }
+
+  const eventLines = events.map((e) => {
+    const time = e.datetime.toLocaleTimeString("en-US", {
+      hour: "numeric",
+      minute: "2-digit",
+    });
+    return `- ${e.title} at ${time}`;
+  });
+
+  return `\nUser's events today:\n${eventLines.join("\n")}\n`;
+}
+
+export async function chatNode(
+  state: GraphStateType,
+  deps: ChatNodeDeps
+): Promise<Partial<GraphStateType>> {
+  const lastMessage = state.messages[state.messages.length - 1];
+
+  // If last message is a ToolMessage, we need to continue the conversation
+  const isToolResponse = lastMessage instanceof ToolMessage;
+
+  if (!lastMessage || (!isToolResponse && !(lastMessage instanceof HumanMessage))) {
+    return {
+      response: "I'm here to help! How can I assist you today?",
+    };
+  }
+
+  const memoriesContext = formatMemoriesContext(state.relevantMemories);
+  const todayContext = formatTodayEventsContext(state.todayEvents);
+  const additionalContext = memoriesContext + todayContext;
+
+  const systemPrompt = additionalContext
+    ? `${CHAT_SYSTEM_PROMPT}\n${additionalContext}`
+    : CHAT_SYSTEM_PROMPT;
+
+  // Build messages array with system prompt at the start
+  const lcMessages: BaseMessage[] = [new SystemMessage(systemPrompt), ...state.messages];
+
+  try {
+    // Pass tool definitions if tools are available
+    const toolDefs = deps.tools && deps.tools.size > 0 ? allToolDefinitions : undefined;
+    const response = await deps.llm.generate(lcMessages, toolDefs);
+
+    // Check if LLM returned tool calls
+    if (response.toolCalls && response.toolCalls.length > 0) {
+      // Convert to OpenAI tool call format for additional_kwargs
+      const formattedToolCalls = response.toolCalls.map((tc) => ({
+        id: tc.id,
+        type: "function" as const,
+        function: {
+          name: tc.name,
+          arguments: JSON.stringify(tc.arguments),
+        },
+      }));
+
+      // Return AI message with tool calls attached
+      const aiMessage = new AIMessage({
+        content: response.content || "",
+        additional_kwargs: {
+          tool_calls: formattedToolCalls,
+        },
+      });
+
+      return {
+        messages: [aiMessage],
+      };
+    }
+
+    return {
+      response: response.content,
+      messages: [new AIMessage(response.content)],
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    return {
+      response: `I encountered an issue: ${errorMessage}. Let me try again.`,
+    };
+  }
+}

package/src/application/graph/nodes/extractMemory.ts

@@ -0,0 +1,135 @@
+import { z } from "zod";
+import { HumanMessage, AIMessage, SystemMessage } from "@langchain/core/messages";
+import { randomUUID } from "crypto";
+import type { GraphStateType } from "../../../domain/state/AgentState";
+import type { Memory } from "../../../domain/entities/Memory";
+import type { ILanguageModel } from "../../../domain/interfaces/ILanguageModel";
+import type {
+  IMemoriesRepository,
+  EmbeddingFunction,
+} from "../../../domain/interfaces/IMemoriesRepository";
+
+const ExtractedMemorySchema = z.object({
+  memories: z
+    .array(
+      z.object({
+        type: z
+          .enum([
+            "fact",
+            "preference",
+            "routine",
+            "relationship",
+            "communication_style",
+            "interest",
+          ])
+          .describe(
+            "The type of memory: 'fact' for identity info, 'preference' for likes/dislikes, 'routine' for regular patterns, 'relationship' for people in their life, 'communication_style' for how they prefer to interact, 'interest' for topics they care about"
+          ),
+        content: z.string().describe("The memory content - a concise statement of the information"),
+        importance: z
+          .number()
+          .min(1)
+          .max(10)
+          .describe("Importance score: 1-3 trivial, 4-6 useful, 7-9 important, 10 critical"),
+      })
+    )
+    .describe("List of extracted memories from the conversation"),
+});
+
+type ExtractedMemories = z.infer<typeof ExtractedMemorySchema>;
+
+const MEMORY_EXTRACTOR_SYSTEM_PROMPT = `Extract ONLY persistent facts about the user that will remain true over time.
+
+Memory types:
+- "fact": Identity facts ("I'm a college student", "I work at XYZ", "My name is...")
+- "preference": Likes/dislikes ("I prefer morning meetings", "I hate spicy food")
+- "routine": Regular patterns ("I exercise on Mondays", "I usually wake at 7am")
+- "relationship": People in their life ("My friend Sarah is a designer", "My sister lives in NYC")
+- "communication_style": How they prefer to interact ("prefers concise responses", "likes detailed explanations")
+- "interest": Topics they care about ("frequently discusses photography", "interested in AI")
+
+DO NOT extract:
+- Specific events: "Meeting at 2 this weekend" (goes to calendar only)
+- Time-bound info: "Traveling next week" (ephemeral)
+- One-time tasks: "Need to call mom tomorrow" (ephemeral)
+- Anything already captured as a calendar event
+
+Guidelines:
+- Only output memories that will still be relevant weeks/months from now
+- Be concise - each memory should be a single clear statement
+- Rate importance based on how core this is to the user's identity/preferences
+
+You must respond with a JSON object containing a "memories" array. If no memories are worth extracting, return {"memories": []}.`;
+
+export interface ExtractMemoryNodeDeps {
+  llm: ILanguageModel;
+  memoriesRepository: IMemoriesRepository;
+  embeddingFn?: EmbeddingFunction;
+}
+
+export async function extractMemoryNode(
+  state: GraphStateType,
+  deps: ExtractMemoryNodeDeps
+): Promise<Partial<GraphStateType>> {
+  const recentMessages = state.messages.slice(-6);
+
+  if (recentMessages.length < 2) {
+    return {};
+  }
+
+  const conversationText = recentMessages
+    .map((msg) => {
+      const role =
+        msg instanceof HumanMessage ? "User" : msg instanceof AIMessage ? "Assistant" : "System";
+      return `${role}: ${String(msg.content)}`;
+    })
+    .join("\n");
+
+  try {
+    const structuredLlm = deps.llm.withStructuredOutput<ExtractedMemories>(ExtractedMemorySchema);
+
+    const response = await structuredLlm.generate([
+      new SystemMessage(MEMORY_EXTRACTOR_SYSTEM_PROMPT),
+      new HumanMessage(`Extract memories from this conversation:\n\n${conversationText}`),
+    ]);
+
+    const parsed = ExtractedMemorySchema.safeParse(JSON.parse(response.content));
+
+    if (!parsed.success || parsed.data.memories.length === 0) {
+      return {};
+    }
+
+    const now = new Date();
+    const savedMemories: Memory[] = [];
+
+    for (const extractedMemory of parsed.data.memories) {
+      const memory: Memory = {
+        id: randomUUID(),
+        type: extractedMemory.type,
+        content: extractedMemory.content,
+        source: "conversation",
+        importance: extractedMemory.importance,
+        lastAccessed: now,
+        createdAt: now,
+      };
+
+      let embedding: number[] | undefined;
+      if (deps.embeddingFn) {
+        try {
+          embedding = await deps.embeddingFn(extractedMemory.content);
+        } catch {
+          // Continue without embedding if it fails
+        }
+      }
+
+      const saved = await deps.memoriesRepository.create(memory, embedding);
+      savedMemories.push(saved);
+    }
+
+    return {
+      relevantMemories: [...state.relevantMemories, ...savedMemories],
+    };
+  } catch {
+    return {};
+  }
+}

package/src/application/graph/nodes/index.ts

@@ -0,0 +1,8 @@
+export { type AddEventNodeDeps, addEventNode } from "./addEvent";
+export { type ChatNodeDeps, chatNode } from "./chat";
+export { type ExtractMemoryNodeDeps, extractMemoryNode } from "./extractMemory";
+export { type QueryNodeDeps, queryNode } from "./query";
+export { type RouterNodeDeps, routerNode } from "./router";
+export { respondNode } from "./respond";
+export { toolExecutorNode, hasToolCalls, type ToolExecutorNodeDeps } from "./toolExecutor";
+export { type ToolExecutor, type ToolRegistry } from "./types";

package/src/application/graph/nodes/query.ts

@@ -0,0 +1,194 @@
+import { AIMessage, HumanMessage, SystemMessage } from "@langchain/core/messages";
+import { z } from "zod";
+import type { Event } from "../../../domain/entities/Event";
+import type { ILanguageModel } from "../../../domain/interfaces/ILanguageModel";
+import type { GraphStateType } from "../../../domain/state/AgentState";
+import type { EventService } from "../../services/EventService";
+
+const QueryIntentSchema = z.object({
+  queryType: z
+    .enum(["today", "tomorrow", "week", "specific_date", "range", "search", "upcoming"])
+    .describe("The type of calendar query"),
+  searchTerm: z.string().optional().describe("Search term if looking for specific events"),
+  specificDate: z.string().optional().describe("ISO 8601 date if querying a specific date"),
+  startDate: z.string().optional().describe("Start date for range queries"),
+  endDate: z.string().optional().describe("End date for range queries"),
+  daysAhead: z.number().optional().describe("Number of days for upcoming events query"),
+});
+
+type QueryIntent = z.infer<typeof QueryIntentSchema>;
+
+const QUERY_PARSER_SYSTEM_PROMPT = `You are a calendar query parser. Analyze the user's question about their calendar and determine what they want to know.
+
+Query types:
+- "today": Events happening today
+- "tomorrow": Events happening tomorrow
+- "week": Events this week
+- "specific_date": Events on a specific date
+- "range": Events within a date range
+- "search": Looking for events by name/keyword
+- "upcoming": Next N events or events in next N days
+
+Current date/time context will be provided to help interpret relative dates.
+
+You must respond with a JSON object containing the query details.`;
+
+export interface QueryNodeDeps {
+  llm: ILanguageModel;
+  eventService: EventService;
+}
+
+function formatEvent(event: Event): string {
+  const date = event.datetime.toLocaleDateString("en-US", {
+    weekday: "short",
+    month: "short",
+    day: "numeric",
+  });
+  const time = event.datetime.toLocaleTimeString("en-US", {
+    hour: "numeric",
+    minute: "2-digit",
+  });
+  const endTime = event.endTime
+    ? ` - ${event.endTime.toLocaleTimeString("en-US", { hour: "numeric", minute: "2-digit" })}`
+    : "";
+
+  let formatted = `• ${event.title} - ${date} at ${time}${endTime}`;
+  if (event.notes) {
+    formatted += `\n  Notes: ${event.notes}`;
+  }
+  if (event.tags.length > 0) {
+    formatted += `\n  Tags: ${event.tags.join(", ")}`;
+  }
+  return formatted;
+}
+
+function formatEventList(events: Event[], context: string): string {
+  if (events.length === 0) {
+    return `No events found ${context}.`;
+  }
+
+  const header =
+    events.length === 1
+      ? `Here's 1 event ${context}:`
+      : `Here are ${events.length} events ${context}:`;
+
+  const formatted = events.map(formatEvent).join("\n\n");
+  return `${header}\n\n${formatted}`;
+}
+
+export async function queryNode(
+  state: GraphStateType,
+  deps: QueryNodeDeps
+): Promise<Partial<GraphStateType>> {
+  const lastMessage = state.messages[state.messages.length - 1];
+
+  if (!lastMessage || !(lastMessage instanceof HumanMessage)) {
+    return {
+      response: "I couldn't understand your question. Please try again.",
+      queryResult: null,
+    };
+  }
+
+  const userMessage =
+    typeof lastMessage.content === "string"
+      ? lastMessage.content
+      : JSON.stringify(lastMessage.content);
+
+  const now = new Date();
+  const contextMessage = `Current date/time: ${now.toISOString()} (${now.toLocaleDateString("en-US", { weekday: "long", year: "numeric", month: "long", day: "numeric" })})
+
+User question: ${userMessage}`;
+
+  try {
+    const structuredLlm = deps.llm.withStructuredOutput<QueryIntent>(QueryIntentSchema);
+
+    const response = await structuredLlm.generate([
+      new SystemMessage(QUERY_PARSER_SYSTEM_PROMPT),
+      new HumanMessage(contextMessage),
+    ]);
+
+    const parsed = QueryIntentSchema.safeParse(JSON.parse(response.content));
+
+    if (!parsed.success) {
+      const todayEvents = await deps.eventService.getToday();
+      const responseText = formatEventList(todayEvents, "for today");
+      return {
+        queryResult: responseText,
+        response: responseText,
+        todayEvents,
+        messages: [new AIMessage(responseText)],
+      };
+    }
+
+    const queryIntent = parsed.data;
+    let events: Event[] = [];
+    let contextText = "";
+
+    switch (queryIntent.queryType) {
+      case "today": {
+        events = await deps.eventService.getToday();
+        contextText = "for today";
+        break;
+      }
+      case "tomorrow": {
+        const tomorrow = new Date(now);
+        tomorrow.setDate(tomorrow.getDate() + 1);
+        events = await deps.eventService.getByDate(tomorrow);
+        contextText = "for tomorrow";
+        break;
+      }
+      case "week": {
+        const weekEnd = new Date(now);
+        weekEnd.setDate(weekEnd.getDate() + 7);
+        events = await deps.eventService.getByRange(now, weekEnd);
+        contextText = "for this week";
+        break;
+      }
+      case "specific_date": {
+        if (queryIntent.specificDate) {
+          const targetDate = new Date(queryIntent.specificDate);
+          events = await deps.eventService.getByDate(targetDate);
+          contextText = `for ${targetDate.toLocaleDateString("en-US", { weekday: "long", month: "long", day: "numeric" })}`;
+        }
+        break;
+      }
+      case "range": {
+        if (queryIntent.startDate && queryIntent.endDate) {
+          const start = new Date(queryIntent.startDate);
+          const end = new Date(queryIntent.endDate);
+          events = await deps.eventService.getByRange(start, end);
+          contextText = `from ${start.toLocaleDateString("en-US", { month: "short", day: "numeric" })} to ${end.toLocaleDateString("en-US", { month: "short", day: "numeric" })}`;
+        }
+        break;
+      }
+      case "search": {
+        if (queryIntent.searchTerm) {
+          events = await deps.eventService.search(queryIntent.searchTerm);
+          contextText = `matching "${queryIntent.searchTerm}"`;
+        }
+        break;
+      }
+      case "upcoming": {
+        const days = queryIntent.daysAhead ?? 7;
+        events = await deps.eventService.getUpcoming(days);
+        contextText = `in the next ${days} days`;
+        break;
+      }
+    }
+
+    const responseText = formatEventList(events, contextText);
+
+    return {
+      queryResult: responseText,
+      response: responseText,
+      todayEvents: queryIntent.queryType === "today" ? events : state.todayEvents,
+      messages: [new AIMessage(responseText)],
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    return {
+      response: `Failed to query events: ${errorMessage}. Please try again.`,
+      queryResult: null,
+    };
+  }
+}

package/src/application/graph/nodes/respond.ts

@@ -0,0 +1,26 @@
+import { AIMessage } from "@langchain/core/messages";
+import type { GraphStateType } from "../../../domain/state/AgentState";
+
+export async function respondNode(state: GraphStateType): Promise<Partial<GraphStateType>> {
+  if (!state.response) {
+    return {
+      response: "I'm not sure how to respond. Could you please rephrase your request?",
+      messages: [
+        new AIMessage("I'm not sure how to respond. Could you please rephrase your request?"),
+      ],
+    };
+  }
+
+  const lastAIMessage = state.messages
+    .slice()
+    .reverse()
+    .find((msg) => msg instanceof AIMessage);
+
+  if (lastAIMessage && String(lastAIMessage.content) === state.response) {
+    return {};
+  }
+
+  return {
+    messages: [new AIMessage(state.response)],
+  };
+}

package/src/application/graph/nodes/router.ts

@@ -0,0 +1,82 @@
+import { z } from "zod";
+import { HumanMessage, SystemMessage } from "@langchain/core/messages";
+import type { GraphStateType, Intent } from "../../../domain/state/AgentState";
+import type { ILanguageModel } from "../../../domain/interfaces/ILanguageModel";
+
+const IntentSchema = z.object({
+  intent: z
+    .enum(["add_event", "query", "chat"])
+    .describe(
+      "The user's intent: 'add_event' for scheduling/creating events, 'query' for asking about existing events or calendar questions, 'chat' for general conversation"
+    ),
+  confidence: z.number().min(0).max(1).describe("Confidence score for the classification"),
+  reasoning: z.string().describe("Brief explanation of why this intent was chosen"),
+});
+
+type IntentClassification = z.infer<typeof IntentSchema>;
+
+const ROUTER_SYSTEM_PROMPT = `You are an intent classifier for a calendar/scheduling assistant. Analyze the user's message and classify their intent.
+
+Intents:
+- "add_event": User mentions ANY upcoming event, plan, appointment, or schedule - whether as a command OR a casual statement. If the message contains a future event with a time reference, classify as add_event.
+  Examples:
+    - Commands: "Schedule a meeting tomorrow at 3pm", "Add dentist appointment next week", "Book a call with John"
+    - Statements: "I have a flight next Thursday", "I'm going to a conference on Monday", "There's a dentist appointment on Friday"
+    - Informal: "Dinner with Sarah at 7pm", "Meeting John tomorrow", "Flight to NYC next week"
+    - Mentions: "I need to pick up kids at 3pm", "Got a job interview on Tuesday", "My mom's birthday is on the 15th"
+
+- "query": User wants to know about existing events, check their schedule, or ask calendar-related questions
+  Examples: "What's on my calendar today?", "When is my next meeting?", "Do I have anything on Friday?", "Show me this month's events", "Check my schedule for next week"
+
+- "chat": General conversation NOT related to calendar operations and does NOT mention any specific future events or dates
+  Examples: "Hello", "How are you?", "What's the weather like?", "Tell me a joke", "Thanks for your help"
+
+IMPORTANT: When in doubt between "add_event" and "chat", if the message mentions ANY specific future date/time with an activity, choose "add_event". Users often mention events casually expecting them to be tracked.
+
+You must respond with a JSON object containing: intent, confidence, and reasoning.`;
+
+export interface RouterNodeDeps {
+  llm: ILanguageModel;
+}
+
+export async function routerNode(
+  state: GraphStateType,
+  deps: RouterNodeDeps
+): Promise<Partial<GraphStateType>> {
+  const lastMessage = state.messages[state.messages.length - 1];
+
+  if (!lastMessage || !(lastMessage instanceof HumanMessage)) {
+    return { intent: "chat" as Intent };
+  }
+
+  const userMessage =
+    typeof lastMessage.content === "string"
+      ? lastMessage.content
+      : JSON.stringify(lastMessage.content);
+
+  try {
+    const structuredLlm = deps.llm.withStructuredOutput<IntentClassification>(IntentSchema);
+
+    const response = await structuredLlm.generate([
+      new SystemMessage(ROUTER_SYSTEM_PROMPT),
+      new HumanMessage(userMessage),
+    ]);
+
+    // console.log("[Router] LLM Response:", response.content);
+
+    const parsed = IntentSchema.safeParse(JSON.parse(response.content));
+
+    // console.log("[Router] Parse result:", parsed.success ? parsed.data : parsed.error);
+
+    if (!parsed.success) {
+      console.log("[Router] Parse failed, defaulting to chat");
+      return { intent: "chat" as Intent };
+    }
+
+    // console.log("[Router] Final intent:", parsed.data.intent);
+    return { intent: parsed.data.intent as Intent };
+  } catch (error) {
+    console.log("[Router] Error:", error instanceof Error ? error.message : String(error));
+    return { intent: "chat" as Intent };
+  }
+}