@exreve/exk 1.0.75 → 1.0.77

package/dist/cli/agentSession.js

@@ -56,7 +56,7 @@ const symlinkAsync = promisify(fsSymlink);
 // AI config - loaded from server after registration, stored in ~/.talk-to-code/ai-config.json
 // (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';
+const DEFAULT_AI_MODEL = 'glm-5.2';
 /** TTL cache for ai-config.json reads to avoid hitting disk on every call */
 let _aiConfigCache = null;
 const AI_CONFIG_TTL_MS = 5_000;
@@ -66,12 +66,12 @@ const PROVIDERS = {
     zai: {
         apiKey: process.env.ZHIPU_API_KEY || '',
         baseUrl: process.env.CLI_AI_BASE_URL || 'https://api.z.ai/api/anthropic',
-        models: ['glm-5.1', 'glm-4.7', 'glm-4.5-air'],
+        models: ['glm-5.2'],
     },
     minimax: {
         apiKey: '',
         baseUrl: 'https://api.minimax.io/anthropic',
-        models: ['MiniMax-M2.7', 'MiniMax-M2.7-highspeed'],
+        models: ['MiniMax-M3'],
     },
     openrouter: {
         apiKey: '',
@@ -588,23 +588,43 @@ export class AgentSessionManager {
                         finalPrompt = `${skillContent}\n\n${effectivePrompt}`;
                     }
                 }
-                // Inject DB history if context was lost in a previous prompt (resume failed)
+                // Inject compacted summary or raw DB history if context was lost
                 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}`);
+                    if (session.compactionSummary) {
+                        // Use AI-generated summary from compaction
+                        console.log(`[agentSession] Injecting AI compaction summary for session ${sessionId}`);
+                        const summaryPrefix = [
+                            '[Compacted Session Context]',
+                            'The following is an AI-generated summary of the previous conversation in this session.',
+                            'Use it as context to continue where you left off.',
+                            '',
+                            session.compactionSummary,
+                            '',
+                            '[End of Compacted Context]',
+                            '',
+                            '',
+                        ].join('\n');
+                        finalPrompt = summaryPrefix + finalPrompt;
+                        session.compactionSummary = undefined; // Only inject once
+                    }
+                    else {
+                        // Fallback: inject raw DB history
+                        console.log(`[agentSession] No compaction summary, 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}`);
+                            }
                         }
-                        else {
-                            console.log(`[agentSession] No DB history available for session ${sessionId}`);
+                        catch (err) {
+                            console.error(`[agentSession] Failed to fetch/format history:`, err);
                         }
                     }
-                    catch (err) {
-                        console.error(`[agentSession] Failed to fetch/format history:`, err);
-                    }
                     session.contextLost = false; // Reset after injection attempt
                 }
                 // Add user message to history
@@ -719,13 +739,13 @@ export class AgentSessionManager {
                         resumeSessionId = session.sdkSessionId;
                     }
                 }
-                // Enable auto-compaction: trigger when context reaches ~150k (of 200k), keep default target
+                // Enable auto-compaction: trigger when context reaches ~800k (of 1M), keep default target
                 if (effectiveSettings) {
                     effectiveSettings.autoCompactEnabled = true;
-                    effectiveSettings.autoCompactWindow = 150000;
+                    effectiveSettings.autoCompactWindow = 800000;
                 }
                 else {
-                    effectiveSettings = { autoCompactEnabled: true, autoCompactWindow: 150000 };
+                    effectiveSettings = { autoCompactEnabled: true, autoCompactWindow: 800000 };
                 }
                 // Build backend config
                 const backendConfig = {
@@ -1088,23 +1108,127 @@ export class AgentSessionManager {
         }
     }
     /**
-     * Compact session context — proactively clear SDK session and inject
-     * a summary on the next prompt.  Prevents hitting the hard context
-     * window limit.
+     * AI-powered session compaction.
+     *
+     * 1. Fetches full conversation history from the backend DB
+     * 2. Writes it to a temp file
+     * 3. Spawns a real prompt asking the model to summarize the conversation
+     * 4. Captures the model's summary
+     * 5. Clears the SDK session and stores the summary for injection on next prompt
+     *
+     * Returns true if the compaction prompt was queued successfully.
+     * The `onCompactionComplete` callback fires when the model finishes summarizing.
      */
-    compactSession(sessionId) {
+    async compactSession(sessionId, projectPath, onOutput, onCompactionComplete) {
         const session = this.sessions.get(sessionId);
         if (!session)
             return false;
         // Don't compact while a prompt is actively running
         if (session.isProcessingQueue && session.activeBackendStream)
             return false;
-        const prevSdkSessionId = session.sdkSessionId;
-        session.sdkSessionId = undefined;
-        session.contextLost = true;
-        session.messages = [];
-        deleteSessionState(sessionId);
-        console.log(`[AgentSessionManager] Session compacted: ${sessionId} (was ${prevSdkSessionId ?? 'empty'})`);
+        // 1. Fetch conversation history from DB
+        const history = await this.fetchSessionHistory(sessionId);
+        if (history.length === 0) {
+            console.log(`[AgentSessionManager] No history to compact for session ${sessionId}`);
+            // Still allow compaction even without history — just clears context
+            session.sdkSessionId = undefined;
+            session.contextLost = true;
+            session.messages = [];
+            deleteSessionState(sessionId);
+            onCompactionComplete?.(true, 'Session context cleared (no history available)');
+            return true;
+        }
+        console.log(`[AgentSessionManager] Starting AI compaction for session ${sessionId} with ${history.length} history entries`);
+        // 2. Build the conversation text
+        const conversationLines = [];
+        for (const entry of history) {
+            const content = typeof entry.content === 'string' ? entry.content : JSON.stringify(entry.content);
+            conversationLines.push(`=== ${entry.role.toUpperCase()} ===\n${content}`);
+        }
+        const conversationText = conversationLines.join('\n\n');
+        // 3. Write conversation to a temp file
+        const attachmentDir = path.join(os.tmpdir(), 'talk-to-code', 'compaction', sessionId);
+        mkdirSync(attachmentDir, { recursive: true });
+        const conversationFilePath = path.join(attachmentDir, 'conversation.md');
+        writeFileSync(conversationFilePath, conversationText, 'utf-8');
+        // 4. Build the compaction prompt
+        const compactionPrompt = [
+            'You are performing a CONTEXT COMPACTION for an ongoing coding session.',
+            '',
+            'Read the full conversation history in the attached file `conversation.md`.',
+            '',
+            'Your task: Create a comprehensive summary that captures:',
+            '1. What the user is working on (project, goals, current task)',
+            '2. All decisions made and their reasoning',
+            '3. The current state of the codebase (what was changed, added, removed)',
+            '4. Any open issues, bugs, or TODOs discussed',
+            '5. Important technical details (file paths, configurations, API designs)',
+            '6. The last thing the user was doing or about to do',
+            '',
+            'Be thorough but concise. Include specific file paths, code snippets, and technical details.',
+            'This summary will be the ONLY context carried forward — everything else is lost.',
+            '',
+            'Format the summary as a structured document with clear sections.',
+            'Write the summary directly — no preamble or meta-commentary.',
+        ].join('\n');
+        // 5. Create a synthetic attachment for the conversation file
+        const attachment = {
+            filename: 'conversation.md',
+            mimeType: 'text/markdown',
+            content: Buffer.from(conversationText).toString('base64'),
+        };
+        // 6. Spawn a compaction prompt through the normal pipeline
+        const compactionPromptId = `compact-${sessionId}-${Date.now()}`;
+        let summaryParts = [];
+        await this.sendPrompt(sessionId, compactionPrompt, [], {
+            sessionId,
+            projectPath,
+            promptId: compactionPromptId,
+            model: session.model,
+            attachments: [attachment],
+            onOutput: (output) => {
+                // Forward to caller for UI display (shows compacting progress)
+                onOutput?.(output);
+                // Capture assistant text for the summary
+                if (output.type === 'assistant' && output.data) {
+                    const d = output.data;
+                    const text = typeof output.data === 'string'
+                        ? output.data
+                        : (d?.content?.[0]?.text || d?.text || '');
+                    if (text)
+                        summaryParts.push(text);
+                }
+            },
+            onError: (error) => {
+                console.error(`[AgentSessionManager] Compaction prompt error: ${error}`);
+                onCompactionComplete?.(false, `Compaction failed: ${error}`);
+            },
+            onComplete: (exitCode) => {
+                const summary = summaryParts.join('\n').trim();
+                if (summary && exitCode === 0) {
+                    // Store summary and clear old context
+                    session.compactionSummary = summary;
+                    session.sdkSessionId = undefined;
+                    session.contextLost = true;
+                    session.messages = [];
+                    deleteSessionState(sessionId);
+                    console.log(`[AgentSessionManager] AI compaction complete for session ${sessionId} (${summary.length} chars summary)`);
+                    onCompactionComplete?.(true, 'Session context compacted with AI summary');
+                }
+                else {
+                    // Compaction prompt failed — fall back to simple clear
+                    session.sdkSessionId = undefined;
+                    session.contextLost = true;
+                    session.messages = [];
+                    deleteSessionState(sessionId);
+                    console.warn(`[AgentSessionManager] Compaction prompt failed (exit=${exitCode}), falling back to simple clear`);
+                    onCompactionComplete?.(true, 'Session context cleared (compaction prompt did not produce summary)');
+                }
+            },
+            onStatusUpdate: () => {
+                // Status updates from the compaction prompt — ignore
+            },
+        });
         return true;
     }
     /**

package/dist/cli/benchmark-models-sdk.js

@@ -262,7 +262,7 @@ async function runSdkBenchmark(provider) {
 // ── Main ────────────────────────────────────────────────────────────
 async function main() {
     console.log(`\n${BOLD}╔══════════════════════════════════════════════════════════════════════╗${RESET}`);
-    console.log(`${BOLD}║  SDK Benchmark: MiniMax M2.7-highspeed vs Cerebras zai-glm-4.7     ║${RESET}`);
+    console.log(`${BOLD}║  SDK Benchmark: MiniMax M3 vs Cerebras zai-glm-4.7                 ║${RESET}`);
     console.log(`${BOLD}║  Task: Generate a complete HTML real estate page                    ║${RESET}`);
     console.log(`${BOLD}╚══════════════════════════════════════════════════════════════════════╝${RESET}\n`);
     const config = loadConfig();
@@ -278,8 +278,8 @@ async function main() {
     const providers = [];
     if (minimaxKey) {
         providers.push({
-            name: 'MiniMax M2.7-highspeed',
-            model: 'MiniMax-M2.7-highspeed',
+            name: 'MiniMax M3',
+            model: 'MiniMax-M3',
             apiKey: minimaxKey,
             baseUrl: 'https://api.minimax.io/anthropic',
             needsProxy: false,

package/dist/cli/claudeBackend.js

@@ -188,6 +188,8 @@ export class ClaudeBackend {
             settingSources: ['project'],
             permissionMode: 'bypassPermissions',
             allowDangerouslySkipPermissions: true,
+            // Enable 1M token context window (GLM-5.2 supports 1M context via z.ai)
+            betas: ['context-1m-2025-08-07'],
             mcpServers: { 'claude-voice-modules': mcpServer },
             ...(pathToClaudeCodeExecutable ? { pathToClaudeCodeExecutable } : {}),
             spawnClaudeCodeProcess: (spawnOptions) => {

package/dist/cli/sessionHandlers.js

@@ -250,26 +250,58 @@ export function registerSessionHandlers(socket, foreground, activeSessions, getS
                 callback?.({ success: false, message: 'Missing sessionId' });
                 return;
             }
+            const sessionInfo = activeSessions.get(sessionId);
+            if (!sessionInfo) {
+                callback?.({ success: false, message: 'Session not found' });
+                return;
+            }
             if (foreground) {
                 console.log(`[CLI] Compacting session: ${sessionId}`);
             }
-            const compacted = agentSessionManager.compactSession(sessionId);
-            if (compacted) {
+            // Respond immediately — compaction runs in the background
+            callback?.({ success: true, message: 'Compaction started' });
+            const compacted = await agentSessionManager.compactSession(sessionId, sessionInfo.projectPath, (output) => {
+                // Forward compaction prompt output to the backend for UI display
+                const compactPromptId = `compact-${sessionId}`;
+                getSocket().emit('prompt:output', {
+                    sessionId,
+                    promptId: compactPromptId,
+                    type: output.type,
+                    data: output.data,
+                    timestamp: output.timestamp,
+                    metadata: { ...output.metadata, isCompaction: true },
+                });
+            }, (success, message) => {
+                // Compaction finished — notify UI
                 getSocket().emit('session:compacted', {
                     sessionId,
                     timestamp: Date.now(),
+                    success,
+                    message,
+                });
+                if (foreground) {
+                    console.log(`[CLI] Compaction ${success ? 'complete' : 'failed'}: ${message}`);
+                }
+            });
+            if (!compacted) {
+                getSocket().emit('session:compacted', {
+                    sessionId,
+                    timestamp: Date.now(),
+                    success: false,
+                    message: 'Session not found or prompt is running',
                 });
-                callback?.({ success: true, message: 'Session context compacted' });
-            }
-            else {
-                callback?.({ success: false, message: 'Session not found or prompt is running' });
             }
         }
         catch (error) {
             if (foreground) {
                 console.error(`✗ Error compacting session: ${error.message}`);
             }
-            callback?.({ success: false, message: error.message });
+            getSocket().emit('session:compacted', {
+                sessionId: data.sessionId,
+                timestamp: Date.now(),
+                success: false,
+                message: error.message,
+            });
         }
     });
     socket.on('emergency:stop', async (data, callback) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exreve/exk",
-  "version": "1.0.75",
+  "version": "1.0.77",
   "description": "exk - Control Claude CLI with voice and programmable interfaces",
   "type": "module",
   "bin": {