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

package/dist/cjs/processors/ChatProcessor.test.cjs

@@ -0,0 +1,803 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const ChatProcessor_1 = require("./ChatProcessor.cjs");
+const ai_agent_types_1 = require("@multiplayer-app/ai-agent-types");
+const ConfigStore_1 = require("../store/ConfigStore.cjs");
+const ModelStore_1 = require("../store/ModelStore.cjs");
+const config_1 = require("../config.cjs");
+const s3_1 = require("../libs/s3/index.cjs");
+const zod_1 = require("zod");
+(0, vitest_1.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';
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.clearAllMocks();
+        capturedOptions = undefined;
+        ModelStore_1.ModelStore.getInstance().setModels([
+            { id: 'openai/gpt-4o', provider: 'openai', label: 'GPT-4o' }
+        ]);
+        // Mock repositories
+        mockChatRepository = {
+            findById: vitest_1.vi.fn(),
+            find: vitest_1.vi.fn().mockResolvedValue([]),
+            create: vitest_1.vi.fn(),
+            update: vitest_1.vi.fn(),
+            delete: vitest_1.vi.fn(),
+            findWithMessages: vitest_1.vi.fn(),
+        };
+        mockMessageRepository = {
+            findByChatId: vitest_1.vi.fn().mockResolvedValue([]),
+            findByChatIdPaginated: vitest_1.vi.fn().mockResolvedValue({ messages: [], hasMore: false }),
+            findById: vitest_1.vi.fn(),
+            create: vitest_1.vi.fn(),
+            deleteByChatId: vitest_1.vi.fn(),
+            update: vitest_1.vi.fn().mockImplementation(async (id, updates) => ({
+                id,
+                chat: 'test-chat-id',
+                role: ai_agent_types_1.MessageRole.Assistant,
+                content: '',
+                createdAt: new Date().toISOString(),
+                ...updates
+            })),
+        };
+        mockAgentConfigRepository = {
+            findByUserIdAndAgentName: vitest_1.vi.fn().mockResolvedValue(null),
+        };
+        // Mock artifact store
+        mockArtifactStore = {
+            listArtifacts: vitest_1.vi.fn().mockReturnValue([]),
+            deleteArtifacts: vitest_1.vi.fn(),
+        };
+        // Mock agent store
+        mockAgentStore = {
+            registerAgentProcess: vitest_1.vi.fn().mockReturnValue({
+                signal: new AbortController().signal,
+            }),
+            shareAgentProcessEvent: vitest_1.vi.fn(),
+            addListener: vitest_1.vi.fn(),
+            removeListener: vitest_1.vi.fn(),
+        };
+        // Mock socket service
+        mockSocketService = {
+            emitMessageUpdate: vitest_1.vi.fn(),
+            emitChatUpdate: vitest_1.vi.fn(),
+        };
+        // Setup config store with agent config
+        configStore = ConfigStore_1.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 = config_1.ConfigProvider.getInstance().getConfig();
+        const s3Lib = new s3_1.S3Lib(config.s3);
+        mockActivityRepository = {
+            create: vitest_1.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: vitest_1.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: vitest_1.vi.fn().mockResolvedValue(1),
+            getGroupedMetadataByParentId: vitest_1.vi.fn().mockResolvedValue({}),
+            updateMetadata: vitest_1.vi.fn().mockResolvedValue({
+                id: 'activity-1',
+                metadata: {}
+            }),
+        };
+        // Create ChatProcessor
+        chatProcessor = new ChatProcessor_1.ChatProcessor({
+            chatRepository: mockChatRepository,
+            messageRepository: mockMessageRepository,
+            agentConfigRepository: mockAgentConfigRepository,
+            artifactStore: mockArtifactStore,
+            s3Lib,
+            config,
+            socketService: mockSocketService,
+            agentStore: mockAgentStore,
+            activityRepository: mockActivityRepository
+        });
+    });
+    (0, vitest_1.it)('should delete chat, messages, activities, and artifacts', async () => {
+        mockChatRepository.delete.mockResolvedValue(true);
+        await chatProcessor.deleteChat('chat-1');
+        (0, vitest_1.expect)(mockChatRepository.delete).toHaveBeenCalledWith('chat-1');
+        (0, vitest_1.expect)(mockMessageRepository.deleteByChatId).toHaveBeenCalledWith('chat-1');
+        (0, vitest_1.expect)(mockActivityRepository.deleteByGroupId).toHaveBeenCalledWith('chat-1');
+        (0, vitest_1.expect)(mockArtifactStore.deleteArtifacts).toHaveBeenCalledWith('chat-1');
+    });
+    (0, vitest_1.it)('should throw when chat does not exist and skip cleanup', async () => {
+        mockChatRepository.delete.mockResolvedValue(false);
+        await (0, vitest_1.expect)(chatProcessor.deleteChat('missing-chat')).rejects.toThrow('Chat not found');
+        (0, vitest_1.expect)(mockMessageRepository.deleteByChatId).not.toHaveBeenCalled();
+        (0, vitest_1.expect)(mockActivityRepository.deleteByGroupId).not.toHaveBeenCalled();
+        (0, vitest_1.expect)(mockArtifactStore.deleteArtifacts).not.toHaveBeenCalled();
+    });
+    (0, vitest_1.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');
+        (0, vitest_1.expect)(mockChatRepository.delete).toHaveBeenCalledWith('chat-1');
+        (0, vitest_1.expect)(mockChatRepository.delete).toHaveBeenCalledWith('sub-a');
+        (0, vitest_1.expect)(mockChatRepository.delete).toHaveBeenCalledWith('sub-b');
+        for (const id of ['chat-1', 'sub-a', 'sub-b']) {
+            (0, vitest_1.expect)(mockMessageRepository.deleteByChatId).toHaveBeenCalledWith(id);
+            (0, vitest_1.expect)(mockActivityRepository.deleteByGroupId).toHaveBeenCalledWith(id);
+            (0, vitest_1.expect)(mockArtifactStore.deleteArtifacts).toHaveBeenCalledWith(id);
+        }
+    });
+    (0, vitest_1.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) {
+            (0, vitest_1.expect)(mockChatRepository.delete).toHaveBeenCalledWith(id);
+            (0, vitest_1.expect)(mockMessageRepository.deleteByChatId).toHaveBeenCalledWith(id);
+            (0, vitest_1.expect)(mockActivityRepository.deleteByGroupId).toHaveBeenCalledWith(id);
+            (0, vitest_1.expect)(mockArtifactStore.deleteArtifacts).toHaveBeenCalledWith(id);
+        }
+    });
+    (0, vitest_1.it)('should pass all agent properties correctly to streamAssistantResponse', async () => {
+        const chat = {
+            id: 'test-chat-id',
+            tenants: { userId },
+            contextKey: 'test-context',
+            type: ai_agent_types_1.ChatType.Chat,
+            status: ai_agent_types_1.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: ai_agent_types_1.MessageRole.User,
+            content: payload.content,
+            createdAt: new Date().toISOString(),
+        };
+        const assistantMessage = {
+            id: 'assistant-msg-1',
+            chat: chat.id,
+            role: ai_agent_types_1.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;
+        vitest_1.vi.spyOn(aiHelper, 'streamAssistantResponse').mockImplementation(async (messages, signal, options) => {
+            capturedOptions = options;
+            return mockStream;
+        });
+        // Call streamMessage
+        await chatProcessor.streamMessage(chat, payload);
+        // Verify options were captured
+        (0, vitest_1.expect)(capturedOptions).toBeDefined();
+        // Verify all agent properties are present in the options
+        if (capturedOptions) {
+            (0, vitest_1.expect)(capturedOptions).toHaveProperty('name', 'test-agent');
+            (0, vitest_1.expect)(capturedOptions).toHaveProperty('system', 'You are a helpful assistant');
+            (0, vitest_1.expect)(capturedOptions).toHaveProperty('temperature', 0.8);
+            (0, vitest_1.expect)(capturedOptions).toHaveProperty('maxOutputTokens', 3000);
+            (0, vitest_1.expect)(capturedOptions).toHaveProperty('topP', 0.95);
+            (0, vitest_1.expect)(capturedOptions).toHaveProperty('topK', 50);
+            (0, vitest_1.expect)(capturedOptions).toHaveProperty('presencePenalty', 0.6);
+            (0, vitest_1.expect)(capturedOptions).toHaveProperty('frequencyPenalty', 0.4);
+            (0, vitest_1.expect)(capturedOptions).toHaveProperty('stopSequences', ['\n\n', '---', 'END']);
+            (0, vitest_1.expect)(capturedOptions).toHaveProperty('seed', 42);
+            (0, vitest_1.expect)(capturedOptions).toHaveProperty('toolChoice', 'auto');
+            (0, vitest_1.expect)(capturedOptions).toHaveProperty('tools');
+        }
+    });
+    (0, vitest_1.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: ai_agent_types_1.ChatType.Chat,
+            status: ai_agent_types_1.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: ai_agent_types_1.MessageRole.User,
+            content: payload.content,
+            createdAt: new Date().toISOString(),
+        };
+        const assistantMessage = {
+            id: 'assistant-msg-2',
+            chat: chat.id,
+            role: ai_agent_types_1.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;
+        vitest_1.vi.spyOn(aiHelper, 'streamAssistantResponse').mockImplementation(async (messages, signal, options) => {
+            capturedOptions = options;
+            return mockStream;
+        });
+        await chatProcessor.streamMessage(chat, payload);
+        // Verify required properties are present
+        (0, vitest_1.expect)(capturedOptions).toBeDefined();
+        if (capturedOptions) {
+            (0, vitest_1.expect)(capturedOptions).toHaveProperty('name', 'minimal-agent');
+            (0, vitest_1.expect)(capturedOptions).toHaveProperty('system', 'You are helpful');
+            (0, vitest_1.expect)(capturedOptions).toHaveProperty('tools');
+        }
+    });
+    (0, vitest_1.it)('should pass stopWhen condition when provided', async () => {
+        configStore.clear();
+        const stopWhenFn = vitest_1.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: ai_agent_types_1.ChatType.Chat,
+            status: ai_agent_types_1.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: ai_agent_types_1.MessageRole.User,
+            content: payload.content,
+            createdAt: new Date().toISOString(),
+        };
+        const assistantMessage = {
+            id: 'assistant-msg-3',
+            chat: chat.id,
+            role: ai_agent_types_1.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;
+        vitest_1.vi.spyOn(aiHelper, 'streamAssistantResponse').mockImplementation(async (messages, signal, options) => {
+            capturedOptions = options;
+            return mockStream;
+        });
+        await chatProcessor.streamMessage(chat, payload);
+        // Verify stopWhen is passed
+        (0, vitest_1.expect)(capturedOptions).toBeDefined();
+        if (capturedOptions) {
+            (0, vitest_1.expect)(capturedOptions).toHaveProperty('stopWhen', stopWhenFn);
+        }
+    });
+    (0, vitest_1.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: ai_agent_types_1.ChatType.Chat,
+            status: ai_agent_types_1.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',
+        });
+        (0, vitest_1.expect)(mockActivityRepository.create).toHaveBeenCalledTimes(1);
+        const [activityPayload] = mockActivityRepository.create.mock.calls[0];
+        (0, vitest_1.expect)(activityPayload.metadata.usage).toMatchObject({
+            inputTokens: 205,
+            outputTokens: 3,
+            totalTokens: 209,
+            inputTokenDetails: { cacheReadTokens: 0 },
+            cost: 0.0005425,
+            costDetails: { upstreamInferenceCost: 0.0005425 },
+        });
+        (0, vitest_1.expect)(activityPayload.metadata.usage.promptTokens).toBeUndefined();
+        (0, vitest_1.expect)(activityPayload.metadata.usage.completionTokens).toBeUndefined();
+        (0, vitest_1.expect)(activityPayload.metadata.usage.promptTokensDetails).toBeUndefined();
+    });
+});
+(0, vitest_1.describe)('ChatProcessor.getMessages', () => {
+    let chatProcessor;
+    let mockChatRepository;
+    let mockMessageRepository;
+    let mockAgentConfigRepository;
+    let mockActivityRepository;
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.clearAllMocks();
+        mockChatRepository = { findById: vitest_1.vi.fn() };
+        mockMessageRepository = {
+            findByChatIdPaginated: vitest_1.vi.fn().mockResolvedValue({ messages: [], hasMore: false }),
+        };
+        mockAgentConfigRepository = {
+            findByUserIdAndAgentName: vitest_1.vi.fn().mockResolvedValue(null),
+        };
+        mockActivityRepository = {
+            create: vitest_1.vi.fn(),
+            update: vitest_1.vi.fn(),
+            deleteByGroupId: vitest_1.vi.fn(),
+        };
+        const config = config_1.ConfigProvider.getInstance().getConfig();
+        const s3Lib = new s3_1.S3Lib(config.s3);
+        chatProcessor = new ChatProcessor_1.ChatProcessor({
+            chatRepository: mockChatRepository,
+            messageRepository: mockMessageRepository,
+            agentConfigRepository: mockAgentConfigRepository,
+            artifactStore: { listArtifacts: vitest_1.vi.fn().mockReturnValue([]), deleteArtifacts: vitest_1.vi.fn() },
+            s3Lib,
+            config,
+            socketService: { emitMessageUpdate: vitest_1.vi.fn(), emitChatUpdate: vitest_1.vi.fn() },
+            agentStore: {
+                registerAgentProcess: vitest_1.vi.fn().mockReturnValue({ signal: new AbortController().signal }),
+                shareAgentProcessEvent: vitest_1.vi.fn(),
+                addListener: vitest_1.vi.fn(),
+                removeListener: vitest_1.vi.fn(),
+            },
+            activityRepository: mockActivityRepository,
+        });
+        const aiHelper = chatProcessor.aiHelper;
+        vitest_1.vi.spyOn(aiHelper, 'getAgentOptions').mockResolvedValue({
+            name: 'test-agent',
+            tools: {
+                test_tool: {
+                    inputSchema: zod_1.z.object({
+                        foo: zod_1.z.any().optional(),
+                        count: zod_1.z.any().optional(),
+                        x: zod_1.z.any().optional(),
+                    }),
+                },
+            },
+        });
+    });
+    (0, vitest_1.it)('returns messages page when chat exists', async () => {
+        const chatId = 'chat-1';
+        const messages = [
+            {
+                id: 'm1',
+                chat: chatId,
+                role: ai_agent_types_1.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 });
+        (0, vitest_1.expect)(result).toEqual({ messages, hasMore: true });
+        (0, vitest_1.expect)(mockMessageRepository.findByChatIdPaginated).toHaveBeenCalledWith(chatId, {
+            limit: 30,
+            before: undefined,
+        });
+    });
+    (0, vitest_1.it)('throws when chat not found', async () => {
+        mockChatRepository.findById.mockResolvedValue(null);
+        await (0, vitest_1.expect)(chatProcessor.getMessages('missing-chat')).rejects.toThrow('Chat not found');
+        (0, vitest_1.expect)(mockMessageRepository.findByChatIdPaginated).not.toHaveBeenCalled();
+    });
+});
+(0, vitest_1.describe)('ChatProcessor.updateToolCall', () => {
+    let chatProcessor;
+    let mockChatRepository;
+    let mockMessageRepository;
+    let mockAgentConfigRepository;
+    let mockActivityRepository;
+    let mockSocketService;
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.clearAllMocks();
+        mockChatRepository = {
+            findById: vitest_1.vi.fn(),
+            update: vitest_1.vi.fn(),
+        };
+        mockMessageRepository = {
+            findById: vitest_1.vi.fn(),
+            updateToolCall: vitest_1.vi.fn(),
+        };
+        mockAgentConfigRepository = {
+            findByUserIdAndAgentName: vitest_1.vi.fn().mockResolvedValue(null),
+        };
+        mockActivityRepository = {
+            create: vitest_1.vi.fn(),
+            update: vitest_1.vi.fn(),
+            deleteByGroupId: vitest_1.vi.fn(),
+        };
+        mockSocketService = {
+            emitMessageUpdate: vitest_1.vi.fn(),
+            emitChatUpdate: vitest_1.vi.fn(),
+        };
+        const config = config_1.ConfigProvider.getInstance().getConfig();
+        const s3Lib = new s3_1.S3Lib(config.s3);
+        chatProcessor = new ChatProcessor_1.ChatProcessor({
+            chatRepository: mockChatRepository,
+            messageRepository: mockMessageRepository,
+            agentConfigRepository: mockAgentConfigRepository,
+            artifactStore: { listArtifacts: vitest_1.vi.fn().mockReturnValue([]), deleteArtifacts: vitest_1.vi.fn() },
+            s3Lib,
+            config,
+            socketService: mockSocketService,
+            agentStore: {
+                registerAgentProcess: vitest_1.vi.fn().mockReturnValue({ signal: new AbortController().signal }),
+                shareAgentProcessEvent: vitest_1.vi.fn(),
+                addListener: vitest_1.vi.fn(),
+                removeListener: vitest_1.vi.fn(),
+            },
+            activityRepository: mockActivityRepository,
+        });
+    });
+    (0, vitest_1.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: ai_agent_types_1.MessageRole.Assistant,
+            content: '',
+            createdAt: now,
+            toolCalls: [
+                {
+                    id: toolCallId,
+                    name: 'test_tool',
+                    input: { foo: 'old' },
+                    status: ai_agent_types_1.AgentToolCallStatus.Pending,
+                },
+            ],
+        });
+        mockMessageRepository.updateToolCall.mockResolvedValue({
+            id: messageId,
+            chat: chatId,
+            role: ai_agent_types_1.MessageRole.Assistant,
+            content: '',
+            createdAt: now,
+            toolCalls: [
+                {
+                    id: toolCallId,
+                    name: 'test_tool',
+                    input: updatedInput,
+                    status: ai_agent_types_1.AgentToolCallStatus.Pending,
+                },
+            ],
+        });
+        const aiHelper = chatProcessor.aiHelper;
+        vitest_1.vi.spyOn(aiHelper, 'getAgentOptions').mockResolvedValue({
+            name: 'test-agent',
+            tools: {
+                test_tool: {
+                    inputSchema: zod_1.z.object({
+                        foo: zod_1.z.any().optional(),
+                        count: zod_1.z.any().optional(),
+                    }),
+                },
+            },
+        });
+        const result = await chatProcessor.updateToolCall({
+            chatId,
+            messageId,
+            toolCallId,
+            input: updatedInput,
+            excludeSocketId: 'socket-1',
+        });
+        (0, vitest_1.expect)(mockMessageRepository.updateToolCall).toHaveBeenCalledWith(messageId, toolCallId, {
+            input: updatedInput,
+        });
+        (0, vitest_1.expect)(mockChatRepository.update).toHaveBeenCalledWith(chatId, vitest_1.expect.objectContaining({ updatedAt: vitest_1.expect.any(String) }));
+        (0, vitest_1.expect)(mockSocketService.emitMessageUpdate).toHaveBeenCalledWith(userId, result, 'socket-1');
+        (0, vitest_1.expect)(result.toolCalls?.[0].input).toEqual(updatedInput);
+    });
+    (0, vitest_1.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: ai_agent_types_1.MessageRole.Assistant,
+            content: '',
+            createdAt: now,
+            toolCalls: [
+                {
+                    id: toolCallId,
+                    name: 'test_tool',
+                    input: { foo: 'old' },
+                    status: ai_agent_types_1.AgentToolCallStatus.Running,
+                },
+            ],
+        });
+        mockMessageRepository.updateToolCall.mockResolvedValue({
+            id: messageId,
+            chat: chatId,
+            role: ai_agent_types_1.MessageRole.Assistant,
+            content: '',
+            createdAt: now,
+            toolCalls: [
+                {
+                    id: toolCallId,
+                    name: 'test_tool',
+                    input: { foo: 'old' },
+                    output: { result: 'ok' },
+                    status: ai_agent_types_1.AgentToolCallStatus.Succeeded,
+                },
+            ],
+        });
+        const result = await chatProcessor.updateToolCall({
+            chatId,
+            messageId,
+            toolCallId,
+            output: { result: 'ok' },
+            status: ai_agent_types_1.AgentToolCallStatus.Succeeded,
+            excludeSocketId: 'socket-1',
+        });
+        (0, vitest_1.expect)(mockMessageRepository.updateToolCall).toHaveBeenCalledWith(messageId, toolCallId, {
+            output: { result: 'ok' },
+            status: ai_agent_types_1.AgentToolCallStatus.Succeeded,
+        });
+        (0, vitest_1.expect)(mockChatRepository.update).toHaveBeenCalledWith(chatId, vitest_1.expect.objectContaining({ updatedAt: vitest_1.expect.any(String) }));
+        (0, vitest_1.expect)(mockSocketService.emitMessageUpdate).toHaveBeenCalledWith(userId, result, 'socket-1');
+        (0, vitest_1.expect)(result.toolCalls?.[0].status).toBe(ai_agent_types_1.AgentToolCallStatus.Succeeded);
+        (0, vitest_1.expect)(result.toolCalls?.[0].output).toEqual({ result: 'ok' });
+    });
+    (0, vitest_1.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: ai_agent_types_1.MessageRole.Assistant,
+            content: '',
+            createdAt: new Date().toISOString(),
+            toolCalls: [],
+        });
+        await (0, vitest_1.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');
+        (0, vitest_1.expect)(mockMessageRepository.updateToolCall).not.toHaveBeenCalled();
+    });
+    (0, vitest_1.it)('throws when chat does not belong to user', async () => {
+        mockChatRepository.findById.mockResolvedValue({ id: 'chat-1', tenants: { userId: 'owner-1' } });
+        await (0, vitest_1.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');
+        (0, vitest_1.expect)(mockMessageRepository.findById).not.toHaveBeenCalled();
+        (0, vitest_1.expect)(mockMessageRepository.updateToolCall).not.toHaveBeenCalled();
+    });
+    (0, vitest_1.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: ai_agent_types_1.MessageRole.Assistant,
+            content: '',
+            createdAt: new Date().toISOString(),
+            toolCalls: [
+                {
+                    id: 'other-tool-call',
+                    name: 'test_tool',
+                    input: {},
+                    status: ai_agent_types_1.AgentToolCallStatus.Pending,
+                },
+            ],
+        });
+        await (0, vitest_1.expect)(chatProcessor.updateToolCall({
+            chatId: 'chat-1',
+            messageId: 'message-1',
+            toolCallId: 'tool-call-1',
+            input: { x: 1 },
+        })).rejects.toThrow('Tool call not found in message');
+        (0, vitest_1.expect)(mockMessageRepository.updateToolCall).not.toHaveBeenCalled();
+    });
+    (0, vitest_1.it)('throws when no tool call fields are provided', async () => {
+        await (0, vitest_1.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');
+    });
+    (0, vitest_1.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: ai_agent_types_1.MessageRole.Assistant,
+            content: '',
+            createdAt: new Date().toISOString(),
+            toolCalls: [
+                {
+                    id: toolCallId,
+                    name: 'test_tool',
+                    input: {},
+                    status: ai_agent_types_1.AgentToolCallStatus.Pending,
+                },
+            ],
+            agentName: 'test-agent',
+        });
+        const aiHelper = chatProcessor.aiHelper;
+        vitest_1.vi.spyOn(aiHelper, 'getAgentOptions').mockResolvedValue({
+            name: 'test-agent',
+            tools: {
+                test_tool: {
+                    inputSchema: zod_1.z.object({
+                        x: zod_1.z.number(),
+                    }),
+                },
+            },
+        });
+        await (0, vitest_1.expect)(chatProcessor.updateToolCall({
+            chatId,
+            messageId,
+            toolCallId,
+            input: { x: 'invalid' },
+        })).rejects.toThrow('Invalid tool input for "test_tool"');
+        (0, vitest_1.expect)(mockMessageRepository.updateToolCall).not.toHaveBeenCalled();
+    });
+});
+//# sourceMappingURL=ChatProcessor.test.js.map