byterover-cli 1.7.2 → 2.0.0

package/dist/agent/infra/llm/transformers/openrouter-stream-transformer.js

@@ -1,270 +0,0 @@
-/**
- * OpenRouter Stream Transformer
- *
- * Transforms OpenRouter/OpenAI streaming chunks (GenerateContentChunk)
- * into StreamEvent format compatible with StreamProcessor.
- *
- * This follows the OpenCode pattern of delta-based streaming events
- * for real-time UI updates.
- *
- * Supports multiple reasoning extraction methods:
- * 1. Native reasoning fields (OpenAI o1/o3, Grok, Gemini) - via rawChunk
- * 2. Pre-extracted reasoning (from content generator) - via chunk.reasoning
- * 3. <think> tags in content (Claude, DeepSeek, MiniMax) - via tag extraction
- *
- * Following OpenCode's extractReasoningMiddleware pattern.
- */
-import { getModelCapabilities } from '../model-capabilities.js';
-import { extractReasoning } from './reasoning-extractor.js';
-/**
- * Process text content to extract <think> tags and separate reasoning from text.
- * Returns events to emit based on the content analysis.
- *
- * @param content - Raw text content from chunk
- * @param state - Mutable state for tracking think tag parsing across chunks
- * @returns Array of StreamEvents to emit
- */
-function processContentForThinkTags(content, state) {
-    const events = [];
-    let remaining = content;
-    let textBuffer = '';
-    while (remaining.length > 0) {
-        if (state.insideThinkTag) {
-            // Look for closing </think> tag
-            const closeIndex = remaining.indexOf('</think>');
-            if (closeIndex === -1) {
-                // No closing tag yet - buffer everything
-                state.buffer += remaining;
-                remaining = '';
-            }
-            else {
-                // Found closing tag - emit buffered reasoning
-                const reasoningContent = state.buffer + remaining.slice(0, closeIndex);
-                if (reasoningContent) {
-                    events.push({ delta: reasoningContent, type: 'reasoning-delta' });
-                }
-                state.buffer = '';
-                state.insideThinkTag = false;
-                remaining = remaining.slice(closeIndex + 8); // Skip past </think>
-            }
-        }
-        else {
-            // Look for opening <think> tag
-            const openIndex = remaining.indexOf('<think>');
-            if (openIndex === -1) {
-                // No think tag - check for partial tag at end
-                // Look for potential start of <think> at the end
-                let partialTagLength = 0;
-                for (let i = 1; i <= Math.min(6, remaining.length); i++) {
-                    const suffix = remaining.slice(-i);
-                    if ('<think>'.startsWith(suffix)) {
-                        partialTagLength = i;
-                    }
-                }
-                if (partialTagLength > 0) {
-                    // Buffer the potential partial tag, emit the rest as text
-                    textBuffer += remaining.slice(0, -partialTagLength);
-                    state.buffer = remaining.slice(-partialTagLength);
-                }
-                else {
-                    textBuffer += remaining;
-                }
-                remaining = '';
-            }
-            else {
-                // Found opening tag - emit any text before it
-                const textBefore = remaining.slice(0, openIndex);
-                if (textBefore) {
-                    textBuffer += textBefore;
-                }
-                state.insideThinkTag = true;
-                state.buffer = '';
-                remaining = remaining.slice(openIndex + 7); // Skip past <think>
-            }
-        }
-    }
-    // Emit accumulated text content
-    if (textBuffer) {
-        events.push({ delta: textBuffer, type: 'text-delta' });
-    }
-    return events;
-}
-/**
- * Transform GenerateContentChunk stream into StreamEvent stream.
- *
- * Maps the chunk format from OpenRouterContentGenerator to the
- * StreamEvent format expected by StreamProcessor:
- *
- * - content (delta) → { type: 'text-delta', delta } or { type: 'reasoning-delta', delta }
- * - reasoning (native) → { type: 'reasoning-start/delta-v2/end' } (for OpenAI, Grok, Gemini)
- * - toolCalls → { type: 'tool-call-start' }, { type: 'tool-call-input' }
- * - finishReason → { type: 'step-finish', ... }
- * - isComplete → { type: 'finish' }
- *
- * Supports multiple reasoning extraction methods:
- * 1. Native reasoning fields (OpenAI o1/o3, Grok, Gemini) - checked first
- * 2. Pre-extracted reasoning from chunk.reasoning
- * 3. <think> tags in content (Claude, DeepSeek, MiniMax) - fallback
- *
- * @param chunks - Async generator of GenerateContentChunk from content generator
- * @param options - Transform options including modelId for capability detection
- * @yields StreamEvent objects for StreamProcessor
- */
-export async function* transformGenerateContentChunksToStreamEvents(chunks, options = {}) {
-    const { modelId = '', stepIndex = 0 } = options;
-    const capabilities = getModelCapabilities(modelId);
-    // Track tool calls that have been started
-    const startedToolCalls = new Set();
-    // State for think tag extraction (fallback for think-tags format)
-    const thinkState = {
-        buffer: '',
-        insideThinkTag: false,
-    };
-    // State for native reasoning tracking
-    let activeReasoningId;
-    let reasoningStarted = false;
-    // Emit step start
-    yield {
-        stepIndex,
-        type: 'step-start',
-    };
-    for await (const chunk of chunks) {
-        let reasoningHandled = false;
-        // Priority 1: Check for native reasoning in rawChunk (for models with native-field format)
-        if (capabilities.reasoningFormat === 'native-field' && chunk.rawChunk) {
-            const reasoningResult = extractReasoning(chunk.rawChunk, modelId);
-            if (reasoningResult.reasoning) {
-                reasoningHandled = true;
-                // Emit reasoning-start if this is the first reasoning chunk
-                if (!reasoningStarted && reasoningResult.reasoningId) {
-                    activeReasoningId = reasoningResult.reasoningId;
-                    reasoningStarted = true;
-                    yield {
-                        id: activeReasoningId,
-                        providerMetadata: reasoningResult.providerMetadata,
-                        type: 'reasoning-start',
-                    };
-                }
-                // Emit reasoning delta (using v2 format with ID tracking)
-                yield {
-                    delta: reasoningResult.reasoning,
-                    id: activeReasoningId ?? `reasoning-${Date.now()}`,
-                    providerMetadata: reasoningResult.providerMetadata,
-                    type: 'reasoning-delta-v2',
-                };
-            }
-            // Handle any text content extracted alongside reasoning
-            if (reasoningResult.content) {
-                yield { delta: reasoningResult.content, type: 'text-delta' };
-            }
-        }
-        // Priority 2: Check for pre-extracted reasoning in chunk (only if Priority 1 didn't handle it)
-        if (!reasoningHandled && chunk.reasoning) {
-            // Emit reasoning-start if this is the first reasoning chunk
-            if (!reasoningStarted) {
-                activeReasoningId = chunk.reasoningId ?? `reasoning-${Date.now()}`;
-                reasoningStarted = true;
-                yield {
-                    id: activeReasoningId,
-                    providerMetadata: chunk.providerMetadata,
-                    type: 'reasoning-start',
-                };
-            }
-            // Emit reasoning delta
-            yield {
-                delta: chunk.reasoning,
-                id: activeReasoningId ?? `reasoning-${Date.now()}`,
-                providerMetadata: chunk.providerMetadata,
-                type: 'reasoning-delta-v2',
-            };
-        }
-        // Priority 3: Handle text content - extract <think> tags for think-tags format
-        if (chunk.content) {
-            if (capabilities.reasoningFormat === 'think-tags') {
-                // Extract <think> tags for models that use them
-                const events = processContentForThinkTags(chunk.content, thinkState);
-                for (const event of events) {
-                    yield event;
-                }
-            }
-            else if (capabilities.reasoningFormat !== 'native-field') {
-                // For models without reasoning or already handled natively, emit as text
-                yield { delta: chunk.content, type: 'text-delta' };
-            }
-            else if (!chunk.rawChunk) {
-                // Native format but no rawChunk - fall back to think tag extraction
-                const events = processContentForThinkTags(chunk.content, thinkState);
-                for (const event of events) {
-                    yield event;
-                }
-            }
-        }
-        // Handle tool calls on final chunk
-        if (chunk.toolCalls && chunk.toolCalls.length > 0) {
-            for (const toolCall of chunk.toolCalls) {
-                const callId = toolCall.id;
-                // Emit tool-call-start if not already started
-                if (!startedToolCalls.has(callId)) {
-                    startedToolCalls.add(callId);
-                    yield {
-                        callId,
-                        toolName: toolCall.function.name,
-                        type: 'tool-call-start',
-                    };
-                }
-                // Emit tool-call-input with parsed arguments
-                try {
-                    const input = JSON.parse(toolCall.function.arguments);
-                    yield {
-                        callId,
-                        input,
-                        type: 'tool-call-input',
-                    };
-                }
-                catch {
-                    // If arguments can't be parsed, emit empty input
-                    yield {
-                        callId,
-                        input: {},
-                        type: 'tool-call-input',
-                    };
-                }
-            }
-        }
-        // Handle completion
-        if (chunk.isComplete) {
-            // Flush any remaining buffered content
-            if (thinkState.buffer) {
-                // Emit as reasoning if inside think tag, otherwise as text
-                yield thinkState.insideThinkTag
-                    ? { delta: thinkState.buffer, type: 'reasoning-delta' }
-                    : { delta: thinkState.buffer, type: 'text-delta' };
-                thinkState.buffer = '';
-            }
-            // Emit reasoning-end if we had active reasoning
-            if (reasoningStarted && activeReasoningId) {
-                yield {
-                    id: activeReasoningId,
-                    providerMetadata: chunk.providerMetadata,
-                    type: 'reasoning-end',
-                };
-            }
-            // Emit step finish with finish reason
-            const finishReason = chunk.finishReason === 'tool_calls' ? 'tool_calls' : chunk.finishReason === 'max_tokens' ? 'max_tokens' : 'stop';
-            yield {
-                cost: 0, // Cost calculated separately
-                finishReason,
-                stepIndex,
-                tokens: {
-                    input: 0, // Tokens updated after stream completes
-                    output: 0,
-                },
-                type: 'step-finish',
-            };
-            // Emit finish event
-            yield {
-                type: 'finish',
-            };
-        }
-    }
-}

package/dist/agent/infra/tools/implementations/bash-exec-tool.d.ts

@@ -1,13 +0,0 @@
-import type { Tool } from '../../../core/domain/tools/types.js';
-import type { IProcessService } from '../../../core/interfaces/i-process-service.js';
-/**
- * Create bash_exec tool.
- *
- * Executes shell commands with security validation and approval for dangerous commands.
- * Supports both foreground (wait for completion) and background (return immediately) execution.
- * When a metadata callback is provided, streams output updates in real-time.
- *
- * @param processService - Process service for command execution
- * @returns bash_exec tool instance
- */
-export declare function createBashExecTool(processService: IProcessService): Tool;

package/dist/agent/infra/tools/implementations/bash-exec-tool.js

@@ -1,110 +0,0 @@
-import { z } from 'zod';
-import { ToolName } from '../../../core/domain/tools/constants.js';
-/**
- * Input schema for bash_exec tool.
- */
-const BashExecInputSchema = z
-    .object({
-    /**
-     * Shell command to execute.
-     */
-    command: z.string().describe('Shell command to execute'),
-    /**
-     * Working directory for command execution (relative to configured base directory).
-     */
-    cwd: z.string().optional().describe('Working directory for command execution'),
-    /**
-     * Human-readable description of what the command does (5-10 words).
-     */
-    description: z.string().optional().describe('Description of what the command does (5-10 words)'),
-    /**
-     * Execute command in background (returns immediately with process handle).
-     */
-    runInBackground: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe('Execute command in background'),
-    /**
-     * Timeout in milliseconds (max: 600000, default: 300000 = 5 minutes).
-     */
-    timeout: z
-        .number()
-        .int()
-        .positive()
-        .max(600_000)
-        .optional()
-        .default(300_000)
-        .describe('Timeout in milliseconds (default: 5 minutes)'),
-})
-    .strict();
-/**
- * Create bash_exec tool.
- *
- * Executes shell commands with security validation and approval for dangerous commands.
- * Supports both foreground (wait for completion) and background (return immediately) execution.
- * When a metadata callback is provided, streams output updates in real-time.
- *
- * @param processService - Process service for command execution
- * @returns bash_exec tool instance
- */
-export function createBashExecTool(processService) {
-    return {
-        description: `Execute a shell command and return its output.`,
-        async execute(input, context) {
-            const { command, cwd, description, runInBackground, timeout } = input;
-            // Stream initial status via metadata callback if available
-            if (context?.metadata) {
-                context.metadata({
-                    description: description ?? `Executing: ${command.slice(0, 50)}${command.length > 50 ? '...' : ''}`,
-                    output: '',
-                    progress: 0,
-                });
-            }
-            // Execute command via process service
-            const result = await processService.executeCommand(command, {
-                cwd,
-                description,
-                runInBackground,
-                timeout,
-            });
-            // Return based on execution mode
-            if ('stdout' in result) {
-                // Stream final output via metadata callback if available
-                if (context?.metadata) {
-                    context.metadata({
-                        description: description ?? 'Command completed',
-                        output: result.stdout + (result.stderr ? `\n[stderr]\n${result.stderr}` : ''),
-                        progress: 100,
-                    });
-                }
-                // Foreground execution result
-                return {
-                    duration: result.duration,
-                    exitCode: result.exitCode,
-                    stderr: result.stderr,
-                    stdout: result.stdout,
-                };
-            }
-            // Stream background process info via metadata callback if available
-            if (context?.metadata) {
-                context.metadata({
-                    description: `Background process started: ${result.processId}`,
-                    output: `Process started with PID ${result.pid}`,
-                    progress: 100,
-                });
-            }
-            // Background execution handle
-            return {
-                command: result.command,
-                description: result.description,
-                message: `Process started in background. Use bash_output with processId="${result.processId}" to retrieve output.`,
-                pid: result.pid,
-                processId: result.processId,
-                startedAt: result.startedAt.toISOString(),
-            };
-        },
-        id: ToolName.BASH_EXEC,
-        inputSchema: BashExecInputSchema,
-    };
-}

package/dist/agent/infra/tools/implementations/bash-output-tool.d.ts

@@ -1,12 +0,0 @@
-import type { Tool } from '../../../core/domain/tools/types.js';
-import type { IProcessService } from '../../../core/interfaces/i-process-service.js';
-/**
- * Create bash_output tool.
- *
- * Retrieves output from a background process started by bash_exec.
- * Reading output clears the buffer (destructive read), so output is only returned once.
- *
- * @param processService - Process service for retrieving output
- * @returns bash_output tool instance
- */
-export declare function createBashOutputTool(processService: IProcessService): Tool;

package/dist/agent/infra/tools/implementations/bash-output-tool.js

@@ -1,43 +0,0 @@
-import { z } from 'zod';
-import { ToolName } from '../../../core/domain/tools/constants.js';
-/**
- * Input schema for bash_output tool.
- */
-const BashOutputInputSchema = z
-    .object({
-    /**
-     * Unique process identifier from bash_exec.
-     */
-    processId: z.string().describe('Unique process identifier from bash_exec'),
-})
-    .strict();
-/**
- * Create bash_output tool.
- *
- * Retrieves output from a background process started by bash_exec.
- * Reading output clears the buffer (destructive read), so output is only returned once.
- *
- * @param processService - Process service for retrieving output
- * @returns bash_output tool instance
- */
-export function createBashOutputTool(processService) {
-    return {
-        description: `Retrieve output from a background process started by bash_exec.`,
-        async execute(input, _context) {
-            const { processId } = input;
-            // Get output from process service
-            const output = await processService.getProcessOutput(processId);
-            // Return output with status
-            return {
-                duration: output.duration,
-                exitCode: output.exitCode,
-                processId,
-                status: output.status,
-                stderr: output.stderr,
-                stdout: output.stdout,
-            };
-        },
-        id: ToolName.BASH_OUTPUT,
-        inputSchema: BashOutputInputSchema,
-    };
-}

package/dist/agent/infra/tools/implementations/batch-tool.d.ts

@@ -1,12 +0,0 @@
-import type { Tool } from '../../../core/domain/tools/types.js';
-import type { ToolProviderGetter } from '../tool-provider-getter.js';
-/**
- * Create batch tool.
- *
- * Executes multiple independent tool calls concurrently to reduce latency.
- * Best used for gathering context (reads, searches, listings).
- *
- * @param getToolProvider - Lazy getter for tool provider (avoids circular dependency)
- * @returns batch tool instance
- */
-export declare function createBatchTool(getToolProvider: ToolProviderGetter): Tool;

package/dist/agent/infra/tools/implementations/batch-tool.js

@@ -1,142 +0,0 @@
-import { z } from 'zod';
-import { ToolName } from '../../../core/domain/tools/constants.js';
-/**
- * Tools that are not allowed in batch execution.
- * - batch: No nesting of batch calls
- * - edit_file: Sequential edits for proper conflict handling
- * - write_todos: Lightweight, call directly
- */
-const DISALLOWED_TOOLS = new Set(['batch', 'edit_file', 'write_todos']);
-/**
- * Maximum number of tool calls allowed in a single batch.
- */
-const MAX_BATCH_SIZE = 10;
-/**
- * Input schema for batch tool.
- */
-const BatchInputSchema = z
-    .object({
-    /**
-     * Array of tool calls to execute in parallel.
-     */
-    toolCalls: z
-        .array(z.object({
-        /**
-         * Parameters for the tool.
-         */
-        parameters: z.record(z.unknown()).describe('Parameters for the tool'),
-        /**
-         * The name of the tool to execute.
-         */
-        tool: z.string().describe('The name of the tool to execute'),
-    }))
-        .min(1, 'Provide at least one tool call')
-        .describe('Array of tool calls to execute in parallel'),
-})
-    .strict();
-/**
- * Create batch tool.
- *
- * Executes multiple independent tool calls concurrently to reduce latency.
- * Best used for gathering context (reads, searches, listings).
- *
- * @param getToolProvider - Lazy getter for tool provider (avoids circular dependency)
- * @returns batch tool instance
- */
-export function createBatchTool(getToolProvider) {
-    return {
-        description: 'Execute multiple independent tool calls concurrently.',
-        async execute(input, context) {
-            const { toolCalls } = input;
-            const toolProvider = getToolProvider();
-            // Limit to MAX_BATCH_SIZE
-            const activeCalls = toolCalls.slice(0, MAX_BATCH_SIZE);
-            const discardedCalls = toolCalls.slice(MAX_BATCH_SIZE);
-            /**
-             * Execute a single tool call and return the result.
-             */
-            const executeCall = async (call) => {
-                const startTime = Date.now();
-                // Check if tool is disallowed in batch
-                if (DISALLOWED_TOOLS.has(call.tool)) {
-                    return {
-                        durationMs: Date.now() - startTime,
-                        error: `Tool '${call.tool}' is not allowed in batch. Disallowed tools: ${[...DISALLOWED_TOOLS].join(', ')}`,
-                        success: false,
-                        tool: call.tool,
-                    };
-                }
-                // Check if tool exists
-                if (!toolProvider.hasTool(call.tool)) {
-                    const availableTools = toolProvider.getToolNames().filter((name) => !DISALLOWED_TOOLS.has(name));
-                    return {
-                        durationMs: Date.now() - startTime,
-                        error: `Tool '${call.tool}' not found. Available tools: ${availableTools.join(', ')}`,
-                        success: false,
-                        tool: call.tool,
-                    };
-                }
-                try {
-                    const result = await toolProvider.executeTool(call.tool, call.parameters, context?.sessionId, context);
-                    return {
-                        durationMs: Date.now() - startTime,
-                        result,
-                        success: true,
-                        tool: call.tool,
-                    };
-                }
-                catch (error) {
-                    return {
-                        durationMs: Date.now() - startTime,
-                        error: error instanceof Error ? error.message : String(error),
-                        success: false,
-                        tool: call.tool,
-                    };
-                }
-            };
-            // Execute all calls in parallel
-            const results = await Promise.all(activeCalls.map((call) => executeCall(call)));
-            // Add discarded calls as errors
-            for (const call of discardedCalls) {
-                results.push({
-                    durationMs: 0,
-                    error: `Maximum of ${MAX_BATCH_SIZE} tools allowed in batch`,
-                    success: false,
-                    tool: call.tool,
-                });
-            }
-            const successful = results.filter((r) => r.success).length;
-            const failed = results.length - successful;
-            // Stream progress update
-            if (context?.metadata) {
-                context.metadata({
-                    description: 'Batch execution complete',
-                    output: `${successful}/${results.length} tools executed successfully`,
-                    progress: 100,
-                });
-            }
-            // Build output message
-            const outputMessage = failed > 0
-                ? `Executed ${successful}/${results.length} tools successfully. ${failed} failed.`
-                : `All ${successful} tools executed successfully.\n\nKeep using the batch tool for optimal performance!`;
-            return {
-                metadata: {
-                    details: results.map((r) => ({ success: r.success, tool: r.tool })),
-                    failed,
-                    successful,
-                    tools: toolCalls.map((c) => c.tool),
-                    totalCalls: results.length,
-                },
-                results: results.map((r) => ({
-                    durationMs: r.durationMs,
-                    success: r.success,
-                    tool: r.tool,
-                    ...(r.success ? { result: r.result } : { error: r.error }),
-                })),
-                summary: outputMessage,
-            };
-        },
-        id: ToolName.BATCH,
-        inputSchema: BatchInputSchema,
-    };
-}

package/dist/agent/infra/tools/implementations/create-knowledge-topic-tool.d.ts

@@ -1,11 +0,0 @@
-import type { Tool } from '../../../core/domain/tools/types.js';
-/**
- * Creates the create knowledge topic tool.
- *
- * Creates organized knowledge topics within domain folders, where each topic and subtopic
- * has its own folder containing a context.md file with relevant snippets. This tool should
- * be used after detecting domains to organize the extracted knowledge into a structured hierarchy.
- *
- * @returns Configured create knowledge topic tool
- */
-export declare function createCreateKnowledgeTopicTool(): Tool;