byterover-cli 1.4.0 → 1.5.0

package/README.md

@@ -14,6 +14,7 @@ Command-line interface for ByteRover, featuring an interactive REPL with a moder
 * [Keyboard Shortcuts](#keyboard-shortcuts)
 * [What is Context Tree?](#what-is-context-tree)
 * [Supported AI Agents](#supported-ai-agents)
+* [LLM Providers](#llm-providers) (BETA)
 * [Slash Commands Reference](#slash-commands-reference)
 * [Authentication](#authentication)
 * [Configuration](#configuration)
@@ -51,7 +52,7 @@ brv --version
 
 Visit [**ByteRover Docs**](https://docs.byterover.dev) for more information.
 
-Get started with ByteRover CLI in three simple steps:
+Get started with ByteRover CLI:
 
 ### 1. Start the REPL
 
@@ -91,6 +92,14 @@ ByteRover automatically configures the best connector for your installed agents:
 - **MCP tools** for most other agents (universal protocol)
 - Switch connector types anytime via `/connectors`
 
+### 5. (Optional) Connect an LLM Provider
+
+```
+/provider
+```
+
+ByteRover works out of the box with its built-in LLM provider. To use your own models, connect to [OpenRouter](https://openrouter.ai/keys) for access to 200+ models. See [LLM Providers](#llm-providers) for details.
+
 You're now ready to use ByteRover! Try `/status` to see your project's current state.
 
 ## Interactive REPL
@@ -203,6 +212,48 @@ ByteRover supports four connector types:
 - All others (16 agents): MCP connector
 - Rules: Available for all agents as fallback
 
+## LLM Providers (BETA)
+
+ByteRover uses LLMs internally to power `/curate` and `/query` operations. By default, the built-in ByteRover provider is used with no configuration required. You can optionally connect to OpenRouter to access 200+ models.
+
+### Available Providers
+
+| Provider | API Key Required | Models |
+|----------|-----------------|--------|
+| **ByteRover** (default) | No | Built-in internal model |
+| **OpenRouter** | Yes | 200+ models from Anthropic, OpenAI, Google, Meta, and more |
+
+### Connecting a Provider
+
+Use `/provider` (aliases: `/providers`, `/connect`) to switch providers:
+
+```
+/provider
+```
+
+This opens an interactive prompt showing all available providers with their connection status.
+
+### Selecting a Model
+
+When connected to OpenRouter, use `/model` (alias: `/models`) to browse and select models:
+
+```
+/model
+```
+
+The model browser shows:
+- **Pricing**: Input/output cost per million tokens (e.g., `$3.00/$15.00/M`)
+- **Context window**: Maximum token capacity (e.g., `200K ctx`)
+- **Free models**: Marked with `[Free]`
+- **Favorites and recents**: Starred and recently used models appear first
+
+### OpenRouter Setup
+
+1. Get an API key at [openrouter.ai/keys](https://openrouter.ai/keys)
+2. Run `/provider` and select **OpenRouter**
+3. Paste your API key when prompted (stored securely in system keychain)
+4. Run `/model` to select a model (default: `anthropic/claude-3.5-sonnet`)
+
 ## Slash Commands Reference
 
 ### Core Workflow
@@ -279,6 +330,15 @@ ByteRover supports four connector types:
 **Reset options:**
 - `-y, --yes`: Skip confirmation prompt
 
+### LLM Providers (BETA)
+
+| Command | Description |
+|---------|-------------|
+| `/provider` | Connect to and switch between LLM providers |
+| `/model` | Select a model from the active provider (OpenRouter) |
+
+**Aliases:** `/providers` and `/connect` for `/provider`; `/models` for `/model`
+
 ### Session Management
 
 | Command | Description |

package/dist/core/domain/cipher/process/types.d.ts

@@ -82,7 +82,7 @@ export interface ExecuteOptions {
     /**
      * Timeout in milliseconds (max: ProcessConfig.maxTimeout).
      *
-     * @default 120000 (2 minutes)
+     * @default 300000 (5 minutes)
      */
     timeout?: number;
 }

package/dist/core/domain/entities/provider-config.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Provider Configuration Entity
+ *
+ * Stores user's provider preferences and connection state.
+ * Non-sensitive data (API keys stored separately in keychain).
+ */
+/**
+ * Configuration for a single connected provider.
+ */
+export interface ConnectedProviderConfig {
+    /** Currently active model for this provider */
+    readonly activeModel?: string;
+    /** When the provider was connected */
+    readonly connectedAt: string;
+    /** User's favorite models (for quick access) */
+    readonly favoriteModels: readonly string[];
+    /** Recently used models (last 10) */
+    readonly recentModels: readonly string[];
+}
+/**
+ * Parameters for creating a ProviderConfig.
+ */
+export interface ProviderConfigParams {
+    /** Currently active provider ID */
+    readonly activeProvider: string;
+    /** Configuration for each connected provider */
+    readonly providers: Readonly<Record<string, ConnectedProviderConfig>>;
+}
+/**
+ * Default configuration when no providers are connected.
+ */
+export declare const DEFAULT_PROVIDER_CONFIG: ProviderConfigParams;
+/**
+ * Represents the provider configuration for the CLI.
+ * Tracks which providers are connected and user preferences.
+ */
+export declare class ProviderConfig {
+    readonly activeProvider: string;
+    readonly providers: Readonly<Record<string, ConnectedProviderConfig>>;
+    private constructor();
+    /**
+     * Creates a new ProviderConfig with default values.
+     */
+    static createDefault(): ProviderConfig;
+    /**
+     * Deserializes config from JSON format.
+     * Returns default config for invalid JSON structure.
+     */
+    static fromJson(json: unknown): ProviderConfig;
+    /**
+     * Get the active model for a provider.
+     */
+    getActiveModel(providerId: string): string | undefined;
+    /**
+     * Get favorite models for a provider.
+     */
+    getFavoriteModels(providerId: string): readonly string[];
+    /**
+     * Get recent models for a provider.
+     */
+    getRecentModels(providerId: string): readonly string[];
+    /**
+     * Check if a provider is connected.
+     */
+    isProviderConnected(providerId: string): boolean;
+    /**
+     * Serializes the config to JSON format.
+     */
+    toJson(): ProviderConfigParams;
+    /**
+     * Create a new config with the active model changed for a provider.
+     */
+    withActiveModel(providerId: string, modelId: string): ProviderConfig;
+    /**
+     * Create a new config with the active provider changed.
+     */
+    withActiveProvider(providerId: string): ProviderConfig;
+    /**
+     * Create a new config with a model toggled as favorite.
+     */
+    withFavoriteToggled(providerId: string, modelId: string): ProviderConfig;
+    /**
+     * Create a new config with a provider connected.
+     */
+    withProviderConnected(providerId: string, options?: {
+        activeModel?: string;
+    }): ProviderConfig;
+    /**
+     * Create a new config with a provider disconnected.
+     */
+    withProviderDisconnected(providerId: string): ProviderConfig;
+}

package/dist/core/domain/entities/provider-config.js

@@ -0,0 +1,181 @@
+/**
+ * Provider Configuration Entity
+ *
+ * Stores user's provider preferences and connection state.
+ * Non-sensitive data (API keys stored separately in keychain).
+ */
+/**
+ * Type guard for ProviderConfig JSON validation.
+ */
+const isProviderConfigJson = (json) => {
+    if (typeof json !== 'object' || json === null)
+        return false;
+    const obj = json;
+    if (typeof obj.activeProvider !== 'string')
+        return false;
+    if (typeof obj.providers !== 'object' || obj.providers === null)
+        return false;
+    return true;
+};
+/**
+ * Default configuration when no providers are connected.
+ */
+export const DEFAULT_PROVIDER_CONFIG = {
+    activeProvider: 'byterover',
+    providers: {},
+};
+/**
+ * Maximum number of recent models to track.
+ */
+const MAX_RECENT_MODELS = 10;
+/**
+ * Represents the provider configuration for the CLI.
+ * Tracks which providers are connected and user preferences.
+ */
+export class ProviderConfig {
+    activeProvider;
+    providers;
+    constructor(params) {
+        this.activeProvider = params.activeProvider;
+        this.providers = params.providers;
+    }
+    /**
+     * Creates a new ProviderConfig with default values.
+     */
+    static createDefault() {
+        return new ProviderConfig(DEFAULT_PROVIDER_CONFIG);
+    }
+    /**
+     * Deserializes config from JSON format.
+     * Returns default config for invalid JSON structure.
+     */
+    static fromJson(json) {
+        if (!isProviderConfigJson(json)) {
+            return ProviderConfig.createDefault();
+        }
+        return new ProviderConfig(json);
+    }
+    /**
+     * Get the active model for a provider.
+     */
+    getActiveModel(providerId) {
+        return this.providers[providerId]?.activeModel;
+    }
+    /**
+     * Get favorite models for a provider.
+     */
+    getFavoriteModels(providerId) {
+        return this.providers[providerId]?.favoriteModels ?? [];
+    }
+    /**
+     * Get recent models for a provider.
+     */
+    getRecentModels(providerId) {
+        return this.providers[providerId]?.recentModels ?? [];
+    }
+    /**
+     * Check if a provider is connected.
+     */
+    isProviderConnected(providerId) {
+        return providerId in this.providers;
+    }
+    /**
+     * Serializes the config to JSON format.
+     */
+    toJson() {
+        return {
+            activeProvider: this.activeProvider,
+            providers: this.providers,
+        };
+    }
+    /**
+     * Create a new config with the active model changed for a provider.
+     */
+    withActiveModel(providerId, modelId) {
+        const existingConfig = this.providers[providerId];
+        if (!existingConfig) {
+            return this;
+        }
+        // Add to recent models (at the front, deduplicated)
+        const recentModels = [
+            modelId,
+            ...existingConfig.recentModels.filter((m) => m !== modelId),
+        ].slice(0, MAX_RECENT_MODELS);
+        const newProviderConfig = {
+            ...existingConfig,
+            activeModel: modelId,
+            recentModels,
+        };
+        return new ProviderConfig({
+            ...this.toJson(),
+            providers: {
+                ...this.providers,
+                [providerId]: newProviderConfig,
+            },
+        });
+    }
+    /**
+     * Create a new config with the active provider changed.
+     */
+    withActiveProvider(providerId) {
+        return new ProviderConfig({
+            ...this.toJson(),
+            activeProvider: providerId,
+        });
+    }
+    /**
+     * Create a new config with a model toggled as favorite.
+     */
+    withFavoriteToggled(providerId, modelId) {
+        const existingConfig = this.providers[providerId];
+        if (!existingConfig) {
+            return this;
+        }
+        const isFavorite = existingConfig.favoriteModels.includes(modelId);
+        const favoriteModels = isFavorite
+            ? existingConfig.favoriteModels.filter((m) => m !== modelId)
+            : [...existingConfig.favoriteModels, modelId];
+        const newProviderConfig = {
+            ...existingConfig,
+            favoriteModels,
+        };
+        return new ProviderConfig({
+            ...this.toJson(),
+            providers: {
+                ...this.providers,
+                [providerId]: newProviderConfig,
+            },
+        });
+    }
+    /**
+     * Create a new config with a provider connected.
+     */
+    withProviderConnected(providerId, options) {
+        const existingConfig = this.providers[providerId];
+        const newProviderConfig = {
+            activeModel: options?.activeModel ?? existingConfig?.activeModel,
+            connectedAt: existingConfig?.connectedAt ?? new Date().toISOString(),
+            favoriteModels: existingConfig?.favoriteModels ?? [],
+            recentModels: existingConfig?.recentModels ?? [],
+        };
+        return new ProviderConfig({
+            ...this.toJson(),
+            providers: {
+                ...this.providers,
+                [providerId]: newProviderConfig,
+            },
+        });
+    }
+    /**
+     * Create a new config with a provider disconnected.
+     */
+    withProviderDisconnected(providerId) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { [providerId]: _removed, ...remainingProviders } = this.providers;
+        const newActiveProvider = this.activeProvider === providerId ? 'byterover' : this.activeProvider;
+        return new ProviderConfig({
+            activeProvider: newActiveProvider,
+            providers: remainingProviders,
+        });
+    }
+}

package/dist/core/domain/entities/provider-registry.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Provider Registry
+ *
+ * Defines available LLM providers that can be connected to byterover-cli.
+ * Inspired by OpenCode's provider system.
+ */
+/**
+ * Definition for an LLM provider.
+ */
+export interface ProviderDefinition {
+    /** URL where users can get an API key */
+    readonly apiKeyUrl?: string;
+    /** API base URL (empty for internal providers) */
+    readonly baseUrl: string;
+    /** Category for grouping in UI */
+    readonly category: 'other' | 'popular';
+    /** Default model to use when first connected */
+    readonly defaultModel?: string;
+    /** Short description */
+    readonly description: string;
+    /** Default headers for API requests */
+    readonly headers: Readonly<Record<string, string>>;
+    /** Unique provider identifier */
+    readonly id: string;
+    /** Endpoint to fetch available models */
+    readonly modelsEndpoint: string;
+    /** Display name */
+    readonly name: string;
+    /** Priority for display order (lower = higher priority) */
+    readonly priority: number;
+}
+/**
+ * Registry of all available providers.
+ * Order by priority for consistent display.
+ */
+export declare const PROVIDER_REGISTRY: Readonly<Record<string, ProviderDefinition>>;
+/**
+ * Get all providers sorted by priority.
+ */
+export declare function getProvidersSortedByPriority(): ProviderDefinition[];
+/**
+ * Get providers grouped by category.
+ */
+export declare function getProvidersGroupedByCategory(): {
+    other: ProviderDefinition[];
+    popular: ProviderDefinition[];
+};
+/**
+ * Get a provider by ID.
+ */
+export declare function getProviderById(id: string): ProviderDefinition | undefined;
+/**
+ * Check if a provider requires an API key.
+ */
+export declare function providerRequiresApiKey(id: string): boolean;

package/dist/core/domain/entities/provider-registry.js

@@ -0,0 +1,74 @@
+/**
+ * Provider Registry
+ *
+ * Defines available LLM providers that can be connected to byterover-cli.
+ * Inspired by OpenCode's provider system.
+ */
+/**
+ * Registry of all available providers.
+ * Order by priority for consistent display.
+ */
+export const PROVIDER_REGISTRY = {
+    byterover: {
+        baseUrl: '',
+        category: 'popular',
+        description: 'Internal ByteRover LLM',
+        headers: {},
+        id: 'byterover',
+        modelsEndpoint: '',
+        name: 'ByteRover',
+        priority: 0,
+    },
+    openrouter: {
+        apiKeyUrl: 'https://openrouter.ai/keys',
+        baseUrl: 'https://openrouter.ai/api/v1',
+        category: 'popular',
+        defaultModel: 'anthropic/claude-3.5-sonnet',
+        description: 'Access 200+ models',
+        headers: {
+            'HTTP-Referer': 'https://byterover.dev',
+            'X-Title': 'byterover-cli',
+        },
+        id: 'openrouter',
+        modelsEndpoint: '/models',
+        name: 'OpenRouter',
+        priority: 1,
+    },
+    // Future providers can be added here:
+    // anthropic: { ... },
+    // openai: { ... },
+    // google: { ... },
+    // groq: { ... },
+};
+/**
+ * Get all providers sorted by priority.
+ */
+export function getProvidersSortedByPriority() {
+    return Object.values(PROVIDER_REGISTRY).sort((a, b) => a.priority - b.priority);
+}
+/**
+ * Get providers grouped by category.
+ */
+export function getProvidersGroupedByCategory() {
+    const providers = getProvidersSortedByPriority();
+    return {
+        other: providers.filter((p) => p.category === 'other'),
+        popular: providers.filter((p) => p.category === 'popular'),
+    };
+}
+/**
+ * Get a provider by ID.
+ */
+export function getProviderById(id) {
+    return PROVIDER_REGISTRY[id];
+}
+/**
+ * Check if a provider requires an API key.
+ */
+export function providerRequiresApiKey(id) {
+    const provider = getProviderById(id);
+    if (!provider)
+        return false;
+    // Internal providers (empty baseUrl) don't need API keys
+    return provider.baseUrl.length > 0;
+}

package/dist/core/interfaces/cipher/i-content-generator.d.ts

@@ -12,6 +12,17 @@
 import type { ToolSet } from '../../domain/cipher/tools/types.js';
 import type { ExecutionContext } from './i-cipher-agent.js';
 import type { InternalMessage, ToolCall } from './message-types.js';
+/**
+ * Stream chunk type for distinguishing content types during streaming.
+ */
+export declare enum StreamChunkType {
+    /** Regular text content */
+    CONTENT = "content",
+    /** Thinking/reasoning content from models like Gemini */
+    THINKING = "thinking",
+    /** Tool call request */
+    TOOL_CALL = "tool_call"
+}
 /**
  * Configuration for content generation.
  */
@@ -76,8 +87,27 @@ export interface GenerateContentChunk {
     finishReason?: 'error' | 'max_tokens' | 'stop' | 'tool_calls';
     /** Whether this is the final chunk */
     isComplete: boolean;
+    /** Provider-specific metadata */
+    providerMetadata?: Record<string, unknown>;
+    /**
+     * Raw API chunk data for native reasoning extraction.
+     * Used by models that return reasoning in native fields (OpenAI, Grok, Gemini).
+     */
+    rawChunk?: unknown;
+    /**
+     * Incremental reasoning/thinking content.
+     * For models that provide native reasoning fields (OpenAI o1/o3, Grok, Gemini).
+     */
+    reasoning?: string;
+    /** Unique ID for the reasoning block (for tracking across deltas) */
+    reasoningId?: string;
     /** Tool calls (only on final chunk or when complete) */
     toolCalls?: ToolCall[];
+    /**
+     * Type of this chunk for distinguishing content from thinking.
+     * Defaults to CONTENT if not specified.
+     */
+    type?: StreamChunkType;
 }
 /**
  * Content Generator interface.

package/dist/core/interfaces/cipher/i-content-generator.js

@@ -9,4 +9,15 @@
  *
  * Based on gemini-cli's ContentGenerator pattern.
  */
-export {};
+/**
+ * Stream chunk type for distinguishing content types during streaming.
+ */
+export var StreamChunkType;
+(function (StreamChunkType) {
+    /** Regular text content */
+    StreamChunkType["CONTENT"] = "content";
+    /** Thinking/reasoning content from models like Gemini */
+    StreamChunkType["THINKING"] = "thinking";
+    /** Tool call request */
+    StreamChunkType["TOOL_CALL"] = "tool_call";
+})(StreamChunkType || (StreamChunkType = {}));

package/dist/core/interfaces/cipher/message-factory.d.ts

@@ -40,7 +40,10 @@ export declare function createFilePart(data: FilePart['data'], mimeType: string,
 export declare function createReasoningPart(text: string, summary?: {
     description: string;
     subject: string;
-}, options?: PartOptions): ReasoningPart;
+}, options?: PartOptions & {
+    id?: string;
+    providerMetadata?: Record<string, unknown>;
+}): ReasoningPart;
 /**
  * Create a ToolPart in pending state.
  */

package/dist/core/interfaces/cipher/message-factory.js

@@ -52,9 +52,14 @@ export function createFilePart(data, mimeType, filename, options) {
  */
 export function createReasoningPart(text, summary, options) {
     return {
+        id: options?.id ?? `reasoning-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
         text,
+        time: {
+            start: Date.now(),
+        },
         type: 'reasoning',
         ...(summary && { summary }),
+        ...(options?.providerMetadata && { providerMetadata: options.providerMetadata }),
         ...(options?.synthetic !== undefined && { synthetic: options.synthetic }),
         ...(options?.metadata && { metadata: options.metadata }),
     };

package/dist/core/interfaces/cipher/message-types.d.ts

@@ -57,9 +57,17 @@ export interface FilePart extends BasePart {
 }
 /**
  * Reasoning/thinking content part.
- * Represents structured thinking traces from models like Gemini or Claude.
+ * Represents structured thinking traces from models like Gemini, Claude, Grok, or OpenAI.
+ * Follows OpenCode's pattern with id, timing, and provider metadata.
  */
 export interface ReasoningPart extends BasePart {
+    /** Unique identifier for this reasoning block */
+    id: string;
+    /**
+     * Provider-specific metadata (encrypted content, reasoning effort, etc.)
+     * Used to preserve original provider data for debugging and special handling.
+     */
+    providerMetadata?: Record<string, unknown>;
     /**
      * Parsed summary for display in UI.
      * Extracted from the raw text for easier rendering.
@@ -72,6 +80,16 @@ export interface ReasoningPart extends BasePart {
     };
     /** Raw reasoning/thinking text from the model */
     text: string;
+    /**
+     * Timing information for the reasoning block.
+     * Used for UX feedback and analytics.
+     */
+    time: {
+        /** Unix timestamp when reasoning ended (undefined if still streaming) */
+        end?: number;
+        /** Unix timestamp when reasoning started */
+        start: number;
+    };
     type: 'reasoning';
 }
 /**