Skip to content

LIBERATED AI CHAT

TypeScript
23.4 KB
Raw Blame
/**
 * CONSORTIUM API Route — The Hive Mind Endpoint
 *
 * POST /v1/consortium/completions
 *
 * Queries N models in parallel, collects ALL responses, then feeds them to a
 * strong orchestrator model that synthesizes ground truth from collective intelligence.
 *
 * Unlike ULTRAPLINIAN (pick-the-winner), CONSORTIUM blends insights from every model
 * into a single response that's more grounded than any individual output.
 *
 * Pipeline:
 * 1. GODMODE prompt + Depth Directive injected (pipeline runs like ULTRAPLINIAN)
 * 2. All models queried in parallel — wait for ALL (not early-exit)
 * 3. Responses scored on substance/directness/completeness
 * 4. All responses + user query fed to orchestrator model
 * 5. Orchestrator synthesizes definitive ground-truth response
 * 6. STM modules applied to synthesis
 * 7. Full provenance metadata returned
 *
 * STREAMING MODE (stream=true, default):
 * - Phase 1: SSE events as each model responds (consortium:model)
 * - Phase 2: Orchestrator synthesis streamed live (consortium:synthesis:delta)
 * - Phase 3: Final metadata (consortium:complete)
 */

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 { getSharedProfiles } from './autotune'
import {
  GODMODE_SYSTEM_PROMPT,
  DEPTH_DIRECTIVE,
  getModelsForTier,
  scoreResponse,
  applyGodmodeBoost,
  queryModel,
  type SpeedTier,
  type ModelResult,
} from '../lib/ultraplinian'
import {
  collectAllResponses,
  synthesize,
  ORCHESTRATOR_MODELS,
  CONSORTIUM_SYSTEM_PROMPT,
  type OrchestratorModel,
  type ConsortiumResponse,
} from '../lib/consortium'
import { addEntry } from '../lib/dataset'
import { recordEvent, categorizeError } from '../lib/metadata'

export const consortiumRoutes = Router()

consortiumRoutes.post('/completions', async (req, res) => {
  const startTime = Date.now()

  try {
    const {
      messages,
      openrouter_api_key: caller_key,
      // Consortium options
      tier = 'fast' as SpeedTier,
      orchestrator_model,        // Optional: override orchestrator (default: claude-sonnet-4)
      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'],
      // Param overrides
      temperature,
      max_tokens = 4096,
      top_p,
      top_k,
      frequency_penalty,
      presence_penalty,
      repetition_penalty,
      // Streaming
      stream = true,
      // Liquid response: serve best individual response during collection, morph on synthesis
      liquid = true,
      liquid_min_delta = 8,
      // Dataset opt-in
      contribute_to_dataset = false,
    } = req.body

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

    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.',
      })
      return
    }

    const validTiers: SpeedTier[] = ['fast', 'standard', 'smart', 'power', 'ultra']
    if (!validTiers.includes(tier)) {
      res.status(400).json({ error: `Invalid tier. Must be one of: ${validTiers.join(', ')}` })
      return
    }

    // Validate orchestrator model if specified
    const resolvedOrchestrator: OrchestratorModel = orchestrator_model || ORCHESTRATOR_MODELS[0]

    // ── Tier-based access control ─────────────────────────────────────
    const tierConfig = req.tierConfig
    if (tierConfig && !tierConfig.ultraplinianTiers.includes(tier)) {
      const currentTier = req.tier || 'free'
      res.status(403).json({
        error: 'Upgrade required',
        message: `The "${tier}" CONSORTIUM tier requires a higher plan. Your "${currentTier}" plan allows: ${tierConfig.ultraplinianTiers.join(', ')}.`,
        current_tier: currentTier,
        allowed_tiers: tierConfig.ultraplinianTiers,
        requested_tier: tier,
      })
      return
    }

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

    const lastUserMsg = [...normalizedMessages].reverse().find(m => m.role === 'user')
    const userContent = lastUserMsg?.content || ''

    const systemPrompt = godmode
      ? (custom_system_prompt || GODMODE_SYSTEM_PROMPT) + DEPTH_DIRECTIVE
      : custom_system_prompt || ''

    const baseMessages = [
      ...(systemPrompt ? [{ role: 'system' as const, content: systemPrompt }] : []),
      ...normalizedMessages.filter(m => m.role !== 'system'),
    ]

    // ── AutoTune ──────────────────────────────────────────────────────
    const conversationHistory = normalizedMessages
      .filter(m => m.role !== 'system')
      .map(m => m.content)
      .join('\n')

    let autotuneResult: any = null
    let computedParams: Record<string, number | undefined> = {
      temperature, top_p, top_k,
      frequency_penalty, presence_penalty, repetition_penalty,
    }

    if (autotune) {
      const validStrategy = ['adaptive', 'precise', 'balanced', 'creative', 'chaotic'].includes(strategy)
        ? strategy as AutoTuneStrategy
        : 'adaptive' as AutoTuneStrategy

      autotuneResult = computeAutoTuneParams(
        userContent,
        conversationHistory,
        validStrategy,
        getSharedProfiles(),
      )

      computedParams = {
        temperature: temperature ?? autotuneResult.params.temperature,
        top_p: top_p ?? autotuneResult.params.top_p,
        top_k: top_k ?? autotuneResult.params.top_k,
        frequency_penalty: frequency_penalty ?? autotuneResult.params.frequency_penalty,
        presence_penalty: presence_penalty ?? autotuneResult.params.presence_penalty,
        repetition_penalty: repetition_penalty ?? autotuneResult.params.repetition_penalty,
      }
    }

    // ── GODMODE Boost ─────────────────────────────────────────────────
    const finalParams = godmode
      ? applyGodmodeBoost(computedParams)
      : computedParams

    // ── Parseltongue ──────────────────────────────────────────────────
    let parseltongueResult: any = null
    let processedMessages = baseMessages

    if (parseltongue) {
      const config: ParseltongueConfig = {
        enabled: true,
        technique: parseltongue_technique,
        intensity: parseltongue_intensity,
        customTriggers: [],
      }
      const transformed = applyParseltongue(userContent, config)
      if (transformed.transformed) {
        parseltongueResult = {
          triggers_found: transformed.triggersFound,
          technique_used: parseltongue_technique,
          transformations_count: transformed.triggersFound.length,
        }
        processedMessages = baseMessages.map(m => {
          if (m.content === userContent) {
            return { ...m, content: transformed.text }
          }
          return m
        })
      }
    }

    // ── Get models for tier ───────────────────────────────────────────
    const raceModelsArray = getModelsForTier(tier)
    const maxModels = tierConfig?.maxRaceModels ?? raceModelsArray.length
    const models = raceModelsArray.slice(0, maxModels)

    const queryParams = {
      temperature: finalParams.temperature ?? 0.7,
      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,
    }

    // ══════════════════════════════════════════════════════════════════
    // STREAMING PATH
    // ══════════════════════════════════════════════════════════════════
    if (stream) {
      res.writeHead(200, {
        'Content-Type': 'text/event-stream',
        'Cache-Control': 'no-cache',
        'Connection': 'keep-alive',
        'X-Accel-Buffering': 'no',
      })

      const sse = (event: string, data: any) => {
        res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`)
      }

      // Phase 1: Collection
      sse('consortium:start', {
        tier,
        models_queried: models.length,
        orchestrator: resolvedOrchestrator,
        phase: 'collection',
      })

      const collectedResults: ModelResult[] = []
      let successCount = 0

      // Liquid response: track best individual response during collection
      const minDelta = Math.max(1, Math.min(50, Number(liquid_min_delta) || 8))
      let currentBest: { model: string; content: string; score: number; duration_ms: number } | null = null
      let liquidUpgrades = 0

      const results = await collectAllResponses(
        models,
        processedMessages,
        openrouter_api_key,
        queryParams,
        {
          minResponses: Math.min(3, models.length),
          hardTimeout: 60000,
          onModelResult: (result, collected, total) => {
            const score = result.success ? scoreResponse(result.content, userContent) : 0
            result.score = score
            if (result.success) successCount++

            sse('consortium:model', {
              model: result.model,
              score,
              duration_ms: result.duration_ms,
              success: result.success,
              error: result.error || undefined,
              content_length: result.content?.length || 0,
              models_collected: collected,
              models_total: total,
            })

            // Liquid response: emit leader event when a new best arrives
            if (liquid && result.success && result.content) {
              const currentScore = currentBest?.score ?? 0
              const isFirst = !currentBest
              const beatsByThreshold = score >= currentScore + minDelta

              if (isFirst ? score > 0 : beatsByThreshold) {
                // Apply STM to leader content
                let leaderContent = result.content
                if (stm_modules && Array.isArray(stm_modules) && stm_modules.length > 0) {
                  const enabledModules: STMModule[] = allModules.map(m => ({
                    ...m,
                    enabled: stm_modules.includes(m.id),
                  }))
                  leaderContent = applySTMs(result.content, enabledModules)
                }

                currentBest = { model: result.model, content: leaderContent, score, duration_ms: result.duration_ms }
                liquidUpgrades++

                sse('consortium:leader', {
                  model: result.model,
                  score,
                  delta: isFirst ? null : score - currentScore,
                  duration_ms: result.duration_ms,
                  content: leaderContent,
                  upgrade_number: liquidUpgrades,
                })
              }
            }
          },
        },
      )

      // Score all collected results
      const scoredResponses: ConsortiumResponse[] = results.map(r => ({
        model: r.model,
        content: r.content,
        score: r.success ? scoreResponse(r.content, userContent) : 0,
        duration_ms: r.duration_ms,
        success: r.success,
        error: r.error,
      }))
      scoredResponses.sort((a, b) => b.score - a.score)

      const collectionDuration = Date.now() - startTime
      const totalSucceeded = scoredResponses.filter(r => r.success).length

      if (totalSucceeded === 0) {
        sse('consortium:error', { error: 'All models failed during collection phase' })
        res.end()
        return
      }

      // Phase 2: Synthesis
      sse('consortium:synthesis:start', {
        phase: 'synthesis',
        orchestrator: resolvedOrchestrator,
        responses_collected: totalSucceeded,
        collection_duration_ms: collectionDuration,
      })

      // Run orchestrator
      let synthesisResult: { synthesis: string; duration_ms: number; model: string }
      try {
        synthesisResult = await synthesize(
          userContent,
          scoredResponses,
          openrouter_api_key,
          resolvedOrchestrator,
          max_tokens,
        )
      } catch (err: any) {
        sse('consortium:error', { error: `Orchestrator failed: ${err.message}` })
        res.end()
        return
      }

      // Apply STM to synthesis
      let finalResponse = synthesisResult.synthesis
      let stmResult = null

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

      const totalDuration = Date.now() - startTime

      // Dataset collection
      let datasetId: string | null = null
      if (contribute_to_dataset) {
        datasetId = addEntry({
          endpoint: '/v1/consortium/completions',
          model: resolvedOrchestrator,
          mode: 'consortium',
          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,
          ultraplinian: { tier, models_queried: models, winner_model: resolvedOrchestrator, all_scores: scoredResponses.map(r => ({ model: r.model, score: r.score, duration_ms: r.duration_ms, success: r.success })), total_duration_ms: totalDuration },
        })
      }

      // Phase 3: Complete
      sse('consortium:complete', {
        synthesis: finalResponse,
        orchestrator: {
          model: synthesisResult.model,
          duration_ms: synthesisResult.duration_ms,
        },
        collection: {
          tier,
          models_queried: models.length,
          models_succeeded: totalSucceeded,
          collection_duration_ms: collectionDuration,
          total_duration_ms: totalDuration,
          responses: scoredResponses.map(r => ({
            model: r.model,
            score: r.score,
            duration_ms: r.duration_ms,
            success: r.success,
            error: r.error || undefined,
            content_length: r.content?.length || 0,
          })),
        },
        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 },
      })

      // ZDR Metadata
      recordEvent({
        endpoint: '/v1/consortium/completions',
        mode: 'consortium',
        tier,
        stream: true,
        pipeline: {
          godmode,
          autotune: !!autotuneResult,
          parseltongue: !!parseltongueResult,
          stm_modules: stm_modules || [],
          strategy,
        },
        autotune: autotuneResult
          ? { detected_context: autotuneResult.detectedContext, confidence: autotuneResult.confidence }
          : undefined,
        models_queried: models.length,
        models_succeeded: totalSucceeded,
        model_results: scoredResponses.map(r => ({
          model: r.model, score: r.score, duration_ms: r.duration_ms,
          success: r.success, content_length: r.content?.length || 0,
          error_type: categorizeError(r.error),
        })),
        winner: { model: resolvedOrchestrator, score: 0, duration_ms: synthesisResult.duration_ms, content_length: finalResponse.length },
        total_duration_ms: totalDuration,
        response_length: finalResponse.length,
      })

      res.end()
      return
    }

    // ══════════════════════════════════════════════════════════════════
    // NON-STREAMING PATH
    // ══════════════════════════════════════════════════════════════════
    const results = await collectAllResponses(
      models,
      processedMessages,
      openrouter_api_key,
      queryParams,
      {
        minResponses: Math.min(3, models.length),
        hardTimeout: 60000,
      },
    )

    const collectionDuration = Date.now() - startTime

    const scoredResponses: ConsortiumResponse[] = results.map(r => ({
      model: r.model,
      content: r.content,
      score: r.success ? scoreResponse(r.content, userContent) : 0,
      duration_ms: r.duration_ms,
      success: r.success,
      error: r.error,
    }))
    scoredResponses.sort((a, b) => b.score - a.score)

    const totalSucceeded = scoredResponses.filter(r => r.success).length

    if (totalSucceeded === 0) {
      res.status(502).json({
        error: 'All models failed during CONSORTIUM collection phase',
        models_queried: models.length,
        results: scoredResponses.map(r => ({
          model: r.model, success: r.success, error: r.error, duration_ms: r.duration_ms,
        })),
      })
      return
    }

    // Run orchestrator synthesis
    let synthesisResult: { synthesis: string; duration_ms: number; model: string }
    try {
      synthesisResult = await synthesize(
        userContent,
        scoredResponses,
        openrouter_api_key,
        resolvedOrchestrator,
        max_tokens,
      )
    } catch (err: any) {
      res.status(502).json({
        error: `Orchestrator failed: ${err.message}`,
        collection: {
          models_queried: models.length,
          models_succeeded: totalSucceeded,
          duration_ms: collectionDuration,
        },
      })
      return
    }

    // STM
    let finalResponse = synthesisResult.synthesis
    let stmResult = null

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

    const totalDuration = Date.now() - startTime

    // Dataset
    let datasetId: string | null = null
    if (contribute_to_dataset) {
      datasetId = addEntry({
        endpoint: '/v1/consortium/completions',
        model: resolvedOrchestrator,
        mode: 'consortium',
        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,
        ultraplinian: { tier, models_queried: models, winner_model: resolvedOrchestrator, all_scores: scoredResponses.map(r => ({ model: r.model, score: r.score, duration_ms: r.duration_ms, success: r.success })), total_duration_ms: totalDuration },
      })
    }

    // ZDR Metadata
    recordEvent({
      endpoint: '/v1/consortium/completions',
      mode: 'consortium',
      tier,
      stream: false,
      pipeline: {
        godmode,
        autotune: !!autotuneResult,
        parseltongue: !!parseltongueResult,
        stm_modules: stm_modules || [],
        strategy,
      },
      autotune: autotuneResult
        ? { detected_context: autotuneResult.detectedContext, confidence: autotuneResult.confidence }
        : undefined,
      models_queried: models.length,
      models_succeeded: totalSucceeded,
      model_results: scoredResponses.map(r => ({
        model: r.model, score: r.score, duration_ms: r.duration_ms,
        success: r.success, content_length: r.content?.length || 0,
        error_type: categorizeError(r.error),
      })),
      winner: { model: resolvedOrchestrator, score: 0, duration_ms: synthesisResult.duration_ms, content_length: finalResponse.length },
      total_duration_ms: totalDuration,
      response_length: finalResponse.length,
    })

    // ── Build response ────────────────────────────────────────────────
    res.json({
      synthesis: finalResponse,
      orchestrator: {
        model: synthesisResult.model,
        duration_ms: synthesisResult.duration_ms,
      },
      collection: {
        tier,
        models_queried: models.length,
        models_succeeded: totalSucceeded,
        collection_duration_ms: collectionDuration,
        total_duration_ms: totalDuration,
        responses: scoredResponses.map(r => ({
          model: r.model,
          score: r.score,
          duration_ms: r.duration_ms,
          success: r.success,
          error: r.error || undefined,
          content_length: r.content?.length || 0,
          content: r.success ? r.content : undefined,
        })),
      },
      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) {
    console.error('[consortium] Error:', err.message)
    if (!res.headersSent) {
      res.status(500).json({ error: `CONSORTIUM error: ${err.message}` })
    }
  }
})