@multiplayer-app/ai-agent-node 0.1.0-beta.8 → 0.1.0-beta.80

package/dist/esm/processors/ChatProcessor.test.js

@@ -0,0 +1,801 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { ChatProcessor } from './ChatProcessor';
+import { MessageRole, AgentStatus, ChatType, AgentToolCallStatus } from '@multiplayer-app/ai-agent-types';
+import { ConfigStore } from '../store/ConfigStore';
+import { ModelStore } from '../store/ModelStore';
+import { ConfigProvider } from '../config';
+import { S3Lib } from '../libs/s3';
+import { z } from 'zod';
+describe('ChatProcessor.streamMessage', () => {
+    let chatProcessor;
+    let mockChatRepository;
+    let mockMessageRepository;
+    let mockAgentConfigRepository;
+    let mockArtifactStore;
+    let mockAgentStore;
+    let mockSocketService;
+    let mockActivityRepository;
+    let configStore;
+    let capturedOptions;
+    const userId = 'test-user-id';
+    beforeEach(() => {
+        vi.clearAllMocks();
+        capturedOptions = undefined;
+        ModelStore.getInstance().setModels([
+            { id: 'openai/gpt-4o', provider: 'openai', label: 'GPT-4o' }
+        ]);
+        // Mock repositories
+        mockChatRepository = {
+            findById: vi.fn(),
+            find: vi.fn().mockResolvedValue([]),
+            create: vi.fn(),
+            update: vi.fn(),
+            delete: vi.fn(),
+            findWithMessages: vi.fn(),
+        };
+        mockMessageRepository = {
+            findByChatId: vi.fn().mockResolvedValue([]),
+            findByChatIdPaginated: vi.fn().mockResolvedValue({ messages: [], hasMore: false }),
+            findById: vi.fn(),
+            create: vi.fn(),
+            deleteByChatId: vi.fn(),
+            update: vi.fn().mockImplementation(async (id, updates) => ({
+                id,
+                chat: 'test-chat-id',
+                role: MessageRole.Assistant,
+                content: '',
+                createdAt: new Date().toISOString(),
+                ...updates
+            })),
+        };
+        mockAgentConfigRepository = {
+            findByUserIdAndAgentName: vi.fn().mockResolvedValue(null),
+        };
+        // Mock artifact store
+        mockArtifactStore = {
+            listArtifacts: vi.fn().mockReturnValue([]),
+            deleteArtifacts: vi.fn(),
+        };
+        // Mock agent store
+        mockAgentStore = {
+            registerAgentProcess: vi.fn().mockReturnValue({
+                signal: new AbortController().signal,
+            }),
+            shareAgentProcessEvent: vi.fn(),
+            addListener: vi.fn(),
+            removeListener: vi.fn(),
+        };
+        // Mock socket service
+        mockSocketService = {
+            emitMessageUpdate: vi.fn(),
+            emitChatUpdate: vi.fn(),
+        };
+        // Setup config store with agent config
+        configStore = ConfigStore.getInstance();
+        configStore.clear();
+        const agentConfig = {
+            name: 'test-agent',
+            description: 'Test agent for property verification',
+            defaultModel: 'openai/gpt-4o',
+            systemPrompt: 'You are a helpful assistant',
+            temperature: 0.8,
+            maxOutputTokens: 3000,
+            topP: 0.95,
+            topK: 50,
+            presencePenalty: 0.6,
+            frequencyPenalty: 0.4,
+            stopSequences: ['\n\n', '---', 'END'],
+            seed: 42,
+            tools: [],
+            toolChoice: 'auto',
+        };
+        // Use addAgent to bypass ConfigHelper conversion
+        configStore.addAgent(['test-context'], agentConfig);
+        const config = ConfigProvider.getInstance().getConfig();
+        const s3Lib = new S3Lib(config.s3);
+        mockActivityRepository = {
+            create: vi.fn().mockResolvedValue({
+                id: 'activity-1',
+                ownerId: 'test-chat-id',
+                groupId: 'test-chat-id',
+                name: 'Message processing',
+                tenants: { userId: 'test-user-id' },
+                sourceId: 'user-msg-1',
+                sourceType: 'AgentMessage',
+                metadata: {}
+            }),
+            update: vi.fn().mockResolvedValue({
+                id: 'activity-1',
+                ownerId: 'test-chat-id',
+                groupId: 'test-chat-id',
+                name: 'Message processing',
+                tenants: { userId: 'test-user-id' },
+                sourceId: 'user-msg-1',
+                sourceType: 'AgentMessage',
+                metadata: {}
+            }),
+            deleteByGroupId: vi.fn().mockResolvedValue(1),
+            getGroupedMetadataByParentId: vi.fn().mockResolvedValue({}),
+            updateMetadata: vi.fn().mockResolvedValue({
+                id: 'activity-1',
+                metadata: {}
+            }),
+        };
+        // Create ChatProcessor
+        chatProcessor = new ChatProcessor({
+            chatRepository: mockChatRepository,
+            messageRepository: mockMessageRepository,
+            agentConfigRepository: mockAgentConfigRepository,
+            artifactStore: mockArtifactStore,
+            s3Lib,
+            config,
+            socketService: mockSocketService,
+            agentStore: mockAgentStore,
+            activityRepository: mockActivityRepository
+        });
+    });
+    it('should delete chat, messages, activities, and artifacts', async () => {
+        mockChatRepository.delete.mockResolvedValue(true);
+        await chatProcessor.deleteChat('chat-1');
+        expect(mockChatRepository.delete).toHaveBeenCalledWith('chat-1');
+        expect(mockMessageRepository.deleteByChatId).toHaveBeenCalledWith('chat-1');
+        expect(mockActivityRepository.deleteByGroupId).toHaveBeenCalledWith('chat-1');
+        expect(mockArtifactStore.deleteArtifacts).toHaveBeenCalledWith('chat-1');
+    });
+    it('should throw when chat does not exist and skip cleanup', async () => {
+        mockChatRepository.delete.mockResolvedValue(false);
+        await expect(chatProcessor.deleteChat('missing-chat')).rejects.toThrow('Chat not found');
+        expect(mockMessageRepository.deleteByChatId).not.toHaveBeenCalled();
+        expect(mockActivityRepository.deleteByGroupId).not.toHaveBeenCalled();
+        expect(mockArtifactStore.deleteArtifacts).not.toHaveBeenCalled();
+    });
+    it('should cascade delete subagent descendants (single level)', async () => {
+        mockChatRepository.delete.mockResolvedValue(true);
+        mockChatRepository.find.mockImplementation(async (filter) => {
+            if (filter?.parentChatId === 'chat-1') {
+                return [
+                    { id: 'sub-a', parentChatId: 'chat-1' },
+                    { id: 'sub-b', parentChatId: 'chat-1' },
+                ];
+            }
+            return [];
+        });
+        await chatProcessor.deleteChat('chat-1');
+        expect(mockChatRepository.delete).toHaveBeenCalledWith('chat-1');
+        expect(mockChatRepository.delete).toHaveBeenCalledWith('sub-a');
+        expect(mockChatRepository.delete).toHaveBeenCalledWith('sub-b');
+        for (const id of ['chat-1', 'sub-a', 'sub-b']) {
+            expect(mockMessageRepository.deleteByChatId).toHaveBeenCalledWith(id);
+            expect(mockActivityRepository.deleteByGroupId).toHaveBeenCalledWith(id);
+            expect(mockArtifactStore.deleteArtifacts).toHaveBeenCalledWith(id);
+        }
+    });
+    it('should cascade delete nested subagent descendants', async () => {
+        mockChatRepository.delete.mockResolvedValue(true);
+        const tree = {
+            'chat-1': [{ id: 'sub-a' }, { id: 'sub-b' }],
+            'sub-a': [{ id: 'sub-a-1' }],
+            'sub-a-1': [{ id: 'sub-a-1-x' }],
+            'sub-b': [],
+            'sub-a-1-x': [],
+        };
+        mockChatRepository.find.mockImplementation(async (filter) => tree[filter?.parentChatId ?? ''] ?? []);
+        await chatProcessor.deleteChat('chat-1');
+        const expectedIds = ['chat-1', 'sub-a', 'sub-b', 'sub-a-1', 'sub-a-1-x'];
+        for (const id of expectedIds) {
+            expect(mockChatRepository.delete).toHaveBeenCalledWith(id);
+            expect(mockMessageRepository.deleteByChatId).toHaveBeenCalledWith(id);
+            expect(mockActivityRepository.deleteByGroupId).toHaveBeenCalledWith(id);
+            expect(mockArtifactStore.deleteArtifacts).toHaveBeenCalledWith(id);
+        }
+    });
+    it('should pass all agent properties correctly to streamAssistantResponse', async () => {
+        const chat = {
+            id: 'test-chat-id',
+            tenants: { userId },
+            contextKey: 'test-context',
+            type: ChatType.Chat,
+            status: AgentStatus.Processing,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+        };
+        const payload = {
+            chatId: chat.id,
+            content: 'Hello, test message',
+            contextKey: 'test-context',
+        };
+        // Mock chat repository
+        mockChatRepository.findById.mockResolvedValue(chat);
+        // Mock message creation
+        const userMessage = {
+            id: 'user-msg-1',
+            chat: chat.id,
+            role: MessageRole.User,
+            content: payload.content,
+            createdAt: new Date().toISOString(),
+        };
+        const assistantMessage = {
+            id: 'assistant-msg-1',
+            chat: chat.id,
+            role: MessageRole.Assistant,
+            content: '',
+            createdAt: new Date().toISOString(),
+            agentName: 'test-agent',
+        };
+        mockMessageRepository.create
+            .mockResolvedValueOnce(userMessage)
+            .mockResolvedValueOnce(assistantMessage);
+        // Mock stream to prevent actual API calls
+        const mockStream = {
+            fullStream: (async function* () {
+                yield { type: 'finish', finishReason: 'stop', text: 'Test response' };
+            })(),
+        };
+        // Capture options passed to streamAssistantResponse
+        const aiHelper = chatProcessor.aiHelper;
+        vi.spyOn(aiHelper, 'streamAssistantResponse').mockImplementation(async (messages, signal, options) => {
+            capturedOptions = options;
+            return mockStream;
+        });
+        // Call streamMessage
+        await chatProcessor.streamMessage(chat, payload);
+        // Verify options were captured
+        expect(capturedOptions).toBeDefined();
+        // Verify all agent properties are present in the options
+        if (capturedOptions) {
+            expect(capturedOptions).toHaveProperty('name', 'test-agent');
+            expect(capturedOptions).toHaveProperty('system', 'You are a helpful assistant');
+            expect(capturedOptions).toHaveProperty('temperature', 0.8);
+            expect(capturedOptions).toHaveProperty('maxOutputTokens', 3000);
+            expect(capturedOptions).toHaveProperty('topP', 0.95);
+            expect(capturedOptions).toHaveProperty('topK', 50);
+            expect(capturedOptions).toHaveProperty('presencePenalty', 0.6);
+            expect(capturedOptions).toHaveProperty('frequencyPenalty', 0.4);
+            expect(capturedOptions).toHaveProperty('stopSequences', ['\n\n', '---', 'END']);
+            expect(capturedOptions).toHaveProperty('seed', 42);
+            expect(capturedOptions).toHaveProperty('toolChoice', 'auto');
+            expect(capturedOptions).toHaveProperty('tools');
+        }
+    });
+    it('should handle optional agent properties when not provided', async () => {
+        configStore.clear();
+        const minimalAgentConfig = {
+            name: 'minimal-agent',
+            description: 'Minimal agent config',
+            systemPrompt: 'You are helpful',
+            tools: [],
+        };
+        configStore.addAgent(['test-context'], minimalAgentConfig);
+        const chat = {
+            id: 'test-chat-id-2',
+            tenants: { userId },
+            contextKey: 'test-context',
+            type: ChatType.Chat,
+            status: AgentStatus.Processing,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+        };
+        const payload = {
+            chatId: chat.id,
+            content: 'Test',
+            contextKey: 'test-context',
+        };
+        mockChatRepository.findById.mockResolvedValue(chat);
+        const userMessage = {
+            id: 'user-msg-2',
+            chat: chat.id,
+            role: MessageRole.User,
+            content: payload.content,
+            createdAt: new Date().toISOString(),
+        };
+        const assistantMessage = {
+            id: 'assistant-msg-2',
+            chat: chat.id,
+            role: MessageRole.Assistant,
+            content: '',
+            createdAt: new Date().toISOString(),
+            agentName: 'minimal-agent',
+        };
+        mockMessageRepository.create
+            .mockResolvedValueOnce(userMessage)
+            .mockResolvedValueOnce(assistantMessage);
+        const mockStream = {
+            fullStream: (async function* () {
+                yield { type: 'finish', finishReason: 'stop', text: 'Response' };
+            })(),
+        };
+        const aiHelper = chatProcessor.aiHelper;
+        vi.spyOn(aiHelper, 'streamAssistantResponse').mockImplementation(async (messages, signal, options) => {
+            capturedOptions = options;
+            return mockStream;
+        });
+        await chatProcessor.streamMessage(chat, payload);
+        // Verify required properties are present
+        expect(capturedOptions).toBeDefined();
+        if (capturedOptions) {
+            expect(capturedOptions).toHaveProperty('name', 'minimal-agent');
+            expect(capturedOptions).toHaveProperty('system', 'You are helpful');
+            expect(capturedOptions).toHaveProperty('tools');
+        }
+    });
+    it('should pass stopWhen condition when provided', async () => {
+        configStore.clear();
+        const stopWhenFn = vi.fn(() => false);
+        const agentConfigWithStopWhen = {
+            name: 'agent-with-stopwhen',
+            description: 'Agent with stopWhen',
+            systemPrompt: 'You are helpful',
+            tools: [],
+            stopWhen: stopWhenFn,
+        };
+        configStore.addAgent(['test-context'], agentConfigWithStopWhen);
+        const chat = {
+            id: 'test-chat-id-3',
+            tenants: { userId },
+            contextKey: 'test-context',
+            type: ChatType.Chat,
+            status: AgentStatus.Processing,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+        };
+        const payload = {
+            chatId: chat.id,
+            content: 'Test',
+            contextKey: 'test-context',
+        };
+        mockChatRepository.findById.mockResolvedValue(chat);
+        const userMessage = {
+            id: 'user-msg-3',
+            chat: chat.id,
+            role: MessageRole.User,
+            content: payload.content,
+            createdAt: new Date().toISOString(),
+        };
+        const assistantMessage = {
+            id: 'assistant-msg-3',
+            chat: chat.id,
+            role: MessageRole.Assistant,
+            content: '',
+            createdAt: new Date().toISOString(),
+            agentName: 'agent-with-stopwhen',
+        };
+        mockMessageRepository.create
+            .mockResolvedValueOnce(userMessage)
+            .mockResolvedValueOnce(assistantMessage);
+        const mockStream = {
+            fullStream: (async function* () {
+                yield { type: 'finish', finishReason: 'stop', text: 'Response' };
+            })(),
+        };
+        const aiHelper = chatProcessor.aiHelper;
+        vi.spyOn(aiHelper, 'streamAssistantResponse').mockImplementation(async (messages, signal, options) => {
+            capturedOptions = options;
+            return mockStream;
+        });
+        await chatProcessor.streamMessage(chat, payload);
+        // Verify stopWhen is passed
+        expect(capturedOptions).toBeDefined();
+        if (capturedOptions) {
+            expect(capturedOptions).toHaveProperty('stopWhen', stopWhenFn);
+        }
+    });
+    it('should merge only cost-related provider usage into stored activity metadata', async () => {
+        const chat = {
+            id: 'test-chat-id-usage',
+            tenants: { userId },
+            contextKey: 'test-context',
+            type: ChatType.Chat,
+            status: AgentStatus.Processing,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+        };
+        await chatProcessor.storeStepActivity({
+            chat,
+            stepResult: {
+                finishReason: 'stop',
+                usage: {
+                    inputTokens: 205,
+                    outputTokens: 3,
+                    totalTokens: 209,
+                    inputTokenDetails: { cacheReadTokens: 0 },
+                },
+                response: {
+                    timestamp: new Date().toISOString(),
+                    modelId: 'openai/gpt-4o',
+                },
+                providerMetadata: {
+                    openrouter: {
+                        provider: 'OpenAI',
+                        usage: {
+                            promptTokens: 205,
+                            promptTokensDetails: { cachedTokens: 0 },
+                            completionTokens: 3,
+                            totalTokens: 208,
+                            cost: 0.0005425,
+                            costDetails: {
+                                upstreamInferenceCost: 0.0005425,
+                            },
+                        },
+                    },
+                },
+            },
+            name: 'titleGeneration',
+            sourceId: chat.id,
+            sourceType: 'Chat',
+        });
+        expect(mockActivityRepository.create).toHaveBeenCalledTimes(1);
+        const [activityPayload] = mockActivityRepository.create.mock.calls[0];
+        expect(activityPayload.metadata.usage).toMatchObject({
+            inputTokens: 205,
+            outputTokens: 3,
+            totalTokens: 209,
+            inputTokenDetails: { cacheReadTokens: 0 },
+            cost: 0.0005425,
+            costDetails: { upstreamInferenceCost: 0.0005425 },
+        });
+        expect(activityPayload.metadata.usage.promptTokens).toBeUndefined();
+        expect(activityPayload.metadata.usage.completionTokens).toBeUndefined();
+        expect(activityPayload.metadata.usage.promptTokensDetails).toBeUndefined();
+    });
+});
+describe('ChatProcessor.getMessages', () => {
+    let chatProcessor;
+    let mockChatRepository;
+    let mockMessageRepository;
+    let mockAgentConfigRepository;
+    let mockActivityRepository;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockChatRepository = { findById: vi.fn() };
+        mockMessageRepository = {
+            findByChatIdPaginated: vi.fn().mockResolvedValue({ messages: [], hasMore: false }),
+        };
+        mockAgentConfigRepository = {
+            findByUserIdAndAgentName: vi.fn().mockResolvedValue(null),
+        };
+        mockActivityRepository = {
+            create: vi.fn(),
+            update: vi.fn(),
+            deleteByGroupId: vi.fn(),
+        };
+        const config = ConfigProvider.getInstance().getConfig();
+        const s3Lib = new S3Lib(config.s3);
+        chatProcessor = new ChatProcessor({
+            chatRepository: mockChatRepository,
+            messageRepository: mockMessageRepository,
+            agentConfigRepository: mockAgentConfigRepository,
+            artifactStore: { listArtifacts: vi.fn().mockReturnValue([]), deleteArtifacts: vi.fn() },
+            s3Lib,
+            config,
+            socketService: { emitMessageUpdate: vi.fn(), emitChatUpdate: vi.fn() },
+            agentStore: {
+                registerAgentProcess: vi.fn().mockReturnValue({ signal: new AbortController().signal }),
+                shareAgentProcessEvent: vi.fn(),
+                addListener: vi.fn(),
+                removeListener: vi.fn(),
+            },
+            activityRepository: mockActivityRepository,
+        });
+        const aiHelper = chatProcessor.aiHelper;
+        vi.spyOn(aiHelper, 'getAgentOptions').mockResolvedValue({
+            name: 'test-agent',
+            tools: {
+                test_tool: {
+                    inputSchema: z.object({
+                        foo: z.any().optional(),
+                        count: z.any().optional(),
+                        x: z.any().optional(),
+                    }),
+                },
+            },
+        });
+    });
+    it('returns messages page when chat exists', async () => {
+        const chatId = 'chat-1';
+        const messages = [
+            {
+                id: 'm1',
+                chat: chatId,
+                role: MessageRole.User,
+                content: 'Hi',
+                createdAt: new Date().toISOString(),
+            },
+        ];
+        mockChatRepository.findById.mockResolvedValue({ id: chatId });
+        mockMessageRepository.findByChatIdPaginated.mockResolvedValue({
+            messages,
+            hasMore: true,
+        });
+        const result = await chatProcessor.getMessages(chatId, { limit: 30 });
+        expect(result).toEqual({ messages, hasMore: true });
+        expect(mockMessageRepository.findByChatIdPaginated).toHaveBeenCalledWith(chatId, {
+            limit: 30,
+            before: undefined,
+        });
+    });
+    it('throws when chat not found', async () => {
+        mockChatRepository.findById.mockResolvedValue(null);
+        await expect(chatProcessor.getMessages('missing-chat')).rejects.toThrow('Chat not found');
+        expect(mockMessageRepository.findByChatIdPaginated).not.toHaveBeenCalled();
+    });
+});
+describe('ChatProcessor.updateToolCall', () => {
+    let chatProcessor;
+    let mockChatRepository;
+    let mockMessageRepository;
+    let mockAgentConfigRepository;
+    let mockActivityRepository;
+    let mockSocketService;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockChatRepository = {
+            findById: vi.fn(),
+            update: vi.fn(),
+        };
+        mockMessageRepository = {
+            findById: vi.fn(),
+            updateToolCall: vi.fn(),
+        };
+        mockAgentConfigRepository = {
+            findByUserIdAndAgentName: vi.fn().mockResolvedValue(null),
+        };
+        mockActivityRepository = {
+            create: vi.fn(),
+            update: vi.fn(),
+            deleteByGroupId: vi.fn(),
+        };
+        mockSocketService = {
+            emitMessageUpdate: vi.fn(),
+            emitChatUpdate: vi.fn(),
+        };
+        const config = ConfigProvider.getInstance().getConfig();
+        const s3Lib = new S3Lib(config.s3);
+        chatProcessor = new ChatProcessor({
+            chatRepository: mockChatRepository,
+            messageRepository: mockMessageRepository,
+            agentConfigRepository: mockAgentConfigRepository,
+            artifactStore: { listArtifacts: vi.fn().mockReturnValue([]), deleteArtifacts: vi.fn() },
+            s3Lib,
+            config,
+            socketService: mockSocketService,
+            agentStore: {
+                registerAgentProcess: vi.fn().mockReturnValue({ signal: new AbortController().signal }),
+                shareAgentProcessEvent: vi.fn(),
+                addListener: vi.fn(),
+                removeListener: vi.fn(),
+            },
+            activityRepository: mockActivityRepository,
+        });
+    });
+    it('updates targeted tool call input and emits update', async () => {
+        const chatId = 'chat-1';
+        const messageId = 'message-1';
+        const toolCallId = 'tool-call-1';
+        const userId = 'user-1';
+        const updatedInput = { foo: 'bar', count: 1 };
+        const now = new Date().toISOString();
+        mockChatRepository.findById.mockResolvedValue({
+            id: chatId,
+            tenants: { userId },
+        });
+        mockMessageRepository.findById.mockResolvedValue({
+            id: messageId,
+            chat: chatId,
+            role: MessageRole.Assistant,
+            content: '',
+            createdAt: now,
+            toolCalls: [
+                {
+                    id: toolCallId,
+                    name: 'test_tool',
+                    input: { foo: 'old' },
+                    status: AgentToolCallStatus.Pending,
+                },
+            ],
+        });
+        mockMessageRepository.updateToolCall.mockResolvedValue({
+            id: messageId,
+            chat: chatId,
+            role: MessageRole.Assistant,
+            content: '',
+            createdAt: now,
+            toolCalls: [
+                {
+                    id: toolCallId,
+                    name: 'test_tool',
+                    input: updatedInput,
+                    status: AgentToolCallStatus.Pending,
+                },
+            ],
+        });
+        const aiHelper = chatProcessor.aiHelper;
+        vi.spyOn(aiHelper, 'getAgentOptions').mockResolvedValue({
+            name: 'test-agent',
+            tools: {
+                test_tool: {
+                    inputSchema: z.object({
+                        foo: z.any().optional(),
+                        count: z.any().optional(),
+                    }),
+                },
+            },
+        });
+        const result = await chatProcessor.updateToolCall({
+            chatId,
+            messageId,
+            toolCallId,
+            input: updatedInput,
+            excludeSocketId: 'socket-1',
+        });
+        expect(mockMessageRepository.updateToolCall).toHaveBeenCalledWith(messageId, toolCallId, {
+            input: updatedInput,
+        });
+        expect(mockChatRepository.update).toHaveBeenCalledWith(chatId, expect.objectContaining({ updatedAt: expect.any(String) }));
+        expect(mockSocketService.emitMessageUpdate).toHaveBeenCalledWith(userId, result, 'socket-1');
+        expect(result.toolCalls?.[0].input).toEqual(updatedInput);
+    });
+    it('updates targeted tool call output and status', async () => {
+        const chatId = 'chat-1';
+        const messageId = 'message-1';
+        const toolCallId = 'tool-call-1';
+        const userId = 'user-1';
+        const now = new Date().toISOString();
+        mockChatRepository.findById.mockResolvedValue({
+            id: chatId,
+            tenants: { userId },
+        });
+        mockMessageRepository.findById.mockResolvedValue({
+            id: messageId,
+            chat: chatId,
+            role: MessageRole.Assistant,
+            content: '',
+            createdAt: now,
+            toolCalls: [
+                {
+                    id: toolCallId,
+                    name: 'test_tool',
+                    input: { foo: 'old' },
+                    status: AgentToolCallStatus.Running,
+                },
+            ],
+        });
+        mockMessageRepository.updateToolCall.mockResolvedValue({
+            id: messageId,
+            chat: chatId,
+            role: MessageRole.Assistant,
+            content: '',
+            createdAt: now,
+            toolCalls: [
+                {
+                    id: toolCallId,
+                    name: 'test_tool',
+                    input: { foo: 'old' },
+                    output: { result: 'ok' },
+                    status: AgentToolCallStatus.Succeeded,
+                },
+            ],
+        });
+        const result = await chatProcessor.updateToolCall({
+            chatId,
+            messageId,
+            toolCallId,
+            output: { result: 'ok' },
+            status: AgentToolCallStatus.Succeeded,
+            excludeSocketId: 'socket-1',
+        });
+        expect(mockMessageRepository.updateToolCall).toHaveBeenCalledWith(messageId, toolCallId, {
+            output: { result: 'ok' },
+            status: AgentToolCallStatus.Succeeded,
+        });
+        expect(mockChatRepository.update).toHaveBeenCalledWith(chatId, expect.objectContaining({ updatedAt: expect.any(String) }));
+        expect(mockSocketService.emitMessageUpdate).toHaveBeenCalledWith(userId, result, 'socket-1');
+        expect(result.toolCalls?.[0].status).toBe(AgentToolCallStatus.Succeeded);
+        expect(result.toolCalls?.[0].output).toEqual({ result: 'ok' });
+    });
+    it('throws when message is not in chat', async () => {
+        mockChatRepository.findById.mockResolvedValue({ id: 'chat-1', tenants: { userId: 'user-1' } });
+        mockMessageRepository.findById.mockResolvedValue({
+            id: 'message-1',
+            chat: 'other-chat',
+            role: MessageRole.Assistant,
+            content: '',
+            createdAt: new Date().toISOString(),
+            toolCalls: [],
+        });
+        await expect(chatProcessor.updateToolCall({
+            chatId: 'chat-1',
+            messageId: 'message-1',
+            toolCallId: 'tool-call-1',
+            input: { x: 1 },
+        })).rejects.toThrow('Message not found or does not belong to this chat');
+        expect(mockMessageRepository.updateToolCall).not.toHaveBeenCalled();
+    });
+    it('throws when chat does not belong to user', async () => {
+        mockChatRepository.findById.mockResolvedValue({ id: 'chat-1', tenants: { userId: 'owner-1' } });
+        await expect(chatProcessor.updateToolCall({
+            chatId: 'chat-1',
+            messageId: 'message-1',
+            toolCallId: 'tool-call-1',
+            userId: 'other-user',
+            input: { x: 1 },
+        })).rejects.toThrow('Chat does not belong to this user');
+        expect(mockMessageRepository.findById).not.toHaveBeenCalled();
+        expect(mockMessageRepository.updateToolCall).not.toHaveBeenCalled();
+    });
+    it('throws when tool call does not exist in message', async () => {
+        mockChatRepository.findById.mockResolvedValue({ id: 'chat-1', tenants: { userId: 'user-1' } });
+        mockMessageRepository.findById.mockResolvedValue({
+            id: 'message-1',
+            chat: 'chat-1',
+            role: MessageRole.Assistant,
+            content: '',
+            createdAt: new Date().toISOString(),
+            toolCalls: [
+                {
+                    id: 'other-tool-call',
+                    name: 'test_tool',
+                    input: {},
+                    status: AgentToolCallStatus.Pending,
+                },
+            ],
+        });
+        await expect(chatProcessor.updateToolCall({
+            chatId: 'chat-1',
+            messageId: 'message-1',
+            toolCallId: 'tool-call-1',
+            input: { x: 1 },
+        })).rejects.toThrow('Tool call not found in message');
+        expect(mockMessageRepository.updateToolCall).not.toHaveBeenCalled();
+    });
+    it('throws when no tool call fields are provided', async () => {
+        await expect(chatProcessor.updateToolCall({
+            chatId: 'chat-1',
+            messageId: 'message-1',
+            toolCallId: 'tool-call-1',
+        })).rejects.toThrow('At least one of input, output, or status must be provided');
+    });
+    it('throws when input does not match tool schema', async () => {
+        const chatId = 'chat-1';
+        const messageId = 'message-1';
+        const toolCallId = 'tool-call-1';
+        mockChatRepository.findById.mockResolvedValue({
+            id: chatId,
+            tenants: { userId: 'user-1' },
+        });
+        mockMessageRepository.findById.mockResolvedValue({
+            id: messageId,
+            chat: chatId,
+            role: MessageRole.Assistant,
+            content: '',
+            createdAt: new Date().toISOString(),
+            toolCalls: [
+                {
+                    id: toolCallId,
+                    name: 'test_tool',
+                    input: {},
+                    status: AgentToolCallStatus.Pending,
+                },
+            ],
+            agentName: 'test-agent',
+        });
+        const aiHelper = chatProcessor.aiHelper;
+        vi.spyOn(aiHelper, 'getAgentOptions').mockResolvedValue({
+            name: 'test-agent',
+            tools: {
+                test_tool: {
+                    inputSchema: z.object({
+                        x: z.number(),
+                    }),
+                },
+            },
+        });
+        await expect(chatProcessor.updateToolCall({
+            chatId,
+            messageId,
+            toolCallId,
+            input: { x: 'invalid' },
+        })).rejects.toThrow('Invalid tool input for "test_tool"');
+        expect(mockMessageRepository.updateToolCall).not.toHaveBeenCalled();
+    });
+});
+//# sourceMappingURL=ChatProcessor.test.js.map