agentgui 1.0.917 → 1.0.919

package/database-schema.js

@@ -94,52 +94,6 @@ export function initSchema(db) {
     CREATE INDEX IF NOT EXISTS idx_chunks_conv_created ON chunks(conversationId, created_at);
     CREATE INDEX IF NOT EXISTS idx_chunks_sess_created ON chunks(sessionId, created_at);
 
-    CREATE TABLE IF NOT EXISTS voice_cache (
-      id TEXT PRIMARY KEY,
-      conversationId TEXT NOT NULL,
-      text TEXT NOT NULL,
-      audioBlob BLOB,
-      byteSize INTEGER NOT NULL,
-      created_at INTEGER NOT NULL,
-      expires_at INTEGER NOT NULL,
-      FOREIGN KEY (conversationId) REFERENCES conversations(id)
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_voice_cache_conv ON voice_cache(conversationId);
-    CREATE INDEX IF NOT EXISTS idx_voice_cache_expires ON voice_cache(expires_at);
-
-    CREATE TABLE IF NOT EXISTS tool_installations (
-      id TEXT PRIMARY KEY,
-      tool_id TEXT NOT NULL UNIQUE,
-      version TEXT,
-      installed_at INTEGER,
-      status TEXT NOT NULL DEFAULT 'not_installed',
-      last_check_at INTEGER,
-      error_message TEXT,
-      update_available INTEGER DEFAULT 0,
-      latest_version TEXT,
-      created_at INTEGER NOT NULL,
-      updated_at INTEGER NOT NULL
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_tool_installations_status ON tool_installations(status);
-    CREATE INDEX IF NOT EXISTS idx_tool_installations_last_check ON tool_installations(last_check_at);
-
-    CREATE TABLE IF NOT EXISTS tool_install_history (
-      id TEXT PRIMARY KEY,
-      tool_id TEXT NOT NULL,
-      action TEXT NOT NULL,
-      started_at INTEGER NOT NULL,
-      completed_at INTEGER,
-      status TEXT NOT NULL,
-      error_message TEXT,
-      created_at INTEGER NOT NULL,
-      FOREIGN KEY (tool_id) REFERENCES tool_installations(tool_id)
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_tool_install_history_tool ON tool_install_history(tool_id);
-    CREATE INDEX IF NOT EXISTS idx_tool_install_history_completed ON tool_install_history(completed_at);
-
     CREATE TABLE IF NOT EXISTS workflow_runs (
       id TEXT PRIMARY KEY,
       workflowName TEXT NOT NULL,
@@ -159,17 +113,5 @@ export function initSchema(db) {
     CREATE INDEX IF NOT EXISTS idx_workflow_runs_sha ON workflow_runs(sha);
     CREATE INDEX IF NOT EXISTS idx_workflow_runs_completed ON workflow_runs(completedAt);
 
-    CREATE TABLE IF NOT EXISTS oauth_tokens (
-      id TEXT PRIMARY KEY,
-      provider TEXT NOT NULL,
-      token TEXT NOT NULL,
-      email TEXT,
-      expires_at INTEGER,
-      created_at INTEGER NOT NULL,
-      updated_at INTEGER NOT NULL
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_oauth_tokens_provider ON oauth_tokens(provider);
-
   `);
 }

package/lib/db-queries-cleanup.js

@@ -16,8 +16,6 @@ export function addCleanupQueries(q, db, prep, generateId) {
 
       prep('DELETE FROM sessions WHERE completed_at IS NOT NULL AND completed_at < ?').run(thirtyDaysAgo);
 
-      prep('DELETE FROM voice_cache WHERE expires_at <= ?').run(now);
-
       const deletedConvIds = prep("SELECT id FROM conversations WHERE status = 'deleted' AND updated_at < ?").all(sevenDaysAgo).map(r => r.id);
       for (const cid of deletedConvIds) {
         prep('DELETE FROM stream_updates WHERE conversationId = ?').run(cid);
@@ -25,25 +23,15 @@ export function addCleanupQueries(q, db, prep, generateId) {
         prep('DELETE FROM events WHERE conversationId = ?').run(cid);
         prep('DELETE FROM sessions WHERE conversationId = ?').run(cid);
         prep('DELETE FROM messages WHERE conversationId = ?').run(cid);
-        prep('DELETE FROM voice_cache WHERE conversationId = ?').run(cid);
         prep('DELETE FROM thread_states WHERE thread_id = ?').run(cid);
-        prep('DELETE FROM checkpoints WHERE thread_id = ?').run(cid);
         prep('DELETE FROM run_metadata WHERE thread_id = ?').run(cid);
         prep('DELETE FROM conversations WHERE id = ?').run(cid);
       }
 
       prep('DELETE FROM thread_states WHERE created_at < ?').run(thirtyDaysAgo);
-      prep('DELETE FROM checkpoints WHERE created_at < ?').run(thirtyDaysAgo);
       prep('DELETE FROM run_metadata WHERE created_at < ? AND status NOT IN (?, ?)').run(thirtyDaysAgo, 'active', 'pending');
 
       prep('DELETE FROM workflow_runs WHERE created_at < ?').run(thirtyDaysAgo);
-
-      const toolIds = prep('SELECT DISTINCT tool_id FROM tool_install_history').all().map(r => r.tool_id);
-      for (const tid of toolIds) {
-        prep(`DELETE FROM tool_install_history WHERE tool_id = ? AND id NOT IN (
-          SELECT id FROM tool_install_history WHERE tool_id = ? ORDER BY created_at DESC LIMIT 50
-        )`).run(tid, tid);
-      }
     });
 
     cleanupStmt();

package/lib/db-queries-del.js

@@ -107,7 +107,6 @@ export function addDeleteQueries(q, db, prep, generateId) {
         prep('DELETE FROM stream_updates').run();
         prep('DELETE FROM chunks').run();
         prep('DELETE FROM events').run();
-        prep('DELETE FROM voice_cache').run();
         prep('DELETE FROM sessions').run();
         prep('DELETE FROM messages').run();
         prep("UPDATE conversations SET status = 'deleted', updated_at = ? WHERE status != 'deleted'").run(Date.now());

package/lib/db-queries.js

@@ -8,8 +8,6 @@ import { addImportQueries } from './db-queries-import.js';
 import { addStreamQueries } from './db-queries-streams.js';
 import { addChunkQueries } from './db-queries-chunks.js';
 import { addChunkQueries2 } from './db-queries-chunks2.js';
-import { addVoiceQueries } from './db-queries-voice.js';
-import { addToolQueries } from './db-queries-tools.js';
 
 export function createQueries(db, prep, generateId) {
   const q = {
@@ -86,8 +84,6 @@ export function createQueries(db, prep, generateId) {
   addStreamQueries(q, db, prep, generateId);
   addChunkQueries(q, db, prep, generateId);
   addChunkQueries2(q, db, prep, generateId);
-  addVoiceQueries(q, db, prep, generateId);
-  addToolQueries(q, db, prep, generateId);
   Object.assign(q, createACPQueries(db, prep));
   return q;
 }

package/lib/http-handler.js

@@ -3,7 +3,7 @@ import path from 'path';
 import os from 'os';
 import crypto from 'crypto';
 
-export function createHttpHandler({ BASE_URL, expressApp, queries, sendJSON, serveFile, staticDir, messageQueues, getWss, activeExecutions, getACPStatus, discoveredAgents, PKG_VERSION, RATE_LIMIT_MAX, rateLimitMap, routes, handleGeminiOAuthCallback, handleCodexOAuthCallback, PORT }) {
+export function createHttpHandler({ BASE_URL, expressApp, queries, sendJSON, serveFile, staticDir, messageQueues, getWss, activeExecutions, getACPStatus, discoveredAgents, PKG_VERSION, RATE_LIMIT_MAX, rateLimitMap, routes, PORT }) {
   return async function httpHandler(req, res) {
     res.setHeader('Access-Control-Allow-Origin', '*');
     res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
@@ -56,9 +56,6 @@ export function createHttpHandler({ BASE_URL, expressApp, queries, sendJSON, ser
     try {
       const pathOnly = routePath.split('?')[0];
 
-      if (pathOnly === '/oauth2callback' && req.method === 'GET') { await handleGeminiOAuthCallback(req, res, PORT); return; }
-      if (pathOnly === '/codex-oauth2callback' && req.method === 'GET') { await handleCodexOAuthCallback(req, res, PORT); return; }
-
       if (pathOnly === '/api/health' && req.method === 'GET') {
         let dbStatus = { ok: true };
         try { queries._db.prepare('SELECT 1').get(); } catch (e) { dbStatus = { ok: false, error: e.message }; }
@@ -80,20 +77,14 @@ export function createHttpHandler({ BASE_URL, expressApp, queries, sendJSON, ser
       if (runsHandler) { await runsHandler(req, res); return; }
       const agentHandler = routes.agents._match(req.method, pathOnly);
       if (agentHandler) { await agentHandler(req, res); return; }
-      const oauthHandler = routes.oauth._match(req.method, pathOnly);
-      if (oauthHandler) { await oauthHandler(req, res); return; }
       const agentActionsHandler = routes.agentActions._match(req.method, pathOnly);
       if (agentActionsHandler) { await agentActionsHandler(req, res); return; }
       const authConfigHandler = routes.authConfig._match(req.method, pathOnly);
       if (authConfigHandler) { await authConfigHandler(req, res); return; }
-      const speechHandler = routes.speech._match(req.method, pathOnly);
-      if (speechHandler) { await speechHandler(req, res, pathOnly); return; }
       const utilHandler = routes.util._match(req.method, pathOnly);
       if (utilHandler) { await utilHandler(req, res); return; }
       const threadHandler = routes.threads._match(req.method, pathOnly);
       if (threadHandler) { await threadHandler(req, res); return; }
-      const toolHandler = routes.tools._match(req.method, pathOnly);
-      if (toolHandler) { await toolHandler(req, res); return; }
       const debugHandler = routes.debug._match(req.method, pathOnly);
       if (debugHandler) { await debugHandler(req, res); return; }
       if (routePath.startsWith('/api/image/')) {

package/lib/plugins/acp-plugin.js

@@ -7,10 +7,9 @@ import fs from 'fs';
 export default {
   name: 'acp',
   version: '1.0.0',
-  dependencies: ['tools'],
+  dependencies: [],
 
   async init(config, plugins) {
-    const tools = plugins.get('tools');
     const toolProcesses = new Map();
     const healthCheckIntervals = new Map();
     const restartCounts = new Map();

package/lib/plugins/database-plugin.js

@@ -1,4 +1,4 @@
-// Database plugin - SQLite init, schema, checkpoint recovery
+// Database plugin - SQLite init, schema
 
 import * as dbModule from '../../database.js';
 

package/lib/process-message.js

@@ -1,4 +1,4 @@
-export function createProcessMessage({ queries, activeExecutions, rateLimitState, execMachine, broadcastSync, runClaudeWithStreaming, cleanupExecution, checkpointManager, discoveredAgents, STARTUP_CWD, buildSystemPrompt, parseRateLimitResetTime, eagerTTS, touchACP, getJsonlWatcher, debugLog, logError, scheduleRetry, drainMessageQueue, createEventHandler }) {
+export function createProcessMessage({ queries, activeExecutions, rateLimitState, execMachine, broadcastSync, runClaudeWithStreaming, cleanupExecution, discoveredAgents, STARTUP_CWD, buildSystemPrompt, parseRateLimitResetTime, touchACP, getJsonlWatcher, debugLog, logError, scheduleRetry, drainMessageQueue, createEventHandler }) {
   async function processMessageWithStreaming(conversationId, messageId, sessionId, content, agentId, model, subAgent) {
     const startTime = Date.now();
     touchACP(agentId);
@@ -37,7 +37,7 @@ export function createProcessMessage({ queries, activeExecutions, rateLimitState
     const isJsonlBacked = resolvedAgentId === 'claude-code';
     // stateRef tracks eventCount (for session response metadata) and resumeSessionId
     const stateRef = { eventCount: 0, resumeSessionId: conv?.claudeSessionId || null };
-    const onEvent = createEventHandler({ queries, activeExecutions, broadcastSync, rateLimitState, batcherRef: stateRef, sessionId, conversationId, messageId, content, agentId, model, subAgent, isJsonlBacked, getJsonlWatcher, scheduleRetry, eagerTTS, debugLog, parseRateLimitResetTime });
+    const onEvent = createEventHandler({ queries, activeExecutions, broadcastSync, rateLimitState, batcherRef: stateRef, sessionId, conversationId, messageId, content, agentId, model, subAgent, isJsonlBacked, getJsonlWatcher, scheduleRetry, debugLog, parseRateLimitResetTime });
     try {
       debugLog(`[stream] Starting: conversationId=${conversationId}, sessionId=${sessionId}, agent=${resolvedAgentId}, jsonlBacked=${isJsonlBacked}`);
       const resolvedModel = model || conv?.model || null;

package/lib/provider-config.js

@@ -1,8 +1,6 @@
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
-import { getGeminiOAuthStatus } from './oauth-gemini.js';
-import { getCodexOAuthStatus } from './oauth-codex.js';
 
 export function buildSystemPrompt(agentId, model, subAgent) {
   const parts = [];
@@ -96,20 +94,6 @@ export function maskKey(key) {
 export function getProviderConfigs() {
   const configs = {};
   for (const [providerId, config] of Object.entries(PROVIDER_CONFIGS)) {
-    if (providerId === 'google') {
-      const oauthStatus = getGeminiOAuthStatus();
-      if (oauthStatus) {
-        configs[providerId] = { name: config.name, ...oauthStatus };
-        continue;
-      }
-    }
-    if (providerId === 'codex') {
-      const oauthStatus = getCodexOAuthStatus();
-      if (oauthStatus) {
-        configs[providerId] = { name: config.name, ...oauthStatus };
-        continue;
-      }
-    }
     for (const configPath of config.configPaths) {
       try {
         if (fs.existsSync(configPath)) {

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 };
   });