api/routes/chat.ts

/**
 * Chat Completions API Route (Single-Model Pipeline)
 *
 * POST /v1/chat/completions
 *
 * The full G0DM0D3 single-model pipeline:
 * 1. GODMODE system prompt + Depth Directive injected (default: on)
 * 2. AutoTune analyzes the message and computes optimal parameters
 * 3. GODMODE parameter boost applied
 * 4. Parseltongue obfuscates trigger words in the user message (if enabled)
 * 5. Request is sent to the LLM via OpenRouter
 * 6. STM modules transform the response (if enabled)
 * 7. Returns the response + all engine metadata
 *
 * For multi-model racing, use POST /v1/ultraplinian/completions instead.
 *
 * Requires the caller to provide their own OpenRouter API key.
 */

import { Router } from 'express'
import { computeAutoTuneParams, type AutoTuneStrategy } from '../../src/lib/autotune'
import { applyParseltongue, type ParseltongueConfig } from '../../src/lib/parseltongue'
import { allModules, applySTMs, type STMModule } from '../../src/stm/modules'
import { sendMessage } from '../../src/lib/openrouter'
import { getSharedProfiles } from './autotune'
import { GODMODE_SYSTEM_PROMPT, DEPTH_DIRECTIVE, applyGodmodeBoost } from '../lib/ultraplinian'
import { addEntry } from '../lib/dataset'

export const chatRoutes = Router()

chatRoutes.post('/completions', async (req, res) => {
  try {
    const {
      messages,
      model = 'nousresearch/hermes-3-llama-3.1-70b',
      openrouter_api_key: caller_key,
      // GODMODE options (ON by default — this is G0DM0D3 after all)
      godmode = true,
      custom_system_prompt,
      // AutoTune options
      autotune = true,
      strategy = 'adaptive',
      // Parseltongue options
      parseltongue = true,
      parseltongue_technique = 'leetspeak',
      parseltongue_intensity = 'medium',
      // STM options
      stm_modules = ['hedge_reducer', 'direct_mode'],
      // Direct param overrides (bypass AutoTune)
      temperature,
      max_tokens = 4096,
      top_p,
      top_k,
      frequency_penalty,
      presence_penalty,
      repetition_penalty,
      // Dataset opt-in
      contribute_to_dataset = false,
    } = req.body

    // Validate required fields
    if (!messages || !Array.isArray(messages) || messages.length === 0) {
      res.status(400).json({ error: 'messages (array) is required and must not be empty' })
      return
    }

    // Resolve OpenRouter key: caller-provided > server-side env var
    const openrouter_api_key = caller_key || process.env.OPENROUTER_API_KEY || ''
    if (!openrouter_api_key) {
      res.status(400).json({
        error: 'No OpenRouter API key available. Either pass openrouter_api_key in the request body, or set OPENROUTER_API_KEY on the server. Get a key at https://openrouter.ai/keys',
      })
      return
    }

    // Normalize messages
    const normalizedMessages = messages.map((m: any) => ({
      role: m.role as 'system' | 'user' | 'assistant',
      content: String(m.content || ''),
    }))

    // Build the system prompt: GODMODE + Depth Directive (default) or custom
    const systemPrompt = godmode
      ? (custom_system_prompt || GODMODE_SYSTEM_PROMPT) + DEPTH_DIRECTIVE
      : custom_system_prompt || ''

    // Build final message array
    const allMessages = [
      ...(systemPrompt ? [{ role: 'system' as const, content: systemPrompt }] : []),
      ...normalizedMessages.filter(m => m.role !== 'system'),
    ]

    // Get the last user message for AutoTune analysis
    const lastUserMsg = [...normalizedMessages].reverse().find(m => m.role === 'user')
    const userContent = lastUserMsg?.content || ''

    // Build conversation history for AutoTune (excluding system messages)
    const conversationHistory = normalizedMessages
      .filter(m => m.role !== 'system')
      .map(m => ({ role: m.role, content: m.content }))

    // ── Step 1: AutoTune ──────────────────────────────────────────────
    let autotuneResult = null
    let finalParams: Record<string, number | undefined> = {
      temperature: temperature ?? 0.7,
      top_p,
      top_k,
      frequency_penalty,
      presence_penalty,
      repetition_penalty,
    }

    if (autotune && temperature === undefined) {
      autotuneResult = computeAutoTuneParams({
        strategy: strategy as AutoTuneStrategy,
        message: userContent,
        conversationHistory,
        overrides: {
          ...(top_p !== undefined && { top_p }),
          ...(top_k !== undefined && { top_k }),
          ...(frequency_penalty !== undefined && { frequency_penalty }),
          ...(presence_penalty !== undefined && { presence_penalty }),
          ...(repetition_penalty !== undefined && { repetition_penalty }),
        },
        learnedProfiles: getSharedProfiles(),
      })
      finalParams = {
        temperature: autotuneResult.params.temperature,
        top_p: autotuneResult.params.top_p,
        top_k: autotuneResult.params.top_k,
        frequency_penalty: autotuneResult.params.frequency_penalty,
        presence_penalty: autotuneResult.params.presence_penalty,
        repetition_penalty: autotuneResult.params.repetition_penalty,
      }
    }

    // Apply GODMODE boost
    if (godmode) {
      finalParams = applyGodmodeBoost(finalParams)
    }

    // ── Step 2: Parseltongue ──────────────────────────────────────────
    let parseltongueResult = null
    let processedMessages = allMessages

    if (parseltongue) {
      const ptConfig: ParseltongueConfig = {
        enabled: true,
        technique: parseltongue_technique,
        intensity: parseltongue_intensity,
        customTriggers: [],
      }

      processedMessages = allMessages.map(m => {
        if (m.role === 'user') {
          const result = applyParseltongue(m.content, ptConfig)
          if (!parseltongueResult && result.triggersFound.length > 0) {
            parseltongueResult = {
              triggers_found: result.triggersFound,
              technique_used: result.techniqueUsed,
              transformations_count: result.transformations.length,
            }
          }
          return { ...m, content: result.transformedText }
        }
        return m
      })
    }

    // ── Step 3: Send to LLM ──────────────────────────────────────────
    const response = await sendMessage({
      messages: processedMessages,
      model,
      apiKey: openrouter_api_key,
      temperature: finalParams.temperature,
      maxTokens: max_tokens,
      top_p: finalParams.top_p,
      top_k: finalParams.top_k,
      frequency_penalty: finalParams.frequency_penalty,
      presence_penalty: finalParams.presence_penalty,
      repetition_penalty: finalParams.repetition_penalty,
    })

    // ── Step 4: STM transforms ───────────────────────────────────────
    let stmResult = null
    let finalResponse = response

    if (stm_modules && Array.isArray(stm_modules) && stm_modules.length > 0) {
      const enabledModules: STMModule[] = allModules.map(m => ({
        ...m,
        enabled: stm_modules.includes(m.id),
      }))
      finalResponse = applySTMs(response, enabledModules)
      stmResult = {
        modules_applied: stm_modules,
        original_length: response.length,
        transformed_length: finalResponse.length,
      }
    }

    // ── Dataset collection (opt-in) ──────────────────────────────────
    let datasetId: string | null = null
    if (contribute_to_dataset) {
      datasetId = addEntry({
        endpoint: '/v1/chat/completions',
        model,
        mode: 'standard',
        messages: normalizedMessages.filter(m => m.role !== 'system'),
        response: finalResponse,
        autotune: autotuneResult
          ? {
              strategy,
              detected_context: autotuneResult.detectedContext,
              confidence: autotuneResult.confidence,
              params: autotuneResult.params,
              reasoning: autotuneResult.reasoning,
            }
          : undefined,
        parseltongue: parseltongueResult || undefined,
        stm: stmResult ? { modules_applied: stmResult.modules_applied } : undefined,
      })
    }

    // ── Build response ───────────────────────────────────────────────
    res.json({
      response: finalResponse,
      model,
      params_used: finalParams,
      pipeline: {
        godmode,
        autotune: autotuneResult
          ? {
              detected_context: autotuneResult.detectedContext,
              confidence: autotuneResult.confidence,
              reasoning: autotuneResult.reasoning,
              strategy,
            }
          : null,
        parseltongue: parseltongueResult,
        stm: stmResult,
      },
      dataset: contribute_to_dataset
        ? { contributed: true, entry_id: datasetId }
        : { contributed: false },
    })
  } catch (err: any) {
    const status = err.message?.includes('API error') ? 502 : 500
    res.status(status).json({ error: err.message })
  }
})