byterover-cli 0.3.5 → 0.4.0

package/dist/infra/cipher/llm/context/compaction/compaction-service.js

@@ -0,0 +1,132 @@
+/**
+ * Default prompt for generating conversation summaries.
+ * Based on OpenCode's PROMPT_COMPACTION.
+ */
+const DEFAULT_SUMMARY_PROMPT = `You are a helpful assistant that summarizes conversations.
+Given the conversation history, provide a detailed summary that captures:
+1. The main tasks or goals discussed
+2. Key decisions and outcomes
+3. Important context that should be preserved
+4. Any unfinished work or pending items
+
+Format the summary as a clear, comprehensive prompt that could be used to continue the conversation.
+Focus on the "what" and "why" rather than the step-by-step "how".`;
+/**
+ * Service for managing context compaction in granular history storage.
+ *
+ * Compaction reduces context size through two mechanisms:
+ * 1. Tool output pruning - marks old tool outputs as compacted
+ * 2. Compaction boundaries - summarizes old history and creates a boundary
+ *
+ * Based on OpenCode's compaction patterns:
+ * - isOverflow() checks if context exceeds threshold
+ * - prune() marks old tool outputs as compacted
+ * - insertCompactionBoundary() creates a summary boundary
+ */
+export class CompactionService {
+    messageStorage;
+    tokenizer;
+    config;
+    constructor(messageStorage, tokenizer, config) {
+        this.messageStorage = messageStorage;
+        this.tokenizer = tokenizer;
+        this.config = {
+            overflowThreshold: config?.overflowThreshold ?? 0.85,
+            pruneKeepTokens: config?.pruneKeepTokens ?? 40_000,
+            summaryPrompt: config?.summaryPrompt ?? DEFAULT_SUMMARY_PROMPT,
+        };
+    }
+    /**
+     * Perform automatic compaction based on current context state.
+     * This is a convenience method that checks overflow and takes appropriate action.
+     *
+     * @returns CompactionResult if action was taken, undefined if no action needed
+     */
+    async autoCompact(input) {
+        const { contextLimit, currentTokens, sessionId } = input;
+        const overflowCheck = this.checkOverflow(currentTokens, contextLimit);
+        if (!overflowCheck.isOverflow) {
+            return undefined;
+        }
+        if (overflowCheck.recommendation === 'prune') {
+            return this.pruneToolOutputs(sessionId);
+        }
+        // For full compaction, we need the caller to generate the summary
+        // via the LLM, then call createCompactionBoundary
+        // Return a result indicating compaction is needed
+        return {
+            compactedCount: 0,
+            compactionMessageId: undefined,
+            tokensSaved: 0,
+        };
+    }
+    /**
+     * Check if context is overflowing and recommend action.
+     */
+    checkOverflow(currentTokens, contextLimit) {
+        const threshold = contextLimit * this.config.overflowThreshold;
+        const isOverflow = currentTokens > threshold;
+        let recommendation = 'none';
+        if (isOverflow) {
+            // First try pruning tool outputs
+            recommendation = 'prune';
+            // If we're significantly over, suggest full compaction
+            if (currentTokens > contextLimit * 0.95) {
+                recommendation = 'compact';
+            }
+        }
+        return {
+            currentTokens,
+            isOverflow,
+            maxTokens: contextLimit,
+            recommendation,
+        };
+    }
+    /**
+     * Create a compaction boundary with the given summary.
+     * The boundary acts as a marker - history loading stops here.
+     */
+    async createCompactionBoundary(sessionId, summary) {
+        await this.messageStorage.insertCompactionBoundary(sessionId, summary);
+    }
+    /**
+     * Estimate tokens for a text string.
+     * Uses the configured tokenizer.
+     */
+    async estimateTokens(text) {
+        return this.tokenizer.countTokens(text);
+    }
+    /**
+     * Get the current compaction configuration.
+     */
+    getConfig() {
+        return this.config;
+    }
+    /**
+     * Generate a summary prompt for the LLM to create a compaction summary.
+     * This returns the system prompt and user message to send to the LLM.
+     */
+    getSummaryPromptParts() {
+        return {
+            systemPrompt: this.config.summaryPrompt,
+            userMessage: 'Based on our conversation so far, provide a detailed summary that captures all important context. ' +
+                'This summary will be used to continue the conversation without the full history.',
+        };
+    }
+    /**
+     * Prune old tool outputs to reduce context size.
+     * Keeps the most recent tool outputs up to the configured token limit.
+     */
+    async pruneToolOutputs(sessionId) {
+        return this.messageStorage.pruneToolOutputs({
+            keepTokens: this.config.pruneKeepTokens,
+            sessionId,
+        });
+    }
+}
+/**
+ * Factory function to create CompactionService.
+ */
+export function createCompactionService(messageStorage, tokenizer, config) {
+    return new CompactionService(messageStorage, tokenizer, config);
+}

package/dist/infra/cipher/llm/context/compaction/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Compaction module for managing context size in granular history storage.
+ *
+ * Exports:
+ * - CompactionService: Main service for overflow detection and compaction
+ * - createCompactionService: Factory function
+ * - Types: CompactionConfig, OverflowCheckResult, CompactionInput
+ */
+export { type CompactionConfig, type CompactionInput, CompactionService, createCompactionService, type OverflowCheckResult, } from './compaction-service.js';

package/dist/infra/cipher/llm/context/compaction/index.js

@@ -0,0 +1,9 @@
+/**
+ * Compaction module for managing context size in granular history storage.
+ *
+ * Exports:
+ * - CompactionService: Main service for overflow detection and compaction
+ * - createCompactionService: Factory function
+ * - Types: CompactionConfig, OverflowCheckResult, CompactionInput
+ */
+export { CompactionService, createCompactionService, } from './compaction-service.js';

package/dist/infra/cipher/llm/context/context-manager.d.ts

@@ -4,6 +4,28 @@ import type { IMessageFormatter } from '../../../../core/interfaces/cipher/i-mes
 import type { ITokenizer } from '../../../../core/interfaces/cipher/i-tokenizer.js';
 import type { InternalMessage } from '../../../../core/interfaces/cipher/message-types.js';
 import type { ICompressionStrategy } from './compression/types.js';
+/**
+ * Configuration for persistence retry behavior.
+ */
+export interface PersistenceRetryConfig {
+    /** Base delay between retries in milliseconds (default: 100) */
+    baseDelayMs?: number;
+    /** Maximum number of retry attempts (default: 3) */
+    maxRetries?: number;
+    /** Multiplier for exponential backoff (default: 2) */
+    multiplier?: number;
+}
+/**
+ * Event emitted when persistence fails after all retries.
+ */
+export interface PersistenceFailedEvent {
+    /** Number of attempts made */
+    attempts: number;
+    /** The error that caused the failure */
+    error: Error;
+    /** Session ID */
+    sessionId: string;
+}
 /**
  * Image data for messages
  */
@@ -51,6 +73,10 @@ export interface ContextManagerOptions<T> {
     historyStorage?: IHistoryStorage;
     logger?: ILogger;
     maxInputTokens: number;
+    /** Callback invoked when persistence fails after all retries */
+    onPersistenceFailed?: (event: PersistenceFailedEvent) => void;
+    /** Configuration for persistence retry behavior */
+    persistenceRetry?: PersistenceRetryConfig;
     sessionId: string;
     tokenizer: ITokenizer;
 }
@@ -79,6 +105,10 @@ export declare class ContextManager<T> {
      * Used during parallel tool execution to prevent race conditions.
      */
     private readonly mutex;
+    /** Callback for persistence failure events */
+    private readonly onPersistenceFailed?;
+    /** Retry configuration for persistence operations */
+    private readonly persistenceRetry;
     private readonly sessionId;
     private readonly tokenizer;
     /**
@@ -91,6 +121,8 @@ export declare class ContextManager<T> {
      * @param options.maxInputTokens - Maximum input tokens allowed
      * @param options.historyStorage - Optional history storage for persistence
      * @param options.compressionStrategies - Optional compression strategies (defaults to MiddleRemoval + OldestRemoval)
+     * @param options.persistenceRetry - Optional retry configuration for persistence
+     * @param options.onPersistenceFailed - Optional callback for persistence failure events
      */
     constructor(options: ContextManagerOptions<T>);
     /**
@@ -204,10 +236,17 @@ export declare class ContextManager<T> {
      */
     private isSystemNoise;
     /**
-     * Persist current conversation history to storage.
+     * Persist current conversation history to storage with retry logic.
      * This is called automatically after each message is added.
      *
-     * @returns Promise that resolves when history is persisted
+     * Uses exponential backoff for retries:
+     * - Attempt 1: immediate
+     * - Attempt 2: baseDelayMs * multiplier^0 = 100ms
+     * - Attempt 3: baseDelayMs * multiplier^1 = 200ms
+     *
+     * If all retries fail, invokes onPersistenceFailed callback if configured.
+     *
+     * @returns Promise that resolves when history is persisted (or all retries exhausted)
      */
     private persistHistory;
     /**
@@ -218,6 +257,11 @@ export declare class ContextManager<T> {
      * @returns Sanitized string representation
      */
     private sanitizeToolResult;
+    /**
+     * Sleep for the specified duration.
+     * @param ms - Duration in milliseconds
+     */
+    private sleep;
     /**
      * Validate a message for API inclusion.
      * Filters out invalid messages that would waste tokens or confuse the LLM.

package/dist/infra/cipher/llm/context/context-manager.js

@@ -28,6 +28,10 @@ export class ContextManager {
      * Used during parallel tool execution to prevent race conditions.
      */
     mutex = new AsyncMutex();
+    /** Callback for persistence failure events */
+    onPersistenceFailed;
+    /** Retry configuration for persistence operations */
+    persistenceRetry;
     sessionId;
     tokenizer;
     /**
@@ -40,6 +44,8 @@ export class ContextManager {
      * @param options.maxInputTokens - Maximum input tokens allowed
      * @param options.historyStorage - Optional history storage for persistence
      * @param options.compressionStrategies - Optional compression strategies (defaults to MiddleRemoval + OldestRemoval)
+     * @param options.persistenceRetry - Optional retry configuration for persistence
+     * @param options.onPersistenceFailed - Optional callback for persistence failure events
      */
     constructor(options) {
         this.sessionId = options.sessionId;
@@ -48,6 +54,13 @@ export class ContextManager {
         this.maxInputTokens = options.maxInputTokens;
         this.historyStorage = options.historyStorage;
         this.logger = options.logger ?? new NoOpLogger();
+        this.onPersistenceFailed = options.onPersistenceFailed;
+        // Initialize persistence retry config with defaults
+        this.persistenceRetry = {
+            baseDelayMs: options.persistenceRetry?.baseDelayMs ?? 100,
+            maxRetries: options.persistenceRetry?.maxRetries ?? 3,
+            multiplier: options.persistenceRetry?.multiplier ?? 2,
+        };
         // Initialize compression strategies with defaults
         this.compressionStrategies = options.compressionStrategies ?? [
             new MiddleRemovalStrategy({ preserveEnd: 5, preserveStart: 4 }),
@@ -350,17 +363,59 @@ export class ContextManager {
         return content.trim().length === 0;
     }
     /**
-     * Persist current conversation history to storage.
+     * Persist current conversation history to storage with retry logic.
      * This is called automatically after each message is added.
      *
-     * @returns Promise that resolves when history is persisted
+     * Uses exponential backoff for retries:
+     * - Attempt 1: immediate
+     * - Attempt 2: baseDelayMs * multiplier^0 = 100ms
+     * - Attempt 3: baseDelayMs * multiplier^1 = 200ms
+     *
+     * If all retries fail, invokes onPersistenceFailed callback if configured.
+     *
+     * @returns Promise that resolves when history is persisted (or all retries exhausted)
      */
     async persistHistory() {
         if (!this.historyStorage) {
             return;
         }
-        // Store InternalMessage directly (no conversion needed)
-        await this.historyStorage.saveHistory(this.sessionId, this.messages);
+        const { baseDelayMs, maxRetries, multiplier } = this.persistenceRetry;
+        let lastError;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                // Store InternalMessage directly (no conversion needed)
+                // eslint-disable-next-line no-await-in-loop
+                await this.historyStorage.saveHistory(this.sessionId, this.messages);
+                return; // Success - exit early
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                if (attempt < maxRetries) {
+                    // Calculate exponential backoff delay
+                    const delay = baseDelayMs * multiplier ** (attempt - 1);
+                    this.logger.warn(`Persistence attempt ${attempt}/${maxRetries} failed, retrying in ${delay}ms`, {
+                        error: lastError.message,
+                        sessionId: this.sessionId,
+                    });
+                    // Wait before next retry
+                    // eslint-disable-next-line no-await-in-loop
+                    await this.sleep(delay);
+                }
+            }
+        }
+        // All retries exhausted
+        this.logger.error(`Persistence failed after ${maxRetries} attempts`, {
+            error: lastError?.message,
+            sessionId: this.sessionId,
+        });
+        // Invoke callback if configured
+        if (this.onPersistenceFailed && lastError) {
+            this.onPersistenceFailed({
+                attempts: maxRetries,
+                error: lastError,
+                sessionId: this.sessionId,
+            });
+        }
     }
     /**
      * Sanitize tool result for storage.
@@ -389,6 +444,15 @@ export class ContextManager {
             return `[Tool result serialization failed: ${getErrorMessage(error)}]`;
         }
     }
+    /**
+     * Sleep for the specified duration.
+     * @param ms - Duration in milliseconds
+     */
+    sleep(ms) {
+        return new Promise((resolve) => {
+            setTimeout(resolve, ms);
+        });
+    }
     /**
      * Validate a message for API inclusion.
      * Filters out invalid messages that would waste tokens or confuse the LLM.

package/dist/infra/cipher/llm/context/rw-lock.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Reader-Writer Lock with Disposable pattern support.
+ *
+ * Provides concurrent read access while ensuring exclusive write access.
+ * Multiple readers can hold the lock simultaneously, but writers get
+ * exclusive access (no readers or other writers).
+ *
+ * Follows OpenCode's lock pattern with ES2022 'using' keyword support
+ * for automatic release.
+ *
+ * Usage:
+ * ```typescript
+ * // Read lock (allows concurrent reads)
+ * using _readLock = await RWLock.read('session:123')
+ * const data = await storage.get(key)
+ *
+ * // Write lock (exclusive access)
+ * using _writeLock = await RWLock.write('session:123')
+ * await storage.set(key, value)
+ * ```
+ */
+/**
+ * Global lock manager for coordinating concurrent access.
+ * Uses per-target locks to allow independent locking of different resources.
+ */
+declare class RWLockManager {
+    private readonly locks;
+    /**
+     * Get current lock statistics for debugging.
+     */
+    getStats(): {
+        activeLocks: number;
+        targets: string[];
+    };
+    /**
+     * Acquire a read lock.
+     * Multiple readers can hold the lock simultaneously.
+     * Will wait if a writer holds the lock or is waiting.
+     *
+     * @param target - Resource identifier to lock
+     * @returns Disposable that releases the lock when disposed
+     */
+    read(target: string): Promise<Disposable>;
+    /**
+     * Acquire a write lock.
+     * Writers get exclusive access - no readers or other writers.
+     * Writers have priority over readers to prevent writer starvation.
+     *
+     * @param target - Resource identifier to lock
+     * @returns Disposable that releases the lock when disposed
+     */
+    write(target: string): Promise<Disposable>;
+    /**
+     * Clean up lock state if no longer needed.
+     */
+    private cleanupIfEmpty;
+    /**
+     * Get or create lock state for a target.
+     */
+    private getLockState;
+}
+/**
+ * Global RWLock instance for coordinating storage access.
+ * Use this for all storage operations to prevent race conditions.
+ */
+export declare const RWLock: RWLockManager;
+/**
+ * Helper function to create a lock key from a storage key.
+ * Converts ["message", "session123", "msg456"] to "message:session123:msg456"
+ */
+export declare function lockKeyFromStorageKey(storageKey: readonly string[]): string;
+export {};

package/dist/infra/cipher/llm/context/rw-lock.js

@@ -0,0 +1,145 @@
+/**
+ * Reader-Writer Lock with Disposable pattern support.
+ *
+ * Provides concurrent read access while ensuring exclusive write access.
+ * Multiple readers can hold the lock simultaneously, but writers get
+ * exclusive access (no readers or other writers).
+ *
+ * Follows OpenCode's lock pattern with ES2022 'using' keyword support
+ * for automatic release.
+ *
+ * Usage:
+ * ```typescript
+ * // Read lock (allows concurrent reads)
+ * using _readLock = await RWLock.read('session:123')
+ * const data = await storage.get(key)
+ *
+ * // Write lock (exclusive access)
+ * using _writeLock = await RWLock.write('session:123')
+ * await storage.set(key, value)
+ * ```
+ */
+/**
+ * Global lock manager for coordinating concurrent access.
+ * Uses per-target locks to allow independent locking of different resources.
+ */
+class RWLockManager {
+    locks = new Map();
+    /**
+     * Get current lock statistics for debugging.
+     */
+    getStats() {
+        return {
+            activeLocks: this.locks.size,
+            targets: [...this.locks.keys()],
+        };
+    }
+    /**
+     * Acquire a read lock.
+     * Multiple readers can hold the lock simultaneously.
+     * Will wait if a writer holds the lock or is waiting.
+     *
+     * @param target - Resource identifier to lock
+     * @returns Disposable that releases the lock when disposed
+     */
+    async read(target) {
+        const state = this.getLockState(target);
+        // Wait for any pending/active writer (writers have priority to prevent starvation)
+        while (state.writer || state.waitingWriters.length > 0) {
+            // eslint-disable-next-line no-await-in-loop
+            await new Promise((resolve) => {
+                state.waitingReaders.push(resolve);
+            });
+        }
+        state.readers++;
+        return {
+            [Symbol.dispose]: () => {
+                state.readers--;
+                // If no more readers and writers are waiting, wake a writer
+                if (state.readers === 0 && state.waitingWriters.length > 0) {
+                    const next = state.waitingWriters.shift();
+                    next?.();
+                }
+                this.cleanupIfEmpty(target);
+            },
+        };
+    }
+    /**
+     * Acquire a write lock.
+     * Writers get exclusive access - no readers or other writers.
+     * Writers have priority over readers to prevent writer starvation.
+     *
+     * @param target - Resource identifier to lock
+     * @returns Disposable that releases the lock when disposed
+     */
+    async write(target) {
+        const state = this.getLockState(target);
+        // Wait for all readers and any active writer
+        while (state.writer || state.readers > 0) {
+            // eslint-disable-next-line no-await-in-loop
+            await new Promise((resolve) => {
+                state.waitingWriters.push(resolve);
+            });
+        }
+        state.writer = true;
+        return {
+            [Symbol.dispose]: () => {
+                state.writer = false;
+                // Prefer writers over readers to prevent writer starvation
+                if (state.waitingWriters.length > 0) {
+                    const next = state.waitingWriters.shift();
+                    next?.();
+                }
+                else {
+                    // Wake all pending readers at once
+                    while (state.waitingReaders.length > 0) {
+                        const next = state.waitingReaders.shift();
+                        next?.();
+                    }
+                }
+                this.cleanupIfEmpty(target);
+            },
+        };
+    }
+    /**
+     * Clean up lock state if no longer needed.
+     */
+    cleanupIfEmpty(target) {
+        const state = this.locks.get(target);
+        if (state &&
+            state.readers === 0 &&
+            !state.writer &&
+            state.waitingReaders.length === 0 &&
+            state.waitingWriters.length === 0) {
+            this.locks.delete(target);
+        }
+    }
+    /**
+     * Get or create lock state for a target.
+     */
+    getLockState(target) {
+        let state = this.locks.get(target);
+        if (!state) {
+            state = {
+                readers: 0,
+                waitingReaders: [],
+                waitingWriters: [],
+                writer: false,
+            };
+            this.locks.set(target, state);
+        }
+        return state;
+    }
+}
+/**
+ * Global RWLock instance for coordinating storage access.
+ * Use this for all storage operations to prevent race conditions.
+ */
+export const RWLock = new RWLockManager();
+/**
+ * Helper function to create a lock key from a storage key.
+ * Converts ["message", "session123", "msg456"] to "message:session123:msg456"
+ */
+export function lockKeyFromStorageKey(storageKey) {
+    return storageKey.join(':');
+}

package/dist/infra/cipher/llm/generators/byterover-content-generator.d.ts

@@ -1,11 +1,11 @@
 /**
  * ByteRover Content Generator.
  *
- * Implements IContentGenerator using ByteRover gRPC service.
- * Supports both Claude and Gemini models through the unified gRPC interface.
+ * Implements IContentGenerator using ByteRover HTTP service.
+ * Supports both Claude and Gemini models through the unified HTTP interface.
  */
 import type { GenerateContentChunk, GenerateContentRequest, GenerateContentResponse, IContentGenerator } from '../../../../core/interfaces/cipher/i-content-generator.js';
-import type { ByteRoverLlmGrpcService } from '../../grpc/internal-llm-grpc-service.js';
+import type { ByteRoverLlmHttpService } from '../../http/internal-llm-http-service.js';
 import { type ThinkingConfig } from '../thought-parser.js';
 /**
  * Configuration for ByteRover Content Generator.
@@ -23,7 +23,7 @@ export interface ByteRoverContentGeneratorConfig {
 /**
  * ByteRover Content Generator.
  *
- * Wraps ByteRoverLlmGrpcService and implements IContentGenerator.
+ * Wraps ByteRoverLlmHttpService and implements IContentGenerator.
  * Handles:
  * - Provider detection (Claude vs Gemini)
  * - Message formatting via provider-specific formatters
@@ -33,16 +33,16 @@ export interface ByteRoverContentGeneratorConfig {
 export declare class ByteRoverContentGenerator implements IContentGenerator {
     private readonly config;
     private readonly formatter;
-    private readonly grpcService;
+    private readonly httpService;
     private readonly providerType;
     private readonly tokenizer;
     /**
      * Create a new ByteRover Content Generator.
      *
-     * @param grpcService - Configured gRPC service for LLM API calls
+     * @param httpService - Configured HTTP service for LLM API calls
      * @param config - Generator configuration
      */
-    constructor(grpcService: ByteRoverLlmGrpcService, config: ByteRoverContentGeneratorConfig);
+    constructor(httpService: ByteRoverLlmHttpService, config: ByteRoverContentGeneratorConfig);
     /**
      * Estimate tokens synchronously using character-based approximation.
      *

package/dist/infra/cipher/llm/generators/byterover-content-generator.js

@@ -1,8 +1,8 @@
 /**
  * ByteRover Content Generator.
  *
- * Implements IContentGenerator using ByteRover gRPC service.
- * Supports both Claude and Gemini models through the unified gRPC interface.
+ * Implements IContentGenerator using ByteRover HTTP service.
+ * Supports both Claude and Gemini models through the unified HTTP interface.
  */
 import { FunctionCallingConfigMode } from '@google/genai';
 import { ClaudeMessageFormatter } from '../formatters/claude-formatter.js';
@@ -13,7 +13,7 @@ import { GeminiTokenizer } from '../tokenizers/gemini-tokenizer.js';
 /**
  * ByteRover Content Generator.
  *
- * Wraps ByteRoverLlmGrpcService and implements IContentGenerator.
+ * Wraps ByteRoverLlmHttpService and implements IContentGenerator.
  * Handles:
  * - Provider detection (Claude vs Gemini)
  * - Message formatting via provider-specific formatters
@@ -23,17 +23,17 @@ import { GeminiTokenizer } from '../tokenizers/gemini-tokenizer.js';
 export class ByteRoverContentGenerator {
     config;
     formatter;
-    grpcService;
+    httpService;
     providerType;
     tokenizer;
     /**
      * Create a new ByteRover Content Generator.
      *
-     * @param grpcService - Configured gRPC service for LLM API calls
+     * @param httpService - Configured HTTP service for LLM API calls
      * @param config - Generator configuration
      */
-    constructor(grpcService, config) {
-        this.grpcService = grpcService;
+    constructor(httpService, config) {
+        this.httpService = httpService;
         this.config = {
             maxTokens: config.maxTokens ?? 8192,
             model: config.model,
@@ -81,7 +81,7 @@ export class ByteRoverContentGenerator {
             ...(request.mode && { mode: request.mode }),
             ...(request.executionContext && { executionContext: request.executionContext }),
         };
-        const rawResponse = await this.grpcService.generateContent(contents, config, this.config.model, executionMetadata);
+        const rawResponse = await this.httpService.generateContent(contents, config, this.config.model, executionMetadata);
         // Parse response to internal format
         const messages = this.formatter.parseResponse(rawResponse);
         const lastMessage = messages.at(-1);

package/dist/infra/cipher/llm/internal-llm-service.js

@@ -390,6 +390,7 @@ export class ByteRoverLLMService {
             availableTools,
             commandType: executionContext?.commandType,
             conversationMetadata: executionContext?.conversationMetadata,
+            fileReferenceInstructions: executionContext?.fileReferenceInstructions,
             memoryManager: this.memoryManager,
             mode,
         });
@@ -498,6 +499,7 @@ export class ByteRoverLLMService {
             // Emit tool result event with success/error info
             this.sessionEventBus.emit('llmservice:toolResult', {
                 callId: toolCall.id,
+                error: result.errorMessage,
                 errorType: result.errorType,
                 metadata: {
                     ...result.metadata,