@illuma-ai/agents 1.1.20 → 1.1.22

package/src/graphs/handoffValidation.test.js

@@ -1,276 +0,0 @@
-/**
- * Unit tests for MultiAgentGraph handoff validation and pre-handoff compaction.
- *
- * These tests exercise the handoff logic (destination validation, compaction threshold,
- * briefing generation, error formatting) without instantiating the full MultiAgentGraph.
- * We test the helper functions directly and verify the behavioral patterns that
- * the graph's agent node closure relies on.
- */
-import { HumanMessage, AIMessage, SystemMessage, ToolMessage, } from '@langchain/core/messages';
-import { summarize, createEmergencySummary, buildFullSummaryPrompt, formatMessagesForSummary, } from '@/messages';
-// ---------------------------------------------------------------------------
-// 1. Handoff destination validation logic
-// ---------------------------------------------------------------------------
-describe('handoff destination validation', () => {
-    it('detects non-existent agent in contexts map', () => {
-        const agentContexts = new Map([
-            ['agent-a', { agentId: 'agent-a', name: 'Agent A' }],
-            ['agent-b', { agentId: 'agent-b', name: 'Agent B' }],
-        ]);
-        const handoffDest = 'agent-c';
-        expect(agentContexts.has(handoffDest)).toBe(false);
-        const availableAgents = Array.from(agentContexts.keys()).join(', ');
-        expect(availableAgents).toBe('agent-a, agent-b');
-    });
-    it('passes validation for existing agent', () => {
-        const agentContexts = new Map([
-            ['agent-a', { agentId: 'agent-a', name: 'Agent A' }],
-        ]);
-        expect(agentContexts.has('agent-a')).toBe(true);
-    });
-    it('handles empty contexts map', () => {
-        const agentContexts = new Map();
-        expect(agentContexts.has('any-agent')).toBe(false);
-        const availableAgents = Array.from(agentContexts.keys()).join(', ');
-        expect(availableAgents).toBe('');
-    });
-});
-// ---------------------------------------------------------------------------
-// 2. Pre-handoff compaction threshold
-// ---------------------------------------------------------------------------
-describe('pre-handoff compaction threshold', () => {
-    it('triggers compaction when context exceeds 70% of receiver budget', () => {
-        const receiverBudget = 100000;
-        const currentSize = 75000; // 75%
-        expect(currentSize > receiverBudget * 0.7).toBe(true);
-    });
-    it('skips compaction when context fits within 70% of receiver budget', () => {
-        const receiverBudget = 100000;
-        const currentSize = 60000; // 60%
-        expect(currentSize > receiverBudget * 0.7).toBe(false);
-    });
-    it('triggers compaction at exactly the boundary (>70%)', () => {
-        const receiverBudget = 100000;
-        // Exactly 70% should NOT trigger (condition is strictly >)
-        expect(70000 > receiverBudget * 0.7).toBe(false);
-        // Just above 70% should trigger
-        expect(70001 > receiverBudget * 0.7).toBe(true);
-    });
-    it('computes summary budget as 20% of receiver budget', () => {
-        const receiverBudget = 100000;
-        const summaryBudget = Math.floor(receiverBudget * 0.2);
-        expect(summaryBudget).toBe(20000);
-    });
-});
-// ---------------------------------------------------------------------------
-// 3. Handoff briefing via summarize (multi-agent aware)
-// ---------------------------------------------------------------------------
-describe('handoff briefing generation', () => {
-    it('generates multi-agent aware briefing', async () => {
-        const messages = [
-            new HumanMessage('Analyze the data'),
-            new AIMessage('I found 3 key patterns...'),
-            new HumanMessage('Can you elaborate on pattern 2?'),
-            new AIMessage('Pattern 2 shows...'),
-        ];
-        const callback = jest.fn().mockResolvedValue('## 5. Agent Workflow State\n- Agent A analyzed data and found 3 patterns');
-        const result = await summarize(messages, callback, {
-            isMultiAgent: true,
-            agentWorkflowState: {
-                currentAgentId: 'agent-b',
-                agentChain: ['agent-a', 'agent-b'],
-                pendingAgents: [],
-            },
-            summaryBudget: 2000,
-        });
-        // Without a tokenCounter the budget check is skipped, so full tier is returned
-        expect(result.tier).toBe('full');
-        expect(result.summary).toContain('Agent Workflow State');
-        // Verify callback was called with the full prompt containing agent workflow info
-        expect(callback).toHaveBeenCalledWith(expect.stringContaining('Agent Workflow State'), expect.any(Number));
-    });
-    it('includes agent chain in the prompt', () => {
-        const conversation = formatMessagesForSummary([
-            new HumanMessage('Hello'),
-        ]);
-        const prompt = buildFullSummaryPrompt(conversation, {
-            isMultiAgent: true,
-            agentWorkflowState: {
-                currentAgentId: 'agent-b',
-                agentChain: ['agent-a', 'agent-b'],
-                pendingAgents: ['agent-c'],
-            },
-        });
-        expect(prompt).toContain('Current agent: agent-b');
-        expect(prompt).toContain('Agent chain: agent-a -> agent-b');
-        expect(prompt).toContain('Pending agents: agent-c');
-    });
-    it('shows N/A for single-agent conversations', () => {
-        const conversation = formatMessagesForSummary([
-            new HumanMessage('Hello'),
-        ]);
-        const prompt = buildFullSummaryPrompt(conversation);
-        expect(prompt).toContain('N/A (single-agent conversation)');
-    });
-});
-// ---------------------------------------------------------------------------
-// 4. Emergency briefing fallback
-// ---------------------------------------------------------------------------
-describe('emergency briefing fallback', () => {
-    it('generates briefing without LLM when callback fails', async () => {
-        const messages = [
-            new HumanMessage('Analyze this'),
-            new AIMessage('Here is the analysis...'),
-        ];
-        const failingCallback = jest.fn().mockRejectedValue(new Error('LLM timeout'));
-        const result = await summarize(messages, failingCallback);
-        expect(result.tier).toBe('emergency');
-        expect(result.summary).toContain('[Emergency Context Summary]');
-        expect(result.summary).toContain('Analyze this');
-    });
-    it('falls to emergency when both full and simple callbacks fail', async () => {
-        let callCount = 0;
-        const failingCallback = jest.fn().mockImplementation(() => {
-            callCount++;
-            throw new Error(`Failure #${callCount}`);
-        });
-        const messages = [
-            new HumanMessage('Do something'),
-            new AIMessage('Working on it...'),
-            new ToolMessage({ content: 'result', tool_call_id: 'tc-1', name: 'search' }),
-        ];
-        const result = await summarize(messages, failingCallback);
-        expect(result.tier).toBe('emergency');
-        expect(result.summary).toContain('Do something');
-        expect(result.summary).toContain('Working on it...');
-        expect(result.summary).toContain('search');
-        expect(result.messagesCompacted).toBe(3);
-    });
-    it('createEmergencySummary captures first user message and last AI message', () => {
-        const messages = [
-            new HumanMessage('First user message'),
-            new AIMessage('First AI response'),
-            new HumanMessage('Second user message'),
-            new AIMessage('Second AI response'),
-        ];
-        const summary = createEmergencySummary(messages);
-        expect(summary).toContain('[Emergency Context Summary]');
-        expect(summary).toContain('Original request: First user message');
-        expect(summary).toContain('Last response: Second AI response');
-        expect(summary).toContain('Tools used: none');
-        expect(summary).toContain('Messages compacted: 4');
-    });
-    it('createEmergencySummary collects unique tool names', () => {
-        const messages = [
-            new HumanMessage('Test'),
-            new ToolMessage({ content: 'ok', tool_call_id: 'tc-1', name: 'search' }),
-            new ToolMessage({ content: 'ok', tool_call_id: 'tc-2', name: 'search' }),
-            new ToolMessage({ content: 'ok', tool_call_id: 'tc-3', name: 'calculator' }),
-        ];
-        const summary = createEmergencySummary(messages);
-        expect(summary).toContain('search');
-        expect(summary).toContain('calculator');
-    });
-});
-// ---------------------------------------------------------------------------
-// 5. Handoff error ToolMessage format
-// ---------------------------------------------------------------------------
-describe('handoff error message format', () => {
-    it('creates properly formatted error ToolMessage', () => {
-        const availableAgents = 'agent-a, agent-b, agent-c';
-        const handoffDest = 'nonexistent-agent';
-        const errorMsg = new ToolMessage({
-            content: `Transfer failed: agent "${handoffDest}" does not exist. Available agents: ${availableAgents}. Please choose a valid agent to transfer to.`,
-            tool_call_id: 'call-123',
-            name: `transfer_to_${handoffDest}`,
-        });
-        expect(errorMsg.content).toContain('does not exist');
-        expect(errorMsg.content).toContain(availableAgents);
-        expect(errorMsg.tool_call_id).toBe('call-123');
-        expect(errorMsg.name).toBe('transfer_to_nonexistent-agent');
-    });
-    it('error message includes all available agents', () => {
-        const agentContexts = new Map([
-            ['alpha', {}],
-            ['beta', {}],
-            ['gamma', {}],
-        ]);
-        const availableAgents = Array.from(agentContexts.keys()).join(', ');
-        const errorMsg = new ToolMessage({
-            content: `Transfer failed: agent "delta" does not exist. Available agents: ${availableAgents}. Please choose a valid agent to transfer to.`,
-            tool_call_id: 'call-456',
-            name: 'lc_transfer_to_delta',
-        });
-        expect(errorMsg.content).toContain('alpha, beta, gamma');
-        expect(errorMsg.getType()).toBe('tool');
-    });
-});
-// ---------------------------------------------------------------------------
-// 6. Compacted handoff message structure
-// ---------------------------------------------------------------------------
-describe('compacted handoff message structure', () => {
-    it('keeps briefing + last 3 messages', () => {
-        const originalMessages = [
-            new HumanMessage('msg 1'),
-            new AIMessage('msg 2'),
-            new HumanMessage('msg 3'),
-            new AIMessage('msg 4'),
-            new HumanMessage('msg 5'),
-            new AIMessage('msg 6'),
-        ];
-        const briefingMsg = new SystemMessage('[Handoff Briefing]\nAgent A completed analysis');
-        const keepCount = Math.min(3, originalMessages.length);
-        const compacted = [
-            briefingMsg,
-            ...originalMessages.slice(originalMessages.length - keepCount),
-        ];
-        expect(compacted).toHaveLength(4); // briefing + 3 messages
-        expect(compacted[0].getType()).toBe('system');
-        expect(compacted[0].content).toContain('Handoff Briefing');
-        expect(compacted[3].getType()).toBe('ai'); // last message preserved
-    });
-    it('keeps all messages when fewer than 3 remain', () => {
-        const originalMessages = [
-            new HumanMessage('only message'),
-            new AIMessage('only response'),
-        ];
-        const briefingMsg = new SystemMessage('[Handoff Briefing]\nBriefing text');
-        const keepCount = Math.min(3, originalMessages.length);
-        const compacted = [
-            briefingMsg,
-            ...originalMessages.slice(originalMessages.length - keepCount),
-        ];
-        // briefing + 2 original messages
-        expect(compacted).toHaveLength(3);
-        expect(compacted[1].content).toBe('only message');
-        expect(compacted[2].content).toBe('only response');
-    });
-    it('preserves the handoff tool message as the last message', () => {
-        const originalMessages = [
-            new HumanMessage('do X'),
-            new AIMessage('calling agent-b'),
-            new ToolMessage({
-                content: 'Transferred to agent-b',
-                tool_call_id: 'tc-handoff',
-                name: 'lc_transfer_to_agent-b',
-            }),
-        ];
-        const briefingMsg = new SystemMessage('[Handoff Briefing]\nContext');
-        const keepCount = Math.min(3, originalMessages.length);
-        const compacted = [
-            briefingMsg,
-            ...originalMessages.slice(originalMessages.length - keepCount),
-        ];
-        const lastMsg = compacted[compacted.length - 1];
-        expect(lastMsg.getType()).toBe('tool');
-        expect(lastMsg.name).toContain('lc_transfer_to_');
-    });
-    it('briefing contains sender name in the expected format', () => {
-        const senderName = 'Research Agent';
-        const summaryText = 'User asked about market trends. Found 5 data points.';
-        const briefingMsg = new SystemMessage(`[Handoff Briefing from "${senderName}"]\n${summaryText}`);
-        expect(briefingMsg.content).toContain(`Handoff Briefing from "Research Agent"`);
-        expect(briefingMsg.content).toContain(summaryText);
-    });
-});
-//# sourceMappingURL=handoffValidation.test.js.map

package/src/graphs/index.js

@@ -1,3 +0,0 @@
-export * from './Graph';
-export * from './MultiAgentGraph';
-//# sourceMappingURL=index.js.map

package/src/index.js

@@ -1,28 +0,0 @@
-/* Main Operations */
-export * from './run';
-export * from './stream';
-export * from './splitStream';
-export * from './events';
-export * from './messages';
-/* Graphs */
-export * from './graphs';
-/* Tools */
-export * from './tools/Calculator';
-export * from './tools/CodeExecutor';
-export * from './tools/BrowserTools';
-export * from './tools/ProgrammaticToolCalling';
-export * from './tools/ToolSearch';
-export * from './tools/ToolNode';
-export * from './tools/schema';
-export * from './tools/handlers';
-export * from './tools/search';
-/* Schemas */
-export * from './schemas';
-/* Misc. */
-export * from './common';
-export * from './utils';
-/* LLM */
-export { CustomOpenAIClient } from './llm/openai';
-export { ChatOpenRouter } from './llm/openrouter';
-export { getChatModelClass, llmProviders } from './llm/providers';
-//# sourceMappingURL=index.js.map

package/src/instrumentation.js

@@ -1,21 +0,0 @@
-import { NodeSDK } from '@opentelemetry/sdk-node';
-import { IllumaSpanProcessor } from '@illuma-ai/observability-otel';
-import { isPresent } from '@/utils/misc';
-// Support both ILLUMA_* and LANGFUSE_* env vars for backwards compatibility
-const secretKey = process.env.ILLUMA_SECRET_KEY ?? process.env.LANGFUSE_SECRET_KEY;
-const publicKey = process.env.ILLUMA_PUBLIC_KEY ?? process.env.LANGFUSE_PUBLIC_KEY;
-const baseUrl = process.env.ILLUMA_BASE_URL ?? process.env.LANGFUSE_BASE_URL;
-const environment = process.env.ILLUMA_ENVIRONMENT ?? process.env.LANGFUSE_TRACING_ENVIRONMENT ?? process.env.NODE_ENV ?? 'development';
-if (isPresent(secretKey) && isPresent(publicKey) && isPresent(baseUrl)) {
-    const spanProcessor = new IllumaSpanProcessor({
-        publicKey,
-        secretKey,
-        baseUrl,
-        environment,
-    });
-    const sdk = new NodeSDK({
-        spanProcessors: [spanProcessor],
-    });
-    sdk.start();
-}
-//# sourceMappingURL=instrumentation.js.map

package/src/llm/anthropic/index.js

@@ -1,319 +0,0 @@
-import { AIMessageChunk } from '@langchain/core/messages';
-import { ChatAnthropicMessages } from '@langchain/anthropic';
-import { ChatGenerationChunk } from '@langchain/core/outputs';
-import { _makeMessageChunkFromAnthropicEvent } from './utils/message_outputs';
-import { _convertMessagesToAnthropicPayload } from './utils/message_inputs';
-import { handleToolChoice } from './utils/tools';
-import { TextStream } from '@/llm/text';
-function _toolsInParams(params) {
-    return !!(params.tools && params.tools.length > 0);
-}
-function _documentsInParams(params) {
-    for (const message of params.messages ?? []) {
-        if (typeof message.content === 'string') {
-            continue;
-        }
-        for (const block of message.content ?? []) {
-            if (typeof block === 'object' &&
-                block != null &&
-                block.type === 'document' &&
-                block.citations != null &&
-                typeof block.citations === 'object' &&
-                block.citations.enabled) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-function _thinkingInParams(params) {
-    return !!(params.thinking &&
-        (params.thinking.type === 'enabled' || params.thinking.type === 'adaptive'));
-}
-function _compactionInParams(params) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const cm = params.context_management;
-    return !!cm?.edits?.some((e) => e.type === 'compact_20260112');
-}
-function extractToken(chunk) {
-    if (typeof chunk.content === 'string') {
-        return [chunk.content, 'string'];
-    }
-    else if (Array.isArray(chunk.content) &&
-        chunk.content.length >= 1 &&
-        'input' in chunk.content[0]) {
-        return typeof chunk.content[0].input === 'string'
-            ? [chunk.content[0].input, 'input']
-            : [JSON.stringify(chunk.content[0].input), 'input'];
-    }
-    else if (Array.isArray(chunk.content) &&
-        chunk.content.length >= 1 &&
-        'text' in chunk.content[0]) {
-        return [chunk.content[0].text, 'content'];
-    }
-    else if (Array.isArray(chunk.content) &&
-        chunk.content.length >= 1 &&
-        'thinking' in chunk.content[0]) {
-        return [chunk.content[0].thinking, 'content'];
-    }
-    return [undefined];
-}
-function cloneChunk(text, tokenType, chunk) {
-    if (tokenType === 'string') {
-        return new AIMessageChunk(Object.assign({}, chunk, { content: text }));
-    }
-    else if (tokenType === 'input') {
-        return chunk;
-    }
-    const content = chunk.content[0];
-    if (tokenType === 'content' && content.type === 'text') {
-        return new AIMessageChunk(Object.assign({}, chunk, {
-            content: [Object.assign({}, content, { text })],
-        }));
-    }
-    else if (tokenType === 'content' && content.type === 'text_delta') {
-        return new AIMessageChunk(Object.assign({}, chunk, {
-            content: [Object.assign({}, content, { text })],
-        }));
-    }
-    else if (tokenType === 'content' && content.type?.startsWith('thinking')) {
-        return new AIMessageChunk(Object.assign({}, chunk, {
-            content: [Object.assign({}, content, { thinking: text })],
-        }));
-    }
-    return chunk;
-}
-export class CustomAnthropic extends ChatAnthropicMessages {
-    _lc_stream_delay;
-    message_start;
-    message_delta;
-    tools_in_params;
-    emitted_usage;
-    top_k;
-    outputConfig;
-    inferenceGeo;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    contextManagement;
-    constructor(fields) {
-        super(fields);
-        this.resetTokenEvents();
-        this.setDirectFields(fields);
-        this._lc_stream_delay = fields?._lc_stream_delay ?? 25;
-        this.outputConfig = fields?.outputConfig;
-        this.inferenceGeo = fields?.inferenceGeo;
-        this.contextManagement = fields?.contextManagement;
-    }
-    static lc_name() {
-        return 'IllumaAnthropic';
-    }
-    /**
-     * Get the parameters used to invoke the model
-     */
-    invocationParams(options) {
-        const tool_choice = handleToolChoice(options?.tool_choice);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const callOptions = options;
-        const mergedOutputConfig = (() => {
-            const base = {
-                ...this.outputConfig,
-                ...callOptions?.outputConfig,
-            };
-            if (callOptions?.outputFormat && !base.format) {
-                base.format = callOptions.outputFormat;
-            }
-            return Object.keys(base).length > 0 ? base : undefined;
-        })();
-        const inferenceGeo = callOptions?.inferenceGeo ?? this.inferenceGeo;
-        const contextManagement = this.contextManagement;
-        const sharedParams = {
-            tools: this.formatStructuredToolToAnthropic(options?.tools),
-            tool_choice,
-            thinking: this.thinking,
-            ...(mergedOutputConfig ? { output_config: mergedOutputConfig } : {}),
-            ...(inferenceGeo ? { inference_geo: inferenceGeo } : {}),
-            ...(contextManagement ? { context_management: contextManagement } : {}),
-            ...this.invocationKwargs,
-        };
-        if (this.thinking.type === 'enabled' || this.thinking.type === 'adaptive') {
-            if (this.top_k !== -1 && this.top_k != null) {
-                throw new Error('topK is not supported when thinking is enabled');
-            }
-            if (this.topP !== -1 && this.topP != null) {
-                throw new Error('topP is not supported when thinking is enabled');
-            }
-            if (this.temperature !== 1 &&
-                this.temperature != null) {
-                throw new Error('temperature is not supported when thinking is enabled');
-            }
-            return {
-                model: this.model,
-                stop_sequences: options?.stop ?? this.stopSequences,
-                stream: this.streaming,
-                max_tokens: this.maxTokens,
-                ...sharedParams,
-            };
-        }
-        return {
-            model: this.model,
-            temperature: this.temperature,
-            top_k: this.top_k,
-            top_p: this.topP,
-            stop_sequences: options?.stop ?? this.stopSequences,
-            stream: this.streaming,
-            max_tokens: this.maxTokens,
-            ...sharedParams,
-        };
-    }
-    /**
-     * Get stream usage as returned by this client's API response.
-     * @returns The stream usage object.
-     */
-    getStreamUsage() {
-        if (this.emitted_usage === true) {
-            return;
-        }
-        const inputUsage = this.message_start?.message.usage;
-        const outputUsage = this.message_delta?.usage;
-        if (!outputUsage) {
-            return;
-        }
-        const totalUsage = {
-            input_tokens: inputUsage?.input_tokens ?? 0,
-            output_tokens: outputUsage.output_tokens ?? 0,
-            total_tokens: (inputUsage?.input_tokens ?? 0) + (outputUsage.output_tokens ?? 0),
-        };
-        if (inputUsage?.cache_creation_input_tokens != null ||
-            inputUsage?.cache_read_input_tokens != null) {
-            totalUsage.input_token_details = {
-                cache_creation: inputUsage.cache_creation_input_tokens ?? 0,
-                cache_read: inputUsage.cache_read_input_tokens ?? 0,
-            };
-        }
-        this.emitted_usage = true;
-        return totalUsage;
-    }
-    resetTokenEvents() {
-        this.message_start = undefined;
-        this.message_delta = undefined;
-        this.emitted_usage = undefined;
-        this.tools_in_params = undefined;
-    }
-    setDirectFields(fields) {
-        this.temperature = fields?.temperature ?? undefined;
-        this.topP = fields?.topP ?? undefined;
-        this.top_k = fields?.topK;
-        if (this.temperature === -1 || this.temperature === 1) {
-            this.temperature = undefined;
-        }
-        if (this.topP === -1) {
-            this.topP = undefined;
-        }
-        if (this.top_k === -1) {
-            this.top_k = undefined;
-        }
-    }
-    createGenerationChunk({ token, chunk, usageMetadata, shouldStreamUsage, }) {
-        const usage_metadata = shouldStreamUsage
-            ? (usageMetadata ?? chunk.usage_metadata)
-            : undefined;
-        return new ChatGenerationChunk({
-            message: new AIMessageChunk({
-                // Just yield chunk as it is and tool_use will be concat by BaseChatModel._generateUncached().
-                content: chunk.content,
-                additional_kwargs: chunk.additional_kwargs,
-                tool_call_chunks: chunk.tool_call_chunks,
-                response_metadata: chunk.response_metadata,
-                usage_metadata,
-                id: chunk.id,
-            }),
-            text: token ?? '',
-        });
-    }
-    async *_streamResponseChunks(messages, options, runManager) {
-        this.resetTokenEvents();
-        const params = this.invocationParams(options);
-        const formattedMessages = _convertMessagesToAnthropicPayload(messages);
-        const payload = {
-            ...params,
-            ...formattedMessages,
-            stream: true,
-        };
-        const coerceContentToString = !_toolsInParams(payload) &&
-            !_documentsInParams(payload) &&
-            !_thinkingInParams(payload) &&
-            !_compactionInParams(payload);
-        const stream = await this.createStreamWithRetry(payload, {
-            headers: options.headers,
-        });
-        const shouldStreamUsage = this.streamUsage ?? options.streamUsage;
-        for await (const data of stream) {
-            if (options.signal?.aborted === true) {
-                stream.controller.abort();
-                throw new Error('AbortError: User aborted the request.');
-            }
-            if (data.type === 'message_start') {
-                this.message_start = data;
-            }
-            else if (data.type === 'message_delta') {
-                this.message_delta = data;
-            }
-            let usageMetadata;
-            if (this.tools_in_params !== true && this.emitted_usage !== true) {
-                usageMetadata = this.getStreamUsage();
-            }
-            const result = _makeMessageChunkFromAnthropicEvent(data, {
-                streamUsage: shouldStreamUsage,
-                coerceContentToString,
-            });
-            if (!result)
-                continue;
-            const { chunk } = result;
-            const [token = '', tokenType] = extractToken(chunk);
-            if (!tokenType ||
-                tokenType === 'input' ||
-                (token === '' && (usageMetadata != null || chunk.id != null))) {
-                const generationChunk = this.createGenerationChunk({
-                    token,
-                    chunk,
-                    usageMetadata,
-                    shouldStreamUsage,
-                });
-                yield generationChunk;
-                await runManager?.handleLLMNewToken(token, undefined, undefined, undefined, undefined, { chunk: generationChunk });
-                continue;
-            }
-            const textStream = new TextStream(token, {
-                delay: this._lc_stream_delay,
-                firstWordChunk: true,
-                minChunkSize: 4,
-                maxChunkSize: 8,
-            });
-            const generator = textStream.generateText(options.signal);
-            try {
-                let emittedUsage = false;
-                for await (const currentToken of generator) {
-                    if (options.signal?.aborted === true) {
-                        break;
-                    }
-                    const newChunk = cloneChunk(currentToken, tokenType, chunk);
-                    const generationChunk = this.createGenerationChunk({
-                        token: currentToken,
-                        chunk: newChunk,
-                        usageMetadata: emittedUsage ? undefined : usageMetadata,
-                        shouldStreamUsage,
-                    });
-                    if (usageMetadata && !emittedUsage) {
-                        emittedUsage = true;
-                    }
-                    yield generationChunk;
-                    await runManager?.handleLLMNewToken(currentToken, undefined, undefined, undefined, undefined, { chunk: generationChunk });
-                }
-            }
-            finally {
-                await generator.return();
-            }
-        }
-        this.resetTokenEvents();
-    }
-}
-//# sourceMappingURL=index.js.map