[V0_FILE]typescriptreact:file="lib/reasoning.ts" isEdit="true" isMerged="true" import { logger } from "@/lib/logger" export interface ReasoningStep { description: string result: string } interface Message { role: "system" | "user" | "assistant" content: string } export async function processWithReasoning(query: string, messages: Message[]): Promise { try { if (!query || typeof query !== "string") { logger.warn("Invalid query provided to reasoning process", { query }) return [ { description: "Input validation", result: "Invalid query format. Proceeding with standard response generation.", }, ] } // Initialize reasoning steps const steps: ReasoningStep[] = [] // Step 1: Analyze query complexity const complexityScore = analyzeComplexity(query) steps.push({ description: "Query complexity analysis", result: `Complexity score: ${complexityScore}/10. ${getComplexityDescription(complexityScore)}`, }) // Step 2: Extract key concepts const concepts = extractKeyConcepts(query) steps.push({ description: "Key concepts extraction", result: concepts.length > 0 ? concepts.join(", ") : "No specific concepts identified", }) // Step 3: Determine required knowledge domains const domains = determineKnowledgeDomains(concepts, query) steps.push({ description: "Knowledge domains identification", result: domains.join(", "), }) // Step 4: Analyze conversation context const contextAnalysis = analyzeConversationContext(messages) steps.push({ description: "Conversation context analysis", result: contextAnalysis, }) // Step 5: Formulate reasoning approach const reasoningApproach = formulateReasoningApproach(complexityScore, domains, contextAnalysis) steps.push({ description: "Reasoning approach", result: reasoningApproach, }) logger.info(`Completed reasoning process with ${steps.length} steps`) return steps } catch (error) { logger.error("Error in reasoning process", error instanceof Error ? error.message : String(error)) return [ { description: "Reasoning error", result: "Failed to complete reasoning process. Proceeding with standard response generation.", }, ] } } // Helper functions for the reasoning process function analyzeComplexity(query: string): number { try { // Simple complexity analysis based on query length, question words, and technical terms const length = query.length const questionWords = (query.match(/what|how|why|when|where|who|which/gi) || []).length const technicalTerms = (query.match(/algorithm|function|component|api|database|neural|model|train/gi) || []).length // Calculate complexity score (1-10) let score = 1 if (length > 100) score += 2 else if (length > 50) score += 1 score += Math.min(questionWords, 3) score += Math.min(technicalTerms * 2, 4) return Math.min(score, 10) } catch (error) { logger.error("Error analyzing complexity", error) return 5 // Default to medium complexity on error } } function getComplexityDescription(score: number): string { if (score <= 3) return "Simple query requiring straightforward information." if (score <= 6) return "Moderate complexity requiring some explanation and context." return "Complex query requiring detailed explanation and possibly multiple knowledge domains." } function extractKeyConcepts(query: string): string[] { try { // In a real implementation, this would use NLP techniques // For simplicity, we'll use a basic approach here const words = query.toLowerCase().split(/\s+/) const stopWords = new Set([ "the", "a", "an", "is", "are", "was", "were", "in", "on", "at", "to", "for", "with", "by", "about", "like", "through", "over", "before", "after", "between", "under", "above", "of", "and", "or", "not", "this", "that", "these", "those", "it", "its", "they", "them", "their", "what", "which", "who", "whom", "whose", "when", "where", "why", "how", "all", "any", "both", "each", "few", "more", "most", "some", "such", "no", "nor", "too", "very", "can", "will", "just", "should", "now", ]) const concepts = words .filter((word) => !stopWords.has(word) && word.length > 3) .map((word) => word.replace(/[^\w]/g, "")) .filter((word) => word.length > 0) // Ensure no empty strings // Remove duplicates return [...new Set(concepts)] } catch (error) { logger.error("Error extracting key concepts", error) return [] // Return empty array on error } } function determineKnowledgeDomains(concepts: string[], query: string): string[] { try { // Map concepts to knowledge domains const domainKeywords: Record = { programming: [ "code", "function", "programming", "javascript", "python", "react", "component", "api", "algorithm", "developer", "software", "app", "application", "website", "frontend", "backend", "fullstack", "database", ], mathematics: [ "math", "equation", "calculus", "algebra", "geometry", "theorem", "formula", "number", "calculation", "statistics", "probability", "arithmetic", "numerical", ], science: [ "physics", "chemistry", "biology", "scientific", "experiment", "theory", "hypothesis", "research", "laboratory", "molecule", "atom", "cell", "organism", "energy", "force", ], history: [ "history", "historical", "century", "ancient", "medieval", "modern", "war", "revolution", "civilization", "empire", "kingdom", "dynasty", "era", "period", "timeline", ], technology: [ "technology", "computer", "software", "hardware", "internet", "digital", "electronic", "device", "gadget", "innovation", "tech", "artificial", "intelligence", "machine", "learning", "data", ], business: [ "business", "finance", "economy", "market", "investment", "company", "startup", "entrepreneur", "management", "strategy", "marketing", "sales", "profit", "revenue", "customer", ], arts: [ "art", "music", "literature", "painting", "sculpture", "novel", "poetry", "artist", "author", "creative", "design", "aesthetic", "culture", "film", "movie", "theater", "performance", ], philosophy: [ "philosophy", "ethics", "moral", "logic", "reasoning", "existence", "consciousness", "metaphysics", "epistemology", "knowledge", "belief", "truth", "reality", "perception", ], health: [ "health", "medical", "medicine", "disease", "treatment", "therapy", "doctor", "patient", "hospital", "clinic", "symptom", "diagnosis", "wellness", "fitness", "nutrition", "diet", ], } // Count domain matches const domainCounts: Record = {} for (const concept of concepts) { for (const [domain, keywords] of Object.entries(domainKeywords)) { if (keywords.some((keyword) => concept.includes(keyword) || keyword.includes(concept))) { domainCounts[domain] = (domainCounts[domain] || 0) + 1 } } } // Also check the full query for domain keywords for (const [domain, keywords] of Object.entries(domainKeywords)) { if (keywords.some((keyword) => query.toLowerCase().includes(keyword))) { domainCounts[domain] = (domainCounts[domain] || 0) + 2 // Give more weight to full query matches } } // Sort domains by count and take the top 3 const sortedDomains = Object.entries(domainCounts) .sort((a, b) => b[1] - a[1]) .map(([domain]) => domain) return sortedDomains.length > 0 ? sortedDomains.slice(0, 3) : ["general_knowledge"] } catch (error) { logger.error("Error determining knowledge domains", error) return ["general_knowledge"] // Default domain on error } } function analyzeConversationContext(messages: Message[]): string { try { // Analyze the conversation history to determine context const userMessages = messages.filter((m) => m.role === "user") if (!userMessages || userMessages.length <= 1) { return "New conversation with no established context." } // Check for topic consistency const recentUserMessages = userMessages.slice(-3) const allContent = recentUserMessages.map((m) => m.content).join(" ") // Simple topic analysis const topics = determineKnowledgeDomains(extractKeyConcepts(allContent), allContent) return `Ongoing conversation about ${topics.join(", ")} with ${userMessages.length} previous user messages.` } catch (error) { logger.error("Error analyzing conversation context", error) return "Unable to determine conversation context. Treating as new conversation." } } function formulateReasoningApproach(complexityScore: number, domains: string[], contextAnalysis: string): string { try { // Determine the appropriate reasoning approach based on complexity and domains const domainStr = domains.join(", ") if (complexityScore <= 3) { return `Direct response approach. Provide a concise and direct answer focusing on the key concepts: ${domainStr}.` } if (complexityScore <= 6) { return `Explanatory approach. Provide a detailed explanation covering the identified knowledge domains: ${domainStr}, to offer more context and clarity.` } return `Comprehensive reasoning approach. Employ a multi-step reasoning process to address the complex query, drawing upon knowledge from ${domainStr}, considering the conversation context, and providing a thorough and nuanced response.` } catch (error) { logger.error("Error formulating reasoning approach", error) return "Standard response approach. Provide a balanced answer based on the query." } } [V0_FILE]typescriptreact:file="lib/logger.ts" isEdit="true" isMerged="true" type LogLevel = "debug" | "info" | "warn" | "error" interface LogEntry { timestamp: string level: LogLevel message: string data?: any } class Logger { private logBuffer: LogEntry[] = [] private maxBufferSize = 100 debug(message: string, data?: any) { this.log("debug", message, data) } info(message: string, data?: any) { this.log("info", message, data) } warn(message: string, data?: any) { this.log("warn", message, data) } error(message: string, data?: any) { this.log("error", message, data) } private log(level: LogLevel, message: string, data?: any) { try { const timestamp = new Date().toISOString() // Format error objects let formattedData = data if (data instanceof Error) { formattedData = { name: data.name, message: data.message, stack: data.stack, } } const entry: LogEntry = { timestamp, level, message, ...(formattedData !== undefined && { data: formattedData }), } // Add to buffer this.logBuffer.push(entry) if (this.logBuffer.length > this.maxBufferSize) { this.logBuffer.shift() } // Log to console in development if (typeof window === "undefined") { // Only log on server side const consoleMethod = level === "debug" ? console.debug : level === "info" ? console.info : level === "warn" ? console.warn : console.error consoleMethod(`[${timestamp}] [${level.toUpperCase()}] ${message}`, formattedData || "") } } catch (error) { // Fallback logging if something goes wrong console.error("Logger error:", error) console.error("Original log:", { level, message, data }) } } getRecentLogs(count = 10): LogEntry[] { return this.logBuffer.slice(-Math.min(count, this.logBuffer.length)) } clearLogs() { this.logBuffer = [] } } // Create a singleton instance export const logger = new Logger() [V0_FILE]typescriptreact:file="components/reasoning-visualizer.tsx" isEdit="true" isMerged="true" "use client" import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card" import { Alert, AlertDescription } from "@/components/ui/alert" import { BrainCircuit, Lightbulb, Sparkles } from "lucide-react" import type { ReasoningStep } from "@/lib/reasoning" interface ReasoningVisualizerProps { steps: ReasoningStep[] } export function ReasoningVisualizer({ steps = [] }: ReasoningVisualizerProps) { if (!steps || steps.length === 0) { return (

No Reasoning Data Available

Send a message to see Sentient-1's reasoning process and how it processes your request.

) } return (

Reasoning Process

See how Sentient-1 processes your request through multiple reasoning steps

{steps.map((step, index) => (

{index === 0 ? ( ) : ( )} {step.description}

Step {index + 1} of {steps.length} {step.result} ))}

) } [V0_FILE]typescriptreact:file="components/settings-panel.tsx" isEdit="true" isMerged="true" "use client" import type { Dispatch, SetStateAction } from "react" import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card" import { Slider } from "@/components/ui/slider" import { Label } from "@/components/ui/label" import { Textarea } from "@/components/ui/textarea" import { Button } from "@/components/ui/button" import { X, RotateCcw } from "lucide-react" interface SettingsPanelProps { systemPrompt: string setSystemPrompt: Dispatch> temperature: number setTemperature: Dispatch> onClose: () => void } export function SettingsPanel({ systemPrompt, setSystemPrompt, temperature, setTemperature, onClose, }: SettingsPanelProps) { const resetToDefaults = () => { setSystemPrompt( "You are Sentient-1, an advanced neural-symbolic AI assistant with contextual understanding and reasoning capabilities.", ) setTemperature(0.7) } return (

Settings

System Prompt Define how Sentient-1 should behave

setSystemPrompt(e.target.value)}
              className="min-h-[100px]"
              placeholder="Enter system prompt..."
              aria-label="System prompt"
            />
          </CardContent>
        </Card>

<Card>
          <CardHeader>
            <CardTitle>Temperature</CardTitle>
            <CardDescription>Adjust how creative or focused the responses should be</CardDescription>
          </CardHeader>
          <CardContent className="space-y-4">
            <div className="space-y-2">
              <div className="flex justify-between">
                <Label htmlFor="temperature">Temperature: {temperature.toFixed(1)}</Label>
                <span className="text-sm text-muted-foreground">
                  {temperature < 0.3 ? "More focused" : temperature > 0.7 ? "More creative" : "Balanced"}
                </span>
              </div>
              <Slider
                id="temperature"
                min={0}
                max={1}
                step={0.1}
                value={[temperature]}
                onValueChange={(value) => setTemperature(value[0])}
                aria-label="Adjust temperature"
              />
            </div>
          </CardContent>
        </Card>

<Button onClick={resetToDefaults} variant="outline" className="w-full" aria-label="Reset settings to defaults">
          <RotateCcw className="h-4 w-4 mr-2" />
          Reset to Defaults
        </Button>
      </div>
    </div>
  )
}

[V0_FILE]typescriptreact:file="env.example" isMerged="true"
# API Keys - Already configured with provided keys
PPLX_API_KEY=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
OPENAI_API_KEY=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

# Vercel URL - Will be set automatically in production
# For local development, this will default to localhost:3000
NEXT_PUBLIC_VERCEL_URL=localhost:3000

# Node Environment
NODE_ENV=development

[V0_FILE]typescriptreact:file="app/layout.tsx" isMerged="true"
import type React from "react"
import "./globals.css"
import { Inter } from "next/font/google"
import { ThemeProvider } from "@/components/theme-provider"

const inter = Inter({ subsets: ["latin"] })

export const metadata = {
  title: "Sentient-1 AI",
  description: "Advanced neural-symbolic AI assistant with contextual understanding and reasoning capabilities",
}

export default function RootLayout({
  children,
}: {
  children: React.ReactNode
}) {
  return (
    <html lang="en" suppressHydrationWarning>
      <body className={inter.className}>
        <ThemeProvider attribute="class" defaultTheme="system" enableSystem>
          {children}
        </ThemeProvider>
      </body>
    </html>
  )
}

[V0_FILE]typescriptreact:file="app/api/function/[name]/route.ts" isMerged="true"
import { logger } from "@/lib/logger"

export async function POST(req: Request, { params }: { params: { name: string } }) {
  try {
    const { name } = params
    const args = await req.json()

logger.info(`Function call: ${name}`, args)

// Handle different functions
    switch (name) {
      case "search":
        return handleSearch(args.query)
      case "calculate":
        return handleCalculate(args.expression)
      default:
        return new Response(
          JSON.stringify({
            error: `Function ${name} not found`,
          }),
          { status: 404, headers: { "Content-Type": "application/json" } },
        )
    }
  } catch (error) {
    logger.error("Error in function API route", error instanceof Error ? error.message : String(error))

return new Response(
      JSON.stringify({
        error: "Error processing function call",
        details: error instanceof Error ? error.message : "Unknown error",
      }),
      { status: 500, headers: { "Content-Type": "application/json" } },
    )
  }
}

async function handleSearch(query: string) {
  try {
    // In a real application, you would implement an actual search here
    // For now, we'll just return a mock response
    const result = `Here are the search results for "${query}":
    
1. First relevant result about ${query}
2. Second relevant result about ${query}
3. Third relevant result about ${query}`

return new Response(
      JSON.stringify({
        result,
      }),
      { status: 200, headers: { "Content-Type": "application/json" } },
    )
  } catch (error) {
    logger.error("Error in search function", error)
    throw error
  }
}

async function handleCalculate(expression: string) {
  try {
    // Safely evaluate the expression
    let result
    try {
      // Use Function constructor to safely evaluate the expression
      // This is safer than eval() but still needs caution
      result = new Function(`return ${expression}`)()
    } catch (error) {
      result = `Error evaluating expression: ${error instanceof Error ? error.message : "Unknown error"}`
    }

return new Response(
      JSON.stringify({
        result: `${expression} = ${result}`,
      }),
      { status: 200, headers: { "Content-Type": "application/json" } },
    )
  } catch (error) {
    logger.error("Error in calculate function", error)
    throw error
  }
}

[V0_FILE]typescriptreact:file="app/api/debug/route.ts" isEdit="true" isMerged="true"
export async function GET() {
  const pplxKey = process.env.PPLX_API_KEY || ""

// Mask the key for security
  const maskKey = (key: string) => {
    if (!key) return "not set"
    if (key.length <= 8) return "***"
    return key.substring(0, 4) + "..." + key.substring(key.length - 4)
  }

return new Response(
    JSON.stringify({
      status: "ok",
      environment: process.env.NODE_ENV,
      api: {
        perplexity: {
          configured: !!pplxKey,
          key: maskKey(pplxKey),
        },
      },
    }),
    {
      status: 200,
      headers: { "Content-Type": "application/json" },
    },
  )
}

[V0_FILE]typescriptreact:file="app/page.tsx" isEdit="true" isMerged="true"
"use client"

import type React from "react"

import { useState, useRef, useEffect } from "react"
import { Button } from "@/components/ui/button"
import { Textarea } from "@/components/ui/textarea"
import { Avatar, AvatarFallback } from "@/components/ui/avatar"
import { Card, CardContent } from "@/components/ui/card"
import {
  Loader2,
  Send,
  Sparkles,
  RefreshCw,
  Copy,
  Check,
  Moon,
  Sun,
  BrainCircuit,
  ChevronDown,
  Info,
} from "lucide-react"
import { cn } from "@/lib/utils"
import { ReasoningVisualizer } from "@/components/reasoning-visualizer"
import type { ReasoningStep } from "@/lib/reasoning"

interface Message {
  id: string
  role: "user" | "assistant" | "system"
  content: string
  timestamp: Date
  reasoning?: ReasoningStep[]
}

export default function ChatPage() {
  // State
  const [messages, setMessages] = useState<Message[]>([])
  const [input, setInput] = useState("")
  const [isLoading, setIsLoading] = useState(false)
  const [theme, setTheme] = useState<"light" | "dark">("light")
  const [error, setError] = useState<string | null>(null)
  const [copiedMessageId, setCopiedMessageId] = useState<string | null>(null)
  const [showScrollButton, setShowScrollButton] = useState(false)
  const [showReasoning, setShowReasoning] = useState(false)
  const [currentReasoningSteps, setCurrentReasoningSteps] = useState<ReasoningStep[]>([])

// Refs
  const messagesEndRef = useRef<HTMLDivElement>(null)
  const chatContainerRef = useRef<HTMLDivElement>(null)
  const textareaRef = useRef<HTMLTextAreaElement>(null)

// Generate unique ID for messages
  const generateId = () => {
    return Date.now().toString(36) + Math.random().toString(36).substring(2)
  }

// Scroll to bottom when messages change
  useEffect(() => {
    if (messagesEndRef.current && !showScrollButton) {
      messagesEndRef.current.scrollIntoView({ behavior: "smooth" })
    }
  }, [messages, showScrollButton])

// Handle scroll events
  useEffect(() => {
    const handleScroll = () => {
      if (!chatContainerRef.current) return

const { scrollTop, scrollHeight, clientHeight } = chatContainerRef.current
      const isNearBottom = scrollHeight - scrollTop - clientHeight < 100

setShowScrollButton(!isNearBottom)
    }

const container = chatContainerRef.current
    if (container) {
      container.addEventListener("scroll", handleScroll)
      return () => container.removeEventListener("scroll", handleScroll)
    }
  }, [])

// Focus textarea on load
  useEffect(() => {
    textareaRef.current?.focus()
  }, [])

// Handle theme toggle
  const toggleTheme = () => {
    setTheme((prevTheme) => {
      const newTheme = prevTheme === "light" ? "dark" : "light"
      document.documentElement.classList.toggle("dark", newTheme === "dark")
      return newTheme
    })
  }

// Initialize theme
  useEffect(() => {
    const prefersDark = window.matchMedia("(prefers-color-scheme: dark)").matches
    if (prefersDark) {
      setTheme("dark")
      document.documentElement.classList.add("dark")
    }
  }, [])

// Preprocess input for better responses
  const preprocessInput = (input: string) => {
    const processedInput = input.trim()

// If it's just a single word or very short phrase, expand it
    if (processedInput.split(" ").length <= 2) {
      if (processedInput.toLowerCase() === "calculus") {
        return "Explain calculus in simple terms."
      } else if (processedInput.toLowerCase() === "ai" || processedInput.toLowerCase() === "artificial intelligence") {
        return "Explain what artificial intelligence is and how it works."
      } else if (processedInput.toLowerCase() === "help") {
        return "What can you help me with?"
      }
    }

return processedInput
  }

// Handle form submission
  const handleSubmit = async (e: React.FormEvent) => {
    e.preventDefault()

if (!input.trim() || isLoading) return

// Preprocess input
    const processedInput = preprocessInput(input)

// Add user message
    const userMessage: Message = {
      id: generateId(),
      role: "user",
      content: processedInput,
      timestamp: new Date(),
    }

setMessages((prev) => [...prev, userMessage])
    setInput("")
    setIsLoading(true)
    setError(null)
    setCurrentReasoningSteps([])

try {
      // Send request to API
      const response = await fetch("/api/chat", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
        },
        body: JSON.stringify({
          messages: messages.concat(userMessage).map((m) => ({
            role: m.role,
            content: m.content,
          })),
          temperature: 0.2,
        }),
      })

if (!response.ok) {
        const errorData = await response.json().catch(() => ({ error: `Error: ${response.status}` }))
        throw new Error(errorData.error || `Error: ${response.status}`)
      }

const data = await response.json()

// Store reasoning steps if available
      if (data.reasoning && Array.isArray(data.reasoning)) {
        setCurrentReasoningSteps(data.reasoning)
      }

// Add assistant message
      setMessages((prev) => [
        ...prev,
        {
          id: generateId(),
          role: "assistant",
          content: data.content,
          timestamp: new Date(),
          reasoning: data.reasoning,
        },
      ])
    } catch (err) {
      console.error("Chat error:", err)
      setError(err instanceof Error ? err.message : "An error occurred")
    } finally {
      setIsLoading(false)
    }
  }

// Auto-resize textarea
  const handleInputChange = (e: React.ChangeEvent<HTMLTextAreaElement>) => {
    const textarea = e.target
    setInput(textarea.value)
    textarea.style.height = "auto"
    textarea.style.height = `${Math.min(textarea.scrollHeight, 200)}px`
  }

// Handle key press
  const handleKeyDown = (e: React.KeyboardEvent<HTMLTextAreaElement>) => {
    if (e.key === "Enter" && !e.shiftKey) {
      e.preventDefault()
      handleSubmit(e as unknown as React.FormEvent)
    }
  }

// Clear chat
  const clearChat = () => {
    setMessages([])
    setError(null)
    setCurrentReasoningSteps([])
    if (textareaRef.current) {
      textareaRef.current.style.height = "auto"
      textareaRef.current.focus()
    }
  }

// Copy message to clipboard
  const copyMessage = (message: Message) => {
    navigator.clipboard.writeText(message.content)
    setCopiedMessageId(message.id)
    setTimeout(() => setCopiedMessageId(null), 2000)
  }

// Format message content with code blocks
  const formatMessageContent = (content: string) => {
    if (!content) return <p>No content</p>

try {
      return content.split("```").map((part, i) => {
        if (i % 2 === 0) {
          return (
            <p key={i} className="whitespace-pre-wrap">
              {part}
            </p>
          )
        } else {
          const [language, ...code] = part.split("\n")
          return (
            <pre key={i} className="bg-black/10 dark:bg-white/10 p-2 rounded-md overflow-x-auto my-2">
              <code>{code.join("\n")}</code>
            </pre>
          )
        }
      })
    } catch (error) {
      console.error("Error formatting message:", error)
      return <p className="whitespace-pre-wrap">{content}</p>
    }
  }

return (
    <div className={cn("min-h-screen bg-background", theme === "dark" ? "dark" : "")}>
      <div className="flex flex-col h-screen">
        <header className="border-b p-4 flex justify-between items-center">
          <div className="flex items-center gap-2">
            <Sparkles className="h-5 w-5 text-primary" />
            <h1 className="font-bold text-xl">Sentient-1</h1>
          </div>
          <div className="flex items-center gap-2">
            <Button
              variant="outline"
              size="sm"
              onClick={() => setShowReasoning(!showReasoning)}
              className={cn(showReasoning && "bg-primary/10")}
            >
              <BrainCircuit className="h-4 w-4 mr-2" />
              {showReasoning ? "Hide" : "Show"} Reasoning
            </Button>
            <Button variant="ghost" size="sm" onClick={clearChat}>
              <RefreshCw className="h-4 w-4 mr-2" />
              Clear Chat
            </Button>
            <Button variant="ghost" size="icon" onClick={toggleTheme}>
              {theme === "light" ? <Moon className="h-5 w-5" /> : <Sun className="h-5 w-5" />}
            </Button>
          </div>
        </header>

<div className="flex flex-1 overflow-hidden">
          <div
            ref={chatContainerRef}
            className={cn("flex-1 overflow-y-auto p-4 transition-all", showReasoning ? "w-1/2" : "w-full")}
          >
            <div className="max-w-3xl mx-auto space-y-6">
              {messages.length === 0 && (
                <div className="text-center p-8">
                  <div className="h-16 w-16 rounded-full bg-primary/10 flex items-center justify-center mx-auto mb-4">
                    <Sparkles className="h-8 w-8 text-primary" />
                  </div>
                  <h2 className="text-2xl font-bold mb-2">Welcome to Sentient-1</h2>
                  <p className="text-muted-foreground mb-6">
                    Your advanced neural-symbolic AI assistant with reasoning capabilities
                  </p>

<div className="grid grid-cols-1 md:grid-cols-2 gap-4">
                    <Card
                      className="bg-card/50 border-0 cursor-pointer hover:bg-card/80 transition-colors"
                      onClick={() => {
                        setInput("What are the ethical implications of AI in healthcare?")
                        if (textareaRef.current) {
                          textareaRef.current.focus()
                          textareaRef.current.style.height = "auto"
                          textareaRef.current.style.height = `${Math.min(textareaRef.current.scrollHeight, 200)}px`
                        }
                      }}
                    >
                      <CardContent className="p-4">
                        <h3 className="font-medium mb-2">Ask a question</h3>
                        <p className="text-sm text-muted-foreground">
                          "What are the ethical implications of AI in healthcare?"
                        </p>
                      </CardContent>
                    </Card>

<Card
                      className="bg-card/50 border-0 cursor-pointer hover:bg-card/80 transition-colors"
                      onClick={() => {
                        setInput("Explain quantum computing in simple terms.")
                        if (textareaRef.current) {
                          textareaRef.current.focus()
                          textareaRef.current.style.height = "auto"
                          textareaRef.current.style.height = `${Math.min(textareaRef.current.scrollHeight, 200)}px`
                        }
                      }}
                    >
                      <CardContent className="p-4">
                        <h3 className="font-medium mb-2">Learn something new</h3>
                        <p className="text-sm text-muted-foreground">"Explain quantum computing in simple terms."</p>
                      </CardContent>
                    </Card>
                  </div>
                </div>
              )}

{messages.map((message) => (
                <div key={message.id} className={cn("flex", message.role === "user" ? "justify-end" : "justify-start")}>
                  <div className="flex items-start gap-3 max-w-[90%] group">
                    {message.role !== "user" && (
                      <Avatar className="h-8 w-8 bg-primary/10">
                        <AvatarFallback className="text-primary">S1</AvatarFallback>
                      </Avatar>
                    )}
                    <div
                      className={cn(
                        "rounded-lg px-4 py-2 relative",
                        message.role === "user" ? "bg-primary text-primary-foreground" : "bg-muted",
                      )}
                    >
                      <div className="prose dark:prose-invert prose-sm max-w-none">
                        {formatMessageContent(message.content)}
                      </div>

{/* Reasoning indicator */}
                      {message.role === "assistant" && message.reasoning && message.reasoning.length > 0 && (
                        <div className="mt-2 pt-2 border-t border-border/50 text-xs text-muted-foreground flex items-center gap-1">
                          <BrainCircuit className="h-3 w-3" />
                          <span>Processed with {message.reasoning.length} reasoning steps</span>
                          {!showReasoning && (
                            <Button
                              variant="ghost"
                              size="sm"
                              className="h-5 px-1 text-xs"
                              onClick={() => setShowReasoning(true)}
                            >
                              View
                            </Button>
                          )}
                        </div>
                      )}

{/* Copy button - only for assistant messages */}
                      {message.role === "assistant" && (
                        <Button
                          variant="ghost"
                          size="icon"
                          className="absolute top-2 right-2 opacity-0 group-hover:opacity-100 transition-opacity"
                          onClick={() => copyMessage(message)}
                        >
                          {copiedMessageId === message.id ? (
                            <Check className="h-4 w-4" />
                          ) : (
                            <Copy className="h-4 w-4" />
                          )}
                          <span className="sr-only">{copiedMessageId === message.id ? "Copied" : "Copy"}</span>
                        </Button>
                      )}

<div className="text-xs text-muted-foreground mt-1 opacity-0 group-hover:opacity-100 transition-opacity">
                        {message.timestamp.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })}
                      </div>
                    </div>
                    {message.role === "user" && (
                      <Avatar className="h-8 w-8 bg-primary">
                        <AvatarFallback>You</AvatarFallback>
                      </Avatar>
                    )}
                  </div>
                </div>
              ))}

{isLoading && (
                <div className="flex justify-start">
                  <div className="flex items-start gap-3 max-w-[80%]">
                    <Avatar className="h-8 w-8 bg-primary/10">
                      <AvatarFallback className="text-primary">S1</AvatarFallback>
                    </Avatar>
                    <div className="rounded-lg px-4 py-2 bg-muted">
                      <div className="flex space-x-2">
                        <div
                          className="w-2 h-2 rounded-full bg-current animate-bounce"
                          style={{ animationDelay: "0ms" }}
                        ></div>
                        <div
                          className="w-2 h-2 rounded-full bg-current animate-bounce"
                          style={{ animationDelay: "150ms" }}
                        ></div>
                        <div
                          className="w-2 h-2 rounded-full bg-current animate-bounce"
                          style={{ animationDelay: "300ms" }}
                        ></div>
                      </div>
                    </div>
                  </div>
                </div>
              )}

{error && (
                <div className="p-4 bg-destructive/10 text-destructive rounded-lg">
                  <div className="flex items-center gap-2 mb-2">
                    <svg
                      xmlns="http://www.w3.org/2000/svg"
                      width="16"
                      height="16"
                      viewBox="0 0 24 24"
                      fill="none"
                      stroke="currentColor"
                      strokeWidth="2"
                      strokeLinecap="round"
                      strokeLinejoin="round"
                      className="lucide lucide-alert-triangle"
                    >
                      <path d="m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3Z" />
                      <path d="M12 9v4" />
                      <path d="M12 17h.01" />
                    </svg>
                    <p className="font-medium">Error</p>
                  </div>
                  <p className="text-sm">{error}</p>
                  <Button variant="outline" size="sm" onClick={() => setError(null)} className="mt-2">
                    Dismiss
                  </Button>
                </div>
              )}

{/* Reasoning panel */}
          {showReasoning && (
            <div className="w-1/2 border-l overflow-y-auto p-4 bg-muted/30">
              <ReasoningVisualizer steps={currentReasoningSteps} />
            </div>
          )}
        </div>

{/* Scroll to bottom button */}
        {showScrollButton && (
          <Button
            variant="outline"
            size="icon"
            className="absolute bottom-24 right-8 rounded-full shadow-md"
            onClick={() => messagesEndRef.current?.scrollIntoView({ behavior: "smooth" })}
          >
            <ChevronDown className="h-5 w-5" />
            <span className="sr-only">Scroll to bottom</span>
          </Button>
        )}

<div className="border-t p-4">
          <div className="max-w-3xl mx-auto">
            <form onSubmit={handleSubmit} className="flex gap-2">
              <Textarea
                ref={textareaRef}
                placeholder="Send a message..."
                value={input}
                onChange={handleInputChange}
                onKeyDown={handleKeyDown}
                className="flex-1 min-h-[60px] max-h-[200px] resize-none"
                disabled={isLoading}
              />
              <Button type="submit" className="self-end" disabled={!input.trim() || isLoading}>
                {isLoading ? <Loader2 className="h-4 w-4 animate-spin" /> : <Send className="h-4 w-4" />}
              </Button>
            </form>
            <div className="flex items-center justify-center mt-2">
              <Info className="h-3 w-3 text-muted-foreground mr-1" />
              <p className="text-xs text-muted-foreground">
                Sentient-1 uses advanced reasoning to process your queries before responding.
              </p>
            </div>
          </div>
        </div>
      </div>
    </div>
  )
}

[V0_FILE]typescriptreact:file="app/api/test/route.ts" isEdit="true" isMerged="true"
import { logger } from "@/lib/logger"

// Use the PPLX API key directly
const PPLX_API_KEY = "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"

export async function GET() {
  try {
    // Test Perplexity API
    try {
      const requestBody = {
        model: "sonar",
        messages: [
          { role: "system", content: "Be precise and concise." },
          { role: "user", content: "Hello" },
        ],
        max_tokens: 50,
        temperature: 0.2,
        top_p: 0.9,
        top_k: 0,
        stream: false,
        presence_penalty: 0,
        frequency_penalty: 1,
      }

const pplxResponse = await fetch("https://api.perplexity.ai/chat/completions", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          Authorization: `Bearer ${PPLX_API_KEY}`,
        },
        body: JSON.stringify(requestBody),
      })

if (pplxResponse.ok) {
        const data = await pplxResponse.json()
        return new Response(
          JSON.stringify({
            status: "ok",
            message: "Perplexity API is working correctly",
            response: data,
          }),
          {
            status: 200,
            headers: { "Content-Type": "application/json" },
          },
        )
      } else {
        const errorText = await pplxResponse.text()
        throw new Error(`API error: ${pplxResponse.status} - ${errorText}`)
      }
    } catch (error) {
      throw error
    }
  } catch (error) {
    logger.error("API test failed", error)

return new Response(
      JSON.stringify({
        status: "error",
        message: "API test failed",
        error: error instanceof Error ? error.message : String(error),
      }),
      {
        status: 500,
        headers: { "Content-Type": "application/json" },
      },
    )
  }
}

[V0_FILE]typescriptreact:file="app/api/health/route.ts" isEdit="true" isMerged="true"
// Use the PPLX API key directly
const PPLX_API_KEY = "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"

export async function GET() {
  return new Response(
    JSON.stringify({
      status: "ok",
      timestamp: new Date().toISOString(),
      api: {
        perplexity: {
          configured: true,
          key_prefix: PPLX_API_KEY.substring(0, 10) + "...",
        },
      },
    }),
    {
      status: 200,
      headers: { "Content-Type": "application/json" },
    },
  )
}

[V0_FILE]typescriptreact:file="lib/pretraining.ts" isEdit="true"
import { logger } from "@/lib/logger"

interface Message {
  role: "user" | "assistant" | "system"
  content: string
}

interface PretrainingSample {
  question: string
  answer: string
}

interface PretrainingResponse {
  samples: PretrainingSample[]
  dataset: string
}

interface DatasetInfo {
  name: string
  config?: string
  split?: string
  questionField: string
  answerField: string
  category: string[]
  description: string
}

// Enhanced dataset registry with more options
const DATASETS: DatasetInfo[] = [
  {
    name: "GeneralReasoning/GeneralThought-195K",
    questionField: "input",
    answerField: "output",
    category: ["reasoning", "general", "thought"],
    description: "General reasoning dataset with diverse thought processes",
  },
  {
    name: "tatsu-lab/alpaca",
    config: "default",
    split: "train",
    questionField: "instruction",
    answerField: "output",
    category: ["instruction", "general", "qa"],
    description: "Instruction-following dataset with diverse tasks",
  },
  {
    name: "databricks/databricks-dolly-15k",
    questionField: "instruction",
    answerField: "response",
    category: ["instruction", "reasoning", "qa"],
    description: "Instruction dataset with reasoning and QA examples",
  },
  {
    name: "OpenAssistant/oasst1",
    config: "full",
    split: "train",
    questionField: "text",
    answerField: "text",
    category: ["conversation", "assistant", "qa"],
    description: "Conversational assistant dataset with high-quality responses",
  },
  {
    name: "Anthropic/hh-rlhf",
    config: "helpful",
    split: "train",
    questionField: "input",
    answerField: "output",
    category: ["helpful", "instruction", "ethics"],
    description: "Helpful and harmless responses to diverse queries",
  },
  {
    name: "bigscience/P3",
    config: "default",
    split: "train",
    questionField: "inputs",
    answerField: "targets",
    category: ["multilingual", "instruction", "diverse"],
    description: "Public Pool of Prompts dataset with diverse tasks",
  },
  {
    name: "EleutherAI/pile",
    config: "all",
    split: "train",
    questionField: "text",
    answerField: "text",
    category: ["general", "knowledge", "code"],
    description: "Large-scale diverse text dataset for knowledge-intensive tasks",
  },
  {
    name: "squad_v2",
    questionField: "question",
    answerField: "answers",
    category: ["qa", "reading", "comprehension"],
    description: "Question answering dataset based on Wikipedia articles",
  },
]

/**
 * Selects the most relevant datasets based on query content
 * @param query User query to analyze
 * @returns Array of most relevant dataset info objects
 */
function selectRelevantDatasets(query: string): DatasetInfo[] {
  try {
    const queryLower = query.toLowerCase()

// Extract key terms from the query
    const terms = queryLower
      .replace(/[^\w\s]/g, "")
      .split(/\s+/)
      .filter(
        (term) =>
          term.length > 3 &&
          !["what", "when", "where", "which", "how", "why", "who", "that", "this", "these", "those"].includes(term),
      )

// Score each dataset based on relevance to the query
    const scoredDatasets = DATASETS.map((dataset) => {
      let score = 0

// Score based on category matches
      if (hasMath && dataset.category.some((cat) => ["reasoning", "logic", "math"].includes(cat))) score += 3
      if (hasCode && dataset.category.some((cat) => ["code", "programming", "technical"].includes(cat))) score += 3
      if (hasScience && dataset.category.some((cat) => ["science", "research", "technical"].includes(cat))) score += 3
      if (hasPhilosophy && dataset.category.some((cat) => ["philosophy", "ethics", "reasoning"].includes(cat)))
        score += 3

// Score based on term matches in categories
      for (const term of terms) {
        if (dataset.category.some((cat) => cat.includes(term))) score += 2
        if (dataset.description.toLowerCase().includes(term)) score += 1
      }

// Always give some score to general datasets
      if (dataset.category.includes("general")) score += 1

return { dataset, score }
    })

// Sort by score and take top 3
    const topDatasets = scoredDatasets
      .sort((a, b) => b.score - a.score)
      .slice(0, 3)
      .map((item) => item.dataset)

// Always include at least one general dataset
    if (!topDatasets.some((ds) => ds.category.includes("general"))) {
      const generalDataset = DATASETS.find((ds) => ds.category.includes("general"))
      if (generalDataset) {
        topDatasets.pop() // Remove the lowest scored dataset
        topDatasets.push(generalDataset)
      }
    }

logger.info(`Selected datasets for query: ${topDatasets.map((ds) => ds.name).join(", ")}`)
    return topDatasets.length > 0 ? topDatasets : [DATASETS[0]] // Fallback to first dataset
  } catch (error) {
    logger.error("Error selecting relevant datasets", error)
    return [DATASETS[0]] // Fallback to first dataset on error
  }
}

/**
 * Enhances conversation with relevant pretraining examples
 * @param messages Current conversation messages
 * @param lastUserMessage The most recent user message
 * @returns Enhanced messages array with pretraining examples
 */
export async function enhanceWithPretraining(messages: Message[], lastUserMessage: string): Promise<Message[]> {
  try {
    if (!lastUserMessage || typeof lastUserMessage !== "string" || lastUserMessage.trim() === "") {
      logger.warn("Invalid user message for pretraining enhancement")
      return messages
    }

// Use a try-catch block for the fetch operation
    try {
      const response = await fetch("/api/pretrain", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
        },
        body: JSON.stringify({
          query: lastUserMessage,
          count: 3, // Reduced from 5 to minimize potential issues
        }),
        // Add a timeout to prevent hanging requests
        signal: AbortSignal.timeout(3000), // 3 second timeout
      })

if (!response.ok) {
        throw new Error(`Pretraining API returned ${response.status}: ${response.statusText}`)
      }

const data = (await response.json()) as PretrainingResponse

if (!data.samples || !Array.isArray(data.samples) || data.samples.length === 0) {
        logger.warn("No pretraining samples returned")
        return messages
      }

logger.info(`Received ${data.samples.length} pretraining samples from ${data.dataset}`)

// Create pretraining examples
      const pretrainingMessages = data.samples.flatMap((sample): Message[] => {
        if (!sample.question || !sample.answer) return []

return [
          { role: "user", content: sample.question },
          { role: "assistant", content: sample.answer },
        ]
      })

// Add pretraining examples at the beginning of the conversation
      // but keep the most recent messages for context
      // Limit the number of messages to prevent exceeding token limits
      return [...pretrainingMessages, ...messages.slice(-5)]
    } catch (fetchError) {
      logger.error("Error fetching pretraining data", fetchError)
      return messages // Return original messages on fetch error
    }
  } catch (error) {
    logger.error("Error enhancing with pretraining", error instanceof Error ? error.message : String(error))
    return messages // Return original messages on any error
  }
}

/**
 * Exports dataset registry for use in the API
 */
export const datasetRegistry = DATASETS

/**
 * Exports the dataset selection function for use in the API
 */
export { selectRelevantDatasets }

[V0_FILE]typescriptreact:file="app/api/pretrain/route.ts" isEdit="true"
import { logger } from "@/lib/logger"
import { selectRelevantDatasets } from "@/lib/pretraining"

// Simple in-memory cache for dataset responses
interface CacheEntry {
  timestamp: number
  data: any
}

const CACHE_TTL = 1000 * 60 * 60 * 24 // 24 hours
const datasetCache = new Map<string, CacheEntry>()

export async function POST(req: Request) {
  try {
    const body = await req.json().catch((error) => {
      logger.error("Failed to parse request body", error)
      throw new Error("Invalid request body")
    })

const { query, count = 3 } = body

if (!query || typeof query !== "string" || query.trim() === "") {
      return new Response(JSON.stringify({ error: "Query is required and must be a non-empty string" }), {
        status: 400,
        headers: { "Content-Type": "application/json" },
      })
    }

logger.info(`Received pretraining request for query: ${query}`)

// Select the most relevant datasets for this query
    const relevantDatasets = selectRelevantDatasets(query)

// Try to fetch from each dataset until we get enough samples
    const allSamples = []
    let successfulDataset = ""

for (const dataset of relevantDatasets) {
      try {
        // Check cache first
        const cacheKey = `${dataset.name}-${dataset.config || "default"}-${dataset.split || "train"}`
        const now = Date.now()
        const cachedEntry = datasetCache.get(cacheKey)

let datasetData

// Use cached data if available and not expired
        if (cachedEntry && now - cachedEntry.timestamp < CACHE_TTL) {
          logger.info(`Using cached data for dataset: ${dataset.name}`)
          datasetData = cachedEntry.data
        } else {
          // Fetch from Hugging Face
          const encodedDataset = encodeURIComponent(dataset.name)
          const config = dataset.config || "default"
          const split = dataset.split || "train"

const url = `https://datasets-server.huggingface.co/rows?dataset=${encodedDataset}&config=${config}&split=${split}&offset=0&length=${count * 3}`

logger.info(`Fetching from Hugging Face: ${url}`)

const response = await fetch(url, {
            method: "GET",
            headers: {
              Accept: "application/json",
            },
            signal: AbortSignal.timeout(5000), // 5 second timeout
          })

if (!response.ok) {
            throw new Error(`Hugging Face API returned ${response.status}`)
          }

datasetData = await response.json()

// Cache the response
          datasetCache.set(cacheKey, {
            timestamp: now,
            data: datasetData,
          })
        }

// Extract rows from the response
        if (datasetData && datasetData.rows && Array.isArray(datasetData.rows)) {
          const questionField = dataset.questionField
          const answerField = dataset.answerField

const samples = datasetData.rows
            .map((row: any) => {
              // Handle nested fields with dot notation
              const getNestedValue = (obj: any, path: string) => {
                return path.split(".").reduce((prev, curr) => {
                  return prev && prev[curr] ? prev[curr] : null
                }, obj)
              }

const question = getNestedValue(row.row, questionField) || ""
              let answer = getNestedValue(row.row, answerField) || ""

// Handle special case for SQuAD where answers is an object
              if (answerField === "answers" && Array.isArray(answer.text)) {
                answer = answer.text[0] || ""
              }

return {
                question,
                answer,
              }
            })
            .filter((sample: any) => sample.question && sample.answer)

if (samples.length > 0) {
            allSamples.push(...samples)
            successfulDataset = dataset.name
            logger.info(`Found ${samples.length} samples from dataset: ${dataset.name}`)

// If we have enough samples, break the loop
            if (allSamples.length >= count) {
              break
            }
          }
        }
      } catch (datasetError) {
        logger.warn(`Error fetching from dataset ${dataset.name}`, datasetError)
        // Continue to the next dataset
      }
    }

// If we got samples from any dataset, return them
    if (allSamples.length > 0) {
      // Deduplicate samples
      const uniqueSamples = allSamples.filter(
        (sample, index, self) => index === self.findIndex((s) => s.question === sample.question),
      )

// Take only the requested number of samples
      const finalSamples = uniqueSamples.slice(0, count)

logger.info(`Returning ${finalSamples.length} samples from ${successfulDataset}`)

return new Response(
        JSON.stringify({
          samples: finalSamples,
          dataset: successfulDataset,
        }),
        {
          status: 200,
          headers: { "Content-Type": "application/json" },
        },
      )
    }

// If all datasets failed, use backup dataset
    logger.warn("All datasets failed, using backup dataset")

// Backup dataset with reasoning examples
    const backupDataset = [
      {
        question: "How do neural networks learn patterns?",
        answer:
          "Neural networks learn patterns through a process called backpropagation. They adjust their internal weights based on the error between their predictions and the actual outcomes. This process involves calculating gradients and using optimization algorithms like gradient descent to minimize the error function.",
      },
      {
        question: "What makes a good research question?",
        answer:
          "A good research question is clear, focused, concise, complex, and arguable. It should be specific enough to be thoroughly answered within the scope of your project. It should also be relevant to your field and contribute to existing knowledge while being original enough to add value.",
      },
      {
        question: "How do you evaluate the credibility of information?",
        answer:
          "To evaluate credibility, examine the source's authority, accuracy, objectivity, currency, and coverage. Consider the author's credentials, check if facts are verifiable, look for bias, ensure the information is up-to-date, and verify that it covers the topic comprehensively.",
      },
      {
        question: "What is the difference between correlation and causation?",
        answer:
          "Correlation means that two variables change together, but one doesn't necessarily cause the other. Causation means that one variable directly affects the other. The key difference is that correlation only identifies a relationship, while causation establishes that one event is the result of the other.",
      },
      {
        question: "How can we address climate change effectively?",
        answer:
          "Addressing climate change effectively requires a multi-faceted approach: 1) Transitioning to renewable energy sources, 2) Improving energy efficiency, 3) Implementing carbon pricing, 4) Protecting and restoring forests, 5) Reducing meat consumption, 6) Developing sustainable transportation, and 7) International cooperation through agreements like the Paris Accord.",
      },
      {
        question: "What are the ethical implications of artificial intelligence?",
        answer:
          "The ethical implications of AI include: 1) Privacy concerns from data collection and surveillance, 2) Bias and discrimination in algorithmic decision-making, 3) Job displacement through automation, 4) Questions of accountability when AI makes mistakes, 5) Transparency issues with 'black box' algorithms, 6) Potential for autonomous weapons, and 7) Long-term existential risks from superintelligent systems.",
      },
      {
        question: "How does quantum computing differ from classical computing?",
        answer:
          "Quantum computing differs from classical computing in several fundamental ways: 1) It uses quantum bits or qubits that can exist in multiple states simultaneously through superposition, unlike classical bits that are either 0 or 1. 2) It leverages quantum entanglement, allowing qubits to be correlated in ways impossible for classical bits. 3) It can perform certain calculations exponentially faster than classical computers, particularly in areas like factoring large numbers and searching unsorted databases.",
      },
      {
        question: "What are the key principles of effective communication?",
        answer:
          "The key principles of effective communication include: 1) Clarity - expressing ideas in a clear, concise manner, 2) Active listening - fully engaging with the speaker, 3) Empathy - understanding others' perspectives, 4) Feedback - providing and receiving constructive feedback, 5) Nonverbal awareness - being conscious of body language and tone, 6) Adaptability - adjusting communication style to different contexts and audiences, and 7) Authenticity - being genuine and honest in your communication.",
      },
      {
        question: "How can I improve my critical thinking skills?",
        answer:
          "To improve critical thinking skills: 1) Question assumptions by asking 'why' and 'how', 2) Evaluate evidence by checking sources and looking for biases, 3) Consider alternative perspectives and explanations, 4) Practice logical reasoning by identifying fallacies, 5) Reflect on your own biases and how they affect your thinking, 6) Engage in thoughtful discussions with people who have different viewpoints, and 7) Apply systematic problem-solving approaches to complex issues.",
      },
      {
        question: "What are the most effective learning strategies?",
        answer:
          "The most effective learning strategies include: 1) Spaced repetition - reviewing material at increasing intervals, 2) Active recall - testing yourself rather than passively reviewing, 3) Interleaving - mixing different topics during study sessions, 4) Elaboration - explaining concepts in your own words, 5) Concrete examples - connecting abstract concepts to specific examples, 6) Dual coding - combining verbal and visual information, and 7) Teaching others - explaining what you've learned to reinforce understanding.",
      },
      // Additional technical examples
      {
        question: "How does a transformer neural network architecture work?",
        answer:
          "Transformer neural networks work through self-attention mechanisms that weigh the importance of different parts of the input data. The architecture consists of an encoder and decoder, each with multiple layers of self-attention and feed-forward neural networks. The key innovation is the attention mechanism that allows the model to focus on different parts of the input sequence when producing each part of the output, enabling better handling of long-range dependencies in sequential data like text.",
      },
      {
        question: "What is the difference between supervised and unsupervised learning?",
        answer:
          "Supervised learning uses labeled data where the model learns to map inputs to known outputs, like classifying images or predicting house prices. Unsupervised learning works with unlabeled data to find patterns or structures, such as clustering similar customers or reducing data dimensionality. Semi-supervised learning combines both approaches by using a small amount of labeled data with a larger amount of unlabeled data.",
      },
      {
        question: "How do you implement a binary search algorithm?",
        answer:
          "To implement binary search: 1) Start with a sorted array, 2) Compare the target value to the middle element, 3) If they match, return the index, 4) If the target is smaller, repeat the search on the left half, 5) If the target is larger, repeat on the right half, 6) Continue until the value is found or the subarray size becomes zero. The time complexity is O(log n), making it efficient for large datasets. Here's a simple implementation in pseudocode:\n\nfunction binarySearch(array, target):\n    left = 0\n    right = array.length - 1\n    while left <= right:\n        mid = (left + right) / 2\n        if array[mid] == target:\n            return mid\n        else if array[mid] < target:\n            left = mid + 1\n        else:\n            right = mid - 1\n    return -1  // Not found",
      },
      {
        question: "What are the principles of responsive web design?",
        answer:
          "Responsive web design principles include: 1) Fluid grids that use relative units like percentages instead of fixed pixels, 2) Flexible images that scale within their containing elements, 3) Media queries that apply different styles based on device characteristics like screen width, 4) Mobile-first approach that designs for small screens first then enhances for larger ones, 5) Breakpoints that define where the layout should change, 6) Content prioritization to determine what's most important for different screen sizes, and 7) Performance optimization to ensure fast loading on all devices.",
      },
    ]

// Filter relevant examples based on query terms
    const queryTerms = query.toLowerCase().split(" ")
    const relevantSamples = backupDataset
      .filter((sample) => {
        const combinedText = (sample.question + sample.answer).toLowerCase()
        return queryTerms.some((term) => term.length > 3 && combinedText.includes(term))
      })
      .slice(0, count)

logger.info(`Found ${relevantSamples.length} relevant samples from backup dataset`)

return new Response(
      JSON.stringify({
        samples: relevantSamples.length > 0 ? relevantSamples : backupDataset.slice(0, count),
        dataset: "backup-reasoning-dataset",
      }),
      {
        status: 200,
        headers: { "Content-Type": "application/json" },
      },
    )
  } catch (error) {
    logger.error("Error in pretrain API route", error instanceof Error ? error.message : String(error))
    return new Response(
      JSON.stringify({
        error: "An error occurred during your request.",
        samples: [], // Return empty samples array to prevent client-side errors
      }),
      {
        status: 500,
        headers: { "Content-Type": "application/json" },
      },
    )
  }
}

[V0_FILE]typescriptreact:file="components/dataset-info.tsx"
"use client"

import { useState } from "react"
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card"
import { Badge } from "@/components/ui/badge"
import { Button } from "@/components/ui/button"
import { Database, ChevronDown, ChevronUp, BookOpen } from "lucide-react"

interface DatasetInfoProps {
  datasetName: string
  sampleCount: number
  onViewSamples?: () => void
}

export function DatasetInfo({ datasetName, sampleCount, onViewSamples }: DatasetInfoProps) {
  const [expanded, setExpanded] = useState(false)

// Get dataset description based on name
  const getDatasetInfo = (name: string) => {
    const datasets: Record<string, { description: string; categories: string[] }> = {
      "GeneralReasoning/GeneralThought-195K": {
        description: "A comprehensive dataset of general reasoning examples with diverse thought processes.",
        categories: ["reasoning", "general", "thought"],
      },
      "tatsu-lab/alpaca": {
        description: "Instruction-following dataset with diverse tasks for language models.",
        categories: ["instruction", "general", "qa"],
      },
      "databricks/databricks-dolly-15k": {
        description: "Instruction dataset with reasoning and QA examples from Databricks.",
        categories: ["instruction", "reasoning", "qa"],
      },
      "OpenAssistant/oasst1": {
        description: "Conversational assistant dataset with high-quality responses from the OpenAssistant project.",
        categories: ["conversation", "assistant", "qa"],
      },
      "Anthropic/hh-rlhf": {
        description: "Helpful and harmless responses to diverse queries from Anthropic.",
        categories: ["helpful", "instruction", "ethics"],
      },
      "bigscience/P3": {
        description: "Public Pool of Prompts dataset with diverse tasks from the BigScience project.",
        categories: ["multilingual", "instruction", "diverse"],
      },
      "EleutherAI/pile": {
        description: "Large-scale diverse text dataset for knowledge-intensive tasks from EleutherAI.",
        categories: ["general", "knowledge", "code"],
      },
      squad_v2: {
        description: "Question answering dataset based on Wikipedia articles.",
        categories: ["qa", "reading", "comprehension"],
      },
      "backup-reasoning-dataset": {
        description: "Curated backup dataset with high-quality reasoning examples.",
        categories: ["reasoning", "general", "curated"],
      },
    }

return (
      datasets[name] || {
        description: "Custom dataset with specialized examples.",
        categories: ["custom"],
      }
    )
  }

const datasetInfo = getDatasetInfo(datasetName)

return (
    <Card className="mb-4">
      <CardHeader className="pb-2">
        <div className="flex justify-between items-center">
          <div className="flex items-center gap-2">
            <Database className="h-4 w-4 text-primary" />
            <CardTitle className="text-base">Pretraining Dataset</CardTitle>
          </div>
          <Button variant="ghost" size="sm" onClick={() => setExpanded(!expanded)} className="h-8 w-8 p-0">
            {expanded ? <ChevronUp className="h-4 w-4" /> : <ChevronDown className="h-4 w-4" />}
          </Button>
        </div>
        <CardDescription>
          {datasetName} ({sampleCount} samples)
        </CardDescription>
      </CardHeader>

{expanded && (
        <CardContent>
          <p className="text-sm mb-3">{datasetInfo.description}</p>
          <div className="flex flex-wrap gap-2 mb-3">
            {datasetInfo.categories.map((category) => (
              <Badge key={category} variant="secondary">
                {category}
              </Badge>
            ))}
          </div>
          {onViewSamples && (
            <Button variant="outline" size="sm" onClick={onViewSamples} className="w-full">
              <BookOpen className="h-4 w-4 mr-2" />
              View Sample Examples
            </Button>
          )}
        </CardContent>
      )}
    </Card>
  )
}

[V0_FILE]typescriptreact:file="app/api/chat/route.ts" isEdit="true"
import { logger } from "@/lib/logger"
import { processWithReasoning } from "@/lib/reasoning"
import { enhanceWithPretraining } from "@/lib/pretraining"

export const runtime = "nodejs"

// Use the PPLX API key directly
const PPLX_API_KEY = "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"

export async function POST(req: Request) {
  try {
    // Parse the request body
    const { messages, systemPrompt = "", temperature = 0.2 } = await req.json()

// Validate messages
    if (!Array.isArray(messages)) {
      return new Response(JSON.stringify({ error: "Invalid messages format" }), {
        status: 400,
        headers: { "Content-Type": "application/json" },
      })
    }

// Get the last user message for preprocessing
    const lastUserMessage = messages.filter((m) => m.role === "user").pop()?.content || ""

// Process with reasoning
    const reasoningSteps = await processWithReasoning(lastUserMessage, messages)
    logger.info("Reasoning steps completed", { steps: reasoningSteps.length })

// Enhance with pretraining examples
    const enhancedMessages = await enhanceWithPretraining(messages, lastUserMessage)
    logger.info("Pretraining enhancement completed", {
      originalCount: messages.length,
      enhancedCount: enhancedMessages.length,
    })

// Prepare system message with reasoning context
    const reasoningContext = reasoningSteps.map((step) => `${step.description}: ${step.result}`).join("\n")

const enhancedSystemPrompt = `
You are Sentient-1, an advanced neural-symbolic AI assistant with contextual understanding and reasoning capabilities.
Be precise and concise.

I've analyzed this query with the following reasoning:
${reasoningContext}

Based on this analysis, provide a well-structured, accurate response.
`.trim()

// Prepare API request body exactly as specified
    const apiRequestBody = {
      model: "sonar",
      messages: [{ role: "system", content: enhancedSystemPrompt }, ...enhancedMessages],
      max_tokens: 1000,
      temperature: temperature,
      top_p: 0.9,
      top_k: 0,
      stream: false,
      presence_penalty: 0,
      frequency_penalty: 1,
    }

// Use Perplexity API with the direct API key
    const response = await fetch("https://api.perplexity.ai/chat/completions", {
      method: "POST",
      headers: {
        Authorization: `Bearer ${PPLX_API_KEY}`,
        "Content-Type": "application/json",
      },
      body: JSON.stringify(apiRequestBody),
    })

if (!response.ok) {
      const errorText = await response.text()
      logger.error("Perplexity API error", { status: response.status, error: errorText })
      throw new Error(`Perplexity API error: ${response.status} - ${errorText}`)
    }

const data = await response.json()

// Log the successful response
    logger.info("Successful API response", {
      model: "sonar",
      messageCount: enhancedMessages.length,
      responseLength: data.choices[0].message.content.length,
      pretrainingUsed: enhancedMessages.length > messages.length,
    })

return new Response(
      JSON.stringify({
        content: data.choices[0].message.content,
        role: "assistant",
        reasoning: reasoningSteps,
        pretrainingUsed: enhancedMessages.length > messages.length,
      }),
      { status: 200, headers: { "Content-Type": "application/json" } },
    )
  } catch (error) {
    logger.error("Error in chat API route", error)

// Return a graceful error response
    return new Response(
      JSON.stringify({
        error: "Something went wrong processing your request. Please try again.",
      }),
      { status: 500, headers: { "Content-Type": "application/json" } },
    )
  }
}
</article></body></html>

About

About