byterover-cli 1.8.0 → 2.0.0

package/dist/agent/infra/llm/context/deferred-effects.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Deferred effects pattern for ensuring side-effects (like event emissions)
+ * only execute after database operations succeed.
+ *
+ * Usage:
+ *   const effects = new DeferredEffects()
+ *   effects.defer(() => bus.emit('event', data))
+ *   await databaseOperation()
+ *   effects.flush()  // Only fires events after DB success
+ *
+ * On error:
+ *   effects.discard()  // Silently drops queued effects
+ */
+export declare class DeferredEffects {
+    private queue;
+    /**
+     * Queue a callback to execute later.
+     *
+     * @param fn - Side-effect callback to defer
+     */
+    defer(fn: () => void): void;
+    /**
+     * Discard all queued effects without executing them.
+     */
+    discard(): void;
+    /**
+     * Execute all queued effects and clear the queue.
+     */
+    flush(): void;
+}

package/dist/agent/infra/llm/context/deferred-effects.js

@@ -0,0 +1,40 @@
+/**
+ * Deferred effects pattern for ensuring side-effects (like event emissions)
+ * only execute after database operations succeed.
+ *
+ * Usage:
+ *   const effects = new DeferredEffects()
+ *   effects.defer(() => bus.emit('event', data))
+ *   await databaseOperation()
+ *   effects.flush()  // Only fires events after DB success
+ *
+ * On error:
+ *   effects.discard()  // Silently drops queued effects
+ */
+export class DeferredEffects {
+    queue = [];
+    /**
+     * Queue a callback to execute later.
+     *
+     * @param fn - Side-effect callback to defer
+     */
+    defer(fn) {
+        this.queue.push(fn);
+    }
+    /**
+     * Discard all queued effects without executing them.
+     */
+    discard() {
+        this.queue = [];
+    }
+    /**
+     * Execute all queued effects and clear the queue.
+     */
+    flush() {
+        const effects = this.queue;
+        this.queue = [];
+        for (const fn of effects) {
+            fn();
+        }
+    }
+}

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

@@ -73,7 +73,7 @@ export declare class GeminiMessageFormatter implements IMessageFormatter<Content
  * 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.
+ * All function calls in each model turn need 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)

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

@@ -321,7 +321,7 @@ export class GeminiMessageFormatter {
  * 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.
+ * All function calls in each model turn need 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)
@@ -355,7 +355,7 @@ export function ensureActiveLoopHasThoughtSignatures(contents, model) {
             continue;
         }
         const newParts = [...content.parts];
-        const updatedContent = addThoughtSignatureToFirstFunctionCall(newParts, content);
+        const updatedContent = addThoughtSignatureToAllFunctionCalls(newParts, content);
         if (updatedContent) {
             newContents[i] = updatedContent;
         }
@@ -363,10 +363,11 @@ export function ensureActiveLoopHasThoughtSignatures(contents, model) {
     return newContents;
 }
 /**
- * Adds thought signature to the first function call in parts if missing.
+ * Adds thought signature to ALL function calls in parts that are missing one.
  * Returns updated content or null if no modification needed.
  */
-function addThoughtSignatureToFirstFunctionCall(parts, content) {
+function addThoughtSignatureToAllFunctionCalls(parts, content) {
+    let modified = false;
     for (let j = 0; j < parts.length; j++) {
         const part = parts[j];
         if (!part || !('functionCall' in part) || !part.functionCall) {
@@ -374,7 +375,7 @@ function addThoughtSignatureToFirstFunctionCall(parts, content) {
         }
         // Check if thoughtSignature already exists using type guard
         if (hasThoughtSignature(part) && part.thoughtSignature) {
-            return null; // Already has signature, no modification needed
+            continue;
         }
         // Add synthetic thought signature
         const partWithSignature = {
@@ -382,10 +383,13 @@ function addThoughtSignatureToFirstFunctionCall(parts, content) {
             thoughtSignature: SYNTHETIC_THOUGHT_SIGNATURE,
         };
         parts[j] = partWithSignature;
-        return {
-            ...content,
-            parts,
-        };
+        modified = true;
+    }
+    if (!modified) {
+        return null;
     }
-    return null; // No function call found
+    return {
+        ...content,
+        parts,
+    };
 }

package/dist/agent/infra/llm/generators/ai-sdk-content-generator.d.ts

@@ -0,0 +1,33 @@
+/**
+ * AI SDK Content Generator
+ *
+ * Universal IContentGenerator adapter wrapping any AI SDK LanguageModel.
+ * Replaces per-provider content generators with one unified implementation.
+ */
+import type { LanguageModel } from 'ai';
+import type { GenerateContentChunk, GenerateContentRequest, GenerateContentResponse, IContentGenerator } from '../../../core/interfaces/i-content-generator.js';
+/**
+ * Configuration for AiSdkContentGenerator.
+ */
+export interface AiSdkContentGeneratorConfig {
+    /** Characters per token ratio for token estimation */
+    charsPerToken?: number;
+    /** AI SDK LanguageModel instance */
+    model: LanguageModel;
+}
+/**
+ * Universal content generator that wraps any AI SDK LanguageModel.
+ *
+ * Implements IContentGenerator by delegating to the AI SDK's
+ * generateText() and streamText() functions. This single adapter
+ * replaces all per-provider content generators (Anthropic, OpenAI,
+ * Google, OpenRouter) with one unified implementation.
+ */
+export declare class AiSdkContentGenerator implements IContentGenerator {
+    private readonly charsPerToken;
+    private readonly model;
+    constructor(config: AiSdkContentGeneratorConfig);
+    estimateTokensSync(content: string): number;
+    generateContent(request: GenerateContentRequest): Promise<GenerateContentResponse>;
+    generateContentStream(request: GenerateContentRequest): AsyncGenerator<GenerateContentChunk>;
+}

package/dist/agent/infra/llm/generators/ai-sdk-content-generator.js

@@ -0,0 +1,166 @@
+/**
+ * AI SDK Content Generator
+ *
+ * Universal IContentGenerator adapter wrapping any AI SDK LanguageModel.
+ * Replaces per-provider content generators with one unified implementation.
+ */
+import { generateText, streamText } from 'ai';
+import { StreamChunkType } from '../../../core/interfaces/i-content-generator.js';
+import { toAiSdkTools, toModelMessages } from './ai-sdk-message-converter.js';
+const DEFAULT_CHARS_PER_TOKEN = 4;
+/**
+ * Universal content generator that wraps any AI SDK LanguageModel.
+ *
+ * Implements IContentGenerator by delegating to the AI SDK's
+ * generateText() and streamText() functions. This single adapter
+ * replaces all per-provider content generators (Anthropic, OpenAI,
+ * Google, OpenRouter) with one unified implementation.
+ */
+export class AiSdkContentGenerator {
+    charsPerToken;
+    model;
+    constructor(config) {
+        this.model = config.model;
+        this.charsPerToken = config.charsPerToken ?? DEFAULT_CHARS_PER_TOKEN;
+    }
+    estimateTokensSync(content) {
+        return Math.ceil(content.length / this.charsPerToken);
+    }
+    async generateContent(request) {
+        const messages = toModelMessages(request.contents);
+        const tools = toAiSdkTools(request.tools);
+        const result = await generateText({
+            maxOutputTokens: request.config.maxTokens,
+            maxRetries: 0, // RetryableContentGenerator handles retries
+            messages,
+            model: this.model,
+            temperature: request.config.temperature,
+            ...(request.systemPrompt && { system: request.systemPrompt }),
+            ...(tools && { tools }),
+            ...(request.config.topK !== undefined && { topK: request.config.topK }),
+            ...(request.config.topP !== undefined && { topP: request.config.topP }),
+        });
+        // Map AI SDK tool calls to our ToolCall format
+        // Preserve thoughtSignature from providerMetadata (required by Gemini 3+ models)
+        const toolCalls = result.toolCalls.map((tc) => {
+            const meta = tc.providerMetadata;
+            const thoughtSig = meta?.google?.thoughtSignature;
+            return {
+                function: {
+                    arguments: JSON.stringify(tc.input),
+                    name: tc.toolName,
+                },
+                id: tc.toolCallId,
+                ...(typeof thoughtSig === 'string' && { thoughtSignature: thoughtSig }),
+                type: 'function',
+            };
+        });
+        return {
+            content: result.text,
+            finishReason: mapFinishReason(result.finishReason, toolCalls.length > 0),
+            rawResponse: result.response,
+            toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+            usage: {
+                completionTokens: result.usage.outputTokens ?? 0,
+                promptTokens: result.usage.inputTokens ?? 0,
+                totalTokens: result.usage.totalTokens ?? 0,
+            },
+        };
+    }
+    async *generateContentStream(request) {
+        const messages = toModelMessages(request.contents);
+        const tools = toAiSdkTools(request.tools);
+        const result = streamText({
+            maxOutputTokens: request.config.maxTokens,
+            maxRetries: 0,
+            messages,
+            model: this.model,
+            temperature: request.config.temperature,
+            ...(request.systemPrompt && { system: request.systemPrompt }),
+            ...(tools && { tools }),
+            ...(request.config.topK !== undefined && { topK: request.config.topK }),
+            ...(request.config.topP !== undefined && { topP: request.config.topP }),
+        });
+        // Accumulate tool calls during streaming
+        const pendingToolCalls = [];
+        for await (const event of result.fullStream) {
+            switch (event.type) {
+                case 'error': {
+                    // Throw the error so RetryableContentGenerator can catch and retry it.
+                    // Yielding it as content would swallow the error and prevent retry logic
+                    // from working (e.g., for 429 rate limit errors).
+                    throw event.error instanceof Error ? event.error : new Error(String(event.error));
+                }
+                case 'finish-step': {
+                    yield {
+                        finishReason: mapFinishReason(event.finishReason, pendingToolCalls.length > 0),
+                        isComplete: true,
+                        toolCalls: pendingToolCalls.length > 0 ? [...pendingToolCalls] : undefined,
+                    };
+                    break;
+                }
+                case 'reasoning-delta': {
+                    yield {
+                        isComplete: false,
+                        reasoning: event.text,
+                        reasoningId: event.id,
+                        type: StreamChunkType.THINKING,
+                    };
+                    break;
+                }
+                case 'text-delta': {
+                    yield {
+                        content: event.text,
+                        isComplete: false,
+                        type: StreamChunkType.CONTENT,
+                    };
+                    break;
+                }
+                case 'tool-call': {
+                    // Preserve thoughtSignature from providerMetadata (required by Gemini 3+ models)
+                    const meta = event.providerMetadata;
+                    const thoughtSig = meta?.google?.thoughtSignature;
+                    pendingToolCalls.push({
+                        function: {
+                            arguments: JSON.stringify(event.input),
+                            name: event.toolName,
+                        },
+                        id: event.toolCallId,
+                        ...(typeof thoughtSig === 'string' && { thoughtSignature: thoughtSig }),
+                        type: 'function',
+                    });
+                    break;
+                }
+                default: {
+                    // Ignore other events (tool-input-start/delta/end, source, file, etc.)
+                    break;
+                }
+            }
+        }
+    }
+}
+/**
+ * Map AI SDK finish reason to our finish reason format.
+ */
+function mapFinishReason(aiReason, hasToolCalls) {
+    if (hasToolCalls) {
+        return 'tool_calls';
+    }
+    switch (aiReason) {
+        case 'error': {
+            return 'error';
+        }
+        case 'length': {
+            return 'max_tokens';
+        }
+        case 'stop': {
+            return 'stop';
+        }
+        case 'tool-calls': {
+            return 'tool_calls';
+        }
+        default: {
+            return 'stop';
+        }
+    }
+}

package/dist/agent/infra/llm/generators/ai-sdk-message-converter.d.ts

@@ -0,0 +1,20 @@
+/**
+ * AI SDK Message Converter
+ *
+ * Converts between internal message format and AI SDK's ModelMessage format.
+ * System messages are excluded — passed separately via the `system` parameter.
+ */
+import type { ModelMessage } from 'ai';
+import { tool as aiSdkTool } from 'ai';
+import type { ToolSet as InternalToolSet } from '../../../core/domain/tools/types.js';
+import type { InternalMessage } from '../../../core/interfaces/message-types.js';
+/**
+ * Convert internal messages to AI SDK ModelMessage format.
+ * System messages are filtered out — they are passed via the `system` param.
+ */
+export declare function toModelMessages(messages: InternalMessage[]): ModelMessage[];
+/**
+ * Convert our ToolSet to AI SDK tool definitions.
+ * Tools are declared without `execute` — our agentic loop handles execution.
+ */
+export declare function toAiSdkTools(tools?: InternalToolSet): Record<string, ReturnType<typeof aiSdkTool>> | undefined;

package/dist/agent/infra/llm/generators/ai-sdk-message-converter.js

@@ -0,0 +1,182 @@
+/**
+ * AI SDK Message Converter
+ *
+ * Converts between internal message format and AI SDK's ModelMessage format.
+ * System messages are excluded — passed separately via the `system` parameter.
+ */
+import { tool as aiSdkTool, jsonSchema } from 'ai';
+/**
+ * Synthetic thought signature that bypasses Gemini 3+ validation.
+ * Used as fallback when real thoughtSignature is not available.
+ */
+const SYNTHETIC_THOUGHT_SIGNATURE = 'skip_thought_signature_validator';
+/**
+ * Convert internal messages to AI SDK ModelMessage format.
+ * System messages are filtered out — they are passed via the `system` param.
+ */
+export function toModelMessages(messages) {
+    const result = [];
+    for (const msg of messages) {
+        if (msg.role === 'system') {
+            continue;
+        }
+        switch (msg.role) {
+            case 'assistant': {
+                const converted = convertAssistantMessage(msg);
+                if (converted) {
+                    result.push(converted);
+                }
+                break;
+            }
+            case 'tool': {
+                appendToolResult(result, msg);
+                break;
+            }
+            case 'user': {
+                const converted = convertUserMessage(msg);
+                if (converted) {
+                    result.push(converted);
+                }
+                break;
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Convert our ToolSet to AI SDK tool definitions.
+ * Tools are declared without `execute` — our agentic loop handles execution.
+ */
+export function toAiSdkTools(tools) {
+    if (!tools || Object.keys(tools).length === 0) {
+        return undefined;
+    }
+    const result = {};
+    for (const [name, def] of Object.entries(tools)) {
+        result[name] = aiSdkTool({
+            description: def.description ?? '',
+            inputSchema: jsonSchema(def.parameters),
+        });
+    }
+    return result;
+}
+/**
+ * Extract text from an InternalMessage's content field.
+ */
+function extractTextContent(msg) {
+    if (typeof msg.content === 'string') {
+        return msg.content;
+    }
+    if (!Array.isArray(msg.content)) {
+        return '';
+    }
+    return msg.content
+        .filter((part) => part.type === 'text')
+        .map((part) => (part.type === 'text' ? part.text : ''))
+        .join('');
+}
+/**
+ * Convert an internal user message to AI SDK format.
+ * Handles text, image, and file content parts.
+ */
+function convertUserMessage(msg) {
+    if (Array.isArray(msg.content)) {
+        const parts = [];
+        for (const part of msg.content) {
+            switch (part.type) {
+                case 'file': {
+                    parts.push({
+                        data: part.data,
+                        mediaType: part.mimeType,
+                        type: 'file',
+                    });
+                    break;
+                }
+                case 'image': {
+                    parts.push({
+                        image: part.image,
+                        type: 'image',
+                        ...(part.mimeType && { mediaType: part.mimeType }),
+                    });
+                    break;
+                }
+                case 'text': {
+                    parts.push({ text: part.text, type: 'text' });
+                    break;
+                }
+                default: {
+                    break;
+                }
+            }
+        }
+        if (parts.length === 0) {
+            return undefined;
+        }
+        return { content: parts, role: 'user' };
+    }
+    const text = typeof msg.content === 'string' ? msg.content : '';
+    if (!text) {
+        return undefined;
+    }
+    return { content: text, role: 'user' };
+}
+/**
+ * Convert an internal assistant message to AI SDK format.
+ * Handles text content and tool calls.
+ */
+function convertAssistantMessage(msg) {
+    const textContent = extractTextContent(msg);
+    const hasToolCalls = msg.toolCalls && msg.toolCalls.length > 0;
+    if (!textContent && !hasToolCalls) {
+        return undefined;
+    }
+    // Simple text-only case
+    if (textContent && !hasToolCalls) {
+        return { content: textContent, role: 'assistant' };
+    }
+    const parts = [];
+    if (textContent) {
+        parts.push({ text: textContent, type: 'text' });
+    }
+    for (const tc of msg.toolCalls ?? []) {
+        let input;
+        try {
+            input = JSON.parse(tc.function.arguments);
+        }
+        catch {
+            input = {};
+        }
+        // Gemini 3+ models require thoughtSignature on function call parts.
+        // Use real signature if available, fall back to synthetic validator skip.
+        const thoughtSig = tc.thoughtSignature || SYNTHETIC_THOUGHT_SIGNATURE;
+        parts.push({
+            input,
+            providerOptions: { google: { thoughtSignature: thoughtSig } },
+            toolCallId: tc.id,
+            toolName: tc.function.name,
+            type: 'tool-call',
+        });
+    }
+    return { content: parts, role: 'assistant' };
+}
+/**
+ * Append a tool result to the message list, merging consecutive tool results.
+ */
+function appendToolResult(result, msg) {
+    const toolResultContent = typeof msg.content === 'string' ? msg.content : extractTextContent(msg);
+    const toolResult = {
+        output: { type: 'text', value: toolResultContent },
+        toolCallId: msg.toolCallId ?? '',
+        toolName: msg.name ?? '',
+        type: 'tool-result',
+    };
+    // Merge consecutive tool results into one tool message
+    const lastMsg = result.at(-1);
+    if (lastMsg && lastMsg.role === 'tool' && Array.isArray(lastMsg.content)) {
+        ;
+        lastMsg.content.push(toolResult);
+    }
+    else {
+        result.push({ content: [toolResult], role: 'tool' });
+    }
+}

package/dist/agent/infra/llm/generators/index.d.ts

@@ -2,12 +2,12 @@
  * Content Generator exports.
  *
  * This module provides content generators implementing IContentGenerator:
- * - ByteRoverContentGenerator: Uses ByteRover gRPC service
- * - OpenRouterContentGenerator: Uses OpenRouter API (OpenAI-compatible)
+ * - AiSdkContentGenerator: Universal adapter wrapping any AI SDK LanguageModel
+ * - ByteRoverContentGenerator: Uses ByteRover internal HTTP service
  * - LoggingContentGenerator: Decorator for debug logging
  * - RetryableContentGenerator: Decorator for retry with backoff
  */
+export { AiSdkContentGenerator, type AiSdkContentGeneratorConfig } from './ai-sdk-content-generator.js';
 export { ByteRoverContentGenerator, type ByteRoverContentGeneratorConfig } from './byterover-content-generator.js';
 export { LoggingContentGenerator, type LoggingOptions } from './logging-content-generator.js';
-export { OpenRouterContentGenerator, type OpenRouterContentGeneratorConfig } from './openrouter-content-generator.js';
 export { RetryableContentGenerator, type RetryableOptions } from './retryable-content-generator.js';

package/dist/agent/infra/llm/generators/index.js

@@ -2,12 +2,12 @@
  * Content Generator exports.
  *
  * This module provides content generators implementing IContentGenerator:
- * - ByteRoverContentGenerator: Uses ByteRover gRPC service
- * - OpenRouterContentGenerator: Uses OpenRouter API (OpenAI-compatible)
+ * - AiSdkContentGenerator: Universal adapter wrapping any AI SDK LanguageModel
+ * - ByteRoverContentGenerator: Uses ByteRover internal HTTP service
  * - LoggingContentGenerator: Decorator for debug logging
  * - RetryableContentGenerator: Decorator for retry with backoff
  */
+export { AiSdkContentGenerator } from './ai-sdk-content-generator.js';
 export { ByteRoverContentGenerator } from './byterover-content-generator.js';
 export { LoggingContentGenerator } from './logging-content-generator.js';
-export { OpenRouterContentGenerator } from './openrouter-content-generator.js';
 export { RetryableContentGenerator } from './retryable-content-generator.js';

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

@@ -83,6 +83,13 @@ export declare class RetryableContentGenerator implements IContentGenerator {
      * Emit a retry event via warning.
      */
     private emitRetry;
+    /**
+     * Return true when the error is a rate-limit (HTTP 429) response.
+     *
+     * Checks both the numeric status code (most reliable) and the error
+     * message text as a fallback for providers that surface 429s differently.
+     */
+    private isRateLimitError;
     /**
      * Sleep for a specified duration.
      */

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

@@ -4,7 +4,7 @@
  * 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';
+import { calculateRetryDelay, DEFAULT_RETRY_POLICY, extractRateLimitDelay, isRetryableError, RATE_LIMIT_FALLBACK_DELAY_MS, } from '../retry/retry-policy.js';
 /**
  * Retryable Content Generator.
  *
@@ -83,8 +83,12 @@ export class RetryableContentGenerator {
             if (!isRetryableError(error, this.policy)) {
                 throw error;
             }
-            // Calculate delay and emit retry event
-            const delayMs = calculateRetryDelay(attempt, this.policy);
+            // For rate-limit errors (429) bypass exponential backoff and use the
+            // delay the provider tells us to wait (Retry-After header, or 65s fallback).
+            // For all other transient errors keep normal exponential backoff.
+            const delayMs = this.isRateLimitError(error)
+                ? (extractRateLimitDelay(error) ?? RATE_LIMIT_FALLBACK_DELAY_MS)
+                : calculateRetryDelay(attempt, this.policy);
             this.emitRetry(attempt, maxAttempts, error, delayMs);
             // Wait before retrying
             await this.sleep(delayMs);
@@ -114,8 +118,12 @@ export class RetryableContentGenerator {
             if (!isRetryableError(error, this.policy)) {
                 throw error;
             }
-            // Calculate delay and emit retry event
-            const delayMs = calculateRetryDelay(attempt, this.policy);
+            // For rate-limit errors (429) bypass exponential backoff and use the
+            // delay the provider tells us to wait (Retry-After header, or 65s fallback).
+            // For all other transient errors keep normal exponential backoff.
+            const delayMs = this.isRateLimitError(error)
+                ? (extractRateLimitDelay(error) ?? RATE_LIMIT_FALLBACK_DELAY_MS)
+                : calculateRetryDelay(attempt, this.policy);
             this.emitRetry(attempt, maxAttempts, error, delayMs);
             // Wait before retrying
             await this.sleep(delayMs);
@@ -141,6 +149,22 @@ export class RetryableContentGenerator {
             message: `Retry attempt ${attempt}/${maxAttempts} after ${delayMs}ms: ${errorMessage}`,
         });
     }
+    /**
+     * Return true when the error is a rate-limit (HTTP 429) response.
+     *
+     * Checks both the numeric status code (most reliable) and the error
+     * message text as a fallback for providers that surface 429s differently.
+     */
+    isRateLimitError(error) {
+        if (!error || typeof error !== 'object')
+            return false;
+        const e = error;
+        const status = e.status ?? e.statusCode;
+        if (status === 429)
+            return true;
+        const msg = (error instanceof Error ? error.message : String(error)).toLowerCase();
+        return msg.includes('rate limit') || msg.includes('rate_limit');
+    }
     /**
      * Sleep for a specified duration.
      */

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

@@ -1,9 +1,8 @@
 export { LlmError, LlmGenerationError, LlmMaxIterationsError, LlmMissingToolExecutorError, LlmResponseParsingError, } from '../../core/domain/errors/llm-error.js';
 export type { ILLMService } from '../../core/interfaces/i-llm-service.js';
+export { AgentLLMService, type AgentLLMServiceConfig, type LLMServiceConfig } from './agent-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';