byterover-cli 1.8.0 → 2.0.0

package/dist/agent/infra/llm/{internal-llm-service.js → agent-llm-service.js}

@@ -9,12 +9,15 @@ import { EnvironmentContextBuilder } from '../environment/environment-context-bu
 import { ToolMetadataHandler } from '../tools/streaming/metadata-handler.js';
 import { AsyncMutex } from './context/async-mutex.js';
 import { ContextManager } from './context/context-manager.js';
+import { DeferredEffects } from './context/deferred-effects.js';
 import { LoopDetector } from './context/loop-detector.js';
 import { ClaudeMessageFormatter } from './formatters/claude-formatter.js';
 import { GeminiMessageFormatter } from './formatters/gemini-formatter.js';
+import { OpenRouterMessageFormatter } from './formatters/openrouter-formatter.js';
 import { ThoughtParser } from './thought-parser.js';
 import { ClaudeTokenizer } from './tokenizers/claude-tokenizer.js';
 import { GeminiTokenizer } from './tokenizers/gemini-tokenizer.js';
+import { OpenRouterTokenizer } from './tokenizers/openrouter-tokenizer.js';
 import { ToolOutputProcessor } from './tool-output-processor.js';
 /** Target utilization ratio for message tokens (leaves headroom for response) */
 const TARGET_MESSAGE_TOKEN_UTILIZATION = 0.7;
@@ -35,7 +38,7 @@ const TARGET_MESSAGE_TOKEN_UTILIZATION = 0.7;
  * - Format messages for specific providers (handled by generators)
  * - Handle retry logic (handled by RetryableContentGenerator decorator)
  */
-export class ByteRoverLLMService {
+export class AgentLLMService {
     /** Cached base system prompt (everything built by SystemPromptManager) for reuse across iterations */
     cachedBasePrompt = null;
     compactionService;
@@ -52,7 +55,10 @@ export class ByteRoverLLMService {
     metadataHandler;
     mutex = new AsyncMutex();
     outputProcessor;
+    providerId;
     providerType;
+    /** Optional sandbox service for rolling checkpoint variable injection (Pattern 1) */
+    sandboxService;
     sessionEventBus;
     sessionId;
     systemPromptManager;
@@ -82,28 +88,32 @@ export class ByteRoverLLMService {
      * @param options.compactionService - Optional compaction service for context overflow management
      * @param options.historyStorage - Optional history storage for persistence
      * @param options.logger - Optional logger for structured logging
+     * @param options.sandboxService - Optional sandbox service for rolling checkpoint variable injection
      */
     constructor(sessionId, generator, config, options) {
         this.sessionId = sessionId;
         this.generator = generator;
         this.compactionService = options.compactionService;
+        this.sandboxService = options.sandboxService;
         this.toolManager = options.toolManager;
         this.systemPromptManager = options.systemPromptManager;
         this.memoryManager = options.memoryManager;
         this.sessionEventBus = options.sessionEventBus;
         this.logger = options.logger ?? new NoOpLogger();
-        this.outputProcessor = new ToolOutputProcessor(config.truncationConfig);
         this.loopDetector = new LoopDetector();
         this.environmentBuilder = new EnvironmentContextBuilder();
         this.metadataHandler = new ToolMetadataHandler(this.sessionEventBus);
         this.workingDirectory = process.cwd();
-        // Detect provider type from model name (needed for validation)
+        // Detect provider type: explicit provider config takes priority over model name heuristic
         const modelName = config.model ?? 'claude-haiku-4-5@20251001';
-        this.providerType = this.detectProviderType(modelName);
+        this.providerId = config.provider ?? 'byterover';
+        this.providerType = this.detectProviderType(modelName, config.provider);
         // Validate core LLM config using Zod schema (logs warning if invalid)
         this.validateConfig(modelName, config.maxInputTokens);
         // Get effective max input tokens from registry (respects model limits)
-        const effectiveMaxInputTokens = getEffectiveMaxInputTokens(this.providerType, modelName, config.maxInputTokens);
+        // For 'openai' provider type, use 'openai' registry; for others use existing logic
+        const registryProvider = this.providerType === 'openai' ? 'openai' : this.providerType;
+        const effectiveMaxInputTokens = getEffectiveMaxInputTokens(registryProvider, modelName, config.maxInputTokens);
         this.config = {
             maxInputTokens: effectiveMaxInputTokens,
             maxIterations: config.maxIterations ?? 50,
@@ -114,8 +124,14 @@ export class ByteRoverLLMService {
             timeout: config.timeout,
             verbose: config.verbose ?? false,
         };
+        // Initialize output processor after config so maxInputTokens is available
+        this.outputProcessor = new ToolOutputProcessor(this.config.maxInputTokens, config.truncationConfig);
         // Initialize formatter and tokenizer based on provider type
-        if (this.providerType === 'claude') {
+        if (this.providerType === 'openai') {
+            this.formatter = new OpenRouterMessageFormatter();
+            this.tokenizer = new OpenRouterTokenizer();
+        }
+        else if (this.providerType === 'claude') {
             this.formatter = new ClaudeMessageFormatter();
             this.tokenizer = new ClaudeTokenizer(this.config.model);
         }
@@ -157,6 +173,11 @@ export class ByteRoverLLMService {
         this.memoryDirtyFlag = false;
         // Extract options with defaults
         const { executionContext, fileData, imageData, signal, stream, taskId } = options ?? {};
+        // RLM mode: Clear conversation history to prevent accumulation across calls.
+        // Context and history are offloaded to files, accessed via code_exec instead.
+        if (executionContext?.clearHistory) {
+            await this.contextManager.clearHistory();
+        }
         // Get filtered tools based on command type (e.g., only read-only tools for 'query')
         const toolSet = this.toolManager.getToolsForCommand(options?.executionContext?.commandType);
         // Create state machine with configured limits (per-invocation overrides via ExecutionContext)
@@ -179,6 +200,7 @@ export class ByteRoverLLMService {
             try {
                 // eslint-disable-next-line no-await-in-loop -- Sequential iterations required for agentic loop
                 const result = await this.executeAgenticIteration({
+                    effectiveMaxIterations,
                     executionContext,
                     fileData,
                     imageData,
@@ -221,7 +243,7 @@ export class ByteRoverLLMService {
      * Returns metadata about the service including:
      * - Configured and model-specific token limits
      * - Selected LLM model
-     * - Provider name (always 'byterover')
+     * - Provider identity (e.g. 'byterover', 'anthropic', 'openrouter')
      * - Router type (always 'in-built')
      *
      * This is useful for introspecting service capabilities and limits
@@ -236,7 +258,7 @@ export class ByteRoverLLMService {
             configuredMaxInputTokens: this.config.maxInputTokens,
             model: this.config.model,
             modelMaxInputTokens: modelMaxTokens,
-            provider: 'byterover',
+            provider: this.providerId,
             router: 'in-built',
         };
     }
@@ -319,6 +341,28 @@ export class ByteRoverLLMService {
             tools: options.tools,
         };
     }
+    /**
+     * Build a compact progress summary from current messages.
+     * Used by rolling checkpoint to capture agentic state before clearing history.
+     *
+     * @param messages - Current conversation messages
+     * @returns JSON string summarizing progress
+     */
+    buildProgressSummary(messages) {
+        const toolCalls = messages
+            .filter((m) => m.toolCalls && m.toolCalls.length > 0)
+            .flatMap((m) => m.toolCalls.map((tc) => tc.function.name));
+        const assistantMessages = messages
+            .filter((m) => m.role === 'assistant')
+            .map((m) => typeof m.content === 'string' ? m.content.slice(0, 300) : '')
+            .filter(Boolean);
+        return JSON.stringify({
+            assistantSummaries: assistantMessages.slice(-3),
+            messageCount: messages.length,
+            toolsUsed: [...new Set(toolCalls)],
+            totalToolCalls: toolCalls.length,
+        });
+    }
     /**
      * Call LLM via generator and process the response.
      *
@@ -449,63 +493,98 @@ export class ByteRoverLLMService {
             taskId: taskId || undefined,
             utilizationPercent,
         });
-        if (overflowResult.recommendation === 'prune') {
-            // Try pruning tool outputs first
-            const pruneResult = await this.compactionService.pruneToolOutputs(this.sessionId);
-            // Emit context pruned event
-            if (pruneResult.compactedCount > 0) {
-                this.sessionEventBus.emit('llmservice:contextPruned', {
-                    pruneCount: pruneResult.compactedCount,
-                    reason: 'overflow',
-                    taskId: taskId || undefined,
-                    tokensSaved: pruneResult.tokensSaved,
-                });
-                // Also emit warning for backward compatibility
-                this.sessionEventBus.emit('llmservice:warning', {
-                    message: `Context compaction: pruned ${pruneResult.compactedCount} old tool outputs (~${pruneResult.tokensSaved} tokens)`,
-                    taskId: taskId || undefined,
+        // Defer event emissions until after DB operations succeed
+        const effects = new DeferredEffects();
+        try {
+            if (overflowResult.recommendation === 'prune') {
+                // Try pruning tool outputs first
+                const pruneResult = await this.compactionService.pruneToolOutputs(this.sessionId, this.config.maxInputTokens);
+                // Sync in-memory state with storage (replace compacted tool outputs)
+                if (pruneResult.compactedCount > 0) {
+                    this.contextManager.markToolOutputsCompacted();
+                    effects.defer(() => {
+                        this.sessionEventBus.emit('llmservice:contextPruned', {
+                            pruneCount: pruneResult.compactedCount,
+                            reason: 'overflow',
+                            taskId: taskId || undefined,
+                            tokensSaved: pruneResult.tokensSaved,
+                        });
+                        this.sessionEventBus.emit('llmservice:warning', {
+                            message: `Context compaction: pruned ${pruneResult.compactedCount} old tool outputs (~${pruneResult.tokensSaved} tokens)`,
+                            taskId: taskId || undefined,
+                        });
+                    });
+                }
+            }
+            else if (overflowResult.recommendation === 'compact') {
+                const originalTokens = currentTokens;
+                // Full compaction needed - generate LLM summary
+                // Use the same taskId from caller for billing tracking
+                const summary = await this.compactionService.generateSummary(this.generator, messages, taskId, this.config.model);
+                await this.compactionService.createCompactionBoundary(this.sessionId, summary);
+                // Reload in-memory state to only include post-boundary messages
+                await this.contextManager.reloadFromStorage();
+                const compressedTokens = this.generator.estimateTokensSync(summary);
+                effects.defer(() => {
+                    this.sessionEventBus.emit('llmservice:contextCompressed', {
+                        compressedTokens,
+                        originalTokens,
+                        strategy: 'summary',
+                        taskId: taskId || undefined,
+                    });
+                    this.sessionEventBus.emit('llmservice:warning', {
+                        message: 'Context compaction: created summary boundary for conversation history',
+                        taskId: taskId || undefined,
+                    });
                 });
             }
+            // All DB ops succeeded — fire events
+            effects.flush();
         }
-        else if (overflowResult.recommendation === 'compact') {
-            const originalTokens = currentTokens;
-            // Full compaction needed - generate LLM summary
-            // Use the same taskId from caller for billing tracking
-            const summary = await this.compactionService.generateSummary(this.generator, messages, taskId, this.config.model);
-            await this.compactionService.createCompactionBoundary(this.sessionId, summary);
-            // Emit context compressed event
-            // Estimate compressed tokens (summary is much smaller than original)
-            const compressedTokens = this.generator.estimateTokensSync(summary);
-            this.sessionEventBus.emit('llmservice:contextCompressed', {
-                compressedTokens,
-                originalTokens,
-                strategy: 'summary',
-                taskId: taskId || undefined,
-            });
-            // Also emit warning for backward compatibility
-            this.sessionEventBus.emit('llmservice:warning', {
-                message: 'Context compaction: created summary boundary for conversation history',
-                taskId: taskId || undefined,
-            });
+        catch (error) {
+            // DB ops failed — discard pending events
+            effects.discard();
+            throw error;
         }
     }
     /**
      * Detect provider type from model name using the LLM registry.
      *
-     * Uses the centralized registry to determine provider from model name.
-     * Falls back to string prefix matching if model is not in registry.
+     * Uses explicit provider config first, then the centralized registry,
+     * and falls back to string prefix matching if model is not in registry.
      *
      * @param model - Model identifier
-     * @returns Provider type ('claude' or 'gemini')
+     * @param explicitProvider - Optional explicit provider ID from config
+     * @returns Provider type ('claude', 'gemini', or 'openai')
      */
-    detectProviderType(model) {
-        // Use registry to detect provider
-        const registryProvider = getProviderFromModel(model);
-        if (registryProvider === 'claude' || registryProvider === 'gemini') {
-            return registryProvider;
+    detectProviderType(model, explicitProvider) {
+        // 1. Explicit provider mapping takes priority
+        if (explicitProvider) {
+            if (explicitProvider === 'anthropic')
+                return 'claude';
+            if (explicitProvider === 'google' || explicitProvider === 'google-vertex')
+                return 'gemini';
+            if (['groq', 'mistral', 'openai', 'openai-compatible', 'openrouter', 'xai'].includes(explicitProvider))
+                return 'openai';
         }
-        // Fallback to string prefix matching for unknown models
-        return model.toLowerCase().startsWith('claude') ? 'claude' : 'gemini';
+        // 2. Use registry to detect provider from model name
+        const registryProvider = getProviderFromModel(model);
+        if (registryProvider === 'claude')
+            return 'claude';
+        if (registryProvider === 'gemini')
+            return 'gemini';
+        if (registryProvider === 'openai')
+            return 'openai';
+        // 3. Fallback to string prefix matching for unknown models
+        const lowerModel = model.toLowerCase();
+        if (lowerModel.startsWith('claude'))
+            return 'claude';
+        if (lowerModel.startsWith('gpt') ||
+            lowerModel.startsWith('o1') ||
+            lowerModel.startsWith('o3') ||
+            lowerModel.startsWith('o4'))
+            return 'openai';
+        return 'gemini';
     }
     /**
      * Determine which reflection prompt to add based on hierarchical priority.
@@ -521,12 +600,13 @@ export class ByteRoverLLMService {
      * @param commandType - Command type ('query' or 'curate')
      * @returns Reflection type to add, or undefined if none eligible
      */
-    determineReflectionType(iterationCount, commandType) {
+    determineReflectionType(iterationCount, commandType, maxIterations) {
+        const effectiveMax = maxIterations ?? this.config.maxIterations;
         const isQuery = commandType === 'query';
-        const isLastIteration = iterationCount === this.config.maxIterations - 1;
-        const midPoint = Math.floor(this.config.maxIterations / 2);
+        const isLastIteration = iterationCount === effectiveMax - 1;
+        const midPoint = Math.floor(effectiveMax / 2);
         const isAtMidPoint = iterationCount === midPoint;
-        const isNearMax = iterationCount >= Math.floor(this.config.maxIterations * 0.8);
+        const isNearMax = iterationCount >= Math.floor(effectiveMax * 0.8);
         const isPeriodicCheck = iterationCount > 0 && iterationCount % 3 === 0;
         // Priority 1: final_iteration (query only, last iteration) - highest priority
         if (isQuery && isLastIteration) {
@@ -550,6 +630,7 @@ export class ByteRoverLLMService {
      * Execute a single iteration of the agentic loop.
      *
      * @param options - Iteration options
+     * @param options.effectiveMaxIterations - Effective max iterations (per-invocation override or config default)
      * @param options.executionContext - Optional execution context
      * @param options.fileData - Optional file data (only used on first iteration)
      * @param options.imageData - Optional image data (only used on first iteration)
@@ -561,7 +642,7 @@ export class ByteRoverLLMService {
      * @returns Final response string if complete, null if more iterations needed
      */
     async executeAgenticIteration(options) {
-        const { executionContext, fileData, imageData, iterationCount, stream, taskId, textInput, tools } = options;
+        const { effectiveMaxIterations, executionContext, fileData, imageData, iterationCount, stream, taskId, textInput, tools } = options;
         // Build system prompt using SystemPromptManager (before compression for correct token accounting)
         // Use filtered tool names based on command type (e.g., only read-only tools for 'query')
         const availableTools = this.toolManager.getToolNamesForCommand(executionContext?.commandType);
@@ -601,12 +682,12 @@ export class ByteRoverLLMService {
         }
         let systemPrompt = basePrompt;
         // Determine which reflection prompt to add (only highest priority is chosen)
-        const reflectionType = this.determineReflectionType(iterationCount, executionContext?.commandType);
+        const reflectionType = this.determineReflectionType(iterationCount, executionContext?.commandType, effectiveMaxIterations);
         // Add reflection prompt if eligible (hierarchical: only one reflection per iteration)
         if (reflectionType) {
             const reflectionPrompt = this.systemPromptManager.buildReflectionPrompt({
                 currentIteration: iterationCount + 1,
-                maxIterations: this.config.maxIterations,
+                maxIterations: effectiveMaxIterations,
                 type: reflectionType,
             });
             systemPrompt = systemPrompt + '\n\n' + reflectionPrompt;
@@ -624,7 +705,7 @@ export class ByteRoverLLMService {
         }
         // Final iteration optimization for query: strip tools (reflection already added above)
         let toolsForThisIteration = tools;
-        if (executionContext?.commandType === 'query' && iterationCount === this.config.maxIterations - 1) {
+        if (executionContext?.commandType === 'query' && iterationCount === effectiveMaxIterations - 1) {
             toolsForThisIteration = {}; // Empty toolset forces text response
         }
         // Get token count for logging (using system prompt for token accounting)
@@ -635,12 +716,45 @@ export class ByteRoverLLMService {
             if (iterationCount === 0) {
                 await this.contextManager.addUserMessage(textInput, imageData, fileData);
             }
-            const messages = this.contextManager.getMessages();
-            const messageTokenCounts = messages.map((msg) => this.generator.estimateTokensSync(typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)));
+            // Rolling checkpoint: periodically save progress and clear history for RLM commands.
+            // This prevents unbounded token accumulation during long curation/query tasks.
+            if (iterationCount > 0) {
+                const preCheckpointMessages = this.contextManager.getMessages();
+                const preCheckpointTokens = preCheckpointMessages.reduce((sum, msg) => sum + this.generator.estimateTokensSync(typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)), 0);
+                if (this.shouldTriggerCheckpoint(iterationCount, executionContext?.commandType, preCheckpointTokens)) {
+                    await this.performRollingCheckpoint(iterationCount, this.sessionId, textInput);
+                }
+            }
             const maxMessageTokens = this.config.maxInputTokens - systemPromptTokens;
             // Target utilization to leave headroom for response
             const targetMessageTokens = Math.floor(maxMessageTokens * TARGET_MESSAGE_TOKEN_UTILIZATION);
-            this.contextManager.compressMessage(targetMessageTokens, messageTokenCounts);
+            // Smart pruning: try clearing old tool outputs before destructive compression
+            this.contextManager.markToolOutputsCompacted(2);
+            // Get token counts (recalculate if pruning changed content)
+            const currentMessages = this.contextManager.getMessages();
+            const effectiveTokenCounts = currentMessages.map((msg) => this.generator.estimateTokensSync(typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)));
+            // Destructive compression as fallback if still over limit
+            this.contextManager.compressMessage(targetMessageTokens, effectiveTokenCounts);
+            // Emergency guard: if still over 90% after normal compression, force aggressive compaction
+            // This is critical for curate/query commands where there's only 1 user turn,
+            // making the protectedTurns=2 in markToolOutputsCompacted() ineffective.
+            if (executionContext?.commandType === 'curate' || executionContext?.commandType === 'query') {
+                const postCompressionMessages = this.contextManager.getMessages();
+                const postCompressionTokens = postCompressionMessages.reduce((sum, msg) => sum + this.generator.estimateTokensSync(typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)), 0);
+                const totalWithSystem = postCompressionTokens + systemPromptTokens;
+                if (totalWithSystem > this.config.maxInputTokens * 0.9) {
+                    // Aggressive: compact ALL tool outputs (protect 0 turns instead of 2)
+                    this.contextManager.markToolOutputsCompacted(0);
+                    // Recalculate and re-compress
+                    const aggressiveMessages = this.contextManager.getMessages();
+                    const aggressiveTokens = aggressiveMessages.map((msg) => this.generator.estimateTokensSync(typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)));
+                    this.contextManager.compressMessage(targetMessageTokens, aggressiveTokens);
+                    this.sessionEventBus.emit('llmservice:warning', {
+                        message: `Emergency context compression triggered (${Math.round((totalWithSystem / this.config.maxInputTokens) * 100)}% utilization)`,
+                        taskId,
+                    });
+                }
+            }
             // Build generation request
             const request = this.buildGenerateContentRequest({
                 executionContext,
@@ -660,8 +774,18 @@ export class ByteRoverLLMService {
                 await this.checkAndTriggerCompaction(taskId ?? '');
                 return response;
             }
-            // Has tool calls - handle them (pass taskId for subagent billing)
-            await this.handleToolCalls(lastMessage, taskId);
+            // Has tool calls - handle them (pass taskId and executionContext for context-aware behavior)
+            const earlyExitResult = await this.handleToolCalls(lastMessage, taskId, executionContext);
+            // Check for early exit from setFinalResult()
+            if (earlyExitResult) {
+                this.sessionEventBus.emit('llmservice:response', {
+                    content: earlyExitResult,
+                    model: this.config.model,
+                    provider: this.providerId,
+                    taskId,
+                });
+                return earlyExitResult;
+            }
             // Auto-compaction check after tool execution batch
             await this.checkAndTriggerCompaction(taskId ?? '');
             return null;
@@ -673,9 +797,10 @@ export class ByteRoverLLMService {
      *
      * @param toolCall - Tool call to execute
      * @param taskId - Task ID from usecase for billing tracking (passed to subagents)
+     * @param executionContext - Optional execution context for context-aware tool behavior
      * @returns Parallel tool result with all execution data
      */
-    async executeToolCallParallel(toolCall, taskId) {
+    async executeToolCallParallel(toolCall, taskId, executionContext) {
         const toolName = toolCall.function.name;
         const toolArgs = JSON.parse(toolCall.function.arguments);
         try {
@@ -720,13 +845,14 @@ export class ByteRoverLLMService {
             // Create metadata callback for streaming tool output
             const metadataCallback = this.metadataHandler.createCallback(toolCall.id, toolName);
             // Execute tool via ToolManager (returns structured result)
-            // Pass taskId in context for subagent billing tracking
+            // Pass taskId and commandType in context for subagent billing tracking and context-aware behavior
             const result = await this.toolManager.executeTool(toolName, toolArgs, this.sessionId, {
+                commandType: executionContext?.commandType,
                 metadata: metadataCallback,
                 taskId,
             });
-            // Process output (truncation and file saving if needed)
-            const processedOutput = await this.outputProcessor.processStructuredOutput(toolName, result.content);
+            // Process output (truncation and file saving if needed, with per-command overrides)
+            const processedOutput = await this.outputProcessor.processStructuredOutput(toolName, result.content, executionContext?.commandType);
             // Emit truncation event if output was truncated
             if (processedOutput.metadata?.truncated) {
                 this.sessionEventBus.emit('llmservice:outputTruncated', {
@@ -750,7 +876,11 @@ export class ByteRoverLLMService {
                 taskId: taskId || undefined,
                 toolName,
             });
+            // Check for early exit signal from setFinalResult() in sandbox
+            const toolContent = result.content;
+            const earlyExitResult = typeof toolContent?.finalResult === 'string' ? toolContent.finalResult : undefined;
             return {
+                earlyExitResult,
                 toolCall,
                 toolResult: {
                     errorType: result.errorType,
@@ -827,7 +957,7 @@ export class ByteRoverLLMService {
         this.sessionEventBus.emit('llmservice:response', {
             content,
             model: this.config.model,
-            provider: 'byterover',
+            provider: this.providerId,
             taskId: taskId || undefined,
         });
         // Add assistant message to context
@@ -882,26 +1012,34 @@ export class ByteRoverLLMService {
         this.sessionEventBus.emit('llmservice:warning', {
             message: `Agent terminated: ${reason} after ${context.turnCount} turns`,
             model: this.config.model,
-            provider: 'byterover',
+            provider: this.providerId,
             taskId: taskId || undefined,
         });
         // Get accumulated response from context
         const partialResponse = await this.getPartialResponse();
+        // Compute final content with fallback BEFORE emitting, so the event
+        // carries the same content that is returned (prevents empty-string mismatch
+        // when the streaming pipeline reads from the emitted event rather than the return value)
+        let finalContent;
+        if (reason === TerminationReason.MAX_TURNS) {
+            finalContent =
+                partialResponse ||
+                    'Maximum iterations reached without completing the task. Please try breaking down the task into smaller steps.';
+        }
+        else if (reason === TerminationReason.TIMEOUT) {
+            finalContent = partialResponse || 'Execution timed out. Please try a simpler task or increase the timeout.';
+        }
+        else {
+            finalContent = partialResponse || 'Agent execution terminated unexpectedly.';
+        }
         this.sessionEventBus.emit('llmservice:response', {
-            content: partialResponse,
+            content: finalContent,
             model: this.config.model,
             partial: true,
-            provider: 'byterover',
+            provider: this.providerId,
             taskId: taskId || undefined,
         });
-        if (reason === TerminationReason.MAX_TURNS) {
-            return (partialResponse ||
-                'Maximum iterations reached without completing the task. Please try breaking down the task into smaller steps.');
-        }
-        if (reason === TerminationReason.TIMEOUT) {
-            return partialResponse || 'Execution timed out. Please try a simpler task or increase the timeout.';
-        }
-        return partialResponse || 'Agent execution terminated unexpectedly.';
+        return finalContent;
     }
     /**
      * Handle thoughts from LLM response (Gemini only).
@@ -937,8 +1075,10 @@ export class ByteRoverLLMService {
      *
      * @param lastMessage - Last message containing tool calls
      * @param taskId - Task ID from usecase for billing tracking (passed to subagents)
+     * @param executionContext - Optional execution context for context-aware tool behavior
+     * @returns Early exit result if setFinalResult() was called, undefined otherwise
      */
-    async handleToolCalls(lastMessage, taskId) {
+    async handleToolCalls(lastMessage, taskId, executionContext) {
         if (!lastMessage.toolCalls || lastMessage.toolCalls.length === 0) {
             return;
         }
@@ -950,7 +1090,8 @@ export class ByteRoverLLMService {
         // Step 1: Create pending tool parts for all tool calls
         for (const toolCall of lastMessage.toolCalls) {
             const toolArgs = JSON.parse(toolCall.function.arguments);
-            this.contextManager.addToolCallPending(toolCall.id, toolCall.function.name, toolArgs);
+            // eslint-disable-next-line no-await-in-loop -- Must add pending parts in order
+            await this.contextManager.addToolCallPending(toolCall.id, toolCall.function.name, toolArgs);
         }
         // Step 2: Transition all to running state
         const startTime = Date.now();
@@ -960,15 +1101,16 @@ export class ByteRoverLLMService {
                 startedAt: startTime,
                 status: 'running',
             };
-            this.contextManager.updateToolCallState(toolCall.id, runningState);
+            // eslint-disable-next-line no-await-in-loop -- Must update states in order
+            await this.contextManager.updateToolCallState(toolCall.id, runningState);
         }
         // Check if any memory-modifying tools are being called (invalidates cached system prompt)
         const memoryModifyingTools = new Set(['delete_memory', 'edit_memory', 'write_memory']);
         if (lastMessage.toolCalls.some((tc) => memoryModifyingTools.has(tc.function.name))) {
             this.memoryDirtyFlag = true;
         }
-        // Step 3: Execute all tool calls in parallel (pass taskId for subagent billing)
-        const parallelResults = await Promise.allSettled(lastMessage.toolCalls.map((toolCall) => this.executeToolCallParallel(toolCall, taskId)));
+        // Step 3: Execute all tool calls in parallel (pass taskId + commandType for context-aware behavior)
+        const parallelResults = await Promise.allSettled(lastMessage.toolCalls.map((toolCall) => this.executeToolCallParallel(toolCall, taskId, executionContext)));
         // Step 4: Update tool part states with results (in order)
         const endTime = Date.now();
         // eslint-disable-next-line unicorn/no-for-loop -- Need index to access both parallelResults and toolCalls in parallel
@@ -989,7 +1131,8 @@ export class ByteRoverLLMService {
                         time: { end: endTime, start: startTime },
                         title: result.toolResult.processedOutput.title,
                     };
-                    this.contextManager.updateToolCallState(toolCall.id, completedState);
+                    // eslint-disable-next-line no-await-in-loop -- Must update states in order
+                    await this.contextManager.updateToolCallState(toolCall.id, completedState);
                 }
                 else {
                     // Transition to error state
@@ -999,7 +1142,8 @@ export class ByteRoverLLMService {
                         status: 'error',
                         time: { end: endTime, start: startTime },
                     };
-                    this.contextManager.updateToolCallState(toolCall.id, errorState);
+                    // eslint-disable-next-line no-await-in-loop -- Must update states in order
+                    await this.contextManager.updateToolCallState(toolCall.id, errorState);
                 }
                 // Also add to context as tool result message (for backward compatibility)
                 // eslint-disable-next-line no-await-in-loop -- Must add results in order
@@ -1020,7 +1164,8 @@ export class ByteRoverLLMService {
                     status: 'error',
                     time: { end: endTime, start: startTime },
                 };
-                this.contextManager.updateToolCallState(toolCall.id, errorState);
+                // eslint-disable-next-line no-await-in-loop -- Must update states in order
+                await this.contextManager.updateToolCallState(toolCall.id, errorState);
                 // Also add to context as tool result message (for backward compatibility)
                 // eslint-disable-next-line no-await-in-loop -- Must add results in order
                 await this.contextManager.addToolResult(toolCall.id, toolCall.function.name, `Error: ${errorMessage}`, {
@@ -1029,6 +1174,40 @@ export class ByteRoverLLMService {
                 });
             }
         }
+        // Check for early exit signal from setFinalResult() in any tool result
+        for (const settledResult of parallelResults) {
+            if (settledResult.status === 'fulfilled' && settledResult.value.earlyExitResult) {
+                return settledResult.value.earlyExitResult;
+            }
+        }
+    }
+    /**
+     * Perform a rolling checkpoint: save progress to sandbox variable, clear history, re-inject prompt.
+     * This treats each batch of iterations as a mini-task, preventing unbounded token accumulation.
+     *
+     * @param iterationCount - Current iteration number
+     * @param sessionId - Session ID for sandbox variable injection
+     * @param textInput - Original user input text (for continuation prompt)
+     */
+    async performRollingCheckpoint(iterationCount, sessionId, textInput) {
+        const messages = this.contextManager.getMessages();
+        const progressSummary = this.buildProgressSummary(messages);
+        // Store progress in sandbox variable (persists across history clears)
+        const checkpointVar = `__checkpoint_progress`;
+        this.sandboxService.setSandboxVariable(sessionId, checkpointVar, progressSummary);
+        // Clear conversation history
+        await this.contextManager.clearHistory();
+        // Re-inject continuation prompt with variable reference
+        const continuationPrompt = [
+            `Continue task. Iteration checkpoint at turn ${iterationCount}.`,
+            `Previous progress stored in variable: ${checkpointVar}`,
+            `Original task: ${textInput.slice(0, 200)}${textInput.length > 200 ? '...' : ''}`,
+            `Read ${checkpointVar} via code_exec to understand what was done, then continue.`,
+        ].join('\n');
+        await this.contextManager.addUserMessage(continuationPrompt);
+        this.sessionEventBus.emit('llmservice:warning', {
+            message: `Rolling checkpoint at iteration ${iterationCount}: history cleared, progress saved to ${checkpointVar}`,
+        });
     }
     /**
      * Replace the DateTime section in a cached system prompt with a fresh timestamp.
@@ -1042,6 +1221,39 @@ export class ByteRoverLLMService {
         const freshDateTime = `<dateTime>Current date and time: ${new Date().toISOString()}</dateTime>`;
         return cachedPrompt.replace(/<dateTime>[\S\s]*?<\/dateTime>/, freshDateTime);
     }
+    /**
+     * Check if a rolling checkpoint should trigger.
+     * Triggers every N iterations for curate/query commands, or when token utilization is high.
+     *
+     * @param iterationCount - Current iteration number
+     * @param commandType - Command type (only curate/query trigger checkpoints)
+     * @param currentTokens - Current estimated token count for messages
+     * @returns True if checkpoint should trigger
+     */
+    shouldTriggerCheckpoint(iterationCount, commandType, currentTokens) {
+        // Only for curate/query commands (never disrupt chat)
+        if (commandType !== 'curate' && commandType !== 'query') {
+            return false;
+        }
+        // Never on first iteration
+        if (iterationCount === 0) {
+            return false;
+        }
+        // Need sandbox service for variable injection
+        if (!this.sandboxService) {
+            return false;
+        }
+        // Trigger every 5 iterations
+        const CHECKPOINT_INTERVAL = 5;
+        if (iterationCount % CHECKPOINT_INTERVAL === 0) {
+            return true;
+        }
+        // Trigger on high token utilization (> 60%)
+        if (currentTokens && currentTokens > this.config.maxInputTokens * 0.6) {
+            return true;
+        }
+        return false;
+    }
     /**
      * Validate LLM configuration using Zod schema.
      *