byterover-cli 1.0.4 → 1.1.0

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

@@ -79,10 +79,14 @@ export class ContextManager {
             role: 'assistant',
             toolCalls,
         };
-        this.messages.push(message);
-        // Auto-save to persistent storage (non-blocking)
-        this.persistHistory().catch((error) => {
-            this.logger.error('Failed to persist history after assistant message', { error, sessionId: this.sessionId });
+        await this.mutex.withLock(async () => {
+            this.messages.push(message);
+            try {
+                await this.persistHistory();
+            }
+            catch (error) {
+                this.logger.error('Failed to persist history after assistant message', { error, sessionId: this.sessionId });
+            }
         });
     }
     /**
@@ -95,10 +99,14 @@ export class ContextManager {
             content,
             role: 'system',
         };
-        this.messages.push(message);
-        // Auto-save to persistent storage (non-blocking)
-        this.persistHistory().catch((error) => {
-            this.logger.error('Failed to persist history after system message', { error, sessionId: this.sessionId });
+        await this.mutex.withLock(async () => {
+            this.messages.push(message);
+            try {
+                await this.persistHistory();
+            }
+            catch (error) {
+                this.logger.error('Failed to persist history after system message', { error, sessionId: this.sessionId });
+            }
         });
     }
     /**
@@ -137,11 +145,32 @@ export class ContextManager {
      * @param _metadata.metadata - Execution metadata (duration, tokens, etc.)
      * @returns The content that was added
      */
-    async addToolResult(toolCallId, toolName, result, _metadata) {
+    async addToolResult(toolCallId, toolName, result, _metadata, attachments) {
         // Sanitize result - convert to string representation (can be done outside lock)
         const sanitized = this.sanitizeToolResult(result);
+        // Build content: if attachments exist, create MessagePart array
+        const content = attachments && attachments.length > 0
+            ? [
+                { text: sanitized, type: 'text' },
+                ...attachments.map((att) => {
+                    if (att.type === 'image') {
+                        return {
+                            image: att.data,
+                            mimeType: att.mime,
+                            type: 'image',
+                        };
+                    }
+                    return {
+                        data: att.data,
+                        filename: att.filename,
+                        mimeType: att.mime,
+                        type: 'file',
+                    };
+                }),
+            ]
+            : sanitized;
         const message = {
-            content: sanitized,
+            content,
             name: toolName,
             role: 'tool',
             toolCallId,
@@ -167,16 +196,18 @@ export class ContextManager {
      * @param _fileData - Optional file data (not yet implemented)
      */
     async addUserMessage(content, _imageData, _fileData) {
-        // Simple implementation: just use text content
-        // Image and file support can be added later
         const message = {
             content,
             role: 'user',
         };
-        this.messages.push(message);
-        // Auto-save to persistent storage (non-blocking)
-        this.persistHistory().catch((error) => {
-            this.logger.error('Failed to persist history after user message', { error, sessionId: this.sessionId });
+        await this.mutex.withLock(async () => {
+            this.messages.push(message);
+            try {
+                await this.persistHistory();
+            }
+            catch (error) {
+                this.logger.error('Failed to persist history after user message', { error, sessionId: this.sessionId });
+            }
         });
     }
     /**
@@ -559,8 +590,22 @@ export class ContextManager {
             if (typeof result === 'string') {
                 return result;
             }
-            // Convert to JSON string
-            const jsonString = JSON.stringify(result, null, 2);
+            // Convert to JSON string with special type handling
+            const jsonString = JSON.stringify(result, (_, val) => {
+                // Convert BigInt to string
+                if (typeof val === 'bigint') {
+                    return val.toString();
+                }
+                // Convert functions to their string representation
+                if (typeof val === 'function') {
+                    return `[Function: ${val.name || 'anonymous'}]`;
+                }
+                // Convert Symbols to string
+                if (typeof val === 'symbol') {
+                    return val.toString();
+                }
+                return val;
+            }, 2);
             // Limit size to prevent extremely large results
             const MAX_RESULT_LENGTH = 50_000;
             if (jsonString.length > MAX_RESULT_LENGTH) {

package/dist/infra/cipher/llm/formatters/gemini-formatter.d.ts

@@ -34,6 +34,7 @@ export declare class GeminiMessageFormatter implements IMessageFormatter<Content
     /**
      * Formats assistant message to Gemini's Content format.
      * Maps 'assistant' role to 'model' and includes both text and tool calls.
+     * For Gemini 3+ models, includes thoughtSignature on function calls.
      */
     private formatAssistantMessage;
     /**
@@ -67,3 +68,15 @@ export declare class GeminiMessageFormatter implements IMessageFormatter<Content
      */
     private generateToolCallId;
 }
+/**
+ * Ensures that function calls in the active conversation loop have thought signatures.
+ * Required for Gemini 3+ preview models.
+ *
+ * The "active loop" starts from the last user text message in the conversation.
+ * Only the first function call in each model turn needs a thought signature.
+ *
+ * @param contents Array of Content objects formatted for Gemini API
+ * @param model The model being used (only applies to Gemini 3+ models)
+ * @returns Modified contents with thought signatures added where needed
+ */
+export declare function ensureActiveLoopHasThoughtSignatures(contents: Content[], model: string): Content[];

package/dist/infra/cipher/llm/formatters/gemini-formatter.js

@@ -1,3 +1,10 @@
+import { isGemini3Model, SYNTHETIC_THOUGHT_SIGNATURE } from '../thought-parser.js';
+/**
+ * Type guard to check if a part has a thoughtSignature property.
+ */
+function hasThoughtSignature(part) {
+    return 'thoughtSignature' in part;
+}
 /**
  * Message formatter for Google Gemini API.
  *
@@ -64,24 +71,30 @@ export class GeminiMessageFormatter {
             return [];
         }
         const textParts = [];
-        const functionCalls = [];
+        const functionCallsWithSignatures = [];
         // Extract text and function calls from response parts
         for (const part of candidate.content.parts) {
             if ('text' in part && part.text) {
                 textParts.push(part.text);
             }
             if ('functionCall' in part && part.functionCall) {
-                functionCalls.push(part.functionCall);
+                // Extract thoughtSignature if present (Gemini 3+ models)
+                const thoughtSignature = hasThoughtSignature(part) ? part.thoughtSignature : undefined;
+                functionCallsWithSignatures.push({
+                    fc: part.functionCall,
+                    thoughtSignature,
+                });
             }
         }
         // Convert to internal message format
-        const toolCalls = functionCalls.length > 0
-            ? functionCalls.map((fc) => ({
+        const toolCalls = functionCallsWithSignatures.length > 0
+            ? functionCallsWithSignatures.map(({ fc, thoughtSignature }) => ({
                 function: {
                     arguments: JSON.stringify(fc.args ?? {}),
                     name: fc.name ?? '',
                 },
                 id: this.generateToolCallId(fc.name ?? ''),
+                thoughtSignature,
                 type: 'function',
             }))
             : undefined;
@@ -98,30 +111,58 @@ export class GeminiMessageFormatter {
      * Required by Gemini API when assistant made multiple tool calls.
      */
     combineToolResults(toolMessages) {
+        const parts = [];
+        for (const msg of toolMessages) {
+            // Add the tool result part
+            parts.push(this.formatToolResultPart(msg));
+            // Extract image/file parts from MessagePart[] content
+            if (Array.isArray(msg.content)) {
+                for (const part of msg.content) {
+                    if (part.type === 'image' || part.type === 'file') {
+                        parts.push(this.formatUserContentPart(part));
+                    }
+                }
+            }
+        }
         return {
-            parts: toolMessages.map((msg) => this.formatToolResultPart(msg)),
+            parts,
             role: 'user',
         };
     }
     /**
      * Formats assistant message to Gemini's Content format.
      * Maps 'assistant' role to 'model' and includes both text and tool calls.
+     * For Gemini 3+ models, includes thoughtSignature on function calls.
      */
     formatAssistantMessage(msg) {
         const parts = [];
         // Add text content if present
         if (msg.content) {
-            parts.push({ text: String(msg.content) });
+            if (typeof msg.content === 'string') {
+                parts.push({ text: msg.content });
+            }
+            else if (Array.isArray(msg.content)) {
+                for (const part of msg.content) {
+                    if (part.type === 'text') {
+                        parts.push({ text: part.text });
+                    }
+                }
+            }
         }
         // Add tool calls if present
         if (msg.toolCalls) {
             for (const tc of msg.toolCalls) {
-                parts.push({
+                const functionCallPart = {
                     functionCall: {
                         args: JSON.parse(tc.function.arguments),
                         name: tc.function.name,
                     },
-                });
+                };
+                // Include thoughtSignature if present (required for Gemini 3+ models)
+                if (tc.thoughtSignature) {
+                    functionCallPart.thoughtSignature = tc.thoughtSignature;
+                }
+                parts.push(functionCallPart);
             }
         }
         return {
@@ -174,8 +215,10 @@ export class GeminiMessageFormatter {
                 responseObject = { result: null };
             }
             else if (Array.isArray(msg.content)) {
-                // Array content (e.g., MessagePart[]) - wrap in result
-                responseObject = { result: msg.content };
+                // Array content (e.g., MessagePart[]) - filter out file/image parts
+                // File/image parts are sent separately as inlineData to avoid duplicate tokenization
+                const textParts = msg.content.filter((p) => p.type === 'text');
+                responseObject = textParts.length > 0 ? { result: textParts } : { result: 'Attachment processed' };
             }
             else if (typeof msg.content === 'object') {
                 // Already an object (shouldn't happen with current implementation, but handle it)
@@ -206,13 +249,28 @@ export class GeminiMessageFormatter {
             return { text: part.text };
         }
         if (part.type === 'image') {
-            // Image support not yet implemented for Gemini
-            // Gemini supports inline images via inlineData or fileData
-            return { text: '[Image not yet supported]' };
+            // Convert image to Gemini inlineData format
+            const imageData = typeof part.image === 'string' ? part.image : String(part.image);
+            // Remove data URL prefix if present (e.g., "data:image/jpeg;base64,")
+            const base64Data = imageData.includes(',') ? imageData.split(',')[1] : imageData;
+            return {
+                inlineData: {
+                    data: base64Data,
+                    mimeType: part.mimeType ?? 'image/jpeg',
+                },
+            };
         }
         if (part.type === 'file') {
-            // File support not yet implemented for Gemini
-            return { text: '[File not yet supported]' };
+            // Convert file to Gemini inlineData format (supports PDFs)
+            const fileData = typeof part.data === 'string' ? part.data : String(part.data);
+            // Remove data URL prefix if present
+            const base64Data = fileData.includes(',') ? fileData.split(',')[1] : fileData;
+            return {
+                inlineData: {
+                    data: base64Data,
+                    mimeType: part.mimeType ?? 'application/pdf',
+                },
+            };
         }
         return { text: '[Unknown content type]' };
     }
@@ -251,3 +309,76 @@ export class GeminiMessageFormatter {
         return `call_${timestamp}_${random}_${toolName}`;
     }
 }
+/**
+ * Ensures that function calls in the active conversation loop have thought signatures.
+ * Required for Gemini 3+ preview models.
+ *
+ * The "active loop" starts from the last user text message in the conversation.
+ * Only the first function call in each model turn needs a thought signature.
+ *
+ * @param contents Array of Content objects formatted for Gemini API
+ * @param model The model being used (only applies to Gemini 3+ models)
+ * @returns Modified contents with thought signatures added where needed
+ */
+export function ensureActiveLoopHasThoughtSignatures(contents, model) {
+    // Only apply to Gemini 3+ models
+    if (!isGemini3Model(model)) {
+        return contents;
+    }
+    // Find the last user turn with text message (start of active loop)
+    let activeLoopStartIndex = -1;
+    for (let i = contents.length - 1; i >= 0; i--) {
+        const content = contents[i];
+        if (content.role === 'user' && content.parts?.some((part) => 'text' in part && part.text)) {
+            activeLoopStartIndex = i;
+            break;
+        }
+    }
+    // No user text message found - nothing to do
+    if (activeLoopStartIndex === -1) {
+        return contents;
+    }
+    // Create shallow copy to avoid mutating original
+    const newContents = [...contents];
+    // Process each content from active loop start to end
+    for (let i = activeLoopStartIndex; i < newContents.length; i++) {
+        const content = newContents[i];
+        // Only process model turns with parts
+        if (content.role !== 'model' || !content.parts) {
+            continue;
+        }
+        const newParts = [...content.parts];
+        const updatedContent = addThoughtSignatureToFirstFunctionCall(newParts, content);
+        if (updatedContent) {
+            newContents[i] = updatedContent;
+        }
+    }
+    return newContents;
+}
+/**
+ * Adds thought signature to the first function call in parts if missing.
+ * Returns updated content or null if no modification needed.
+ */
+function addThoughtSignatureToFirstFunctionCall(parts, content) {
+    for (let j = 0; j < parts.length; j++) {
+        const part = parts[j];
+        if (!part || !('functionCall' in part) || !part.functionCall) {
+            continue;
+        }
+        // Check if thoughtSignature already exists using type guard
+        if (hasThoughtSignature(part) && part.thoughtSignature) {
+            return null; // Already has signature, no modification needed
+        }
+        // Add synthetic thought signature
+        const partWithSignature = {
+            ...part,
+            thoughtSignature: SYNTHETIC_THOUGHT_SIGNATURE,
+        };
+        parts[j] = partWithSignature;
+        return {
+            ...content,
+            parts,
+        };
+    }
+    return null; // No function call found
+}

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

@@ -6,7 +6,7 @@
  */
 import { FunctionCallingConfigMode } from '@google/genai';
 import { ClaudeMessageFormatter } from '../formatters/claude-formatter.js';
-import { GeminiMessageFormatter } from '../formatters/gemini-formatter.js';
+import { ensureActiveLoopHasThoughtSignatures, GeminiMessageFormatter } from '../formatters/gemini-formatter.js';
 import { ThinkingConfigManager } from '../thought-parser.js';
 import { ClaudeTokenizer } from '../tokenizers/claude-tokenizer.js';
 import { GeminiTokenizer } from '../tokenizers/gemini-tokenizer.js';
@@ -69,7 +69,11 @@ export class ByteRoverContentGenerator {
      */
     async generateContent(request) {
         // Format messages for provider
-        const formattedMessages = this.formatter.format(request.contents);
+        let formattedMessages = this.formatter.format(request.contents);
+        // For Gemini 3+ models, ensure function calls in the active loop have thought signatures
+        if (this.providerType === 'gemini') {
+            formattedMessages = ensureActiveLoopHasThoughtSignatures(formattedMessages, this.config.model);
+        }
         // Build generation config
         const genConfig = this.buildGenerationConfig(request.tools ?? {}, request.systemPrompt ?? '', formattedMessages);
         // Call gRPC service

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

@@ -272,7 +272,7 @@ export class ByteRoverLLMService {
             errorType: toolResult.errorType,
             metadata: toolResult.metadata,
             success: toolResult.success,
-        });
+        }, toolResult.processedOutput.attachments);
     }
     /**
      * Build generation request for the IContentGenerator.
@@ -624,7 +624,7 @@ export class ByteRoverLLMService {
                 taskId,
             });
             // Process output (truncation and file saving if needed)
-            const processedOutput = await this.outputProcessor.processOutput(toolName, result.content);
+            const processedOutput = await this.outputProcessor.processStructuredOutput(toolName, result.content);
             // Emit truncation event if output was truncated
             if (processedOutput.metadata?.truncated) {
                 this.sessionEventBus.emit('llmservice:outputTruncated', {

package/dist/infra/cipher/llm/thought-parser.d.ts

@@ -39,13 +39,34 @@ export interface ThinkingConfig {
 }
 /**
  * Thinking levels for Gemini 3.x models
+ * Matches @google/genai ThinkingLevel enum values
  */
 export declare enum ThinkingLevel {
+    DISABLED = "DISABLED",
     HIGH = "HIGH",
     LOW = "LOW",
     MEDIUM = "MEDIUM",
     UNSPECIFIED = "THINKING_LEVEL_UNSPECIFIED"
 }
+/**
+ * Check if model is a Gemini 2.x model
+ * @param model - Model identifier
+ * @returns True if model is Gemini 2.x
+ */
+export declare function isGemini2Model(model: string): boolean;
+/**
+ * Check if model is a Gemini 3.x model
+ * @param model - Model identifier
+ * @returns True if model is Gemini 3.x
+ */
+export declare function isGemini3Model(model: string): boolean;
+/**
+ * Check if model supports multimodal function responses
+ * This is supported in Gemini 3+ models
+ * @param model - Model identifier
+ * @returns True if model supports multimodal function responses
+ */
+export declare function supportsMultimodalFunctionResponse(model: string): boolean;
 /**
  * Default thinking mode token budget
  */

package/dist/infra/cipher/llm/thought-parser.js

@@ -6,14 +6,41 @@
  */
 /**
  * Thinking levels for Gemini 3.x models
+ * Matches @google/genai ThinkingLevel enum values
  */
 export var ThinkingLevel;
 (function (ThinkingLevel) {
+    ThinkingLevel["DISABLED"] = "DISABLED";
     ThinkingLevel["HIGH"] = "HIGH";
     ThinkingLevel["LOW"] = "LOW";
     ThinkingLevel["MEDIUM"] = "MEDIUM";
     ThinkingLevel["UNSPECIFIED"] = "THINKING_LEVEL_UNSPECIFIED";
 })(ThinkingLevel || (ThinkingLevel = {}));
+/**
+ * Check if model is a Gemini 2.x model
+ * @param model - Model identifier
+ * @returns True if model is Gemini 2.x
+ */
+export function isGemini2Model(model) {
+    return /^gemini-2(\.|$)/.test(model);
+}
+/**
+ * Check if model is a Gemini 3.x model
+ * @param model - Model identifier
+ * @returns True if model is Gemini 3.x
+ */
+export function isGemini3Model(model) {
+    return model.startsWith('gemini-3-');
+}
+/**
+ * Check if model supports multimodal function responses
+ * This is supported in Gemini 3+ models
+ * @param model - Model identifier
+ * @returns True if model supports multimodal function responses
+ */
+export function supportsMultimodalFunctionResponse(model) {
+    return model.startsWith('gemini-3-');
+}
 /**
  * Default thinking mode token budget
  */

package/dist/infra/cipher/llm/tool-output-processor.d.ts

@@ -126,6 +126,16 @@ export declare class ToolOutputProcessor {
      * Extract text content from structured output.
      */
     private extractTextContent;
+    /**
+     * Fallback stringify for when JSON.stringify fails.
+     * Creates a meaningful string representation of objects/arrays.
+     *
+     * @param value - Value to stringify
+     * @param seen - Set to track circular references
+     * @param depth - Current depth for limiting recursion
+     * @returns String representation
+     */
+    private fallbackStringify;
     /**
      * Check if output is an MCP-style content array.
      */

package/dist/infra/cipher/llm/tool-output-processor.js

@@ -185,6 +185,64 @@ export class ToolOutputProcessor {
         }
         return '';
     }
+    /**
+     * Fallback stringify for when JSON.stringify fails.
+     * Creates a meaningful string representation of objects/arrays.
+     *
+     * @param value - Value to stringify
+     * @param seen - Set to track circular references
+     * @param depth - Current depth for limiting recursion
+     * @returns String representation
+     */
+    fallbackStringify(value, seen = new WeakSet(), depth = 0) {
+        const MAX_DEPTH = 10;
+        // Handle primitives
+        if (value === null)
+            return 'null';
+        if (value === undefined)
+            return 'undefined';
+        if (typeof value === 'string')
+            return `"${value}"`;
+        if (typeof value === 'number' || typeof value === 'boolean')
+            return String(value);
+        if (typeof value === 'bigint')
+            return `${value}n`;
+        if (typeof value === 'symbol')
+            return value.toString();
+        if (typeof value === 'function')
+            return `[Function: ${value.name || 'anonymous'}]`;
+        // Handle objects and arrays
+        if (typeof value === 'object') {
+            // Check for circular reference
+            if (seen.has(value)) {
+                return '[Circular]';
+            }
+            seen.add(value);
+            // Depth limit
+            if (depth > MAX_DEPTH) {
+                return Array.isArray(value) ? '[Array]' : '[Object]';
+            }
+            // Handle arrays
+            if (Array.isArray(value)) {
+                const items = value.map((item) => this.fallbackStringify(item, seen, depth + 1));
+                return `[${items.join(', ')}]`;
+            }
+            // Handle Date
+            if (value instanceof Date) {
+                return value.toISOString();
+            }
+            // Handle Error
+            if (value instanceof Error) {
+                return `[Error: ${value.message}]`;
+            }
+            // Handle plain objects
+            const entries = Object.entries(value)
+                .map(([key, val]) => `"${key}": ${this.fallbackStringify(val, seen, depth + 1)}`);
+            return `{${entries.join(', ')}}`;
+        }
+        // Unknown type
+        return '[Unknown]';
+    }
     /**
      * Check if output is an MCP-style content array.
      */
@@ -246,18 +304,33 @@ export class ToolOutputProcessor {
             return String(value);
         }
         try {
-            // Try JSON.stringify with circular reference handling
+            // Try JSON.stringify with proper handling for special types
             return JSON.stringify(value, (_, val) => {
-                // Handle circular references by converting to string
-                if (typeof val === 'object' && val !== null) {
-                    return val;
+                // Convert BigInt to string
+                if (typeof val === 'bigint') {
+                    return val.toString();
+                }
+                // Convert functions to their string representation
+                if (typeof val === 'function') {
+                    return `[Function: ${val.name || 'anonymous'}]`;
+                }
+                // Convert Symbols to string
+                if (typeof val === 'symbol') {
+                    return val.toString();
                 }
                 return val;
             }, 2);
         }
-        catch {
-            // Fallback to String() if JSON.stringify fails
-            return String(value);
+        catch (error) {
+            // Fallback: Try to create a meaningful string representation
+            // instead of [object Object]
+            try {
+                return this.fallbackStringify(value);
+            }
+            catch {
+                // Last resort: Return error description
+                return `[Serialization failed: ${error instanceof Error ? error.message : 'Unknown error'}]`;
+            }
         }
     }
     /**

package/dist/infra/cipher/process/process-service.js

@@ -20,6 +20,11 @@ const DEFAULT_MAX_CONCURRENT_PROCESSES = 5;
  * Default maximum output buffer size (bytes).
  */
 const DEFAULT_MAX_OUTPUT_BUFFER = 1024 * 1024; // 1MB
+/**
+ * Default grace period for SIGTERM before SIGKILL (milliseconds).
+ * 5 seconds gives processes ample time to clean up gracefully.
+ */
+const DEFAULT_KILL_GRACE_PERIOD = 5000;
 /**
  * Process service implementation.
  *
@@ -47,6 +52,7 @@ export class ProcessService {
             allowedCommands: config.allowedCommands || [],
             blockedCommands: config.blockedCommands || [],
             environment: config.environment || {},
+            killGracePeriod: config.killGracePeriod ?? DEFAULT_KILL_GRACE_PERIOD,
             maxConcurrentProcesses: config.maxConcurrentProcesses || DEFAULT_MAX_CONCURRENT_PROCESSES,
             maxOutputBuffer: config.maxOutputBuffer || DEFAULT_MAX_OUTPUT_BUFFER,
             maxTimeout: config.maxTimeout || DEFAULT_MAX_TIMEOUT,
@@ -303,7 +309,7 @@ export class ProcessService {
      */
     async executeInBackground(command, options) {
         // Check concurrent process limit
-        const runningCount = [...this.backgroundProcesses.values()].filter(p => p.status === 'running').length;
+        const runningCount = [...this.backgroundProcesses.values()].filter((p) => p.status === 'running').length;
         if (runningCount >= this.config.maxConcurrentProcesses) {
             throw ProcessError.tooManyProcesses(runningCount, this.config.maxConcurrentProcesses);
         }
@@ -436,9 +442,11 @@ export class ProcessService {
             });
         }
         // Unix: kill process group using negative PID
+        // Grace period allows processes to clean up gracefully before SIGKILL
+        const gracePeriodMs = this.config.killGracePeriod;
         try {
             process.kill(-targetPid, 'SIGTERM');
-            await this.sleep(5000);
+            await this.sleep(gracePeriodMs);
             try {
                 process.kill(-targetPid, 'SIGKILL');
             }
@@ -450,7 +458,7 @@ export class ProcessService {
             // Fallback to direct kill if process group kill fails
             // (e.g., process wasn't started with detached: true)
             child.kill('SIGTERM');
-            await this.sleep(5000);
+            await this.sleep(gracePeriodMs);
             if (child.exitCode === null) {
                 child.kill('SIGKILL');
             }