"use strict";
/**
 * Streaming response support for RuvLLM
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.StreamingGenerator = void 0;
exports.createReadableStream = createReadableStream;
/**
 * Async generator for streaming responses
 *
 * @example
 * ```typescript
 * import { RuvLLM, StreamingGenerator } from '@ruvector/ruvllm';
 *
 * const llm = new RuvLLM();
 * const streamer = new StreamingGenerator(llm);
 *
 * // Stream with async iterator
 * for await (const chunk of streamer.stream('Write a story')) {
 *   process.stdout.write(chunk.text);
 * }
 *
 * // Stream with callbacks
 * await streamer.streamWithCallbacks('Write a poem', {
 *   onChunk: (chunk) => console.log(chunk.text),
 *   onComplete: (response) => console.log('Done!', response.latencyMs),
 * });
 * ```
 */
class StreamingGenerator {
    constructor(llm) {
        this.llm = llm;
    }
    /**
     * Stream response as async generator
     *
     * Note: This simulates streaming by chunking the full response.
     * Native streaming requires native module support.
     */
    async *stream(prompt, config) {
        const start = Date.now();
        // Generate full response (native streaming would yield real chunks)
        const fullText = this.llm.generate(prompt, config);
        // Simulate streaming by yielding words
        const words = fullText.split(/(\s+)/);
        let accumulated = '';
        let tokenCount = 0;
        for (let i = 0; i < words.length; i++) {
            accumulated += words[i];
            tokenCount++;
            // Yield every few tokens or at end
            if (tokenCount % 3 === 0 || i === words.length - 1) {
                yield {
                    text: words.slice(Math.max(0, i - 2), i + 1).join(''),
                    done: i === words.length - 1,
                    tokenCount,
                    latencyMs: Date.now() - start,
                };
                // Small delay to simulate streaming
                await this.delay(10);
            }
        }
    }
    /**
     * Stream with callback handlers
     */
    async streamWithCallbacks(prompt, options) {
        const start = Date.now();
        let fullText = '';
        let tokenCount = 0;
        try {
            for await (const chunk of this.stream(prompt, options)) {
                fullText += chunk.text;
                tokenCount = chunk.tokenCount;
                if (options.onChunk) {
                    options.onChunk(chunk);
                }
            }
            const response = {
                text: fullText.trim(),
                confidence: 0.8,
                model: 'streaming',
                contextSize: tokenCount,
                latencyMs: Date.now() - start,
                requestId: `stream-${Date.now()}-${Math.random().toString(36).slice(2)}`,
            };
            if (options.onComplete) {
                options.onComplete(response);
            }
            return response;
        }
        catch (error) {
            if (options.onError) {
                options.onError(error);
            }
            throw error;
        }
    }
    /**
     * Collect stream into single response
     */
    async collect(prompt, config) {
        let result = '';
        for await (const chunk of this.stream(prompt, config)) {
            result = chunk.text; // Each chunk is cumulative
        }
        return result.trim();
    }
    delay(ms) {
        return new Promise(resolve => setTimeout(resolve, ms));
    }
}
exports.StreamingGenerator = StreamingGenerator;
/**
 * Create a readable stream from response
 * (For Node.js stream compatibility)
 */
function createReadableStream(generator) {
    return new ReadableStream({
        async pull(controller) {
            const { value, done } = await generator.next();
            if (done) {
                controller.close();
            }
            else {
                controller.enqueue(value.text);
            }
        },
    });
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"streaming.js","sourceRoot":"","sources":["../../src/streaming.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Streaming response support for RuvLLM\n */\n\nimport {\n  StreamChunk,\n  StreamOptions,\n  QueryResponse,\n  GenerationConfig,\n} from './types';\n\n/**\n * Async generator for streaming responses\n *\n * @example\n * ```typescript\n * import { RuvLLM, StreamingGenerator } from '@ruvector/ruvllm';\n *\n * const llm = new RuvLLM();\n * const streamer = new StreamingGenerator(llm);\n *\n * // Stream with async iterator\n * for await (const chunk of streamer.stream('Write a story')) {\n *   process.stdout.write(chunk.text);\n * }\n *\n * // Stream with callbacks\n * await streamer.streamWithCallbacks('Write a poem', {\n *   onChunk: (chunk) => console.log(chunk.text),\n *   onComplete: (response) => console.log('Done!', response.latencyMs),\n * });\n * ```\n */\nexport class StreamingGenerator {\n  private llm: {\n    generate: (prompt: string, config?: GenerationConfig) => string;\n    query: (text: string, config?: GenerationConfig) => QueryResponse;\n  };\n\n  constructor(llm: {\n    generate: (prompt: string, config?: GenerationConfig) => string;\n    query: (text: string, config?: GenerationConfig) => QueryResponse;\n  }) {\n    this.llm = llm;\n  }\n\n  /**\n   * Stream response as async generator\n   *\n   * Note: This simulates streaming by chunking the full response.\n   * Native streaming requires native module support.\n   */\n  async *stream(\n    prompt: string,\n    config?: GenerationConfig\n  ): AsyncGenerator<StreamChunk> {\n    const start = Date.now();\n\n    // Generate full response (native streaming would yield real chunks)\n    const fullText = this.llm.generate(prompt, config);\n\n    // Simulate streaming by yielding words\n    const words = fullText.split(/(\\s+)/);\n    let accumulated = '';\n    let tokenCount = 0;\n\n    for (let i = 0; i < words.length; i++) {\n      accumulated += words[i];\n      tokenCount++;\n\n      // Yield every few tokens or at end\n      if (tokenCount % 3 === 0 || i === words.length - 1) {\n        yield {\n          text: words.slice(Math.max(0, i - 2), i + 1).join(''),\n          done: i === words.length - 1,\n          tokenCount,\n          latencyMs: Date.now() - start,\n        };\n\n        // Small delay to simulate streaming\n        await this.delay(10);\n      }\n    }\n  }\n\n  /**\n   * Stream with callback handlers\n   */\n  async streamWithCallbacks(\n    prompt: string,\n    options: StreamOptions\n  ): Promise<QueryResponse> {\n    const start = Date.now();\n    let fullText = '';\n    let tokenCount = 0;\n\n    try {\n      for await (const chunk of this.stream(prompt, options)) {\n        fullText += chunk.text;\n        tokenCount = chunk.tokenCount;\n\n        if (options.onChunk) {\n          options.onChunk(chunk);\n        }\n      }\n\n      const response: QueryResponse = {\n        text: fullText.trim(),\n        confidence: 0.8,\n        model: 'streaming',\n        contextSize: tokenCount,\n        latencyMs: Date.now() - start,\n        requestId: `stream-${Date.now()}-${Math.random().toString(36).slice(2)}`,\n      };\n\n      if (options.onComplete) {\n        options.onComplete(response);\n      }\n\n      return response;\n    } catch (error) {\n      if (options.onError) {\n        options.onError(error as Error);\n      }\n      throw error;\n    }\n  }\n\n  /**\n   * Collect stream into single response\n   */\n  async collect(prompt: string, config?: GenerationConfig): Promise<string> {\n    let result = '';\n    for await (const chunk of this.stream(prompt, config)) {\n      result = chunk.text; // Each chunk is cumulative\n    }\n    return result.trim();\n  }\n\n  private delay(ms: number): Promise<void> {\n    return new Promise(resolve => setTimeout(resolve, ms));\n  }\n}\n\n/**\n * Create a readable stream from response\n * (For Node.js stream compatibility)\n */\nexport function createReadableStream(\n  generator: AsyncGenerator<StreamChunk>\n): ReadableStream<string> {\n  return new ReadableStream({\n    async pull(controller) {\n      const { value, done } = await generator.next();\n      if (done) {\n        controller.close();\n      } else {\n        controller.enqueue(value.text);\n      }\n    },\n  });\n}\n"]}