byterover-cli 1.5.0 → 1.7.0

package/dist/agent/infra/http/internal-llm-http-service.js

@@ -0,0 +1,265 @@
+import { AuthenticatedHttpClient } from '../../../server/infra/http/authenticated-http-client.js';
+import { StreamChunkType } from '../../core/interfaces/i-content-generator.js';
+import { ThoughtParser } from '../llm/thought-parser.js';
+/**
+ * ByteRover HTTP LLM API client.
+ *
+ * Simple wrapper around ByteRover REST LLM service.
+ * Delegates prompt building and formatting to service layer.
+ *
+ * Responsibilities:
+ * - Call the remote REST API
+ * - Handle HTTP responses
+ * - Convert to GenerateContentResponse format
+ *
+ * Does NOT:
+ * - Build prompts or format inputs
+ * - Parse or manipulate response content
+ * - Handle tool call parsing from text
+ */
+export class ByteRoverLlmHttpService {
+    config;
+    /**
+     * Initialize a new ByteRover HTTP LLM service client.
+     *
+     * Sets up configuration with sensible defaults:
+     * - projectId defaults to 'byterover'
+     * - region defaults to 'us-east1' (can be overridden per request)
+     * - timeout defaults to 60 seconds
+     *
+     * @param config - HTTP client configuration (accessToken, apiBaseUrl, sessionKey, optional: projectId, region, timeout)
+     */
+    constructor(config) {
+        this.config = {
+            apiBaseUrl: config.apiBaseUrl,
+            projectId: config.projectId ?? 'byterover',
+            region: config.region ?? 'us-east1',
+            sessionKey: config.sessionKey,
+            spaceId: config.spaceId,
+            teamId: config.teamId,
+            timeout: config.timeout ?? 60_000,
+        };
+    }
+    /**
+     * Call ByteRover REST LLM service to generate content.
+     *
+     * Simple forward to remote REST API - delegates all formatting to backend.
+     * Supports both Gemini and Claude formats - the correct format is determined
+     * automatically based on the model name.
+     *
+     * Parameter structure differs by provider:
+     * - Gemini: contents = Content[], config = GenerateContentConfig
+     * - Claude: contents = MessageCreateParamsNonStreaming (complete body), config = RequestOptions (HTTP options)
+     *
+     * @param contents - For Gemini: Content[]. For Claude: MessageCreateParamsNonStreaming (complete body)
+     * @param config - For Gemini: GenerateContentConfig. For Claude: RequestOptions (optional HTTP options)
+     * @param model - Model to use (detects provider from model name)
+     * @param executionMetadata - Optional execution metadata (mode, executionContext)
+     * @returns Response in GenerateContentResponse format
+     */
+    async generateContent(contents, config, model, executionMetadata) {
+        const request = {
+            executionMetadata: JSON.stringify(executionMetadata ?? {}),
+            params: {
+                config,
+                contents,
+                model,
+            },
+            project_id: this.config.projectId,
+            provider: this.detectProviderFromModel(model),
+            region: this.detectRegionFromModel(model),
+            spaceId: this.config.spaceId,
+            teamId: this.config.teamId,
+        };
+        return this.callHttpGenerate(request);
+    }
+    /**
+     * Call ByteRover REST LLM service to generate content with streaming.
+     *
+     * Currently falls back to non-streaming endpoint since /api/llm/generate/stream
+     * doesn't exist on the backend yet. Extracts thinking/reasoning from the complete
+     * response and yields them as separate chunks.
+     *
+     * When backend streaming is available, this will use SSE for true streaming.
+     *
+     * @param contents - For Gemini: Content[]. For Claude: MessageCreateParamsNonStreaming (complete body)
+     * @param config - For Gemini: GenerateContentConfig. For Claude: RequestOptions (optional HTTP options)
+     * @param model - Model to use (detects provider from model name)
+     * @param executionMetadata - Optional execution metadata (mode, executionContext)
+     * @yields GenerateContentChunk objects as they are generated
+     */
+    async *generateContentStream(contents, config, model, executionMetadata) {
+        // Fall back to non-streaming endpoint and simulate streaming
+        // by extracting thinking from the complete response
+        const response = await this.generateContent(contents, config, model, executionMetadata);
+        // Extract and yield thinking/reasoning chunks first
+        yield* this.extractThinkingFromResponse(response);
+        // Then yield the final content
+        yield* this.extractContentFromResponse(response);
+    }
+    /**
+     * Call the ByteRover REST Generate endpoint.
+     *
+     * Handles authentication headers and error handling.
+     *
+     * @param request - The REST generate request with model, provider, region, and params
+     * @returns Promise resolving to the complete LLM response
+     * @throws Error if the request fails
+     */
+    async callHttpGenerate(request) {
+        const url = `${this.config.apiBaseUrl}/api/llm/generate`;
+        const httpClient = new AuthenticatedHttpClient(this.config.sessionKey);
+        const httpResponse = await httpClient.post(url, request, {
+            timeout: this.config.timeout,
+        });
+        return httpResponse.data;
+    }
+    /**
+     * Detect LLM provider from model identifier.
+     *
+     * Determines which provider (Claude or Gemini) to use based on the model name.
+     * Defaults to Gemini if the model doesn't match Claude patterns.
+     *
+     * @param model - Model identifier (e.g., 'claude-3-5-sonnet', 'gemini-2.5-flash')
+     * @returns Provider name: 'claude' or 'gemini'
+     */
+    detectProviderFromModel(model) {
+        return model.toLowerCase().startsWith('claude') ? 'claude' : 'gemini';
+    }
+    /**
+     * Detect appropriate GCP region from model identifier.
+     *
+     * Routes Claude models to us-east5 and Gemini models to global.
+     * This ensures compatibility with the provider's available regions on Vertex AI.
+     *
+     * @param model - Model identifier (e.g., 'claude-3-5-sonnet', 'gemini-2.5-flash')
+     * @returns GCP region identifier ('us-east5' or 'global')
+     */
+    detectRegionFromModel(model) {
+        return model.toLowerCase().startsWith('claude') ? 'us-east5' : 'global';
+    }
+    /**
+     * Extract content chunks from a complete response.
+     *
+     * Looks for text parts (excluding thinking) and function calls,
+     * yields them as final chunks.
+     *
+     * @param response - Complete GenerateContentResponse
+     * @yields GenerateContentChunk for content and tool calls
+     */
+    *extractContentFromResponse(response) {
+        const { candidates } = response;
+        if (!candidates || candidates.length === 0) {
+            yield {
+                content: '',
+                finishReason: 'stop',
+                isComplete: true,
+            };
+            return;
+        }
+        const candidate = candidates[0];
+        const parts = candidate?.content?.parts;
+        const finishReason = this.mapFinishReason(candidate?.finishReason ?? 'STOP');
+        if (!parts || parts.length === 0) {
+            yield {
+                content: '',
+                finishReason,
+                isComplete: true,
+            };
+            return;
+        }
+        // Collect text content (excluding thinking parts)
+        const textParts = [];
+        const functionCalls = [];
+        for (const part of parts) {
+            const partRecord = part;
+            // Skip thinking parts
+            if (partRecord.thought === true)
+                continue;
+            // Collect text
+            if (partRecord.text && typeof partRecord.text === 'string') {
+                textParts.push(partRecord.text);
+            }
+            // Collect function calls
+            if (partRecord.functionCall) {
+                functionCalls.push(partRecord.functionCall);
+            }
+        }
+        // Yield final content chunk
+        yield {
+            content: textParts.join('').trimEnd(),
+            finishReason,
+            isComplete: true,
+            toolCalls: functionCalls.length > 0
+                ? functionCalls.map((fc, index) => ({
+                    function: {
+                        arguments: JSON.stringify(fc.args ?? {}),
+                        name: fc.name ?? '',
+                    },
+                    id: `call_${Date.now()}_${index}`,
+                    type: 'function',
+                }))
+                : undefined,
+        };
+    }
+    /**
+     * Extract thinking/reasoning chunks from a complete response.
+     *
+     * Looks for parts with `thought: true` and yields them as THINKING chunks.
+     *
+     * @param response - Complete GenerateContentResponse
+     * @yields GenerateContentChunk for each thinking part
+     */
+    *extractThinkingFromResponse(response) {
+        const { candidates } = response;
+        if (!candidates || candidates.length === 0)
+            return;
+        const parts = candidates[0]?.content?.parts;
+        if (!parts)
+            return;
+        let thinkingSubject;
+        for (const part of parts) {
+            const partRecord = part;
+            // Check for thinking part (thought: true)
+            if (partRecord.thought === true && partRecord.text && typeof partRecord.text === 'string') {
+                const delta = partRecord.text;
+                // Extract subject from **Subject** markdown if not already found
+                if (!thinkingSubject && delta) {
+                    const parsed = ThoughtParser.parse(delta);
+                    if (parsed.subject) {
+                        thinkingSubject = parsed.subject;
+                    }
+                }
+                yield {
+                    isComplete: false,
+                    providerMetadata: {
+                        subject: thinkingSubject,
+                    },
+                    reasoning: delta.trimEnd(),
+                    type: StreamChunkType.THINKING,
+                };
+            }
+        }
+    }
+    /**
+     * Map provider finish reason to standard format.
+     */
+    mapFinishReason(reason) {
+        switch (reason.toUpperCase()) {
+            case 'FUNCTION_CALL':
+            case 'TOOL_CALLS': {
+                return 'tool_calls';
+            }
+            case 'LENGTH':
+            case 'MAX_TOKENS': {
+                return 'max_tokens';
+            }
+            case 'STOP': {
+                return 'stop';
+            }
+            default: {
+                return 'stop';
+            }
+        }
+    }
+}

package/dist/agent/infra/llm/capability-cache.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Model Capability Cache
+ *
+ * Caches model capability lookups for performance.
+ * Avoids repeated registry lookups for the same model.
+ */
+import { type LLMProvider, type ModelCapabilities } from '../../core/domain/llm/index.js';
+/**
+ * Cache for model capability lookups.
+ *
+ * This cache stores model information to avoid repeated registry lookups.
+ * The cache is keyed by "provider:model" for quick access.
+ */
+export declare class ModelCapabilityCache {
+    private readonly cache;
+    /**
+     * Get cache size (number of cached models).
+     */
+    get size(): number;
+    /**
+     * Clear the cache.
+     */
+    clear(): void;
+    /**
+     * Get model capabilities.
+     * @param provider - LLM provider
+     * @param model - Model name
+     * @returns ModelCapabilities object
+     */
+    getCapabilities(provider: LLMProvider, model: string): ModelCapabilities;
+    /**
+     * Get characters per token ratio for model.
+     */
+    getCharsPerToken(provider: LLMProvider, model: string): number;
+    /**
+     * Get max input tokens for model.
+     */
+    getMaxInputTokens(provider: LLMProvider, model: string): number;
+    /**
+     * Check if a model is cached.
+     */
+    has(provider: LLMProvider, model: string): boolean;
+    /**
+     * Check if model supports audio.
+     */
+    supportsAudio(provider: LLMProvider, model: string): boolean;
+    /**
+     * Check if model supports a specific feature.
+     * @param provider - LLM provider
+     * @param model - Model name
+     * @param feature - Feature to check
+     * @returns true if feature is supported
+     */
+    supportsFeature(provider: LLMProvider, model: string, feature: keyof ModelCapabilities): boolean;
+    /**
+     * Check if model supports images.
+     */
+    supportsImages(provider: LLMProvider, model: string): boolean;
+    /**
+     * Check if model supports PDFs.
+     */
+    supportsPdf(provider: LLMProvider, model: string): boolean;
+    /**
+     * Check if model supports streaming.
+     */
+    supportsStreaming(provider: LLMProvider, model: string): boolean;
+    /**
+     * Check if model supports extended thinking (Gemini).
+     */
+    supportsThinking(provider: LLMProvider, model: string): boolean;
+    /**
+     * Generate cache key from provider and model.
+     */
+    private getCacheKey;
+    /**
+     * Get cached model info, fetching from registry if not cached.
+     * @param provider - LLM provider
+     * @param model - Model name
+     * @returns Cached model info
+     */
+    private getOrFetch;
+}
+/**
+ * Singleton instance for shared capability cache.
+ * Use this for application-wide caching.
+ */
+export declare const globalCapabilityCache: ModelCapabilityCache;

package/dist/agent/infra/llm/capability-cache.js

@@ -0,0 +1,125 @@
+/**
+ * Model Capability Cache
+ *
+ * Caches model capability lookups for performance.
+ * Avoids repeated registry lookups for the same model.
+ */
+import { getModelInfoWithFallback, } from '../../core/domain/llm/index.js';
+/**
+ * Cache for model capability lookups.
+ *
+ * This cache stores model information to avoid repeated registry lookups.
+ * The cache is keyed by "provider:model" for quick access.
+ */
+export class ModelCapabilityCache {
+    cache = new Map();
+    /**
+     * Get cache size (number of cached models).
+     */
+    get size() {
+        return this.cache.size;
+    }
+    /**
+     * Clear the cache.
+     */
+    clear() {
+        this.cache.clear();
+    }
+    /**
+     * Get model capabilities.
+     * @param provider - LLM provider
+     * @param model - Model name
+     * @returns ModelCapabilities object
+     */
+    getCapabilities(provider, model) {
+        return this.getOrFetch(provider, model).capabilities;
+    }
+    /**
+     * Get characters per token ratio for model.
+     */
+    getCharsPerToken(provider, model) {
+        return this.getOrFetch(provider, model).charsPerToken;
+    }
+    /**
+     * Get max input tokens for model.
+     */
+    getMaxInputTokens(provider, model) {
+        return this.getOrFetch(provider, model).maxInputTokens;
+    }
+    /**
+     * Check if a model is cached.
+     */
+    has(provider, model) {
+        return this.cache.has(this.getCacheKey(provider, model));
+    }
+    /**
+     * Check if model supports audio.
+     */
+    supportsAudio(provider, model) {
+        return this.supportsFeature(provider, model, 'supportsAudio');
+    }
+    /**
+     * Check if model supports a specific feature.
+     * @param provider - LLM provider
+     * @param model - Model name
+     * @param feature - Feature to check
+     * @returns true if feature is supported
+     */
+    supportsFeature(provider, model, feature) {
+        const capabilities = this.getCapabilities(provider, model);
+        return capabilities[feature] ?? false;
+    }
+    /**
+     * Check if model supports images.
+     */
+    supportsImages(provider, model) {
+        return this.supportsFeature(provider, model, 'supportsImages');
+    }
+    /**
+     * Check if model supports PDFs.
+     */
+    supportsPdf(provider, model) {
+        return this.supportsFeature(provider, model, 'supportsPdf');
+    }
+    /**
+     * Check if model supports streaming.
+     */
+    supportsStreaming(provider, model) {
+        return this.supportsFeature(provider, model, 'supportsStreaming');
+    }
+    /**
+     * Check if model supports extended thinking (Gemini).
+     */
+    supportsThinking(provider, model) {
+        return this.supportsFeature(provider, model, 'supportsThinking');
+    }
+    /**
+     * Generate cache key from provider and model.
+     */
+    getCacheKey(provider, model) {
+        return `${provider}:${model}`;
+    }
+    /**
+     * Get cached model info, fetching from registry if not cached.
+     * @param provider - LLM provider
+     * @param model - Model name
+     * @returns Cached model info
+     */
+    getOrFetch(provider, model) {
+        const key = this.getCacheKey(provider, model);
+        if (!this.cache.has(key)) {
+            const modelInfo = getModelInfoWithFallback(provider, model);
+            this.cache.set(key, {
+                capabilities: modelInfo.capabilities,
+                charsPerToken: modelInfo.charsPerToken,
+                maxInputTokens: modelInfo.maxInputTokens,
+            });
+        }
+        return this.cache.get(key);
+    }
+}
+/**
+ * Singleton instance for shared capability cache.
+ * Use this for application-wide caching.
+ */
+export const globalCapabilityCache = new ModelCapabilityCache();

package/dist/agent/infra/llm/context/compaction/compaction-service.d.ts

@@ -0,0 +1,138 @@
+import type { CompactionResult } from '../../../../core/domain/storage/message-storage-types.js';
+import type { IContentGenerator } from '../../../../core/interfaces/i-content-generator.js';
+import type { ITokenizer } from '../../../../core/interfaces/i-tokenizer.js';
+import type { InternalMessage } from '../../../../core/interfaces/message-types.js';
+import type { MessageStorageService } from '../../../storage/message-storage-service.js';
+/**
+ * Configuration for compaction behavior.
+ */
+export interface CompactionConfig {
+    /**
+     * Percentage of context tokens that triggers compaction (0.0 - 1.0).
+     * Default: 0.85 (85%)
+     */
+    overflowThreshold?: number;
+    /**
+     * Number of recent user turns to protect from pruning.
+     * Based on OpenCode's turn-based protection pattern.
+     * Tool outputs in these turns will not be compacted.
+     * Default: 2
+     */
+    protectedTurns?: number;
+    /**
+     * Number of tokens to keep in tool outputs after pruning.
+     * Based on OpenCode's PRUNE_PROTECT constant.
+     * Default: 40000
+     */
+    pruneKeepTokens?: number;
+    /**
+     * Minimum tokens that must be recoverable to perform pruning.
+     * Based on OpenCode's PRUNE_MINIMUM constant.
+     * If pruning would save less than this, skip it.
+     * Default: 20000
+     */
+    pruneMinimumTokens?: number;
+    /**
+     * System prompt for generating compaction summaries.
+     */
+    summaryPrompt?: string;
+}
+/**
+ * Result of checking for context overflow.
+ */
+export interface OverflowCheckResult {
+    /** Current token count */
+    currentTokens: number;
+    /** Whether overflow threshold is exceeded */
+    isOverflow: boolean;
+    /** Maximum allowed tokens */
+    maxTokens: number;
+    /** Recommended action */
+    recommendation: 'compact' | 'none' | 'prune';
+}
+/**
+ * Input for compaction operations.
+ */
+export interface CompactionInput {
+    /** Maximum context tokens allowed */
+    contextLimit: number;
+    /** Current token count (including all messages) */
+    currentTokens: number;
+    /** Session ID to compact */
+    sessionId: string;
+}
+/**
+ * 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 declare class CompactionService {
+    private readonly messageStorage;
+    private readonly tokenizer;
+    private readonly config;
+    constructor(messageStorage: MessageStorageService, tokenizer: ITokenizer, config?: CompactionConfig);
+    /**
+     * 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
+     */
+    autoCompact(input: CompactionInput): Promise<CompactionResult | undefined>;
+    /**
+     * Check if context is overflowing and recommend action.
+     */
+    checkOverflow(currentTokens: number, contextLimit: number): OverflowCheckResult;
+    /**
+     * Create a compaction boundary with the given summary.
+     * The boundary acts as a marker - history loading stops here.
+     */
+    createCompactionBoundary(sessionId: string, summary: string): Promise<void>;
+    /**
+     * Estimate tokens for a text string.
+     * Uses the configured tokenizer.
+     */
+    estimateTokens(text: string): Promise<number>;
+    /**
+     * Generate a compaction summary using the LLM.
+     * Called when context overflow requires full compaction (not just pruning).
+     *
+     * @param generator - The content generator to use for LLM calls
+     * @param messages - The conversation history to summarize
+     * @param taskId - Task ID from usecase for billing tracking
+     * @param model - The model ID to use for generation
+     * @returns The generated summary text
+     */
+    generateSummary(generator: IContentGenerator, messages: InternalMessage[], taskId: string, model: string): Promise<string>;
+    /**
+     * Get the current compaction configuration.
+     */
+    getConfig(): Readonly<Required<CompactionConfig>>;
+    /**
+     * 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(): {
+        systemPrompt: string;
+        userMessage: string;
+    };
+    /**
+     * Prune old tool outputs to reduce context size.
+     * Keeps the most recent tool outputs up to the configured token limit.
+     * Only executes if minimum token threshold can be recovered.
+     *
+     * @param sessionId - The session to prune
+     * @returns CompactionResult with count and tokens saved (or zeros if below threshold)
+     */
+    pruneToolOutputs(sessionId: string): Promise<CompactionResult>;
+}
+/**
+ * Factory function to create CompactionService.
+ */
+export declare function createCompactionService(messageStorage: MessageStorageService, tokenizer: ITokenizer, config?: CompactionConfig): CompactionService;