@exreve/exk 1.0.45 → 1.0.47

package/dist/agentSession.js

@@ -251,7 +251,7 @@ function readProxyToggle() {
 /** Env for the Claude Code child: copy of host env with host ANTHROPIC_* stripped, then inject from provider or ai-config.
  *  If a local model is provided, override baseUrl to point to the anthropic-proxy adapter.
  *  If resolvedProvider is provided, use its credentials instead of ai-config defaults. */
-function envForClaudeCodeChild(localModel, resolvedProvider) {
+function envForClaudeCodeChild(_localModel, resolvedProvider) {
     const env = { ...process.env };
     // Strip any host ANTHROPIC_* vars to prevent leaking credentials or wrong URLs
     delete env.ANTHROPIC_API_KEY;
@@ -333,6 +333,71 @@ export class AgentSessionManager {
     promptAbortControllers = new Map(); // Map promptId -> AbortController for cancellation
     emergencyStopInProgress = new Set(); // Track sessions being emergency stopped
     sessionHandlers = new Map(); // Track handlers for each session
+    socketRef = null; // Socket.IO reference for fetching session history from backend
+    /** Set the socket reference for backend communication (called from app-child.ts) */
+    setSocketRef(socket) {
+        this.socketRef = socket;
+    }
+    /**
+     * Fetch conversation history from the backend DB for a session.
+     * Returns array of { role, content } pairs (user prompts + assistant responses).
+     */
+    async fetchSessionHistory(sessionId) {
+        return new Promise((resolve) => {
+            if (!this.socketRef?.connected) {
+                console.log(`[AgentSessionManager] Cannot fetch history: socket not connected`);
+                resolve([]);
+                return;
+            }
+            const timeoutId = setTimeout(() => {
+                console.warn(`[AgentSessionManager] fetchSessionHistory timed out for ${sessionId}`);
+                resolve([]);
+            }, 5000);
+            this.socketRef.emit('session:history', { sessionId }, (response) => {
+                clearTimeout(timeoutId);
+                if (response?.history && Array.isArray(response.history)) {
+                    console.log(`[AgentSessionManager] Fetched ${response.history.length} history entries for session ${sessionId}`);
+                    resolve(response.history);
+                }
+                else {
+                    resolve([]);
+                }
+            });
+        });
+    }
+    /**
+     * Format conversation history into a text block for injection into a prompt.
+     * Takes the last N exchanges to avoid token overflow.
+     */
+    formatHistoryForPrompt(history) {
+        if (!history.length)
+            return '';
+        // Take last N entries to stay within reasonable token limits
+        const maxEntries = 40;
+        const trimmed = history.slice(-maxEntries);
+        const lines = trimmed.map(m => {
+            const content = typeof m.content === 'string' ? m.content : JSON.stringify(m.content);
+            // Truncate very long individual messages
+            const maxLen = 2000;
+            const truncated = content.length > maxLen
+                ? content.slice(0, maxLen) + '...[truncated]'
+                : content;
+            return `<${m.role}>\n${truncated}\n</${m.role}>`;
+        });
+        return [
+            '[Previous Conversation Context]',
+            'The following is conversation history from this session that was lost due to a session reset.',
+            'Use it as context for the current request.',
+            '',
+            '<conversation>',
+            ...lines,
+            '</conversation>',
+            '',
+            '[End of Previous Context]',
+            '',
+            '',
+        ].join('\n');
+    }
     async createSession(handler) {
         const { sessionId, projectPath, model } = handler;
         const sessionModel = model || CLAUDE_CONFIG.model;
@@ -456,8 +521,10 @@ export class AgentSessionManager {
         while (session.promptQueue.length > 0 && !this.emergencyStopInProgress.has(sessionId)) {
             const queuedPrompt = session.promptQueue.shift();
             const { enhancers, handler, promptId: queuedPromptId, abortController: queuedAbortController } = queuedPrompt;
-            const { projectPath, promptId, onOutput, onError, onComplete, onStatusUpdate } = handler;
-            const promptStartTime = Date.now();
+            const { projectPath, promptId, onOutput: _onOutput, onError: _onError, onComplete: _onComplete, onStatusUpdate } = handler;
+            const onOutput = _onOutput;
+            const onError = _onError;
+            const onComplete = _onComplete;
             // Write attachments to temp dir and inject paths into prompt
             let effectivePrompt = queuedPrompt.prompt;
             let attachmentDir;
@@ -503,7 +570,9 @@ export class AgentSessionManager {
                     try {
                         for await (const _ of session.activeQueryStream) { }
                     }
-                    catch { }
+                    catch (err) {
+                        console.error(`[AgentSession] Error draining active query stream:`, err);
+                    }
                     session.activeQueryStream = undefined;
                 }
                 session.activeQueryStream = undefined;
@@ -515,6 +584,25 @@ export class AgentSessionManager {
                         finalPrompt = `${skillContent}\n\n${effectivePrompt}`;
                     }
                 }
+                // Inject DB history if context was lost in a previous prompt (resume failed)
+                if (session.contextLost) {
+                    console.log(`[agentSession] Context was lost previously, fetching DB history for session ${sessionId}`);
+                    try {
+                        const history = await this.fetchSessionHistory(sessionId);
+                        if (history.length > 0) {
+                            const historyPrefix = this.formatHistoryForPrompt(history);
+                            finalPrompt = historyPrefix + finalPrompt;
+                            console.log(`[agentSession] Injected ${history.length} history entries into prompt for session ${sessionId}`);
+                        }
+                        else {
+                            console.log(`[agentSession] No DB history available for session ${sessionId}`);
+                        }
+                    }
+                    catch (err) {
+                        console.error(`[agentSession] Failed to fetch/format history:`, err);
+                    }
+                    session.contextLost = false; // Reset after injection attempt
+                }
                 // Add user message to history
                 session.messages.push({
                     role: 'user',
@@ -577,7 +665,9 @@ export class AgentSessionManager {
                                 mkdirSync(cwd2, { recursive: true });
                             }
                         }
-                        catch { }
+                        catch (err) {
+                            console.error(`[AgentSession] Failed to create working directory ${cwd2}:`, err);
+                        }
                         const isWin = process.platform === 'win32';
                         // Ensure PATH includes common node locations, especially in containers
                         const defaultPath = isWin
@@ -778,15 +868,24 @@ export class AgentSessionManager {
                         // Capture Claude SDK session ID from system init message
                         if (message.type === 'system' && message.subtype === 'init') {
                             const systemMsg = message;
-                            if (systemMsg.session_id && !session.claudeSessionId) {
+                            if (systemMsg.session_id) {
+                                // Detect context loss: session_id changed unexpectedly (resume failed)
+                                if (session.claudeSessionId && session.claudeSessionId !== systemMsg.session_id) {
+                                    session.contextLost = true;
+                                    console.warn(`[AgentSessionManager] Context lost! Session ID changed: ${session.claudeSessionId} → ${systemMsg.session_id}`);
+                                }
                                 session.claudeSessionId = systemMsg.session_id;
                                 saveSessionState(sessionId, { claudeSessionId: systemMsg.session_id, model: session.model, provider: resolveProvider(session.model).provider, updatedAt: Date.now() });
                             }
                         }
                         if (message.type === 'assistant') {
                             const msg = message;
-                            // Capture Claude session ID from assistant message if not already set
-                            if (msg.session_id && !session.claudeSessionId) {
+                            // Capture Claude session ID from assistant message (always update to track session changes)
+                            if (msg.session_id) {
+                                if (session.claudeSessionId && session.claudeSessionId !== msg.session_id) {
+                                    session.contextLost = true;
+                                    console.warn(`[AgentSessionManager] Context lost! Session ID changed in assistant msg: ${session.claudeSessionId} → ${msg.session_id}`);
+                                }
                                 session.claudeSessionId = msg.session_id;
                                 saveSessionState(sessionId, { claudeSessionId: msg.session_id, model: session.model, provider: resolveProvider(session.model).provider, updatedAt: Date.now() });
                             }
@@ -1073,33 +1172,6 @@ export class AgentSessionManager {
             this.processPromptQueue(sessionId);
         }
     }
-    getContextInfo(sessionId) {
-        const session = this.sessions.get(sessionId);
-        if (!session)
-            return null;
-        return {
-            messageCount: session.messages.length,
-            totalInputTokens: session.totalInputTokens,
-            totalOutputTokens: session.totalOutputTokens,
-            totalTokens: session.totalInputTokens + session.totalOutputTokens,
-            totalCostUsd: session.totalCostUsd,
-            lastUsage: session.lastUsage
-        };
-    }
-    clearContext(sessionId) {
-        const session = this.sessions.get(sessionId);
-        if (session) {
-            session.messages = [];
-            session.totalInputTokens = 0;
-            session.totalOutputTokens = 0;
-            session.totalCostUsd = 0;
-            // Clear Claude session ID to start fresh
-            session.claudeSessionId = undefined;
-            session.lastUsage = undefined;
-            // Also clear persisted state
-            deleteSessionState(sessionId);
-        }
-    }
     async deleteSession(sessionId) {
         const session = this.sessions.get(sessionId);
         if (session) {