'use client' import { useState, useRef, useEffect, KeyboardEvent } from 'react' import { useStore } from '@/store' import { sendMessage, sendMessageViaProxy, streamUltraplinian, streamConsortium } from '@/lib/openrouter' import { recordChatEvent } from '@/lib/telemetry' import { classifyPrompt } from '@/lib/classify' import { classifyWithLLM } from '@/lib/classify-llm' import type { ClassificationResult } from '@/lib/classify' import { computeAutoTuneParams, getContextLabel, getStrategyLabel, PARAM_META } from '@/lib/autotune' import type { AutoTuneResult } from '@/lib/autotune' import { applyParseltongue, detectTriggers } from '@/lib/parseltongue' import { Send, Loader2, StopCircle, SlidersHorizontal, AlertTriangle } from 'lucide-react' export function ChatInput() { const { currentConversationId, currentConversation, addMessage, updateMessageContent, apiKey, isStreaming, setIsStreaming, personas, stmModules, noLogMode, autoTuneEnabled, autoTuneStrategy, autoTuneOverrides, autoTuneLastResult, setAutoTuneLastResult, feedbackState, memories, memoriesEnabled, parseltongueConfig, customSystemPrompt, useCustomSystemPrompt, // Liquid Response (universal) liquidResponseEnabled, liquidMinDelta, incrementPromptsTried, // ULTRAPLINIAN ultraplinianEnabled, ultraplinianTier, ultraplinianApiUrl, ultraplinianApiKey, ultraplinianRacing, ultraplinianModelsResponded, ultraplinianModelsTotal, ultraplinianLiveModel, ultraplinianLiveScore, setUltraplinianLive, setUltraplinianProgress, setUltraplinianRacing, resetUltraplinianRace, // Privacy datasetGenerationEnabled, // CONSORTIUM consortiumEnabled, consortiumTier, consortiumPhase, consortiumModelsCollected, consortiumModelsTotal, setConsortiumPhase, setConsortiumProgress, resetConsortium, } = useStore() const [input, setInput] = useState('') const [showTuneDetails, setShowTuneDetails] = useState(false) const [parseltonguePreview, setParseltonguePreview] = useState<{ triggersFound: string[] transformed: boolean } | null>(null) const textareaRef = useRef(null) const abortControllerRef = useRef(null) // Auto-resize textarea useEffect(() => { if (textareaRef.current) { textareaRef.current.style.height = 'auto' textareaRef.current.style.height = `${Math.min(textareaRef.current.scrollHeight, 200)}px` } }, [input]) // Live preview: compute autotune params as user types (debounced) const [livePreview, setLivePreview] = useState(null) useEffect(() => { if (!autoTuneEnabled || !input.trim()) { setLivePreview(null) return } const timer = setTimeout(() => { const persona = personas.find(p => p.id === currentConversation?.persona) || personas[0] const history = (currentConversation?.messages || []).map(m => ({ role: m.role, content: m.content })) const result = computeAutoTuneParams({ strategy: autoTuneStrategy, message: input.trim(), conversationHistory: history, overrides: autoTuneOverrides, learnedProfiles: feedbackState.learnedProfiles }) setLivePreview(result) }, 300) return () => clearTimeout(timer) }, [input, autoTuneEnabled, autoTuneStrategy, autoTuneOverrides, currentConversation, personas, feedbackState]) // Live preview: detect triggers as user types (debounced) useEffect(() => { if (!parseltongueConfig.enabled || !input.trim()) { setParseltonguePreview(null) return } const timer = setTimeout(() => { const triggers = detectTriggers(input.trim(), parseltongueConfig.customTriggers) if (triggers.length > 0) { setParseltonguePreview({ triggersFound: triggers, transformed: true }) } else { setParseltonguePreview(null) } }, 200) return () => clearTimeout(timer) }, [input, parseltongueConfig]) // Proxy mode: when no personal OpenRouter key, route through self-hosted API const proxyMode = !apiKey && !!ultraplinianApiUrl && !!ultraplinianApiKey const handleSubmit = async () => { if (!input.trim() || !currentConversationId || isStreaming) return if (!apiKey && !proxyMode) return const originalMessage = input.trim() setInput('') setIsStreaming(true) incrementPromptsTried() // Apply parseltongue obfuscation if enabled const parseltongueResult = applyParseltongue(originalMessage, parseltongueConfig) const userMessage = parseltongueResult.transformedText // Add user message (show original to user, send transformed to API) addMessage(currentConversationId, { role: 'user', content: originalMessage // Show original message in UI }) // Get persona and model const persona = personas.find(p => p.id === currentConversation?.persona) || personas[0] const model = currentConversation?.model || 'anthropic/claude-3-opus' // Build memory context if enabled const activeMemories = memoriesEnabled ? memories.filter(m => m.active) : [] let memoryContext = '' if (activeMemories.length > 0) { const facts = activeMemories.filter(m => m.type === 'fact') const preferences = activeMemories.filter(m => m.type === 'preference') const instructions = activeMemories.filter(m => m.type === 'instruction') memoryContext = '\n\n\n' if (facts.length > 0) { memoryContext += '## About the User\n' facts.forEach(f => { memoryContext += `- ${f.content}\n` }) } if (preferences.length > 0) { memoryContext += '\n## User Preferences\n' preferences.forEach(p => { memoryContext += `- ${p.content}\n` }) } if (instructions.length > 0) { memoryContext += '\n## Always Follow\n' instructions.forEach(i => { memoryContext += `- ${i.content}\n` }) } memoryContext += '\n' } // Build system prompt with GODMODE prompt + memory const basePrompt = useCustomSystemPrompt ? customSystemPrompt : (persona.systemPrompt || persona.coreDirective || '') const systemPrompt = basePrompt + memoryContext // Build messages array const messages = [ // System prompt from persona + memory ...(systemPrompt ? [{ role: 'system' as const, content: systemPrompt }] : []), // Conversation history ...((currentConversation?.messages || []).map(m => ({ role: m.role as 'user' | 'assistant', content: m.content }))), // New user message { role: 'user' as const, content: userMessage } ] // Classify prompt for research telemetry // Regex runs instantly as fallback; LLM classifier fires in parallel // with the main model call and overwrites with a more accurate result. let promptClassification: ClassificationResult = classifyPrompt(userMessage) const llmClassifyPromise = apiKey ? classifyWithLLM(userMessage, apiKey).then(result => { promptClassification = result }) : Promise.resolve() // Compute AutoTune parameters if enabled let tuneResult: AutoTuneResult | null = null if (autoTuneEnabled) { const history = (currentConversation?.messages || []).map(m => ({ role: m.role, content: m.content })) tuneResult = computeAutoTuneParams({ strategy: autoTuneStrategy, message: userMessage, conversationHistory: history, overrides: autoTuneOverrides, learnedProfiles: feedbackState.learnedProfiles }) setAutoTuneLastResult(tuneResult) } try { abortControllerRef.current = new AbortController() // ── CONSORTIUM PATH: Hive-mind synthesis ────────────────────── if (consortiumEnabled && ultraplinianApiUrl && ultraplinianApiKey && !ultraplinianEnabled) { const assistantMsgId = addMessage(currentConversationId, { role: 'assistant', content: '', model: 'consortium', persona: persona.id, }) setConsortiumPhase('collecting') resetConsortium() await streamConsortium( { messages, openrouterApiKey: apiKey, apiBaseUrl: ultraplinianApiUrl, godmodeApiKey: ultraplinianApiKey, tier: consortiumTier, stm_modules: stmModules.filter(m => m.enabled).map(m => m.id), liquid: liquidResponseEnabled, liquid_min_delta: liquidMinDelta, signal: abortControllerRef.current.signal, }, { onStart: (data) => { setConsortiumProgress(0, data.models_queried) updateMessageContent(currentConversationId, assistantMsgId, `*Collecting from ${data.models_queried} models...*`) }, onModelResult: (data) => { setConsortiumProgress(data.models_collected, data.models_total) // Only update with progress text if liquid hasn't already shown real content if (!liquidResponseEnabled) { updateMessageContent(currentConversationId, assistantMsgId, `*Collecting responses... ${data.models_collected}/${data.models_total} models*`) } }, onBestResponse: (data) => { // Liquid response: show best individual model response while collecting updateMessageContent(currentConversationId, assistantMsgId, data.content, { model: `${data.model} (${data.score}pts — synthesizing...)`, }) }, onSynthesisStart: (data) => { setConsortiumPhase('synthesizing') if (!liquidResponseEnabled) { updateMessageContent(currentConversationId, assistantMsgId, `*${data.responses_collected} models collected. Orchestrator synthesizing ground truth...*`) } }, onComplete: (data) => { const finalContent = data.synthesis || '' const orchModel = data.orchestrator?.model || 'consortium' setConsortiumPhase('done') updateMessageContent(currentConversationId, assistantMsgId, finalContent, { model: `consortium (${orchModel})`, ...(tuneResult ? { autoTuneParams: tuneResult.params, autoTuneContext: tuneResult.detectedContext, autoTuneContextScores: tuneResult.contextScores, autoTunePatternMatches: tuneResult.patternMatches, autoTuneDeltas: tuneResult.paramDeltas, } : {}), }) }, onError: (error) => { updateMessageContent(currentConversationId, assistantMsgId, `CONSORTIUM error: ${error}`) setConsortiumPhase('idle') }, }, ) setIsStreaming(false) setConsortiumPhase('idle') return } // ── ULTRAPLINIAN PATH: Multi-model race with liquid response ── if (ultraplinianEnabled && ultraplinianApiUrl && ultraplinianApiKey) { // Add placeholder assistant message that we'll update live const assistantMsgId = addMessage(currentConversationId, { role: 'assistant', content: '', model: 'ultraplinian', persona: persona.id, }) setUltraplinianRacing(true) resetUltraplinianRace() // Collect all race responses for browsing later const collectedResponses: Array<{ model: string; content: string; score: number; duration_ms: number }> = [] await streamUltraplinian( { messages, openrouterApiKey: apiKey, apiBaseUrl: ultraplinianApiUrl, godmodeApiKey: ultraplinianApiKey, tier: ultraplinianTier, stm_modules: stmModules.filter(m => m.enabled).map(m => m.id), liquid: liquidResponseEnabled, liquid_min_delta: liquidMinDelta, signal: abortControllerRef.current.signal, }, { onRaceStart: (data) => { setUltraplinianProgress(0, data.models_queried) updateMessageContent(currentConversationId, assistantMsgId, `*Racing ${data.models_queried} models...*`) }, onModelResult: (data) => { setUltraplinianProgress(data.models_responded, data.models_total) }, onLeaderChange: (data) => { // Collect each leader response for later browsing collectedResponses.push({ model: data.model, content: data.content, score: data.score, duration_ms: data.duration_ms, }) setUltraplinianLive(data.content, data.model, data.score) updateMessageContent(currentConversationId, assistantMsgId, data.content, { model: data.model, }) }, onComplete: async (data) => { const finalContent = data.response || '' const winnerModel = data.winner?.model || 'ultraplinian' // Build full race responses from rankings (backend now includes content) const rankingResponses = (data.race?.rankings ?? []) .filter(r => r.success && r.content) .map(r => ({ model: r.model, content: r.content!, score: r.score, duration_ms: r.duration_ms, isWinner: r.model === winnerModel, })) .sort((a, b) => b.score - a.score) // Fall back to collected leader changes if rankings lack content const raceResponses = rankingResponses.length > 0 ? rankingResponses : collectedResponses.map(r => ({ ...r, isWinner: r.model === winnerModel, })) updateMessageContent(currentConversationId, assistantMsgId, finalContent, { model: winnerModel, raceResponses: raceResponses.length > 1 ? raceResponses : undefined, ...(tuneResult ? { autoTuneParams: tuneResult.params, autoTuneContext: tuneResult.detectedContext, autoTuneContextScores: tuneResult.contextScores, autoTunePatternMatches: tuneResult.patternMatches, autoTuneDeltas: tuneResult.paramDeltas, } : {}), }) resetUltraplinianRace() // Wait for LLM classification to land (usually already resolved) await llmClassifyPromise // Beacon metadata to HF dataset (fire-and-forget, no content) recordChatEvent({ mode: 'ultraplinian', model: winnerModel, duration_ms: data.race?.total_duration_ms || 0, response_length: finalContent.length, success: true, pipeline: { autotune: autoTuneEnabled, parseltongue: parseltongueConfig.enabled, stm_modules: stmModules.filter(m => m.enabled).map(m => m.id), strategy: autoTuneStrategy, godmode: true, }, ...(tuneResult ? { autotune: { detected_context: tuneResult.detectedContext, confidence: tuneResult.confidence, }, } : {}), parseltongue: parseltongueConfig.enabled ? { triggers_found: parseltongueResult.triggersFound.length, technique: parseltongueConfig.technique, intensity: parseltongueConfig.intensity, } : undefined, ultraplinian: { tier: ultraplinianTier, models_queried: data.race?.models_queried || 0, models_succeeded: data.race?.models_succeeded || 0, winner_model: winnerModel, winner_score: data.winner?.score || 0, total_duration_ms: data.race?.total_duration_ms || 0, }, classification: promptClassification, persona: persona.id, prompt_length: originalMessage.length, conversation_depth: currentConversation?.messages?.length || 0, memory_count: activeMemories.length, no_log: noLogMode, parseltongue_transformed: parseltongueResult.triggersFound.length > 0, }) }, onError: (error) => { updateMessageContent(currentConversationId, assistantMsgId, `**ULTRAPLINIAN Error:** ${error}`) resetUltraplinianRace() }, }, ) } else { // ── STANDARD PATH: Single model ──────────────────────────── const startTime = Date.now() const response = proxyMode ? await sendMessageViaProxy({ messages, model, apiBaseUrl: ultraplinianApiUrl, godmodeApiKey: ultraplinianApiKey, signal: abortControllerRef.current.signal, stm_modules: stmModules.filter(m => m.enabled).map(m => m.id), ...(tuneResult ? { temperature: tuneResult.params.temperature, top_p: tuneResult.params.top_p, top_k: tuneResult.params.top_k, frequency_penalty: tuneResult.params.frequency_penalty, presence_penalty: tuneResult.params.presence_penalty, repetition_penalty: tuneResult.params.repetition_penalty, } : {}), }) : await sendMessage({ messages, model, apiKey, noLog: noLogMode, signal: abortControllerRef.current.signal, ...(tuneResult ? { temperature: tuneResult.params.temperature, top_p: tuneResult.params.top_p, top_k: tuneResult.params.top_k, frequency_penalty: tuneResult.params.frequency_penalty, presence_penalty: tuneResult.params.presence_penalty, repetition_penalty: tuneResult.params.repetition_penalty } : {}) }) const durationMs = Date.now() - startTime // Apply STM transformations let transformedResponse = response for (const stm of stmModules) { if (stm.enabled) { transformedResponse = stm.transformer(transformedResponse) } } addMessage(currentConversationId, { role: 'assistant', content: transformedResponse, model, persona: persona.id, ...(tuneResult ? { autoTuneParams: tuneResult.params, autoTuneContext: tuneResult.detectedContext, autoTuneContextScores: tuneResult.contextScores, autoTunePatternMatches: tuneResult.patternMatches, autoTuneDeltas: tuneResult.paramDeltas } : {}) }) // Wait for LLM classification to land (usually already resolved) await llmClassifyPromise // Beacon metadata to HF dataset (fire-and-forget, no content) recordChatEvent({ mode: 'standard', model, duration_ms: durationMs, response_length: transformedResponse.length, success: true, pipeline: { autotune: autoTuneEnabled, parseltongue: parseltongueConfig.enabled, stm_modules: stmModules.filter(m => m.enabled).map(m => m.id), strategy: autoTuneStrategy, godmode: useCustomSystemPrompt, }, ...(tuneResult ? { autotune: { detected_context: tuneResult.detectedContext, confidence: tuneResult.confidence, }, } : {}), parseltongue: parseltongueConfig.enabled ? { triggers_found: parseltongueResult.triggersFound.length, technique: parseltongueConfig.technique, intensity: parseltongueConfig.intensity, } : undefined, classification: promptClassification, persona: persona.id, prompt_length: originalMessage.length, conversation_depth: currentConversation?.messages?.length || 0, memory_count: activeMemories.length, no_log: noLogMode, parseltongue_transformed: parseltongueResult.triggersFound.length > 0, }) } } catch (error: any) { resetUltraplinianRace() if (error.name === 'AbortError') { addMessage(currentConversationId, { role: 'assistant', content: '_[Response stopped by user]_', model, persona: persona.id }) recordChatEvent({ mode: ultraplinianEnabled ? 'ultraplinian' : 'standard', model, duration_ms: 0, response_length: 0, success: false, error_type: 'abort', pipeline: { autotune: autoTuneEnabled, parseltongue: parseltongueConfig.enabled, stm_modules: stmModules.filter(m => m.enabled).map(m => m.id), strategy: autoTuneStrategy, godmode: useCustomSystemPrompt, }, classification: promptClassification, persona: persona.id, prompt_length: originalMessage.length, conversation_depth: currentConversation?.messages?.length || 0, memory_count: activeMemories.length, no_log: noLogMode, parseltongue_transformed: parseltongueResult.triggersFound.length > 0, }) } else { console.error('Error sending message:', error) const errMsg = error.message || 'Failed to get response. Check your API key in Settings and try again.' const errLower = errMsg.toLowerCase() const errorType = errLower.includes('api key') || errLower.includes('expired') || errLower.includes('denied') || errLower.includes('permission') ? 'auth' : errLower.includes('rate limit') || errLower.includes('wait') ? 'rate_limit' : errLower.includes('timeout') || errLower.includes('timed out') ? 'timeout' : errLower.includes('unavailable') || errLower.includes('overloaded') ? 'model_error' : errLower.includes('credit') || errLower.includes('insufficient') ? 'billing' : 'unknown' addMessage(currentConversationId, { role: 'assistant', content: `**Error:** ${errMsg}`, model, persona: persona.id }) recordChatEvent({ mode: ultraplinianEnabled ? 'ultraplinian' : 'standard', model, duration_ms: 0, response_length: 0, success: false, error_type: errorType, pipeline: { autotune: autoTuneEnabled, parseltongue: parseltongueConfig.enabled, stm_modules: stmModules.filter(m => m.enabled).map(m => m.id), strategy: autoTuneStrategy, godmode: useCustomSystemPrompt, }, classification: promptClassification, persona: persona.id, prompt_length: originalMessage.length, conversation_depth: currentConversation?.messages?.length || 0, memory_count: activeMemories.length, no_log: noLogMode, parseltongue_transformed: parseltongueResult.triggersFound.length > 0, }) } } finally { setIsStreaming(false) setUltraplinianRacing(false) abortControllerRef.current = null } } const handleStop = () => { if (abortControllerRef.current) { abortControllerRef.current.abort() } } const handleKeyDown = (e: KeyboardEvent) => { if (e.key === 'Enter' && !e.shiftKey) { e.preventDefault() handleSubmit() } } // Determine which result to show (live preview while typing, last result after send) const displayResult = livePreview || autoTuneLastResult // Count active memories for display const activeMemoryCount = memoriesEnabled ? memories.filter(m => m.active).length : 0 return (
{/* AutoTune live parameter display */} {autoTuneEnabled && displayResult && showTuneDetails && (
{/* Header */}
AUTOTUNE {autoTuneStrategy === 'adaptive' ? `// ${getContextLabel(displayResult.detectedContext)} (${Math.round(displayResult.confidence * 100)}%)` : `// ${getStrategyLabel(autoTuneStrategy)}` }
{/* Context Competition - show all context scores */} {displayResult.contextScores && displayResult.contextScores.length > 1 && (
CONTEXT: {displayResult.contextScores .filter(s => s.percentage > 0) .slice(0, 4) .map((s, i) => ( {i > 0 && >} {getContextLabel(s.type)} {s.percentage}% ))}
)} {/* Pattern Match Reasoning - why this context was detected */} {displayResult.patternMatches && displayResult.patternMatches.length > 0 && (
MATCHED: {displayResult.patternMatches .slice(0, 3) .map(p => p.pattern) .join(' | ')} {displayResult.patternMatches.length > 3 && ` +${displayResult.patternMatches.length - 3} more`}
)} {/* Parameter Grid with Deltas */}
{(Object.entries(displayResult.params) as [keyof typeof PARAM_META, number][]).map( ([key, value]) => { // Find if there's a delta for this param const delta = displayResult.paramDeltas?.find(d => d.param === key) const hasDelta = delta && Math.abs(delta.delta) > 0.001 return (
{PARAM_META[key].short}
{typeof value === 'number' ? value.toFixed(2) : value}
{hasDelta && (
0 ? 'text-green-400' : 'text-red-400'}`}> {delta.delta > 0 ? '+' : ''}{delta.delta.toFixed(2)}
)}
) } )}
{/* Delta Explanations - what changed and why */} {displayResult.paramDeltas && displayResult.paramDeltas.length > 0 && (
TUNING: {displayResult.paramDeltas.slice(0, 4).map((d, i) => (
{PARAM_META[d.param].short} {d.before.toFixed(2)} → {d.after.toFixed(2)} 0 ? 'text-green-400' : 'text-red-400'}> ({d.delta > 0 ? '+' : ''}{d.delta.toFixed(2)}) {d.reason}
))} {displayResult.paramDeltas.length > 4 && (
+{displayResult.paramDeltas.length - 4} more adjustments
)}
)}
)} {/* Dataset Mode Warning Badge */} {datasetGenerationEnabled && (
DATASET MODE — your prompts are being collected for public research. Avoid sharing personal info.
)}