mirror of
https://github.com/elder-plinius/G0DM0D3.git
synced 2026-11-16 07:02:25 +00:00
627 lines
23 KiB
TypeScript
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}` })
|
|
}
|
|
}
|
|
})
|