@illuma-ai/agents 1.0.90 → 1.0.93

package/src/tools/__tests__/handlers.test.js

@@ -0,0 +1,799 @@
+import { describe, it, expect, beforeEach, jest } from '@jest/globals';
+import { StepTypes, ToolCallTypes, Providers, GraphEvents } from '@/common';
+import { handleToolCallChunks, handleToolCalls, handleServerToolResult, } from '../handlers';
+function createMockGraph(overrides) {
+    let stepCounter = 0;
+    return {
+        getStepKey: jest.fn().mockReturnValue('step-key'),
+        getStepIdByKey: jest.fn().mockReturnValue('prev-step-id'),
+        getRunStep: jest
+            .fn()
+            .mockReturnValue(undefined),
+        dispatchRunStep: jest
+            .fn()
+            .mockImplementation(async () => `new-step-${++stepCounter}`),
+        dispatchRunStepDelta: jest
+            .fn()
+            .mockResolvedValue(undefined),
+        toolCallStepIds: new Map(),
+        messageStepHasToolCalls: new Map(),
+        messageIdsByStepKey: new Map(),
+        prelimMessageIdsByStepKey: new Map(),
+        invokedToolIds: undefined,
+        handlerRegistry: undefined,
+        streamingToolCallBuffer: {
+            append: jest.fn(),
+            setToolName: jest.fn(),
+            getToolName: jest.fn(),
+            getRawArgs: jest.fn(),
+            extractFieldValue: jest.fn(),
+            has: jest.fn().mockReturnValue(false),
+            clear: jest.fn(),
+            clearAll: jest.fn(),
+            setIndexMapping: jest.fn(),
+            getIdByIndex: jest.fn().mockReturnValue(undefined),
+        },
+        ...overrides,
+    };
+}
+function makeRunStep(type, opts) {
+    const stepDetails = type === StepTypes.MESSAGE_CREATION
+        ? {
+            type: StepTypes.MESSAGE_CREATION,
+            message_creation: { message_id: 'msg-1' },
+        }
+        : { type: StepTypes.TOOL_CALLS, tool_calls: opts?.tool_calls ?? [] };
+    return {
+        type,
+        id: opts?.id ?? 'run-step-1',
+        index: opts?.index ?? 0,
+        stepDetails,
+        usage: null,
+    };
+}
+function makeToolCall(id, name = 'calculator') {
+    return { id, name, args: {}, type: 'tool_call' };
+}
+function makeToolCallChunk(opts) {
+    return {
+        id: opts?.id,
+        name: opts?.name,
+        args: '',
+        index: opts?.index ?? 0,
+        type: 'tool_call_chunk',
+    };
+}
+const defaultMetadata = { run_id: 'test-run' };
+describe('handleToolCallChunks', () => {
+    let graph;
+    beforeEach(() => {
+        graph = createMockGraph();
+    });
+    it('creates TOOL_CALLS step when previous step is MESSAGE_CREATION', async () => {
+        const msgStep = makeRunStep(StepTypes.MESSAGE_CREATION);
+        graph.getRunStep.mockReturnValue(msgStep);
+        const chunks = [makeToolCallChunk({ index: 2 })];
+        await handleToolCallChunks({
+            graph: graph,
+            stepKey: 'step-key',
+            toolCallChunks: chunks,
+            metadata: defaultMetadata,
+        });
+        const dispatchCalls = graph.dispatchRunStep.mock.calls;
+        expect(dispatchCalls).toHaveLength(1);
+        expect(dispatchCalls[0][1]).toEqual(expect.objectContaining({ type: StepTypes.TOOL_CALLS }));
+        expect(graph.messageStepHasToolCalls.has('prev-step-id')).toBe(true);
+        expect(graph.dispatchRunStepDelta).toHaveBeenCalledTimes(1);
+    });
+    it('reuses existing TOOL_CALLS step without dispatching a new one', async () => {
+        const toolStep = makeRunStep(StepTypes.TOOL_CALLS);
+        graph.getRunStep.mockReturnValue(toolStep);
+        const chunks = [makeToolCallChunk({ index: 2 })];
+        await handleToolCallChunks({
+            graph: graph,
+            stepKey: 'step-key',
+            toolCallChunks: chunks,
+            metadata: defaultMetadata,
+        });
+        expect(graph.dispatchRunStep).not.toHaveBeenCalled();
+        expect(graph.dispatchRunStepDelta).toHaveBeenCalledTimes(1);
+        expect(graph.dispatchRunStepDelta).toHaveBeenCalledWith('prev-step-id', expect.objectContaining({ type: StepTypes.TOOL_CALLS }));
+    });
+    it('creates MESSAGE_CREATION when no previous step exists', async () => {
+        let callCount = 0;
+        graph.getStepIdByKey.mockImplementation(() => {
+            callCount++;
+            if (callCount === 1) {
+                throw new Error('No step found');
+            }
+            return 'new-step-1';
+        });
+        graph.getRunStep.mockReturnValue(makeRunStep(StepTypes.MESSAGE_CREATION));
+        const chunks = [makeToolCallChunk({ index: 0 })];
+        await handleToolCallChunks({
+            graph: graph,
+            stepKey: 'step-key',
+            toolCallChunks: chunks,
+            metadata: defaultMetadata,
+        });
+        const dispatchCalls = graph.dispatchRunStep.mock.calls;
+        expect(dispatchCalls.length).toBeGreaterThanOrEqual(2);
+        expect(dispatchCalls[0][1]).toEqual(expect.objectContaining({ type: StepTypes.MESSAGE_CREATION }));
+        expect(dispatchCalls[1][1]).toEqual(expect.objectContaining({ type: StepTypes.TOOL_CALLS }));
+    });
+    it('skips TOOL_CALLS dispatch when already dispatched for this MESSAGE_CREATION', async () => {
+        const msgStep = makeRunStep(StepTypes.MESSAGE_CREATION);
+        graph.getRunStep.mockReturnValue(msgStep);
+        graph.messageStepHasToolCalls.set('prev-step-id', true);
+        const chunks = [makeToolCallChunk({ index: 2 })];
+        await handleToolCallChunks({
+            graph: graph,
+            stepKey: 'step-key',
+            toolCallChunks: chunks,
+            metadata: defaultMetadata,
+        });
+        expect(graph.dispatchRunStep).not.toHaveBeenCalled();
+        expect(graph.dispatchRunStepDelta).toHaveBeenCalledTimes(1);
+    });
+    it('sanitizes empty string id and name to undefined', async () => {
+        const msgStep = makeRunStep(StepTypes.MESSAGE_CREATION);
+        graph.getRunStep.mockReturnValue(msgStep);
+        const chunk = makeToolCallChunk({ id: '', name: '' });
+        await handleToolCallChunks({
+            graph: graph,
+            stepKey: 'step-key',
+            toolCallChunks: [chunk],
+            metadata: defaultMetadata,
+        });
+        expect(chunk.id).toBeUndefined();
+        expect(chunk.name).toBeUndefined();
+    });
+    it('populates tool_calls when chunk has valid id and name', async () => {
+        const msgStep = makeRunStep(StepTypes.MESSAGE_CREATION);
+        graph.getRunStep.mockReturnValue(msgStep);
+        const chunks = [
+            makeToolCallChunk({ id: 'tooluse_abc', name: 'calculator', index: 2 }),
+        ];
+        await handleToolCallChunks({
+            graph: graph,
+            stepKey: 'step-key',
+            toolCallChunks: chunks,
+            metadata: defaultMetadata,
+        });
+        const toolCallsArg = graph.dispatchRunStep.mock
+            .calls[0][1];
+        expect(toolCallsArg.tool_calls).toEqual([
+            expect.objectContaining({
+                id: 'tooluse_abc',
+                name: 'calculator',
+                type: ToolCallTypes.TOOL_CALL,
+            }),
+        ]);
+    });
+    it('never dispatches empty text block alongside TOOL_CALLS step', async () => {
+        const msgStep = makeRunStep(StepTypes.MESSAGE_CREATION);
+        graph.getRunStep.mockReturnValue(msgStep);
+        const chunks = [
+            makeToolCallChunk({ id: 'tooluse_abc', name: 'calculator', index: 2 }),
+        ];
+        await handleToolCallChunks({
+            graph: graph,
+            stepKey: 'step-key',
+            toolCallChunks: chunks,
+            metadata: defaultMetadata,
+        });
+        const allDispatches = graph.dispatchRunStep.mock.calls;
+        expect(allDispatches).toHaveLength(1);
+        const stepDetails = allDispatches[0][1];
+        expect(stepDetails.type).toBe(StepTypes.TOOL_CALLS);
+        expect(stepDetails).not.toHaveProperty('content');
+        expect(stepDetails).not.toHaveProperty('text');
+    });
+    it('feeds buffer with id+args on same chunk (OpenAI/Anthropic pattern)', async () => {
+        const msgStep = makeRunStep(StepTypes.MESSAGE_CREATION);
+        graph.getRunStep.mockReturnValue(msgStep);
+        const chunk = {
+            id: 'tc_1',
+            name: 'content_tool',
+            args: '{"action":"wri',
+            index: 0,
+            type: 'tool_call_chunk',
+        };
+        await handleToolCallChunks({
+            graph: graph,
+            stepKey: 'step-key',
+            toolCallChunks: [chunk],
+            metadata: defaultMetadata,
+        });
+        expect(graph.streamingToolCallBuffer.setIndexMapping).toHaveBeenCalledWith(0, 'tc_1');
+        expect(graph.streamingToolCallBuffer.setToolName).toHaveBeenCalledWith('tc_1', 'content_tool');
+        expect(graph.streamingToolCallBuffer.append).toHaveBeenCalledWith('tc_1', '{"action":"wri');
+    });
+    it('feeds buffer via index lookup for Bedrock DELTA chunks (no id)', async () => {
+        const msgStep = makeRunStep(StepTypes.MESSAGE_CREATION);
+        graph.getRunStep.mockReturnValue(msgStep);
+        // Simulate: index 0 was previously mapped to 'tc_1'
+        graph.streamingToolCallBuffer.getIdByIndex.mockReturnValue('tc_1');
+        const deltaChunk = {
+            id: undefined,
+            name: undefined,
+            args: 'te","content":"hello',
+            index: 0,
+            type: 'tool_call_chunk',
+        };
+        await handleToolCallChunks({
+            graph: graph,
+            stepKey: 'step-key',
+            toolCallChunks: [deltaChunk],
+            metadata: defaultMetadata,
+        });
+        expect(graph.streamingToolCallBuffer.getIdByIndex).toHaveBeenCalledWith(0);
+        expect(graph.streamingToolCallBuffer.append).toHaveBeenCalledWith('tc_1', 'te","content":"hello');
+    });
+    it('does not feed buffer when DELTA chunk has no index mapping', async () => {
+        const msgStep = makeRunStep(StepTypes.MESSAGE_CREATION);
+        graph.getRunStep.mockReturnValue(msgStep);
+        // No index mapping exists
+        graph.streamingToolCallBuffer.getIdByIndex.mockReturnValue(undefined);
+        const deltaChunk = {
+            id: undefined,
+            name: undefined,
+            args: 'some args',
+            index: 5,
+            type: 'tool_call_chunk',
+        };
+        await handleToolCallChunks({
+            graph: graph,
+            stepKey: 'step-key',
+            toolCallChunks: [deltaChunk],
+            metadata: defaultMetadata,
+        });
+        expect(graph.streamingToolCallBuffer.append).not.toHaveBeenCalled();
+    });
+    it('dispatches delta even when chunks lack id/name (Bedrock pattern)', async () => {
+        const msgStep = makeRunStep(StepTypes.MESSAGE_CREATION);
+        graph.getRunStep.mockReturnValue(msgStep);
+        const chunks = [makeToolCallChunk({ index: 2 })];
+        await handleToolCallChunks({
+            graph: graph,
+            stepKey: 'step-key',
+            toolCallChunks: chunks,
+            metadata: defaultMetadata,
+        });
+        expect(graph.dispatchRunStepDelta).toHaveBeenCalledTimes(1);
+        const toolCallsArg = graph.dispatchRunStep.mock
+            .calls[0][1];
+        expect(toolCallsArg.tool_calls).toEqual([]);
+    });
+});
+describe('handleToolCalls', () => {
+    let graph;
+    beforeEach(() => {
+        graph = createMockGraph();
+    });
+    it('returns early when metadata is missing', async () => {
+        await handleToolCalls([makeToolCall('id-1')], undefined, graph);
+        expect(graph.dispatchRunStep).not.toHaveBeenCalled();
+    });
+    it('returns early when toolCalls is undefined', async () => {
+        await handleToolCalls(undefined, defaultMetadata, graph);
+        expect(graph.dispatchRunStep).not.toHaveBeenCalled();
+    });
+    it('returns early when toolCalls is empty', async () => {
+        await handleToolCalls([], defaultMetadata, graph);
+        expect(graph.dispatchRunStep).not.toHaveBeenCalled();
+    });
+    it('skips tool call when id already in toolCallStepIds', async () => {
+        graph.toolCallStepIds.set('id-1', 'existing-step');
+        const msgStep = makeRunStep(StepTypes.MESSAGE_CREATION);
+        graph.getRunStep.mockReturnValue(msgStep);
+        await handleToolCalls([makeToolCall('id-1')], defaultMetadata, graph);
+        expect(graph.dispatchRunStep).not.toHaveBeenCalled();
+    });
+    it('assigns fallback id when tool_call.id is undefined', async () => {
+        const tc = {
+            id: undefined,
+            name: 'calc',
+            args: {},
+            type: 'tool_call',
+        };
+        graph.getStepIdByKey.mockImplementation(() => {
+            throw new Error('no step');
+        });
+        await handleToolCalls([tc], defaultMetadata, graph);
+        expect(tc.id).toBeDefined();
+        expect(tc.id.startsWith('toolu_')).toBe(true);
+        expect(graph.dispatchRunStep).toHaveBeenCalled();
+    });
+    it('flags messageStepHasToolCalls and dispatches TOOL_CALLS when prev step is MESSAGE_CREATION', async () => {
+        const msgStep = makeRunStep(StepTypes.MESSAGE_CREATION);
+        graph.getRunStep.mockReturnValue(msgStep);
+        await handleToolCalls([makeToolCall('id-1')], defaultMetadata, graph);
+        expect(graph.messageStepHasToolCalls.get('prev-step-id')).toBe(true);
+        const calls = graph.dispatchRunStep.mock.calls;
+        expect(calls).toHaveLength(1);
+        expect(calls[0][1]).toEqual(expect.objectContaining({ type: StepTypes.TOOL_CALLS }));
+    });
+    it('creates MESSAGE_CREATION when no previous step exists', async () => {
+        graph.getStepIdByKey.mockImplementation(() => {
+            throw new Error('no step');
+        });
+        await handleToolCalls([makeToolCall('id-1')], defaultMetadata, graph);
+        const calls = graph.dispatchRunStep.mock.calls;
+        expect(calls).toHaveLength(2);
+        expect(calls[0][1]).toEqual(expect.objectContaining({ type: StepTypes.MESSAGE_CREATION }));
+        expect(calls[1][1]).toEqual(expect.objectContaining({ type: StepTypes.TOOL_CALLS }));
+    });
+    it('reuses empty TOOL_CALLS step exactly once', async () => {
+        const emptyToolStep = makeRunStep(StepTypes.TOOL_CALLS, {
+            id: 'empty-step',
+            tool_calls: [],
+        });
+        graph.getRunStep.mockReturnValue(emptyToolStep);
+        graph.getStepIdByKey.mockReturnValue('empty-step-id');
+        await handleToolCalls([makeToolCall('id-1'), makeToolCall('id-2')], defaultMetadata, graph);
+        expect(graph.toolCallStepIds.get('id-1')).toBe('empty-step-id');
+        const calls = graph.dispatchRunStep.mock.calls;
+        expect(calls).toHaveLength(1);
+        expect(calls[0][1]).toEqual(expect.objectContaining({
+            type: StepTypes.TOOL_CALLS,
+            tool_calls: [expect.objectContaining({ id: 'id-2' })],
+        }));
+    });
+    it('gives each parallel tool call its own step (3 tool calls)', async () => {
+        const emptyToolStep = makeRunStep(StepTypes.TOOL_CALLS, { tool_calls: [] });
+        graph.getStepIdByKey.mockReturnValue('chunk-step-id');
+        let callCount = 0;
+        graph.getRunStep.mockImplementation(() => {
+            if (callCount === 0) {
+                callCount++;
+                return emptyToolStep;
+            }
+            return makeRunStep(StepTypes.TOOL_CALLS, {
+                tool_calls: [
+                    {
+                        id: 'prev',
+                        name: 'calc',
+                        args: {},
+                        type: 'tool_call',
+                    },
+                ],
+            });
+        });
+        await handleToolCalls([makeToolCall('id-1'), makeToolCall('id-2'), makeToolCall('id-3')], defaultMetadata, graph);
+        expect(graph.toolCallStepIds.get('id-1')).toBe('chunk-step-id');
+        const calls = graph.dispatchRunStep.mock.calls;
+        expect(calls).toHaveLength(2);
+        expect(calls[0][1].tool_calls[0].id).toBe('id-2');
+        expect(calls[1][1].tool_calls[0].id).toBe('id-3');
+    });
+    it('never creates MESSAGE_CREATION for parallel tool calls after TOOL_CALLS prev', async () => {
+        const emptyToolStep = makeRunStep(StepTypes.TOOL_CALLS, { tool_calls: [] });
+        graph.getStepIdByKey.mockReturnValue('chunk-step-id');
+        let callCount = 0;
+        graph.getRunStep.mockImplementation(() => {
+            if (callCount === 0) {
+                callCount++;
+                return emptyToolStep;
+            }
+            return makeRunStep(StepTypes.TOOL_CALLS, {
+                tool_calls: [
+                    {
+                        id: 'prev',
+                        name: 'calc',
+                        args: {},
+                        type: 'tool_call',
+                    },
+                ],
+            });
+        });
+        await handleToolCalls([makeToolCall('id-1'), makeToolCall('id-2'), makeToolCall('id-3')], defaultMetadata, graph);
+        const msgCreationCalls = graph.dispatchRunStep.mock.calls.filter((call) => call[1].type === StepTypes.MESSAGE_CREATION);
+        expect(msgCreationCalls).toHaveLength(0);
+    });
+    it('dispatches new TOOL_CALLS directly when prev TOOL_CALLS has existing data', async () => {
+        const populatedToolStep = makeRunStep(StepTypes.TOOL_CALLS, {
+            tool_calls: [
+                {
+                    id: 'existing',
+                    name: 'calc',
+                    args: {},
+                    type: 'tool_call',
+                },
+            ],
+        });
+        graph.getRunStep.mockReturnValue(populatedToolStep);
+        await handleToolCalls([makeToolCall('id-1')], defaultMetadata, graph);
+        const calls = graph.dispatchRunStep.mock.calls;
+        expect(calls).toHaveLength(1);
+        expect(calls[0][1]).toEqual(expect.objectContaining({ type: StepTypes.TOOL_CALLS }));
+    });
+    it('never dispatches empty text block with tool_call_ids (MESSAGE_CREATION path)', async () => {
+        const msgStep = makeRunStep(StepTypes.MESSAGE_CREATION);
+        graph.getRunStep.mockReturnValue(msgStep);
+        await handleToolCalls([makeToolCall('id-1')], defaultMetadata, graph);
+        for (const call of graph.dispatchRunStep.mock.calls) {
+            const stepDetails = call[1];
+            if (stepDetails.type === StepTypes.TOOL_CALLS) {
+                expect(stepDetails).not.toHaveProperty('content');
+                expect(stepDetails).not.toHaveProperty('text');
+            }
+        }
+    });
+    it('never dispatches empty text block with tool_call_ids (no prev step path)', async () => {
+        graph.getStepIdByKey.mockImplementation(() => {
+            throw new Error('no step');
+        });
+        await handleToolCalls([makeToolCall('id-1')], defaultMetadata, graph);
+        for (const call of graph.dispatchRunStep.mock.calls) {
+            const stepDetails = call[1];
+            if (stepDetails.type === StepTypes.TOOL_CALLS) {
+                expect(stepDetails).not.toHaveProperty('content');
+                expect(stepDetails).not.toHaveProperty('text');
+            }
+            if (stepDetails.type === StepTypes.MESSAGE_CREATION) {
+                const msgDetails = stepDetails;
+                expect(msgDetails.message_creation.message_id).toBeDefined();
+                expect(msgDetails).not.toHaveProperty('tool_call_ids');
+            }
+        }
+    });
+});
+describe('handleToolCallChunks + handleToolCalls integration', () => {
+    let graph;
+    const stepKey = 'step-key';
+    beforeEach(() => {
+        graph = createMockGraph();
+    });
+    it('Bedrock single tool: chunks create empty TOOL_CALLS, then handleToolCalls reuses it', async () => {
+        const msgStep = makeRunStep(StepTypes.MESSAGE_CREATION);
+        graph.getRunStep.mockReturnValue(msgStep);
+        await handleToolCallChunks({
+            graph: graph,
+            stepKey,
+            toolCallChunks: [makeToolCallChunk({ index: 2 })],
+            metadata: defaultMetadata,
+        });
+        const chunkStepId = graph.dispatchRunStep.mock.results[0].value;
+        const resolvedChunkStepId = await chunkStepId;
+        const emptyToolStep = makeRunStep(StepTypes.TOOL_CALLS, { tool_calls: [] });
+        graph.getRunStep.mockReturnValue(emptyToolStep);
+        graph.getStepIdByKey.mockReturnValue(resolvedChunkStepId);
+        graph.dispatchRunStep.mockClear();
+        await handleToolCalls([makeToolCall('tooluse_abc')], defaultMetadata, graph);
+        expect(graph.toolCallStepIds.get('tooluse_abc')).toBe(resolvedChunkStepId);
+        expect(graph.dispatchRunStep).not.toHaveBeenCalled();
+    });
+    it('Bedrock parallel: 3 chunks then 3 tool calls yields 3 unique step IDs', async () => {
+        const msgStep = makeRunStep(StepTypes.MESSAGE_CREATION);
+        graph.getRunStep.mockReturnValue(msgStep);
+        await handleToolCallChunks({
+            graph: graph,
+            stepKey,
+            toolCallChunks: [makeToolCallChunk({ index: 2 })],
+            metadata: defaultMetadata,
+        });
+        const chunkStepId = await graph.dispatchRunStep.mock.results[0]
+            .value;
+        const emptyToolStep = makeRunStep(StepTypes.TOOL_CALLS, { tool_calls: [] });
+        graph.getStepIdByKey.mockReturnValue(chunkStepId);
+        let callIdx = 0;
+        graph.getRunStep.mockImplementation(() => {
+            if (callIdx === 0) {
+                callIdx++;
+                return emptyToolStep;
+            }
+            return makeRunStep(StepTypes.TOOL_CALLS, {
+                tool_calls: [
+                    {
+                        id: 'prev',
+                        name: 'calc',
+                        args: {},
+                        type: 'tool_call',
+                    },
+                ],
+            });
+        });
+        graph.dispatchRunStep.mockClear();
+        let newStepCounter = 10;
+        graph.dispatchRunStep.mockImplementation(async () => `new-step-${++newStepCounter}`);
+        await handleToolCalls([makeToolCall('id-1'), makeToolCall('id-2'), makeToolCall('id-3')], defaultMetadata, graph);
+        expect(graph.toolCallStepIds.get('id-1')).toBe(chunkStepId);
+        const dispatchedIds = graph.dispatchRunStep.mock.calls.map((_, i) => graph.dispatchRunStep.mock.results[i].value);
+        expect(dispatchedIds).toHaveLength(2);
+        const allStepIds = new Set([
+            chunkStepId,
+            graph.toolCallStepIds.get('id-1'),
+            ...graph.dispatchRunStep.mock.calls.map((call) => {
+                const tc = call[1].tool_calls;
+                return tc?.[0]?.id;
+            }),
+        ]);
+        expect(graph.toolCallStepIds.get('id-1')).toBe(chunkStepId);
+        expect(allStepIds.size).toBeGreaterThanOrEqual(2);
+        const msgCreationCalls = graph.dispatchRunStep.mock.calls.filter((call) => call[1].type === StepTypes.MESSAGE_CREATION);
+        expect(msgCreationCalls).toHaveLength(0);
+    });
+});
+describe('handleServerToolResult', () => {
+    let graph;
+    const anthropicContext = { provider: Providers.ANTHROPIC };
+    beforeEach(() => {
+        graph = createMockGraph();
+    });
+    it('returns false when provider is not Anthropic', async () => {
+        const result = await handleServerToolResult({
+            graph: graph,
+            content: [{ type: 'tool_result', tool_use_id: 'tu-1', content: 'ok' }],
+            agentContext: { provider: Providers.OPENAI },
+        });
+        expect(result).toBe(false);
+    });
+    it('returns false when content is a string', async () => {
+        const result = await handleServerToolResult({
+            graph: graph,
+            content: 'plain text',
+            agentContext: anthropicContext,
+        });
+        expect(result).toBe(false);
+    });
+    it('returns false when content is null/undefined', async () => {
+        const result = await handleServerToolResult({
+            graph: graph,
+            content: undefined,
+            agentContext: anthropicContext,
+        });
+        expect(result).toBe(false);
+    });
+    it('returns false when content is empty array', async () => {
+        const result = await handleServerToolResult({
+            graph: graph,
+            content: [],
+            agentContext: anthropicContext,
+        });
+        expect(result).toBe(false);
+    });
+    it('returns false when single content item has no tool_use_id', async () => {
+        const result = await handleServerToolResult({
+            graph: graph,
+            content: [{ type: 'tool_result', content: 'ok' }],
+            agentContext: anthropicContext,
+        });
+        expect(result).toBe(false);
+    });
+    it('skips content parts with empty tool_use_id', async () => {
+        const result = await handleServerToolResult({
+            graph: graph,
+            content: [
+                { type: 'tool_result', tool_use_id: '', content: 'ok' },
+                { type: 'tool_result', tool_use_id: 'tu-valid', content: 'ok' },
+            ],
+            agentContext: anthropicContext,
+        });
+        expect(result).toBe(false);
+    });
+    it('warns and skips when toolCallStepIds has no mapping for tool_use_id', async () => {
+        const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
+        const result = await handleServerToolResult({
+            graph: graph,
+            content: [
+                { type: 'tool_result', tool_use_id: 'tu-missing', content: 'ok' },
+            ],
+            agentContext: anthropicContext,
+        });
+        expect(result).toBe(false);
+        expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('tu-missing'));
+        warnSpy.mockRestore();
+    });
+    it('warns when run step does not exist for stepId', async () => {
+        graph.toolCallStepIds.set('tu-1', 'step-1');
+        graph.getRunStep.mockReturnValue(undefined);
+        const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
+        const result = await handleServerToolResult({
+            graph: graph,
+            content: [
+                { type: 'tool_result', tool_use_id: 'tu-1', content: 'ok' },
+            ],
+            agentContext: anthropicContext,
+        });
+        expect(result).toBe(false);
+        expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('does not exist'));
+        warnSpy.mockRestore();
+    });
+    it('warns when run step is not a TOOL_CALLS type', async () => {
+        graph.toolCallStepIds.set('tu-1', 'step-1');
+        graph.getRunStep.mockReturnValue(makeRunStep(StepTypes.MESSAGE_CREATION));
+        const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
+        const result = await handleServerToolResult({
+            graph: graph,
+            content: [
+                { type: 'tool_result', tool_use_id: 'tu-1', content: 'ok' },
+            ],
+            agentContext: anthropicContext,
+        });
+        expect(result).toBe(false);
+        expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('not a tool call step'));
+        warnSpy.mockRestore();
+    });
+    it('skips when no matching tool call found in step details', async () => {
+        graph.toolCallStepIds.set('tu-1', 'step-1');
+        graph.getRunStep.mockReturnValue(makeRunStep(StepTypes.TOOL_CALLS, {
+            tool_calls: [
+                {
+                    id: 'tu-other',
+                    name: 'calc',
+                    args: {},
+                    type: 'tool_call',
+                },
+            ],
+        }));
+        const result = await handleServerToolResult({
+            graph: graph,
+            content: [
+                { type: 'tool_result', tool_use_id: 'tu-1', content: 'ok' },
+            ],
+            agentContext: anthropicContext,
+        });
+        expect(result).toBe(false);
+    });
+    it('returns true and sets skipHandling when a valid tool result is found', async () => {
+        graph.toolCallStepIds.set('tu-1', 'step-1');
+        graph.getRunStep.mockReturnValue(makeRunStep(StepTypes.TOOL_CALLS, {
+            tool_calls: [
+                {
+                    id: 'tu-1',
+                    name: 'calc',
+                    args: {},
+                    type: 'tool_call',
+                },
+            ],
+        }));
+        const result = await handleServerToolResult({
+            graph: graph,
+            content: [
+                { type: 'tool_result', tool_use_id: 'tu-1', content: 'ok' },
+            ],
+            agentContext: anthropicContext,
+        });
+        expect(result).toBe(true);
+    });
+    it('calls handleAnthropicSearchResults for web_search_result type', async () => {
+        const mockToolEndHandle = jest
+            .fn()
+            .mockResolvedValue(undefined);
+        graph.handlerRegistry = {
+            getHandler: jest.fn().mockReturnValue({ handle: mockToolEndHandle }),
+        };
+        graph.toolCallStepIds.set('tu-1', 'step-1');
+        graph.getRunStep.mockReturnValue(makeRunStep(StepTypes.TOOL_CALLS, {
+            tool_calls: [
+                {
+                    id: 'tu-1',
+                    name: 'web_search',
+                    args: { query: 'test' },
+                    type: 'tool_call',
+                },
+            ],
+        }));
+        const webSearchContent = {
+            type: 'web_search_result',
+            tool_use_id: 'tu-1',
+            content: [
+                {
+                    type: 'web_search_result',
+                    url: 'https://example.com',
+                    title: 'Example',
+                    encrypted_index: 'abc',
+                    page_age: '2024-01-01',
+                },
+            ],
+        };
+        const result = await handleServerToolResult({
+            graph: graph,
+            content: [webSearchContent],
+            metadata: defaultMetadata,
+            agentContext: anthropicContext,
+        });
+        expect(result).toBe(true);
+        expect(mockToolEndHandle).toHaveBeenCalledWith(GraphEvents.TOOL_END, expect.objectContaining({ input: { query: 'test' } }), defaultMetadata, graph);
+        expect(graph.invokedToolIds).toBeDefined();
+        expect(graph.invokedToolIds.has('tu-1')).toBe(true);
+    });
+    it('initializes invokedToolIds set when null', async () => {
+        const mockToolEndHandle = jest
+            .fn()
+            .mockResolvedValue(undefined);
+        graph.handlerRegistry = {
+            getHandler: jest.fn().mockReturnValue({ handle: mockToolEndHandle }),
+        };
+        graph.invokedToolIds = undefined;
+        graph.toolCallStepIds.set('tu-1', 'step-1');
+        graph.getRunStep.mockReturnValue(makeRunStep(StepTypes.TOOL_CALLS, {
+            tool_calls: [
+                {
+                    id: 'tu-1',
+                    name: 'web_search',
+                    args: {},
+                    type: 'tool_call',
+                },
+            ],
+        }));
+        const webSearchContent = {
+            type: 'web_search_tool_result',
+            tool_use_id: 'tu-1',
+            content: [
+                {
+                    type: 'web_search_result',
+                    url: 'https://example.com',
+                    title: 'Test',
+                    encrypted_index: 'x',
+                },
+            ],
+        };
+        await handleServerToolResult({
+            graph: graph,
+            content: [webSearchContent],
+            metadata: defaultMetadata,
+            agentContext: anthropicContext,
+        });
+        expect(graph.invokedToolIds).toBeInstanceOf(Set);
+        expect(graph.invokedToolIds.has('tu-1')).toBe(true);
+    });
+    it('warns when web search content is not an array', async () => {
+        graph.toolCallStepIds.set('tu-1', 'step-1');
+        graph.getRunStep.mockReturnValue(makeRunStep(StepTypes.TOOL_CALLS, {
+            tool_calls: [
+                {
+                    id: 'tu-1',
+                    name: 'web_search',
+                    args: {},
+                    type: 'tool_call',
+                },
+            ],
+        }));
+        const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
+        const webSearchContent = {
+            type: 'web_search_result',
+            tool_use_id: 'tu-1',
+            content: 'not an array',
+        };
+        const result = await handleServerToolResult({
+            graph: graph,
+            content: [webSearchContent],
+            metadata: defaultMetadata,
+            agentContext: anthropicContext,
+        });
+        expect(result).toBe(true);
+        expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('Expected content to be an array'));
+        warnSpy.mockRestore();
+    });
+    it('warns when content is not an Anthropic web search result', async () => {
+        graph.toolCallStepIds.set('tu-1', 'step-1');
+        graph.getRunStep.mockReturnValue(makeRunStep(StepTypes.TOOL_CALLS, {
+            tool_calls: [
+                {
+                    id: 'tu-1',
+                    name: 'web_search',
+                    args: {},
+                    type: 'tool_call',
+                },
+            ],
+        }));
+        const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
+        const webSearchContent = {
+            type: 'web_search_result',
+            tool_use_id: 'tu-1',
+            content: [{ type: 'text', text: 'not a search result' }],
+        };
+        const result = await handleServerToolResult({
+            graph: graph,
+            content: [webSearchContent],
+            metadata: defaultMetadata,
+            agentContext: anthropicContext,
+        });
+        expect(result).toBe(true);
+        expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('Expected content to be an Anthropic web search result'));
+        warnSpy.mockRestore();
+    });
+});
+//# sourceMappingURL=handlers.test.js.map