surf
', blocks: [{ locator: 'abc' }] }; - const result = agentMessages([ - { role: 'user', content: 'add fishing para' }, - virtualRead('r1', TURN, output), - ]); - - expect(result).to.have.lengthOf(3); - expect(result[0]).to.deep.equal({ role: 'user', content: 'add fishing para' }); - expect(result[1]).to.deep.equal({ - role: 'assistant', - content: [{ type: 'tool-call', toolCallId: 'r1', toolName: 'content_read', input: { path: '/x' } }], - }); - expect(result[2]).to.deep.equal({ - role: 'tool', - content: [{ type: 'tool-result', toolCallId: 'r1', toolName: 'content_read', output: { type: 'json', value: output } }], - }); - }); - - it('wraps a string tool output as a text part', () => { - const result = agentMessages([virtualRead('r1', TURN, 'plain text')]); - expect(result[1].content[0].output).to.deep.equal({ type: 'text', value: 'plain text' }); - }); - - it('drops tool I/O from previous turns to keep the payload bounded', () => { - const result = agentMessages([ - virtualRead('old', OTHER_TURN, { content: 'stale' }), - { role: 'user', content: 'new question' }, - virtualRead('new', TURN, { content: 'fresh' }), - ]); - const readIds = result - .flatMap((m) => (Array.isArray(m.content) ? m.content : [])) - .filter((p) => p.type === 'tool-call') - .map((p) => p.toolCallId); - expect(readIds).to.deep.equal(['new']); // 'old' dropped - }); - - it('drops the virtual twin of an approval tool already represented by a real tool-call', () => { - const result = agentMessages([ - // Real (non-virtual) approval message for content_replace. - { - role: 'assistant', - content: [ - { type: 'tool-call', toolCallId: 'w1', toolName: 'content_replace', input: {} }, - { type: 'tool-approval-request', approvalId: 'a1', toolCallId: 'w1' }, - ], - }, - { role: 'tool', content: [{ type: 'tool-approval-response', approvalId: 'a1', approved: true }] }, - // Virtual DONE twin for the same call — must NOT be re-sent (would duplicate w1). - { - role: 'assistant', - virtual: true, - turnId: TURN, - toolResult: { output: { updated: true } }, - content: [{ type: 'tool-call', toolCallId: 'w1', toolName: 'content_replace', input: {} }], - }, - ]); - - const w1Calls = result - .filter((m) => m.role === 'assistant' && Array.isArray(m.content)) - .flatMap((m) => m.content) - .filter((p) => p.type === 'tool-call' && p.toolCallId === 'w1'); - expect(w1Calls).to.have.lengthOf(1); // exactly one, from the real approval message - }); - - it('skips a current-turn virtual message that has no stored output', () => { - const result = agentMessages([ - { role: 'assistant', virtual: true, turnId: TURN, content: [{ type: 'tool-call', toolCallId: 'r1', toolName: 'content_read', input: {} }] }, - ]); - expect(result).to.deep.equal([]); // no orphan tool-call emitted - }); -}); diff --git a/test/nx2/blocks/chat/controllers/chat-controller.test.js b/test/nx2/blocks/chat/controllers/chat-controller.test.js new file mode 100644 index 000000000..85003d0df --- /dev/null +++ b/test/nx2/blocks/chat/controllers/chat-controller.test.js @@ -0,0 +1,666 @@ +import { expect } from '@esm-bundle/chai'; +import ChatController from '../../../../../nx2/blocks/chat/controllers/chat-controller.js'; +import { TOOL_STATE, AGENT_EVENT, ROLE, FINISH_REASON } from '../../../../../nx2/blocks/chat/constants.js'; + +function makeController() { + return new ChatController({ onUpdate() { }, onToolDone() { } }); +} + +describe('ChatController — _onApprovalRequest', () => { + it('does nothing when card is already in a settled state', () => { + const ctrl = makeController(); + ctrl._turn.begin(); + const settled = [ + TOOL_STATE.APPROVAL_REQUESTED, TOOL_STATE.APPROVED, + TOOL_STATE.REJECTED, TOOL_STATE.DONE, TOOL_STATE.ERROR, + ]; + for (const state of settled) { + ctrl._messages = [{ role: ROLE.USER, content: 'go' }]; + ctrl._toolCards = new Map([['tc-1', { toolName: 'my-tool', input: {}, state }]]); + ctrl._pendingBatch = { toolCalls: [], approvalRequests: [] }; + ctrl._onApprovalRequest('tc-1', 'my-tool', 'ap-1'); + expect(ctrl._pendingBatch.approvalRequests).to.have.lengthOf(0); + expect(ctrl._messages).to.have.lengthOf(1); // no message committed + } + }); + + it('commits assistant message and updates card to APPROVAL_REQUESTED for manual approval', () => { + const ctrl = makeController(); + ctrl._turn.begin(); + ctrl._messages = [{ role: ROLE.USER, content: 'go' }]; + ctrl._pendingBatch = { + toolCalls: [{ toolCallId: 'tc-1', toolName: 'my-tool', input: { path: '/a.md' } }], + approvalRequests: [], + }; + ctrl._toolCards = new Map([['tc-1', { toolName: 'my-tool', input: { path: '/a.md' }, state: TOOL_STATE.RUNNING }]]); + + ctrl._onApprovalRequest('tc-1', 'my-tool', 'ap-1'); + + expect(ctrl._toolCards.get('tc-1').state).to.equal(TOOL_STATE.APPROVAL_REQUESTED); + expect(ctrl._toolCards.get('tc-1').approvalId).to.equal('ap-1'); + expect(ctrl._pendingBatch.approvalRequests).to.deep.equal([{ approvalId: 'ap-1', toolCallId: 'tc-1' }]); + // tool-call removed from batch (already committed in the message) + expect(ctrl._pendingBatch.toolCalls).to.have.lengthOf(0); + expect(ctrl._turn.isActive).to.be.true; + + // Assistant message committed immediately + expect(ctrl._messages).to.have.lengthOf(2); + expect(ctrl._messages[1]).to.deep.equal({ + role: ROLE.ASSISTANT, + content: [ + { type: AGENT_EVENT.TOOL_CALL, toolCallId: 'tc-1', toolName: 'my-tool', input: { path: '/a.md' } }, + { type: AGENT_EVENT.TOOL_APPROVAL_REQUEST, approvalId: 'ap-1', toolCallId: 'tc-1' }, + ], + }); + }); + + it('merges a preceding text-only assistant message into the approval message', () => { + const ctrl = makeController(); + ctrl._turn.begin(); + ctrl._messages = [ + { role: ROLE.USER, content: 'go' }, + { role: ROLE.ASSISTANT, content: 'Sure, creating those pages now.' }, + ]; + ctrl._pendingBatch = { + toolCalls: [{ toolCallId: 'tc-1', toolName: 'content_create', input: { path: '/a.md' } }], + approvalRequests: [], + }; + ctrl._toolCards = new Map([ + ['tc-1', { toolName: 'content_create', input: { path: '/a.md' }, state: TOOL_STATE.RUNNING }], + ]); + + ctrl._onApprovalRequest('tc-1', 'content_create', 'ap-1'); + + // Text merged in — only 2 messages total, not 3 + expect(ctrl._messages).to.have.lengthOf(2); + expect(ctrl._messages[1]).to.deep.equal({ + role: ROLE.ASSISTANT, + content: [ + { type: 'text', text: 'Sure, creating those pages now.' }, + { type: AGENT_EVENT.TOOL_CALL, toolCallId: 'tc-1', toolName: 'content_create', input: { path: '/a.md' } }, + { type: AGENT_EVENT.TOOL_APPROVAL_REQUEST, approvalId: 'ap-1', toolCallId: 'tc-1' }, + ], + }); + }); + + it('sets card to APPROVED and commits message when tool name is in autoApprovedTools', () => { + const ctrl = makeController(); + ctrl._turn.begin(); + ctrl._autoApprovedTools = new Set(['my-tool']); + ctrl._messages = [{ role: ROLE.USER, content: 'go' }]; + ctrl._pendingBatch = { + toolCalls: [{ toolCallId: 'tc-1', toolName: 'my-tool', input: {} }], + approvalRequests: [], + }; + ctrl._toolCards = new Map([['tc-1', { toolName: 'my-tool', input: {}, state: TOOL_STATE.RUNNING }]]); + + ctrl._onApprovalRequest('tc-1', 'my-tool', 'ap-1'); + + expect(ctrl._toolCards.get('tc-1').state).to.equal(TOOL_STATE.APPROVED); + expect(ctrl._pendingBatch.approvalRequests).to.deep.equal([{ approvalId: 'ap-1', toolCallId: 'tc-1' }]); + // Message still committed immediately even for auto-approved + expect(ctrl._messages).to.have.lengthOf(2); + expect(ctrl._messages[1].content[1].type).to.equal(AGENT_EVENT.TOOL_APPROVAL_REQUEST); + }); + + it('each parallel approval tool gets its own assistant message (no batching)', () => { + const ctrl = makeController(); + ctrl._turn.begin(); + ctrl._messages = [{ role: ROLE.USER, content: 'go' }]; + ctrl._pendingBatch = { + toolCalls: [ + { toolCallId: 'tc-1', toolName: 'tool-a', input: { a: 1 } }, + { toolCallId: 'tc-2', toolName: 'tool-b', input: { b: 2 } }, + ], + approvalRequests: [], + }; + ctrl._toolCards = new Map([ + ['tc-1', { toolName: 'tool-a', input: { a: 1 }, state: TOOL_STATE.RUNNING }], + ['tc-2', { toolName: 'tool-b', input: { b: 2 }, state: TOOL_STATE.RUNNING }], + ]); + + ctrl._onApprovalRequest('tc-1', 'tool-a', 'ap-1'); + ctrl._onApprovalRequest('tc-2', 'tool-b', 'ap-2'); + + // Two separate approval messages + expect(ctrl._messages).to.have.lengthOf(3); + expect(ctrl._messages[1].content).to.deep.equal([ + { type: AGENT_EVENT.TOOL_CALL, toolCallId: 'tc-1', toolName: 'tool-a', input: { a: 1 } }, + { type: AGENT_EVENT.TOOL_APPROVAL_REQUEST, approvalId: 'ap-1', toolCallId: 'tc-1' }, + ]); + expect(ctrl._messages[2].content).to.deep.equal([ + { type: AGENT_EVENT.TOOL_CALL, toolCallId: 'tc-2', toolName: 'tool-b', input: { b: 2 } }, + { type: AGENT_EVENT.TOOL_APPROVAL_REQUEST, approvalId: 'ap-2', toolCallId: 'tc-2' }, + ]); + expect(ctrl._pendingBatch.toolCalls).to.have.lengthOf(0); + }); +}); + +describe('ChatController — _onStreamFinish', () => { + it('does not modify messages or set continuation when batch is empty (text-only response)', () => { + const ctrl = makeController(); + const messages = [ + { role: 'user', content: 'hello' }, + { role: 'assistant', content: 'hi there' }, + ]; + ctrl._messages = [...messages]; + + ctrl._onStreamFinish('room-1'); + + expect(ctrl._messages).to.deep.equal(messages); + expect(ctrl._pendingContinuation).to.be.undefined; + }); + + it('adds auto-approval responses and sets continuation when all cards are approved', () => { + const ctrl = makeController(); + // Approval messages were already committed by _onApprovalRequest + ctrl._messages = [ + { role: ROLE.USER, content: 'go' }, + { + role: ROLE.ASSISTANT, + content: [ + { type: AGENT_EVENT.TOOL_CALL, toolCallId: 'tc-1', toolName: 'my-tool', input: { x: 1 } }, + { type: AGENT_EVENT.TOOL_APPROVAL_REQUEST, approvalId: 'ap-1', toolCallId: 'tc-1' }, + ], + }, + ]; + ctrl._pendingBatch = { + toolCalls: [], + approvalRequests: [{ approvalId: 'ap-1', toolCallId: 'tc-1' }], + }; + ctrl._toolCards = new Map([ + ['tc-1', { toolName: 'my-tool', input: { x: 1 }, state: TOOL_STATE.APPROVED, approvalId: 'ap-1' }], + ]); + + ctrl._onStreamFinish('room-1'); + + // Auto-approval response appended after the already-committed assistant message + expect(ctrl._messages).to.have.lengthOf(3); + expect(ctrl._messages[2]).to.deep.equal({ + role: ROLE.TOOL, + content: [{ type: AGENT_EVENT.TOOL_APPROVAL_RESPONSE, approvalId: 'ap-1', approved: true }], + }); + expect(ctrl._pendingContinuation).to.be.true; + expect(ctrl._pendingBatch.approvalRequests).to.have.lengthOf(0); + }); + + it('does not set continuation when approval is pending (manual) — just clears the batch', () => { + const ctrl = makeController(); + // Approval message was already committed by _onApprovalRequest + ctrl._messages = [ + { role: ROLE.USER, content: 'go' }, + { + role: ROLE.ASSISTANT, + content: [ + { type: AGENT_EVENT.TOOL_CALL, toolCallId: 'tc-1', toolName: 'my-tool', input: {} }, + { type: AGENT_EVENT.TOOL_APPROVAL_REQUEST, approvalId: 'ap-1', toolCallId: 'tc-1' }, + ], + }, + ]; + ctrl._pendingBatch = { + toolCalls: [], + approvalRequests: [{ approvalId: 'ap-1', toolCallId: 'tc-1' }], + }; + ctrl._toolCards = new Map([ + ['tc-1', { toolName: 'my-tool', input: {}, state: TOOL_STATE.APPROVAL_REQUESTED, approvalId: 'ap-1' }], + ]); + + ctrl._onStreamFinish('room-1'); + + expect(ctrl._messages).to.have.lengthOf(2); // no new messages added + expect(ctrl._pendingContinuation).to.not.be.true; + expect(ctrl._pendingBatch.approvalRequests).to.have.lengthOf(0); + }); + + it('adds responses for all parallel auto-approved tools', () => { + const ctrl = makeController(); + ctrl._messages = [ + { role: ROLE.USER, content: 'go' }, + { + role: ROLE.ASSISTANT, + content: [ + { type: AGENT_EVENT.TOOL_CALL, toolCallId: 'tc-1', toolName: 'tool-a', input: {} }, + { type: AGENT_EVENT.TOOL_APPROVAL_REQUEST, approvalId: 'ap-1', toolCallId: 'tc-1' }, + ], + }, + { + role: ROLE.ASSISTANT, + content: [ + { type: AGENT_EVENT.TOOL_CALL, toolCallId: 'tc-2', toolName: 'tool-b', input: {} }, + { type: AGENT_EVENT.TOOL_APPROVAL_REQUEST, approvalId: 'ap-2', toolCallId: 'tc-2' }, + ], + }, + ]; + ctrl._pendingBatch = { + toolCalls: [], + approvalRequests: [ + { approvalId: 'ap-1', toolCallId: 'tc-1' }, + { approvalId: 'ap-2', toolCallId: 'tc-2' }, + ], + }; + ctrl._toolCards = new Map([ + ['tc-1', { toolName: 'tool-a', input: {}, state: TOOL_STATE.APPROVED, approvalId: 'ap-1' }], + ['tc-2', { toolName: 'tool-b', input: {}, state: TOOL_STATE.APPROVED, approvalId: 'ap-2' }], + ]); + + ctrl._onStreamFinish('room-1'); + + expect(ctrl._messages[3].content[0].approvalId).to.equal('ap-1'); + expect(ctrl._messages[4].content[0].approvalId).to.equal('ap-2'); + expect(ctrl._messages).to.have.lengthOf(5); + expect(ctrl._pendingContinuation).to.be.true; + }); + + it('skips duplicate responses and does not set continuation when user approved before stream ended (race condition)', () => { + // Scenario: user clicked "approve" before FINISH_MESSAGE arrived, so approveToolCall + // already added the tool-approval-response. _onStreamFinish must not add it again and + // must not set _pendingContinuation (approveToolCall's stream is already in flight). + const ctrl = makeController(); + ctrl._messages = [ + { role: ROLE.USER, content: 'go' }, + { + role: ROLE.ASSISTANT, + content: [ + { type: AGENT_EVENT.TOOL_CALL, toolCallId: 'tc-1', toolName: 'my-tool', input: {} }, + { type: AGENT_EVENT.TOOL_APPROVAL_REQUEST, approvalId: 'ap-1', toolCallId: 'tc-1' }, + ], + }, + // approveToolCall already added this response + { role: ROLE.TOOL, content: [{ type: AGENT_EVENT.TOOL_APPROVAL_RESPONSE, approvalId: 'ap-1', approved: true }] }, + ]; + ctrl._pendingBatch = { + toolCalls: [], + approvalRequests: [{ approvalId: 'ap-1', toolCallId: 'tc-1' }], + }; + ctrl._toolCards = new Map([ + ['tc-1', { toolName: 'my-tool', input: {}, state: TOOL_STATE.APPROVED, approvalId: 'ap-1' }], + ]); + + ctrl._onStreamFinish('room-1'); + + expect(ctrl._messages).to.have.lengthOf(3); // no duplicate added + expect(ctrl._pendingContinuation).to.not.be.true; // no spurious Stream C + expect(ctrl._pendingBatch.approvalRequests).to.have.lengthOf(0); // batch still cleared + }); +}); + +describe('ChatController — approveToolCall', () => { + function makeControllerWithCard(state = TOOL_STATE.APPROVAL_REQUESTED) { + const ctrl = makeController(); + ctrl._messages = [ + { role: ROLE.USER, content: 'go' }, + { + role: ROLE.ASSISTANT, + content: [ + { type: AGENT_EVENT.TOOL_CALL, toolCallId: 'tc-1', toolName: 'my-tool', input: {} }, + { type: AGENT_EVENT.TOOL_APPROVAL_REQUEST, approvalId: 'ap-1', toolCallId: 'tc-1' }, + ], + }, + ]; + ctrl._toolCards = new Map([ + ['tc-1', { toolName: 'my-tool', input: {}, state, approvalId: 'ap-1' }], + ]); + ctrl._turn.begin(); + ctrl._turn.pause(); + return ctrl; + } + + it('does nothing when the card has no approvalId', async () => { + const ctrl = makeController(); + ctrl._messages = [{ role: ROLE.USER, content: 'go' }]; + ctrl._toolCards = new Map([['tc-1', { toolName: 'my-tool', state: TOOL_STATE.APPROVAL_REQUESTED }]]); + await ctrl.approveToolCall('tc-1', true); + expect(ctrl._messages).to.have.lengthOf(1); + }); + + it('appends an approval response and calls stream', async () => { + const ctrl = makeControllerWithCard(); + let streamCalled = false; + ctrl._stream = () => { + streamCalled = true; + return Promise.resolve(); + }; + + await ctrl.approveToolCall('tc-1', true); + + // Approval response is committed; mock stream returns no tool-result so the justApproved + // close-out adds a synthetic tool-result — the response is not the last message. + const response = ctrl._messages + .filter((m) => m.role === ROLE.TOOL) + .flatMap((m) => m.content) + .find((p) => p.type === AGENT_EVENT.TOOL_APPROVAL_RESPONSE); + expect(response).to.deep.equal({ type: AGENT_EVENT.TOOL_APPROVAL_RESPONSE, approvalId: 'ap-1', approved: true }); + expect(streamCalled).to.be.true; + expect(ctrl._turn.isActive).to.be.false; + }); + + it('bulk-approves siblings with the same tool name when always=true', async () => { + const ctrl = makeControllerWithCard(); + ctrl._toolCards.set('tc-2', { toolName: 'my-tool', input: {}, state: TOOL_STATE.APPROVAL_REQUESTED, approvalId: 'ap-2' }); + ctrl._toolCards.set('tc-3', { toolName: 'my-tool', input: {}, state: TOOL_STATE.APPROVAL_REQUESTED, approvalId: 'ap-3' }); + ctrl._stream = () => Promise.resolve(); + + await ctrl.approveToolCall('tc-1', true, true); + + // All three responses committed in one go + const responses = ctrl._messages + .filter((m) => m.role === ROLE.TOOL) + .flatMap((m) => m.content) + .filter((p) => p.type === AGENT_EVENT.TOOL_APPROVAL_RESPONSE); + + expect(responses).to.have.lengthOf(3); + expect(responses.map((r) => r.approvalId)).to.include.members(['ap-1', 'ap-2', 'ap-3']); + // Mock stream returns no tool-results → justApproved close-out sets all to DONE. + expect(ctrl._toolCards.get('tc-2').state).to.equal(TOOL_STATE.DONE); + expect(ctrl._toolCards.get('tc-3').state).to.equal(TOOL_STATE.DONE); + }); + + it('appends a rejection response and calls stream', async () => { + const ctrl = makeControllerWithCard(); + let streamCalled = false; + ctrl._stream = () => { + streamCalled = true; + return Promise.resolve(); + }; + + await ctrl.approveToolCall('tc-1', false); + + expect(ctrl._messages.at(-1)).to.deep.equal({ + role: ROLE.TOOL, + content: [{ type: AGENT_EVENT.TOOL_APPROVAL_RESPONSE, approvalId: 'ap-1', approved: false }], + }); + // Rejection streams immediately so da-agent can respond (e.g. "I won't do that"). + expect(streamCalled).to.be.true; + expect(ctrl._turn.isActive).to.be.false; + }); + + it('streams immediately for the first approval even when siblings are still pending', async () => { + // Per-tool streaming: each approval fires its own _stream() right away so da-agent + // can use buildApprovalContinuationResponse while other tools still have unresolved + // tool-approval-request parts — this keeps hasPendingApprovals=true and ensures + // results are streamed back rather than absorbed internally by streamText. + const ctrl = makeControllerWithCard(); + ctrl._toolCards.set('tc-2', { toolName: 'my-tool', input: {}, state: TOOL_STATE.APPROVAL_REQUESTED, approvalId: 'ap-2' }); + ctrl._toolCards.set('tc-3', { toolName: 'my-tool', input: {}, state: TOOL_STATE.APPROVAL_REQUESTED, approvalId: 'ap-3' }); + let streamCount = 0; + ctrl._stream = async () => { streamCount += 1; }; + + await ctrl.approveToolCall('tc-1', true); + + // Stream fired immediately for tc-1, not deferred until tc-2/tc-3 are resolved. + expect(streamCount).to.equal(1); + // Response for tc-1 is committed. + const responses = ctrl._messages + .filter((m) => m.role === ROLE.TOOL) + .flatMap((m) => m.content) + .filter((p) => p.type === AGENT_EVENT.TOOL_APPROVAL_RESPONSE); + expect(responses).to.have.lengthOf(1); + expect(responses[0].approvalId).to.equal('ap-1'); + }); +}); + +describe('ChatController — _onToolResult', () => { + it('commits call+result pair and removes tool from batch (non-approval)', () => { + const ctrl = makeController(); + ctrl._messages = [{ role: ROLE.USER, content: 'go' }]; + ctrl._pendingBatch = { + toolCalls: [{ toolCallId: 'tc-1', toolName: 'my-tool', input: { path: '/a.md' } }], + approvalRequests: [], + }; + ctrl._toolCards = new Map([ + ['tc-1', { toolName: 'my-tool', input: { path: '/a.md' }, state: TOOL_STATE.RUNNING }], + ]); + + ctrl._onToolResult('tc-1', 'my-tool', 'done', false, null); + + expect(ctrl._messages).to.have.lengthOf(3); + expect(ctrl._messages[1]).to.deep.equal({ + role: ROLE.ASSISTANT, + content: [{ type: AGENT_EVENT.TOOL_CALL, toolCallId: 'tc-1', toolName: 'my-tool', input: { path: '/a.md' } }], + }); + expect(ctrl._messages[2]).to.deep.equal({ + role: ROLE.TOOL, + content: [{ type: AGENT_EVENT.TOOL_RESULT, toolCallId: 'tc-1', toolName: 'my-tool', output: { type: 'text', value: 'done' } }], + }); + expect(ctrl._pendingBatch.toolCalls).to.have.lengthOf(0); + }); + + it('commits result only in continuation stream (approval tool, not in batch)', () => { + const ctrl = makeController(); + ctrl._messages = [ + { role: ROLE.USER, content: 'go' }, + { + role: ROLE.ASSISTANT, + content: [ + { type: AGENT_EVENT.TOOL_CALL, toolCallId: 'tc-1', toolName: 'my-tool', input: {} }, + { type: AGENT_EVENT.TOOL_APPROVAL_REQUEST, approvalId: 'ap-1', toolCallId: 'tc-1' }, + ], + }, + { role: ROLE.TOOL, content: [{ type: AGENT_EVENT.TOOL_APPROVAL_RESPONSE, approvalId: 'ap-1', approved: true }] }, + ]; + ctrl._pendingBatch = { toolCalls: [], approvalRequests: [] }; + ctrl._toolCards = new Map([ + ['tc-1', { toolName: 'my-tool', input: {}, state: TOOL_STATE.APPROVED, approvalId: 'ap-1' }], + ]); + + ctrl._onToolResult('tc-1', 'my-tool', 'done', false, null); + + expect(ctrl._messages).to.have.lengthOf(4); + expect(ctrl._messages[3]).to.deep.equal({ + role: ROLE.TOOL, + content: [{ type: AGENT_EVENT.TOOL_RESULT, toolCallId: 'tc-1', toolName: 'my-tool', output: { type: 'text', value: 'done' } }], + }); + }); + + it('sets card state to error, commits no messages, and evicts from batch when isError is true', () => { + const ctrl = makeController(); + ctrl._messages = [{ role: ROLE.USER, content: 'go' }]; + ctrl._pendingBatch = { + toolCalls: [{ toolCallId: 'tc-1', toolName: 'my-tool', input: {} }], + approvalRequests: [], + }; + ctrl._toolCards = new Map([ + ['tc-1', { toolName: 'my-tool', input: {}, state: TOOL_STATE.RUNNING }], + ]); + + ctrl._onToolResult('tc-1', 'my-tool', 'something went wrong', true, null); + + expect(ctrl._messages).to.have.lengthOf(1); + expect(ctrl._toolCards.get('tc-1').state).to.equal(TOOL_STATE.ERROR); + // Must be evicted so it cannot contaminate a later approval batch commit. + expect(ctrl._pendingBatch.toolCalls).to.have.lengthOf(0); + }); + + it('merges a preceding text-only assistant message into the tool-call message', () => { + const ctrl = makeController(); + ctrl._messages = [ + { role: ROLE.USER, content: 'go' }, + { role: ROLE.ASSISTANT, content: 'Now let me read the existing pages:' }, + ]; + ctrl._pendingBatch = { + toolCalls: [{ toolCallId: 'tc-1', toolName: 'content_list', input: { path: '/a' } }], + approvalRequests: [], + }; + ctrl._toolCards = new Map([ + ['tc-1', { toolName: 'content_list', input: { path: '/a' }, state: TOOL_STATE.RUNNING }], + ]); + + ctrl._onToolResult('tc-1', 'content_list', 'result', false, null); + + // 3 messages: user + merged-assistant + tool-result (not 4 with separate text and tool-call) + expect(ctrl._messages).to.have.lengthOf(3); + expect(ctrl._messages[1]).to.deep.equal({ + role: ROLE.ASSISTANT, + content: [ + { type: 'text', text: 'Now let me read the existing pages:' }, + { type: AGENT_EVENT.TOOL_CALL, toolCallId: 'tc-1', toolName: 'content_list', input: { path: '/a' } }, + ], + }); + expect(ctrl._messages[2].role).to.equal(ROLE.TOOL); + }); +}); + +describe('ChatController — _onStreamFinish (finishReason)', () => { + it('sets _pendingContinuation when finishReason is tool-calls and batch is empty', () => { + const ctrl = makeController(); + ctrl._messages = [ + { role: ROLE.USER, content: 'go' }, + { role: ROLE.TOOL, content: [{ type: AGENT_EVENT.TOOL_RESULT, toolCallId: 'tc-1', output: 'ok' }] }, + ]; + + ctrl._onStreamFinish('room-1', FINISH_REASON.TOOL_CALLS); + + expect(ctrl._pendingContinuation).to.be.true; + }); + + it('does not set _pendingContinuation when last message is role:assistant (prefill guard)', () => { + const ctrl = makeController(); + ctrl._messages = [ + { role: ROLE.USER, content: 'go' }, + { role: ROLE.ASSISTANT, content: 'I will now create the files.' }, + ]; + + ctrl._onStreamFinish('room-1', FINISH_REASON.TOOL_CALLS); + + expect(ctrl._pendingContinuation).to.not.be.true; + }); +}); + +describe('ChatController — _done (batch cleanup)', () => { + it('does not end the turn when _activeApprovalStreams > 0', () => { + // Scenario: sendMessage's stream ended (FINISH_MESSAGE received) while approveToolCall's + // stream is still in progress. sendMessage's _done() must not set turn to IDLE — that + // would incorrectly hide the thinking indicator and corrupt turn state. + const ctrl = makeController(); + ctrl._turn.begin(); + ctrl._turn.pause(); + ctrl._turn.resume(); // RESUMING — approval stream is in progress + ctrl._activeApprovalStreams = 1; + + ctrl._done(); + + expect(ctrl._turn.isActive).to.be.true; // turn still active + }); + + it('ends the turn normally when _activeApprovalStreams is 0', () => { + const ctrl = makeController(); + ctrl._turn.begin(); + + ctrl._done(); + + expect(ctrl._turn.isActive).to.be.false; + }); + + it('does not end the turn when a second approval stream is still running (counter > 0 after first decrements)', () => { + // Race: user approves tc-2 while stream C (tc-1's approval stream) is still open. + // Stream C's finally decrements the counter but stream D (tc-2's) already incremented it. + // Net counter = 1 — _done() from stream C must not end the turn. + const ctrl = makeController(); + ctrl._turn.begin(); + ctrl._turn.pause(); + ctrl._turn.resume(); // RESUMING + ctrl._activeApprovalStreams = 1; // stream D incremented before stream C's finally ran + + ctrl._done(); // stream C's _done() + + expect(ctrl._turn.isActive).to.be.true; + }); + + it('does not end the turn when tool cards are still APPROVAL_REQUESTED', () => { + // Per-tool streaming: after tc-1's stream finishes, tc-2 and tc-3 are still pending. + // _done() must not end the turn — the turn should stay active so the UI keeps + // showing the spinner and sendMessage remains blocked. + const ctrl = makeController(); + ctrl._turn.begin(); + ctrl._turn.pause(); + ctrl._turn.resume(); // RESUMING — approval streams ongoing + ctrl._toolCards = new Map([ + ['tc-1', { toolName: 'my-tool', input: {}, state: TOOL_STATE.DONE, approvalId: 'ap-1' }], + ['tc-2', { toolName: 'my-tool', input: {}, state: TOOL_STATE.APPROVAL_REQUESTED, approvalId: 'ap-2' }], + ['tc-3', { toolName: 'my-tool', input: {}, state: TOOL_STATE.APPROVAL_REQUESTED, approvalId: 'ap-3' }], + ]); + + ctrl._done(); // called after tc-1's stream finishes + + expect(ctrl._turn.isActive).to.be.true; + }); + + it('ends the turn in _done when no pending cards remain and no approval stream is active', () => { + const ctrl = makeController(); + ctrl._turn.begin(); + ctrl._turn.pause(); + ctrl._turn.resume(); + ctrl._toolCards = new Map([ + ['tc-1', { toolName: 'my-tool', input: {}, state: TOOL_STATE.DONE, approvalId: 'ap-1' }], + ['tc-2', { toolName: 'my-tool', input: {}, state: TOOL_STATE.DONE, approvalId: 'ap-2' }], + ]); + + ctrl._done(); + + expect(ctrl._turn.isActive).to.be.false; + }); + + it('clears _pendingBatch before triggering continuation stream', async () => { + const ctrl = makeController(); + ctrl._turn.begin(); + ctrl._pendingContinuation = true; + ctrl._pendingBatch = { + toolCalls: [{ toolCallId: 'stale', toolName: 'my-tool', input: {} }], + approvalRequests: [], + }; + + let batchAtStreamTime; + const started = new Promise((resolve) => { + ctrl._stream = () => { + batchAtStreamTime = { toolCalls: [...ctrl._pendingBatch.toolCalls] }; + resolve(); + return Promise.resolve(); + }; + }); + + ctrl._done(); + await started; + + expect(batchAtStreamTime.toolCalls).to.have.lengthOf(0); + }); +}); + +describe('ChatController — sendMessage', () => { + describe('guards', () => { + it('does nothing when turn is already active', async () => { + const ctrl = makeController(); + ctrl._isConnected = true; + ctrl._turn.begin(); + await ctrl.sendMessage('hi', [], {}); + expect(ctrl._messages).to.be.undefined; + }); + + it('does nothing when not connected', async () => { + const ctrl = makeController(); + // _isConnected is undefined by default + await ctrl.sendMessage('hi', [], {}); + expect(ctrl._messages).to.be.undefined; + }); + }); + + describe('error handling', () => { + it('appends an error message when stream throws', async () => { + const ctrl = makeController(); + ctrl._isConnected = true; + ctrl._stream = () => Promise.reject(new Error('network failure')); + await ctrl.sendMessage('hi', [], {}); + expect(ctrl._messages.at(-1)).to.deep.equal({ + role: 'assistant', + content: 'Error: network failure', + }); + }); + + it('does not append an error message when stream is aborted', async () => { + const ctrl = makeController(); + ctrl._isConnected = true; + ctrl._stream = () => Promise.reject(Object.assign(new Error('aborted'), { name: 'AbortError' })); + await ctrl.sendMessage('hi', [], {}); + expect(ctrl._messages.at(-1).role).to.equal('user'); + }); + }); +}); diff --git a/test/nx2/blocks/chat/controllers/turn.test.js b/test/nx2/blocks/chat/controllers/turn.test.js new file mode 100644 index 000000000..e89653d3a --- /dev/null +++ b/test/nx2/blocks/chat/controllers/turn.test.js @@ -0,0 +1,146 @@ +import { expect } from '@esm-bundle/chai'; +import Turn from '../../../../../nx2/blocks/chat/controllers/turn.js'; + +describe('Turn', () => { + let turn; + + beforeEach(() => { + turn = new Turn(); + }); + + describe('initial state', () => { + it('starts idle and inactive', () => { + expect(turn.isActive).to.be.false; + }); + }); + + describe('begin()', () => { + it('idle → streaming (isActive becomes true)', () => { + turn.begin(); + expect(turn.isActive).to.be.true; + }); + }); + + describe('end()', () => { + it('streaming → idle', () => { + turn.begin(); + turn.end(); + expect(turn.isActive).to.be.false; + }); + + it('resuming → idle', () => { + turn.begin(); + turn.pause(); + turn.resume(); + turn.end(); + expect(turn.isActive).to.be.false; + }); + + it('no-op from approval-pending — stays active', () => { + turn.begin(); + turn.pause(); + turn.end(); // must not go to idle + expect(turn.isActive).to.be.true; + }); + }); + + describe('pause()', () => { + it('streaming → approval-pending (end becomes no-op)', () => { + turn.begin(); + turn.pause(); + turn.end(); // no-op from approval-pending + expect(turn.isActive).to.be.true; + }); + + it('resuming → approval-pending (nested approval)', () => { + turn.begin(); + turn.pause(); + turn.resume(); + turn.pause(); // nested — back to approval-pending + turn.end(); // no-op from approval-pending + expect(turn.isActive).to.be.true; + }); + + it('no-op from idle', () => { + turn.pause(); + expect(turn.isActive).to.be.false; + }); + + it('no-op from approval-pending', () => { + turn.begin(); + turn.pause(); + turn.pause(); // second pause — no-op + // resume still works, confirming still in approval-pending + turn.resume(); + turn.end(); + expect(turn.isActive).to.be.false; + }); + }); + + describe('resume()', () => { + it('approval-pending → resuming (end then works)', () => { + turn.begin(); + turn.pause(); + turn.resume(); + turn.end(); + expect(turn.isActive).to.be.false; + }); + + it('no-op from streaming (end still works)', () => { + turn.begin(); + turn.resume(); // no-op — not in approval-pending + turn.end(); + expect(turn.isActive).to.be.false; + }); + + it('no-op from resuming (end still works)', () => { + turn.begin(); + turn.pause(); + turn.resume(); + turn.resume(); // no-op — already resuming + turn.end(); + expect(turn.isActive).to.be.false; + }); + }); + + describe('cancel()', () => { + it('streaming → idle', () => { + turn.begin(); + turn.cancel(); + expect(turn.isActive).to.be.false; + }); + + it('approval-pending → idle', () => { + turn.begin(); + turn.pause(); + turn.cancel(); + expect(turn.isActive).to.be.false; + }); + + it('resuming → idle', () => { + turn.begin(); + turn.pause(); + turn.resume(); + turn.cancel(); + expect(turn.isActive).to.be.false; + }); + }); + + describe('isActive', () => { + it('is false only in idle — true for streaming, approval-pending, resuming', () => { + expect(turn.isActive).to.be.false; // idle + + turn.begin(); + expect(turn.isActive).to.be.true; // streaming + + turn.pause(); + expect(turn.isActive).to.be.true; // approval-pending + + turn.resume(); + expect(turn.isActive).to.be.true; // resuming + + turn.end(); + expect(turn.isActive).to.be.false; // idle + }); + }); +}); diff --git a/test/nx2/blocks/chat/utils/messages.test.js b/test/nx2/blocks/chat/utils/messages.test.js new file mode 100644 index 000000000..16ef14401 --- /dev/null +++ b/test/nx2/blocks/chat/utils/messages.test.js @@ -0,0 +1,367 @@ +import { expect } from '@esm-bundle/chai'; +import { stripOrphanedToolCallMessages, buildUserMessage } from '../../../../../nx2/blocks/chat/utils/messages.js'; + +// Helpers to build message shapes without repeating boilerplate. +const user = (content = 'hello') => ({ role: 'user', content }); +const text = (content = 'ok') => ({ role: 'assistant', content }); +const toolCall = (toolCallId, toolName = 'do-thing', input = {}) => ({ + role: 'assistant', + content: [{ type: 'tool-call', toolCallId, toolName, input }], +}); +const toolResult = (toolCallId, toolName = 'do-thing', output = 'done') => ({ + role: 'tool', + content: [{ type: 'tool-result', toolCallId, toolName, output }], +}); +const approvalBatch = (calls, requests) => ({ + role: 'assistant', + content: [ + ...calls.map(({ toolCallId, toolName = 'do-thing', input = {} }) => ({ + type: 'tool-call', toolCallId, toolName, input, + })), + ...requests.map(({ approvalId, toolCallId }) => ({ + type: 'tool-approval-request', approvalId, toolCallId, + })), + ], +}); +const approvalResponse = (approvalId, approved = true) => ({ + role: 'tool', + content: [{ type: 'tool-approval-response', approvalId, approved }], +}); + +describe('stripOrphanedToolCallMessages', () => { + describe('no-op cases — nothing to strip', () => { + it('returns empty array unchanged', () => { + expect(stripOrphanedToolCallMessages([])).to.deep.equal([]); + }); + + it('passes through user and text-only assistant messages', () => { + const msgs = [user('hi'), text('hello back')]; + expect(stripOrphanedToolCallMessages(msgs)).to.deep.equal(msgs); + }); + + it('keeps a non-approval tool-call that has a result', () => { + const msgs = [user(), toolCall('id-1'), toolResult('id-1'), text()]; + expect(stripOrphanedToolCallMessages(msgs)).to.deep.equal(msgs); + }); + + it('keeps a complete approval batch (request + response) while tool result is absent and tool is live', () => { + // Response exists and tool is actively executing — keep both so da-agent can execute. + const msgs = [ + user(), + approvalBatch([{ toolCallId: 'id-1' }], [{ approvalId: 'ap-1', toolCallId: 'id-1' }]), + approvalResponse('ap-1'), + ]; + expect(stripOrphanedToolCallMessages(msgs, { + liveToolCallIds: new Set(['id-1']), + })).to.deep.equal(msgs); + }); + + it('strips the approval-response and approval-request once the tool result is present', () => { + // When a tool-result exists, both the approval-response and approval-request are stale. + // The approval-response is dropped to avoid "unknown approvalId" in da-agent's streamText. + // The approval-request is also stripped from the assistant message so da-agent sees a + // plain tool_call → tool_result pair rather than an unresolved approval. + const msgs = [ + user(), + approvalBatch([{ toolCallId: 'id-1' }], [{ approvalId: 'ap-1', toolCallId: 'id-1' }]), + approvalResponse('ap-1'), + toolResult('id-1'), + text(), + ]; + expect(stripOrphanedToolCallMessages(msgs)).to.deep.equal([ + user(), + toolCall('id-1'), // approval_request stripped — only tool_call remains + toolResult('id-1'), + text(), + ]); + }); + + it('strips approval-responses and approval-requests for a parallel batch once tool results exist', () => { + const msgs = [ + user(), + approvalBatch( + [{ toolCallId: 'id-1' }, { toolCallId: 'id-2' }], + [{ approvalId: 'ap-1', toolCallId: 'id-1' }, { approvalId: 'ap-2', toolCallId: 'id-2' }], + ), + approvalResponse('ap-1'), + approvalResponse('ap-2'), + toolResult('id-1'), + toolResult('id-2'), + text(), + ]; + expect(stripOrphanedToolCallMessages(msgs)).to.deep.equal([ + user(), + // Both approval_requests stripped — assistant message has only the two tool_calls + { + role: 'assistant', + content: [ + { type: 'tool-call', toolCallId: 'id-1', toolName: 'do-thing', input: {} }, + { type: 'tool-call', toolCallId: 'id-2', toolName: 'do-thing', input: {} }, + ], + }, + toolResult('id-1'), + toolResult('id-2'), + text(), + ]); + }); + }); + + describe('stripping cases', () => { + it('strips an assistant message whose tool-call has no result', () => { + const msgs = [user(), toolCall('id-1')]; + expect(stripOrphanedToolCallMessages(msgs)).to.deep.equal([user()]); + }); + + it('strips an approval batch where the request has no response', () => { + const msgs = [ + user(), + approvalBatch([{ toolCallId: 'id-1' }], [{ approvalId: 'ap-1', toolCallId: 'id-1' }]), + ]; + expect(stripOrphanedToolCallMessages(msgs)).to.deep.equal([user()]); + }); + + it('strips an orphaned approval response that has no matching request', () => { + // Response references approvalId that was never in an assistant message. + const msgs = [user(), approvalResponse('ap-ghost')]; + expect(stripOrphanedToolCallMessages(msgs)).to.deep.equal([user()]); + }); + + it('strips an entire parallel batch when one tool-call has no result', () => { + // Both id-1 and id-2 are in the same assistant message. + // id-2 has no result — the whole message must be stripped. + const msgs = [ + user(), + { + role: 'assistant', + content: [ + { type: 'tool-call', toolCallId: 'id-1', toolName: 'do-thing', input: {} }, + { type: 'tool-call', toolCallId: 'id-2', toolName: 'do-thing', input: {} }, + ], + }, + toolResult('id-1'), + ]; + const result = stripOrphanedToolCallMessages(msgs); + // Assistant message stripped; tool result for id-1 kept (it's not an approval-response) + expect(result).to.deep.equal([user(), toolResult('id-1')]); + }); + + it('strips a parallel approval batch whose assistant message is incomplete', () => { + // ap-2 has no response → batch stripped. ap-1 has a complete approval but no tool result + // and is not live → its response is also stripped (would cause orphaned tool_use). + const msgs = [ + user(), + approvalBatch( + [{ toolCallId: 'id-1' }, { toolCallId: 'id-2' }], + [{ approvalId: 'ap-1', toolCallId: 'id-1' }, { approvalId: 'ap-2', toolCallId: 'id-2' }], + ), + approvalResponse('ap-1'), + // ap-2 never responded + ]; + const result = stripOrphanedToolCallMessages(msgs); + expect(result).to.deep.equal([user()]); + }); + }); + + describe('mixed sequences', () => { + it('strips only the unresolved tool, keeps the resolved one', () => { + const msgs = [ + user(), + toolCall('id-1'), + toolResult('id-1'), + text('after first'), + user('second ask'), + toolCall('id-2'), + // id-2 has no result + ]; + expect(stripOrphanedToolCallMessages(msgs)).to.deep.equal([ + user(), + toolCall('id-1'), + toolResult('id-1'), + text('after first'), + user('second ask'), + ]); + }); + + it('strips an approval batch where response exists but tool result is missing (not live)', () => { + // Approval complete but tool result never arrived and tool is not in liveToolCallIds + // (e.g. session loaded from persistence after an interrupted stream). Keeping this + // would cause da-agent to forward an unresolved tool_use to Anthropic. + const msgs = [ + user(), + approvalBatch([{ toolCallId: 'id-1' }], [{ approvalId: 'ap-1', toolCallId: 'id-1' }]), + approvalResponse('ap-1'), + // tool result never arrived + ]; + expect(stripOrphanedToolCallMessages(msgs)).to.deep.equal([user()]); + }); + + it('keeps an approval batch with no tool result when tool is live', () => { + // Tool is actively executing — approval given, result not yet back. + const msgs = [ + user(), + approvalBatch([{ toolCallId: 'id-1' }], [{ approvalId: 'ap-1', toolCallId: 'id-1' }]), + approvalResponse('ap-1'), + ]; + const result = stripOrphanedToolCallMessages(msgs, { + liveToolCallIds: new Set(['id-1']), + }); + expect(result).to.deep.equal(msgs); + }); + + it('strips only the incomplete approval, keeps the complete one (stale response and request also stripped)', () => { + const msgs = [ + user(), + approvalBatch([{ toolCallId: 'id-1' }], [{ approvalId: 'ap-1', toolCallId: 'id-1' }]), + approvalResponse('ap-1'), + toolResult('id-1'), + text('first done'), + user('second ask'), + approvalBatch([{ toolCallId: 'id-2' }], [{ approvalId: 'ap-2', toolCallId: 'id-2' }]), + // ap-2 never responded + ]; + // ap-1 resolved: response stripped (stale), approval-request stripped from assistant message. + // ap-2 stripped (no response). + expect(stripOrphanedToolCallMessages(msgs)).to.deep.equal([ + user(), + toolCall('id-1'), // approval-request stripped — only tool_call remains + toolResult('id-1'), + text('first done'), + user('second ask'), + ]); + }); + }); + + describe('liveToolCallIds option', () => { + it('keeps a sibling approval message when its tool is in liveToolCallIds', () => { + // tc-2 has no response yet but is actively pending — keep so da-agent sees it + const msgs = [ + user(), + approvalBatch([{ toolCallId: 'id-1' }], [{ approvalId: 'ap-1', toolCallId: 'id-1' }]), + approvalBatch([{ toolCallId: 'id-2' }], [{ approvalId: 'ap-2', toolCallId: 'id-2' }]), + approvalResponse('ap-1'), + ]; + const result = stripOrphanedToolCallMessages(msgs, { + liveToolCallIds: new Set(['id-1', 'id-2']), + }); + expect(result).to.deep.equal(msgs); + }); + + it('without liveToolCallIds: strips all approval sequences that have no tool result', () => { + // Neither id-1 nor id-2 has a tool result and neither is live → both stripped entirely. + const msgs = [ + user(), + approvalBatch([{ toolCallId: 'id-1' }], [{ approvalId: 'ap-1', toolCallId: 'id-1' }]), + approvalBatch([{ toolCallId: 'id-2' }], [{ approvalId: 'ap-2', toolCallId: 'id-2' }]), + approvalResponse('ap-1'), + ]; + const result = stripOrphanedToolCallMessages(msgs); + expect(result).to.deep.equal([user()]); + }); + + it('per-tool streaming: keeps siblings live, strips stale approval-response after resolution', () => { + // Stream C scenario: tc-1 already done (tr-1 present), tc-2 just approved (tar-resp-2), + // tc-3 still pending (APPROVAL_REQUESTED). tar-resp-1 must be stripped (stale). + // Both tc-2 and tc-3 assistant messages must be kept (live). + const msgs = [ + user(), + approvalBatch([{ toolCallId: 'id-1' }], [{ approvalId: 'ap-1', toolCallId: 'id-1' }]), + approvalBatch([{ toolCallId: 'id-2' }], [{ approvalId: 'ap-2', toolCallId: 'id-2' }]), + approvalBatch([{ toolCallId: 'id-3' }], [{ approvalId: 'ap-3', toolCallId: 'id-3' }]), + approvalResponse('ap-1'), + toolResult('id-1'), + approvalResponse('ap-2'), + ]; + const result = stripOrphanedToolCallMessages(msgs, { + liveToolCallIds: new Set(['id-2', 'id-3']), + }); + expect(result).to.deep.equal([ + user(), + toolCall('id-1'), // approval-request stripped (id-1 resolved) — only tool_call remains + approvalBatch([{ toolCallId: 'id-2' }], [{ approvalId: 'ap-2', toolCallId: 'id-2' }]), + approvalBatch([{ toolCallId: 'id-3' }], [{ approvalId: 'ap-3', toolCallId: 'id-3' }]), + toolResult('id-1'), + approvalResponse('ap-2'), + ]); + }); + }); +}); + +describe('buildUserMessage', () => { + describe('base shape', () => { + it('returns role:user with content when context and attachments are empty', () => { + const result = buildUserMessage('hello', [], []); + expect(result).to.deep.equal({ role: 'user', content: 'hello' }); + }); + }); + + describe('selectionContext', () => { + it('includes items with proseIndex', () => { + const result = buildUserMessage('hi', [{ proseIndex: 2, innerText: 'some text' }], []); + expect(result.selectionContext).to.deep.equal([{ proseIndex: 2, innerText: 'some text' }]); + }); + + it('includes items with blockName', () => { + const result = buildUserMessage('hi', [{ blockName: 'hero', innerText: 'hi' }], []); + expect(result.selectionContext).to.deep.equal([{ blockName: 'hero', innerText: 'hi' }]); + }); + + it('includes items with both proseIndex and blockName', () => { + const result = buildUserMessage('hi', [{ proseIndex: 0, blockName: 'columns', innerText: 'x' }], []); + expect(result.selectionContext).to.deep.equal([{ proseIndex: 0, blockName: 'columns', innerText: 'x' }]); + }); + + it('omits innerText when not present', () => { + const result = buildUserMessage('hi', [{ proseIndex: 1 }], []); + expect(result.selectionContext).to.deep.equal([{ proseIndex: 1 }]); + }); + + it('filters out items with neither proseIndex nor blockName', () => { + const context = [ + { innerText: 'no index or name' }, + { proseIndex: 3, innerText: 'valid' }, + ]; + const result = buildUserMessage('hi', context, []); + expect(result.selectionContext).to.deep.equal([{ proseIndex: 3, innerText: 'valid' }]); + }); + + it('omits selectionContext entirely when all items are filtered out', () => { + const result = buildUserMessage('hi', [{ innerText: 'no index or name' }], []); + expect(result).to.not.have.property('selectionContext'); + }); + + it('treats proseIndex: 0 as valid (falsy but is a number)', () => { + const result = buildUserMessage('hi', [{ proseIndex: 0 }], []); + expect(result.selectionContext).to.deep.equal([{ proseIndex: 0 }]); + }); + }); + + describe('attachmentsMeta', () => { + it('maps attachments to id, fileName, mediaType, sizeBytes', () => { + const attachments = [{ id: 'a1', fileName: 'img.png', mediaType: 'image/png', sizeBytes: 1024, dataBase64: 'abc' }]; + const result = buildUserMessage('hi', [], attachments); + expect(result.attachmentsMeta).to.deep.equal([ + { id: 'a1', fileName: 'img.png', mediaType: 'image/png', sizeBytes: 1024 }, + ]); + }); + + it('omits sizeBytes when undefined', () => { + const attachments = [{ id: 'a1', fileName: 'doc.pdf', mediaType: 'application/pdf' }]; + const result = buildUserMessage('hi', [], attachments); + expect(result.attachmentsMeta[0]).to.not.have.property('sizeBytes'); + }); + + it('keeps sizeBytes when 0', () => { + const attachments = [{ id: 'a1', fileName: 'empty.txt', mediaType: 'text/plain', sizeBytes: 0 }]; + const result = buildUserMessage('hi', [], attachments); + expect(result.attachmentsMeta[0].sizeBytes).to.equal(0); + }); + + it('strips extra fields like dataBase64 and contentUrl', () => { + const attachments = [{ id: 'a1', fileName: 'f.png', mediaType: 'image/png', dataBase64: 'xyz', contentUrl: 'https://...' }]; + const result = buildUserMessage('hi', [], attachments); + const meta = result.attachmentsMeta[0]; + expect(meta).to.not.have.property('dataBase64'); + expect(meta).to.not.have.property('contentUrl'); + }); + }); +}); diff --git a/test/nx2/blocks/chat/utils/stream.test.js b/test/nx2/blocks/chat/utils/stream.test.js new file mode 100644 index 000000000..6e5e9137a --- /dev/null +++ b/test/nx2/blocks/chat/utils/stream.test.js @@ -0,0 +1,47 @@ +import { expect } from '@esm-bundle/chai'; +import { readStream } from '../../../../../nx2/blocks/chat/utils/stream.js'; + +async function* makeBody(...chunks) { + const enc = new TextEncoder(); + for (const chunk of chunks) { + yield enc.encode(chunk); + } +} + +describe('readStream', () => { + it('reassembles a JSON event split across two chunks', async () => { + // The buffer management splits on \n and holds the tail — a line broken + // at a chunk boundary must be completed by the next chunk before parsing. + const body = makeBody( + 'data: {"type":"text-delta","delta":"hel', + 'lo"}\n\n', + ); + const deltas = []; + await readStream(body, { onDelta: (t) => deltas.push(t) }); + expect(deltas).to.deep.equal(['hello']); + }); + + it('does not process events from chunks that arrive after a finish event', async () => { + // Once finished=true the outer for-await breaks on its next iteration, + // so a delta in a subsequent chunk must never reach onDelta. + const body = makeBody( + 'data: {"type":"finish","finishReason":"stop"}\n\n', + 'data: {"type":"text-delta","delta":"ghost"}\n\n', + ); + const deltas = []; + await readStream(body, { onDelta: (t) => deltas.push(t) }); + expect(deltas).to.have.lengthOf(0); + }); + + it('flushes uncommitted streaming text via onText when the stream ends without TEXT_END', async () => { + // If the connection drops after text-delta events but before text-end, + // readStream must still commit what it accumulated rather than silently dropping it. + const body = makeBody('data: {"type":"text-delta","delta":"partial"}\n\n'); + let committed = null; + await readStream(body, { + onDelta: () => {}, + onText: (t) => { committed = t; }, + }); + expect(committed).to.equal('partial'); + }); +}); diff --git a/test/nx2/blocks/chat/utils/tools.test.js b/test/nx2/blocks/chat/utils/tools.test.js new file mode 100644 index 000000000..ccc3a7899 --- /dev/null +++ b/test/nx2/blocks/chat/utils/tools.test.js @@ -0,0 +1,114 @@ +import { expect } from '@esm-bundle/chai'; +import { affectedFolders } from '../../../../../nx2/blocks/chat/utils/tools.js'; + +const ORG = 'adobe'; +const REPO = 'mysite'; +const base = { org: ORG, repo: REPO }; + +describe('affectedFolders', () => { + describe('guard — missing org/repo', () => { + it('returns [] when input is null', () => { + expect(affectedFolders('content_create', null)).to.deep.equal([]); + }); + + it('returns [] when input is undefined', () => { + expect(affectedFolders('content_create', undefined)).to.deep.equal([]); + }); + + it('returns [] when org is missing', () => { + expect(affectedFolders('content_create', { repo: REPO, path: '/a/b.md' })).to.deep.equal([]); + }); + + it('returns [] when repo is missing', () => { + expect(affectedFolders('content_create', { org: ORG, path: '/a/b.md' })).to.deep.equal([]); + }); + }); + + describe('toParent — path resolution', () => { + it('returns the immediate parent of a deep path', () => { + const result = affectedFolders('content_create', { ...base, path: '/folder/sub/file.md' }); + expect(result).to.deep.equal([`/${ORG}/${REPO}/folder/sub`]); + }); + + it('returns /org/repo for a file at the repo root', () => { + const result = affectedFolders('content_create', { ...base, path: '/file.md' }); + expect(result).to.deep.equal([`/${ORG}/${REPO}`]); + }); + + it('handles paths without a leading slash', () => { + const result = affectedFolders('content_create', { ...base, path: 'folder/file.md' }); + expect(result).to.deep.equal([`/${ORG}/${REPO}/folder`]); + }); + + it('returns [] when path is absent', () => { + expect(affectedFolders('content_create', { ...base })).to.deep.equal([]); + }); + }); + + describe('content_move', () => { + it('returns both source and destination parent folders', () => { + const input = { + ...base, + sourcePath: '/src/file.md', + destinationPath: '/dst/file.md', + }; + const result = affectedFolders('content_move', input); + expect(result).to.deep.equal([`/${ORG}/${REPO}/src`, `/${ORG}/${REPO}/dst`]); + }); + + it('deduplicates when source and destination are in the same folder', () => { + const input = { + ...base, + sourcePath: '/shared/a.md', + destinationPath: '/shared/b.md', + }; + const result = affectedFolders('content_move', input); + expect(result).to.deep.equal([`/${ORG}/${REPO}/shared`]); + }); + + it('returns single entry when both paths are at repo root', () => { + const input = { + ...base, + sourcePath: '/a.md', + destinationPath: '/b.md', + }; + const result = affectedFolders('content_move', input); + expect(result).to.deep.equal([`/${ORG}/${REPO}`]); + }); + }); + + describe('content_copy', () => { + it('returns only the destination parent', () => { + const input = { + ...base, + sourcePath: '/src/file.md', + destinationPath: '/dst/sub/file.md', + }; + const result = affectedFolders('content_copy', input); + expect(result).to.deep.equal([`/${ORG}/${REPO}/dst/sub`]); + }); + + it('does not include the source parent', () => { + const input = { + ...base, + sourcePath: '/original/file.md', + destinationPath: '/copy/file.md', + }; + const result = affectedFolders('content_copy', input); + expect(result).to.not.include(`/${ORG}/${REPO}/original`); + }); + }); + + describe('other tools (content_create, content_delete, content_update, content_upload)', () => { + for (const toolName of ['content_create', 'content_delete', 'content_update', 'content_upload']) { + it(`${toolName} — returns parent of input.path`, () => { + const result = affectedFolders(toolName, { ...base, path: '/docs/page.md' }); + expect(result).to.deep.equal([`/${ORG}/${REPO}/docs`]); + }); + } + + it('returns [] when path is absent', () => { + expect(affectedFolders('content_delete', { ...base })).to.deep.equal([]); + }); + }); +});