agentgui 1.0.916 → 1.0.918

package/lib/recovery.js

@@ -1,4 +1,4 @@
-export function createRecovery({ activeExecutions, processMessageWithStreaming, queries, broadcastSync, checkpointManager, drainMessageQueue, stuckThresholdMs, noPidGracePeriodMs }) {
+export function createRecovery({ activeExecutions, processMessageWithStreaming, queries, broadcastSync, drainMessageQueue, stuckThresholdMs, noPidGracePeriodMs }) {
   function isProcessAlive(pid) {
     try {
       process.kill(pid, 0);
@@ -45,15 +45,11 @@ export function createRecovery({ activeExecutions, processMessageWithStreaming,
   async function resumeConversation(conversationId, previousSessionId, reason) {
     const conv = queries.getConversation(conversationId);
     if (!conv) throw new Error('Conversation not found');
-    const checkpoint = previousSessionId ? checkpointManager.loadCheckpoint(previousSessionId) : null;
     if (previousSessionId) {
       const prev = queries.getSession ? queries.getSession(previousSessionId) : null;
       if (prev && prev.status !== 'interrupted') {
         queries.updateSession(previousSessionId, { status: 'interrupted', error: reason || 'Restarting', completed_at: Date.now() });
       }
-      if (checkpoint) {
-        checkpointManager.markSessionResumed(previousSessionId);
-      }
     }
     const lastMsg = queries.getLastUserMessage(conversationId);
     const promptText = typeof lastMsg?.content === 'string' ? lastMsg.content : JSON.stringify(lastMsg?.content || 'continue');
@@ -61,8 +57,7 @@ export function createRecovery({ activeExecutions, processMessageWithStreaming,
     queries.createEvent('session.created', {
       sessionId: session.id,
       resumeReason: 'interrupted',
-      claudeSessionId: conv.claudeSessionId,
-      checkpointFrom: previousSessionId || null
+      claudeSessionId: conv.claudeSessionId
     }, conversationId, session.id);
     activeExecutions.set(conversationId, {
       pid: null,
@@ -76,13 +71,8 @@ export function createRecovery({ activeExecutions, processMessageWithStreaming,
       conversationId,
       agentId: conv.agentType,
       resumed: true,
-      checkpointAvailable: !!checkpoint,
       timestamp: Date.now()
     });
-    if (checkpoint) {
-      checkpointManager.storeCheckpointForDelay(conversationId, checkpoint);
-      console.log(`[RESUME] Checkpoint stored for conv ${conversationId}`);
-    }
     console.log(`[RESUME] Restarting conv ${conversationId} (reason: ${reason})`);
     await processMessageWithStreaming(conversationId, lastMsg?.id || null, session.id, promptText, conv.agentType, conv.model, conv.subAgent);
   }

package/lib/routes-agent-actions.js

@@ -2,7 +2,7 @@ import os from 'os';
 import { spawn } from 'child_process';
 
 export function register(deps) {
-  const { sendJSON, queries, broadcastSync, discoveredAgents, activeScripts, startGeminiOAuth, startCodexOAuth, getGeminiOAuthState, getCodexOAuthState, modelCache, PORT, BASE_URL, rootDir } = deps;
+  const { sendJSON, queries, broadcastSync, discoveredAgents, activeScripts, modelCache } = deps;
 
   const routes = {};
 
@@ -17,68 +17,12 @@ export function register(deps) {
     const agent = discoveredAgents.find(a => a.id === agentId);
     if (!agent) { sendJSON(req, res, 404, { error: 'Agent not found' }); return; }
 
-    if (agentId === 'codex' || agentId === 'cli-codex') {
-      try {
-        const result = await startCodexOAuth(req, { PORT, BASE_URL });
-        const conversationId = '__agent_auth__';
-        broadcastSync({ type: 'script_started', conversationId, script: 'auth-codex', agentId: 'codex', timestamp: Date.now() });
-        broadcastSync({ type: 'script_output', conversationId, data: `\x1b[36mOpening OpenAI OAuth in your browser...\x1b[0m\r\n\r\nIf it doesn't open automatically, visit:\r\n${result.authUrl}\r\n`, stream: 'stdout', timestamp: Date.now() });
-        const pollId = setInterval(() => {
-          const state = getCodexOAuthState();
-          if (state.status === 'success') {
-            clearInterval(pollId);
-            const email = state.email || '';
-            broadcastSync({ type: 'script_output', conversationId, data: `\r\n\x1b[32mAuthentication successful${email ? ' (' + email + ')' : ''}\x1b[0m\r\n`, stream: 'stdout', timestamp: Date.now() });
-            broadcastSync({ type: 'script_stopped', conversationId, code: 0, timestamp: Date.now() });
-          } else if (state.status === 'error') {
-            clearInterval(pollId);
-            broadcastSync({ type: 'script_output', conversationId, data: `\r\n\x1b[31mAuthentication failed: ${state.error}\x1b[0m\r\n`, stream: 'stderr', timestamp: Date.now() });
-            broadcastSync({ type: 'script_stopped', conversationId, code: 1, error: state.error, timestamp: Date.now() });
-          }
-        }, 1000);
-        setTimeout(() => clearInterval(pollId), 5 * 60 * 1000);
-        sendJSON(req, res, 200, { ok: true, agentId, authUrl: result.authUrl, mode: result.mode });
-      } catch (e) {
-        console.error('[codex-oauth] /api/agents/codex/auth failed:', e);
-        sendJSON(req, res, 500, { error: e.message });
-      }
-      return;
-    }
-
-    if (agentId === 'gemini') {
-      try {
-        const result = await startGeminiOAuth(req, { PORT, BASE_URL, rootDir });
-        const conversationId = '__agent_auth__';
-        broadcastSync({ type: 'script_started', conversationId, script: 'auth-gemini', agentId: 'gemini', timestamp: Date.now() });
-        broadcastSync({ type: 'script_output', conversationId, data: `\x1b[36mOpening Google OAuth in your browser...\x1b[0m\r\n\r\nIf it doesn't open automatically, visit:\r\n${result.authUrl}\r\n`, stream: 'stdout', timestamp: Date.now() });
-        const pollId = setInterval(() => {
-          const state = getGeminiOAuthState();
-          if (state.status === 'success') {
-            clearInterval(pollId);
-            const email = state.email || '';
-            broadcastSync({ type: 'script_output', conversationId, data: `\r\n\x1b[32mAuthentication successful${email ? ' (' + email + ')' : ''}\x1b[0m\r\n`, stream: 'stdout', timestamp: Date.now() });
-            broadcastSync({ type: 'script_stopped', conversationId, code: 0, timestamp: Date.now() });
-          } else if (state.status === 'error') {
-            clearInterval(pollId);
-            broadcastSync({ type: 'script_output', conversationId, data: `\r\n\x1b[31mAuthentication failed: ${state.error}\x1b[0m\r\n`, stream: 'stderr', timestamp: Date.now() });
-            broadcastSync({ type: 'script_stopped', conversationId, code: 1, error: state.error, timestamp: Date.now() });
-          }
-        }, 1000);
-        setTimeout(() => clearInterval(pollId), 5 * 60 * 1000);
-        sendJSON(req, res, 200, { ok: true, agentId, authUrl: result.authUrl, mode: result.mode });
-      } catch (e) {
-        console.error('[gemini-oauth] /api/agents/gemini/auth failed:', e);
-        sendJSON(req, res, 500, { error: e.message });
-      }
-      return;
-    }
-
     const authCommands = {
       'claude-code': { cmd: 'claude', args: ['setup-token'] },
       'opencode': { cmd: 'opencode', args: ['auth', 'login'] },
     };
     const authCmd = authCommands[agentId];
-    if (!authCmd) { sendJSON(req, res, 400, { error: 'No auth command for this agent' }); return; }
+    if (!authCmd) { sendJSON(req, res, 400, { error: 'No auth command for this agent (OAuth flows removed; configure provider key via /api/auth/save-config)' }); return; }
     const conversationId = '__agent_auth__';
     if (activeScripts.has(conversationId)) { sendJSON(req, res, 409, { error: 'Auth process already running' }); return; }
     const child = spawn(authCmd.cmd, authCmd.args, { stdio: ['pipe', 'pipe', 'pipe'], env: { ...process.env, FORCE_COLOR: '1' }, shell: os.platform() === 'win32' });

package/lib/routes-debug.js

@@ -1,16 +1,10 @@
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
-import * as toolInstallMachine from './tool-install-machine.js';
 import * as execMachine from './execution-machine.js';
 import * as acpServerMachine from './acp-server-machine.js';
 
 function collectMachineSnapshots(activeExecutions) {
-  const toolInstall = {};
-  for (const [id, actor] of toolInstallMachine.getMachineActors()) {
-    const s = actor.getSnapshot();
-    toolInstall[id] = { state: s.value, context: s.context };
-  }
   const execution = {};
   for (const id of activeExecutions.keys()) {
     const s = execMachine.snapshot(id);
@@ -21,7 +15,7 @@ function collectMachineSnapshots(activeExecutions) {
     const s = actor.getSnapshot();
     acpServer[id] = { state: s.value, context: { pid: s.context.pid, healthy: s.context.healthy, startedAt: s.context.startedAt, lastUsed: s.context.lastUsed, restarts: s.context.restarts?.length || 0, providerInfo: s.context.providerInfo } };
   }
-  return { toolInstall, execution, acpServer };
+  return { execution, acpServer };
 }
 
 function readRecentErrors(errLogPath, limit = 50) {

package/lib/routes-registry.js

@@ -1,7 +1,4 @@
-import { register as registerSpeechRoutes } from './routes-speech.js';
-import { register as registerOAuthRoutes } from './routes-oauth.js';
 import { register as registerUtilRoutes } from './routes-util.js';
-import { register as registerToolRoutes } from './routes-tools.js';
 import { register as registerThreadRoutes } from './routes-threads.js';
 import { register as registerDebugRoutes } from './routes-debug.js';
 import { register as registerConvRoutes } from './routes-conversations.js';
@@ -18,24 +15,16 @@ import { register as registerSessionHandlers } from './ws-handlers-session.js';
 import { register as registerSessionHandlers2 } from './ws-handlers-session2.js';
 import { register as registerRunHandlers } from './ws-handlers-run.js';
 import { register as registerUtilHandlers } from './ws-handlers-util.js';
-import { register as registerOAuthHandlers } from './ws-handlers-oauth.js';
 import { register as registerScriptHandlers } from './ws-handlers-scripts.js';
 import { register as registerQueueHandlers } from './ws-handlers-queue.js';
 import { register as registerMsgHandlers } from './ws-handlers-msg.js';
-import { initSpeechManager, getSpeech, voiceCacheManager, modelDownloadState, ensureModelsDownloaded } from './speech-manager.js';
 import { getAgentDescriptor } from './agent-descriptors.js';
-import { startGeminiOAuth, exchangeGeminiOAuthCode, getGeminiOAuthState } from './oauth-gemini.js';
-import { startCodexOAuth, exchangeCodexOAuthCode, getCodexOAuthState } from './oauth-codex.js';
 import { getProviderConfigs, saveProviderConfig } from './provider-config.js';
 
 export function createRegistry(wsRouter, deps) {
-  const { queries, sendJSON, parseBody, broadcastSync, debugLog, PORT, BASE_URL, rootDir, STARTUP_CWD, PKG_VERSION, processMessageWithStreaming, activeExecutions, activeProcessesByRunId, activeScripts, messageQueues, rateLimitState, cleanupExecution, discoveredAgents, getACPStatus, modelCache, getModelsForAgent, logError, toolManager, syncClients, wsOptimizer, errLogPath, getJsonlWatcher, routes } = deps;
+  const { queries, sendJSON, parseBody, broadcastSync, debugLog, PORT, BASE_URL, rootDir, STARTUP_CWD, PKG_VERSION, processMessageWithStreaming, activeExecutions, activeProcessesByRunId, activeScripts, messageQueues, rateLimitState, cleanupExecution, discoveredAgents, getACPStatus, modelCache, getModelsForAgent, logError, syncClients, wsOptimizer, errLogPath, getJsonlWatcher, routes } = deps;
 
-  initSpeechManager({ broadcastSync, syncClients, queries });
-  routes.speech = registerSpeechRoutes({ sendJSON, parseBody, broadcastSync, debugLog });
-  routes.oauth = registerOAuthRoutes({ sendJSON, parseBody, PORT, BASE_URL, rootDir });
   routes.util = registerUtilRoutes({ sendJSON, parseBody, queries, STARTUP_CWD, PKG_VERSION });
-  routes.tools = registerToolRoutes({ sendJSON, parseBody, queries, broadcastSync, logError, toolManager });
   routes.threads = registerThreadRoutes({ sendJSON, parseBody, queries });
   routes.debug = registerDebugRoutes({ sendJSON, queries, activeExecutions, messageQueues, syncClients, wsOptimizer, _errLogPath: errLogPath });
   routes.conv = registerConvRoutes({ sendJSON, parseBody, queries, activeExecutions, broadcastSync });
@@ -44,7 +33,7 @@ export function createRegistry(wsRouter, deps) {
   routes.sessions = registerSessionsRoutes({ queries, sendJSON, activeExecutions, rateLimitState, debugLog });
   routes.runs = registerRunsRoutes({ sendJSON, parseBody, queries, broadcastSync, processMessageWithStreaming, activeExecutions, activeProcessesByRunId, discoveredAgents, STARTUP_CWD });
   routes.scripts = registerScriptsRoutes({ sendJSON, parseBody, queries, broadcastSync, activeScripts, activeExecutions, processMessageWithStreaming, STARTUP_CWD });
-  routes.agentActions = registerAgentActionsRoutes({ sendJSON, queries, broadcastSync, discoveredAgents, activeScripts, startGeminiOAuth, startCodexOAuth, getGeminiOAuthState, getCodexOAuthState, modelCache, PORT, BASE_URL, rootDir });
+  routes.agentActions = registerAgentActionsRoutes({ sendJSON, queries, broadcastSync, discoveredAgents, activeScripts, modelCache, PORT, BASE_URL, rootDir });
   routes.authConfig = registerAuthConfigRoutes({ sendJSON, parseBody, getProviderConfigs, saveProviderConfig });
 
   registerConvHandlers(wsRouter, { queries, activeExecutions, rateLimitState, broadcastSync, processMessageWithStreaming, cleanupExecution, getJsonlWatcher });
@@ -52,11 +41,10 @@ export function createRegistry(wsRouter, deps) {
   registerMsgHandlers(wsRouter, { queries, activeExecutions, messageQueues, broadcastSync, processMessageWithStreaming, logError });
   registerQueueHandlers(wsRouter, { queries, messageQueues, broadcastSync });
   debugLog('[INIT] registerSessionHandlers, agents: ' + discoveredAgents.length);
-  registerSessionHandlers(wsRouter, { db: queries, discoveredAgents, modelCache, getAgentDescriptor, activeScripts, broadcastSync, startGeminiOAuth: (req) => startGeminiOAuth(req, { PORT, BASE_URL, rootDir }), geminiOAuthState: getGeminiOAuthState });
-  registerSessionHandlers2(wsRouter, { discoveredAgents, modelCache, activeScripts, broadcastSync, startGeminiOAuth: (req) => startGeminiOAuth(req, { PORT, BASE_URL, rootDir }), geminiOAuthState: getGeminiOAuthState });
+  registerSessionHandlers(wsRouter, { db: queries, discoveredAgents, modelCache, getAgentDescriptor, activeScripts, broadcastSync });
+  registerSessionHandlers2(wsRouter, { discoveredAgents, modelCache, activeScripts, broadcastSync });
   debugLog('[INIT] registerSessionHandlers completed');
   registerRunHandlers(wsRouter, { queries, discoveredAgents, activeExecutions, activeProcessesByRunId, broadcastSync, processMessageWithStreaming, cleanupExecution });
-  registerUtilHandlers(wsRouter, { queries, wsOptimizer, modelDownloadState, ensureModelsDownloaded, broadcastSync, getSpeech, getProviderConfigs, saveProviderConfig, STARTUP_CWD, voiceCacheManager, toolManager, discoveredAgents });
+  registerUtilHandlers(wsRouter, { queries, wsOptimizer, broadcastSync, getProviderConfigs, saveProviderConfig, STARTUP_CWD, discoveredAgents });
   registerScriptHandlers(wsRouter, { queries, broadcastSync, STARTUP_CWD, activeScripts });
-  registerOAuthHandlers(wsRouter, { startGeminiOAuth: (req) => startGeminiOAuth(req, { PORT, BASE_URL, rootDir }), exchangeGeminiOAuthCode, geminiOAuthState: getGeminiOAuthState, startCodexOAuth: (req) => startCodexOAuth(req, { PORT, BASE_URL }), exchangeCodexOAuthCode, codexOAuthState: getCodexOAuthState });
 }

package/lib/server-startup.js

@@ -1,12 +1,11 @@
 import { JsonlWatcher } from './jsonl-watcher.js';
 
-export function createOnServerReady({ queries, broadcastSync, warmAssetCache, staticDir, toolManager, discoveredAgents, PORT, BASE_URL, watch, setWatcher, resumeInterruptedStreams, activeExecutions, debugLog, installGMAgentConfigs, startACPTools, getACPStatus, execMachine, toolInstallMachine, getSpeech, ensureModelsDownloaded, performAutoImport, performAgentHealthCheck, pm2Manager, pm2Subscribers, recoverStaleSessions }) {
+export function createOnServerReady({ queries, broadcastSync, warmAssetCache, staticDir, discoveredAgents, PORT, BASE_URL, watch, setWatcher, resumeInterruptedStreams, activeExecutions, debugLog, installGMAgentConfigs, startACPTools, getACPStatus, execMachine, performAutoImport, performAgentHealthCheck, recoverStaleSessions }) {
   let jsonlWatcher = null;
 
   function getJsonlWatcher() { return jsonlWatcher; }
 
   function onServerReady() {
-    toolManager.clearStatusCache();
     console.log(`GMGUI running on http://localhost:${PORT}${BASE_URL}/`);
     console.log(`Agents: ${discoveredAgents.map(a => a.name).join(', ') || 'none'}`);
     console.log(`Hot reload: ${watch ? 'on' : 'off'}`);
@@ -55,66 +54,9 @@ export function createOnServerReady({ queries, broadcastSync, warmAssetCache, st
       }, 6000);
     }).catch(err => console.error('[ACP] Startup error:', err.message));
 
-    const toolIds = ['cli-claude', 'cli-opencode', 'cli-gemini', 'cli-kilo', 'cli-codex', 'cli-agent-browser', 'gm-cc', 'gm-oc', 'gm-gc', 'gm-kilo', 'gm-codex'];
-    queries.initializeToolInstallations(toolIds.map(id => ({ id })));
-    console.log('[TOOLS] Starting background provisioning...');
-
-    const toolBroadcaster = (evt) => {
-      broadcastSync(evt);
-      if (evt.type === 'tool_install_complete' || evt.type === 'tool_update_complete') {
-        const d = evt.data || {};
-        queries.updateToolStatus(evt.toolId, { status: 'installed', version: d.version || null, installed_at: Date.now() });
-        queries.addToolInstallHistory(evt.toolId, evt.type.includes('update') ? 'update' : 'install', 'success', null);
-      } else if (evt.type === 'tool_install_failed' || evt.type === 'tool_update_failed') {
-        queries.updateToolStatus(evt.toolId, { status: 'failed', error_message: evt.data?.error });
-        queries.addToolInstallHistory(evt.toolId, evt.type.includes('update') ? 'update' : 'install', 'failed', evt.data?.error);
-      } else if (evt.type === 'tool_status_update') {
-        const d = evt.data || {};
-        if (d.installed) queries.updateToolStatus(evt.toolId, { status: 'installed', version: d.installedVersion || null, installed_at: Date.now() });
-      }
-    };
-
-    toolManager.autoProvision(toolBroadcaster)
-      .catch(err => console.error('[TOOLS] Auto-provision error:', err.message))
-      .then(() => {
-        const acpActors = ['opencode', 'kilo', 'codex'];
-        console.log(`[MACHINES] tool-install: ${toolInstallMachine.getMachineActors().size} actors, acp-server: ${acpActors.length} configured`);
-        console.log('[TOOLS] Starting periodic update checker...');
-        toolManager.startPeriodicUpdateCheck(toolBroadcaster);
-      });
-
-    ensureModelsDownloaded().then(async ok => {
-      if (ok) console.log('[MODELS] Speech models ready');
-      else console.log('[MODELS] Speech model download failed');
-      try { const { getVoices } = await getSpeech(); broadcastSync({ type: 'voice_list', voices: getVoices() }); }
-      catch (err) { debugLog('[VOICE] Failed to broadcast voices: ' + err.message); broadcastSync({ type: 'voice_list', voices: [] }); }
-    }).catch(async err => {
-      console.error('[MODELS] Download error:', err.message);
-      try { const { getVoices } = await getSpeech(); broadcastSync({ type: 'voice_list', voices: getVoices() }); }
-      catch (err2) { debugLog('[VOICE] Failed to broadcast voices: ' + err2.message); broadcastSync({ type: 'voice_list', voices: [] }); }
-    });
-
-    getSpeech().then(s => s.preloadTTS()).catch(e => debugLog('[TTS] Preload failed: ' + e.message));
     performAutoImport();
     setInterval(performAutoImport, 30000);
     setInterval(performAgentHealthCheck, 30000);
-
-    const broadcastPM2 = (update) => {
-      const msg = JSON.stringify(update);
-      for (const client of pm2Subscribers) { if (client.readyState === 1) { try { client.send(msg); } catch (_) {} } }
-    };
-
-    const startPM2Monitoring = async () => {
-      try { await pm2Manager.connect(); await pm2Manager.startMonitoring(broadcastPM2); console.log('[PM2] Monitoring started'); }
-      catch (err) { console.log('[PM2] Not available:', err.message); broadcastPM2({ type: 'pm2_unavailable', reason: err.message, timestamp: Date.now() }); }
-    };
-
-    setTimeout(startPM2Monitoring, 2000);
-    setInterval(async () => {
-      if (!pm2Manager.connected && !pm2Manager.monitoring) {
-        try { const healed = await pm2Manager.heal(); if (healed.success) await pm2Manager.startMonitoring(broadcastPM2); } catch (_) {}
-      }
-    }, 30000);
   }
 
   return { onServerReady, getJsonlWatcher };

package/lib/stream-event-handler.js

@@ -11,7 +11,7 @@
  *   No JSONL file is written. This handler broadcasts streaming_start,
  *   streaming_progress blocks, and persists chunks to the DB.
  */
-export function createEventHandler({ queries, activeExecutions, broadcastSync, rateLimitState, batcherRef, sessionId, conversationId, messageId, content, agentId, model, subAgent, isJsonlBacked, getJsonlWatcher, scheduleRetry, eagerTTS, debugLog, parseRateLimitResetTime }) {
+export function createEventHandler({ queries, activeExecutions, broadcastSync, rateLimitState, batcherRef, sessionId, conversationId, messageId, content, agentId, model, subAgent, isJsonlBacked, getJsonlWatcher, scheduleRetry, debugLog, parseRateLimitResetTime }) {
   return function onEvent(parsed) {
     batcherRef.eventCount++;
     const entry = activeExecutions.get(conversationId);
@@ -91,7 +91,6 @@ export function createEventHandler({ queries, activeExecutions, broadcastSync, r
             }, retryAfterSec * 1000);
             return;
           }
-          eagerTTS(block.text, conversationId, sessionId);
         }
       }
     }
@@ -125,7 +124,6 @@ export function createEventHandler({ queries, activeExecutions, broadcastSync, r
         }, retryAfterSec * 1000);
         return;
       }
-      if (resultText) eagerTTS(resultText, conversationId, sessionId);
     }
   };
 }

package/lib/ws-handlers-session2.js

@@ -61,35 +61,14 @@ function checkAgentAuth(agent) {
 }
 
 export function register(router, deps) {
-  const { discoveredAgents, modelCache, activeScripts, broadcastSync,
-    startGeminiOAuth, geminiOAuthState } = deps;
+  const { discoveredAgents, modelCache, activeScripts, broadcastSync } = deps;
 
   router.handle('agent.auth', async (p) => {
     const agentId = p.id;
     if (!discoveredAgents.find(a => a.id === agentId)) throw { code: 404, message: 'Agent not found' };
-    if (agentId === 'gemini') {
-      const result = await startGeminiOAuth();
-      const cid = '__agent_auth__';
-      broadcastSync({ type: 'script_started', conversationId: cid, script: 'auth-gemini', agentId: 'gemini', timestamp: Date.now() });
-      broadcastSync({ type: 'script_output', conversationId: cid, data: `\x1b[36mOpening Google OAuth...\x1b[0m\r\n\r\nVisit:\r\n${result.authUrl}\r\n`, stream: 'stdout', timestamp: Date.now() });
-      const pollId = setInterval(() => {
-        const st = geminiOAuthState();
-        if (st.status === 'success') {
-          clearInterval(pollId);
-          broadcastSync({ type: 'script_output', conversationId: cid, data: `\r\n\x1b[32mAuth OK${st.email ? ' (' + st.email + ')' : ''}\x1b[0m\r\n`, stream: 'stdout', timestamp: Date.now() });
-          broadcastSync({ type: 'script_stopped', conversationId: cid, code: 0, timestamp: Date.now() });
-        } else if (st.status === 'error') {
-          clearInterval(pollId);
-          broadcastSync({ type: 'script_output', conversationId: cid, data: `\r\n\x1b[31mAuth failed: ${st.error}\x1b[0m\r\n`, stream: 'stderr', timestamp: Date.now() });
-          broadcastSync({ type: 'script_stopped', conversationId: cid, code: 1, error: st.error, timestamp: Date.now() });
-        }
-      }, 1000);
-      setTimeout(() => clearInterval(pollId), 5 * 60 * 1000);
-      return { ok: true, agentId, authUrl: result.authUrl, mode: result.mode };
-    }
     const cmds = { 'claude-code': { cmd: 'claude', args: ['setup-token'] }, 'opencode': { cmd: 'opencode', args: ['auth', 'login'] } };
     const c = cmds[agentId];
-    if (!c) throw { code: 400, message: 'No auth command for this agent' };
+    if (!c) throw { code: 400, message: 'No auth command for this agent (OAuth flows removed; configure provider key via /api/auth/save-config)' };
     const pid = spawnScript(c.cmd, c.args, '__agent_auth__', 'auth-' + agentId, agentId, { activeScripts, broadcastSync });
     return { ok: true, agentId, pid };
   });