byterover-cli 1.3.0 → 1.5.0

package/dist/infra/cipher/file-system/pdf-extractor.d.ts

@@ -0,0 +1,100 @@
+import type { PdfMetadata, PdfPageContent } from '../../../core/domain/cipher/file-system/types.js';
+/**
+ * Options for PDF text extraction.
+ */
+export interface PdfExtractOptions {
+    /** Maximum number of pages to extract (default: 100, max: 200) */
+    limit?: number;
+    /** Starting page number (1-based, default: 1) */
+    offset?: number;
+}
+/**
+ * Result of PDF text extraction.
+ */
+export interface PdfExtractResult {
+    /** Whether there are more pages available after this extraction */
+    hasMore: boolean;
+    /** PDF metadata (page count, title, author, etc.) */
+    metadata: PdfMetadata;
+    /** Extracted page contents */
+    pages: PdfPageContent[];
+}
+/**
+ * PDF text extraction and metadata extraction utility.
+ * Provides page-by-page extraction with pagination support.
+ *
+ * Features:
+ * - Magic byte validation
+ * - Fast metadata-only extraction
+ * - Page-by-page text extraction with offset/limit
+ * - Default: 100 pages, max: 200 pages per extraction
+ */
+export declare class PdfExtractor {
+    /**
+     * Extracts metadata from a PDF buffer without extracting text.
+     * This is a fast path when you only need page count, title, author, etc.
+     *
+     * @param buffer - PDF file buffer
+     * @param filePath - Path to the PDF file (for error messages)
+     * @returns PDF metadata
+     */
+    static extractMetadata(buffer: Buffer, filePath: string): Promise<PdfMetadata>;
+    /**
+     * Extracts text from a PDF buffer with pagination support.
+     *
+     * @param buffer - PDF file buffer
+     * @param filePath - Path to the PDF file (for error messages)
+     * @param options - Extraction options (offset, limit)
+     * @returns Extraction result with pages, metadata, and continuation info
+     */
+    static extractText(buffer: Buffer, filePath: string, options?: PdfExtractOptions): Promise<PdfExtractResult>;
+    /**
+     * Checks if a buffer contains valid PDF magic bytes.
+     * @param buffer - Buffer to check
+     * @returns true if buffer starts with %PDF-
+     */
+    static isValidPdf(buffer: Buffer): boolean;
+    /**
+     * Builds PdfMetadata from unpdf meta info object.
+     * @param pageCount - Total number of pages
+     * @param info - Optional info object from unpdf getMeta
+     * @returns PdfMetadata object
+     */
+    private static buildMetadataFromInfo;
+    /**
+     * Extracts text from specific pages of a PDF document.
+     * Uses PDF.js page-level API for efficient extraction of page ranges.
+     *
+     * @param pdf - PDF document proxy from unpdf
+     * @param startPage - Starting page number (1-based)
+     * @param endPage - Ending page number (1-based, inclusive)
+     * @returns Array of PdfPageContent with extracted text
+     */
+    private static extractPagesFromDocument;
+    /**
+     * Extracts a meaningful error message from an unknown error.
+     */
+    private static getExtractionErrorMessage;
+    /**
+     * Parses PDF date string format (D:YYYYMMDDHHmmSS) to Date object.
+     * @param dateStr - PDF date string
+     * @returns Parsed Date or undefined if invalid
+     */
+    private static parsePdfDate;
+    /**
+     * Wraps extraction errors with appropriate PdfExtractionError.
+     * @param error - The caught error
+     * @param filePath - Path to the PDF file
+     * @returns PdfExtractionError with appropriate message
+     */
+    private static wrapExtractionError;
+}
+/**
+ * Formats extracted PDF pages into a readable string with page separators.
+ * @param pages - Array of extracted page contents
+ * @param metadata - PDF metadata
+ * @param hasMore - Whether there are more pages
+ * @param nextOffset - Next offset for continuation (if hasMore is true)
+ * @returns Formatted string with page separators
+ */
+export declare function formatPdfContent(pages: PdfPageContent[], metadata: PdfMetadata, hasMore: boolean, nextOffset: number): string;

package/dist/infra/cipher/file-system/pdf-extractor.js

@@ -0,0 +1,226 @@
+import { getDocumentProxy, getMeta } from 'unpdf';
+import { PdfExtractionError } from '../../../core/domain/cipher/errors/file-system-error.js';
+/**
+ * PDF magic bytes: %PDF-
+ */
+const PDF_MAGIC_BYTES = [0x25, 0x50, 0x44, 0x46, 0x2d];
+/**
+ * Default number of pages to extract when no limit specified.
+ */
+const DEFAULT_PAGE_LIMIT = 100;
+/**
+ * Maximum number of pages allowed per extraction.
+ */
+const MAX_PAGE_LIMIT = 200;
+/**
+ * PDF text extraction and metadata extraction utility.
+ * Provides page-by-page extraction with pagination support.
+ *
+ * Features:
+ * - Magic byte validation
+ * - Fast metadata-only extraction
+ * - Page-by-page text extraction with offset/limit
+ * - Default: 100 pages, max: 200 pages per extraction
+ */
+export class PdfExtractor {
+    /**
+     * Extracts metadata from a PDF buffer without extracting text.
+     * This is a fast path when you only need page count, title, author, etc.
+     *
+     * @param buffer - PDF file buffer
+     * @param filePath - Path to the PDF file (for error messages)
+     * @returns PDF metadata
+     */
+    static async extractMetadata(buffer, filePath) {
+        try {
+            const pdf = await getDocumentProxy(new Uint8Array(buffer));
+            const meta = await getMeta(pdf);
+            return PdfExtractor.buildMetadataFromInfo(pdf.numPages, meta.info);
+        }
+        catch (error) {
+            throw PdfExtractor.wrapExtractionError(error, filePath);
+        }
+    }
+    /**
+     * Extracts text from a PDF buffer with pagination support.
+     *
+     * @param buffer - PDF file buffer
+     * @param filePath - Path to the PDF file (for error messages)
+     * @param options - Extraction options (offset, limit)
+     * @returns Extraction result with pages, metadata, and continuation info
+     */
+    static async extractText(buffer, filePath, options = {}) {
+        // Validate PDF magic bytes
+        if (!PdfExtractor.isValidPdf(buffer)) {
+            throw new PdfExtractionError(filePath, 'Invalid PDF file format (missing PDF header)');
+        }
+        try {
+            const pdf = await getDocumentProxy(new Uint8Array(buffer));
+            const meta = await getMeta(pdf);
+            const totalPages = pdf.numPages;
+            const metaInfo = meta.info;
+            // Calculate pagination
+            const offset = Math.max(1, options.offset ?? 1);
+            const limit = Math.min(options.limit ?? DEFAULT_PAGE_LIMIT, MAX_PAGE_LIMIT);
+            // Return empty result if offset is beyond total pages
+            if (offset > totalPages) {
+                return {
+                    hasMore: false,
+                    metadata: PdfExtractor.buildMetadataFromInfo(totalPages, metaInfo),
+                    pages: [],
+                };
+            }
+            // Calculate page range
+            const endPage = Math.min(offset + limit - 1, totalPages);
+            // Extract text only from requested pages using PDF.js page-level API
+            const pages = await PdfExtractor.extractPagesFromDocument(pdf, offset, endPage);
+            return {
+                hasMore: endPage < totalPages,
+                metadata: PdfExtractor.buildMetadataFromInfo(totalPages, metaInfo),
+                pages,
+            };
+        }
+        catch (error) {
+            throw PdfExtractor.wrapExtractionError(error, filePath);
+        }
+    }
+    /**
+     * Checks if a buffer contains valid PDF magic bytes.
+     * @param buffer - Buffer to check
+     * @returns true if buffer starts with %PDF-
+     */
+    static isValidPdf(buffer) {
+        if (buffer.length < PDF_MAGIC_BYTES.length) {
+            return false;
+        }
+        for (const [index, byte] of PDF_MAGIC_BYTES.entries()) {
+            if (buffer[index] !== byte) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Builds PdfMetadata from unpdf meta info object.
+     * @param pageCount - Total number of pages
+     * @param info - Optional info object from unpdf getMeta
+     * @returns PdfMetadata object
+     */
+    static buildMetadataFromInfo(pageCount, info) {
+        const metadata = { pageCount };
+        if (!info) {
+            return metadata;
+        }
+        if (typeof info.Title === 'string' && info.Title.trim()) {
+            metadata.title = info.Title.trim();
+        }
+        if (typeof info.Author === 'string' && info.Author.trim()) {
+            metadata.author = info.Author.trim();
+        }
+        if (info.CreationDate) {
+            const parsed = PdfExtractor.parsePdfDate(info.CreationDate);
+            if (parsed) {
+                metadata.creationDate = parsed;
+            }
+        }
+        return metadata;
+    }
+    /**
+     * Extracts text from specific pages of a PDF document.
+     * Uses PDF.js page-level API for efficient extraction of page ranges.
+     *
+     * @param pdf - PDF document proxy from unpdf
+     * @param startPage - Starting page number (1-based)
+     * @param endPage - Ending page number (1-based, inclusive)
+     * @returns Array of PdfPageContent with extracted text
+     */
+    static async extractPagesFromDocument(pdf, startPage, endPage) {
+        // Build array of page numbers to extract
+        const pageNumbers = [];
+        for (let pageNum = startPage; pageNum <= endPage; pageNum++) {
+            pageNumbers.push(pageNum);
+        }
+        // Extract all requested pages in parallel
+        const pages = await Promise.all(pageNumbers.map(async (pageNum) => {
+            const page = await pdf.getPage(pageNum);
+            const textContent = await page.getTextContent();
+            // Extract text from text items, handling EOL markers
+            // TextContent.items contains TextItem and TextMarkedContent - we only want TextItem (has 'str')
+            const text = textContent.items
+                .filter((item) => typeof item === 'object' && item !== null && 'str' in item)
+                .map((item) => item.str + (item.hasEOL ? '\n' : ''))
+                .join('');
+            return {
+                pageNumber: pageNum,
+                text: text.trim(),
+            };
+        }));
+        return pages;
+    }
+    /**
+     * Extracts a meaningful error message from an unknown error.
+     */
+    static getExtractionErrorMessage(error) {
+        if (error instanceof Error) {
+            return error.message;
+        }
+        if (typeof error === 'string') {
+            return error;
+        }
+        return 'Unknown PDF extraction error';
+    }
+    /**
+     * Parses PDF date string format (D:YYYYMMDDHHmmSS) to Date object.
+     * @param dateStr - PDF date string
+     * @returns Parsed Date or undefined if invalid
+     */
+    static parsePdfDate(dateStr) {
+        if (!dateStr) {
+            return undefined;
+        }
+        // PDF date format: D:YYYYMMDDHHmmSS+HH'mm' or variations
+        const match = dateStr.match(/D:(\d{4})(\d{2})?(\d{2})?(\d{2})?(\d{2})?(\d{2})?/);
+        if (!match) {
+            return undefined;
+        }
+        const year = Number.parseInt(match[1], 10);
+        const month = match[2] ? Number.parseInt(match[2], 10) - 1 : 0;
+        const day = match[3] ? Number.parseInt(match[3], 10) : 1;
+        const hour = match[4] ? Number.parseInt(match[4], 10) : 0;
+        const minute = match[5] ? Number.parseInt(match[5], 10) : 0;
+        const second = match[6] ? Number.parseInt(match[6], 10) : 0;
+        return new Date(year, month, day, hour, minute, second);
+    }
+    /**
+     * Wraps extraction errors with appropriate PdfExtractionError.
+     * @param error - The caught error
+     * @param filePath - Path to the PDF file
+     * @returns PdfExtractionError with appropriate message
+     */
+    static wrapExtractionError(error, filePath) {
+        const errorMessage = PdfExtractor.getExtractionErrorMessage(error);
+        const lowerMessage = errorMessage.toLowerCase();
+        if (lowerMessage.includes('password') || lowerMessage.includes('encrypted')) {
+            return new PdfExtractionError(filePath, 'PDF is password-protected or encrypted');
+        }
+        return new PdfExtractionError(filePath, errorMessage);
+    }
+}
+/**
+ * Formats extracted PDF pages into a readable string with page separators.
+ * @param pages - Array of extracted page contents
+ * @param metadata - PDF metadata
+ * @param hasMore - Whether there are more pages
+ * @param nextOffset - Next offset for continuation (if hasMore is true)
+ * @returns Formatted string with page separators
+ */
+export function formatPdfContent(pages, metadata, hasMore, nextOffset) {
+    if (pages.length === 0) {
+        return '';
+    }
+    const formattedPages = pages.map((page) => `--- Page ${page.pageNumber} ---\n${page.text}`).join('\n\n');
+    const truncationNote = hasMore
+        ? `\n\n(PDF has more pages. Use offset=${nextOffset} to continue)`
+        : `\n\n(End of PDF - ${metadata.pageCount} pages)`;
+    return formattedPages + truncationNote;
+}

package/dist/infra/cipher/http/internal-llm-http-service.d.ts

@@ -1,6 +1,7 @@
 import type { RequestOptions } from '@anthropic-ai/sdk/internal/request-options';
 import type { MessageCreateParamsNonStreaming } from '@anthropic-ai/sdk/resources/messages.js';
 import type { Content, GenerateContentConfig, GenerateContentResponse } from '@google/genai';
+import type { GenerateContentChunk } from '../../../core/interfaces/cipher/i-content-generator.js';
 /**
  * ByteRover HTTP LLM provider configuration.
  */
@@ -61,6 +62,22 @@ export declare class ByteRoverLlmHttpService {
      * @returns Response in GenerateContentResponse format
      */
     generateContent(contents: Content[] | MessageCreateParamsNonStreaming, config: GenerateContentConfig | RequestOptions, model: string, executionMetadata?: Record<string, unknown>): Promise<GenerateContentResponse>;
+    /**
+     * 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
+     */
+    generateContentStream(contents: Content[] | MessageCreateParamsNonStreaming, config: GenerateContentConfig | RequestOptions, model: string, executionMetadata?: Record<string, unknown>): AsyncGenerator<GenerateContentChunk>;
     /**
      * Call the ByteRover REST Generate endpoint.
      *
@@ -91,4 +108,27 @@ export declare class ByteRoverLlmHttpService {
      * @returns GCP region identifier ('us-east5' or 'global')
      */
     private detectRegionFromModel;
+    /**
+     * 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
+     */
+    private extractContentFromResponse;
+    /**
+     * 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
+     */
+    private extractThinkingFromResponse;
+    /**
+     * Map provider finish reason to standard format.
+     */
+    private mapFinishReason;
 }

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

@@ -1,4 +1,6 @@
+import { StreamChunkType } from '../../../core/interfaces/cipher/i-content-generator.js';
 import { AuthenticatedHttpClient } from '../../http/authenticated-http-client.js';
+import { ThoughtParser } from '../llm/thought-parser.js';
 /**
  * ByteRover HTTP LLM API client.
  *
@@ -72,6 +74,30 @@ export class ByteRoverLlmHttpService {
         };
         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.
      *
@@ -84,10 +110,10 @@ export class ByteRoverLlmHttpService {
     async callHttpGenerate(request) {
         const url = `${this.config.apiBaseUrl}/api/llm/generate`;
         const httpClient = new AuthenticatedHttpClient(this.config.accessToken, this.config.sessionKey);
-        const response = await httpClient.post(url, request, {
+        const httpResponse = await httpClient.post(url, request, {
             timeout: this.config.timeout,
         });
-        return response.data;
+        return httpResponse.data;
     }
     /**
      * Detect LLM provider from model identifier.
@@ -113,4 +139,128 @@ export class ByteRoverLlmHttpService {
     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/infra/cipher/llm/formatters/gemini-formatter.js

@@ -72,8 +72,14 @@ export class GeminiMessageFormatter {
         }
         const textParts = [];
         const functionCallsWithSignatures = [];
-        // Extract text and function calls from response parts
+        let thoughtText;
+        // Extract text, thoughts, and function calls from response parts
         for (const part of candidate.content.parts) {
+            // Check for thought parts first (Gemini 2.5+ with includeThoughts: true)
+            if ('thought' in part && part.thought === true && 'text' in part && part.text) {
+                thoughtText = part.text;
+                continue; // Don't add thought to textParts
+            }
             if ('text' in part && part.text) {
                 textParts.push(part.text);
             }
@@ -102,6 +108,7 @@ export class GeminiMessageFormatter {
             {
                 content: textParts.join('') || null,
                 role: 'assistant',
+                thought: thoughtText,
                 toolCalls,
             },
         ];

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

@@ -60,9 +60,8 @@ export declare class ByteRoverContentGenerator implements IContentGenerator {
     /**
      * Generate content with streaming.
      *
-     * Note: The current gRPC service collects all chunks before returning.
-     * This implementation yields the complete response as a single chunk.
-     * True streaming can be implemented when the gRPC service exposes the stream.
+     * Uses the HTTP service's streaming endpoint to yield chunks as they arrive.
+     * Handles both regular content and thinking/reasoning parts from Gemini models.
      *
      * @param request - Generation request
      * @yields Content chunks as they are generated

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

@@ -117,24 +117,33 @@ export class ByteRoverContentGenerator {
     /**
      * Generate content with streaming.
      *
-     * Note: The current gRPC service collects all chunks before returning.
-     * This implementation yields the complete response as a single chunk.
-     * True streaming can be implemented when the gRPC service exposes the stream.
+     * Uses the HTTP service's streaming endpoint to yield chunks as they arrive.
+     * Handles both regular content and thinking/reasoning parts from Gemini models.
      *
      * @param request - Generation request
      * @yields Content chunks as they are generated
      * @returns Async generator yielding content chunks
      */
     async *generateContentStream(request) {
-        // For now, use non-streaming and yield complete response
-        // True streaming can be added when gRPC service exposes the stream
-        const response = await this.generateContent(request);
-        yield {
-            content: response.content,
-            finishReason: response.finishReason,
-            isComplete: true,
-            toolCalls: response.toolCalls,
+        // Format messages for provider
+        let formattedMessages = this.formatter.format(request.contents);
+        // For Gemini 3+ models, ensure function calls in the active loop have thought signatures
+        if (this.providerType === 'gemini') {
+            formattedMessages = ensureActiveLoopHasThoughtSignatures(formattedMessages, this.config.model);
+        }
+        // Build generation config
+        const genConfig = this.buildGenerationConfig(request.tools ?? {}, request.systemPrompt ?? '', formattedMessages);
+        // Build execution metadata from request
+        const executionMetadata = {
+            sessionId: request.taskId,
+            taskId: request.taskId,
+            ...(request.executionContext && { executionContext: request.executionContext }),
         };
+        // Determine contents and config based on provider
+        const contents = this.providerType === 'claude' ? genConfig : formattedMessages;
+        const config = this.providerType === 'claude' ? {} : genConfig;
+        // Stream from HTTP service
+        yield* this.httpService.generateContentStream(contents, config, this.config.model, executionMetadata);
     }
     /**
      * Build Claude-specific generation configuration.

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

@@ -64,6 +64,7 @@ export declare class OpenRouterContentGenerator implements IContentGenerator {
      * Generate content with streaming.
      *
      * Uses OpenAI SDK's native streaming support for real-time content generation.
+     * Includes rawChunk for native reasoning extraction by the stream transformer.
      *
      * @param request - Generation request
      * @yields Content chunks as they are generated