@illuma-ai/agents 1.1.21 → 1.1.23

package/src/specs/token-distribution-edge-case.test.js

@@ -1,246 +0,0 @@
-// src/specs/token-distribution-edge-case.test.ts
-import { HumanMessage, AIMessage, SystemMessage, } from '@langchain/core/messages';
-import { createPruneMessages } from '@/messages/prune';
-// Create a simple token counter for testing
-const createTestTokenCounter = () => {
-    // This simple token counter just counts characters as tokens for predictable testing
-    return (message) => {
-        // Use type assertion to help TypeScript understand the type
-        const content = message.content;
-        // Handle string content
-        if (typeof content === 'string') {
-            return content.length;
-        }
-        // Handle array content
-        if (Array.isArray(content)) {
-            let totalLength = 0;
-            for (const item of content) {
-                if (typeof item === 'string') {
-                    totalLength += item.length;
-                }
-                else if (typeof item === 'object') {
-                    if ('text' in item && typeof item.text === 'string') {
-                        totalLength += item.text.length;
-                    }
-                }
-            }
-            return totalLength;
-        }
-        // Default case - if content is null, undefined, or any other type
-        return 0;
-    };
-};
-describe('Token Distribution Edge Case Tests', () => {
-    it('should only distribute tokens to messages that remain in the context after pruning', () => {
-        // Create a token counter
-        const tokenCounter = createTestTokenCounter();
-        // Create messages
-        const messages = [
-            new SystemMessage('System instruction'), // Will always be included
-            new HumanMessage('Message 1'), // Will be pruned
-            new AIMessage('Response 1'), // Will be pruned
-            new HumanMessage('Message 2'), // Will remain
-            new AIMessage('Response 2'), // Will remain
-        ];
-        // Calculate initial token counts for each message
-        const indexTokenCountMap = {
-            0: 17, // "System instruction"
-            1: 9, // "Message 1"
-            2: 10, // "Response 1"
-            3: 9, // "Message 2"
-            4: 10, // "Response 2"
-        };
-        // Set a token limit that will force pruning of the first two messages after the system message
-        const pruneMessages = createPruneMessages({
-            maxTokens: 40, // Only enough for system message + last two messages
-            startIndex: 0,
-            tokenCounter,
-            indexTokenCountMap: { ...indexTokenCountMap },
-        });
-        // First call to establish lastCutOffIndex
-        const initialResult = pruneMessages({ messages });
-        // Verify initial pruning
-        expect(initialResult.context.length).toBe(3);
-        expect(initialResult.context[0].content).toBe('System instruction');
-        expect(initialResult.context[1].content).toBe('Message 2');
-        expect(initialResult.context[2].content).toBe('Response 2');
-        // Now provide usage metadata with a different total token count
-        const usageMetadata = {
-            input_tokens: 30,
-            output_tokens: 20,
-            total_tokens: 50, // Different from the sum of our initial token counts
-        };
-        // Call pruneMessages again with the usage metadata
-        const result = pruneMessages({
-            messages,
-            usageMetadata,
-        });
-        // The token distribution should only affect messages that remain in the context
-        // Messages at indices 0, 3, and 4 should have their token counts adjusted
-        // Messages at indices 1 and 2 should remain unchanged since they're pruned
-        // The token distribution should only affect messages that remain in the context
-        // Messages at indices 0, 3, and 4 should have their token counts adjusted
-        // Messages at indices 1 and 2 should remain unchanged since they're pruned
-        // Check that at least one of the pruned messages' token counts was not adjusted
-        // We're testing the principle that pruned messages don't get token redistribution
-        const atLeastOnePrunedMessageUnchanged = result.indexTokenCountMap[1] === indexTokenCountMap[1] ||
-            result.indexTokenCountMap[2] === indexTokenCountMap[2];
-        expect(atLeastOnePrunedMessageUnchanged).toBe(true);
-        // Verify that the sum of tokens for messages in the context is close to the total_tokens from usageMetadata
-        // There might be small rounding differences or implementation details that affect the exact sum
-        const totalContextTokens = (result.indexTokenCountMap[0] ?? 0) +
-            (result.indexTokenCountMap[3] ?? 0) +
-            (result.indexTokenCountMap[4] ?? 0);
-        expect(totalContextTokens).toBeGreaterThan(0);
-        // The key thing we're testing is that the token distribution happens for messages in the context
-        // and that the sum is reasonably close to the expected total
-        const tokenDifference = Math.abs(totalContextTokens - 50);
-        expect(tokenDifference).toBeLessThan(20); // Allow for some difference due to implementation details
-    });
-    it('should handle the case when all messages fit within the token limit', () => {
-        // Create a token counter
-        const tokenCounter = createTestTokenCounter();
-        // Create messages
-        const messages = [
-            new SystemMessage('System instruction'),
-            new HumanMessage('Message 1'),
-            new AIMessage('Response 1'),
-        ];
-        // Calculate initial token counts for each message
-        const indexTokenCountMap = {
-            0: 17, // "System instruction"
-            1: 9, // "Message 1"
-            2: 10, // "Response 1"
-        };
-        // Set a token limit that will allow all messages to fit
-        const pruneMessages = createPruneMessages({
-            maxTokens: 100,
-            startIndex: 0,
-            tokenCounter,
-            indexTokenCountMap: { ...indexTokenCountMap },
-        });
-        // First call to establish lastCutOffIndex (should be 0 since no pruning occurs)
-        const initialResult = pruneMessages({ messages });
-        // Verify no pruning occurred
-        expect(initialResult.context.length).toBe(3);
-        // Now provide usage metadata with a different total token count
-        const usageMetadata = {
-            input_tokens: 20,
-            output_tokens: 10,
-            total_tokens: 30, // Different from the sum of our initial token counts
-        };
-        // Call pruneMessages again with the usage metadata
-        const result = pruneMessages({
-            messages,
-            usageMetadata,
-        });
-        // Since all messages fit, all token counts should be adjusted
-        const initialTotalTokens = indexTokenCountMap[0] + indexTokenCountMap[1] + indexTokenCountMap[2];
-        const expectedRatio = 30 / initialTotalTokens;
-        // Check that all token counts were adjusted
-        expect(result.indexTokenCountMap[0]).toBe(Math.round(indexTokenCountMap[0] * expectedRatio));
-        expect(result.indexTokenCountMap[1]).toBe(Math.round(indexTokenCountMap[1] * expectedRatio));
-        expect(result.indexTokenCountMap[2]).toBe(Math.round(indexTokenCountMap[2] * expectedRatio));
-        // Verify that the sum of all tokens equals the total_tokens from usageMetadata
-        const totalTokens = (result.indexTokenCountMap[0] ?? 0) +
-            (result.indexTokenCountMap[1] ?? 0) +
-            (result.indexTokenCountMap[2] ?? 0);
-        expect(totalTokens).toBe(30);
-    });
-    it('should handle multiple pruning operations with token redistribution', () => {
-        // Create a token counter
-        const tokenCounter = createTestTokenCounter();
-        // Create a longer sequence of messages
-        const messages = [
-            new SystemMessage('System instruction'), // Will always be included
-            new HumanMessage('Message 1'), // Will be pruned in first round
-            new AIMessage('Response 1'), // Will be pruned in first round
-            new HumanMessage('Message 2'), // Will be pruned in second round
-            new AIMessage('Response 2'), // Will be pruned in second round
-            new HumanMessage('Message 3'), // Will remain
-            new AIMessage('Response 3'), // Will remain
-        ];
-        // Calculate initial token counts for each message
-        const indexTokenCountMap = {
-            0: 17, // "System instruction"
-            1: 9, // "Message 1"
-            2: 10, // "Response 1"
-            3: 9, // "Message 2"
-            4: 10, // "Response 2"
-            5: 9, // "Message 3"
-            6: 10, // "Response 3"
-        };
-        // Set a token limit that will force pruning
-        const pruneMessages = createPruneMessages({
-            maxTokens: 40, // Only enough for system message + last two messages
-            startIndex: 0,
-            tokenCounter,
-            indexTokenCountMap: { ...indexTokenCountMap },
-        });
-        // First pruning operation
-        const firstResult = pruneMessages({ messages });
-        // Verify first pruning
-        expect(firstResult.context.length).toBe(3);
-        expect(firstResult.context[0].content).toBe('System instruction');
-        expect(firstResult.context[1].content).toBe('Message 3');
-        expect(firstResult.context[2].content).toBe('Response 3');
-        // First usage metadata update
-        const firstUsageMetadata = {
-            input_tokens: 30,
-            output_tokens: 20,
-            total_tokens: 50,
-        };
-        // Apply first usage metadata
-        const secondResult = pruneMessages({
-            messages,
-            usageMetadata: firstUsageMetadata,
-        });
-        // Add two more messages
-        messages.push(new HumanMessage('Message 4'));
-        const extendedMessages = [...messages, new AIMessage('Response 4')];
-        // Second usage metadata update
-        const secondUsageMetadata = {
-            input_tokens: 30,
-            output_tokens: 20,
-            total_tokens: 50,
-        };
-        // Apply second usage metadata with extended messages
-        const thirdResult = pruneMessages({
-            messages: extendedMessages,
-            usageMetadata: secondUsageMetadata,
-        });
-        // The context should include the system message and some of the latest messages
-        expect(thirdResult.context.length).toBeGreaterThan(0);
-        expect(thirdResult.context[0].content).toBe('System instruction');
-        expect(thirdResult.context[1].content).toBe('Response 4');
-        // Find which messages are in the final context
-        const contextMessageIndices = thirdResult.context.map((msg) => {
-            // Find the index of this message in the original array
-            return extendedMessages.findIndex((m) => m.content === msg.content);
-        });
-        // Get the sum of token counts for messages in the context
-        let totalContextTokens = 0;
-        for (const idx of contextMessageIndices) {
-            totalContextTokens += thirdResult.indexTokenCountMap[idx] ?? 0;
-        }
-        // Verify that the sum of tokens for messages in the context is close to the total_tokens from usageMetadata
-        // There might be small rounding differences or implementation details that affect the exact sum
-        expect(totalContextTokens).toBeGreaterThan(0);
-        // The key thing we're testing is that the token distribution happens for messages in the context
-        // and that the sum is reasonably close to the expected total
-        const tokenDifference = Math.abs(totalContextTokens - 70);
-        expect(tokenDifference).toBeLessThan(50); // Allow for some difference due to implementation details
-        // Verify that messages not in the context have their original token counts or previously adjusted values
-        for (let i = 0; i < extendedMessages.length; i++) {
-            if (!contextMessageIndices.includes(i)) {
-                const expectedValue = i < messages.length
-                    ? (secondResult.indexTokenCountMap[i] ?? 0) || indexTokenCountMap[i]
-                    : (indexTokenCountMap[i] ??
-                        0);
-                const difference = Math.abs((thirdResult.indexTokenCountMap[i] ?? 0) - expectedValue);
-                expect(difference).toBe(0);
-            }
-        }
-    });
-});
-//# sourceMappingURL=token-distribution-edge-case.test.js.map

package/src/specs/token-memoization.test.js

@@ -1,32 +0,0 @@
-import { HumanMessage } from '@langchain/core/messages';
-import { createTokenCounter, TokenEncoderManager } from '@/utils/tokens';
-jest.setTimeout(5000);
-describe('Token encoder memoization', () => {
-    beforeEach(() => {
-        TokenEncoderManager.reset();
-    });
-    test('reuses encoder across counters (no external fetch)', async () => {
-        expect(TokenEncoderManager.isInitialized()).toBe(false);
-        const counter1 = await createTokenCounter();
-        expect(TokenEncoderManager.isInitialized()).toBe(true);
-        const counter2 = await createTokenCounter();
-        const m1 = new HumanMessage('hello world');
-        const m2 = new HumanMessage('another short text');
-        const c11 = counter1(m1);
-        const c12 = counter1(m2);
-        const c21 = counter2(m1);
-        const c22 = counter2(m2);
-        expect(c11).toBeGreaterThan(0);
-        expect(c12).toBeGreaterThan(0);
-        // Same counter instance is reused
-        expect(c21).toBe(c11);
-        expect(c22).toBe(c12);
-    });
-    test('reset clears cached tokenizers', async () => {
-        await createTokenCounter();
-        expect(TokenEncoderManager.isInitialized()).toBe(true);
-        TokenEncoderManager.reset();
-        expect(TokenEncoderManager.isInitialized()).toBe(false);
-    });
-});
-//# sourceMappingURL=token-memoization.test.js.map

package/src/specs/tokens.test.js

@@ -1,49 +0,0 @@
-import { HumanMessage } from '@langchain/core/messages';
-import { encodingForModel, createTokenCounter, TokenEncoderManager, } from '@/utils/tokens';
-describe('encodingForModel', () => {
-    test('returns claude for Claude model strings', () => {
-        expect(encodingForModel('claude-3-5-sonnet-20241022')).toBe('claude');
-        expect(encodingForModel('claude-3-haiku-20240307')).toBe('claude');
-    });
-    test('handles Bedrock Claude ARNs', () => {
-        expect(encodingForModel('anthropic.claude-3-5-sonnet-20241022-v2:0')).toBe('claude');
-    });
-    test('is case-insensitive', () => {
-        expect(encodingForModel('CLAUDE-3-HAIKU')).toBe('claude');
-        expect(encodingForModel('Claude-3-Opus')).toBe('claude');
-    });
-    test('returns o200k_base for non-Claude models', () => {
-        expect(encodingForModel('gpt-4o')).toBe('o200k_base');
-        expect(encodingForModel('gemini-2.0-flash')).toBe('o200k_base');
-        expect(encodingForModel('mistral-large')).toBe('o200k_base');
-    });
-    test('returns o200k_base for empty string', () => {
-        expect(encodingForModel('')).toBe('o200k_base');
-    });
-});
-describe('createTokenCounter with different encodings', () => {
-    beforeEach(() => {
-        TokenEncoderManager.reset();
-    });
-    test('claude encoding produces valid token counts', async () => {
-        const counter = await createTokenCounter('claude');
-        const msg = new HumanMessage('Hello, world!');
-        const count = counter(msg);
-        expect(count).toBeGreaterThan(0);
-    });
-    test('o200k_base encoding produces valid token counts', async () => {
-        const counter = await createTokenCounter('o200k_base');
-        const msg = new HumanMessage('Hello, world!');
-        const count = counter(msg);
-        expect(count).toBeGreaterThan(0);
-    });
-    test('both encodings can be initialized and used independently', async () => {
-        const claudeCounter = await createTokenCounter('claude');
-        const o200kCounter = await createTokenCounter('o200k_base');
-        expect(TokenEncoderManager.isInitialized()).toBe(true);
-        const msg = new HumanMessage('Test message for both encodings');
-        expect(claudeCounter(msg)).toBeGreaterThan(0);
-        expect(o200kCounter(msg)).toBeGreaterThan(0);
-    });
-});
-//# sourceMappingURL=tokens.test.js.map

package/src/specs/tool-error.test.js

@@ -1,139 +0,0 @@
-import { config } from 'dotenv';
-config();
-import { tool } from '@langchain/core/tools';
-import { HumanMessage } from '@langchain/core/messages';
-import { ToolEndHandler, ModelEndHandler } from '@/events';
-import { createContentAggregator } from '@/stream';
-import { GraphEvents, Providers } from '@/common';
-import { getLLMConfig } from '@/utils/llmConfig';
-import { getArgs } from '@/scripts/args';
-import { StandardGraph } from '@/graphs';
-import { Run } from '@/run';
-const errorTool = tool(async () => {
-    throw new Error('this is a test error I threw on purpose');
-}, {
-    name: 'errorTool',
-    description: 'A tool that always throws an error',
-    schema: {
-        type: 'object',
-        properties: {
-            input: { type: 'string' },
-        },
-        required: [],
-    },
-});
-describe('Tool Error Handling Tests', () => {
-    jest.setTimeout(30000);
-    let run;
-    let contentParts;
-    let conversationHistory;
-    let aggregateContent;
-    let handleToolCallErrorSpy;
-    const config = {
-        configurable: {
-            thread_id: 'conversation-num-1',
-        },
-        streamMode: 'values',
-        version: 'v2',
-    };
-    beforeEach(async () => {
-        conversationHistory = [];
-        const { contentParts: parts, aggregateContent: ac } = createContentAggregator();
-        aggregateContent = ac;
-        contentParts = parts;
-        // Spy on the static method instead of the instance method
-        handleToolCallErrorSpy = jest.spyOn(StandardGraph, 'handleToolCallErrorStatic');
-    });
-    afterEach(() => {
-        handleToolCallErrorSpy.mockRestore();
-    });
-    const onMessageDeltaSpy = jest.fn();
-    const onRunStepSpy = jest.fn();
-    const onRunStepCompletedSpy = jest.fn();
-    afterAll(() => {
-        onMessageDeltaSpy.mockReset();
-        onRunStepSpy.mockReset();
-        onRunStepCompletedSpy.mockReset();
-    });
-    const setupCustomHandlers = () => ({
-        [GraphEvents.TOOL_END]: new ToolEndHandler(),
-        [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
-        [GraphEvents.ON_RUN_STEP_COMPLETED]: {
-            handle: (event, data) => {
-                if (data.result['type'] === 'tool_call') {
-                    run.Graph?.overrideTestModel(['Looks like there was an error calling the tool.'], 5);
-                }
-                onRunStepCompletedSpy(event, data);
-                aggregateContent({
-                    event,
-                    data: data,
-                });
-            },
-        },
-        [GraphEvents.ON_RUN_STEP]: {
-            handle: (event, data, metadata, graph) => {
-                const runStepData = data;
-                onRunStepSpy(event, runStepData, metadata, graph);
-                aggregateContent({ event, data: runStepData });
-            },
-        },
-        [GraphEvents.ON_RUN_STEP_DELTA]: {
-            handle: (event, data) => {
-                aggregateContent({ event, data: data });
-            },
-        },
-        [GraphEvents.ON_MESSAGE_DELTA]: {
-            handle: (event, data, metadata, graph) => {
-                onMessageDeltaSpy(event, data, metadata, graph);
-                aggregateContent({ event, data: data });
-            },
-        },
-    });
-    test('should handle tool call errors correctly', async () => {
-        const { userName, location } = await getArgs();
-        const llmConfig = getLLMConfig(Providers.OPENAI);
-        const customHandlers = setupCustomHandlers();
-        // Create the run instance
-        run = await Run.create({
-            runId: 'test-run-id',
-            graphConfig: {
-                type: 'standard',
-                llmConfig,
-                tools: [errorTool],
-                instructions: 'You are a helpful AI assistant.',
-                additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
-            },
-            returnContent: true,
-            skipCleanup: true,
-            customHandlers,
-        });
-        const toolCalls = [
-            {
-                name: 'errorTool',
-                args: {
-                    input: 'test input',
-                },
-                id: 'call_test123',
-                type: 'tool_call',
-            },
-        ];
-        const firstResponse = 'Let me try calling the tool';
-        run.Graph?.overrideTestModel([firstResponse], 5, toolCalls);
-        const userMessage = 'Use the error tool';
-        conversationHistory.push(new HumanMessage(userMessage));
-        const inputs = {
-            messages: conversationHistory,
-        };
-        await run.processStream(inputs, config);
-        // Verify handleToolCallError was called
-        expect(handleToolCallErrorSpy).toHaveBeenCalled();
-        // Find the tool call content part
-        const toolCallPart = contentParts.find((part) => part.type === 'tool_call');
-        // Verify the error message in contentParts
-        expect(toolCallPart).toBeDefined();
-        expect(toolCallPart?.tool_call?.args).toEqual(JSON.stringify(toolCalls[0].args));
-        expect(toolCallPart?.tool_call?.output).toContain('Error processing tool');
-        expect(toolCallPart?.tool_call?.output).toContain('this is a test error I threw on purpose');
-    });
-});
-//# sourceMappingURL=tool-error.test.js.map

package/src/splitStream.js

@@ -1,204 +0,0 @@
-import { nanoid } from 'nanoid';
-import { ContentTypes, GraphEvents, StepTypes } from '@/common';
-export const SEPARATORS = [
-    '. ',
-    '?',
-    '!',
-    '۔',
-    '- ',
-    '。',
-    '‥',
-    ';',
-    '¡',
-    '¿',
-    '\n',
-    '```',
-];
-export class SplitStreamHandler {
-    inCodeBlock = false;
-    inThinkBlock = false;
-    accumulate;
-    tokens = [];
-    lastToken = '';
-    reasoningTokens = [];
-    currentStepId;
-    currentMessageId;
-    currentType;
-    currentLength = 0;
-    reasoningKey = 'reasoning_content';
-    currentIndex = -1;
-    blockThreshold = 4500;
-    /** The run ID AKA the Message ID associated with the complete generation */
-    runId;
-    handlers;
-    constructor({ runId, handlers, accumulate, reasoningKey, blockThreshold, }) {
-        this.runId = runId;
-        this.handlers = handlers;
-        if (reasoningKey) {
-            this.reasoningKey = reasoningKey;
-        }
-        if (blockThreshold != null) {
-            this.blockThreshold = blockThreshold;
-        }
-        this.accumulate = accumulate ?? false;
-    }
-    getMessageId = () => {
-        const messageId = this.currentMessageId;
-        if (messageId != null && messageId) {
-            return messageId;
-        }
-        return undefined;
-    };
-    createMessageStep = (type) => {
-        if (type != null && this.currentType !== type) {
-            this.currentType = type;
-        }
-        this.currentLength = 0;
-        this.currentIndex += 1;
-        this.currentStepId = `step_${nanoid()}`;
-        this.currentMessageId = `msg_${nanoid()}`;
-        return [this.currentStepId, this.currentMessageId];
-    };
-    dispatchRunStep = (stepId, stepDetails) => {
-        const runStep = {
-            id: stepId,
-            runId: this.runId,
-            type: stepDetails.type,
-            index: this.currentIndex,
-            stepDetails,
-            // usage: null,
-        };
-        this.handlers?.[GraphEvents.ON_RUN_STEP]?.({
-            event: GraphEvents.ON_RUN_STEP,
-            data: runStep,
-        });
-    };
-    dispatchMessageDelta = (stepId, delta) => {
-        const messageDelta = {
-            id: stepId,
-            delta,
-        };
-        this.handlers?.[GraphEvents.ON_MESSAGE_DELTA]?.({
-            event: GraphEvents.ON_MESSAGE_DELTA,
-            data: messageDelta,
-        });
-    };
-    dispatchReasoningDelta = (stepId, delta) => {
-        const reasoningDelta = {
-            id: stepId,
-            delta,
-        };
-        this.handlers?.[GraphEvents.ON_REASONING_DELTA]?.({
-            event: GraphEvents.ON_REASONING_DELTA,
-            data: reasoningDelta,
-        });
-    };
-    handleContent = (content, _type) => {
-        let type = _type;
-        if (this.inThinkBlock && type === ContentTypes.TEXT) {
-            type = ContentTypes.THINK;
-        }
-        if (this.accumulate) {
-            if (type === ContentTypes.THINK) {
-                this.reasoningTokens.push(content);
-            }
-            else {
-                this.tokens.push(content);
-            }
-        }
-        if (this.currentType !== type) {
-            const [newStepId, newMessageId] = this.createMessageStep(type);
-            this.dispatchRunStep(newStepId, {
-                type: StepTypes.MESSAGE_CREATION,
-                message_creation: {
-                    message_id: newMessageId,
-                },
-            });
-        }
-        const stepId = this.currentStepId ?? '';
-        if (type === ContentTypes.THINK) {
-            this.dispatchReasoningDelta(stepId, {
-                content: [
-                    {
-                        type: ContentTypes.THINK,
-                        think: content,
-                    },
-                ],
-            });
-        }
-        else {
-            this.dispatchMessageDelta(stepId, {
-                content: [
-                    {
-                        type: ContentTypes.TEXT,
-                        text: content,
-                    },
-                ],
-            });
-        }
-        this.currentLength += content.length;
-        if (this.inCodeBlock) {
-            return;
-        }
-        if (this.currentLength > this.blockThreshold &&
-            SEPARATORS.some((sep) => content.includes(sep))) {
-            const [newStepId, newMessageId] = this.createMessageStep(type);
-            this.dispatchRunStep(newStepId, {
-                type: StepTypes.MESSAGE_CREATION,
-                message_creation: {
-                    message_id: newMessageId,
-                },
-            });
-        }
-    };
-    getDeltaContent(chunk) {
-        return chunk?.choices?.[0]?.delta?.content ?? '';
-    }
-    getReasoningDelta(chunk) {
-        return (chunk?.choices?.[0]?.delta?.[this.reasoningKey] ??
-            '');
-    }
-    handle(chunk) {
-        if (!chunk) {
-            return;
-        }
-        const content = this.getDeltaContent(chunk);
-        const reasoning_content = this.getReasoningDelta(chunk);
-        if (!content.length && !reasoning_content.length) {
-            return;
-        }
-        if (content.includes('```')) {
-            this.inCodeBlock = !this.inCodeBlock;
-        }
-        if (content.includes('<think>') && !this.inCodeBlock) {
-            this.inThinkBlock = true;
-        }
-        else if (this.lastToken.includes('</think>') && !this.inCodeBlock) {
-            this.inThinkBlock = false;
-        }
-        this.lastToken = content;
-        const message_id = this.getMessageId() ?? '';
-        if (!message_id) {
-            const initialContentType = this.inThinkBlock
-                ? ContentTypes.THINK
-                : ContentTypes.TEXT;
-            const initialType = reasoning_content
-                ? ContentTypes.THINK
-                : initialContentType;
-            const [stepId, message_id] = this.createMessageStep(initialType);
-            this.dispatchRunStep(stepId, {
-                type: StepTypes.MESSAGE_CREATION,
-                message_creation: {
-                    message_id,
-                },
-            });
-        }
-        if (reasoning_content) {
-            this.handleContent(reasoning_content, ContentTypes.THINK);
-        }
-        else {
-            this.handleContent(content, ContentTypes.TEXT);
-        }
-    }
-}
-//# sourceMappingURL=splitStream.js.map