@google/gemini-cli-core 0.42.0 → 0.43.0-preview.1

package/dist/src/agents/local-subagent-protocol.test.js

@@ -0,0 +1,676 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { LocalSubagentSession } from './local-subagent-protocol.js';
+import { LocalAgentExecutor } from './local-executor.js';
+import { AgentTerminateMode, } from './types.js';
+import { makeFakeConfig } from '../test-utils/config.js';
+import { createMockMessageBus } from '../test-utils/mock-message-bus.js';
+vi.mock('./local-executor.js');
+const MockLocalAgentExecutor = vi.mocked(LocalAgentExecutor);
+// Captures the onActivity callback passed to LocalAgentExecutor.create().
+// Set via create.mockImplementation in beforeEach to avoid mock.calls index fragility.
+let capturedOnActivity;
+const testDefinition = {
+    kind: 'local',
+    name: 'TestProtocolAgent',
+    description: 'A test agent for protocol tests.',
+    inputConfig: {
+        inputSchema: {
+            type: 'object',
+            properties: {
+                task: { type: 'string' },
+                priority: { type: 'number' },
+            },
+        },
+    },
+    modelConfig: { model: 'test', generateContentConfig: {} },
+    runConfig: { maxTimeMinutes: 1 },
+    promptConfig: { systemPrompt: 'test' },
+};
+const GOAL_OUTPUT = {
+    result: 'Analysis complete.',
+    terminate_reason: AgentTerminateMode.GOAL,
+};
+describe('LocalSubagentSession (protocol)', () => {
+    let mockContext;
+    let mockMessageBus;
+    let mockExecutorInstance;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        capturedOnActivity = undefined;
+        mockContext = makeFakeConfig();
+        mockMessageBus = createMockMessageBus();
+        mockExecutorInstance = {
+            run: vi.fn().mockResolvedValue(GOAL_OUTPUT),
+            definition: testDefinition,
+        };
+        // Use mockImplementation (not mockResolvedValue) so we can capture onActivity.
+        MockLocalAgentExecutor.create.mockImplementation(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        async (_def, _ctx, onActivity) => {
+            capturedOnActivity = onActivity;
+            return mockExecutorInstance;
+        });
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    // ---------------------------------------------------------------------------
+    // Lifecycle events
+    // ---------------------------------------------------------------------------
+    describe('lifecycle events', () => {
+        it('emits agent_start then agent_end(completed) for a GOAL run', async () => {
+            const session = new LocalSubagentSession(testDefinition, mockContext, mockMessageBus);
+            const events = [];
+            session.subscribe((e) => events.push(e));
+            await session.send({
+                message: { content: [{ type: 'text', text: 'query' }] },
+            });
+            await session.getResult();
+            expect(events[0].type).toBe('agent_start');
+            expect(events[events.length - 1].type).toBe('agent_end');
+            const endEvent = events[events.length - 1];
+            if (endEvent.type === 'agent_end') {
+                expect(endEvent.reason).toBe('completed');
+            }
+        });
+        it('emits agent_start exactly once even if ensureAgentStart called twice internally', async () => {
+            const session = new LocalSubagentSession(testDefinition, mockContext, mockMessageBus);
+            const events = [];
+            session.subscribe((e) => events.push(e));
+            await session.send({
+                message: { content: [{ type: 'text', text: 'query' }] },
+            });
+            await session.getResult();
+            const startEvents = events.filter((e) => e.type === 'agent_start');
+            expect(startEvents).toHaveLength(1);
+        });
+        it('emits agent_end exactly once on error path', async () => {
+            const session = new LocalSubagentSession(testDefinition, mockContext, mockMessageBus);
+            mockExecutorInstance.run.mockRejectedValue(new Error('executor failed'));
+            const events = [];
+            session.subscribe((e) => events.push(e));
+            await session.send({
+                message: { content: [{ type: 'text', text: 'query' }] },
+            });
+            await expect(session.getResult()).rejects.toThrow('executor failed');
+            const endEvents = events.filter((e) => e.type === 'agent_end');
+            expect(endEvents).toHaveLength(1);
+        });
+        it('all events share the same streamId', async () => {
+            const session = new LocalSubagentSession(testDefinition, mockContext, mockMessageBus);
+            const events = [];
+            session.subscribe((e) => events.push(e));
+            await session.send({
+                message: { content: [{ type: 'text', text: 'query' }] },
+            });
+            await session.getResult();
+            const streamIds = new Set(events.map((e) => e.streamId));
+            expect(streamIds.size).toBe(1);
+        });
+    });
+    // ---------------------------------------------------------------------------
+    // Config buffering (update + message pattern)
+    // ---------------------------------------------------------------------------
+    describe('config buffering', () => {
+        it('merges buffered config with message query', async () => {
+            const session = new LocalSubagentSession(testDefinition, mockContext, mockMessageBus);
+            await session.send({
+                update: { config: { task: 'analyze', priority: 5 } },
+            });
+            await session.send({
+                message: { content: [{ type: 'text', text: 'my query' }] },
+            });
+            await session.getResult();
+            expect(mockExecutorInstance.run).toHaveBeenCalledWith({ task: 'analyze', priority: 5, query: 'my query' }, expect.any(AbortSignal));
+        });
+        it('omits query key when message text is empty', async () => {
+            const session = new LocalSubagentSession(testDefinition, mockContext, mockMessageBus);
+            await session.send({ update: { config: { task: 'no-query-task' } } });
+            await session.send({
+                message: { content: [{ type: 'text', text: '' }] },
+            });
+            await session.getResult();
+            const callArgs = mockExecutorInstance.run.mock.calls[0][0];
+            expect(callArgs).not.toHaveProperty('query');
+            expect(callArgs).toEqual({ task: 'no-query-task' });
+        });
+        it('sends only query when no prior update', async () => {
+            const session = new LocalSubagentSession(testDefinition, mockContext, mockMessageBus);
+            await session.send({
+                message: { content: [{ type: 'text', text: 'just a query' }] },
+            });
+            await session.getResult();
+            expect(mockExecutorInstance.run).toHaveBeenCalledWith({ query: 'just a query' }, expect.any(AbortSignal));
+        });
+        it('multiple update calls are merged', async () => {
+            const session = new LocalSubagentSession(testDefinition, mockContext, mockMessageBus);
+            await session.send({ update: { config: { field1: 'a' } } });
+            await session.send({ update: { config: { field2: 'b' } } });
+            await session.send({
+                message: { content: [{ type: 'text', text: 'q' }] },
+            });
+            await session.getResult();
+            expect(mockExecutorInstance.run).toHaveBeenCalledWith({ field1: 'a', field2: 'b', query: 'q' }, expect.any(AbortSignal));
+        });
+        it('update returns streamId: null; message returns a streamId', async () => {
+            const session = new LocalSubagentSession(testDefinition, mockContext, mockMessageBus);
+            const updateResult = await session.send({ update: { config: {} } });
+            expect(updateResult.streamId).toBeNull();
+            const messageResult = await session.send({
+                message: { content: [{ type: 'text', text: 'q' }] },
+            });
+            expect(messageResult.streamId).not.toBeNull();
+            expect(typeof messageResult.streamId).toBe('string');
+            // Await completion to prevent dangling execution affecting subsequent tests
+            await session.getResult();
+        });
+    });
+    // ---------------------------------------------------------------------------
+    // Activity translation
+    // ---------------------------------------------------------------------------
+    describe('activity translation', () => {
+        function makeSession() {
+            const activityEvents = [];
+            const session = new LocalSubagentSession(testDefinition, mockContext, mockMessageBus);
+            return { session, activityEvents };
+        }
+        async function runWithActivities(session, activities) {
+            mockExecutorInstance.run.mockImplementation(async () => {
+                // capturedOnActivity is set by the create.mockImplementation in beforeEach
+                // and updated whenever create() is called. By the time run() is called,
+                // capturedOnActivity holds the onActivity closure for the most-recently
+                // created executor — which is the one associated with this session.
+                for (const act of activities) {
+                    capturedOnActivity?.(act);
+                }
+                return GOAL_OUTPUT;
+            });
+            const events = [];
+            session.subscribe((e) => events.push(e));
+            await session.send({
+                message: { content: [{ type: 'text', text: 'q' }] },
+            });
+            await session.getResult();
+            return events;
+        }
+        it('THOUGHT_CHUNK → message event with thought content', async () => {
+            const { session } = makeSession();
+            const events = await runWithActivities(session, [
+                {
+                    isSubagentActivityEvent: true,
+                    agentName: 'TestProtocolAgent',
+                    type: 'THOUGHT_CHUNK',
+                    data: { text: 'I am thinking...' },
+                },
+            ]);
+            const msgEvent = events.find((e) => e.type === 'message');
+            expect(msgEvent).toBeDefined();
+            if (msgEvent?.type === 'message') {
+                expect(msgEvent.role).toBe('agent');
+                expect(msgEvent.content).toContainEqual({
+                    type: 'thought',
+                    thought: 'I am thinking...',
+                });
+            }
+        });
+        it('TOOL_CALL_START → tool_request event', async () => {
+            const { session } = makeSession();
+            const events = await runWithActivities(session, [
+                {
+                    isSubagentActivityEvent: true,
+                    agentName: 'TestProtocolAgent',
+                    type: 'TOOL_CALL_START',
+                    data: { callId: 'call-123', name: 'read_file', args: { path: '/a' } },
+                },
+            ]);
+            const reqEvent = events.find((e) => e.type === 'tool_request');
+            expect(reqEvent).toBeDefined();
+            if (reqEvent?.type === 'tool_request') {
+                expect(reqEvent.requestId).toBe('call-123');
+                expect(reqEvent.name).toBe('read_file');
+                expect(reqEvent.args).toEqual({ path: '/a' });
+            }
+        });
+        it('TOOL_CALL_END → tool_response event', async () => {
+            const { session } = makeSession();
+            const events = await runWithActivities(session, [
+                {
+                    isSubagentActivityEvent: true,
+                    agentName: 'TestProtocolAgent',
+                    type: 'TOOL_CALL_END',
+                    data: { id: 'call-123', name: 'read_file', output: 'file contents' },
+                },
+            ]);
+            const respEvent = events.find((e) => e.type === 'tool_response');
+            expect(respEvent).toBeDefined();
+            if (respEvent?.type === 'tool_response') {
+                expect(respEvent.requestId).toBe('call-123');
+                expect(respEvent.name).toBe('read_file');
+                expect(respEvent.content).toContainEqual({
+                    type: 'text',
+                    text: 'file contents',
+                });
+            }
+        });
+        it('ERROR activity → error event with INTERNAL status, fatal: false', async () => {
+            const { session } = makeSession();
+            const events = await runWithActivities(session, [
+                {
+                    isSubagentActivityEvent: true,
+                    agentName: 'TestProtocolAgent',
+                    type: 'ERROR',
+                    data: { error: 'something went wrong' },
+                },
+            ]);
+            const errEvent = events.find((e) => e.type === 'error');
+            expect(errEvent).toBeDefined();
+            if (errEvent?.type === 'error') {
+                expect(errEvent.status).toBe('INTERNAL');
+                expect(errEvent.message).toBe('something went wrong');
+                expect(errEvent.fatal).toBe(false);
+            }
+        });
+        it('unknown activity type → no events emitted', async () => {
+            const { session } = makeSession();
+            const events = await runWithActivities(session, [
+                {
+                    isSubagentActivityEvent: true,
+                    agentName: 'TestProtocolAgent',
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    type: 'UNKNOWN_TYPE',
+                    data: {},
+                },
+            ]);
+            // Only agent_start and agent_end should be present
+            const nonLifecycle = events.filter((e) => e.type !== 'agent_start' && e.type !== 'agent_end');
+            expect(nonLifecycle).toHaveLength(0);
+        });
+        it('TOOL_CALL_START with non-object args defaults to {}', async () => {
+            const { session } = makeSession();
+            const events = await runWithActivities(session, [
+                {
+                    isSubagentActivityEvent: true,
+                    agentName: 'TestProtocolAgent',
+                    type: 'TOOL_CALL_START',
+                    data: { callId: 'x', name: 'tool', args: null },
+                },
+            ]);
+            const reqEvent = events.find((e) => e.type === 'tool_request');
+            if (reqEvent?.type === 'tool_request') {
+                expect(reqEvent.args).toEqual({});
+            }
+        });
+    });
+    // ---------------------------------------------------------------------------
+    // getResult() promise
+    // ---------------------------------------------------------------------------
+    describe('getResult()', () => {
+        it('resolves with OutputObject on GOAL termination', async () => {
+            const session = new LocalSubagentSession(testDefinition, mockContext, mockMessageBus);
+            await session.send({
+                message: { content: [{ type: 'text', text: 'q' }] },
+            });
+            const output = await session.getResult();
+            expect(output.result).toBe('Analysis complete.');
+            expect(output.terminate_reason).toBe(AgentTerminateMode.GOAL);
+        });
+        it('rejects when executor throws', async () => {
+            const session = new LocalSubagentSession(testDefinition, mockContext, mockMessageBus);
+            mockExecutorInstance.run.mockRejectedValue(new Error('executor error'));
+            await session.send({
+                message: { content: [{ type: 'text', text: 'q' }] },
+            });
+            await expect(session.getResult()).rejects.toThrow('executor error');
+        });
+    });
+    // ---------------------------------------------------------------------------
+    // rawActivityCallback
+    // ---------------------------------------------------------------------------
+    describe('rawActivityCallback', () => {
+        it('receives raw SubagentActivityEvent before AgentEvent translation', async () => {
+            const rawActivities = [];
+            const session = new LocalSubagentSession(testDefinition, mockContext, mockMessageBus, (activity) => rawActivities.push(activity));
+            const thoughtActivity = {
+                isSubagentActivityEvent: true,
+                agentName: 'TestProtocolAgent',
+                type: 'THOUGHT_CHUNK',
+                data: { text: 'raw thought' },
+            };
+            mockExecutorInstance.run.mockImplementation(async () => {
+                const onActivity = MockLocalAgentExecutor.create.mock.calls[0]?.[2];
+                onActivity?.(thoughtActivity);
+                return GOAL_OUTPUT;
+            });
+            await session.send({
+                message: { content: [{ type: 'text', text: 'q' }] },
+            });
+            await session.getResult();
+            expect(rawActivities).toHaveLength(1);
+            expect(rawActivities[0]).toBe(thoughtActivity);
+        });
+        it('is called before AgentEvent translation (raw arrives first)', async () => {
+            const callOrder = [];
+            const session = new LocalSubagentSession(testDefinition, mockContext, mockMessageBus, () => callOrder.push('raw'));
+            session.subscribe((e) => {
+                if (e.type === 'message')
+                    callOrder.push('translated');
+            });
+            mockExecutorInstance.run.mockImplementation(async () => {
+                const onActivity = MockLocalAgentExecutor.create.mock.calls[0]?.[2];
+                onActivity?.({
+                    isSubagentActivityEvent: true,
+                    agentName: 'TestProtocolAgent',
+                    type: 'THOUGHT_CHUNK',
+                    data: { text: 'thought' },
+                });
+                return GOAL_OUTPUT;
+            });
+            await session.send({
+                message: { content: [{ type: 'text', text: 'q' }] },
+            });
+            await session.getResult();
+            expect(callOrder).toEqual(['raw', 'translated']);
+        });
+        it('is optional — no callback causes no error', async () => {
+            const session = new LocalSubagentSession(testDefinition, mockContext, mockMessageBus);
+            await session.send({
+                message: { content: [{ type: 'text', text: 'q' }] },
+            });
+            await expect(session.getResult()).resolves.toBeDefined();
+        });
+    });
+    // ---------------------------------------------------------------------------
+    // Subscription
+    // ---------------------------------------------------------------------------
+    describe('subscription', () => {
+        it('unsubscribe stops event delivery', async () => {
+            const session = new LocalSubagentSession(testDefinition, mockContext, mockMessageBus);
+            const received = [];
+            const unsub = session.subscribe((e) => received.push(e));
+            unsub();
+            await session.send({
+                message: { content: [{ type: 'text', text: 'q' }] },
+            });
+            await session.getResult();
+            expect(received).toHaveLength(0);
+        });
+        it('multiple subscribers all receive events', async () => {
+            const session = new LocalSubagentSession(testDefinition, mockContext, mockMessageBus);
+            const received1 = [];
+            const received2 = [];
+            session.subscribe((e) => received1.push(e));
+            session.subscribe((e) => received2.push(e));
+            await session.send({
+                message: { content: [{ type: 'text', text: 'q' }] },
+            });
+            await session.getResult();
+            expect(received1.length).toBeGreaterThan(0);
+            expect(received1).toEqual(received2);
+        });
+        it('events array accumulates all emitted events', async () => {
+            const session = new LocalSubagentSession(testDefinition, mockContext, mockMessageBus);
+            await session.send({
+                message: { content: [{ type: 'text', text: 'q' }] },
+            });
+            await session.getResult();
+            expect(session.events.length).toBeGreaterThanOrEqual(2); // at least agent_start + agent_end
+            expect(session.events[0].type).toBe('agent_start');
+        });
+    });
+    // ---------------------------------------------------------------------------
+    // Terminate mode mapping
+    // ---------------------------------------------------------------------------
+    describe('terminate mode → StreamEndReason mapping', () => {
+        const cases = [
+            [AgentTerminateMode.GOAL, 'completed'],
+            [AgentTerminateMode.TIMEOUT, 'max_time'],
+            [AgentTerminateMode.MAX_TURNS, 'max_turns'],
+            [AgentTerminateMode.ABORTED, 'aborted'],
+            [AgentTerminateMode.ERROR, 'failed'],
+            [AgentTerminateMode.ERROR_NO_COMPLETE_TASK_CALL, 'failed'],
+        ];
+        for (const [terminateMode, expectedReason] of cases) {
+            it(`${terminateMode} → agent_end(reason:'${expectedReason}')`, async () => {
+                mockExecutorInstance.run.mockResolvedValue({
+                    result: 'done',
+                    terminate_reason: terminateMode,
+                });
+                const session = new LocalSubagentSession(testDefinition, mockContext, mockMessageBus);
+                const events = [];
+                session.subscribe((e) => events.push(e));
+                await session.send({
+                    message: { content: [{ type: 'text', text: 'q' }] },
+                });
+                await session.getResult().catch(() => {
+                    // ABORTED results in rejection — catch to let test complete
+                });
+                const endEvent = events.find((e) => e.type === 'agent_end');
+                expect(endEvent).toBeDefined();
+                if (endEvent?.type === 'agent_end') {
+                    expect(endEvent.reason).toBe(expectedReason);
+                }
+            });
+        }
+    });
+    // ---------------------------------------------------------------------------
+    // Abort
+    // ---------------------------------------------------------------------------
+    describe('abort()', () => {
+        it('abort() causes agent_end(reason:aborted)', async () => {
+            // Make run() wait until aborted
+            let abortSignal;
+            mockExecutorInstance.run.mockImplementation((_params, signal) => {
+                abortSignal = signal;
+                return new Promise((_resolve, reject) => {
+                    signal.addEventListener('abort', () => {
+                        const err = new Error('AbortError');
+                        err.name = 'AbortError';
+                        reject(err);
+                    });
+                });
+            });
+            const session = new LocalSubagentSession(testDefinition, mockContext, mockMessageBus);
+            const events = [];
+            session.subscribe((e) => events.push(e));
+            void session.send({
+                message: { content: [{ type: 'text', text: 'q' }] },
+            });
+            // Wait for executor to be created and run started
+            await vi.waitFor(() => {
+                expect(abortSignal).toBeDefined();
+            });
+            await session.abort();
+            const result = await session.getResult();
+            expect(result.result).toBe('');
+            expect(result.terminate_reason).toBe('ABORTED');
+            const endEvent = events.find((e) => e.type === 'agent_end');
+            expect(endEvent).toBeDefined();
+            if (endEvent?.type === 'agent_end') {
+                expect(endEvent.reason).toBe('aborted');
+            }
+        });
+    });
+    // ---------------------------------------------------------------------------
+    // Full event sequence
+    // ---------------------------------------------------------------------------
+    describe('full event sequence', () => {
+        it('emits agent_start → message(thought) → tool_request → tool_response → agent_end in order', async () => {
+            const session = new LocalSubagentSession(testDefinition, mockContext, mockMessageBus);
+            mockExecutorInstance.run.mockImplementation(async () => {
+                const onActivity = MockLocalAgentExecutor.create.mock.calls[0]?.[2];
+                onActivity?.({
+                    isSubagentActivityEvent: true,
+                    agentName: 'TestProtocolAgent',
+                    type: 'THOUGHT_CHUNK',
+                    data: { text: 'thinking' },
+                });
+                onActivity?.({
+                    isSubagentActivityEvent: true,
+                    agentName: 'TestProtocolAgent',
+                    type: 'TOOL_CALL_START',
+                    data: { callId: 'c1', name: 'tool', args: {} },
+                });
+                onActivity?.({
+                    isSubagentActivityEvent: true,
+                    agentName: 'TestProtocolAgent',
+                    type: 'TOOL_CALL_END',
+                    data: { id: 'c1', name: 'tool', output: 'result' },
+                });
+                return GOAL_OUTPUT;
+            });
+            const events = [];
+            session.subscribe((e) => events.push(e));
+            await session.send({
+                message: { content: [{ type: 'text', text: 'go' }] },
+            });
+            await session.getResult();
+            const types = events.map((e) => e.type);
+            expect(types).toEqual([
+                'agent_start',
+                'message',
+                'tool_request',
+                'tool_response',
+                'agent_end',
+            ]);
+        });
+    });
+    // ---------------------------------------------------------------------------
+    // Concurrent send() guard
+    // ---------------------------------------------------------------------------
+    describe('concurrent send() guard', () => {
+        it('calling send() while a stream is active throws', async () => {
+            let abortSignal;
+            mockExecutorInstance.run.mockImplementation((_params, signal) => {
+                abortSignal = signal;
+                return new Promise((_resolve, reject) => {
+                    // Reject when aborted so getResult() can settle during cleanup
+                    signal.addEventListener('abort', () => {
+                        const err = new Error('AbortError');
+                        err.name = 'AbortError';
+                        reject(err);
+                    });
+                });
+            });
+            const session = new LocalSubagentSession(testDefinition, mockContext, mockMessageBus);
+            void session.send({
+                message: { content: [{ type: 'text', text: 'first' }] },
+            });
+            // Wait for execution to start
+            await vi.waitFor(() => {
+                expect(abortSignal).toBeDefined();
+            });
+            // Second send() while first stream is active must throw
+            await expect(session.send({
+                message: { content: [{ type: 'text', text: 'second' }] },
+            })).rejects.toThrow('cannot be called while a stream is active');
+            // Clean up: abort to unblock the hanging executor
+            await session.abort();
+            await session.getResult().catch(() => { });
+        });
+    });
+    // ---------------------------------------------------------------------------
+    // Multi-send support
+    // ---------------------------------------------------------------------------
+    describe('multi-send', () => {
+        it('supports sequential sends after stream completion', async () => {
+            const session = new LocalSubagentSession(testDefinition, mockContext, mockMessageBus);
+            // First send
+            const result1 = await session.send({
+                message: { content: [{ type: 'text', text: 'first' }] },
+            });
+            expect(result1.streamId).not.toBeNull();
+            const output1 = await session.getResult();
+            expect(output1.result).toBe('Analysis complete.');
+            // Second send — should work, not throw
+            const secondOutput = {
+                result: 'Second analysis.',
+                terminate_reason: AgentTerminateMode.GOAL,
+            };
+            mockExecutorInstance.run.mockResolvedValue(secondOutput);
+            const result2 = await session.send({
+                message: { content: [{ type: 'text', text: 'second' }] },
+            });
+            expect(result2.streamId).not.toBeNull();
+            expect(result2.streamId).not.toBe(result1.streamId);
+            const output2 = await session.getResult();
+            expect(output2.result).toBe('Second analysis.');
+        });
+        it('getResult() returns the latest stream result', async () => {
+            const session = new LocalSubagentSession(testDefinition, mockContext, mockMessageBus);
+            // First send
+            await session.send({
+                message: { content: [{ type: 'text', text: 'first' }] },
+            });
+            const result1 = await session.getResult();
+            // Second send with different output
+            const secondOutput = {
+                result: 'Different result.',
+                terminate_reason: AgentTerminateMode.GOAL,
+            };
+            mockExecutorInstance.run.mockResolvedValue(secondOutput);
+            await session.send({
+                message: { content: [{ type: 'text', text: 'second' }] },
+            });
+            const result2 = await session.getResult();
+            expect(result1.result).toBe('Analysis complete.');
+            expect(result2.result).toBe('Different result.');
+        });
+        it('buffered config does not bleed across sends', async () => {
+            const session = new LocalSubagentSession(testDefinition, mockContext, mockMessageBus);
+            // Buffer config, then send first message
+            await session.send({ update: { config: { temperature: 0.5 } } });
+            await session.send({
+                message: { content: [{ type: 'text', text: 'first' }] },
+            });
+            await session.getResult();
+            // The executor.run params include the buffered config
+            const firstRunParams = mockExecutorInstance.run.mock.calls[0]?.[0];
+            expect(firstRunParams).toHaveProperty('temperature', 0.5);
+            expect(firstRunParams).toHaveProperty('query', 'first');
+            // Second send without buffered config — temperature should be gone
+            mockExecutorInstance.run.mockResolvedValue(GOAL_OUTPUT);
+            await session.send({
+                message: { content: [{ type: 'text', text: 'second' }] },
+            });
+            await session.getResult();
+            const secondRunParams = mockExecutorInstance.run.mock.calls[1]?.[0];
+            expect(secondRunParams).not.toHaveProperty('temperature');
+            expect(secondRunParams).toHaveProperty('query', 'second');
+        });
+        it('getResult() rejects when called before any send', async () => {
+            const session = new LocalSubagentSession(testDefinition, mockContext, mockMessageBus);
+            await expect(session.getResult()).rejects.toThrow('No active or completed stream');
+        });
+        it('emits fresh agent_start/agent_end per stream', async () => {
+            const session = new LocalSubagentSession(testDefinition, mockContext, mockMessageBus);
+            const events = [];
+            session.subscribe((e) => events.push(e));
+            // First send
+            await session.send({
+                message: { content: [{ type: 'text', text: 'first' }] },
+            });
+            await session.getResult();
+            const firstStreamEvents = events.length;
+            expect(events[0]?.type).toBe('agent_start');
+            expect(events[firstStreamEvents - 1]?.type).toBe('agent_end');
+            // Second send
+            mockExecutorInstance.run.mockResolvedValue(GOAL_OUTPUT);
+            await session.send({
+                message: { content: [{ type: 'text', text: 'second' }] },
+            });
+            await session.getResult();
+            // Should have a second agent_start/agent_end pair
+            const secondStreamStart = events[firstStreamEvents];
+            const lastEvent = events[events.length - 1];
+            expect(secondStreamStart?.type).toBe('agent_start');
+            expect(lastEvent?.type).toBe('agent_end');
+            expect(secondStreamStart?.streamId).not.toBe(events[0]?.streamId);
+        });
+    });
+});
+//# sourceMappingURL=local-subagent-protocol.test.js.map