@illuma-ai/agents 1.1.21 → 1.1.23

package/src/llm/openai/utils/isReasoningModel.test.js

@@ -1,79 +0,0 @@
-import { isReasoningModel } from './index';
-describe('isReasoningModel', () => {
-    describe('should return true for reasoning models', () => {
-        test('basic o-series models', () => {
-            expect(isReasoningModel('o1')).toBe(true);
-            expect(isReasoningModel('o2')).toBe(true);
-            expect(isReasoningModel('o9')).toBe(true);
-            expect(isReasoningModel('o1-preview')).toBe(true);
-            expect(isReasoningModel('o1-mini')).toBe(true);
-        });
-        test('gpt-5+ models', () => {
-            expect(isReasoningModel('gpt-5')).toBe(true);
-            expect(isReasoningModel('gpt-6')).toBe(true);
-            expect(isReasoningModel('gpt-7')).toBe(true);
-            expect(isReasoningModel('gpt-8')).toBe(true);
-            expect(isReasoningModel('gpt-9')).toBe(true);
-        });
-        test('with provider prefixes', () => {
-            expect(isReasoningModel('azure/o1')).toBe(true);
-            expect(isReasoningModel('azure/gpt-5')).toBe(true);
-            expect(isReasoningModel('openai/o1')).toBe(true);
-            expect(isReasoningModel('openai/gpt-5')).toBe(true);
-        });
-        test('with custom prefixes', () => {
-            expect(isReasoningModel('custom-provider/o1')).toBe(true);
-            expect(isReasoningModel('my-deployment/gpt-5')).toBe(true);
-            expect(isReasoningModel('company/azure/gpt-5')).toBe(true);
-        });
-        test('case insensitive', () => {
-            expect(isReasoningModel('O1')).toBe(true);
-            expect(isReasoningModel('GPT-5')).toBe(true);
-            expect(isReasoningModel('gPt-6')).toBe(true);
-            expect(isReasoningModel('Azure/O1')).toBe(true);
-        });
-    });
-    describe('should return false for non-reasoning models', () => {
-        test('older GPT models', () => {
-            expect(isReasoningModel('gpt-3.5-turbo')).toBe(false);
-            expect(isReasoningModel('gpt-4')).toBe(false);
-            expect(isReasoningModel('gpt-4-turbo')).toBe(false);
-            expect(isReasoningModel('gpt-4o')).toBe(false);
-            expect(isReasoningModel('gpt-4o-mini')).toBe(false);
-        });
-        test('other model families', () => {
-            expect(isReasoningModel('claude-3')).toBe(false);
-            expect(isReasoningModel('claude-3-opus')).toBe(false);
-            expect(isReasoningModel('llama-2')).toBe(false);
-            expect(isReasoningModel('gemini-pro')).toBe(false);
-        });
-        test('partial matches that should not match', () => {
-            expect(isReasoningModel('proto1')).toBe(false);
-            expect(isReasoningModel('version-o1')).toBe(true);
-            expect(isReasoningModel('gpt-40')).toBe(false);
-            expect(isReasoningModel('gpt-3.5')).toBe(false);
-        });
-        test('empty, null, and undefined', () => {
-            expect(isReasoningModel('')).toBe(false);
-            expect(isReasoningModel()).toBe(false);
-            expect(isReasoningModel(undefined)).toBe(false);
-        });
-    });
-    describe('edge cases', () => {
-        test('with special characters', () => {
-            expect(isReasoningModel('deployment_o1_model')).toBe(false);
-            expect(isReasoningModel('gpt-5-deployment')).toBe(true);
-            expect(isReasoningModel('o1@latest')).toBe(true);
-            expect(isReasoningModel('gpt-5.0')).toBe(true);
-        });
-        test('word boundary behavior', () => {
-            // These should match because o1 and gpt-5 are whole words
-            expect(isReasoningModel('use-o1-model')).toBe(true);
-            expect(isReasoningModel('model-gpt-5-latest')).toBe(true);
-            // These should not match because o1/gpt-5 are not whole words
-            expect(isReasoningModel('proto1model')).toBe(false);
-            expect(isReasoningModel('supergpt-50')).toBe(false);
-        });
-    });
-});
-//# sourceMappingURL=isReasoningModel.test.js.map

package/src/llm/openrouter/index.js

@@ -1,261 +0,0 @@
-import { ChatOpenAI } from '@/llm/openai';
-import { ChatGenerationChunk } from '@langchain/core/outputs';
-import { AIMessageChunk as AIMessageChunkClass } from '@langchain/core/messages';
-import { _convertMessagesToOpenAIParams } from '@/llm/openai/utils';
-export class ChatOpenRouter extends ChatOpenAI {
-    openRouterReasoning;
-    /** @deprecated Use `reasoning` object instead */
-    includeReasoning;
-    constructor(_fields) {
-        const { include_reasoning, reasoning: openRouterReasoning, modelKwargs = {}, ...fields } = _fields;
-        // Extract reasoning from modelKwargs if provided there (e.g., from LLMConfig)
-        const { reasoning: mkReasoning, ...restModelKwargs } = modelKwargs;
-        super({
-            ...fields,
-            modelKwargs: restModelKwargs,
-        });
-        // Merge reasoning config: modelKwargs.reasoning < constructor reasoning
-        if (mkReasoning != null || openRouterReasoning != null) {
-            this.openRouterReasoning = {
-                ...mkReasoning,
-                ...openRouterReasoning,
-            };
-        }
-        this.includeReasoning = include_reasoning;
-    }
-    static lc_name() {
-        return 'IllumaOpenRouter';
-    }
-    // @ts-expect-error - OpenRouter reasoning extends OpenAI Reasoning with additional
-    // effort levels ('xhigh' | 'none' | 'minimal') not in ReasoningEffort.
-    // The parent's generic conditional return type cannot be widened in an override.
-    invocationParams(options, extra) {
-        const params = super.invocationParams(options, extra);
-        // Remove the OpenAI-native reasoning_effort that the parent sets;
-        // OpenRouter uses a `reasoning` object instead
-        delete params.reasoning_effort;
-        // Build the OpenRouter reasoning config
-        const reasoning = this.buildOpenRouterReasoning(options);
-        if (reasoning != null) {
-            params.reasoning = reasoning;
-        }
-        else {
-            delete params.reasoning;
-        }
-        return params;
-    }
-    buildOpenRouterReasoning(options) {
-        let reasoning;
-        // 1. Instance-level reasoning config (from constructor)
-        if (this.openRouterReasoning != null) {
-            reasoning = { ...this.openRouterReasoning };
-        }
-        // 2. LangChain-style reasoning params (from parent's `this.reasoning`)
-        const lcReasoning = this.getReasoningParams(options);
-        if (lcReasoning?.effort != null) {
-            reasoning = {
-                ...reasoning,
-                effort: lcReasoning.effort,
-            };
-        }
-        // 3. Call-level reasoning override
-        const callReasoning = options
-            ?.reasoning;
-        if (callReasoning != null) {
-            reasoning = { ...reasoning, ...callReasoning };
-        }
-        // 4. Legacy include_reasoning backward compatibility
-        if (reasoning == null && this.includeReasoning === true) {
-            reasoning = { enabled: true };
-        }
-        return reasoning;
-    }
-    _convertOpenAIDeltaToBaseMessageChunk(
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    delta, rawResponse, defaultRole) {
-        const messageChunk = super._convertOpenAIDeltaToBaseMessageChunk(delta, rawResponse, defaultRole);
-        if (delta.reasoning != null) {
-            messageChunk.additional_kwargs.reasoning = delta.reasoning;
-        }
-        if (delta.reasoning_details != null) {
-            messageChunk.additional_kwargs.reasoning_details =
-                delta.reasoning_details;
-        }
-        return messageChunk;
-    }
-    async *_streamResponseChunks2(messages, options, runManager) {
-        const messagesMapped = _convertMessagesToOpenAIParams(messages, this.model, {
-            includeReasoningDetails: true,
-            convertReasoningDetailsToContent: true,
-        });
-        const params = {
-            ...this.invocationParams(options, {
-                streaming: true,
-            }),
-            messages: messagesMapped,
-            stream: true,
-        };
-        let defaultRole;
-        const streamIterable = await this.completionWithRetry(params, options);
-        let usage;
-        // Store reasoning_details keyed by unique identifier to prevent incorrect merging
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const reasoningTextByIndex = new Map();
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const reasoningEncryptedById = new Map();
-        for await (const data of streamIterable) {
-            const choice = data.choices[0];
-            if (data.usage) {
-                usage = data.usage;
-            }
-            if (!choice) {
-                continue;
-            }
-            const { delta } = choice;
-            if (!delta) {
-                continue;
-            }
-            // Accumulate reasoning_details from each delta
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const deltaAny = delta;
-            // Extract current chunk's reasoning text for streaming (before accumulation)
-            let currentChunkReasoningText = '';
-            if (deltaAny.reasoning_details != null &&
-                Array.isArray(deltaAny.reasoning_details)) {
-                for (const detail of deltaAny.reasoning_details) {
-                    // For encrypted reasoning (thought signatures), store by ID - MUST be separate
-                    if (detail.type === 'reasoning.encrypted' && detail.id) {
-                        reasoningEncryptedById.set(detail.id, {
-                            type: detail.type,
-                            id: detail.id,
-                            data: detail.data,
-                            format: detail.format,
-                            index: detail.index,
-                        });
-                    }
-                    else if (detail.type === 'reasoning.text') {
-                        // Extract current chunk's text for streaming
-                        currentChunkReasoningText += detail.text || '';
-                        // For text reasoning, accumulate text by index for final message
-                        const idx = detail.index ?? 0;
-                        const existing = reasoningTextByIndex.get(idx);
-                        if (existing) {
-                            // Only append text, keep other fields from first entry
-                            existing.text = (existing.text || '') + (detail.text || '');
-                        }
-                        else {
-                            reasoningTextByIndex.set(idx, {
-                                type: detail.type,
-                                text: detail.text || '',
-                                format: detail.format,
-                                index: idx,
-                            });
-                        }
-                    }
-                }
-            }
-            const chunk = this._convertOpenAIDeltaToBaseMessageChunk(delta, data, defaultRole);
-            // For models that send reasoning_details (Gemini style) instead of reasoning (DeepSeek style),
-            // set the current chunk's reasoning text to additional_kwargs.reasoning for streaming
-            if (currentChunkReasoningText && !chunk.additional_kwargs.reasoning) {
-                chunk.additional_kwargs.reasoning = currentChunkReasoningText;
-            }
-            // IMPORTANT: Only set reasoning_details on the FINAL chunk to prevent
-            // LangChain's chunk concatenation from corrupting the array
-            // Check if this is the final chunk (has finish_reason)
-            if (choice.finish_reason != null) {
-                // Build properly structured reasoning_details array
-                // Text entries first (but we only need the encrypted ones for thought signatures)
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const finalReasoningDetails = [
-                    ...reasoningTextByIndex.values(),
-                    ...reasoningEncryptedById.values(),
-                ];
-                if (finalReasoningDetails.length > 0) {
-                    chunk.additional_kwargs.reasoning_details = finalReasoningDetails;
-                }
-            }
-            else {
-                // Clear reasoning_details from intermediate chunks to prevent concatenation issues
-                delete chunk.additional_kwargs.reasoning_details;
-            }
-            defaultRole = delta.role ?? defaultRole;
-            const newTokenIndices = {
-                prompt: options.promptIndex ?? 0,
-                completion: choice.index ?? 0,
-            };
-            if (typeof chunk.content !== 'string') {
-                // eslint-disable-next-line no-console
-                console.log('[WARNING]: Received non-string content from OpenAI. This is currently not supported.');
-                continue;
-            }
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const generationInfo = { ...newTokenIndices };
-            if (choice.finish_reason != null) {
-                generationInfo.finish_reason = choice.finish_reason;
-                generationInfo.system_fingerprint = data.system_fingerprint;
-                generationInfo.model_name = data.model;
-                generationInfo.service_tier = data.service_tier;
-            }
-            if (this.logprobs == true) {
-                generationInfo.logprobs = choice.logprobs;
-            }
-            const generationChunk = new ChatGenerationChunk({
-                message: chunk,
-                text: chunk.content,
-                generationInfo,
-            });
-            yield generationChunk;
-            if (this._lc_stream_delay != null) {
-                await new Promise((resolve) => setTimeout(resolve, this._lc_stream_delay));
-            }
-            await runManager?.handleLLMNewToken(generationChunk.text || '', newTokenIndices, undefined, undefined, undefined, { chunk: generationChunk });
-        }
-        if (usage) {
-            const inputTokenDetails = {
-                ...(usage.prompt_tokens_details?.audio_tokens != null && {
-                    audio: usage.prompt_tokens_details.audio_tokens,
-                }),
-                ...(usage.prompt_tokens_details?.cached_tokens != null && {
-                    cache_read: usage.prompt_tokens_details.cached_tokens,
-                }),
-            };
-            const outputTokenDetails = {
-                ...(usage.completion_tokens_details?.audio_tokens != null && {
-                    audio: usage.completion_tokens_details.audio_tokens,
-                }),
-                ...(usage.completion_tokens_details?.reasoning_tokens != null && {
-                    reasoning: usage.completion_tokens_details.reasoning_tokens,
-                }),
-            };
-            const generationChunk = new ChatGenerationChunk({
-                message: new AIMessageChunkClass({
-                    content: '',
-                    response_metadata: {
-                        usage: { ...usage },
-                    },
-                    usage_metadata: {
-                        input_tokens: usage.prompt_tokens,
-                        output_tokens: usage.completion_tokens,
-                        total_tokens: usage.total_tokens,
-                        ...(Object.keys(inputTokenDetails).length > 0 && {
-                            input_token_details: inputTokenDetails,
-                        }),
-                        ...(Object.keys(outputTokenDetails).length > 0 && {
-                            output_token_details: outputTokenDetails,
-                        }),
-                    },
-                }),
-                text: '',
-            });
-            yield generationChunk;
-            if (this._lc_stream_delay != null) {
-                await new Promise((resolve) => setTimeout(resolve, this._lc_stream_delay));
-            }
-        }
-        if (options.signal?.aborted === true) {
-            throw new Error('AbortError');
-        }
-    }
-}
-//# sourceMappingURL=index.js.map

package/src/llm/openrouter/reasoning.test.js

@@ -1,181 +0,0 @@
-import { ChatOpenRouter } from './index';
-function createRouter(overrides = {}) {
-    return new ChatOpenRouter({
-        model: 'openrouter/test-model',
-        apiKey: 'test-key',
-        ...overrides,
-    });
-}
-describe('ChatOpenRouter reasoning handling', () => {
-    // ---------------------------------------------------------------
-    // 1. Constructor reasoning config
-    // ---------------------------------------------------------------
-    describe('constructor reasoning config', () => {
-        it('stores reasoning when passed directly', () => {
-            const router = createRouter({ reasoning: { effort: 'high' } });
-            const params = router.invocationParams();
-            expect(params.reasoning).toEqual({ effort: 'high' });
-        });
-    });
-    // ---------------------------------------------------------------
-    // 2. modelKwargs reasoning extraction
-    // ---------------------------------------------------------------
-    describe('modelKwargs reasoning extraction', () => {
-        it('extracts reasoning from modelKwargs and places it into params.reasoning', () => {
-            const router = createRouter({
-                modelKwargs: { reasoning: { effort: 'medium' } },
-            });
-            const params = router.invocationParams();
-            expect(params.reasoning).toEqual({ effort: 'medium' });
-        });
-        it('does not leak reasoning into modelKwargs that reach the parent', () => {
-            const router = createRouter({
-                modelKwargs: {
-                    reasoning: { effort: 'medium' },
-                },
-            });
-            const params = router.invocationParams();
-            // reasoning should be the structured OpenRouter object, not buried in modelKwargs
-            expect(params.reasoning).toEqual({ effort: 'medium' });
-        });
-    });
-    // ---------------------------------------------------------------
-    // 3. Reasoning merge precedence
-    // ---------------------------------------------------------------
-    describe('reasoning merge precedence', () => {
-        it('constructor reasoning overrides modelKwargs.reasoning', () => {
-            const router = createRouter({
-                reasoning: { effort: 'high' },
-                modelKwargs: { reasoning: { effort: 'low' } },
-            });
-            const params = router.invocationParams();
-            expect(params.reasoning).toEqual({ effort: 'high' });
-        });
-        it('merges non-overlapping keys from modelKwargs.reasoning and constructor reasoning', () => {
-            const router = createRouter({
-                reasoning: { effort: 'high' },
-                modelKwargs: { reasoning: { max_tokens: 5000 } },
-            });
-            const params = router.invocationParams();
-            expect(params.reasoning).toEqual({ effort: 'high', max_tokens: 5000 });
-        });
-    });
-    // ---------------------------------------------------------------
-    // 4. invocationParams output
-    // ---------------------------------------------------------------
-    describe('invocationParams output', () => {
-        it('includes reasoning object in params', () => {
-            const router = createRouter({ reasoning: { effort: 'high' } });
-            const params = router.invocationParams();
-            expect(params.reasoning).toBeDefined();
-            expect(params.reasoning).toEqual({ effort: 'high' });
-        });
-        it('does NOT include reasoning_effort in params', () => {
-            const router = createRouter({ reasoning: { effort: 'high' } });
-            const params = router.invocationParams();
-            expect(params.reasoning_effort).toBeUndefined();
-        });
-        it('does not include reasoning when none is configured', () => {
-            const router = createRouter();
-            const params = router.invocationParams();
-            expect(params.reasoning).toBeUndefined();
-            expect(params.reasoning_effort).toBeUndefined();
-        });
-    });
-    // ---------------------------------------------------------------
-    // 5. Legacy include_reasoning
-    // ---------------------------------------------------------------
-    describe('legacy include_reasoning', () => {
-        it('produces { enabled: true } when only include_reasoning is true', () => {
-            const router = createRouter({ include_reasoning: true });
-            const params = router.invocationParams();
-            expect(params.reasoning).toEqual({ enabled: true });
-        });
-        it('does not produce reasoning when include_reasoning is false', () => {
-            const router = createRouter({ include_reasoning: false });
-            const params = router.invocationParams();
-            expect(params.reasoning).toBeUndefined();
-        });
-    });
-    // ---------------------------------------------------------------
-    // 6. Legacy include_reasoning ignored when reasoning is provided
-    // ---------------------------------------------------------------
-    describe('legacy include_reasoning ignored when reasoning provided', () => {
-        it('reasoning wins over include_reasoning', () => {
-            const router = createRouter({
-                reasoning: { effort: 'medium' },
-                include_reasoning: true,
-            });
-            const params = router.invocationParams();
-            // Should use the structured reasoning, NOT fall back to { enabled: true }
-            expect(params.reasoning).toEqual({ effort: 'medium' });
-        });
-        it('reasoning from modelKwargs also wins over include_reasoning', () => {
-            const router = createRouter({
-                modelKwargs: { reasoning: { effort: 'low' } },
-                include_reasoning: true,
-            });
-            const params = router.invocationParams();
-            expect(params.reasoning).toEqual({ effort: 'low' });
-        });
-    });
-    // ---------------------------------------------------------------
-    // 7. Various effort levels (OpenRouter-specific)
-    // ---------------------------------------------------------------
-    describe('various effort levels', () => {
-        const efforts = [
-            { effort: 'xhigh' },
-            { effort: 'none' },
-            { effort: 'minimal' },
-            { effort: 'high' },
-            { effort: 'medium' },
-            { effort: 'low' },
-        ];
-        it.each(efforts)('supports effort level "$effort"', ({ effort }) => {
-            const router = createRouter({ reasoning: { effort } });
-            const params = router.invocationParams();
-            expect(params.reasoning).toEqual({ effort });
-            expect(params.reasoning_effort).toBeUndefined();
-        });
-    });
-    // ---------------------------------------------------------------
-    // 8. max_tokens reasoning
-    // ---------------------------------------------------------------
-    describe('max_tokens reasoning', () => {
-        it('passes max_tokens in reasoning object', () => {
-            const router = createRouter({
-                reasoning: { max_tokens: 8000 },
-            });
-            const params = router.invocationParams();
-            expect(params.reasoning).toEqual({ max_tokens: 8000 });
-        });
-        it('combines max_tokens with effort', () => {
-            const router = createRouter({
-                reasoning: { effort: 'high', max_tokens: 8000 },
-            });
-            const params = router.invocationParams();
-            expect(params.reasoning).toEqual({ effort: 'high', max_tokens: 8000 });
-            expect(params.reasoning_effort).toBeUndefined();
-        });
-    });
-    // ---------------------------------------------------------------
-    // 9. exclude reasoning
-    // ---------------------------------------------------------------
-    describe('exclude reasoning', () => {
-        it('passes exclude flag in reasoning object', () => {
-            const router = createRouter({
-                reasoning: { effort: 'high', exclude: true },
-            });
-            const params = router.invocationParams();
-            expect(params.reasoning).toEqual({ effort: 'high', exclude: true });
-        });
-        it('supports exclude without effort', () => {
-            const router = createRouter({
-                reasoning: { exclude: true },
-            });
-            const params = router.invocationParams();
-            expect(params.reasoning).toEqual({ exclude: true });
-        });
-    });
-});
-//# sourceMappingURL=reasoning.test.js.map

package/src/llm/providers.js

@@ -1,36 +0,0 @@
-// src/llm/providers.ts
-import { ChatMistralAI } from '@langchain/mistralai';
-import { AzureChatOpenAI, ChatDeepSeek, ChatMoonshot, ChatOpenAI, ChatXAI, } from '@/llm/openai';
-import { CustomChatGoogleGenerativeAI } from '@/llm/google';
-import { CustomChatBedrockConverse } from '@/llm/bedrock';
-import { CustomAnthropic } from '@/llm/anthropic';
-import { ChatOpenRouter } from '@/llm/openrouter';
-import { ChatVertexAI } from '@/llm/vertexai';
-import { Providers } from '@/common';
-export const llmProviders = {
-    [Providers.XAI]: ChatXAI,
-    [Providers.OPENAI]: ChatOpenAI,
-    [Providers.AZURE]: AzureChatOpenAI,
-    [Providers.VERTEXAI]: ChatVertexAI,
-    [Providers.DEEPSEEK]: ChatDeepSeek,
-    [Providers.MISTRALAI]: ChatMistralAI,
-    [Providers.MISTRAL]: ChatMistralAI,
-    [Providers.ANTHROPIC]: CustomAnthropic,
-    [Providers.OPENROUTER]: ChatOpenRouter,
-    [Providers.BEDROCK]: CustomChatBedrockConverse,
-    // [Providers.ANTHROPIC]: ChatAnthropic,
-    [Providers.GOOGLE]: CustomChatGoogleGenerativeAI,
-    [Providers.MOONSHOT]: ChatMoonshot,
-};
-export const manualToolStreamProviders = new Set([
-    Providers.ANTHROPIC,
-    Providers.BEDROCK,
-]);
-export const getChatModelClass = (provider) => {
-    const ChatModelClass = llmProviders[provider];
-    if (!ChatModelClass) {
-        throw new Error(`Unsupported LLM provider: ${provider}`);
-    }
-    return ChatModelClass;
-};
-//# sourceMappingURL=providers.js.map

package/src/llm/text.js

@@ -1,65 +0,0 @@
-export class TextStream {
-    text;
-    currentIndex;
-    minChunkSize;
-    maxChunkSize;
-    delay;
-    firstWordChunk;
-    constructor(text, options = {}) {
-        this.text = text;
-        this.currentIndex = 0;
-        this.minChunkSize = options.minChunkSize ?? 4;
-        this.maxChunkSize = options.maxChunkSize ?? 8;
-        this.delay = options.delay ?? 20;
-        this.firstWordChunk = options.firstWordChunk ?? true;
-    }
-    randomInt(min, max) {
-        return Math.floor(Math.random() * (max - min)) + min;
-    }
-    static BOUNDARIES = new Set([
-        ' ',
-        '.',
-        ',',
-        '!',
-        '?',
-        ';',
-        ':',
-    ]);
-    findFirstWordBoundary(text, minSize) {
-        if (minSize >= text.length)
-            return text.length;
-        // Ensure we meet the minimum size first
-        let pos = minSize;
-        // Look forward until we find a boundary
-        while (pos < text.length) {
-            if (TextStream.BOUNDARIES.has(text[pos])) {
-                return pos + 1; // Include the boundary character
-            }
-            pos++;
-        }
-        return text.length; // If no boundary found, return entire remaining text
-    }
-    async *generateText(signal, progressCallback) {
-        const { delay, minChunkSize, maxChunkSize } = this;
-        while (this.currentIndex < this.text.length) {
-            if (signal?.aborted === true) {
-                break;
-            }
-            await new Promise((resolve) => setTimeout(resolve, delay));
-            const remainingText = this.text.slice(this.currentIndex);
-            let chunkSize;
-            if (this.firstWordChunk) {
-                chunkSize = this.findFirstWordBoundary(remainingText, minChunkSize);
-            }
-            else {
-                const remainingChars = remainingText.length;
-                chunkSize = Math.min(this.randomInt(minChunkSize, maxChunkSize + 1), remainingChars);
-            }
-            const chunk = this.text.slice(this.currentIndex, this.currentIndex + chunkSize);
-            progressCallback?.(chunk);
-            yield chunk;
-            this.currentIndex += chunkSize;
-        }
-    }
-}
-//# sourceMappingURL=text.js.map