@pentoshi/clai 3.8.40 → 3.8.42

package/dist/agent/runner.js

@@ -15,7 +15,7 @@ import { availableToolNames, normalizeToolCall, runToolCall, BATCH_SAFE_TOOLS, }
 import { getToolDefinitions, getCompactToolDefinitions, PLAN_TOOL_NAMES, } from "../tools/definitions.js";
 import { appendAssistantWithTools, ensureUniqueToolCallIds, appendToolResult, assertValidToolProtocol, fillMissingToolResults, repairToolProtocol, } from "./tool-history.js";
 import { formatViewportHint, registerViewport } from "../ui/output-pane.js";
-import { compactMessagesWithSummary, estimateMessagesTokens, shouldApplyAutoCompact, COMPACTION_MEMORY_PREFIX, PLAN_IMPLEMENT_MEMORY_PREFIX, isCompactionMemoryMessage, } from "./context-manager.js";
+import { compactMessagesWithSummary, shouldApplyAutoCompact, COMPACTION_MEMORY_PREFIX, PLAN_IMPLEMENT_MEMORY_PREFIX, isCompactionMemoryMessage, } from "./context-manager.js";
 import { buildContextBreakdown, contextBreakdownAuditPayload, } from "./context-breakdown.js";
 import { autoCompactTriggerTokens, dedupeToolContextOutput, freeTierGuardNotices, getReliabilityPolicy, resolveStepMaxTokens, } from "./reliability-policy.js";
 import { auditLog } from "../store/logs.js";
@@ -2010,8 +2010,19 @@ export async function runAgentTurn(prompt, options = {}) {
             });
             return response.text;
         };
+        /**
+         * Estimate the complete next model request, including attached native-tool
+         * schemas. This must match the request-context accounting used by the UI
+         * and audit trail: large schemas can otherwise push an actual request past
+         * the compaction threshold while message-only accounting says it is safe.
+         */
+        const estimateNextRequestTokens = (contextMessages) => {
+            const { native } = resolveNativeTools(provider, model);
+            const nextTools = selectToolDefs(native, useCompactSystemPrompt);
+            return buildContextBreakdown(contextMessages, nextTools).estimatedTotalTokens;
+        };
         async function maybeAutoCompact(reason, force = false) {
-            const beforeTokens = estimateMessagesTokens(messages);
+            const beforeTokens = estimateNextRequestTokens(messages);
             // E1: soft early compact (default 70k) while hard ceiling remains 100k.
             const compactTrigger = autoCompactTriggerTokens();
             if (!force && beforeTokens < compactTrigger)
@@ -2037,8 +2048,8 @@ export async function runAgentTurn(prompt, options = {}) {
                 }
                 messages.splice(0, messages.length, ...result.messages);
                 loopGuard.resetReadOnly();
-                // Token stats BEFORE plan re-injection so the reduction is accurate.
-                const compactedTokens = estimateMessagesTokens(messages);
+                // Token stats use the same complete request estimate as the trigger.
+                const compactedTokens = estimateNextRequestTokens(messages);
                 // Re-inject the live plan so the model keeps full plan awareness even
                 // after older turns (which carried the plan context) were summarized.
                 const livePlan = await loadPlan(session.sessionId).catch(() => undefined);
@@ -2051,8 +2062,8 @@ export async function runAgentTurn(prompt, options = {}) {
                 // Re-inject live SESSION STATE after compaction (older flags survive).
                 refreshSessionState(livePlan);
                 lastCompactionMsgCount = messages.length;
-                // Final count the model actually receives (may include re-injected plan).
-                const afterTokens = estimateMessagesTokens(messages);
+                // Final request count the model receives (may include re-injected plan).
+                const afterTokens = estimateNextRequestTokens(messages);
                 await auditLog("agent.compact", {
                     newLength: messages.length,
                     estimatedTokens: afterTokens,
@@ -2347,20 +2358,20 @@ export async function runAgentTurn(prompt, options = {}) {
                                     }
                                 }
                             }
-                            if (!sawReasoning && /<think/i.test(token)) {
+                            if (!sawReasoning && /<think(?:ing)?\b/i.test(token)) {
                                 sawReasoning = true;
                                 inThinking = true;
                                 spinner.setLabel("thinking");
                                 if (!writesDirectly)
                                     emit({ type: "status", text: "thinking" });
                             }
-                            if (/<\/think>/i.test(token)) {
+                            if (/<\/think(?:ing)?>/i.test(token)) {
                                 inThinking = false;
                                 spinner.setLabel("generating response (0 tokens)");
                                 generatedTokens = 0;
                             }
                             if (inThinking) {
-                                const cleaned = token.replace(/<\/?think[^>]*>/gi, "");
+                                const cleaned = token.replace(/<\/?think(?:ing)?[^>]*>/gi, "");
                                 if (cleaned) {
                                     spinner.pushPreview(cleaned);
                                     const approx = cleaned.split(/\s+/).filter(Boolean).length;
@@ -2422,7 +2433,16 @@ export async function runAgentTurn(prompt, options = {}) {
                     (toolsAttached && !isTextOnlyModel(provider, model));
                 const assistantTextResult = rememberThinkingFromText(completion.text);
                 assistantText = assistantTextResult;
-                if (assistantText.hasThinking) {
+                // Only emit a thinking-block event when the classic renderer is
+                // active (writesDirectly / no deltaParser).  In TUI v2 the
+                // deltaParser already streamed thinking-delta events that created
+                // the thinking item in the correct transcript position; emitting
+                // a redundant thinking-block after tool-call events have cleared
+                // pendingThinkingId causes the reducer to append a *duplicate*
+                // thinking item at the end of the transcript — the root cause of
+                // the "ghost thinking blocks below the response" bug seen with
+                // models that use reasoning_content (e.g. Kimi K2-thinking).
+                if (assistantText.hasThinking && !deltaParser) {
                     writeThinkingBlock(assistantText.thinkContent);
                 }
                 // Native-first: prefer structured toolCalls from the provider.