byterover-cli 0.2.0 → 0.3.0

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

@@ -0,0 +1,254 @@
+/**
+ * OpenRouter Content Generator.
+ *
+ * Implements IContentGenerator using OpenRouter API (OpenAI-compatible).
+ * Supports various models available through OpenRouter.
+ */
+import { OpenAI } from 'openai';
+import { OpenRouterMessageFormatter } from '../formatters/openrouter-formatter.js';
+import { OpenRouterTokenizer } from '../tokenizers/openrouter-tokenizer.js';
+/**
+ * OpenRouter Content Generator.
+ *
+ * Wraps OpenAI client configured for OpenRouter and implements IContentGenerator.
+ * Provides:
+ * - Non-streaming content generation
+ * - Streaming content generation (true streaming via OpenAI SDK)
+ * - Token estimation
+ */
+export class OpenRouterContentGenerator {
+    client;
+    config;
+    formatter;
+    tokenizer;
+    /**
+     * Create a new OpenRouter Content Generator.
+     *
+     * @param config - Generator configuration
+     */
+    constructor(config) {
+        this.config = {
+            maxTokens: config.maxTokens ?? 8192,
+            model: config.model ?? 'anthropic/claude-haiku-4.5',
+            temperature: config.temperature ?? 0.7,
+        };
+        // Initialize OpenAI client with OpenRouter base URL
+        this.client = new OpenAI({
+            apiKey: config.apiKey,
+            baseURL: config.baseUrl ?? 'https://openrouter.ai/api/v1',
+            defaultHeaders: {
+                ...(config.httpReferer && { 'HTTP-Referer': config.httpReferer }),
+                ...(config.siteName && { 'X-Title': config.siteName }),
+            },
+            timeout: config.timeout,
+        });
+        // Initialize formatter and tokenizer
+        this.formatter = new OpenRouterMessageFormatter();
+        this.tokenizer = new OpenRouterTokenizer();
+    }
+    /**
+     * Estimate tokens synchronously using character-based approximation.
+     *
+     * @param content - Text to estimate tokens for
+     * @returns Estimated token count
+     */
+    estimateTokensSync(content) {
+        return this.tokenizer.countTokens(content);
+    }
+    /**
+     * Generate content (non-streaming).
+     *
+     * @param request - Generation request
+     * @returns Generated content response
+     */
+    async generateContent(request) {
+        // Format messages for OpenAI/OpenRouter
+        const formattedMessages = this.formatter.format(request.contents);
+        // Build tools array
+        const tools = this.buildTools(request.tools ?? {});
+        // Build messages with system prompt
+        const messages = request.systemPrompt
+            ? [{ content: request.systemPrompt, role: 'system' }, ...formattedMessages]
+            : formattedMessages;
+        // Call OpenRouter API
+        const rawResponse = await this.client.chat.completions.create({
+            // eslint-disable-next-line camelcase
+            max_tokens: request.config.maxTokens ?? this.config.maxTokens,
+            messages,
+            model: request.model ?? this.config.model,
+            temperature: request.config.temperature ?? this.config.temperature,
+            ...(tools.length > 0 && { tools: tools }),
+        });
+        // Parse response to internal format
+        const parsedMessages = this.formatter.parseResponse(rawResponse);
+        const lastMessage = parsedMessages.at(-1);
+        if (!lastMessage) {
+            return {
+                content: '',
+                finishReason: 'error',
+                rawResponse,
+                toolCalls: [],
+            };
+        }
+        // Extract content and tool calls
+        const content = this.extractTextContent(lastMessage);
+        const toolCalls = lastMessage.toolCalls ?? [];
+        // Determine finish reason
+        let finishReason = 'stop';
+        if (toolCalls.length > 0) {
+            finishReason = 'tool_calls';
+        }
+        else if (rawResponse.choices[0]?.finish_reason === 'length') {
+            finishReason = 'max_tokens';
+        }
+        // Extract usage if available
+        const usage = rawResponse.usage
+            ? {
+                completionTokens: rawResponse.usage.completion_tokens,
+                promptTokens: rawResponse.usage.prompt_tokens,
+                totalTokens: rawResponse.usage.total_tokens,
+            }
+            : undefined;
+        return {
+            content,
+            finishReason,
+            rawResponse,
+            toolCalls,
+            usage,
+        };
+    }
+    /**
+     * Generate content with streaming.
+     *
+     * Uses OpenAI SDK's native streaming support for real-time content generation.
+     *
+     * @param request - Generation request
+     * @yields Content chunks as they are generated
+     * @returns Async generator yielding content chunks
+     */
+    async *generateContentStream(request) {
+        // Format messages for OpenAI/OpenRouter
+        const formattedMessages = this.formatter.format(request.contents);
+        // Build tools array
+        const tools = this.buildTools(request.tools ?? {});
+        // Build messages with system prompt
+        const messages = request.systemPrompt
+            ? [{ content: request.systemPrompt, role: 'system' }, ...formattedMessages]
+            : formattedMessages;
+        // Call OpenRouter API with streaming
+        const stream = await this.client.chat.completions.create({
+            // eslint-disable-next-line camelcase
+            max_tokens: request.config.maxTokens ?? this.config.maxTokens,
+            messages,
+            model: request.model ?? this.config.model,
+            stream: true,
+            temperature: request.config.temperature ?? this.config.temperature,
+            ...(tools.length > 0 && { tools: tools }),
+        });
+        // Accumulate tool calls across chunks
+        const accumulatedToolCalls = new Map();
+        // Stream chunks
+        for await (const chunk of stream) {
+            const choice = chunk.choices[0];
+            if (!choice)
+                continue;
+            const { delta } = choice;
+            // Handle tool call deltas
+            if (delta.tool_calls) {
+                this.processToolCallDeltas(delta.tool_calls, accumulatedToolCalls);
+            }
+            // Yield content chunk
+            const isComplete = choice.finish_reason !== null;
+            const finishReason = this.determineFinishReason(choice.finish_reason, isComplete);
+            const toolCalls = this.buildToolCallsArray(accumulatedToolCalls, isComplete);
+            yield {
+                content: delta.content ?? undefined,
+                finishReason,
+                isComplete,
+                toolCalls,
+            };
+        }
+    }
+    /**
+     * Build tool calls array from accumulated tool calls.
+     */
+    buildToolCallsArray(accumulatedToolCalls, isComplete) {
+        if (!isComplete || accumulatedToolCalls.size === 0) {
+            return undefined;
+        }
+        return [...accumulatedToolCalls.values()].map((tc) => ({
+            function: {
+                arguments: tc.arguments,
+                name: tc.name,
+            },
+            id: tc.id,
+            type: 'function',
+        }));
+    }
+    /**
+     * Build tools array from ToolSet.
+     */
+    buildTools(tools) {
+        return Object.entries(tools).map(([name, schema]) => ({
+            function: {
+                description: schema.description ?? '',
+                name,
+                parameters: schema.parameters,
+            },
+            type: 'function',
+        }));
+    }
+    /**
+     * Determine finish reason from OpenAI finish reason.
+     */
+    determineFinishReason(finishReason, isComplete) {
+        if (!isComplete) {
+            return undefined;
+        }
+        if (finishReason === 'tool_calls') {
+            return 'tool_calls';
+        }
+        if (finishReason === 'length') {
+            return 'max_tokens';
+        }
+        return 'stop';
+    }
+    /**
+     * Extract text content from an internal message.
+     */
+    extractTextContent(message) {
+        if (typeof message.content === 'string') {
+            return message.content;
+        }
+        if (Array.isArray(message.content)) {
+            return message.content
+                .filter((part) => part.type === 'text')
+                .map((part) => (part.type === 'text' ? part.text : ''))
+                .join('');
+        }
+        return '';
+    }
+    /**
+     * Process tool call deltas and accumulate them.
+     */
+    processToolCallDeltas(toolCallDeltas, accumulatedToolCalls) {
+        for (const toolCallDelta of toolCallDeltas) {
+            const { function: func, id, index } = toolCallDelta;
+            const existing = accumulatedToolCalls.get(index);
+            if (existing) {
+                // Append to existing tool call
+                if (func?.arguments) {
+                    existing.arguments += func.arguments;
+                }
+            }
+            else {
+                // Start new tool call
+                accumulatedToolCalls.set(index, {
+                    arguments: func?.arguments ?? '',
+                    id: id ?? `tool_${index}`,
+                    name: func?.name ?? '',
+                });
+            }
+        }
+    }
+}

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

@@ -0,0 +1,90 @@
+/**
+ * Retryable Content Generator Decorator.
+ *
+ * Wraps any IContentGenerator to add retry capabilities with exponential backoff.
+ * Handles transient errors like rate limits, timeouts, and server errors.
+ */
+import type { GenerateContentChunk, GenerateContentRequest, GenerateContentResponse, IContentGenerator } from '../../../../core/interfaces/cipher/i-content-generator.js';
+import type { SessionEventBus } from '../../events/event-emitter.js';
+import { type RetryPolicy } from '../retry/retry-policy.js';
+/**
+ * Options for the RetryableContentGenerator.
+ */
+export interface RetryableOptions {
+    /** Event bus for emitting retry events */
+    eventBus?: SessionEventBus;
+    /** Retry policy configuration */
+    policy?: RetryPolicy;
+}
+/**
+ * Retryable Content Generator.
+ *
+ * Decorator that wraps any IContentGenerator to add retry capabilities.
+ * Uses exponential backoff with jitter to handle transient failures gracefully.
+ *
+ * Features:
+ * - Configurable retry policy
+ * - Exponential backoff with jitter
+ * - Retries on rate limits, timeouts, and server errors
+ * - Event emission for retry attempts
+ * - Streaming support with full request retry
+ */
+export declare class RetryableContentGenerator implements IContentGenerator {
+    private readonly eventBus?;
+    private readonly inner;
+    private readonly policy;
+    /**
+     * Create a new Retryable Content Generator.
+     *
+     * @param inner - The wrapped content generator
+     * @param options - Retry options
+     */
+    constructor(inner: IContentGenerator, options?: RetryableOptions);
+    /**
+     * Estimate tokens (delegates to inner generator).
+     *
+     * @param content - Text to estimate tokens for
+     * @returns Estimated token count
+     */
+    estimateTokensSync(content: string): number;
+    /**
+     * Generate content with retry.
+     *
+     * @param request - Generation request
+     * @returns Generated content response
+     */
+    generateContent(request: GenerateContentRequest): Promise<GenerateContentResponse>;
+    /**
+     * Generate content with streaming and retry.
+     *
+     * Note: For streaming, we retry the entire request if an error occurs.
+     * This is because partial streams cannot be resumed mid-way.
+     *
+     * @param request - Generation request
+     * @yields Content chunks as they are generated
+     * @returns Async generator yielding content chunks
+     */
+    generateContentStream(request: GenerateContentRequest): AsyncGenerator<GenerateContentChunk>;
+    /**
+     * Attempt to generate content with retry logic.
+     */
+    private attemptGenerateContent;
+    /**
+     * Attempt to generate content stream with retry logic.
+     *
+     * @yields Content chunks as they are generated
+     */
+    private attemptGenerateContentStream;
+    /**
+     * Emit an exhausted event when all retries are used.
+     */
+    private emitExhausted;
+    /**
+     * Emit a retry event via warning.
+     */
+    private emitRetry;
+    /**
+     * Sleep for a specified duration.
+     */
+    private sleep;
+}

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

@@ -0,0 +1,157 @@
+/**
+ * Retryable Content Generator Decorator.
+ *
+ * Wraps any IContentGenerator to add retry capabilities with exponential backoff.
+ * Handles transient errors like rate limits, timeouts, and server errors.
+ */
+import { calculateRetryDelay, DEFAULT_RETRY_POLICY, isRetryableError, } from '../retry/retry-policy.js';
+/**
+ * Retryable Content Generator.
+ *
+ * Decorator that wraps any IContentGenerator to add retry capabilities.
+ * Uses exponential backoff with jitter to handle transient failures gracefully.
+ *
+ * Features:
+ * - Configurable retry policy
+ * - Exponential backoff with jitter
+ * - Retries on rate limits, timeouts, and server errors
+ * - Event emission for retry attempts
+ * - Streaming support with full request retry
+ */
+export class RetryableContentGenerator {
+    eventBus;
+    inner;
+    policy;
+    /**
+     * Create a new Retryable Content Generator.
+     *
+     * @param inner - The wrapped content generator
+     * @param options - Retry options
+     */
+    constructor(inner, options = {}) {
+        this.inner = inner;
+        this.policy = options.policy ?? DEFAULT_RETRY_POLICY;
+        this.eventBus = options.eventBus;
+    }
+    /**
+     * Estimate tokens (delegates to inner generator).
+     *
+     * @param content - Text to estimate tokens for
+     * @returns Estimated token count
+     */
+    estimateTokensSync(content) {
+        return this.inner.estimateTokensSync(content);
+    }
+    /**
+     * Generate content with retry.
+     *
+     * @param request - Generation request
+     * @returns Generated content response
+     */
+    async generateContent(request) {
+        const maxAttempts = this.policy.maxRetries + 1;
+        return this.attemptGenerateContent(request, 1, maxAttempts);
+    }
+    /**
+     * Generate content with streaming and retry.
+     *
+     * Note: For streaming, we retry the entire request if an error occurs.
+     * This is because partial streams cannot be resumed mid-way.
+     *
+     * @param request - Generation request
+     * @yields Content chunks as they are generated
+     * @returns Async generator yielding content chunks
+     */
+    async *generateContentStream(request) {
+        const maxAttempts = this.policy.maxRetries + 1;
+        yield* this.attemptGenerateContentStream(request, 1, maxAttempts);
+    }
+    /**
+     * Attempt to generate content with retry logic.
+     */
+    async attemptGenerateContent(request, attempt, maxAttempts) {
+        try {
+            return await this.inner.generateContent(request);
+        }
+        catch (error) {
+            // Check if this is the last attempt
+            if (attempt >= maxAttempts) {
+                this.emitExhausted(attempt, error);
+                throw error;
+            }
+            // Check if error is retryable
+            if (!isRetryableError(error, this.policy)) {
+                throw error;
+            }
+            // Calculate delay and emit retry event
+            const delayMs = calculateRetryDelay(attempt, this.policy);
+            this.emitRetry(attempt, maxAttempts, error, delayMs);
+            // Wait before retrying
+            await this.sleep(delayMs);
+            // Recursively attempt again
+            return this.attemptGenerateContent(request, attempt + 1, maxAttempts);
+        }
+    }
+    /**
+     * Attempt to generate content stream with retry logic.
+     *
+     * @yields Content chunks as they are generated
+     */
+    async *attemptGenerateContentStream(request, attempt, maxAttempts) {
+        try {
+            // Yield all chunks from the inner generator
+            for await (const chunk of this.inner.generateContentStream(request)) {
+                yield chunk;
+            }
+        }
+        catch (error) {
+            // Check if this is the last attempt
+            if (attempt >= maxAttempts) {
+                this.emitExhausted(attempt, error);
+                throw error;
+            }
+            // Check if error is retryable
+            if (!isRetryableError(error, this.policy)) {
+                throw error;
+            }
+            // Calculate delay and emit retry event
+            const delayMs = calculateRetryDelay(attempt, this.policy);
+            this.emitRetry(attempt, maxAttempts, error, delayMs);
+            // Wait before retrying
+            await this.sleep(delayMs);
+            // Recursively attempt again
+            yield* this.attemptGenerateContentStream(request, attempt + 1, maxAttempts);
+        }
+    }
+    /**
+     * Emit an exhausted event when all retries are used.
+     */
+    emitExhausted(attempts, error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`[Retry] All ${attempts} attempts exhausted. Final error: ${errorMessage}`);
+        this.eventBus?.emit('llmservice:error', {
+            error: `All ${attempts} retry attempts exhausted: ${errorMessage}`,
+        });
+    }
+    /**
+     * Emit a retry event via warning.
+     */
+    emitRetry(attempt, maxAttempts, error, delayMs) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.warn(`[Retry] Attempt ${attempt}/${maxAttempts} failed: ${errorMessage}. ` +
+            `Retrying in ${delayMs}ms...`);
+        this.eventBus?.emit('llmservice:warning', {
+            message: `Retry attempt ${attempt}/${maxAttempts} after ${delayMs}ms: ${errorMessage}`,
+        });
+    }
+    /**
+     * Sleep for a specified duration.
+     */
+    sleep(ms) {
+        return new Promise((resolve) => {
+            setTimeout(() => {
+                resolve();
+            }, ms);
+        });
+    }
+}

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

@@ -0,0 +1,9 @@
+export { LlmError, LlmGenerationError, LlmMaxIterationsError, LlmMissingToolExecutorError, LlmResponseParsingError, } from '../../../core/domain/cipher/errors/llm-error.js';
+export type { ILLMService } from '../../../core/interfaces/cipher/i-llm-service.js';
+export { ContextManager, type FileData, type ImageData } from './context/context-manager.js';
+export { GeminiMessageFormatter } from './formatters/gemini-formatter.js';
+export { OpenRouterMessageFormatter } from './formatters/openrouter-formatter.js';
+export { ByteRoverLLMService, type ByteRoverLLMServiceConfig, type LLMServiceConfig } from './internal-llm-service.js';
+export { OpenRouterLLMService, type OpenRouterServiceConfig } from './openrouter-llm-service.js';
+export { GeminiTokenizer } from './tokenizers/gemini-tokenizer.js';
+export { OpenRouterTokenizer } from './tokenizers/openrouter-tokenizer.js';

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

@@ -0,0 +1,13 @@
+// LLM errors
+export { LlmError, LlmGenerationError, LlmMaxIterationsError, LlmMissingToolExecutorError, LlmResponseParsingError, } from '../../../core/domain/cipher/errors/llm-error.js';
+// Context manager
+export { ContextManager } from './context/context-manager.js';
+// Message formatters
+export { GeminiMessageFormatter } from './formatters/gemini-formatter.js';
+export { OpenRouterMessageFormatter } from './formatters/openrouter-formatter.js';
+// LLM services
+export { ByteRoverLLMService } from './internal-llm-service.js';
+export { OpenRouterLLMService } from './openrouter-llm-service.js';
+// Tokenizers
+export { GeminiTokenizer } from './tokenizers/gemini-tokenizer.js';
+export { OpenRouterTokenizer } from './tokenizers/openrouter-tokenizer.js';