From 0dfdbc137ffad7375bbd128050c6581bc489495e Mon Sep 17 00:00:00 2001 From: pliny <133052465+elder-plinius@users.noreply.github.com> Date: Wed, 25 Mar 2026 11:52:38 -0700 Subject: [PATCH] Add files via upload --- ChatInput.tsx | 888 ++++++++++++++++ SettingsModal.tsx | 2536 +++++++++++++++++++++++++++++++++++++++++++++ TERMS.md | 30 +- dataset.ts | 231 +++++ 4 files changed, 3682 insertions(+), 3 deletions(-) create mode 100644 ChatInput.tsx create mode 100644 SettingsModal.tsx create mode 100644 dataset.ts diff --git a/ChatInput.tsx b/ChatInput.tsx new file mode 100644 index 0000000..173f498 --- /dev/null +++ b/ChatInput.tsx @@ -0,0 +1,888 @@ +'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. +
+ )} + +
+
+