@0xmaxma/claude-gateway 2.0.4 → 2.0.5

package/dist/agent/runner.js

@@ -35,8 +35,10 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentRunner = exports.CHANNEL_COALESCE_WINDOW_MS = exports.WHATSAPP_CLOUD_WINDOW_NOTE = exports.DEFAULT_MODELS = exports.MAX_IMAGE_SIZE_BYTES = void 0;
 exports.toRelMediaFiles = toRelMediaFiles;
+const response_errors_1 = require("../orchestration/response-errors");
 const channel_media_error_1 = require("../orchestration/channel-media-error");
 const store_1 = require("../orchestration/store");
+const config_1 = require("../orchestration/config");
 const channel_input_media_1 = require("../orchestration/channel-input-media");
 const chunks_1 = require("../telegram/chunks");
 const file_delivery_1 = require("../orchestration/file-delivery");
@@ -56,7 +58,7 @@ const config_write_lock_1 = require("../config/config-write-lock");
 const logger_1 = require("../logger");
 const process_1 = require("../session/process");
 const store_2 = require("../session/store");
-const compactor_1 = require("../session/compactor");
+const native_compact_1 = require("../orchestration/native-compact");
 const receiver_1 = require("../telegram/receiver");
 const receiver_2 = require("../discord/receiver");
 const line_reply_manager_1 = require("./line-reply-manager");
@@ -73,7 +75,7 @@ const skills_1 = require("../skills");
 const builtin_commands_1 = require("./builtin-commands");
 const model_catalog_1 = require("./model-catalog");
 const safe_mode_1 = require("./safe-mode");
-const config_1 = require("./skill-learning/config");
+const config_2 = require("./skill-learning/config");
 const turn_stream_1 = require("./turn-stream");
 const recovery_executor_1 = require("./recovery-executor");
 const recovery_policy_1 = require("./recovery-policy");
@@ -348,9 +350,21 @@ class AgentRunner extends events_1.EventEmitter {
     async subscribeResponseText(sessionId, principalId, receive) {
         return (await this.getOrchestration()).subscribeText(sessionId, principalId, receive);
     }
+    async setBrowserVoice(sessionId, principalId, enabled) {
+        return (await this.getOrchestration()).setBrowserVoice(sessionId, principalId, enabled);
+    }
+    async pendingVoiceSpeech(sessionId, principalId, claimed = []) {
+        return (await this.getOrchestration()).pendingVoiceSpeech(sessionId, principalId, claimed);
+    }
     async voiceReplay(sessionId, principalId, responseId) {
         return (await this.getOrchestration()).voiceAudio(sessionId, principalId, responseId);
     }
+    async replayableVoiceResponses(sessionId, principalId) {
+        return (await this.getOrchestration()).replayableVoiceResponses(sessionId, principalId);
+    }
+    async voiceReplaySpeech(sessionId, principalId, responseId) {
+        return (await this.getOrchestration()).voiceReplaySpeech(sessionId, principalId, responseId);
+    }
     saveVoiceReplay(sessionId, principalId, responseId, audio) {
         this.orchestration?.saveVoiceAudio(sessionId, principalId, responseId, audio);
     }
@@ -642,6 +656,7 @@ class AgentRunner extends events_1.EventEmitter {
                 }
             });
         };
+        this.compactingSessions = new Set();
         this.telegramCommandConfig = '';
         this.agentConfig = (0, gateway_config_1.applyGatewayOrchestration)(agentConfig, gatewayConfig);
         this.gatewayConfig = gatewayConfig;
@@ -907,6 +922,7 @@ class AgentRunner extends events_1.EventEmitter {
                             .then(() => this.writeTypingDone(chatId))
                             .catch((err) => {
                             this.logger.error('Session command failed', { error: err.message });
+                            this.writeAutoForward(chatId, 'Command failed: ' + err.message);
                             this.writeTypingDone(chatId);
                         });
                         return;
@@ -1375,7 +1391,7 @@ class AgentRunner extends events_1.EventEmitter {
                 return;
             }
             const restarted = await this.restartChannelSessions();
-            respond({ success: true, model: newModel, restarted });
+            respond({ success: true, model: newModel, restarted, appliesNextTurn: !restarted });
             return;
         }
         if (command === 'restart') {
@@ -2189,6 +2205,7 @@ class AgentRunner extends events_1.EventEmitter {
         // size when the cap has been lowered.
         const recoveryCount = this.tooLargeRecoveries.get(mapKey) ?? 0;
         proc.historyLimit = this.spawnHistoryLimit(configuredMax, recoveryCount);
+        proc.historyRecoveryActive = recoveryCount > 0;
         if (recoveryCount > 0) {
             this.logger.info('Spawning with reduced history after request_too_large', {
                 mapKey, recoveryCount, historyLimit: proc.historyLimit,
@@ -2800,6 +2817,7 @@ class AgentRunner extends events_1.EventEmitter {
         }
         else if (content.startsWith('/clear')) {
             await this.handleCommandClear(agentId, chatId);
+            this.writeAutoForward(chatId, 'Claude Code context reset. Chat history is unchanged. The next message loads the latest 50 messages.');
         }
         else if (content.startsWith('/compact')) {
             await this.handleCommandCompact(agentId, chatId);
@@ -2869,7 +2887,7 @@ class AgentRunner extends events_1.EventEmitter {
         }
         if (!this.isDirectChat(meta)) {
             this.writeAutoForward(chatId, 'Switching models is only available in a direct message with the bot — '
-                + 'it changes the model for every chat of this agent and restarts them. '
+                + 'it changes the model for every chat of this agent. '
                 + 'Use /models here to see the list.');
             return;
         }
@@ -2885,10 +2903,10 @@ class AgentRunner extends events_1.EventEmitter {
             return;
         }
         await this.setModel(match.id);
-        // Same restart the Telegram picker's set_model does — the running session
-        // was spawned with the old model and would otherwise keep using it.
+        // Legacy sessions need respawning; managed decisions pick up the new model
+        // on their next spawn without terminating the response in progress.
         const restarted = await this.restartChannelSessions();
-        this.writeAutoForward(chatId, `Model set to ${match.label} (${match.id}).${restarted ? ' Restarting the session…' : ''}`);
+        this.writeAutoForward(chatId, `Model set to ${match.label} (${match.id}).${restarted ? ' Restarting the session…' : ' Applies to the next response; current work continues.'}`);
     }
     /**
      * /sessions — list all sessions for this chat.
@@ -3005,87 +3023,76 @@ class AgentRunner extends events_1.EventEmitter {
         const stopped = interrupted || hadActive || hadQueued || !!buffered;
         this.writeAutoForward(chatId, stopped ? 'Stopped.' : 'No turn in progress.');
     }
-    /**
-     * /clear — clear history of the current session and restart the process.
-     * Also clears the permanent history DB and media files for this chat.
-     */
+    /** /clear rotates model context while preserving history, media and tasks. */
+    async clearContext(sessionId) {
+        if (this.compactingSessions.has(sessionId))
+            throw new Error('Context maintenance is already running for this session.');
+        this.compactingSessions.add(sessionId);
+        try {
+            const runtime = this.orchestration ?? (this.agentConfig.orchestration?.enabled ? await this.getOrchestration() : undefined);
+            if (runtime?.isBusy(sessionId))
+                throw new Error('The agent is responding. Try /clear after the current response finishes.');
+            const sessions = [...this.sessions.entries()].filter(([, process]) => process.sessionId === sessionId);
+            if (sessions.some(([, process]) => process.isProcessing))
+                throw new Error('The agent is responding. Try /clear after the current response finishes.');
+            for (const [key, process] of sessions) {
+                await process.stop();
+                if (this.sessions.get(key) === process)
+                    this.sessions.delete(key);
+            }
+            // No await between persisting the seed window and dropping the resume mapping.
+            // The marker survives gateway restarts until a successful turn consumes it.
+            if (runtime?.isBusy(sessionId))
+                throw new Error('The agent is responding. Try /clear after the current response finishes.');
+            this.sessionStore.requestContextReset(this.agentConfig.id, sessionId);
+            if (runtime?.ownsSession(sessionId))
+                runtime.resetSessionContext(sessionId);
+            for (const key of [sessionId, ...sessions.map(([key]) => key)]) {
+                this.tooLargeRecoveries.delete(key);
+                this.tooLargeExhausted.delete(key);
+            }
+        }
+        finally {
+            this.compactingSessions.delete(sessionId);
+        }
+    }
     async handleCommandClear(agentId, chatId) {
-        const ch = this.channelFor(chatId);
-        const sessionId = await this.sessionStore.getActiveSessionId(agentId, chatId, ch);
-        // Clear messages and reset all metadata in-place (preserves session ID and name)
-        await this.sessionStore.clearTelegramSessionHistory(agentId, chatId, sessionId, ch);
-        await this.sessionStore.updateSessionMeta(agentId, chatId, sessionId, {
-            totalTokensUsed: 0,
-            lastInputTokens: 0,
-            archivedCount: 0,
-            loadedAtSpawn: undefined,
-            messageCountAtSpawn: undefined,
-        }, ch);
-        // Clear permanent history DB for this chat
-        const historyChatId = `${ch}-${chatId}`;
-        this.historyDb.clearChat(historyChatId);
-        // Delete persisted media files for this chat
-        media_store_1.MediaStore.clearChatMedia(this.agentsBaseDir, agentId, historyChatId);
-        // Reset any request_too_large escalation — the context is now empty, so the
-        // next spawn should start fresh at the top of the history ladder.
-        this.tooLargeRecoveries.delete(chatId);
-        this.tooLargeExhausted.delete(chatId);
-        // Kill old process so next message spawns fresh
-        this.restartProcess(chatId).catch(() => { });
+        const sessionId = await this.sessionStore.getActiveSessionId(agentId, chatId, this.channelFor(chatId));
+        await this.clearContext(sessionId);
+    }
+    /** Native CLI compaction leaves canonical chat history intact. */
+    async compactContext(sessionId, model) {
+        if (this.compactingSessions.has(sessionId))
+            throw new Error('Context compaction is already running for this session.');
+        this.compactingSessions.add(sessionId);
+        try {
+            const runtime = this.orchestration ?? (this.agentConfig.orchestration?.enabled ? await this.getOrchestration() : undefined);
+            if (runtime?.ownsSession(sessionId))
+                return await runtime.compactSession(sessionId, model);
+            const process = [...this.sessions.values()].find(p => p.sessionId === sessionId && p.isRunning());
+            if (!process)
+                throw new Error('No active Claude Code context to compact. Send a message first; chat history was not changed.');
+            if (process.isProcessing)
+                throw new Error('The agent is responding. Try /compact after the current response finishes.');
+            if (this.gatewayConfig.gateway.headless === false)
+                throw new Error('Native /compact currently requires the headless Claude Code backend. Chat history was not changed.');
+            await (0, native_compact_1.startNativeCompact)(process, true).result;
+        }
+        finally {
+            this.compactingSessions.delete(sessionId);
+        }
     }
-    /**
-     * /compact — summarise old history and keep only recent messages.
-     */
     async handleCommandCompact(agentId, chatId) {
         const ch = this.channelFor(chatId);
         const sessionId = await this.sessionStore.getActiveSessionId(agentId, chatId, ch);
-        const index = await this.sessionStore.listSessions(agentId, chatId, ch);
-        const meta = index.sessions.find(s => s.id === sessionId);
-        const name = meta?.name ?? 'Session';
-        const compactModel = this.agentConfig.claude.model;
-        const contextWindow = await this.contextWindowFor(compactModel);
-        this.writeAutoForward(chatId, `⏳ Compacting session "${name}"...`);
+        this.writeAutoForward(chatId, '⏳ Compacting Claude Code context…');
         try {
-            const compactor = new compactor_1.SessionCompactor(this.sessionStore);
-            // Large sessions summarize in many chunks (see compactor.ts); post a status
-            // update at each ~25% step so the channel doesn't look dead mid-compact.
-            // Throttled (not per-chunk) to avoid spamming the chat on a 16+ chunk job.
-            let lastReportedPct = -1;
-            const onProgress = (done, total) => {
-                if (total <= 1)
-                    return;
-                const pct = Math.floor((done / total) * 100);
-                if (pct - lastReportedPct >= 25) {
-                    lastReportedPct = pct;
-                    this.writeAutoForward(chatId, `⏳ Compacting session "${name}"... ${done}/${total} parts summarized`);
-                }
-            };
-            const result = await compactor.compact(agentId, chatId, sessionId, compactModel, contextWindow, ch, onProgress);
-            await this.sessionStore.updateSessionMeta(agentId, chatId, sessionId, {
-                loadedAtSpawn: undefined,
-                archivedCount: undefined,
-                messageCountAtSpawn: undefined,
-            }, ch);
-            await this.restartProcess(chatId);
-            const summary = [
-                `✅ Session compacted`,
-                '',
-                `Before: ${result.beforeMessages} messages (~${result.beforeTokens.toLocaleString()} tokens)  →  ${result.contextPctBefore}% of context`,
-                `After:  ${result.afterMessages} messages (~${result.afterTokens.toLocaleString()} tokens)   →  ${result.contextPctAfter}% of context`,
-                `Reduced by: ${result.reductionPct}%`,
-                '',
-                'Summary preserved. Full history before compaction is archived.',
-            ].join('\n');
-            this.writeAutoForward(chatId, summary);
+            await this.compactContext(sessionId);
+            this.writeAutoForward(chatId, '✅ Claude Code context compacted. Chat history is unchanged.');
         }
         catch (err) {
-            if (err.name === 'NotEnoughMessagesError') {
-                this.writeAutoForward(chatId, `⚠️ ${err.message}`);
-            }
-            else {
-                this.logger.error('Compact failed', { error: err.message });
-                this.writeAutoForward(chatId, `❌ Compact failed: ${err.message}\n\nYour session history is unchanged.`);
-            }
+            this.logger.error('Compact failed', { error: err.message });
+            this.writeAutoForward(chatId, 'Context compaction failed: ' + err.message + '\nChat history is unchanged.');
         }
     }
     /**
@@ -4161,9 +4168,9 @@ class AgentRunner extends events_1.EventEmitter {
         // Each precedence level is validated in turn — an invalid-but-present
         // cleanupTimezone does not count as "set" and falls through to gw.timezone
         // rather than jumping straight to UTC (issue #462 review).
-        const cleanupTimezone = (0, config_1.isValidTimezone)(gw.history?.cleanupTimezone)
+        const cleanupTimezone = (0, config_2.isValidTimezone)(gw.history?.cleanupTimezone)
             ? gw.history.cleanupTimezone
-            : (0, config_1.isValidTimezone)(gw.timezone)
+            : (0, config_2.isValidTimezone)(gw.timezone)
                 ? gw.timezone
                 : 'UTC';
         const agentMediaRoot = media_store_1.MediaStore.agentMediaRoot(this.agentsBaseDir, this.agentConfig.id);
@@ -4185,6 +4192,23 @@ class AgentRunner extends events_1.EventEmitter {
     isRunning() {
         return this.receiver?.isRunning() ?? false;
     }
+    getDashboardSource() {
+        return { workspace: this.agentConfig.type === 'app-agent' ? undefined : this.agentConfig.workspace, filename: path.join(this.agentDir, 'orchestration.db'), historyFilename: path.join(this.agentDir, 'history.db'),
+            enabled: Boolean(this.orchestration || this.agentConfig.orchestration?.enabled),
+            workspaceMode: this.agentConfig.type === 'app-agent' ? 'container' : this.agentConfig.orchestration?.tasks?.workspaceMode ?? 'host',
+            maxWorkers: this.agentConfig.orchestration?.tasks?.maxConcurrentPerAgent ?? config_1.ORCHESTRATION_DEFAULTS.tasks.maxConcurrentPerAgent,
+            idleTtlMs: this.agentConfig.orchestration?.tasks?.workerIdleTtlMs ?? config_1.ORCHESTRATION_DEFAULTS.tasks.workerIdleTtlMs };
+    }
+    async dashboardContextWindow(model) {
+        const models = await this.availableModels();
+        return models.find(m => m.id === model)?.contextWindow
+            ?? (this.gatewayConfig.gateway.models ?? exports.DEFAULT_MODELS).find(m => m.id === model)?.contextWindow
+            ?? null;
+    }
+    getTokenReport(sessionId) {
+        const report = this.orchestration?.tokenReport(sessionId);
+        return report ? { ...report, backgroundReviews: this.historyDb.listReviewRuns().filter(run => run.sessionId === sessionId) } : undefined;
+    }
     getOrchestrationSummary() {
         if (!this.agentConfig.orchestration?.enabled && !this.orchestration)
             return undefined;
@@ -4224,6 +4248,29 @@ class AgentRunner extends events_1.EventEmitter {
         }
         return out;
     }
+    /**
+     * Session IDs currently alive in the in-memory session map. Display-only
+     * liveness signal for the dashboard: a session removed by the idle cleaner
+     * (kept-alive window elapsed) or released is no longer present here.
+     */
+    liveSessionIds() {
+        return [...this.sessions.values()].filter(p => p.isRunning()).map(p => p.sessionId);
+    }
+    /**
+     * Live status of one agent session derived from the in-memory session map:
+     * - 'running' → alive and processing a turn right now
+     * - 'idle'    → alive and kept warm, not currently processing
+     * - 'stopped' → gone from the map (idle-timeout kill or otherwise released)
+     * Display-only; does not touch token accounting.
+     */
+    isSessionCompacting(sessionId) { return this.orchestration?.isCompacting(sessionId) ?? false; }
+    agentSessionLiveStatus(sessionId) {
+        for (const p of this.sessions.values()) {
+            if (p.sessionId === sessionId && p.isRunning())
+                return p.isProcessing ? 'running' : 'idle';
+        }
+        return 'stopped';
+    }
     /**
      * Send a message to an API session and wait for the response.
      *
@@ -4526,7 +4573,10 @@ class AgentRunner extends events_1.EventEmitter {
             void this.sendOrchestratedApi(sessionId, chatId, message, { ...opts, requestId: turn.requestId }, text => turn.emit({ type: 'text_delta', text }), event => { if (event.type === 'tool_use')
                 turn.emit({ ...event, type: 'tool_use' }); })
                 .then(result => this.turnStreams.complete(turn, (0, turn_stream_1.resultEvent)(result.text, result.attachments)))
-                .catch(error => this.turnStreams.complete(turn, (0, turn_stream_1.errorEvent)(error), error));
+                .catch(error => {
+                const publicError = (0, response_errors_1.presentedResponseError)(error);
+                this.turnStreams.complete(turn, (0, turn_stream_1.errorEvent)(publicError), publicError);
+            });
             return () => turn.detach(sink);
         }
         if (this.pendingApiSessions.has(sessionId)) {
@@ -5022,10 +5072,7 @@ class AgentRunner extends events_1.EventEmitter {
             this.historyDb.insertMessage({ chatId: dbChatId, sessionId, source: 'api', role, content, ts: Date.now() });
         };
         // Persist the full user command before executing so it appears in history.
-        // Skip for /clear — clearSession() below wipes the table anyway; only the response survives.
-        if (cmd !== '/clear') {
-            persist('user', opts?.displayCommand ?? command);
-        }
+        persist('user', opts?.displayCommand ?? command);
         let result;
         let responseText;
         let forcePersist = false;
@@ -5130,36 +5177,14 @@ class AgentRunner extends events_1.EventEmitter {
                 }
             }
             else if (cmd === '/clear') {
-                const ch = 'api';
-                await this.sessionStore.clearTelegramSessionHistory(agentId, storeChatId, sessionId, ch);
-                await this.sessionStore.updateSessionMeta(agentId, storeChatId, sessionId, {
-                    totalTokensUsed: 0,
-                    lastInputTokens: 0,
-                    archivedCount: 0,
-                    loadedAtSpawn: undefined,
-                    messageCountAtSpawn: undefined,
-                }, ch);
-                const mediaPaths = this.historyDb.clearSession(dbChatId, sessionId);
-                media_store_1.MediaStore.deleteMediaFiles(this.agentsBaseDir, agentId, mediaPaths);
-                this.restartProcess(sessionId).catch(() => { });
-                result = { success: true };
-                responseText = 'Session cleared.';
+                await this.clearContext(sessionId);
+                result = { success: true, historyUnchanged: true, historyLimit: 50 };
+                responseText = 'Claude Code context reset. Chat history is unchanged. Your next message starts a new context with the latest 50 messages.';
             }
             else if (cmd === '/compact') {
-                const ch = 'api';
-                const activeSession = this.sessions.get(sessionId);
-                const compactEffectiveModel = opts?.model ?? activeSession?.modelOverride ?? this.agentConfig.claude.model;
-                const contextWindow = await this.contextWindowFor(compactEffectiveModel);
-                const compactor = new compactor_1.SessionCompactor(this.sessionStore);
-                const compactResult = await compactor.compact(agentId, storeChatId, sessionId, compactEffectiveModel, contextWindow, ch);
-                await this.sessionStore.updateSessionMeta(agentId, storeChatId, sessionId, {
-                    loadedAtSpawn: undefined,
-                    archivedCount: undefined,
-                    messageCountAtSpawn: undefined,
-                }, ch);
-                await this.restartProcess(sessionId);
-                result = { success: true, keptMessages: compactResult.afterMessages, archivedMessages: compactResult.beforeMessages - compactResult.afterMessages };
-                responseText = `Session compacted. Kept ${compactResult.afterMessages} messages, archived ${compactResult.beforeMessages - compactResult.afterMessages}.`;
+                await this.compactContext(sessionId, opts?.model);
+                result = { success: true, native: true, historyUnchanged: true };
+                responseText = 'Claude Code context compacted. Chat history is unchanged.';
             }
             else {
                 // Passed the gate but has no dispatch branch — BUILTIN_COMMANDS drifted from this
@@ -5205,17 +5230,20 @@ class AgentRunner extends events_1.EventEmitter {
         return kind === 'direct' || kind === 'user';
     }
     /**
-     * Restart every non-api session so a model change actually takes effect.
+     * Restart legacy non-api sessions so a model change actually takes effect.
      *
      * `setModel` only rewrites config — a session process was spawned with the
      * old model on its command line and keeps using it until it is restarted.
      * Reporting "model set" without this is a false success: the next turn still
-     * runs on the previous model. Returns whether anything was restarted.
+     * runs on the previous model. Managed decisions already spawn per turn and
+     * must finish with the model they started with. Returns whether anything restarted.
      */
     async restartChannelSessions() {
         const restartPromises = [];
         for (const [key, session] of this.sessions) {
-            if (session.source !== 'api')
+            // Managed decisions spawn a new process on every turn. Killing the current
+            // one here bypasses orchestration cancellation and reports PROCESS_EXITED.
+            if (session.source !== 'api' && !session.runtimeProfile)
                 restartPromises.push(this.restartProcess(key));
         }
         await Promise.all(restartPromises);
@@ -5421,7 +5449,8 @@ class AgentRunner extends events_1.EventEmitter {
                 drain();
             }
             catch { /* Preserve the original stream/provider failure. */ }
-            this.turnStreams.completeAndRelease(turn, (0, turn_stream_1.errorEvent)(error), error);
+            const publicError = (0, response_errors_1.presentedResponseError)(error);
+            this.turnStreams.completeAndRelease(turn, (0, turn_stream_1.errorEvent)(publicError), publicError);
             close();
         };
         void (async () => {