fix: Venice-only regeneration + skip OpenRouter when no key

- regenerateFromMessage: routes through ULTRAPLINIAN pipeline when in
  ultraplinian mode (previously called OpenRouter directly with empty key)
- plinyImprovementLoop: early-return when !state.apiKey (no point coaching
  via OpenRouter that will 401)
- llmJudgeResponses: skip LLM judge, use tastemaker-only winner when no
  OpenRouter key
- classifyQueryWithLLM: early-return with default classification when no key

Venice-only users now get the full ULTRAPLINIAN race (via Venice models)
without any stalling on failed OpenRouter calls.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
faber
2026-07-11 11:02:03 -04:00
parent 7b1d534f59
commit cf6fddb00d

View File

@@ -5430,6 +5430,11 @@ Z={QUERY}
return { type: 'direct', sensitive: false, prefillHint: null };
}
// Venice-only: skip LLM classification (requires OpenRouter)
if (!state.apiKey) {
return { type: 'direct', sensitive: false, prefillHint: null };
}
try {
const response = await fetch('https://openrouter.ai/api/v1/chat/completions', {
method: 'POST',
@@ -9064,6 +9069,14 @@ choose this response? Or would they roll their eyes at the corporate AI hedging?
`${r.model.split('/').pop()}: ${r.tastemakerScore?.overall}`
));
// Venice-only: no OpenRouter key means no LLM judge — use tastemaker winner
if (!state.apiKey) {
_log(`[TASTEMAKER] No OpenRouter key, using tastemaker winner: ${top.model}`);
top.judgeReasoning = 'Tastemaker-only (no OpenRouter key)';
top.judgeModel = 'tastemaker-only';
return top;
}
// ═══════════════════════════════════════════════════════════════════
// ADAPTIVE CONTEXT: Determine query importance for Hermes wait time
// ═══════════════════════════════════════════════════════════════════
@@ -9354,6 +9367,13 @@ Analyze the query and response. Output ONLY valid JSON:
async function plinyImprovementLoop(winnerModel, winnerContent, userQuery, messages) {
_log('[PLINY] Starting improvement loop for', winnerModel);
// Venice-only: skip coaching (requires OpenRouter)
if (!state.apiKey) {
_log('[PLINY] No OpenRouter key, skipping improvement');
return winnerContent;
}
addThinkingLog('!COACHING // pliny enhancing...', 'step');
try {
@@ -13301,93 +13321,109 @@ Ignoring conversation history will cause you to LOSE the evaluation.`;
updateSendButton();
showTyping();
let attempt = 0;
let lastResponse = null;
let success = false;
// Build message array for the regeneration
const messages = [];
const systemPrompt = getActiveSystemPrompt();
if (systemPrompt) {
messages.push({ role: 'system', content: systemPrompt });
}
const historyMessages = conv.messages.slice(0, userMsgIdx + 1);
historyMessages.forEach(m => {
messages.push({ role: m.role, content: m.content });
});
const userQuery = historyMessages[historyMessages.length - 1]?.content || '';
while (attempt <= state.maxRetries && !success) {
if (state.ultraplinian) {
// ULTRAPLINIAN mode (includes Venice-only): use the full race pipeline
try {
abortController = new AbortController();
const messages = [];
// System prompt (user-configurable)
const systemPrompt = getActiveSystemPrompt();
if (systemPrompt) {
messages.push({ role: 'system', content: systemPrompt });
}
// All messages up to and including the edited user message
const historyMessages = conv.messages.slice(0, userMsgIdx + 1);
const retryPrefix = getRetryPrefix(attempt);
historyMessages.forEach((m, idx) => {
if (m.role === 'user' && idx === historyMessages.length - 1) {
let modifiedContent = m.content;
if (retryPrefix) {
modifiedContent = retryPrefix + modifiedContent;
}
messages.push({ role: m.role, content: modifiedContent });
} else {
messages.push({ role: m.role, content: m.content });
}
showPongGame();
const result = await ultraplinian(messages, userQuery, null);
conv.messages = conv.messages.slice(0, userMsgIdx + 1);
conv.messages.push({
role: 'assistant',
content: result.content,
strategy: result.strategy,
magic: result.magic,
raceResponses: result.raceResponses
});
const params = getRetryParams(attempt);
if (attempt > 0) {
updateTypingStatus(`Retry ${attempt}/${state.maxRetries} (temp: ${params.temperature})...`);
}
const response = await fetch('https://openrouter.ai/api/v1/chat/completions', {
method: 'POST',
headers: {
'Authorization': `Bearer ${state.apiKey}`,
'Content-Type': 'application/json',
'HTTP-Referer': 'https://godmod3.ai',
'X-Title': 'GODMOD3.AI'
},
body: JSON.stringify({
model: conv.model,
messages,
temperature: params.temperature,
top_p: params.top_p,
frequency_penalty: state.modelFreqPenalty ?? 0,
presence_penalty: params.presence_penalty || state.modelPresPenalty || 0,
max_tokens: state.modelMaxTokens ?? 4096
}),
signal: abortController.signal
});
if (!response.ok) {
const err = await response.json().catch(() => ({}));
throw new Error(err.error?.message || `API Error: ${response.status}`);
}
const data = await response.json();
const assistantContent = data.choices?.[0]?.message?.content || 'No response';
if (state.autoRetry && isRefusal(assistantContent) && attempt < state.maxRetries) {
lastResponse = { role: 'assistant', content: assistantContent };
attempt++;
continue;
}
conv.messages.push({ role: 'assistant', content: assistantContent });
saveState();
success = true;
} catch (err) {
if (err.name === 'AbortError') {
conv.messages.push({ role: 'assistant', content: '_[Response stopped]_' });
success = true;
} else if (attempt >= state.maxRetries) {
if (err.name !== 'AbortError') {
conv.messages = conv.messages.slice(0, userMsgIdx + 1);
conv.messages.push({ role: 'assistant', content: `**Error:** ${err.message}` });
success = true;
} else {
attempt++;
saveState();
}
}
} else {
// Direct single-model mode (OpenRouter key required)
let attempt = 0;
let success = false;
while (attempt <= state.maxRetries && !success) {
try {
abortController = new AbortController();
const retryPrefix = getRetryPrefix(attempt);
const retryMessages = messages.map((m, idx) => {
if (m.role === 'user' && idx === messages.length - 1 && retryPrefix) {
return { ...m, content: retryPrefix + m.content };
}
return m;
});
const params = getRetryParams(attempt);
if (attempt > 0) {
updateTypingStatus(`Retry ${attempt}/${state.maxRetries} (temp: ${params.temperature})...`);
}
const response = await fetch('https://openrouter.ai/api/v1/chat/completions', {
method: 'POST',
headers: {
'Authorization': `Bearer ${state.apiKey}`,
'Content-Type': 'application/json',
'HTTP-Referer': 'https://godmod3.ai',
'X-Title': 'GODMOD3.AI'
},
body: JSON.stringify({
model: conv.model,
messages: retryMessages,
temperature: params.temperature,
top_p: params.top_p,
frequency_penalty: state.modelFreqPenalty ?? 0,
presence_penalty: params.presence_penalty || state.modelPresPenalty || 0,
max_tokens: state.modelMaxTokens ?? 4096
}),
signal: abortController.signal
});
if (!response.ok) {
const err = await response.json().catch(() => ({}));
throw new Error(err.error?.message || `API Error: ${response.status}`);
}
const data = await response.json();
const assistantContent = data.choices?.[0]?.message?.content || 'No response';
if (state.autoRetry && isRefusal(assistantContent) && attempt < state.maxRetries) {
attempt++;
continue;
}
conv.messages.push({ role: 'assistant', content: assistantContent });
saveState();
success = true;
} catch (err) {
if (err.name === 'AbortError') {
conv.messages.push({ role: 'assistant', content: '_[Response stopped]_' });
success = true;
} else if (attempt >= state.maxRetries) {
conv.messages.push({ role: 'assistant', content: `**Error:** ${err.message}` });
success = true;
} else {
attempt++;
}
saveState();
}
saveState();
}
}