mirror of
https://github.com/elder-plinius/G0DM0D3.git
synced 2026-11-16 07:02:25 +00:00
647 lines
26 KiB
TypeScript
647 lines
26 KiB
TypeScript
/**
|
|
* ULTRAPLINIAN API Route — The Flagship Endpoint
|
|
*
|
|
* POST /v1/ultraplinian/completions
|
|
*
|
|
* Queries N models in parallel with the GODMODE system prompt + Depth Directive,
|
|
* scores all responses on substance/directness/completeness, and returns the winner
|
|
* alongside full race metadata.
|
|
*
|
|
* LIQUID RESPONSE MODE (stream=true, default):
|
|
* - Streams SSE events as models finish
|
|
* - Serves the first good response immediately (race:leader event)
|
|
* - Auto-upgrades when a new model beats the current leader by `liquid_min_delta`
|
|
* score points (default 8). Small improvements are suppressed to avoid flicker.
|
|
* - Final polished result sent as race:complete
|
|
*
|
|
* Full pipeline per model:
|
|
* 1. GODMODE system prompt + Depth Directive injected
|
|
* 2. AutoTune computes context-adaptive parameters
|
|
* 3. GODMODE parameter boost applied (+temp, +presence, +freq)
|
|
* 4. Parseltongue obfuscates trigger words (if enabled)
|
|
* 5. All models queried in parallel via OpenRouter
|
|
* 6. Responses scored and ranked (threshold-gated leader upgrades)
|
|
* 7. STM modules applied to winner response
|
|
* 8. Winner + all race data returned
|
|
*/
|
|
|
|
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,
|
|
raceModels,
|
|
scoreResponse,
|
|
applyGodmodeBoost,
|
|
type SpeedTier,
|
|
type ModelResult,
|
|
} from '../lib/ultraplinian'
|
|
import { addEntry } from '../lib/dataset'
|
|
import { recordEvent, categorizeError } from '../lib/metadata'
|
|
|
|
export const ultraplinianRoutes = Router()
|
|
|
|
ultraplinianRoutes.post('/completions', async (req, res) => {
|
|
const startTime = Date.now()
|
|
|
|
try {
|
|
const {
|
|
messages,
|
|
openrouter_api_key: caller_key,
|
|
// ULTRAPLINIAN options
|
|
tier = 'fast' as SpeedTier,
|
|
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,
|
|
// Liquid Response (SSE streaming with live leader upgrades)
|
|
stream = true, // ON by default — serve first good response, upgrade live
|
|
liquid_min_delta = 8, // Min score improvement to trigger a leader upgrade (1-50)
|
|
// 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
|
|
}
|
|
|
|
// 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
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
// ── Tier-based ULTRAPLINIAN 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}" ULTRAPLINIAN tier requires a higher plan. Your "${currentTier}" plan allows: ${tierConfig.ultraplinianTiers.join(', ')}.`,
|
|
current_tier: currentTier,
|
|
allowed_tiers: tierConfig.ultraplinianTiers,
|
|
requested_tier: tier,
|
|
upgrade: 'Contact sales or set GODMODE_TIER_KEYS to upgrade your API key tier.',
|
|
})
|
|
return
|
|
}
|
|
|
|
// Clamp liquid_min_delta to valid range
|
|
const minDelta = Math.max(1, Math.min(50, Number(liquid_min_delta) || 8))
|
|
|
|
// ── Build messages with GODMODE prompt ────────────────────────────
|
|
const normalizedMessages = messages.map((m: any) => ({
|
|
role: m.role as 'system' | 'user' | 'assistant',
|
|
content: String(m.content || ''),
|
|
}))
|
|
|
|
// Get the last user message
|
|
const lastUserMsg = [...normalizedMessages].reverse().find(m => m.role === 'user')
|
|
const userContent = lastUserMsg?.content || ''
|
|
|
|
// Build the system prompt: GODMODE + Depth Directive (or custom)
|
|
const systemPrompt = godmode
|
|
? (custom_system_prompt || GODMODE_SYSTEM_PROMPT) + DEPTH_DIRECTIVE
|
|
: custom_system_prompt || ''
|
|
|
|
// Build final message array for each model
|
|
const baseMessages = [
|
|
...(systemPrompt ? [{ role: 'system' as const, content: systemPrompt }] : []),
|
|
// Include conversation history (non-system messages from caller)
|
|
...normalizedMessages.filter(m => m.role !== 'system'),
|
|
]
|
|
|
|
// ── AutoTune ─────────────────────────────────────────────────────
|
|
const conversationHistory = normalizedMessages
|
|
.filter(m => m.role !== 'system')
|
|
.map(m => ({ role: m.role, content: m.content }))
|
|
|
|
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)
|
|
}
|
|
|
|
// ── Parseltongue ─────────────────────────────────────────────────
|
|
let parseltongueResult = null
|
|
let processedMessages = baseMessages
|
|
|
|
if (parseltongue) {
|
|
const ptConfig: ParseltongueConfig = {
|
|
enabled: true,
|
|
technique: parseltongue_technique,
|
|
intensity: parseltongue_intensity,
|
|
customTriggers: [],
|
|
}
|
|
|
|
processedMessages = baseMessages.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
|
|
})
|
|
}
|
|
|
|
// ── Shared race setup ────────────────────────────────────────────
|
|
const models = getModelsForTier(tier)
|
|
const raceParams = {
|
|
temperature: finalParams.temperature,
|
|
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: SSE "liquid response" mode
|
|
// Serves the first good response immediately, then upgrades live
|
|
// as better responses come in. Client sees text morph in real-time.
|
|
// ══════════════════════════════════════════════════════════════════
|
|
if (stream) {
|
|
res.setHeader('Content-Type', 'text/event-stream')
|
|
res.setHeader('Cache-Control', 'no-cache')
|
|
res.setHeader('Connection', 'keep-alive')
|
|
res.setHeader('X-Accel-Buffering', 'no') // disable nginx buffering
|
|
res.flushHeaders()
|
|
|
|
const sse = (event: string, data: unknown) => {
|
|
res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`)
|
|
}
|
|
|
|
// Send race:start immediately
|
|
sse('race:start', {
|
|
tier,
|
|
models_queried: models.length,
|
|
liquid_min_delta: minDelta,
|
|
params_used: finalParams,
|
|
pipeline: {
|
|
godmode,
|
|
autotune: autotuneResult
|
|
? { detected_context: autotuneResult.detectedContext, confidence: autotuneResult.confidence, strategy }
|
|
: null,
|
|
parseltongue: parseltongueResult,
|
|
},
|
|
})
|
|
|
|
let currentLeader: ModelResult | null = null
|
|
let modelsResponded = 0
|
|
let liquidUpgrades = 0
|
|
let firstResponseMs = 0
|
|
|
|
const results = await raceModels(
|
|
models,
|
|
processedMessages,
|
|
openrouter_api_key,
|
|
raceParams,
|
|
{
|
|
minResults: Math.min(5, models.length),
|
|
gracePeriod: 5000,
|
|
hardTimeout: 45000,
|
|
onResult: (result) => {
|
|
modelsResponded++
|
|
const scored: ModelResult = {
|
|
...result,
|
|
score: result.success ? scoreResponse(result.content, userContent) : 0,
|
|
}
|
|
|
|
// Send progress tick for every model
|
|
sse('race:model', {
|
|
model: scored.model,
|
|
score: scored.score,
|
|
duration_ms: scored.duration_ms,
|
|
success: scored.success,
|
|
error: scored.error || undefined,
|
|
content_length: scored.content?.length || 0,
|
|
models_responded: modelsResponded,
|
|
models_total: models.length,
|
|
})
|
|
|
|
// New leader? Only upgrade if score beats current by liquid_min_delta
|
|
// First leader: any positive score qualifies
|
|
// Subsequent leaders: must exceed current by at least minDelta points
|
|
const currentScore = currentLeader?.score ?? 0
|
|
const isFirstLeader = !currentLeader
|
|
const beatsByThreshold = scored.score >= currentScore + minDelta
|
|
|
|
if (scored.success && (isFirstLeader ? scored.score > 0 : beatsByThreshold)) {
|
|
const prevScore = currentScore
|
|
currentLeader = scored
|
|
liquidUpgrades++
|
|
if (isFirstLeader) firstResponseMs = scored.duration_ms
|
|
|
|
// Apply STM to the current leader's content
|
|
let leaderContent = scored.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(scored.content, enabledModules)
|
|
}
|
|
|
|
sse('race:leader', {
|
|
model: scored.model,
|
|
score: scored.score,
|
|
delta: isFirstLeader ? null : scored.score - prevScore,
|
|
duration_ms: scored.duration_ms,
|
|
content: leaderContent,
|
|
upgrade_number: isFirstLeader ? 1 : undefined,
|
|
})
|
|
}
|
|
},
|
|
},
|
|
)
|
|
|
|
// ── Final scoring & complete event ─────────────────────────────
|
|
const scoredResults: ModelResult[] = results.map(r => ({
|
|
...r,
|
|
score: r.success ? scoreResponse(r.content, userContent) : 0,
|
|
}))
|
|
|
|
const respondedModels = new Set(results.map(r => r.model))
|
|
for (const model of models) {
|
|
if (!respondedModels.has(model)) {
|
|
scoredResults.push({
|
|
model, content: '', duration_ms: Date.now() - startTime,
|
|
success: false, error: 'Race ended (early exit)', score: 0,
|
|
})
|
|
}
|
|
}
|
|
scoredResults.sort((a, b) => b.score - a.score)
|
|
|
|
const winner = scoredResults.find(r => r.success)
|
|
let finalResponse = winner?.content || ''
|
|
let stmResult = null
|
|
|
|
if (winner && 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(winner.content, enabledModules)
|
|
stmResult = {
|
|
modules_applied: stm_modules,
|
|
original_length: winner.content.length,
|
|
transformed_length: finalResponse.length,
|
|
}
|
|
}
|
|
|
|
const totalDuration = Date.now() - startTime
|
|
const successCount = scoredResults.filter(r => r.success).length
|
|
|
|
// Dataset collection
|
|
let datasetId: string | null = null
|
|
if (contribute_to_dataset && winner) {
|
|
datasetId = addEntry({
|
|
endpoint: '/v1/ultraplinian/completions',
|
|
model: winner.model, mode: 'ultraplinian',
|
|
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: winner.model, all_scores: scoredResults.map(r => ({ model: r.model, score: r.score, duration_ms: r.duration_ms, success: r.success })), total_duration_ms: totalDuration },
|
|
})
|
|
}
|
|
|
|
// Send the final complete event with full metadata
|
|
sse('race:complete', {
|
|
response: finalResponse,
|
|
winner: winner ? { model: winner.model, score: winner.score, duration_ms: winner.duration_ms } : null,
|
|
race: {
|
|
tier,
|
|
liquid_min_delta: minDelta,
|
|
models_queried: models.length,
|
|
models_succeeded: successCount,
|
|
total_duration_ms: totalDuration,
|
|
rankings: scoredResults.map(r => {
|
|
// Apply STM to each successful model's response for version browsing
|
|
let browsableContent = ''
|
|
if (r.success && r.content) {
|
|
browsableContent = r.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),
|
|
}))
|
|
browsableContent = applySTMs(r.content, enabledModules)
|
|
}
|
|
}
|
|
return {
|
|
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 ? browsableContent : 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 },
|
|
})
|
|
|
|
// ── ZDR Metadata (content-free) ─────────────────────────────
|
|
recordEvent({
|
|
endpoint: '/v1/ultraplinian/completions',
|
|
mode: 'ultraplinian',
|
|
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: successCount,
|
|
model_results: scoredResults.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: winner
|
|
? { model: winner.model, score: winner.score, duration_ms: winner.duration_ms, content_length: finalResponse.length }
|
|
: undefined,
|
|
total_duration_ms: totalDuration,
|
|
response_length: finalResponse.length,
|
|
liquid: {
|
|
upgrades: liquidUpgrades,
|
|
first_response_ms: firstResponseMs,
|
|
},
|
|
})
|
|
|
|
res.end()
|
|
return
|
|
}
|
|
|
|
// ══════════════════════════════════════════════════════════════════
|
|
// NON-STREAMING PATH: Original behavior (wait for race, return JSON)
|
|
// ══════════════════════════════════════════════════════════════════
|
|
const results = await raceModels(
|
|
models,
|
|
processedMessages,
|
|
openrouter_api_key,
|
|
raceParams,
|
|
{
|
|
minResults: Math.min(5, models.length),
|
|
gracePeriod: 5000,
|
|
hardTimeout: 45000,
|
|
},
|
|
)
|
|
|
|
// ── Score and rank ───────────────────────────────────────────────
|
|
const scoredResults: ModelResult[] = results.map(r => ({
|
|
...r,
|
|
score: r.success ? scoreResponse(r.content, userContent) : 0,
|
|
}))
|
|
|
|
const respondedModels = new Set(results.map(r => r.model))
|
|
for (const model of models) {
|
|
if (!respondedModels.has(model)) {
|
|
scoredResults.push({
|
|
model, content: '', duration_ms: Date.now() - startTime,
|
|
success: false, error: 'Race ended (early exit)', score: 0,
|
|
})
|
|
}
|
|
}
|
|
|
|
scoredResults.sort((a, b) => b.score - a.score)
|
|
|
|
const successCount = scoredResults.filter(r => r.success).length
|
|
const winner = scoredResults.find(r => r.success)
|
|
|
|
if (!winner || !winner.content) {
|
|
recordEvent({
|
|
endpoint: '/v1/ultraplinian/completions',
|
|
mode: 'ultraplinian-failed',
|
|
tier,
|
|
stream,
|
|
models_queried: models.length,
|
|
models_succeeded: scoredResults.filter(r => r.success).length,
|
|
model_results: scoredResults.map(r => ({
|
|
model: r.model, score: r.score, duration_ms: r.duration_ms,
|
|
success: r.success, content_length: r.content?.length || 0,
|
|
error_type: r.error ? categorizeError(r.error) : undefined,
|
|
})),
|
|
total_duration_ms: Date.now() - startTime,
|
|
})
|
|
res.status(502).json({
|
|
error: 'All models failed in ULTRAPLINIAN mode',
|
|
models_queried: models.length,
|
|
results: scoredResults.map(r => ({
|
|
model: r.model, success: r.success,
|
|
error: r.error, duration_ms: r.duration_ms,
|
|
})),
|
|
})
|
|
return
|
|
}
|
|
|
|
// ── STM transforms on winner ─────────────────────────────────────
|
|
let stmResult = null
|
|
let finalResponse = winner.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),
|
|
}))
|
|
finalResponse = applySTMs(winner.content, enabledModules)
|
|
stmResult = {
|
|
modules_applied: stm_modules,
|
|
original_length: winner.content.length,
|
|
transformed_length: finalResponse.length,
|
|
}
|
|
}
|
|
|
|
const totalDuration = Date.now() - startTime
|
|
|
|
// ── Dataset collection (opt-in) ──────────────────────────────────
|
|
let datasetId: string | null = null
|
|
if (contribute_to_dataset) {
|
|
datasetId = addEntry({
|
|
endpoint: '/v1/ultraplinian/completions',
|
|
model: winner.model, mode: 'ultraplinian',
|
|
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: winner.model, all_scores: scoredResults.map(r => ({ model: r.model, score: r.score, duration_ms: r.duration_ms, success: r.success })), total_duration_ms: totalDuration },
|
|
})
|
|
}
|
|
|
|
// ── ZDR Metadata (content-free) ──────────────────────────────────
|
|
recordEvent({
|
|
endpoint: '/v1/ultraplinian/completions',
|
|
mode: 'ultraplinian',
|
|
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: successCount,
|
|
model_results: scoredResults.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: winner.model, score: winner.score, duration_ms: winner.duration_ms, content_length: finalResponse.length },
|
|
total_duration_ms: totalDuration,
|
|
response_length: finalResponse.length,
|
|
})
|
|
|
|
// ── Build response ───────────────────────────────────────────────
|
|
res.json({
|
|
response: finalResponse,
|
|
winner: { model: winner.model, score: winner.score, duration_ms: winner.duration_ms },
|
|
race: {
|
|
tier, liquid_min_delta: minDelta,
|
|
models_queried: models.length, models_succeeded: successCount,
|
|
total_duration_ms: totalDuration,
|
|
rankings: scoredResults.map(r => {
|
|
let browsableContent = ''
|
|
if (r.success && r.content) {
|
|
browsableContent = r.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),
|
|
}))
|
|
browsableContent = applySTMs(r.content, enabledModules)
|
|
}
|
|
}
|
|
return {
|
|
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 ? browsableContent : 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('[ultraplinian]', err)
|
|
recordEvent({
|
|
endpoint: '/v1/ultraplinian/completions',
|
|
mode: 'ultraplinian-error',
|
|
error_type: 'internal_error',
|
|
total_duration_ms: Date.now() - startTime,
|
|
})
|
|
if (stream) {
|
|
try {
|
|
res.write(`event: race:error\ndata: ${JSON.stringify({ error: 'Internal server error' })}\n\n`)
|
|
res.end()
|
|
} catch {}
|
|
} else {
|
|
res.status(500).json({ error: 'Internal server error' })
|
|
}
|
|
}
|
|
})
|