AI Agent Infinite Loops — LangChain + Next.js Cost Control

// ============================================
// AI Agent Architecture — Core Components (2026 LangChain 0.3+)
// ============================================

// ---- Component 1: LLM (Reasoning Engine) ----
// The LLM decides which tools to call and interprets results

import { ChatOpenAI } from '@langchain/openai'

const llm = new ChatOpenAI({
  modelName: 'gpt-4o',
  temperature: 0, // Deterministic for tool-calling — reduces hallucination
  openAIApiKey: process.env.OPENAI_API_KEY,
})

// ---- Component 2: Tools (External Capabilities) ----
// Each tool has a name, description, schema, and execution function

import { DynamicStructuredTool } from '@langchain/core/tools'
import { z } from 'zod'

const searchKnowledgeBase = new DynamicStructuredTool({
  name: 'search_knowledge_base',
  description: 'Search the internal knowledge base for answers to customer questions. Use this when the user asks about product features, pricing, or troubleshooting.',
  schema: z.object({
    query: z.string().describe('The search query — use keywords from the user question'),
    category: z.enum(['product', 'pricing', 'troubleshooting', 'general']).optional()
      .describe('Filter by category if the topic is clear'),
  }),
  func: async ({ query, category }) => {
    // Search Supabase vector store
    const results = await searchDocuments(query, category)
    if (results.length === 0) {
      return 'No results found. Try a different search query or answer from general knowledge.'
    }
    return results.map((r) => `[${r.title}]: ${r.content}`).join('\n\n')
  },
})

const getOrderStatus = new DynamicStructuredTool({
  name: 'get_order_status',
  description: 'Look up the status of a customer order by order ID. Returns shipping status, estimated delivery, and tracking number.',
  schema: z.object({
    orderId: z.string().describe('The order ID — format: ORD-XXXXX'),
  }),
  func: async ({ orderId }) => {
    const order = await getOrderFromDatabase(orderId)
    if (!order) {
      return `Order ${orderId} not found. Ask the user to verify the order ID.`
    }
    return JSON.stringify({
      status: order.status,
      estimatedDelivery: order.estimatedDelivery,
      trackingNumber: order.trackingNumber,
    })
  },
})

const calculateRefund = new DynamicStructuredTool({
  name: 'calculate_refund',
  description: 'Calculate the refund amount for a return. Considers order total, return reason, and days since purchase.',
  schema: z.object({
    orderId: z.string().describe('The order ID'),
    returnReason: z.enum(['defective', 'wrong_item', 'changed_mind', 'not_as_described'])
      .describe('The reason for the return'),
  }),
  func: async ({ orderId, returnReason }) => {
    const order = await getOrderFromDatabase(orderId)
    if (!order) return 'Order not found.'

    const daysSincePurchase = Math.floor(
      (Date.now() - new Date(order.createdAt).getTime()) / (1000 * 60 * 60 * 24)
    )

    let refundPercentage = 1.0
    if (returnReason === 'changed_mind' && daysSincePurchase > 30) {
      refundPercentage = 0.0
    } else if (returnReason === 'changed_mind') {
      refundPercentage = 0.85
    }

    const refundAmount = order.total * refundPercentage
    return JSON.stringify({ refundAmount, refundPercentage, daysSincePurchase })
  },
})

// ---- Component 3: Memory (Conversation History) ----
// Stored in Supabase PostgreSQL for persistence across requests
// Custom history class to match your token-tracking schema
import { SupabaseChatMessageHistory } from '@langchain/community/stores/message/supabase'

function createMemory(conversationId: string) {
  return new SupabaseChatMessageHistory({
    supabaseClient: supabase,
    tableName: 'messages',
    sessionId: conversationId,
  })
}

// ---- Component 4: Agent (2026 pattern) ----
// Use createToolCallingAgent + RunnableWithMessageHistory
import { createToolCallingAgent } from 'langchain/agents'
import { RunnableWithMessageHistory } from '@langchain/core/runnables'
import { ChatPromptTemplate, MessagesPlaceholder } from '@langchain/core/prompts'

const prompt = ChatPromptTemplate.fromMessages([
  ['system', `You are a helpful customer support agent for Acme Corp.

You have access to the following tools:
- search_knowledge_base: Search the internal knowledge base
- get_order_status: Look up order status by order ID
- calculate_refund: Calculate refund amounts for returns

Rules:
1. Always search the knowledge base before answering product questions
2. If a tool returns no new information, answer from what you know
3. Never make up order statuses — always use get_order_status
4. If you cannot answer, say so and offer to connect with a human agent
5. Maximum 10 tool calls per response — synthesize your answer after that`],
  new MessagesPlaceholder('chat_history'),
  ['human', '{input}'],
  new MessagesPlaceholder('agent_scratchpad'),
])

async function createAgent(conversationId: string) {
  const tools = [searchKnowledgeBase, getOrderStatus, calculateRefund]

  const agent = await createToolCallingAgent({
    llm,
    tools,
    prompt,
  })

  const agentWithHistory = new RunnableWithMessageHistory({
    runnable: agent,
    getMessageHistory: () => createMemory(conversationId),
    inputMessagesKey: 'input',
    historyMessagesKey: 'chat_history',
  })

  return agentWithHistory
}

-- ============================================
-- Supabase Schema for AI Agent
-- ============================================

-- Enable pgvector extension
CREATE EXTENSION IF NOT EXISTS vector;

-- ---- Conversations Table ----
-- Each conversation has a unique ID and tracks the user
CREATE TABLE public.conversations (
  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
  user_id UUID NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
  title TEXT,
  total_tokens INTEGER DEFAULT 0,
  created_at TIMESTAMPTZ DEFAULT NOW(),
  updated_at TIMESTAMPTZ DEFAULT NOW()
);

ALTER TABLE public.conversations ENABLE ROW LEVEL SECURITY;

CREATE POLICY "Users can manage their own conversations"
  ON public.conversations
  FOR ALL
  USING (auth.uid() = user_id)
  WITH CHECK (auth.uid() = user_id);

-- ---- Messages Table ----
-- Stores each message in a conversation
CREATE TABLE public.messages (
  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
  conversation_id UUID NOT NULL REFERENCES public.conversations(id) ON DELETE CASCADE,
  role TEXT NOT NULL CHECK (role IN ('user', 'assistant', 'system', 'tool')),
  content TEXT NOT NULL,
  tool_calls JSONB, -- Stores tool call details for assistant messages
  tool_call_id TEXT, -- Links tool response to the original call
  token_count INTEGER DEFAULT 0,
  created_at TIMESTAMPTZ DEFAULT NOW()
);

ALTER TABLE public.messages ENABLE ROW LEVEL SECURITY;

CREATE POLICY "Users can manage messages in their conversations"
  ON public.messages
  FOR ALL
  USING (
    conversation_id IN (
      SELECT id FROM public.conversations WHERE user_id = auth.uid()
    )
  )
  WITH CHECK (
    conversation_id IN (
      SELECT id FROM public.conversations WHERE user_id = auth.uid()
    )
  );

-- Index for fast conversation history retrieval
CREATE INDEX idx_messages_conversation_created
  ON public.messages (conversation_id, created_at ASC);

-- ---- Documents Table ----
-- Knowledge base with vector embeddings
CREATE TABLE public.documents (
  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
  title TEXT NOT NULL,
  content TEXT NOT NULL,
  category TEXT, -- product, pricing, troubleshooting, general
  embedding vector(1536), -- text-embedding-3-small produces 1536-dim vectors
  metadata JSONB DEFAULT '{}',
  created_at TIMESTAMPTZ DEFAULT NOW()
);

ALTER TABLE public.documents ENABLE ROW LEVEL SECURITY;

CREATE POLICY "Documents are readable by authenticated users"
  ON public.documents
  FOR SELECT
  USING (auth.role() = 'authenticated');

-- Index for vector similarity search
CREATE INDEX ON public.documents
  USING ivfflat (embedding vector_cosine_ops)
  WITH (lists = 100);

-- ---- Vector Search RPC Function ----
-- Performs nearest-neighbor search using cosine similarity
CREATE OR REPLACE FUNCTION match_documents(
  query_embedding vector(1536),
  match_count INTEGER DEFAULT 5,
  match_threshold FLOAT DEFAULT 0.8, -- Production value for text-embedding-3-small
  filter_category TEXT DEFAULT NULL
)
RETURNS TABLE (
  id UUID,
  title TEXT,
  content TEXT,
  category TEXT,
  similarity FLOAT
)
LANGUAGE plpgsql
AS $$
BEGIN
  RETURN QUERY
  SELECT
    documents.id,
    documents.title,
    documents.content,
    documents.category,
    1 - (documents.embedding <=> query_embedding) AS similarity
  FROM public.documents
  WHERE
    (filter_category IS NULL OR documents.category = filter_category)
    AND 1 - (documents.embedding <=> query_embedding) > match_threshold
  ORDER BY documents.embedding <=> query_embedding
  LIMIT match_count;
END;
$$;

-- ---- Conversation Summaries Table ----
-- Stores summarized history for long conversations
CREATE TABLE public.conversation_summaries (
  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
  conversation_id UUID NOT NULL REFERENCES public.conversations(id) ON DELETE CASCADE,
  summary TEXT NOT NULL,
  message_count INTEGER NOT NULL, -- Number of messages summarized
  token_count INTEGER NOT NULL, -- Token count of the original messages
  created_at TIMESTAMPTZ DEFAULT NOW()
);

-- ---- Updated At Trigger ----
CREATE OR REPLACE FUNCTION update_updated_at()
RETURNS TRIGGER
LANGUAGE plpgsql
AS $$
BEGIN
  NEW.updated_at = NOW();
  RETURN NEW;
END;
$$;

CREATE TRIGGER conversations_updated_at
  BEFORE UPDATE ON public.conversations
  FOR EACH ROW
  EXECUTE FUNCTION update_updated_at();

// ============================================
// Client Component — Chat Interface with Streaming
// ============================================
// File: components/chat-interface.tsx

'use client'

import { useChat } from 'ai/react'
import { useState } from 'react'
import { Button } from '@/components/ui/button'
import { Input } from '@/components/ui/input'

export function ChatInterface({ conversationId }: { conversationId?: string }) {
  const [activeConversationId, setActiveConversationId] = useState(conversationId)

  const { messages, input, handleInputChange, handleSubmit, isLoading } = useChat({
    api: '/api/chat',
    body: { conversationId: activeConversationId },
    onFinish: (message) => {
      // Extract conversation ID from response headers
      // (set by the server in StreamingTextResponse headers)
    },
    onError: (error) => {
      console.error('Chat error:', error)
    },
  })

  return (
    <div className="flex flex-col h-[600px] max-w-2xl mx-auto">
      {/* Messages */}
      <div className="flex-1 overflow-y-auto space-y-4 p-4">
        {messages.map((message) => (
          <div
            key={message.id}
            className={`flex ${message.role === 'user' ? 'justify-end' : 'justify-start'}`}
          >
            <div
              className={`max-w-[80%] rounded-lg px-4 py-2 ${
                message.role === 'user'
                  ? 'bg-primary text-primary-foreground'
                  : 'bg-muted'
              }`}
            >
              <p className="text-sm whitespace-pre-wrap">{message.content}</p>
            </div>
          </div>
        ))}

        {isLoading && (
          <div className="flex justify-start">
            <div className="bg-muted rounded-lg px-4 py-2">
              <div className="flex space-x-1">
                <div className="w-2 h-2 bg-muted-foreground rounded-full animate-bounce" />
                <div className="w-2 h-2 bg-muted-foreground rounded-full animate-bounce delay-100" />
                <div className="w-2 h-2 bg-muted-foreground rounded-full animate-bounce delay-200" />
              </div>
            </div>
          </div>
        )}
      </div>

      {/* Input */}
      <form onSubmit={handleSubmit} className="flex gap-2 p-4 border-t">
        <Input
          value={input}
          onChange={handleInputChange}
          placeholder="Ask a question..."
          disabled={isLoading}
          className="flex-1"
        />
        <Button type="submit" disabled={isLoading}>
          Send
        </Button>
      </form>
    </div>
  )
}

// ============================================
// Server Action — Non-Streaming Agent (Background Processing)
// ============================================
// File: app/actions/agent.ts

'use server'

import { createAgent } from '@/lib/agent/factory'
import { createClient } from '@/lib/supabase/server'

export async function processAgentMessage(
  conversationId: string,
  message: string
) {
  const supabase = await createClient()
  const { data: { user } } = await supabase.auth.getUser()

  if (!user) {
    throw new Error('Unauthorized')
  }

  // Store user message
  await supabase.from('messages').insert({
    conversation_id: conversationId,
    role: 'user',
    content: message,
  })

  // Run agent (non-streaming)
  const agent = await createAgent(conversationId)
  const result = await agent.invoke({ input: message })

  // Store assistant response
  await supabase.from('messages').insert({
    conversation_id: conversationId,
    role: 'assistant',
    content: result.output,
  })

  return {
    answer: result.output,
    steps: result.intermediateSteps?.length ?? 0,
  }
}

// ============================================
// Tool Design Patterns
// ============================================

import { DynamicStructuredTool } from '@langchain/core/tools'
import { z } from 'zod'

// ---- Good Tool: Clear description, validated inputs, actionable errors + deduplication ----

export const searchKnowledgeBase = new DynamicStructuredTool({
  name: 'search_knowledge_base',
  description: `Search the internal knowledge base for answers to customer questions. Use this when the user asks about product features, pricing, or troubleshooting.
Do NOT use this tool for:
- Order status queries (use get_order_status instead)
- Calculations (use calculate tool instead)
- Questions about the current date or time`,
  schema: z.object({
    query: z.string()
      .min(3, 'Query must be at least 3 characters')
      .max(200, 'Query must be under 200 characters')
      .describe('The search query — use specific keywords from the user question. Avoid full sentences.'),
    category: z.enum(['product', 'pricing', 'troubleshooting', 'general'])
      .optional()
      .describe('Filter by category if the topic is clear from the question'),
    maxResults: z.number()
      .min(1)
      .max(10)
      .default(5)
      .describe('Maximum number of results to return — use 3 for focused answers, 5 for comprehensive'),
  }),
  func: async ({ query, category, maxResults }) => {
    try {
      // Deduplication guardrail
      const resultHash = JSON.stringify({ query, category }).slice(0, 100)
      if (globalThis.seenResults?.has(resultHash)) {
        return "You've already seen this result. Answer from context or ask for clarification."
      }
      globalThis.seenResults = globalThis.seenResults || new Set()
      globalThis.seenResults.add(resultHash)

      // Generate embedding for the query
      const embedding = await generateEmbedding(query)

      // Search Supabase vector store
      const { data, error } = await supabase.rpc('match_documents', {
        query_embedding: embedding,
        match_count: maxResults,
        match_threshold: 0.8, // Production value
        filter_category: category ?? null,
      })

      if (error) {
        return `Search failed: ${error.message}. Try a simpler query or remove the category filter.`
      }

      if (!data || data.length === 0) {
        return `No results found for "${query}". Try:
1. Using different keywords
2. Removing the category filter
3. Broadening the search terms`
      }

      return data.map((doc: any, i: number) =>
        `[Result ${i + 1}] (similarity: ${doc.similarity.toFixed(2)})
Title: ${doc.title}
Content: ${doc.content.slice(0, 500)}...`
      ).join('\n\n')
    } catch (err) {
      return `Search error: ${err instanceof Error ? err.message : 'Unknown error'}. The user should try again or contact support.`
    }
  },
})

// ---- Good Tool: Input validation with meaningful error messages ----

export const createTicket = new DynamicStructuredTool({
  name: 'create_support_ticket',
  description: 'Create a support ticket when the agent cannot resolve the issue. Use this as a last resort after exhausting available tools.',
  schema: z.object({
    subject: z.string()
      .min(10, 'Subject must be at least 10 characters — provide a clear summary')
      .max(200)
      .describe('Brief subject line summarizing the issue'),
    description: z.string()
      .min(50, 'Description must be at least 50 characters — include what was tried and what failed')
      .max(2000)
      .describe('Detailed description including what the user tried and what went wrong'),
    priority: z.enum(['low', 'medium', 'high', 'urgent'])
      .describe('Priority based on impact: low = question, medium = minor issue, high = blocked, urgent = production down'),
    category: z.enum(['billing', 'technical', 'account', 'feature_request'])
      .describe('Category of the issue'),
  }),
  func: async ({ subject, description, priority, category }) => {
    // Validate business rules
    if (priority === 'urgent' && category !== 'technical') {
      return 'Urgent priority is only available for technical issues. Please use high priority instead.'
    }

    const ticket = await createTicketInDatabase({ subject, description, priority, category })

    return `Ticket created successfully.
Ticket ID: ${ticket.id}
Priority: ${priority}
Expected response time: ${getResponseTime(priority)}

Tell the user: "I've created a support ticket (ID: ${ticket.id}) for you. A team member will respond within ${getResponseTime(priority)}."`
  },
})

// ---- Helper: Generate embedding ----
async function generateEmbedding(text: string): Promise<number[]> {
  const response = await openai.embeddings.create({
    model: 'text-embedding-3-small',
    input: text,
  })
  return response.data[0].embedding
}

function getResponseTime(priority: string): string {
  const times: Record<string, string> = {
    low: '48 hours',
    medium: '24 hours',
    high: '4 hours',
    urgent: '1 hour',
  }
  return times[priority] ?? '24 hours'
}

// ============================================
// Cost Control: Token Management
// ============================================

import { ChatOpenAI } from '@langchain/openai'
import { createClient } from '@/lib/supabase/server'

// ---- Strategy 1: Conversation Summarization ----
// Summarize old messages when the conversation gets too long
// Reduces token count by 80-90% while preserving context

export async function getConversationHistory(conversationId: string, maxTokens: number = 8000) {
  const supabase = await createClient()

  // Get the latest summary (if any)
  const { data: summary } = await supabase
    .from('conversation_summaries')
    .select('summary, message_count')
    .eq('conversation_id', conversationId)
    .order('created_at', { ascending: false })
    .limit(1)
    .single()

  // Get messages after the summary
  const offset = summary?.message_count ?? 0
  const { data: recentMessages } = await supabase
    .from('messages')
    .select('role, content, token_count')
    .eq('conversation_id', conversationId)
    .order('created_at', { ascending: true })
    .range(offset, offset + 49)

  if (!recentMessages) return []

  // Build the history
  const history: { role: string; content: string }[] = []

  // Add summary as a system message if it exists
  if (summary) {
    history.push({
      role: 'system',
      content: `[Previous conversation summary]: ${summary.summary}`,
    })
  }

  // Add recent messages
  let totalTokens = summary ? estimateTokens(summary.summary) : 0
  for (const msg of recentMessages) {
    if (totalTokens + (msg.token_count ?? 0) > maxTokens) {
      break // Stop adding messages when we hit the token limit
    }
    history.push({ role: msg.role, content: msg.content })
    totalTokens += msg.token_count ?? 0
  }

  return history
}

// ---- Strategy 2: Model Selection Based on Task Complexity ----
// Use cheaper models for simple tasks, expensive models for complex reasoning

export function selectModel(taskComplexity: 'simple' | 'moderate' | 'complex') {
  const models = {
    simple: new ChatOpenAI({
      modelName: 'gpt-4o-mini',
      temperature: 0,
      maxTokens: 500, // Limit output tokens for simple responses
    }),
    moderate: new ChatOpenAI({
      modelName: 'gpt-4o-mini',
      temperature: 0,
      maxTokens: 1000,
    }),
    complex: new ChatOpenAI({
      modelName: 'gpt-4o',
      temperature: 0,
      maxTokens: 2000,
    }),
  }
  return models[taskComplexity]
}

// ---- Strategy 3: Token Budget Per Conversation ----
// Track and enforce token limits per conversation

export async function checkTokenBudget(conversationId: string): Promise<boolean> {
  const supabase = await createClient()
  const MAX_TOKENS_PER_CONVERSATION = 50000

  const { data: conversation } = await supabase
    .from('conversations')
    .select('total_tokens')
    .eq('id', conversationId)
    .single()

  if (!conversation) return true

  if (conversation.total_tokens >= MAX_TOKENS_PER_CONVERSATION) {
    // Summarize and continue
    await summarizeConversation(conversationId)
    return true
  }

  return true
}

// ---- Cost Estimation ----
// Estimate cost before running the agent

const MODEL_COSTS: Record<string, { input: number; output: number }> = {
  'gpt-4o': { input: 2.50 / 1_000_000, output: 10.00 / 1_000_000 },
  'gpt-4o-mini': { input: 0.15 / 1_000_000, output: 0.60 / 1_000_000 },
  'text-embedding-3-small': { input: 0.02 / 1_000_000, output: 0 },
}

export function estimateCost(
  modelName: string,
  inputTokens: number,
  outputTokens: number
): number {
  const costs = MODEL_COSTS[modelName] ?? MODEL_COSTS['gpt-4o']
  return (inputTokens * costs.input) + (outputTokens * costs.output)
}

// ---- Usage Tracking ----
// Store token usage per conversation for billing and monitoring

export async function trackUsage(
  conversationId: string,
  modelName: string,
  inputTokens: number,
  outputTokens: number
) {
  const supabase = await createClient()
  const cost = estimateCost(modelName, inputTokens, outputTokens)

  await supabase.from('usage_logs').insert({
    conversation_id: conversationId,
    model: modelName,
    input_tokens: inputTokens,
    output_tokens: outputTokens,
    cost,
  })

  // Update conversation total
  await supabase
    .from('conversations')
    .update({
      total_tokens: supabase.rpc('increment_conversation_tokens', {
        conv_id: conversationId,
        tokens: inputTokens + outputTokens,
      }),
    })
    .eq('id', conversationId)
}

// ============================================
// Deployment Configuration
// ============================================

// ---- Environment Variables (.env.local) ----
// NEVER commit API keys to the repository

// OPENAI_API_KEY=sk-...
// SUPABASE_URL=https://your-project.supabase.co
// SUPABASE_ANON_KEY=eyJ...
// SUPABASE_SERVICE_ROLE_KEY=eyJ... (for server-side only)
// NODE_ENV=production

// ---- next.config.ts ----
// Configure for AI workloads

import type { NextConfig } from 'next'

const nextConfig: NextConfig = {
  // Increase body size limit for conversation history
  experimental: {
    serverActions: {
      bodySizeLimit: '2mb',
    },
  },
  // Configure for Vercel deployment
  serverExternalPackages: ['@langchain/openai', '@langchain/core'],
}

export default nextConfig

// ---- Rate Limiting (Upstash Redis — works in serverless) ----
// In-memory Map dies in serverless — use Redis

import { Ratelimit } from '@upstash/ratelimit'
import { Redis } from '@upstash/redis'

const redis = new Redis({ url: process.env.UPSTASH_REDIS_REST_URL!, token: process.env.UPSTASH_REDIS_REST_TOKEN! })

const ratelimit = new Ratelimit({
  redis,
  limiter: Ratelimit.slidingWindow(10, '60 s'), // 10 requests per minute
})

export async function rateLimitMiddleware(request: NextRequest) {
  if (request.nextUrl.pathname.startsWith('/api/chat')) {
    const ip = request.headers.get('x-forwarded-for') ?? 'unknown'
    const { success } = await ratelimit.limit(ip)
    if (!success) {
      return NextResponse.json(
        { error: 'Rate limit exceeded. Please wait before sending another message.' },
        { status: 429 }
      )
    }
  }
  return NextResponse.next()
}

// ---- Middleware: Rate Limiting ----
// Prevent abuse by limiting requests per user
export const config = {
  matcher: ['/api/:path*'],
}

// ---- Error Handling Wrapper ----
// Catch and log agent errors for observability
export async function runAgentWithErrorHandling(
  conversationId: string,
  input: string
) {
  const startTime = Date.now()

  try {
    const agent = await createAgent(conversationId)
    const result = await agent.invoke({ input })

    // Log success
    await logAgentRun({
      conversationId,
      status: 'success',
      duration: Date.now() - startTime,
      steps: result.intermediateSteps?.length ?? 0,
      input,
      output: result.output,
    })

    return result
  } catch (error) {
    // Log failure
    await logAgentRun({
      conversationId,
      status: 'error',
      duration: Date.now() - startTime,
      error: error instanceof Error ? error.message : 'Unknown error',
      input,
    })

    // Return user-friendly error
    if (error instanceof Error && error.message.includes('timeout')) {
      return {
        output: 'The request took too long to process. Please try a simpler question or try again later.',
      }
    }

    if (error instanceof Error && error.message.includes('rate_limit')) {
      return {
        output: 'The AI service is currently experiencing high demand. Please wait a moment and try again.',
      }
    }

    return {
      output: 'I encountered an error processing your request. A support ticket has been created automatically.',
    }
  }
}

async function logAgentRun(data: Record<string, unknown>) {
  const supabase = await createClient()
  await supabase.from('agent_runs').insert(data)
}

// ---- Health Check Endpoint ----
// File: app/api/health/route.ts
export async function GET() {
  const checks = {
    openai: false,
    supabase: false,
  }

  // Check OpenAI
  try {
    const response = await fetch('https://api.openai.com/v1/models', {
      headers: { Authorization: `Bearer ${process.env.OPENAI_API_KEY}` },
    })
    checks.openai = response.ok
  } catch {
    checks.openai = false
  }

  // Check Supabase
  try {
    const supabase = await createClient()
    const { error } = await supabase.from('conversations').select('id').limit(1)
    checks.supabase = !error
  } catch {
    checks.supabase = false
  }

  const healthy = Object.values(checks).every(Boolean)

  return Response.json(
    { status: healthy ? 'healthy' : 'degraded', checks },
    { status: healthy ? 200 : 503 }
  )
}

// io.thecodeforge — javascript tutorial

// Verify environment before you write a single agent
const REQUIRED_NODE_VERSION = 18;

const nodeMajor = parseInt(process.version.slice(1).split('.')[0], 10);
if (nodeMajor < REQUIRED_NODE_VERSION) {
  console.error(`FATAL: Node ${process.version} detected. Need >= ${REQUIRED_NODE_VERSION}.`);
  process.exit(1);
}

// Confirm Supabase local chain is alive
import { createClient } from '@supabase/supabase-js';

const localSupabase = createClient(
  'http://localhost:54321',
  process.env.SUPABASE_LOCAL_SERVICE_ROLE_KEY
);

const { data, error } = await localSupabase.from('conversations').select('count').single();
if (error) {
  console.error('Supabase local container not responding. Run `supabase start` first.');
  process.exit(1);
}

console.log(`Env validated. Node ${process.version}, Supabase live. Building agent.`);

// io.thecodeforge — javascript tutorial

// Run this after install to catch version fights
import { execSync } from 'child_process';

try {
  const zodVersions = execSync('npm ls zod --depth=0 --json', { encoding: 'utf8' });
  const parsed = JSON.parse(zodVersions);
  const deps = parsed.dependencies || {};
  const uniqueVersions = new Set(Object.values(deps).map(d => d.version));
  
  if (uniqueVersions.size > 1) {
    console.warn('WARN: Multiple zod versions detected. Run `npm dedupe`.');
    console.table(deps);
  } else {
    console.log('OK: Single zod version in tree.');
  }
} catch {
  console.log('zod not installed yet — clean slate.');
}

// io.thecodeforge — javascript tutorial

// Server-side tool with authenticated Supabase access
import { createServerClient } from '@supabase/ssr';
import { tool } from '@langchain/core/tools';
import { z } from 'zod';

export const searchUserBlogs = tool(
  async ({ query, userToken }) => {
    const supabase = createServerClient(
      process.env.SUPABASE_URL!,
      process.env.SUPABASE_SERVICE_ROLE_KEY!,
      {
        cookies: {
          get: () => null, // Not used here — we use token directly
        },
        auth: {
          autoRefreshToken: false,
          detectSessionInUrl: false,
        },
      }
    );

    // Impersonate the user with their JWT
    const { data, error } = await supabase.auth.setSession({
      access_token: userToken,
      refresh_token: '',
    });

    if (error || !data.user) {
      return JSON.stringify({ error: 'Session expired' });
    }

    const { data: blogs } = await supabase
      .from('blogs')
      .select('title, content, created_at')
      .textSearch('content', query)
      .limit(5);

    return JSON.stringify(blogs || []);
  },
  {
    name: 'searchUserBlogs',
    description: 'Search the authenticated user\'s blog posts',
    schema: z.object({
      query: z.string(),
      userToken: z.string(),
    }),
  }
);

// io.thecodeforge — javascript tutorial
// Verify LangChain + OpenAI install before Next.js

const { OpenAI } = require('@langchain/openai');
const { ChatOpenAI } = require('@langchain/openai');

const model = new ChatOpenAI({ temperature: 0 });

async function test() {
  const res = await model.invoke('Just say OK');
  console.log('Agent ready:', res.content);
}

test().catch(err => console.error('Install broken:', err.message));

// io.thecodeforge — javascript tutorial
// Validated Supabase tool with Zod schema

import { z } from 'zod';
import { createClient } from '@supabase/supabase-js';

const supabase = createClient(process.env.SUPABASE_URL, process.env.SUPABASE_SERVICE_KEY);

const schema = z.object({
  userId: z.string().uuid()
});

export const getInvoiceTool = {
  name: 'get_invoice',
  description: 'Find invoice by userId. Fields: id, email_address, amount, created_at.',
  schema,
  async call({ userId }) {
    const { data, error } = await supabase
      .from('invoices')
      .select('id, email_address, amount, created_at')
      .eq('user_id', userId)
      .single();

    if (error || !data) return { status: 'missing', data: null };
    return { status: 'found', data };
  }
};

// io.thecodeforge — javascript tutorial
import { createServerActionClient } from '@supabase/auth-helpers-nextjs'
import { RunnableWithMessageHistory } from '@langchain/core/runnables'
import { cookies } from 'next/headers'

export async function agentAction(input: string) {
  const supabase = createServerActionClient({ cookies })
  const { data: { session } } = await supabase.auth.getSession()
  const agent = new RunnableWithMessageHistory({
    runnable: agentChain,
    getMessageHistory: (sessionId) => new SupabaseChatHistory(sessionId, supabase),
    inputMessagesKey: 'input',
    historyMessagesKey: 'chat_history'
  })
  const stream = await agent.stream({ input }, { configurable: { sessionId: session.user.id } })
  return stream
}

// io.thecodeforge — javascript tutorial
import { SupabaseVectorStore } from '@langchain/community/vectorstores/supabase'
import { ParentDocumentRetriever } from 'langchain/retrievers/parent_document'
import { RecursiveCharacterTextSplitter } from 'langchain/text_splitter'

export async function createRetriever(supabaseClient) {
  const store = new SupabaseVectorStore(new OpenAIEmbeddings(), {
    client: supabaseClient,
    tableName: 'documents',
    queryName: 'match_documents'
  })
  const retriever = new ParentDocumentRetriever({
    vectorstore: store,
    parentSplitter: new RecursiveCharacterTextSplitter({ chunkSize: 2000 }),
    childSplitter: new RecursiveCharacterTextSplitter({ chunkSize: 400 }),
    childK: 20,
    parentK: 5
  })
  return retriever
}