clodds 1.6.3 → 1.6.4

package/dist/agents/index.js

@@ -16336,14 +16336,16 @@ async function createAgentManager(config, feeds, db, sessionManager, sendMessage
                 'claude-3-opus-20240229': 200000,
             };
             const modelContextWindow = MODEL_CONTEXT_WINDOWS[modelId] || 200000;
-            // Estimate fixed overhead: tool definitions + system prompt (these don't change during conversation)
-            const toolsTokenEstimate = (0, context_1.estimateTokens)(JSON.stringify(tools), modelId);
+            // 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);
-            // Reserve enough for tools + system prompt + response buffer
-            const reserveForFixed = toolsTokenEstimate + systemTokenEstimate + 4096;
+            const reserveTokens = systemTokenEstimate + 8192;
             const contextConfig = {
                 maxTokens: modelContextWindow,
-                reserveTokens: reserveForFixed,
+                reserveTokens,
                 compactThreshold: 0.85,
                 minMessagesAfterCompact: 6,
                 summarizer,
@@ -16354,15 +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) - reserveForFixed;
-            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);
@@ -16413,20 +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');
-            // Safety: if still over limit after compaction, return a friendly error
-            if (initialEstimate > effectiveMaxTokens * 1.1) {
-                logger_1.logger.warn({ tokens: initialEstimate, max: effectiveMaxTokens }, 'Context exceeds limit even after compaction');
-                return 'This conversation has gotten too long for me to process. Please start a new conversation and I\'ll be happy to help!';
+            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');
             }
-            let response = await createMessage({
-                model: modelId,
-                max_tokens: 1024,
-                system: finalSystemPrompt,
-                tools: tools,
-                messages,
-            });
             // Tool use loop
             while (response.stop_reason === 'tool_use') {
                 const assistantContent = response.content;
@@ -16540,20 +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)');
-                // Safety: bail if over limit during tool loop
-                if (loopEstimate > effectiveMaxTokens * 1.1) {
-                    logger_1.logger.warn({ tokens: loopEstimate, max: effectiveMaxTokens }, 'Context exceeds limit during tool loop');
-                    break;
+                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,
+                                });
+                            }
+                        }
+                    }
                 }
-                response = await createMessage({
-                    model: modelId,
-                    max_tokens: 1024,
-                    system: finalSystemPrompt,
-                    tools: tools,
-                    messages,
-                });
             }
             // Extract text response
             const responseText = extractResponseText(response);