@roj-ai/sdk 0.1.36 → 0.2.1

package/src/plugins/user-chat/user-chat.integration.test.ts

@@ -1,893 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import { MockLLMProvider } from '~/core/llm/mock.js'
-import { selectPluginState } from '~/core/sessions/reducer.js'
-import { ToolCallId } from '~/core/tools/schema.js'
-import { createTestPreset, TestHarness } from '~/testing/index.js'
-import { userChatEvents, userChatPlugin } from './index.js'
-import type { UserChatState } from './plugin.js'
-
-describe('user-chat plugin', () => {
-	// =========================================================================
-	// sendMessage flow
-	// =========================================================================
-
-	describe('sendMessage flow', () => {
-		it('sendMessage → agent scheduled → LLM called with user message content', async () => {
-			const harness = new TestHarness({
-				presets: [createTestPreset()],
-				llmProvider: MockLLMProvider.withFixedResponse({ content: 'Ok', toolCalls: [] }),
-			})
-
-			const session = await harness.createSession('test')
-			await session.sendAndWaitForIdle('Hello world')
-
-			const lastRequest = harness.llmProvider.getLastRequest()
-			expect(lastRequest).toBeDefined()
-			const lastMessage = lastRequest!.messages[lastRequest!.messages.length - 1]
-			expect(lastMessage.content).toContain('Hello world')
-
-			await harness.shutdown()
-		})
-
-		it('sendMessage → user_chat_message_received event emitted', async () => {
-			const harness = new TestHarness({
-				presets: [createTestPreset()],
-				llmProvider: MockLLMProvider.withFixedResponse({ content: 'Ok', toolCalls: [] }),
-			})
-
-			const session = await harness.createSession('test')
-			await session.sendAndWaitForIdle('Test message')
-
-			const events = await session.getEventsByType('user_chat_message_received')
-			expect(events).toHaveLength(1)
-			expect(events[0]).toMatchObject({
-				type: 'user_chat_message_received',
-				content: 'Test message',
-			})
-
-			await harness.shutdown()
-		})
-
-		it('sendMessage to specific agent (non-entry) via sendMessageToAgent', async () => {
-			const harness = new TestHarness({
-				presets: [createTestPreset()],
-				llmProvider: MockLLMProvider.withFixedResponse({ content: 'Ok', toolCalls: [] }),
-			})
-
-			const session = await harness.createSession('test')
-			const entryAgentId = session.getEntryAgentId()!
-			await session.sendMessageToAgent(entryAgentId, 'Direct message')
-			await session.waitForIdle()
-
-			const events = await session.getEventsByType('user_chat_message_received')
-			expect(events).toHaveLength(1)
-			expect(events[0]).toMatchObject({
-				agentId: entryAgentId,
-				content: 'Direct message',
-			})
-
-			await harness.shutdown()
-		})
-
-		it('multiple sendMessage calls → all messages appear in conversation history in order', async () => {
-			const harness = new TestHarness({
-				presets: [createTestPreset()],
-				llmProvider: MockLLMProvider.withFixedResponse({ content: 'Ok', toolCalls: [] }),
-			})
-
-			const session = await harness.createSession('test')
-			await session.sendAndWaitForIdle('First message')
-			await session.sendAndWaitForIdle('Second message')
-
-			const events = await session.getEventsByType('user_chat_message_received')
-			expect(events).toHaveLength(2)
-			expect(events[0]).toMatchObject({ content: 'First message' })
-			expect(events[1]).toMatchObject({ content: 'Second message' })
-
-			await harness.shutdown()
-		})
-
-		it('sendMessage → pending inbound message created and marked consumed after inference', async () => {
-			const harness = new TestHarness({
-				presets: [createTestPreset()],
-				llmProvider: MockLLMProvider.withFixedResponse({ content: 'Ok', toolCalls: [] }),
-			})
-
-			const session = await harness.createSession('test')
-			await session.sendAndWaitForIdle('Test')
-
-			// Check consumed event was emitted
-			const consumedEvents = await session.getEventsByType('user_chat_messages_consumed')
-			expect(consumedEvents.length).toBeGreaterThanOrEqual(1)
-
-			// After consumption, pending messages should be marked consumed in state
-			const pendingInbound = selectPluginState<UserChatState>(session.state, 'messages')?.pendingInbound ?? []
-			const unconsumed = pendingInbound.filter((m) => !m.consumed)
-			expect(unconsumed).toHaveLength(0)
-
-			await harness.shutdown()
-		})
-	})
-
-	// =========================================================================
-	// tell_user tool
-	// =========================================================================
-
-	describe('tell_user tool', () => {
-		it('agent calls tell_user → agentMessage notification emitted', async () => {
-			const harness = new TestHarness({
-				presets: [createTestPreset()],
-				llmProvider: MockLLMProvider.withSequence([
-					{
-						toolCalls: [{ id: ToolCallId('tc1'), name: 'tell_user', input: { message: 'Hello user!' } }],
-					},
-					{ content: 'Done', toolCalls: [] },
-				]),
-			})
-
-			const session = await harness.createSession('test')
-			await session.sendAndWaitForIdle('Hi')
-
-			const messages = harness.notifications.getAgentMessages()
-			expect(messages).toHaveLength(1)
-			expect(messages[0].content).toBe('Hello user!')
-
-			await harness.shutdown()
-		})
-
-		it('tell_user with format: text → notification has text format', async () => {
-			const harness = new TestHarness({
-				presets: [createTestPreset()],
-				llmProvider: MockLLMProvider.withSequence([
-					{
-						toolCalls: [{ id: ToolCallId('tc1'), name: 'tell_user', input: { message: 'Plain text', format: 'text' } }],
-					},
-					{ content: 'Done', toolCalls: [] },
-				]),
-			})
-
-			const session = await harness.createSession('test')
-			await session.sendAndWaitForIdle('Hi')
-
-			const messages = harness.notifications.getAgentMessages()
-			expect(messages).toHaveLength(1)
-			expect(messages[0].format).toBe('text')
-
-			await harness.shutdown()
-		})
-
-		it('tell_user with format: markdown → notification has markdown format', async () => {
-			const harness = new TestHarness({
-				presets: [createTestPreset()],
-				llmProvider: MockLLMProvider.withSequence([
-					{
-						toolCalls: [{ id: ToolCallId('tc1'), name: 'tell_user', input: { message: '**Bold**', format: 'markdown' } }],
-					},
-					{ content: 'Done', toolCalls: [] },
-				]),
-			})
-
-			const session = await harness.createSession('test')
-			await session.sendAndWaitForIdle('Hi')
-
-			const messages = harness.notifications.getAgentMessages()
-			expect(messages).toHaveLength(1)
-			expect(messages[0].format).toBe('markdown')
-
-			await harness.shutdown()
-		})
-
-		it('tell_user → user_message_sent event emitted with correct content', async () => {
-			const harness = new TestHarness({
-				presets: [createTestPreset()],
-				llmProvider: MockLLMProvider.withSequence([
-					{
-						toolCalls: [{ id: ToolCallId('tc1'), name: 'tell_user', input: { message: 'Event test' } }],
-					},
-					{ content: 'Done', toolCalls: [] },
-				]),
-			})
-
-			const session = await harness.createSession('test')
-			await session.sendAndWaitForIdle('Hi')
-
-			const events = await session.getEventsByType('user_message_sent')
-			expect(events).toHaveLength(1)
-			expect(events[0]).toMatchObject({
-				type: 'user_message_sent',
-				message: 'Event test',
-			})
-
-			await harness.shutdown()
-		})
-
-		it('tell_user → message appears in getMessages result', async () => {
-			const harness = new TestHarness({
-				presets: [createTestPreset()],
-				llmProvider: MockLLMProvider.withSequence([
-					{
-						toolCalls: [{ id: ToolCallId('tc1'), name: 'tell_user', input: { message: 'Stored msg' } }],
-					},
-					{ content: 'Done', toolCalls: [] },
-				]),
-			})
-
-			const session = await harness.createSession('test')
-			await session.sendAndWaitForIdle('Hi')
-
-			const chatMessages = selectPluginState<UserChatState>(session.state, 'messages')?.messages ?? []
-			const agentMessages = chatMessages.filter((m) => m.type === 'agent_message')
-			expect(agentMessages).toHaveLength(1)
-			expect(agentMessages[0]).toMatchObject({
-				type: 'agent_message',
-				content: 'Stored msg',
-			})
-
-			await harness.shutdown()
-		})
-	})
-
-	// =========================================================================
-	// ask_user tool
-	// =========================================================================
-
-	describe('ask_user tool', () => {
-		it('agent calls ask_user (text input) → askUser notification emitted with question', async () => {
-			const harness = new TestHarness({
-				presets: [createTestPreset()],
-				llmProvider: MockLLMProvider.withSequence([
-					{
-						toolCalls: [{
-							id: ToolCallId('tc1'),
-							name: 'ask_user',
-							input: { question: 'What is your name?', inputType: 'text' },
-						}],
-					},
-					{ content: 'Done', toolCalls: [] },
-				]),
-			})
-
-			const session = await harness.createSession('test')
-			await session.sendAndWaitForIdle('Hi')
-
-			const askNotifications = harness.notifications.getByType('user-chat', 'askUser')
-			expect(askNotifications).toHaveLength(1)
-			expect(askNotifications[0].payload).toMatchObject({
-				question: 'What is your name?',
-				inputType: { type: 'text' },
-			})
-
-			await harness.shutdown()
-		})
-
-		it('ask_user → user_question_asked event emitted', async () => {
-			const harness = new TestHarness({
-				presets: [createTestPreset()],
-				llmProvider: MockLLMProvider.withSequence([
-					{
-						toolCalls: [{
-							id: ToolCallId('tc1'),
-							name: 'ask_user',
-							input: { question: 'Confirm?', inputType: 'confirm' },
-						}],
-					},
-					{ content: 'Done', toolCalls: [] },
-				]),
-			})
-
-			const session = await harness.createSession('test')
-			await session.sendAndWaitForIdle('Hi')
-
-			const events = await session.getEventsByType('user_question_asked')
-			expect(events).toHaveLength(1)
-			expect(events[0]).toMatchObject({
-				type: 'user_question_asked',
-				question: 'Confirm?',
-			})
-
-			await harness.shutdown()
-		})
-
-		it('ask_user with single_choice → notification contains options', async () => {
-			const harness = new TestHarness({
-				presets: [createTestPreset()],
-				llmProvider: MockLLMProvider.withSequence([
-					{
-						toolCalls: [{
-							id: ToolCallId('tc1'),
-							name: 'ask_user',
-							input: {
-								question: 'Pick one',
-								inputType: 'single_choice',
-								options: [
-									{ value: 'a', label: 'Option A' },
-									{ value: 'b', label: 'Option B' },
-								],
-							},
-						}],
-					},
-					{ content: 'Done', toolCalls: [] },
-				]),
-			})
-
-			const session = await harness.createSession('test')
-			await session.sendAndWaitForIdle('Hi')
-
-			const askNotifications = harness.notifications.getByType('user-chat', 'askUser')
-			expect(askNotifications).toHaveLength(1)
-			expect(askNotifications[0].payload).toMatchObject({
-				inputType: {
-					type: 'single_choice',
-					options: [
-						{ value: 'a', label: 'Option A' },
-						{ value: 'b', label: 'Option B' },
-					],
-				},
-			})
-
-			await harness.shutdown()
-		})
-
-		it('ask_user with multi_choice → notification contains options', async () => {
-			const harness = new TestHarness({
-				presets: [createTestPreset()],
-				llmProvider: MockLLMProvider.withSequence([
-					{
-						toolCalls: [{
-							id: ToolCallId('tc1'),
-							name: 'ask_user',
-							input: {
-								question: 'Pick multiple',
-								inputType: 'multi_choice',
-								options: [
-									{ value: 'x', label: 'X' },
-									{ value: 'y', label: 'Y' },
-								],
-							},
-						}],
-					},
-					{ content: 'Done', toolCalls: [] },
-				]),
-			})
-
-			const session = await harness.createSession('test')
-			await session.sendAndWaitForIdle('Hi')
-
-			const askNotifications = harness.notifications.getByType('user-chat', 'askUser')
-			expect(askNotifications).toHaveLength(1)
-			expect(askNotifications[0].payload).toMatchObject({
-				inputType: {
-					type: 'multi_choice',
-					options: [
-						{ value: 'x', label: 'X' },
-						{ value: 'y', label: 'Y' },
-					],
-				},
-			})
-
-			await harness.shutdown()
-		})
-
-		it('ask_user with confirm → notification has confirm type', async () => {
-			const harness = new TestHarness({
-				presets: [createTestPreset()],
-				llmProvider: MockLLMProvider.withSequence([
-					{
-						toolCalls: [{
-							id: ToolCallId('tc1'),
-							name: 'ask_user',
-							input: { question: 'Are you sure?', inputType: 'confirm' },
-						}],
-					},
-					{ content: 'Done', toolCalls: [] },
-				]),
-			})
-
-			const session = await harness.createSession('test')
-			await session.sendAndWaitForIdle('Hi')
-
-			const askNotifications = harness.notifications.getByType('user-chat', 'askUser')
-			expect(askNotifications).toHaveLength(1)
-			expect(askNotifications[0].payload).toMatchObject({
-				inputType: { type: 'confirm' },
-			})
-
-			await harness.shutdown()
-		})
-
-		it('ask_user with rating → notification has min/max', async () => {
-			const harness = new TestHarness({
-				presets: [createTestPreset()],
-				llmProvider: MockLLMProvider.withSequence([
-					{
-						toolCalls: [{
-							id: ToolCallId('tc1'),
-							name: 'ask_user',
-							input: { question: 'Rate this', inputType: 'rating', min: 1, max: 10 },
-						}],
-					},
-					{ content: 'Done', toolCalls: [] },
-				]),
-			})
-
-			const session = await harness.createSession('test')
-			await session.sendAndWaitForIdle('Hi')
-
-			const askNotifications = harness.notifications.getByType('user-chat', 'askUser')
-			expect(askNotifications).toHaveLength(1)
-			expect(askNotifications[0].payload).toMatchObject({
-				inputType: { type: 'rating', min: 1, max: 10 },
-			})
-
-			await harness.shutdown()
-		})
-
-		it('answerQuestion → answer delivered → agent sees answer in next inference', async () => {
-			let inferenceCount = 0
-			const harness = new TestHarness({
-				presets: [createTestPreset()],
-				mockHandler: (request) => {
-					inferenceCount++
-					if (inferenceCount === 1) {
-						return {
-							content: null,
-							toolCalls: [{
-								id: ToolCallId('tc1'),
-								name: 'ask_user',
-								input: { question: 'Your name?', inputType: 'text' },
-							}],
-							finishReason: 'stop',
-							metrics: MockLLMProvider.defaultMetrics(),
-						}
-					}
-					if (inferenceCount === 2) {
-						// After tool result — agent finishes this cycle
-						return {
-							content: 'Waiting for answer',
-							toolCalls: [],
-							finishReason: 'stop',
-							metrics: MockLLMProvider.defaultMetrics(),
-						}
-					}
-					// After answer arrives — check the LLM sees it
-					const lastMessage = request.messages[request.messages.length - 1]
-					const content = typeof lastMessage.content === 'string' ? lastMessage.content : ''
-					return {
-						content: `Got: ${content}`,
-						toolCalls: [],
-						finishReason: 'stop',
-						metrics: MockLLMProvider.defaultMetrics(),
-					}
-				},
-			})
-
-			const session = await harness.createSession('test')
-			await session.sendAndWaitForIdle('Hi')
-
-			// Find the question event to get the questionId
-			const questionEvents = await session.getEventsByType(userChatEvents, 'user_question_asked')
-			expect(questionEvents).toHaveLength(1)
-			const questionId = questionEvents[0].messageId
-			const entryAgentId = session.getEntryAgentId()!
-
-			// Answer the question via the new helper
-			await session.answerQuestion(entryAgentId, questionId, 'John')
-			await session.waitForIdle()
-
-			// Verify the answer event was emitted
-			const answerEvents = await session.getEventsByType('user_chat_answer_received')
-			expect(answerEvents).toHaveLength(1)
-			expect(answerEvents[0]).toMatchObject({
-				answerValue: 'John',
-			})
-
-			// Verify LLM saw the answer (inference count should be > 2)
-			expect(inferenceCount).toBeGreaterThan(2)
-
-			await harness.shutdown()
-		})
-
-		it('answerQuestion → user_chat_answer_received event emitted', async () => {
-			const harness = new TestHarness({
-				presets: [createTestPreset()],
-				llmProvider: MockLLMProvider.withSequence([
-					{
-						toolCalls: [{
-							id: ToolCallId('tc1'),
-							name: 'ask_user',
-							input: { question: 'Color?', inputType: 'text' },
-						}],
-					},
-					{ content: 'Waiting', toolCalls: [] },
-					{ content: 'Got it', toolCalls: [] },
-				]),
-			})
-
-			const session = await harness.createSession('test')
-			await session.sendAndWaitForIdle('Hi')
-
-			const questionEvents = await session.getEventsByType(userChatEvents, 'user_question_asked')
-			const questionId = questionEvents[0].messageId
-			const entryAgentId = session.getEntryAgentId()!
-
-			await session.answerQuestion(entryAgentId, questionId, 'Blue')
-			await session.waitForIdle()
-
-			const answerEvents = await session.getEventsByType('user_chat_answer_received')
-			expect(answerEvents).toHaveLength(1)
-			expect(answerEvents[0]).toMatchObject({
-				type: 'user_chat_answer_received',
-				answerValue: 'Blue',
-				questionId,
-			})
-
-			await harness.shutdown()
-		})
-
-		it('answerQuestion → question marked as answered in getMessages', async () => {
-			const harness = new TestHarness({
-				presets: [createTestPreset()],
-				llmProvider: MockLLMProvider.withSequence([
-					{
-						toolCalls: [{
-							id: ToolCallId('tc1'),
-							name: 'ask_user',
-							input: { question: 'Ready?', inputType: 'confirm' },
-						}],
-					},
-					{ content: 'Waiting', toolCalls: [] },
-					{ content: 'Great', toolCalls: [] },
-				]),
-			})
-
-			const session = await harness.createSession('test')
-			await session.sendAndWaitForIdle('Hi')
-
-			const questionEvents = await session.getEventsByType(userChatEvents, 'user_question_asked')
-			const questionId = questionEvents[0].messageId
-			const entryAgentId = session.getEntryAgentId()!
-
-			await session.answerQuestion(entryAgentId, questionId, true)
-			await session.waitForIdle()
-
-			// Check messages state
-			const chatMessages = selectPluginState<UserChatState>(session.state, 'messages')?.messages ?? []
-			const askMessages = chatMessages.filter((m) => m.type === 'ask_user')
-			expect(askMessages).toHaveLength(1)
-			expect(askMessages[0]).toMatchObject({
-				type: 'ask_user',
-				answered: true,
-				answer: true,
-			})
-
-			await harness.shutdown()
-		})
-	})
-
-	// =========================================================================
-	// Unicode escape decoding (defensive fix for models that double-escape
-	// non-ASCII in tool argument JSON — see plugin.ts decodeUnicodeEscapes).
-	// =========================================================================
-
-	describe('unicode escape decoding in user-facing fields', () => {
-		it('ask_user (text) → literal \\uXXXX in question/placeholder is decoded', async () => {
-			const harness = new TestHarness({
-				presets: [createTestPreset()],
-				llmProvider: MockLLMProvider.withSequence([
-					{
-						toolCalls: [{
-							id: ToolCallId('tc1'),
-							name: 'ask_user',
-							input: {
-								question: 'Pro\\u010d ne?',
-								inputType: 'text',
-								placeholder: 'Nap\\u0159. ano',
-							},
-						}],
-					},
-					{ content: 'Done', toolCalls: [] },
-				]),
-			})
-
-			const session = await harness.createSession('test')
-			await session.sendAndWaitForIdle('Hi')
-
-			const askNotifications = harness.notifications.getByType('user-chat', 'askUser')
-			expect(askNotifications[0].payload).toMatchObject({
-				question: 'Proč ne?',
-				inputType: { type: 'text', placeholder: 'Např. ano' },
-			})
-
-			await harness.shutdown()
-		})
-
-		it('ask_user (single_choice) → option labels decoded, values left intact', async () => {
-			const harness = new TestHarness({
-				presets: [createTestPreset()],
-				llmProvider: MockLLMProvider.withSequence([
-					{
-						toolCalls: [{
-							id: ToolCallId('tc1'),
-							name: 'ask_user',
-							input: {
-								question: 'Pick',
-								inputType: 'single_choice',
-								options: [
-									{ value: 'kun_ze_\\u0159adu', label: 'K\\u016f\\u0148 ze \\u0159adu' },
-								],
-							},
-						}],
-					},
-					{ content: 'Done', toolCalls: [] },
-				]),
-			})
-
-			const session = await harness.createSession('test')
-			await session.sendAndWaitForIdle('Hi')
-
-			const askNotifications = harness.notifications.getByType('user-chat', 'askUser')
-			expect(askNotifications[0].payload).toMatchObject({
-				inputType: {
-					type: 'single_choice',
-					// Value preserved verbatim so answer round-trip stays consistent
-					// with what the LLM emitted.
-					options: [{ value: 'kun_ze_\\u0159adu', label: 'Kůň ze řadu' }],
-				},
-			})
-
-			await harness.shutdown()
-		})
-
-		it('tell_user → literal \\uXXXX in message is decoded', async () => {
-			const harness = new TestHarness({
-				presets: [createTestPreset()],
-				llmProvider: MockLLMProvider.withSequence([
-					{
-						toolCalls: [{
-							id: ToolCallId('tc1'),
-							name: 'tell_user',
-							input: { message: 'Ahoj sv\\u011bte' },
-						}],
-					},
-					{ content: 'Done', toolCalls: [] },
-				]),
-			})
-
-			const session = await harness.createSession('test')
-			await session.sendAndWaitForIdle('Hi')
-
-			const msgs = harness.notifications.getByType('user-chat', 'agentMessage')
-			expect(msgs[0].payload).toMatchObject({ content: 'Ahoj světe' })
-
-			await harness.shutdown()
-		})
-	})
-
-	// =========================================================================
-	// XML mode
-	// =========================================================================
-
-	describe('XML mode', () => {
-		it('agent with userCommunication: xml → <user> tags parsed from response → notification emitted', async () => {
-			const harness = new TestHarness({
-				presets: [createTestPreset({
-					orchestratorPlugins: [
-						userChatPlugin.configureAgent({ enabled: true, userCommunication: 'xml' }),
-					],
-				})],
-				llmProvider: MockLLMProvider.withFixedResponse({
-					content: 'Thinking... <user>Hello from XML!</user> Done.',
-					toolCalls: [],
-				}),
-			})
-
-			const session = await harness.createSession('test')
-			await session.sendAndWaitForIdle('Hi')
-
-			const messages = harness.notifications.getAgentMessages()
-			expect(messages).toHaveLength(1)
-			expect(messages[0].content).toBe('Hello from XML!')
-
-			await harness.shutdown()
-		})
-
-		it('<user> tags stripped from response content after parsing', async () => {
-			const harness = new TestHarness({
-				presets: [createTestPreset({
-					orchestratorPlugins: [
-						userChatPlugin.configureAgent({ enabled: true, userCommunication: 'xml' }),
-					],
-				})],
-				llmProvider: MockLLMProvider.withFixedResponse({
-					content: 'Before <user>Message</user> After',
-					toolCalls: [],
-				}),
-			})
-
-			const session = await harness.createSession('test')
-			await session.sendAndWaitForIdle('Hi')
-
-			// The user_message_sent event should have the extracted message
-			const events = await session.getEventsByType('user_message_sent')
-			expect(events).toHaveLength(1)
-			expect(events[0]).toMatchObject({ message: 'Message' })
-
-			await harness.shutdown()
-		})
-
-		it('agent with userCommunication: both → both tools and <user> tags work', async () => {
-			const harness = new TestHarness({
-				presets: [createTestPreset({
-					orchestratorPlugins: [
-						userChatPlugin.configureAgent({ enabled: true, userCommunication: 'both' }),
-					],
-				})],
-				llmProvider: MockLLMProvider.withSequence([
-					{
-						content: 'Thinking... <user>XML message!</user> Done.',
-						toolCalls: [{ id: ToolCallId('tc1'), name: 'tell_user', input: { message: 'Tool message!' } }],
-					},
-					{ content: 'Finished', toolCalls: [] },
-				]),
-			})
-
-			const session = await harness.createSession('test')
-			await session.sendAndWaitForIdle('Hi')
-
-			const messages = harness.notifications.getAgentMessages()
-			expect(messages).toHaveLength(2)
-			const contents = messages.map((m) => m.content)
-			expect(contents).toContain('Tool message!')
-			expect(contents).toContain('XML message!')
-
-			await harness.shutdown()
-		})
-
-		it('agent with userCommunication: tool (default) → <user> tags ignored', async () => {
-			const harness = new TestHarness({
-				presets: [createTestPreset()],
-				llmProvider: MockLLMProvider.withFixedResponse({
-					content: 'Response with <user>Should not be parsed</user> content',
-					toolCalls: [],
-				}),
-			})
-
-			const session = await harness.createSession('test')
-			await session.sendAndWaitForIdle('Hi')
-
-			const messages = harness.notifications.getAgentMessages()
-			expect(messages).toHaveLength(0)
-
-			await harness.shutdown()
-		})
-	})
-
-	// =========================================================================
-	// getMessages
-	// =========================================================================
-
-	describe('getMessages', () => {
-		it('getMessages returns all chat messages (user + agent + ask_user) in order', async () => {
-			const harness = new TestHarness({
-				presets: [createTestPreset()],
-				llmProvider: MockLLMProvider.withSequence([
-					{
-						toolCalls: [
-							{ id: ToolCallId('tc1'), name: 'tell_user', input: { message: 'Hello!' } },
-							{ id: ToolCallId('tc2'), name: 'ask_user', input: { question: 'Name?', inputType: 'text' } },
-						],
-					},
-					{ content: 'Done', toolCalls: [] },
-				]),
-			})
-
-			const session = await harness.createSession('test')
-			await session.sendAndWaitForIdle('Hi')
-
-			const chatMessages = selectPluginState<UserChatState>(session.state, 'messages')?.messages ?? []
-			// Should have: user_message (from sendMessage), agent_message (from tell_user), ask_user (from ask_user)
-			expect(chatMessages.length).toBeGreaterThanOrEqual(3)
-
-			const types = chatMessages.map((m) => m.type)
-			expect(types).toContain('user_message')
-			expect(types).toContain('agent_message')
-			expect(types).toContain('ask_user')
-
-			await harness.shutdown()
-		})
-
-		it('getMessages reflects answered questions', async () => {
-			const harness = new TestHarness({
-				presets: [createTestPreset()],
-				llmProvider: MockLLMProvider.withSequence([
-					{
-						toolCalls: [{
-							id: ToolCallId('tc1'),
-							name: 'ask_user',
-							input: { question: 'Favorite color?', inputType: 'text' },
-						}],
-					},
-					{ content: 'Waiting', toolCalls: [] },
-					{ content: 'Got it', toolCalls: [] },
-				]),
-			})
-
-			const session = await harness.createSession('test')
-			await session.sendAndWaitForIdle('Hi')
-
-			// Before answering — question should be unanswered
-			const beforeMessages = selectPluginState<UserChatState>(session.state, 'messages')?.messages ?? []
-			const beforeAsk = beforeMessages.filter((m) => m.type === 'ask_user')
-			expect(beforeAsk).toHaveLength(1)
-			expect(beforeAsk[0]).toMatchObject({ answered: false })
-			expect(beforeAsk[0]).not.toHaveProperty('answer')
-
-			// Answer the question
-			const questionEvents = await session.getEventsByType(userChatEvents, 'user_question_asked')
-			const questionId = questionEvents[0].messageId
-			const entryAgentId = session.getEntryAgentId()!
-
-			await session.answerQuestion(entryAgentId, questionId, 'Blue')
-			await session.waitForIdle()
-
-			// After answering — question should be marked as answered with answer value
-			const afterMessages = selectPluginState<UserChatState>(session.state, 'messages')?.messages ?? []
-			const afterAsk = afterMessages.filter((m) => m.type === 'ask_user')
-			expect(afterAsk).toHaveLength(1)
-			expect(afterAsk[0]).toMatchObject({
-				answered: true,
-				answer: 'Blue',
-			})
-
-			await harness.shutdown()
-		})
-	})
-
-	// =========================================================================
-	// disabled
-	// =========================================================================
-
-	describe('disabled', () => {
-		it('plugin enabled: false → no tools provided to agent', async () => {
-			const harness = new TestHarness({
-				presets: [createTestPreset({
-					plugins: [
-						userChatPlugin.configure({ enabled: false }),
-					],
-				})],
-				llmProvider: MockLLMProvider.withFixedResponse({ content: 'Ok', toolCalls: [] }),
-			})
-
-			const session = await harness.createSession('test')
-			await session.sendAndWaitForIdle('Hi')
-
-			const lastRequest = harness.llmProvider.getLastRequest()
-			const toolNames = lastRequest?.tools?.map((t) => t.name) ?? []
-			expect(toolNames).not.toContain('tell_user')
-			expect(toolNames).not.toContain('ask_user')
-
-			await harness.shutdown()
-		})
-
-		it('agent enabled: false → no user-chat tools provided to that agent', async () => {
-			const harness = new TestHarness({
-				presets: [createTestPreset({
-					orchestratorPlugins: [
-						userChatPlugin.configureAgent({ enabled: false }),
-					],
-				})],
-				llmProvider: MockLLMProvider.withFixedResponse({ content: 'Ok', toolCalls: [] }),
-			})
-
-			const session = await harness.createSession('test')
-			await session.sendAndWaitForIdle('Hi')
-
-			const lastRequest = harness.llmProvider.getLastRequest()
-			const toolNames = lastRequest?.tools?.map((t) => t.name) ?? []
-			expect(toolNames).not.toContain('tell_user')
-			expect(toolNames).not.toContain('ask_user')
-
-			await harness.shutdown()
-		})
-	})
-})