@illuma-ai/agents 1.1.20 → 1.1.22

package/src/tools/__tests__/truncation-recovery.integration.test.js

@@ -1,362 +0,0 @@
-/**
- * Integration test: Full Truncation Recovery Pipeline
- *
- * Tests the end-to-end flow that would catch the Bedrock buffer bug:
- *   Streaming chunks → handleToolCallChunks → StreamingToolCallBuffer → handleToolCalls → ToolNode.recoverTruncatedArgs → tool receives recovered args
- *
- * Uses real StreamingToolCallBuffer (not mocked) and real ToolNode with real tool definitions.
- * Only the graph dispatch layer is mocked (since we're not testing SSE dispatch).
- *
- * Verified against live Bedrock API output (see bedrock-live-poc.ts):
- *   START chunk: { id, name, index, args: "" }
- *   DELTA chunks: { args, index } — NO id, NO name
- */
-import { z } from 'zod';
-import { tool } from '@langchain/core/tools';
-import { AIMessage } from '@langchain/core/messages';
-import { describe, it, expect, beforeEach, jest } from '@jest/globals';
-import { StepTypes } from '@/common';
-import { StreamingToolCallBuffer } from '../StreamingToolCallBuffer';
-import { handleToolCallChunks } from '../handlers';
-import { ToolNode } from '../ToolNode';
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-/** Creates a mock graph that delegates buffer operations to a REAL StreamingToolCallBuffer */
-function createIntegrationGraph(buffer) {
-    let stepCounter = 0;
-    return {
-        getStepKey: jest.fn().mockReturnValue('step-key'),
-        getStepIdByKey: jest.fn().mockReturnValue('prev-step-id'),
-        getRunStep: jest.fn().mockReturnValue({
-            type: StepTypes.MESSAGE_CREATION,
-            id: 'prev-step-id',
-            index: 0,
-            stepDetails: { type: StepTypes.MESSAGE_CREATION, message_creation: { message_id: 'msg-1' } },
-            usage: null,
-        }),
-        dispatchRunStep: jest.fn()
-            .mockImplementation(async () => `step-${++stepCounter}`),
-        dispatchRunStepDelta: jest.fn().mockResolvedValue(undefined),
-        toolCallStepIds: new Map(),
-        messageStepHasToolCalls: new Map(),
-        messageIdsByStepKey: new Map(),
-        prelimMessageIdsByStepKey: new Map(),
-        streamingToolCallBuffer: buffer, // REAL buffer, not mocked
-    };
-}
-/** Creates a tool that captures received args for assertion */
-function createCaptureTool(name, schema, capturedArgs) {
-    return tool(async (input) => {
-        capturedArgs.push({ ...input });
-        return `OK`;
-    }, { name, description: `Test tool: ${name}`, schema });
-}
-/** Simulates Bedrock streaming: START chunk with {id, name, index, args:""}, then DELTA chunks with {args, index} */
-function simulateBedrockChunks(toolCallId, toolName, index, argsJson, chunkSize = 30) {
-    const chunks = [];
-    // START chunk: id + name + index, args="" (verified from live Bedrock API)
-    chunks.push({
-        id: toolCallId,
-        name: toolName,
-        index,
-        args: '',
-        type: 'tool_call_chunk',
-    });
-    // DELTA chunks: args + index, NO id, NO name (verified from live Bedrock API)
-    for (let i = 0; i < argsJson.length; i += chunkSize) {
-        chunks.push({
-            id: undefined,
-            name: undefined,
-            index,
-            args: argsJson.substring(i, i + chunkSize),
-            type: 'tool_call_chunk',
-        });
-    }
-    return chunks;
-}
-/** Simulates OpenAI/Anthropic streaming: every chunk has {id, args} */
-function simulateOpenAIChunks(toolCallId, toolName, index, argsJson, chunkSize = 30) {
-    const chunks = [];
-    // First chunk: id + name + first args fragment
-    const firstArgs = argsJson.substring(0, chunkSize);
-    chunks.push({
-        id: toolCallId,
-        name: toolName,
-        index,
-        args: firstArgs,
-        type: 'tool_call_chunk',
-    });
-    // Subsequent chunks: id + args (OpenAI sends id on every chunk)
-    for (let i = chunkSize; i < argsJson.length; i += chunkSize) {
-        chunks.push({
-            id: toolCallId,
-            name: undefined,
-            index,
-            args: argsJson.substring(i, i + chunkSize),
-            type: 'tool_call_chunk',
-        });
-    }
-    return chunks;
-}
-const contentToolSchema = z.object({
-    action: z.string(),
-    filename: z.string().optional(),
-    content: z.string().optional(),
-});
-const codeExecutorSchema = z.object({
-    code: z.string(),
-    language: z.string().optional(),
-});
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-describe('Truncation Recovery Pipeline (Integration)', () => {
-    let buffer;
-    beforeEach(() => {
-        buffer = new StreamingToolCallBuffer();
-    });
-    it('Bedrock truncated write — full pipeline recovery', async () => {
-        const capturedArgs = [];
-        const graph = createIntegrationGraph(buffer);
-        // Full args JSON that Bedrock would stream (including content)
-        const fullArgsJson = '{"action":"write","filename":"app.tsx","content":"import React from \\"react\\";\\nexport default function App() {\\n  return <div>Hello World</div>;\\n}"}';
-        // Simulate Bedrock streaming: START + DELTA chunks
-        const chunks = simulateBedrockChunks('tooluse_abc', 'content_tool', 0, fullArgsJson, 20);
-        // Feed all chunks through handleToolCallChunks (real buffer accumulation)
-        for (const chunk of chunks) {
-            await handleToolCallChunks({
-                graph: graph,
-                stepKey: 'step-key',
-                toolCallChunks: [chunk],
-                metadata: { run_id: 'test' },
-            });
-        }
-        // Verify buffer was populated
-        expect(buffer.has('tooluse_abc')).toBe(true);
-        expect(buffer.getRawArgs('tooluse_abc')).toBe(fullArgsJson);
-        // Simulate truncation: parsePartialJson lost the content field
-        const truncatedArgs = { action: 'write', filename: 'app.tsx' }; // content MISSING
-        // Create ToolNode with real buffer
-        const contentTool = createCaptureTool('content_tool', contentToolSchema, capturedArgs);
-        const toolNode = new ToolNode({
-            tools: [contentTool],
-            streamingToolCallBuffer: buffer,
-        });
-        // Invoke ToolNode with truncated args
-        const aiMsg = new AIMessage({
-            content: '',
-            tool_calls: [{ id: 'tooluse_abc', name: 'content_tool', args: truncatedArgs }],
-        });
-        await toolNode.invoke({ messages: [aiMsg] });
-        // Assert: tool received RECOVERED content, not truncated
-        expect(capturedArgs).toHaveLength(1);
-        expect(capturedArgs[0].action).toBe('write');
-        expect(capturedArgs[0].filename).toBe('app.tsx');
-        expect(capturedArgs[0].content).toBe('import React from "react";\nexport default function App() {\n  return <div>Hello World</div>;\n}');
-    });
-    it('OpenAI/Anthropic chunked write — full pipeline recovery', async () => {
-        const capturedArgs = [];
-        const graph = createIntegrationGraph(buffer);
-        const fullArgsJson = '{"action":"write","filename":"test.tsx","content":"const x = 42;\\nconst y = 100;"}';
-        const chunks = simulateOpenAIChunks('tc_openai', 'content_tool', 0, fullArgsJson, 15);
-        for (const chunk of chunks) {
-            await handleToolCallChunks({
-                graph: graph,
-                stepKey: 'step-key',
-                toolCallChunks: [chunk],
-                metadata: { run_id: 'test' },
-            });
-        }
-        expect(buffer.has('tc_openai')).toBe(true);
-        expect(buffer.getRawArgs('tc_openai')).toBe(fullArgsJson);
-        // Simulate truncation: content missing
-        const contentTool = createCaptureTool('content_tool', contentToolSchema, capturedArgs);
-        const toolNode = new ToolNode({
-            tools: [contentTool],
-            streamingToolCallBuffer: buffer,
-        });
-        const aiMsg = new AIMessage({
-            content: '',
-            tool_calls: [{ id: 'tc_openai', name: 'content_tool', args: { action: 'write', filename: 'test.tsx' } }],
-        });
-        await toolNode.invoke({ messages: [aiMsg] });
-        expect(capturedArgs[0].content).toBe('const x = 42;\nconst y = 100;');
-    });
-    it('multiple parallel tool calls — no cross-contamination', async () => {
-        const capturedArgs = [];
-        const graph = createIntegrationGraph(buffer);
-        // Two parallel tool calls with different indexes
-        const args1 = '{"action":"write","filename":"a.tsx","content":"file A content"}';
-        const args2 = '{"action":"write","filename":"b.tsx","content":"file B content"}';
-        const chunks1 = simulateBedrockChunks('tc_1', 'content_tool', 0, args1, 15);
-        const chunks2 = simulateBedrockChunks('tc_2', 'content_tool', 1, args2, 15);
-        // Interleave chunks (realistic concurrent streaming)
-        const interleaved = [];
-        const maxLen = Math.max(chunks1.length, chunks2.length);
-        for (let i = 0; i < maxLen; i++) {
-            if (i < chunks1.length)
-                interleaved.push(chunks1[i]);
-            if (i < chunks2.length)
-                interleaved.push(chunks2[i]);
-        }
-        for (const chunk of interleaved) {
-            await handleToolCallChunks({
-                graph: graph,
-                stepKey: 'step-key',
-                toolCallChunks: [chunk],
-                metadata: { run_id: 'test' },
-            });
-        }
-        expect(buffer.getRawArgs('tc_1')).toBe(args1);
-        expect(buffer.getRawArgs('tc_2')).toBe(args2);
-        const contentTool = createCaptureTool('content_tool', contentToolSchema, capturedArgs);
-        const toolNode = new ToolNode({
-            tools: [contentTool],
-            streamingToolCallBuffer: buffer,
-        });
-        // Only tc_1 is truncated (missing content), tc_2 has all fields
-        const aiMsg = new AIMessage({
-            content: '',
-            tool_calls: [
-                { id: 'tc_1', name: 'content_tool', args: { action: 'write', filename: 'a.tsx' } }, // truncated
-                { id: 'tc_2', name: 'content_tool', args: { action: 'write', filename: 'b.tsx', content: 'file B content' } }, // complete
-            ],
-        });
-        await toolNode.invoke({ messages: [aiMsg] });
-        expect(capturedArgs).toHaveLength(2);
-        // tc_1: content recovered from buffer
-        expect(capturedArgs[0].content).toBe('file A content');
-        // tc_2: content unchanged (already present in parsed args)
-        expect(capturedArgs[1].content).toBe('file B content');
-    });
-    it('buffer cleanup after recovery — no stale data', async () => {
-        const capturedArgs = [];
-        const graph = createIntegrationGraph(buffer);
-        const fullArgs = '{"action":"write","filename":"x.tsx","content":"test"}';
-        const chunks = simulateBedrockChunks('tc_cleanup', 'content_tool', 0, fullArgs);
-        for (const chunk of chunks) {
-            await handleToolCallChunks({
-                graph: graph,
-                stepKey: 'step-key',
-                toolCallChunks: [chunk],
-                metadata: { run_id: 'test' },
-            });
-        }
-        expect(buffer.has('tc_cleanup')).toBe(true);
-        const contentTool = createCaptureTool('content_tool', contentToolSchema, capturedArgs);
-        const toolNode = new ToolNode({
-            tools: [contentTool],
-            streamingToolCallBuffer: buffer,
-        });
-        const aiMsg = new AIMessage({
-            content: '',
-            tool_calls: [{ id: 'tc_cleanup', name: 'content_tool', args: { action: 'write' } }],
-        });
-        await toolNode.invoke({ messages: [aiMsg] });
-        // Buffer should be cleared after processing
-        expect(buffer.has('tc_cleanup')).toBe(false);
-        expect(buffer.getRawArgs('tc_cleanup')).toBeUndefined();
-    });
-    it('no truncation — buffer populated but not used for overwrite', async () => {
-        const capturedArgs = [];
-        const graph = createIntegrationGraph(buffer);
-        const fullArgs = '{"action":"read","filename":"existing.tsx"}';
-        const chunks = simulateBedrockChunks('tc_complete', 'content_tool', 0, fullArgs);
-        for (const chunk of chunks) {
-            await handleToolCallChunks({
-                graph: graph,
-                stepKey: 'step-key',
-                toolCallChunks: [chunk],
-                metadata: { run_id: 'test' },
-            });
-        }
-        const contentTool = createCaptureTool('content_tool', contentToolSchema, capturedArgs);
-        const toolNode = new ToolNode({
-            tools: [contentTool],
-            streamingToolCallBuffer: buffer,
-        });
-        // Complete args — nothing missing
-        const aiMsg = new AIMessage({
-            content: '',
-            tool_calls: [{ id: 'tc_complete', name: 'content_tool', args: { action: 'read', filename: 'existing.tsx' } }],
-        });
-        await toolNode.invoke({ messages: [aiMsg] });
-        expect(capturedArgs[0].action).toBe('read');
-        expect(capturedArgs[0].filename).toBe('existing.tsx');
-        // No content field in args or buffer — should stay absent
-        expect(capturedArgs[0]).not.toHaveProperty('content');
-    });
-    it('generic tool recovery — non-content_tool (code_executor)', async () => {
-        const capturedArgs = [];
-        const graph = createIntegrationGraph(buffer);
-        const largeCode = 'function fibonacci(n) {\\n  if (n <= 1) return n;\\n  return fibonacci(n-1) + fibonacci(n-2);\\n}\\nconsole.log(fibonacci(10));';
-        const fullArgs = `{"code":"${largeCode}","language":"javascript"}`;
-        const chunks = simulateBedrockChunks('tc_code', 'execute_code', 0, fullArgs, 20);
-        for (const chunk of chunks) {
-            await handleToolCallChunks({
-                graph: graph,
-                stepKey: 'step-key',
-                toolCallChunks: [chunk],
-                metadata: { run_id: 'test' },
-            });
-        }
-        const codeTool = createCaptureTool('execute_code', codeExecutorSchema, capturedArgs);
-        const toolNode = new ToolNode({
-            tools: [codeTool],
-            streamingToolCallBuffer: buffer,
-        });
-        // Truncated: only has language, code is missing
-        const aiMsg = new AIMessage({
-            content: '',
-            tool_calls: [{ id: 'tc_code', name: 'execute_code', args: { language: 'javascript' } }],
-        });
-        await toolNode.invoke({ messages: [aiMsg] });
-        expect(capturedArgs[0].code).toContain('fibonacci');
-        expect(capturedArgs[0].language).toBe('javascript');
-    });
-    it('Bedrock large content (5000+ chars) — recovery preserves full content', async () => {
-        const capturedArgs = [];
-        const graph = createIntegrationGraph(buffer);
-        // Generate large content (simulating a real dashboard component)
-        const lines = [];
-        lines.push('import React from \\"react\\";');
-        lines.push('import { useState, useEffect } from \\"react\\";');
-        for (let i = 0; i < 100; i++) {
-            lines.push(`// Component section ${i}`);
-            lines.push(`const Section${i} = () => <div>Section ${i}</div>;`);
-        }
-        lines.push('export default function Dashboard() {');
-        lines.push('  return <div>Dashboard</div>;');
-        lines.push('}');
-        const content = lines.join('\\n');
-        const fullArgs = `{"action":"write","filename":"dashboard.tsx","content":"${content}"}`;
-        const chunks = simulateBedrockChunks('tc_large', 'content_tool', 0, fullArgs, 50);
-        for (const chunk of chunks) {
-            await handleToolCallChunks({
-                graph: graph,
-                stepKey: 'step-key',
-                toolCallChunks: [chunk],
-                metadata: { run_id: 'test' },
-            });
-        }
-        const contentTool = createCaptureTool('content_tool', contentToolSchema, capturedArgs);
-        const toolNode = new ToolNode({
-            tools: [contentTool],
-            streamingToolCallBuffer: buffer,
-        });
-        // Completely empty args (truncation wiped everything)
-        const aiMsg = new AIMessage({
-            content: '',
-            tool_calls: [{ id: 'tc_large', name: 'content_tool', args: {} }],
-        });
-        await toolNode.invoke({ messages: [aiMsg] });
-        expect(capturedArgs[0].action).toBe('write');
-        expect(capturedArgs[0].filename).toBe('dashboard.tsx');
-        const recoveredContent = capturedArgs[0].content;
-        expect(recoveredContent).toContain('import React from "react"');
-        expect(recoveredContent).toContain('Section 99');
-        expect(recoveredContent).toContain('export default function Dashboard()');
-    });
-});
-//# sourceMappingURL=truncation-recovery.integration.test.js.map

package/src/tools/handlers.js

@@ -1,306 +0,0 @@
-/* eslint-disable no-console */
-// src/tools/handlers.ts
-import { nanoid } from 'nanoid';
-import { ToolMessage } from '@langchain/core/messages';
-import { ToolCallTypes, GraphEvents, StepTypes, Providers, Constants, } from '@/common';
-import { coerceAnthropicSearchResults, isAnthropicWebSearchResult, } from '@/tools/search/anthropic';
-import { formatResultsForLLM } from '@/tools/search/format';
-import { getMessageId } from '@/messages';
-export async function handleToolCallChunks({ graph, stepKey, toolCallChunks, metadata, }) {
-    let prevStepId;
-    let prevRunStep;
-    try {
-        prevStepId = graph.getStepIdByKey(stepKey);
-        prevRunStep = graph.getRunStep(prevStepId);
-    }
-    catch {
-        /** Edge Case: If no previous step exists, create a new message creation step */
-        const message_id = getMessageId(stepKey, graph, true) ?? '';
-        prevStepId = await graph.dispatchRunStep(stepKey, {
-            type: StepTypes.MESSAGE_CREATION,
-            message_creation: {
-                message_id,
-            },
-        }, metadata);
-        prevRunStep = graph.getRunStep(prevStepId);
-    }
-    const _stepId = graph.getStepIdByKey(stepKey);
-    /** Edge Case: Tool Call Run Step or `tool_call_ids` never dispatched */
-    const tool_calls = prevStepId && prevRunStep && prevRunStep.type === StepTypes.MESSAGE_CREATION
-        ? []
-        : undefined;
-    /**
-     * Feed streaming tool call buffer — accumulate raw arg strings for truncation recovery.
-     *
-     * Provider chunk patterns:
-     * - OpenAI/Anthropic: every chunk has {id, args} → direct append
-     * - Bedrock: START chunk has {id, name, index}, DELTA chunks have {args, index} (no id)
-     *   → use index-to-id mapping to resolve the target buffer entry
-     */
-    for (const toolCallChunk of toolCallChunks) {
-        const chunkIndex = toolCallChunk.index;
-        // START chunk: has id (and usually name). Store index→id mapping for future DELTA chunks.
-        if (toolCallChunk.id) {
-            if (typeof chunkIndex === 'number') {
-                graph.streamingToolCallBuffer.setIndexMapping(chunkIndex, toolCallChunk.id);
-            }
-            if (toolCallChunk.name) {
-                graph.streamingToolCallBuffer.setToolName(toolCallChunk.id, toolCallChunk.name);
-            }
-            // Append args if present on the same chunk (OpenAI/Anthropic pattern)
-            if (toolCallChunk.args) {
-                graph.streamingToolCallBuffer.append(toolCallChunk.id, toolCallChunk.args);
-            }
-        }
-        else if (toolCallChunk.args && typeof chunkIndex === 'number') {
-            // DELTA chunk: no id, but has args + index. Resolve id via index mapping (Bedrock pattern).
-            const resolvedId = graph.streamingToolCallBuffer.getIdByIndex(chunkIndex);
-            if (resolvedId) {
-                graph.streamingToolCallBuffer.append(resolvedId, toolCallChunk.args);
-            }
-        }
-    }
-    /** Edge Case: `id` and `name` fields cannot be empty strings */
-    for (const toolCallChunk of toolCallChunks) {
-        if (toolCallChunk.name === '') {
-            toolCallChunk.name = undefined;
-        }
-        if (toolCallChunk.id === '') {
-            toolCallChunk.id = undefined;
-        }
-        else if (tool_calls != null &&
-            toolCallChunk.id != null &&
-            toolCallChunk.name != null) {
-            tool_calls.push({
-                args: {},
-                id: toolCallChunk.id,
-                name: toolCallChunk.name,
-                type: ToolCallTypes.TOOL_CALL,
-            });
-        }
-    }
-    let stepId = _stepId;
-    const alreadyDispatched = prevRunStep?.type === StepTypes.MESSAGE_CREATION &&
-        graph.messageStepHasToolCalls.has(prevStepId);
-    if (prevRunStep?.type === StepTypes.TOOL_CALLS) {
-        /**
-         * If previous step is already a tool_calls step, use that step ID
-         * This ensures tool call deltas are dispatched to the correct step
-         */
-        stepId = prevStepId;
-    }
-    else if (!alreadyDispatched &&
-        prevRunStep?.type === StepTypes.MESSAGE_CREATION) {
-        /**
-         * Create tool_calls step as soon as we receive the first tool call chunk
-         * This ensures deltas are always associated with the correct step
-         *
-         * NOTE: We do NOT dispatch an empty text block here because:
-         * - Empty text blocks cause providers (Anthropic, Bedrock) to reject messages
-         * - The tool_calls themselves are sufficient for the step
-         * - Empty content with tool_call_ids gets stored in conversation history
-         *   and causes "messages must have non-empty content" errors on replay
-         */
-        graph.messageStepHasToolCalls.set(prevStepId, true);
-        stepId = await graph.dispatchRunStep(stepKey, {
-            type: StepTypes.TOOL_CALLS,
-            tool_calls: tool_calls ?? [],
-        }, metadata);
-    }
-    await graph.dispatchRunStepDelta(stepId, {
-        type: StepTypes.TOOL_CALLS,
-        tool_calls: toolCallChunks,
-    });
-}
-export const handleToolCalls = async (toolCalls, metadata, graph) => {
-    if (!graph || !metadata) {
-        console.warn('Graph or metadata not found in `handleToolCalls`');
-        return;
-    }
-    if (!toolCalls) {
-        return;
-    }
-    if (toolCalls.length === 0) {
-        return;
-    }
-    const stepKey = graph.getStepKey(metadata);
-    /**
-     * Track whether we've already reused an empty TOOL_CALLS step created by
-     * handleToolCallChunks during streaming. Only reuse it once (for the first
-     * tool call); subsequent parallel tool calls must create their own steps.
-     */
-    let reusedChunkStepId;
-    for (const tool_call of toolCalls) {
-        const toolCallId = tool_call.id ?? `toolu_${nanoid()}`;
-        tool_call.id = toolCallId;
-        // If this tool call ID was already tracked via handleToolCallChunks,
-        // the step exists but may lack the name (Bedrock sends name only at model end).
-        // Dispatch a delta with the complete data so the client can fill in the name.
-        if (toolCallId && graph.toolCallStepIds.has(toolCallId)) {
-            const existingStepId = graph.toolCallStepIds.get(toolCallId);
-            if (existingStepId != null && existingStepId !== '') {
-                const argsStr = typeof tool_call.args === 'string'
-                    ? tool_call.args
-                    : JSON.stringify(tool_call.args);
-                await graph.dispatchRunStepDelta(existingStepId, {
-                    type: StepTypes.TOOL_CALLS,
-                    tool_calls: [{ name: tool_call.name, args: argsStr, id: toolCallId }],
-                });
-            }
-            continue;
-        }
-        let prevStepId = '';
-        let prevRunStep;
-        try {
-            prevStepId = graph.getStepIdByKey(stepKey);
-            prevRunStep = graph.getRunStep(prevStepId);
-        }
-        catch {
-            // no previous step
-        }
-        // If the previous step is TOOL_CALLS (created by handleToolCallChunks),
-        // either reuse it (if empty) or dispatch a new TOOL_CALLS step directly —
-        // skip the intermediate MESSAGE_CREATION to avoid orphaned gaps.
-        if (prevRunStep?.type === StepTypes.TOOL_CALLS) {
-            const details = prevRunStep.stepDetails;
-            const isEmpty = !details.tool_calls || details.tool_calls.length === 0;
-            if (isEmpty && prevStepId !== reusedChunkStepId) {
-                graph.toolCallStepIds.set(toolCallId, prevStepId);
-                reusedChunkStepId = prevStepId;
-                continue;
-            }
-            await graph.dispatchRunStep(stepKey, { type: StepTypes.TOOL_CALLS, tool_calls: [tool_call] }, metadata);
-            continue;
-        }
-        /**
-         * NOTE: We do NOT dispatch empty text blocks with tool_call_ids because:
-         * - Empty text blocks cause providers (Anthropic, Bedrock) to reject messages
-         * - They get stored in conversation history and cause errors on replay:
-         *   "messages must have non-empty content" (Anthropic)
-         *   "The content field in the Message object is empty" (Bedrock)
-         * - The tool_calls themselves are sufficient
-         */
-        /* If the previous step exists and is a message creation */
-        if (prevStepId && prevRunStep) {
-            graph.messageStepHasToolCalls.set(prevStepId, true);
-            /* If the previous step doesn't exist */
-        }
-        else if (!prevRunStep) {
-            const messageId = getMessageId(stepKey, graph, true) ?? '';
-            const stepId = await graph.dispatchRunStep(stepKey, {
-                type: StepTypes.MESSAGE_CREATION,
-                message_creation: {
-                    message_id: messageId,
-                },
-            }, metadata);
-            graph.messageStepHasToolCalls.set(stepId, true);
-        }
-        await graph.dispatchRunStep(stepKey, {
-            type: StepTypes.TOOL_CALLS,
-            tool_calls: [tool_call],
-        }, metadata);
-    }
-};
-export const toolResultTypes = new Set([
-    // 'tool_use',
-    // 'server_tool_use',
-    // 'input_json_delta',
-    'tool_result',
-    'web_search_result',
-    'web_search_tool_result',
-]);
-/**
- * Handles the result of a server tool call; in other words, a provider's built-in tool.
- * As of 2025-07-06, only Anthropic handles server tool calls with this pattern.
- */
-export async function handleServerToolResult({ graph, content, metadata, agentContext, }) {
-    let skipHandling = false;
-    if (agentContext?.provider !== Providers.ANTHROPIC) {
-        return skipHandling;
-    }
-    if (typeof content === 'string' ||
-        content == null ||
-        content.length === 0 ||
-        (content.length === 1 &&
-            content[0].tool_use_id == null)) {
-        return skipHandling;
-    }
-    for (const contentPart of content) {
-        const toolUseId = contentPart.tool_use_id;
-        if (toolUseId == null || toolUseId === '') {
-            continue;
-        }
-        const stepId = graph.toolCallStepIds.get(toolUseId);
-        if (stepId == null || stepId === '') {
-            console.warn(`Tool use ID ${toolUseId} not found in graph, cannot dispatch tool result.`);
-            continue;
-        }
-        const runStep = graph.getRunStep(stepId);
-        if (!runStep) {
-            console.warn(`Run step for ${stepId} does not exist, cannot dispatch tool result.`);
-            continue;
-        }
-        else if (runStep.type !== StepTypes.TOOL_CALLS) {
-            console.warn(`Run step for ${stepId} is not a tool call step, cannot dispatch tool result.`);
-            continue;
-        }
-        const toolCall = runStep.stepDetails.type === StepTypes.TOOL_CALLS
-            ? runStep.stepDetails.tool_calls?.find((toolCall) => toolCall.id === toolUseId)
-            : undefined;
-        if (!toolCall) {
-            continue;
-        }
-        if (contentPart.type === 'web_search_result' ||
-            contentPart.type === 'web_search_tool_result') {
-            await handleAnthropicSearchResults({
-                contentPart: contentPart,
-                toolCall,
-                metadata,
-                graph,
-            });
-        }
-        if (!skipHandling) {
-            skipHandling = true;
-        }
-    }
-    return skipHandling;
-}
-async function handleAnthropicSearchResults({ contentPart, toolCall, metadata, graph, }) {
-    if (!Array.isArray(contentPart.content)) {
-        console.warn(`Expected content to be an array, got ${typeof contentPart.content}`);
-        return;
-    }
-    if (!isAnthropicWebSearchResult(contentPart.content[0])) {
-        console.warn(`Expected content to be an Anthropic web search result, got ${JSON.stringify(contentPart.content)}`);
-        return;
-    }
-    const turn = graph.invokedToolIds?.size ?? 0;
-    const searchResultData = coerceAnthropicSearchResults({
-        turn,
-        results: contentPart.content,
-    });
-    const name = toolCall.name;
-    const input = toolCall.args ?? {};
-    const artifact = {
-        [Constants.WEB_SEARCH]: searchResultData,
-    };
-    const { output: formattedOutput } = formatResultsForLLM(turn, searchResultData);
-    const output = new ToolMessage({
-        name,
-        artifact,
-        content: formattedOutput,
-        tool_call_id: toolCall.id,
-    });
-    const toolEndData = {
-        input,
-        output,
-    };
-    await graph.handlerRegistry
-        ?.getHandler(GraphEvents.TOOL_END)
-        ?.handle(GraphEvents.TOOL_END, toolEndData, metadata, graph);
-    if (graph.invokedToolIds == null) {
-        graph.invokedToolIds = new Set();
-    }
-    graph.invokedToolIds.add(toolCall.id);
-}
-//# sourceMappingURL=handlers.js.map