byterover-cli 0.2.1 → 0.3.0

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

@@ -0,0 +1,253 @@
+/**
+ * Message formatter for Google Gemini API.
+ *
+ * Converts the internal message format to Gemini's specific structure:
+ * - Maps 'assistant' role to 'model' (Gemini's terminology)
+ * - System prompts are injected as user messages (Gemini doesn't have system role)
+ * - Tool calls use functionCall parts
+ * - Tool results use functionResponse parts in user messages
+ */
+export class GeminiMessageFormatter {
+    /**
+     * Formats internal messages into Gemini's API format.
+     *
+     * @param history Array of internal messages to format
+     * @param systemPrompt Optional system prompt to include at the beginning
+     * @returns Array of Content objects formatted for Gemini's API
+     */
+    format(history, systemPrompt) {
+        const contents = [];
+        // Add system prompt as a user message if provided
+        // Gemini doesn't have a separate system role
+        if (systemPrompt) {
+            contents.push({
+                parts: [{ text: `System: ${systemPrompt}` }],
+                role: 'user',
+            });
+        }
+        // Accumulator for consecutive tool results
+        let toolGroup = [];
+        for (const msg of history) {
+            if (msg.role === 'tool') {
+                // Accumulate tool results
+                toolGroup.push(msg);
+            }
+            else {
+                // Flush accumulated tool results before processing non-tool message
+                if (toolGroup.length > 0) {
+                    contents.push(this.combineToolResults(toolGroup));
+                    toolGroup = [];
+                }
+                // Format non-tool message
+                contents.push(this.formatNonToolMessage(msg));
+            }
+        }
+        // Flush any remaining tool results
+        if (toolGroup.length > 0) {
+            contents.push(this.combineToolResults(toolGroup));
+        }
+        return contents;
+    }
+    /**
+     * Parses Gemini API response into internal message objects.
+     *
+     * @param response The raw response from Gemini API
+     * @returns Array of internal messages (typically one assistant message)
+     */
+    parseResponse(response) {
+        const typedResponse = response;
+        if (!typedResponse.candidates || typedResponse.candidates.length === 0) {
+            return [];
+        }
+        const candidate = typedResponse.candidates[0];
+        if (!candidate?.content?.parts) {
+            return [];
+        }
+        const textParts = [];
+        const functionCalls = [];
+        // 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);
+            }
+        }
+        // Convert to internal message format
+        const toolCalls = functionCalls.length > 0
+            ? functionCalls.map((fc) => ({
+                function: {
+                    arguments: JSON.stringify(fc.args ?? {}),
+                    name: fc.name ?? '',
+                },
+                id: this.generateToolCallId(fc.name ?? ''),
+                type: 'function',
+            }))
+            : undefined;
+        return [
+            {
+                content: textParts.join('') || null,
+                role: 'assistant',
+                toolCalls,
+            },
+        ];
+    }
+    /**
+     * Combines multiple tool results into a single Gemini user message.
+     * Required by Gemini API when assistant made multiple tool calls.
+     */
+    combineToolResults(toolMessages) {
+        return {
+            parts: toolMessages.map((msg) => this.formatToolResultPart(msg)),
+            role: 'user',
+        };
+    }
+    /**
+     * Formats assistant message to Gemini's Content format.
+     * Maps 'assistant' role to 'model' and includes both text and tool calls.
+     */
+    formatAssistantMessage(msg) {
+        const parts = [];
+        // Add text content if present
+        if (msg.content) {
+            parts.push({ text: String(msg.content) });
+        }
+        // Add tool calls if present
+        if (msg.toolCalls) {
+            for (const tc of msg.toolCalls) {
+                parts.push({
+                    functionCall: {
+                        args: JSON.parse(tc.function.arguments),
+                        name: tc.function.name,
+                    },
+                });
+            }
+        }
+        return {
+            parts,
+            role: 'model', // Gemini uses 'model' instead of 'assistant'
+        };
+    }
+    /**
+     * Formats a single non-tool message to Gemini Content.
+     */
+    formatNonToolMessage(msg) {
+        switch (msg.role) {
+            case 'assistant': {
+                return this.formatAssistantMessage(msg);
+            }
+            case 'system': {
+                return {
+                    parts: [{ text: `System: ${String(msg.content || '')}` }],
+                    role: 'user',
+                };
+            }
+            case 'user': {
+                return this.formatUserMessage(msg);
+            }
+            default: {
+                return {
+                    parts: [{ text: String(msg.content || '') }],
+                    role: 'user',
+                };
+            }
+        }
+    }
+    /**
+     * Formats a single tool result message to a Gemini functionResponse Part.
+     * Multiple tool results are combined into a single user message by format().
+     *
+     * Note: msg.content is a JSON string from ToolOutputProcessor.
+     * We need to parse it back to an object for Gemini's API.
+     */
+    formatToolResultPart(msg) {
+        // msg.content is a JSON string from ToolOutputProcessor
+        // Parse it back to object for Gemini's API
+        let responseObject;
+        try {
+            // Try to parse as JSON
+            if (typeof msg.content === 'string') {
+                responseObject = JSON.parse(msg.content);
+            }
+            else if (msg.content === null) {
+                responseObject = { result: null };
+            }
+            else if (Array.isArray(msg.content)) {
+                // Array content (e.g., MessagePart[]) - wrap in result
+                responseObject = { result: msg.content };
+            }
+            else if (typeof msg.content === 'object') {
+                // Already an object (shouldn't happen with current implementation, but handle it)
+                responseObject = msg.content;
+            }
+            else {
+                // Primitive types - wrap them
+                responseObject = { result: msg.content };
+            }
+        }
+        catch {
+            // If parsing fails, wrap the string as-is
+            responseObject = { result: msg.content };
+        }
+        return {
+            functionResponse: {
+                name: msg.name ?? '',
+                response: responseObject,
+            },
+        };
+    }
+    /**
+     * Formats a single user content part.
+     * Currently supports text parts, with placeholders for image/file support.
+     */
+    formatUserContentPart(part) {
+        if (part.type === 'text') {
+            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]' };
+        }
+        if (part.type === 'file') {
+            // File support not yet implemented for Gemini
+            return { text: '[File not yet supported]' };
+        }
+        return { text: '[Unknown content type]' };
+    }
+    /**
+     * Formats user message to Gemini's Content format.
+     * Handles both simple string content and multimodal content parts.
+     */
+    formatUserMessage(msg) {
+        const parts = [];
+        if (typeof msg.content === 'string') {
+            // Simple text message
+            parts.push({ text: msg.content });
+        }
+        else if (Array.isArray(msg.content)) {
+            // Multimodal content (text, images, files)
+            for (const part of msg.content) {
+                parts.push(this.formatUserContentPart(part));
+            }
+        }
+        return {
+            parts,
+            role: 'user',
+        };
+    }
+    /**
+     * Generates a unique tool call ID.
+     * Gemini doesn't provide tool call IDs, so we generate them.
+     *
+     * @param toolName The name of the tool being called
+     * @returns A unique identifier for the tool call
+     */
+    generateToolCallId(toolName) {
+        // Simple ID generation: timestamp + random + tool name
+        const timestamp = Date.now();
+        const random = Math.random().toString(36).slice(2, 9);
+        return `call_${timestamp}_${random}_${toolName}`;
+    }
+}

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

@@ -0,0 +1,47 @@
+import type { ChatCompletionMessageParam } from 'openai/resources';
+import type { IMessageFormatter } from '../../../../core/interfaces/cipher/i-message-formatter.js';
+import type { InternalMessage } from '../../../../core/interfaces/cipher/message-types.js';
+/**
+ * Message formatter for OpenRouter API.
+ *
+ * OpenRouter uses OpenAI-compatible API format:
+ * - System prompts are included in the messages array
+ * - Tool calls use the tool_calls property
+ * - Tool results use the 'tool' role with tool_call_id
+ * - Supports multimodal content (text, images, files)
+ */
+export declare class OpenRouterMessageFormatter implements IMessageFormatter<ChatCompletionMessageParam> {
+    /**
+     * Formats internal messages into OpenRouter's API format (OpenAI-compatible).
+     *
+     * @param history Array of internal messages to format
+     * @param systemPrompt Optional system prompt to include at the beginning
+     * @returns Array of messages formatted for OpenRouter's API
+     */
+    format(history: Readonly<InternalMessage[]>, systemPrompt?: null | string): ChatCompletionMessageParam[];
+    /**
+     * Parses OpenRouter API response into internal message objects.
+     *
+     * @param response The raw response from OpenRouter API
+     * @returns Array of internal messages (typically one assistant message)
+     */
+    parseResponse(response: unknown): InternalMessage[];
+    /**
+     * Formats tool result content to text string.
+     * OpenRouter only supports text content for tool messages.
+     */
+    private formatToolContent;
+    /**
+     * Formats user message content into OpenRouter's format.
+     * Handles both simple string content and multimodal content parts (text, images, files).
+     */
+    private formatUserContent;
+    /**
+     * Formats a single user content part (text, image, or file).
+     */
+    private formatUserContentPart;
+    /**
+     * Extracts image data as base64 string or URL.
+     */
+    private getImageData;
+}

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

@@ -0,0 +1,238 @@
+/**
+ * Message formatter for OpenRouter API.
+ *
+ * OpenRouter uses OpenAI-compatible API format:
+ * - System prompts are included in the messages array
+ * - Tool calls use the tool_calls property
+ * - Tool results use the 'tool' role with tool_call_id
+ * - Supports multimodal content (text, images, files)
+ */
+export class OpenRouterMessageFormatter {
+    /**
+     * Formats internal messages into OpenRouter's API format (OpenAI-compatible).
+     *
+     * @param history Array of internal messages to format
+     * @param systemPrompt Optional system prompt to include at the beginning
+     * @returns Array of messages formatted for OpenRouter's API
+     */
+    format(history, systemPrompt) {
+        const formatted = [];
+        // Add system message if provided
+        if (systemPrompt) {
+            formatted.push({
+                content: systemPrompt,
+                role: 'system',
+            });
+        }
+        // Track pending tool calls to detect orphans (tool calls without results)
+        const pendingToolCallIds = new Set();
+        for (const msg of history) {
+            switch (msg.role) {
+                case 'assistant': {
+                    // Assistant messages may or may not have tool calls
+                    if (msg.toolCalls && msg.toolCalls.length > 0) {
+                        formatted.push({
+                            content: String(msg.content || ''),
+                            role: 'assistant',
+                            // eslint-disable-next-line camelcase
+                            tool_calls: msg.toolCalls,
+                        });
+                        // Track these tool call IDs as pending
+                        for (const toolCall of msg.toolCalls) {
+                            pendingToolCallIds.add(toolCall.id);
+                        }
+                    }
+                    else {
+                        formatted.push({
+                            content: String(msg.content || ''),
+                            role: 'assistant',
+                        });
+                    }
+                    break;
+                }
+                case 'system': {
+                    // Additional system messages in history
+                    formatted.push({
+                        content: String(msg.content || ''),
+                        role: 'system',
+                    });
+                    break;
+                }
+                case 'tool': {
+                    // Tool results for OpenRouter — only text field is supported.
+                    // Only add if we've seen the corresponding tool call
+                    if (msg.toolCallId && pendingToolCallIds.has(msg.toolCallId)) {
+                        formatted.push({
+                            content: this.formatToolContent(msg.content),
+                            role: 'tool',
+                            // eslint-disable-next-line camelcase
+                            tool_call_id: msg.toolCallId,
+                        });
+                        // Remove from pending since we found its result
+                        pendingToolCallIds.delete(msg.toolCallId);
+                    }
+                    else {
+                        // Orphaned tool result (result without matching call)
+                        // Skip it to prevent API errors
+                        console.warn(`Skipping orphaned tool result ${msg.toolCallId} (no matching tool call found)`);
+                    }
+                    break;
+                }
+                case 'user': {
+                    formatted.push({
+                        content: this.formatUserContent(msg.content),
+                        role: 'user',
+                    });
+                    break;
+                }
+            }
+        }
+        // Add synthetic error results for any orphaned tool calls
+        // This can happen when the agent crashes/interrupts before tool execution completes
+        if (pendingToolCallIds.size > 0) {
+            for (const toolCallId of pendingToolCallIds) {
+                formatted.push({
+                    content: 'Error: Tool execution was interrupted (session crashed or cancelled before completion)',
+                    role: 'tool',
+                    // eslint-disable-next-line camelcase
+                    tool_call_id: toolCallId,
+                });
+                console.warn(`Tool call ${toolCallId} had no matching tool result - added synthetic error result`);
+            }
+        }
+        return formatted;
+    }
+    /**
+     * Parses OpenRouter API response into internal message objects.
+     *
+     * @param response The raw response from OpenRouter API
+     * @returns Array of internal messages (typically one assistant message)
+     */
+    parseResponse(response) {
+        const internal = [];
+        const typedResponse = response;
+        if (!typedResponse.choices || !Array.isArray(typedResponse.choices)) {
+            return internal;
+        }
+        for (const choice of typedResponse.choices) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const msg = choice.message;
+            if (!msg || !msg.role)
+                continue;
+            const role = msg.role;
+            switch (role) {
+                case 'assistant': {
+                    const content = msg.content ?? null;
+                    // Handle tool calls if present
+                    if (msg.tool_calls && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0) {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        const calls = msg.tool_calls.map((call) => ({
+                            function: {
+                                arguments: call.function.arguments,
+                                name: call.function.name,
+                            },
+                            id: call.id,
+                            type: 'function',
+                        }));
+                        internal.push({ content, role: 'assistant', toolCalls: calls });
+                    }
+                    else {
+                        internal.push({ content, role: 'assistant' });
+                    }
+                    break;
+                }
+                case 'system':
+                case 'user': {
+                    if (msg.content) {
+                        internal.push({ content: msg.content, role });
+                    }
+                    break;
+                }
+                case 'tool': {
+                    internal.push({
+                        content: msg.content,
+                        name: msg.name,
+                        role: 'tool',
+                        toolCallId: msg.tool_call_id,
+                    });
+                    break;
+                }
+            }
+        }
+        return internal;
+    }
+    /**
+     * Formats tool result content to text string.
+     * OpenRouter only supports text content for tool messages.
+     */
+    formatToolContent(content) {
+        if (typeof content === 'string') {
+            return content;
+        }
+        if (Array.isArray(content)) {
+            // Extract text from multimodal content
+            return content
+                .filter((part) => part.type === 'text')
+                .map((part) => part.text)
+                .join('\n');
+        }
+        return String(content || '');
+    }
+    /**
+     * Formats user message content into OpenRouter's format.
+     * Handles both simple string content and multimodal content parts (text, images, files).
+     */
+    formatUserContent(content) {
+        if (!Array.isArray(content)) {
+            return String(content || '');
+        }
+        const parts = content
+            .map((part) => this.formatUserContentPart(part))
+            .filter((part) => part !== null);
+        return parts;
+    }
+    /**
+     * Formats a single user content part (text, image, or file).
+     */
+    formatUserContentPart(part) {
+        if (part.type === 'text') {
+            return { text: part.text, type: 'text' };
+        }
+        if (part.type === 'image') {
+            // Convert image to data URL or use existing URL
+            const imageData = this.getImageData(part.image);
+            const url = imageData.startsWith('http://') ||
+                imageData.startsWith('https://') ||
+                imageData.startsWith('data:')
+                ? imageData
+                : `data:${part.mimeType || 'application/octet-stream'};base64,${imageData}`;
+            // eslint-disable-next-line camelcase
+            return { image_url: { url }, type: 'image_url' };
+        }
+        if (part.type === 'file') {
+            // File support: convert to text representation
+            // OpenRouter may support files differently depending on the model
+            return { text: `[File: ${part.filename || 'unknown'}]`, type: 'text' };
+        }
+        return null;
+    }
+    /**
+     * Extracts image data as base64 string or URL.
+     */
+    getImageData(image) {
+        if (typeof image === 'string') {
+            return image;
+        }
+        if (image instanceof URL) {
+            return image.toString();
+        }
+        if (image instanceof Buffer) {
+            return image.toString('base64');
+        }
+        if (image instanceof Uint8Array || image instanceof ArrayBuffer) {
+            const buffer = image instanceof ArrayBuffer ? new Uint8Array(image) : image;
+            return Buffer.from(buffer).toString('base64');
+        }
+        return '';
+    }
+}

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

@@ -0,0 +1,92 @@
+/**
+ * ByteRover Content Generator.
+ *
+ * Implements IContentGenerator using ByteRover gRPC service.
+ * Supports both Claude and Gemini models through the unified gRPC 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 ThinkingConfig } from '../thought-parser.js';
+/**
+ * Configuration for ByteRover Content Generator.
+ */
+export interface ByteRoverContentGeneratorConfig {
+    /** Maximum tokens in the response */
+    maxTokens?: number;
+    /** Model identifier */
+    model: string;
+    /** Temperature for randomness */
+    temperature?: number;
+    /** Thinking configuration for Gemini models */
+    thinkingConfig?: ThinkingConfig;
+}
+/**
+ * ByteRover Content Generator.
+ *
+ * Wraps ByteRoverLlmGrpcService and implements IContentGenerator.
+ * Handles:
+ * - Provider detection (Claude vs Gemini)
+ * - Message formatting via provider-specific formatters
+ * - Token estimation via provider-specific tokenizers
+ * - Response parsing to unified format
+ */
+export declare class ByteRoverContentGenerator implements IContentGenerator {
+    private readonly config;
+    private readonly formatter;
+    private readonly grpcService;
+    private readonly providerType;
+    private readonly tokenizer;
+    /**
+     * Create a new ByteRover Content Generator.
+     *
+     * @param grpcService - Configured gRPC service for LLM API calls
+     * @param config - Generator configuration
+     */
+    constructor(grpcService: ByteRoverLlmGrpcService, config: ByteRoverContentGeneratorConfig);
+    /**
+     * Estimate tokens synchronously using character-based approximation.
+     *
+     * @param content - Text to estimate tokens for
+     * @returns Estimated token count
+     */
+    estimateTokensSync(content: string): number;
+    /**
+     * Generate content (non-streaming).
+     *
+     * @param request - Generation request
+     * @returns Generated content response
+     */
+    generateContent(request: GenerateContentRequest): Promise<GenerateContentResponse>;
+    /**
+     * Generate content with streaming.
+     *
+     * Note: The current gRPC service collects all chunks before returning.
+     * This implementation yields the complete response as a single chunk.
+     * True streaming can be implemented when the gRPC service exposes the stream.
+     *
+     * @param request - Generation request
+     * @yields Content chunks as they are generated
+     * @returns Async generator yielding content chunks
+     */
+    generateContentStream(request: GenerateContentRequest): AsyncGenerator<GenerateContentChunk>;
+    /**
+     * Build Claude-specific generation configuration.
+     */
+    private buildClaudeConfig;
+    /**
+     * Build Gemini-specific generation configuration.
+     */
+    private buildGeminiConfig;
+    /**
+     * Build generation config for the appropriate provider.
+     */
+    private buildGenerationConfig;
+    /**
+     * Detect provider type from model name.
+     */
+    private detectProviderType;
+    /**
+     * Extract text content from an internal message.
+     */
+    private extractTextContent;
+}