clodds 1.6.2 → 1.6.4

package/dist/agents/index.js

@@ -16336,9 +16336,16 @@ async function createAgentManager(config, feeds, db, sessionManager, sendMessage
                 'claude-3-opus-20240229': 200000,
             };
             const modelContextWindow = MODEL_CONTEXT_WINDOWS[modelId] || 200000;
+            // Reserve space for system prompt + response buffer.
+            // Tool tokens are NOT included here because client-side estimation of tool
+            // tokens is wildly inaccurate (JSON.stringify tokenization != API's internal
+            // tool token counting). Instead, we use actual API usage feedback after the
+            // first call to calibrate. The API will reject if truly over limit.
+            const systemTokenEstimate = (0, context_1.estimateTokens)(finalSystemPrompt, modelId);
+            const reserveTokens = systemTokenEstimate + 8192;
             const contextConfig = {
                 maxTokens: modelContextWindow,
-                reserveTokens: 4096,
+                reserveTokens,
                 compactThreshold: 0.85,
                 minMessagesAfterCompact: 6,
                 summarizer,
@@ -16349,17 +16356,9 @@ async function createAgentManager(config, feeds, db, sessionManager, sendMessage
                 similarity: memory?.cosineSimilarity,
             };
             const contextManager = (0, context_1.createContextManager)(contextConfig, memory);
-            const effectiveMaxTokens = (contextConfig.maxTokens ?? 128000) - (contextConfig.reserveTokens ?? 4096);
-            // Estimate tool definitions once (they don't change during the conversation)
-            const toolsTokenEstimate = (0, context_1.estimateTokens)(JSON.stringify(tools), modelId);
-            const estimateSubmitTokens = () => {
-                const system = (0, context_1.estimateTokens)(finalSystemPrompt, modelId);
-                const msgs = messages.reduce((sum, m) => {
-                    const content = typeof m.content === 'string' ? m.content : JSON.stringify(m.content);
-                    return sum + (0, context_1.estimateTokens)(content, modelId) + 4;
-                }, 0);
-                return system + msgs + toolsTokenEstimate;
-            };
+            const effectiveMaxTokens = modelContextWindow - reserveTokens;
+            // Track actual API token usage for accurate compaction decisions
+            let lastKnownInputTokens = 0;
             // Add all messages to context manager for tracking
             for (const msg of messages) {
                 const content = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content);
@@ -16368,10 +16367,9 @@ async function createAgentManager(config, feeds, db, sessionManager, sendMessage
                     content,
                 });
             }
-            // Add system prompt tokens
-            const systemTokens = (0, context_1.estimateTokens)(finalSystemPrompt, modelId);
             // Check if we need to compact before first API call
-            const guard = contextManager.checkGuard(systemTokens);
+            // (tools + system prompt are already accounted for in reserveTokens)
+            const guard = contextManager.checkGuard();
             if (guard.shouldCompact) {
                 logger_1.logger.info({ percentUsed: guard.percentUsed }, 'Context approaching limit, compacting');
                 // Trigger compaction:before hook
@@ -16411,15 +16409,30 @@ async function createAgentManager(config, feeds, db, sessionManager, sendMessage
                     }, 'Context compacted successfully');
                 }
             }
-            const initialEstimate = estimateSubmitTokens();
-            logger_1.logger.info({ tokens: initialEstimate, max: effectiveMaxTokens }, 'Token estimate before submit');
-            let response = await createMessage({
-                model: modelId,
-                max_tokens: 1024,
-                system: finalSystemPrompt,
-                tools: tools,
-                messages,
-            });
+            let response;
+            try {
+                response = await createMessage({
+                    model: modelId,
+                    max_tokens: 1024,
+                    system: finalSystemPrompt,
+                    tools: tools,
+                    messages,
+                });
+            }
+            catch (err) {
+                // Handle prompt-too-long gracefully instead of crashing
+                const errMsg = err instanceof Error ? err.message : String(err);
+                if (errMsg.includes('prompt is too long') || errMsg.includes('too many tokens')) {
+                    logger_1.logger.warn({ error: errMsg }, 'Prompt exceeded context window');
+                    return 'This conversation has gotten too long for me to process. Please start a new conversation and I\'ll be happy to help!';
+                }
+                throw err;
+            }
+            // Use actual API token count for accurate context tracking
+            if (response.usage) {
+                lastKnownInputTokens = response.usage.input_tokens;
+                logger_1.logger.info({ inputTokens: lastKnownInputTokens, max: modelContextWindow }, 'Actual API token usage');
+            }
             // Tool use loop
             while (response.stop_reason === 'tool_use') {
                 const assistantContent = response.content;
@@ -16517,7 +16530,7 @@ async function createAgentManager(config, feeds, db, sessionManager, sendMessage
                         content,
                     });
                 }
-                const loopGuard = contextManager.checkGuard(0);
+                const loopGuard = contextManager.checkGuard();
                 if (loopGuard.shouldCompact) {
                     logger_1.logger.info({ percentUsed: loopGuard.percentUsed }, 'Compacting context during tool loop');
                     const loopCompactResult = await contextManager.compact();
@@ -16533,15 +16546,42 @@ async function createAgentManager(config, feeds, db, sessionManager, sendMessage
                         sessionManager.saveCheckpoint(session, loopCompactResult.summary);
                     }
                 }
-                const loopEstimate = estimateSubmitTokens();
-                logger_1.logger.info({ tokens: loopEstimate, max: effectiveMaxTokens }, 'Token estimate before submit (tool loop)');
-                response = await createMessage({
-                    model: modelId,
-                    max_tokens: 1024,
-                    system: finalSystemPrompt,
-                    tools: tools,
-                    messages,
-                });
+                try {
+                    response = await createMessage({
+                        model: modelId,
+                        max_tokens: 1024,
+                        system: finalSystemPrompt,
+                        tools: tools,
+                        messages,
+                    });
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    if (errMsg.includes('prompt is too long') || errMsg.includes('too many tokens')) {
+                        logger_1.logger.warn({ error: errMsg }, 'Prompt exceeded context window during tool loop');
+                        break;
+                    }
+                    throw err;
+                }
+                // Update actual token usage after each API call
+                if (response.usage) {
+                    lastKnownInputTokens = response.usage.input_tokens;
+                    // If actual usage is approaching limit, force compaction next iteration
+                    if (lastKnownInputTokens > modelContextWindow * 0.85) {
+                        logger_1.logger.info({ inputTokens: lastKnownInputTokens }, 'API reports high token usage, will compact');
+                        const urgentCompact = await contextManager.compact();
+                        if (urgentCompact.success) {
+                            const compactedMessages = contextManager.getMessagesForApi();
+                            messages.length = 0;
+                            for (const msg of compactedMessages) {
+                                messages.push({
+                                    role: msg.role === 'system' ? 'user' : msg.role,
+                                    content: msg.content,
+                                });
+                            }
+                        }
+                    }
+                }
             }
             // Extract text response
             const responseText = extractResponseText(response);