@exreve/exk 1.0.44 → 1.0.46

package/dist/agentSession.js

@@ -135,6 +135,9 @@ function lookupToolNameFromHistory(messages, toolUseId) {
 // (Do not read ANTHROPIC_* / CLAUDE_MODEL from the host environment — only this file + code default model.)
 const AI_CONFIG_PATH = path.join(os.homedir(), '.talk-to-code', 'ai-config.json');
 const DEFAULT_AI_MODEL = 'glm-5.1';
+/** TTL cache for ai-config.json reads to avoid hitting disk on every call */
+let _aiConfigCache = null;
+const AI_CONFIG_TTL_MS = 5_000;
 const PROVIDERS = {
     zai: {
         apiKey: process.env.ZHIPU_API_KEY || '',
@@ -184,6 +187,10 @@ function resolveProvider(model, providerId) {
     };
 }
 function loadAiConfig() {
+    const now = Date.now();
+    if (_aiConfigCache && (now - _aiConfigCache.ts) < AI_CONFIG_TTL_MS) {
+        return _aiConfigCache.data;
+    }
     try {
         const data = readFileSync(AI_CONFIG_PATH, 'utf-8');
         const config = JSON.parse(data);
@@ -193,10 +200,14 @@ function loadAiConfig() {
         const proxy = typeof config.proxy === 'string' ? config.proxy.trim() : '';
         const minimaxApiKey = typeof config.minimaxApiKey === 'string' ? config.minimaxApiKey.trim() : '';
         const openrouterApiKey = typeof config.openrouterApiKey === 'string' ? config.openrouterApiKey.trim() : '';
-        return { apiKey, baseUrl, model, proxy, minimaxApiKey, openrouterApiKey };
+        const result = { apiKey, baseUrl, model, proxy, minimaxApiKey, openrouterApiKey };
+        _aiConfigCache = { data: result, ts: now };
+        return result;
     }
     catch {
-        return { apiKey: '', baseUrl: '', model: DEFAULT_AI_MODEL, proxy: '', minimaxApiKey: '', openrouterApiKey: '' };
+        const fallback = { apiKey: '', baseUrl: '', model: DEFAULT_AI_MODEL, proxy: '', minimaxApiKey: '', openrouterApiKey: '' };
+        _aiConfigCache = { data: fallback, ts: now };
+        return fallback;
     }
 }
 /** Get OpenRouter API key from ai-config.json (served by backend) */
@@ -240,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;
@@ -322,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;
@@ -445,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;
@@ -492,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;
@@ -504,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',
@@ -566,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
@@ -767,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() });
                             }
@@ -1082,6 +1192,7 @@ export class AgentSessionManager {
             session.totalInputTokens = 0;
             session.totalOutputTokens = 0;
             session.totalCostUsd = 0;
+            session.contextLost = false;
             // Clear Claude session ID to start fresh
             session.claudeSessionId = undefined;
             session.lastUsage = undefined;