@chrisromp/copilot-bridge 0.10.0 → 0.12.0

package/dist/index.js

@@ -19,6 +19,11 @@ import path from 'node:path';
 const log = createLogger('bridge');
 // Active streaming responses, keyed by channelId
 const activeStreams = new Map(); // channelId → streamKey
+// Channels where the no_reply tool was called — used to suppress the SDK's
+// second agentic turn (which always fires after a tool call).
+const noReplyChannels = new Set();
+// Tracks whether content was emitted after no_reply (second turn succeeded)
+const noReplyHadContent = new Set();
 // Preserve thread context across turn_end stream finalization so auto-started
 // streams stay in the same thread.
 const channelThreadRoots = new Map(); // channelId → threadRootId
@@ -32,7 +37,7 @@ const channelLocks = new Map();
 // Per-channel promise chain to serialize SESSION EVENT handling (prevents race on auto-start)
 const eventLocks = new Map();
 // Channels in "quiet mode" — all streaming output suppressed until we determine
-// whether the response is NO_REPLY. Used for startup nudges and scheduled tasks.
+// whether the response is NO_REPLY. Used for scheduled tasks and silent cron jobs.
 // State managed in src/core/quiet-mode.ts
 // Bot adapters keyed by "platform:botName" for channel→adapter lookup
 const botAdapters = new Map();
@@ -482,7 +487,7 @@ async function main() {
                     log.info(`Auto-registered DM channel ${dm.channelId.slice(0, 8)}... for bot "${botName}"`);
                 }
                 else {
-                    // Mark pre-configured DM channels so nudge logic can identify them
+                    // Mark pre-configured DM channels so restart notice logic can identify them
                     markChannelAsDM(dm.channelId);
                 }
             }
@@ -547,8 +552,8 @@ async function main() {
             }
         },
     });
-    // Nudge admin bot sessions that may have been mid-task before restart
-    nudgeAdminSessions(sessionManager).catch(err => log.error('Admin nudge failed:', err));
+    // Post restart notice to admin DM channels (no session creation needed)
+    postRestartNotices();
     // Graceful shutdown
     const shutdown = async () => {
         log.info('Shutting down...');
@@ -725,7 +730,7 @@ async function handleMidTurnMessage(msg, sessionManager, platformName, botName)
             }
             const mcpInfo = undefined;
             const contextUsage = sessionManager.getContextUsage(msg.channelId);
-            const cmdResult = handleCommand(msg.channelId, commandText, sessionInfo ?? undefined, { verbose: effPrefs.verbose, permissionMode: effPrefs.permissionMode, reasoningEffort: effPrefs.reasoningEffort }, { workingDirectory: channelConfig.workingDirectory, bot: channelConfig.bot }, models, mcpInfo, contextUsage);
+            const cmdResult = handleCommand(msg.channelId, commandText, sessionInfo ?? undefined, { verbose: effPrefs.verbose, permissionMode: effPrefs.permissionMode, reasoningEffort: effPrefs.reasoningEffort }, { workingDirectory: channelConfig.workingDirectory, bot: channelConfig.bot }, models, mcpInfo, contextUsage, getConfig().providers);
             if (cmdResult.handled) {
                 // Model/agent switch while busy — defer to serialized path
                 if (cmdResult.action === 'switch_model' || cmdResult.action === 'switch_agent') {
@@ -763,12 +768,82 @@ async function handleMidTurnMessage(msg, sessionManager, platformName, botName)
     }
     catch { /* best-effort */ }
 }
+/** Test BYOK provider connectivity by hitting its models endpoint. */
+async function testProviderConnectivity(providerName) {
+    const providers = getConfig().providers ?? {};
+    const provider = providers[providerName];
+    if (!provider)
+        return `⚠️ Provider "${providerName}" not found in config.`;
+    const baseUrl = provider.baseUrl.replace(/\/+$/, '');
+    const modelsUrl = `${baseUrl}/models`;
+    // Resolve auth
+    let apiKey = provider.apiKey;
+    if (!apiKey && provider.apiKeyEnv)
+        apiKey = process.env[provider.apiKeyEnv];
+    let bearerToken = provider.bearerToken;
+    if (!bearerToken && provider.bearerTokenEnv)
+        bearerToken = process.env[provider.bearerTokenEnv];
+    const headers = { 'Accept': 'application/json' };
+    if (apiKey)
+        headers['Authorization'] = `Bearer ${apiKey}`;
+    else if (bearerToken)
+        headers['Authorization'] = `Bearer ${bearerToken}`;
+    const startTime = Date.now();
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 10_000);
+        const response = await fetch(modelsUrl, { headers, signal: controller.signal });
+        clearTimeout(timeout);
+        const elapsed = Date.now() - startTime;
+        if (!response.ok) {
+            return `❌ Provider "${providerName}" returned HTTP ${response.status} ${response.statusText}\n  URL: \`${modelsUrl}\``;
+        }
+        const data = await response.json();
+        const modelCount = Array.isArray(data?.data) ? data.data.length : '?';
+        const configuredModels = provider.models.map(m => m.id);
+        const lines = [
+            `✅ Provider "${providerName}" is reachable (${elapsed}ms)`,
+            `  URL: \`${modelsUrl}\``,
+            `  Remote models: ${modelCount}`,
+            `  Configured: ${configuredModels.map(m => `\`${m}\``).join(', ')}`,
+        ];
+        // Check if configured models exist on the remote
+        if (Array.isArray(data?.data)) {
+            const remoteIds = new Set(data.data.map((m) => m.id));
+            const missing = configuredModels.filter(id => !remoteIds.has(id));
+            if (missing.length > 0) {
+                lines.push(`  ⚠️ Not found on remote: ${missing.map(m => `\`${m}\``).join(', ')}`);
+            }
+        }
+        return lines.join('\n');
+    }
+    catch (err) {
+        const elapsed = Date.now() - startTime;
+        if (err?.name === 'AbortError') {
+            return `❌ Provider "${providerName}" timed out after 10s\n  URL: \`${modelsUrl}\``;
+        }
+        const msg = String(err?.message ?? err);
+        if (msg.includes('ECONNREFUSED')) {
+            return `❌ Provider "${providerName}" connection refused\n  URL: \`${modelsUrl}\`\n  Is the service running?`;
+        }
+        if (msg.includes('ENOTFOUND')) {
+            return `❌ Provider "${providerName}" hostname not found\n  URL: \`${modelsUrl}\``;
+        }
+        return `❌ Provider "${providerName}" failed (${elapsed}ms): ${msg}\n  URL: \`${modelsUrl}\``;
+    }
+}
 async function handleInboundMessage(msg, sessionManager, platformName, botName) {
     // Ignore messages from any bot we manage on this platform (prevents cross-bot loops)
     for (const [key, a] of botAdapters) {
         if (key.startsWith(`${platformName}:`) && msg.userId === a.getBotUserId())
             return;
     }
+    // Clear stale no_reply flags from previous turn.
+    // Note: a late post-no_reply error could theoretically arrive after this
+    // clear if the user types very quickly after restart, but post-no_reply errors take
+    // ~30s and users rarely type during that window.
+    noReplyChannels.delete(msg.channelId);
+    noReplyHadContent.delete(msg.channelId);
     // Check user-level access control (reads live config — hot-reloadable)
     const botInfo = getPlatformBots(platformName).get(botName);
     if (!checkUserAccess(msg.userId, msg.username, botInfo?.access, getPlatformAccess(platformName))) {
@@ -847,11 +922,11 @@ async function handleInboundMessage(msg, sessionManager, platformName, botName)
     }
     // Get cached context usage for /context and /status
     const contextUsage = sessionManager.getContextUsage(msg.channelId);
-    const cmdResult = handleCommand(msg.channelId, text, sessionInfo ?? undefined, { verbose: effPrefs.verbose, permissionMode: effPrefs.permissionMode, reasoningEffort: effPrefs.reasoningEffort }, { workingDirectory: channelConfig.workingDirectory, bot: channelConfig.bot }, models, undefined, contextUsage);
+    const cmdResult = handleCommand(msg.channelId, text, sessionInfo ?? undefined, { verbose: effPrefs.verbose, permissionMode: effPrefs.permissionMode, reasoningEffort: effPrefs.reasoningEffort }, { workingDirectory: channelConfig.workingDirectory, bot: channelConfig.bot }, models, undefined, contextUsage, getConfig().providers);
     if (cmdResult.handled) {
         const threadRoot = resolveThreadRoot(msg, threadRequested, channelConfig);
         // Send response before action, except for actions that send their own ack after completing
-        const deferResponse = cmdResult.action === 'switch_model' || cmdResult.action === 'switch_agent' || cmdResult.action === 'set_reasoning';
+        const deferResponse = cmdResult.action === 'switch_model' || cmdResult.action === 'switch_agent' || cmdResult.action === 'set_reasoning' || cmdResult.action === 'reload_mcp' || cmdResult.action === 'reload_skills';
         if (cmdResult.response && !deferResponse) {
             await adapter.sendMessage(msg.channelId, cmdResult.response, { threadRootId: threadRoot });
         }
@@ -930,6 +1005,30 @@ async function handleInboundMessage(msg, sessionManager, platformName, botName)
                 await adapter.updateMessage(msg.channelId, ackId, reloadMsg);
                 break;
             }
+            case 'reload_mcp': {
+                const mcpAck = await adapter.sendMessage(msg.channelId, '⏳ Reloading MCP servers...', { threadRootId: threadRoot });
+                try {
+                    await sessionManager.reloadMcp(msg.channelId);
+                    await adapter.updateMessage(msg.channelId, mcpAck, '✅ MCP servers reloaded.');
+                }
+                catch (err) {
+                    log.warn(`MCP reload failed for ${msg.channelId}:`, err);
+                    await adapter.updateMessage(msg.channelId, mcpAck, `❌ MCP reload failed: ${err?.message ?? err}`);
+                }
+                break;
+            }
+            case 'reload_skills': {
+                const skillsAck = await adapter.sendMessage(msg.channelId, '⏳ Reloading skills...', { threadRootId: threadRoot });
+                try {
+                    await sessionManager.reloadSkills(msg.channelId);
+                    await adapter.updateMessage(msg.channelId, skillsAck, '✅ Skills reloaded.');
+                }
+                catch (err) {
+                    log.warn(`Skills reload failed for ${msg.channelId}:`, err);
+                    await adapter.updateMessage(msg.channelId, skillsAck, `❌ Skills reload failed: ${err?.message ?? err}`);
+                }
+                break;
+            }
             case 'resume_session': {
                 const oldResumeStream = activeStreams.get(msg.channelId);
                 if (oldResumeStream) {
@@ -999,7 +1098,8 @@ async function handleInboundMessage(msg, sessionManager, platformName, botName)
             case 'switch_model': {
                 const ackId = await adapter.sendMessage(msg.channelId, '⏳ Switching model...', { threadRootId: threadRoot });
                 try {
-                    await sessionManager.switchModel(msg.channelId, cmdResult.payload);
+                    const { modelId, provider } = cmdResult.payload;
+                    await sessionManager.switchModel(msg.channelId, modelId, provider);
                     await adapter.updateMessage(msg.channelId, ackId, cmdResult.response ?? '✅ Model switched.');
                 }
                 catch (err) {
@@ -1020,6 +1120,19 @@ async function handleInboundMessage(msg, sessionManager, platformName, botName)
                 }
                 break;
             }
+            case 'provider_test': {
+                const providerName = cmdResult.payload;
+                const ackId = await adapter.sendMessage(msg.channelId, cmdResult.response ?? `🔄 Testing provider "${providerName}"...`, { threadRootId: threadRoot });
+                try {
+                    const result = await testProviderConnectivity(providerName);
+                    await adapter.updateMessage(msg.channelId, ackId, result);
+                }
+                catch (err) {
+                    log.error(`Provider test failed for "${providerName}":`, err);
+                    await adapter.updateMessage(msg.channelId, ackId, `❌ Provider test failed: ${err?.message ?? 'unknown error'}`);
+                }
+                break;
+            }
             case 'set_reasoning': {
                 const reasoningSessionId = sessionManager.getSessionId(msg.channelId);
                 if (!reasoningSessionId) {
@@ -1029,14 +1142,12 @@ async function handleInboundMessage(msg, sessionManager, platformName, botName)
                 }
                 const ackId = await adapter.sendMessage(msg.channelId, `🧠 Setting reasoning effort to **${cmdResult.payload}**...`, { threadRootId: threadRoot });
                 try {
-                    const newId = await sessionManager.reloadSession(msg.channelId);
-                    const wasNew = newId !== reasoningSessionId;
-                    const suffix = wasNew ? ' (previous session expired — new session created)' : '';
-                    await adapter.updateMessage(msg.channelId, ackId, `🧠 Reasoning effort set to **${cmdResult.payload}**.${suffix}`);
+                    await sessionManager.setReasoningEffort(msg.channelId, cmdResult.payload);
+                    await adapter.updateMessage(msg.channelId, ackId, `🧠 Reasoning effort set to **${cmdResult.payload}**.`);
                 }
                 catch (err) {
-                    log.error(`Failed to reload session for reasoning on ${msg.channelId.slice(0, 8)}...:`, err);
-                    await adapter.updateMessage(msg.channelId, ackId, `🧠 Reasoning effort saved as **${cmdResult.payload}** but session reload failed. Use \`/reload\` to apply.`);
+                    log.error(`Failed to set reasoning effort on ${msg.channelId.slice(0, 8)}...:`, err);
+                    await adapter.updateMessage(msg.channelId, ackId, `🧠 Reasoning effort saved as **${cmdResult.payload}** but RPC failed. Use \`/reload\` to apply.`);
                 }
                 break;
             }
@@ -1270,11 +1381,25 @@ async function handleInboundMessage(msg, sessionManager, platformName, botName)
                     if (toggleAction === 'disable') {
                         const allNames = [...new Set(skills.map(s => s.name))];
                         setChannelPrefs(msg.channelId, { disabledSkills: allNames });
-                        await adapter.sendMessage(msg.channelId, `🔴 Disabled all ${allNames.length} skills. Use \`/reload\` to apply.`, { threadRootId: threadRoot });
+                        // Apply via RPC for each skill
+                        for (const name of allNames) {
+                            try {
+                                await sessionManager.toggleSkillRpc(msg.channelId, name, 'disable');
+                            }
+                            catch { /* best-effort */ }
+                        }
+                        await adapter.sendMessage(msg.channelId, `🔴 Disabled all ${allNames.length} skills.`, { threadRootId: threadRoot });
                     }
                     else {
+                        const allNames = [...currentDisabled];
                         setChannelPrefs(msg.channelId, { disabledSkills: [] });
-                        await adapter.sendMessage(msg.channelId, `🟢 Enabled all skills. Use \`/reload\` to apply.`, { threadRootId: threadRoot });
+                        for (const name of allNames) {
+                            try {
+                                await sessionManager.toggleSkillRpc(msg.channelId, name, 'enable');
+                            }
+                            catch { /* best-effort */ }
+                        }
+                        await adapter.sendMessage(msg.channelId, `🟢 Enabled all skills.`, { threadRootId: threadRoot });
                     }
                     break;
                 }
@@ -1310,6 +1435,13 @@ async function handleInboundMessage(msg, sessionManager, platformName, botName)
                 }
                 if (matched.length > 0) {
                     setChannelPrefs(msg.channelId, { disabledSkills: [...currentDisabled] });
+                    // Apply each toggle via RPC (best-effort — pref is already persisted)
+                    for (const name of matched) {
+                        try {
+                            await sessionManager.toggleSkillRpc(msg.channelId, name, toggleAction);
+                        }
+                        catch { /* best-effort */ }
+                    }
                 }
                 const lines = [];
                 if (matched.length > 0) {
@@ -1323,9 +1455,6 @@ async function handleInboundMessage(msg, sessionManager, platformName, botName)
                 if (notFound.length > 0) {
                     lines.push(`❌ No match: ${notFound.map(n => `"${n}"`).join(', ')}`);
                 }
-                if (matched.length > 0) {
-                    lines.push('Use `/reload` to apply.');
-                }
                 await adapter.sendMessage(msg.channelId, lines.join(' '), { threadRootId: threadRoot });
                 break;
             }
@@ -1840,6 +1969,14 @@ async function handleSessionEvent(sessionId, channelId, event, sessionManager) {
             }
             if (event.type === 'assistant.message') {
                 const content = formatted.content?.trim();
+                // Check if this message includes a no_reply tool request — the SDK may
+                // bundle tool requests with content and then skip tool execution entirely,
+                // so we must detect no_reply here (not just in tool.execution_start)
+                const toolRequests = event.data?.toolRequests;
+                const hasNoReply = toolRequests?.some(t => t.name === 'no_reply');
+                if (hasNoReply) {
+                    noReplyChannels.add(channelId);
+                }
                 // Skip empty assistant.message events (tool-call signals)
                 if (!content)
                     return;
@@ -1866,6 +2003,15 @@ async function handleSessionEvent(sessionId, channelId, event, sessionManager) {
         // Suppress verbose/tool/status events during quiet — but let session.idle
         // and session.error pass through so channel idle tracking still works
         if (formatted.type === 'tool_start' || formatted.type === 'tool_complete') {
+            // Detect no_reply tool even during quiet mode so we can suppress the
+            // second-turn error that the SDK fires after the tool completes
+            if (formatted.type === 'tool_start' && event.type === 'tool.execution_start') {
+                const toolName = event.data?.toolName ?? event.data?.name;
+                if (toolName === 'no_reply') {
+                    log.info(`no_reply tool invoked (quiet) on channel ${channelId.slice(0, 8)}...`);
+                    noReplyChannels.add(channelId);
+                }
+            }
             return;
         }
         if (formatted.type === 'status' && event.type !== 'session.idle') {
@@ -1874,7 +2020,20 @@ async function handleSessionEvent(sessionId, channelId, event, sessionManager) {
         // Errors: exit quiet and fall through to normal error handling (surfaces to user)
         if (formatted.type === 'error') {
             exitQuietMode(channelId);
-            // Fall through to normal error handling
+            // Fall through to post-no_reply suppression or normal error handling below
+        }
+    }
+    // Suppress errors from the second agentic turn after no_reply tool.
+    // The SDK always starts another turn after a tool call; that turn's model
+    // call may fail but the session remains functional.
+    // Scoped to the specific SDK error to avoid masking unrelated failures.
+    if (formatted.type === 'error' && noReplyChannels.has(channelId)) {
+        const msg = event.data?.message ?? '';
+        if (typeof msg === 'string' && msg.includes('Failed to get response from the AI model')) {
+            log.info(`Suppressing post-no_reply model error on ${channelId.slice(0, 8)}...`);
+            noReplyChannels.delete(channelId);
+            noReplyHadContent.delete(channelId);
+            return;
         }
     }
     if (formatted.verbose && !verbose)
@@ -1886,6 +2045,31 @@ async function handleSessionEvent(sessionId, channelId, event, sessionManager) {
             cancelIdleDebounce(channelId);
             if (!isBusy(channelId))
                 markBusy(channelId);
+            // Track if content arrives after no_reply (second turn succeeded)
+            if (noReplyChannels.has(channelId) && formatted.content?.trim()) {
+                noReplyHadContent.add(channelId);
+            }
+            // Suppress NO_REPLY responses — agent decided no response was needed.
+            // This can happen outside quiet mode when the agent determines a user
+            // message doesn't require a reply.
+            if (event.type === 'assistant.message') {
+                // Detect no_reply in tool requests bundled with the message — the SDK
+                // may skip tool execution when content is present alongside tool calls
+                const toolReqs = event.data?.toolRequests;
+                if (toolReqs?.some(t => t.name === 'no_reply')) {
+                    noReplyChannels.add(channelId);
+                }
+                const trimmed = formatted.content?.trim();
+                if (trimmed === 'NO_REPLY' || trimmed === '`NO_REPLY`') {
+                    log.info(`Filtered NO_REPLY on channel ${channelId.slice(0, 8)}...`);
+                    const sk = activeStreams.get(channelId);
+                    if (sk) {
+                        await streaming.deleteStream(sk);
+                        activeStreams.delete(channelId);
+                    }
+                    break;
+                }
+            }
             // When response content starts, finalize the activity feed
             if (activityFeeds.has(channelId)) {
                 await finalizeActivityFeed(channelId, adapter);
@@ -1939,6 +2123,12 @@ async function handleSessionEvent(sessionId, channelId, event, sessionManager) {
             if (event.type === 'tool.execution_start') {
                 const toolName = event.data?.toolName ?? event.data?.name ?? 'unknown';
                 const args = event.data?.arguments ?? {};
+                // Detect no_reply tool — mark channel for stream suppression
+                if (toolName === 'no_reply') {
+                    log.info(`no_reply tool invoked on channel ${channelId.slice(0, 8)}...`);
+                    noReplyChannels.add(channelId);
+                    break;
+                }
                 const loop = loopDetector.recordToolCall(channelId, toolName, args);
                 if (loop.isCritical) {
                     // Critical loop — warn and force a new session
@@ -2028,7 +2218,30 @@ async function handleSessionEvent(sessionId, channelId, event, sessionManager) {
                 await finalizeActivityFeed(channelId, adapter);
                 initialStreamPosted.delete(channelId);
                 channelThreadRoots.delete(channelId);
-                if (streamKey) {
+                // If no_reply tool was called, handle stream based on whether
+                // the SDK's second turn produced any content.
+                if (noReplyChannels.has(channelId)) {
+                    if (noReplyHadContent.has(channelId)) {
+                        // Second turn succeeded and produced content — finalize normally
+                        // (content will already have been suppressed by quiet mode or
+                        // the text NO_REPLY fallback in most cases)
+                        log.info(`no_reply: second turn had content, finalizing stream for ${channelId.slice(0, 8)}...`);
+                        if (streamKey) {
+                            await streaming.finalizeStream(streamKey);
+                            activeStreams.delete(channelId);
+                        }
+                    }
+                    else if (streamKey) {
+                        // No content from second turn — delete the stream silently
+                        log.info(`no_reply: deleting stream for ${channelId.slice(0, 8)}...`);
+                        await streaming.deleteStream(streamKey);
+                        activeStreams.delete(channelId);
+                    }
+                    noReplyHadContent.delete(channelId);
+                    // Don't clear noReplyChannels here — the SDK may start a second
+                    // agentic turn that errors. We clear it on the error or next message.
+                }
+                else if (streamKey) {
                     log.info(`Session idle, finalizing stream for ${channelId.slice(0, 8)}...`);
                     await streaming.finalizeStream(streamKey);
                     activeStreams.delete(channelId);
@@ -2089,41 +2302,23 @@ async function finalizeActivityFeed(channelId, adapter) {
     }
     activityFeeds.delete(channelId);
 }
-// --- Admin Session Nudge ---
-const NUDGE_PROMPT = `The bridge service was just restarted. If you were in the middle of a task, review your conversation history and continue where you left off. If you were not mid-task, respond with exactly: NO_REPLY`;
-async function nudgeAdminSessions(sessionManager) {
+// --- Startup Restart Notice ---
+/** Post a restart notice to admin DM channels (no session creation or LLM interaction). */
+function postRestartNotices() {
     const allSessions = getAllChannelSessions();
-    if (allSessions.length === 0)
-        return;
     for (const { channelId } of allSessions) {
-        // Only nudge channels belonging to admin bots
         if (!isConfiguredChannel(channelId))
             continue;
         const channelConfig = getChannelConfig(channelId);
         const botName = getChannelBotName(channelId);
         if (!isBotAdmin(channelConfig.platform, botName))
             continue;
-        try {
-            log.info(`Nudging admin session for bot "${botName}" on channel ${channelId.slice(0, 8)}...`);
-            // Only post the visible restart notice in DM channels
-            if (channelConfig.isDM) {
-                const resolved = getAdapterForChannel(channelId);
-                if (resolved) {
-                    resolved.adapter.sendMessage(channelId, '🔄 Bridge restarted.').catch(e => log.warn(`Failed to post restart notice on ${channelId.slice(0, 8)}...:`, e));
-                }
-            }
-            const clearQuiet = enterQuietMode(channelId);
-            try {
-                await sessionManager.sendMessage(channelId, NUDGE_PROMPT);
-            }
-            finally {
-                clearQuiet();
-            }
-        }
-        catch (err) {
-            exitQuietMode(channelId);
-            log.warn(`Failed to nudge admin session on channel ${channelId.slice(0, 8)}...:`, err);
-        }
+        if (!channelConfig.isDM)
+            continue;
+        const resolved = getAdapterForChannel(channelId);
+        if (!resolved)
+            continue;
+        resolved.adapter.sendMessage(channelId, '🔄 Bridge restarted.').catch(e => log.warn(`Failed to post restart notice on ${channelId.slice(0, 8)}...:`, e));
     }
 }
 // Start the bridge