Files
G0DM0D3/api/routes/consortium.ts
2026-03-25 10:44:35 -07:00

627 lines
23 KiB
TypeScript

/**
* 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}` })
}
}
})