@machina.ai/cell-cli 1.41.1-rc1 → 1.45.1-rc1

package/dist/src/nonInteractiveCli.test.js

@@ -3,7 +3,7 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { ToolErrorType, GeminiEventType, OutputFormat, uiTelemetryService, FatalInputError, CoreEvent, CoreToolCallStatus, } from '@google/gemini-cli-core';
+import { ToolErrorType, GeminiEventType, OutputFormat, uiTelemetryService, FatalInputError, CoreEvent, CoreToolCallStatus, JsonStreamEventType, } from '@google/gemini-cli-core';
 import { runNonInteractive } from './nonInteractiveCli.js';
 import { describe, it, expect, beforeEach, afterEach, vi, } from 'vitest';
 // Mock core modules
@@ -193,7 +193,7 @@ describe('runNonInteractive', () => {
             input: 'Test input',
             prompt_id: 'prompt-id-1',
         });
-        expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledWith([{ text: 'Test input' }], expect.any(AbortSignal), 'prompt-id-1', undefined, false, 'Test input');
+        expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledWith([{ text: 'Test input' }], expect.any(AbortSignal), 'prompt-id-1', undefined, 'Test input');
         expect(getWrittenOutput()).toBe('Hello World\n');
         // Note: Telemetry shutdown is now handled in runExitCleanup() in cleanup.ts
         // so we no longer expect shutdownTelemetry to be called directly here
@@ -286,7 +286,7 @@ describe('runNonInteractive', () => {
         });
         expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledTimes(2);
         expect(mockSchedulerSchedule).toHaveBeenCalledWith([expect.objectContaining({ name: 'testTool' })], expect.any(AbortSignal));
-        expect(mockGeminiClient.sendMessageStream).toHaveBeenNthCalledWith(2, [{ text: 'Tool response' }], expect.any(AbortSignal), 'prompt-id-2', undefined, false, undefined);
+        expect(mockGeminiClient.sendMessageStream).toHaveBeenNthCalledWith(2, [{ text: 'Tool response' }], expect.any(AbortSignal), 'prompt-id-2', undefined, undefined);
         expect(getWrittenOutput()).toBe('Final answer\n');
     });
     it('should write a single newline between sequential text outputs from the model', async () => {
@@ -425,7 +425,7 @@ describe('runNonInteractive', () => {
                     },
                 },
             },
-        ], expect.any(AbortSignal), 'prompt-id-3', undefined, false, undefined);
+        ], expect.any(AbortSignal), 'prompt-id-3', undefined, undefined);
         expect(getWrittenOutput()).toBe('Sorry, let me try again.\n');
     });
     it('should exit with error if sendMessageStream throws initially', async () => {
@@ -537,7 +537,7 @@ describe('runNonInteractive', () => {
             prompt_id: 'prompt-id-7',
         });
         // 5. Assert that sendMessageStream was called with the PROCESSED parts, not the raw input
-        expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledWith(processedParts, expect.any(AbortSignal), 'prompt-id-7', undefined, false, rawInput);
+        expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledWith(processedParts, expect.any(AbortSignal), 'prompt-id-7', undefined, rawInput);
         // 6. Assert the final output is correct
         expect(getWrittenOutput()).toBe('Summary complete.\n');
     });
@@ -551,14 +551,14 @@ describe('runNonInteractive', () => {
         ];
         mockGeminiClient.sendMessageStream.mockReturnValue(createStreamFromEvents(events));
         vi.mocked(mockConfig.getOutputFormat).mockReturnValue(OutputFormat.JSON);
-        vi.mocked(uiTelemetryService.getMetrics).mockReturnValue(MOCK_SESSION_METRICS);
+        vi.spyOn(uiTelemetryService, 'getMetrics').mockReturnValue(MOCK_SESSION_METRICS);
         await runNonInteractive({
             config: mockConfig,
             settings: mockSettings,
             input: 'Test input',
             prompt_id: 'prompt-id-1',
         });
-        expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledWith([{ text: 'Test input' }], expect.any(AbortSignal), 'prompt-id-1', undefined, false, 'Test input');
+        expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledWith([{ text: 'Test input' }], expect.any(AbortSignal), 'prompt-id-1', undefined, 'Test input');
         expect(processStdoutSpy).toHaveBeenCalledWith(JSON.stringify({
             session_id: 'test-session-id',
             response: 'Hello World',
@@ -619,7 +619,7 @@ describe('runNonInteractive', () => {
             .mockReturnValueOnce(createStreamFromEvents(firstCallEvents))
             .mockReturnValueOnce(createStreamFromEvents(secondCallEvents));
         vi.mocked(mockConfig.getOutputFormat).mockReturnValue(OutputFormat.JSON);
-        vi.mocked(uiTelemetryService.getMetrics).mockReturnValue(MOCK_SESSION_METRICS);
+        vi.spyOn(uiTelemetryService, 'getMetrics').mockReturnValue(MOCK_SESSION_METRICS);
         await runNonInteractive({
             config: mockConfig,
             settings: mockSettings,
@@ -645,14 +645,14 @@ describe('runNonInteractive', () => {
         ];
         mockGeminiClient.sendMessageStream.mockReturnValue(createStreamFromEvents(events));
         vi.mocked(mockConfig.getOutputFormat).mockReturnValue(OutputFormat.JSON);
-        vi.mocked(uiTelemetryService.getMetrics).mockReturnValue(MOCK_SESSION_METRICS);
+        vi.spyOn(uiTelemetryService, 'getMetrics').mockReturnValue(MOCK_SESSION_METRICS);
         await runNonInteractive({
             config: mockConfig,
             settings: mockSettings,
             input: 'Empty response test',
             prompt_id: 'prompt-id-empty',
         });
-        expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledWith([{ text: 'Empty response test' }], expect.any(AbortSignal), 'prompt-id-empty', undefined, false, 'Empty response test');
+        expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledWith([{ text: 'Empty response test' }], expect.any(AbortSignal), 'prompt-id-empty', undefined, 'Empty response test');
         // This should output JSON with empty response but include stats
         expect(processStdoutSpy).toHaveBeenCalledWith(JSON.stringify({
             session_id: 'test-session-id',
@@ -747,7 +747,7 @@ describe('runNonInteractive', () => {
             prompt_id: 'prompt-id-slash',
         });
         // Ensure the prompt sent to the model is from the command, not the raw input
-        expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledWith([{ text: 'Prompt from command' }], expect.any(AbortSignal), 'prompt-id-slash', undefined, false, '/testcommand');
+        expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledWith([{ text: 'Prompt from command' }], expect.any(AbortSignal), 'prompt-id-slash', undefined, '/testcommand');
         expect(getWrittenOutput()).toBe('Response from command\n');
     });
     it('should handle slash commands', async () => {
@@ -769,7 +769,7 @@ describe('runNonInteractive', () => {
             prompt_id: 'prompt-id-slash',
         });
         expect(handleSlashCommandSpy).toHaveBeenCalledWith('/help', expect.any(AbortController), mockConfig, mockSettings);
-        expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledWith([{ text: 'Slash command output' }], expect.any(AbortSignal), 'prompt-id-slash', undefined, false, '/help');
+        expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledWith([{ text: 'Slash command output' }], expect.any(AbortSignal), 'prompt-id-slash', undefined, '/help');
         expect(getWrittenOutput()).toBe('Response to slash command\n');
         handleSlashCommandSpy.mockRestore();
     });
@@ -901,7 +901,7 @@ describe('runNonInteractive', () => {
             prompt_id: 'prompt-id-unknown',
         });
         // Ensure the raw input is sent to the model
-        expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledWith([{ text: '/unknowncommand' }], expect.any(AbortSignal), 'prompt-id-unknown', undefined, false, '/unknowncommand');
+        expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledWith([{ text: '/unknowncommand' }], expect.any(AbortSignal), 'prompt-id-unknown', undefined, '/unknowncommand');
         expect(getWrittenOutput()).toBe('Response to unknown\n');
     });
     it('should throw for unhandled command result types', async () => {
@@ -1138,7 +1138,7 @@ describe('runNonInteractive', () => {
     });
     it('should emit appropriate events for streaming JSON output', async () => {
         vi.mocked(mockConfig.getOutputFormat).mockReturnValue(OutputFormat.STREAM_JSON);
-        vi.mocked(uiTelemetryService.getMetrics).mockReturnValue(MOCK_SESSION_METRICS);
+        vi.spyOn(uiTelemetryService, 'getMetrics').mockReturnValue(MOCK_SESSION_METRICS);
         const toolCallEvent = {
             type: GeminiEventType.ToolCallRequest,
             value: {
@@ -1265,7 +1265,7 @@ describe('runNonInteractive', () => {
         },
     ])('should emit appropriate error event in streaming JSON mode: $name', async ({ events, input, promptId }) => {
         vi.mocked(mockConfig.getOutputFormat).mockReturnValue(OutputFormat.STREAM_JSON);
-        vi.mocked(uiTelemetryService.getMetrics).mockReturnValue(MOCK_SESSION_METRICS);
+        vi.spyOn(uiTelemetryService, 'getMetrics').mockReturnValue(MOCK_SESSION_METRICS);
         const streamEvents = [
             ...events,
             {
@@ -1291,6 +1291,42 @@ describe('runNonInteractive', () => {
             .replace(/"duration_ms":\d+/g, '"duration_ms":<DURATION>');
         expect(sanitizedOutput).toMatchSnapshot();
     });
+    it.each([
+        {
+            name: 'loop detected',
+            events: [
+                { type: GeminiEventType.LoopDetected },
+            ],
+            expectedWarning: 'Loop detected, stopping execution',
+        },
+        {
+            name: 'max session turns',
+            events: [
+                { type: GeminiEventType.MaxSessionTurns },
+            ],
+            expectedWarning: 'Maximum session turns exceeded',
+        },
+    ])('should include warning in JSON mode for: $name', async ({ events, expectedWarning }) => {
+        vi.mocked(mockConfig.getOutputFormat).mockReturnValue(OutputFormat.JSON);
+        vi.spyOn(uiTelemetryService, 'getMetrics').mockReturnValue(MOCK_SESSION_METRICS);
+        const streamEvents = [
+            ...events,
+            {
+                type: GeminiEventType.Finished,
+                value: { reason: undefined, usageMetadata: { totalTokenCount: 0 } },
+            },
+        ];
+        mockGeminiClient.sendMessageStream.mockReturnValue(createStreamFromEvents(streamEvents));
+        await runNonInteractive({
+            config: mockConfig,
+            settings: mockSettings,
+            input: 'test',
+            prompt_id: 'test',
+        });
+        const output = JSON.parse(getWrittenOutput());
+        expect(output.warnings).toBeDefined();
+        expect(output.warnings).toContain(expectedWarning);
+    });
     it('should log error when tool recording fails', async () => {
         const toolCallEvent = {
             type: GeminiEventType.ToolCallRequest,
@@ -1410,7 +1446,7 @@ describe('runNonInteractive', () => {
     });
     it('should write JSON output when a tool call returns STOP_EXECUTION error', async () => {
         vi.mocked(mockConfig.getOutputFormat).mockReturnValue(OutputFormat.JSON);
-        vi.mocked(uiTelemetryService.getMetrics).mockReturnValue(MOCK_SESSION_METRICS);
+        vi.spyOn(uiTelemetryService, 'getMetrics').mockReturnValue(MOCK_SESSION_METRICS);
         const toolCallEvent = {
             type: GeminiEventType.ToolCallRequest,
             value: {
@@ -1455,7 +1491,7 @@ describe('runNonInteractive', () => {
     });
     it('should emit result event when a tool call returns STOP_EXECUTION error in streaming JSON mode', async () => {
         vi.mocked(mockConfig.getOutputFormat).mockReturnValue(OutputFormat.STREAM_JSON);
-        vi.mocked(uiTelemetryService.getMetrics).mockReturnValue(MOCK_SESSION_METRICS);
+        vi.spyOn(uiTelemetryService, 'getMetrics').mockReturnValue(MOCK_SESSION_METRICS);
         const toolCallEvent = {
             type: GeminiEventType.ToolCallRequest,
             value: {
@@ -1512,6 +1548,51 @@ describe('runNonInteractive', () => {
             // Should exit without calling sendMessageStream again
             expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledTimes(1);
         });
+        it('should write JSON output when AgentExecutionStopped event occurs', async () => {
+            vi.mocked(mockConfig.getOutputFormat).mockReturnValue(OutputFormat.JSON);
+            vi.spyOn(uiTelemetryService, 'getMetrics').mockReturnValue(MOCK_SESSION_METRICS);
+            const events = [
+                { type: GeminiEventType.Content, value: 'Partial content' },
+                {
+                    type: GeminiEventType.AgentExecutionStopped,
+                    value: { reason: 'Stopped by hook' },
+                },
+            ];
+            mockGeminiClient.sendMessageStream.mockReturnValue(createStreamFromEvents(events));
+            await runNonInteractive({
+                config: mockConfig,
+                settings: mockSettings,
+                input: 'test stop',
+                prompt_id: 'prompt-id-stop-json',
+            });
+            expect(processStdoutSpy).toHaveBeenCalledWith(JSON.stringify({
+                session_id: 'test-session-id',
+                response: 'Partial content',
+                stats: MOCK_SESSION_METRICS,
+                warnings: ['Agent execution stopped: Stopped by hook'],
+            }, null, 2));
+        });
+        it('should emit result event when AgentExecutionStopped event occurs in streaming JSON mode', async () => {
+            vi.mocked(mockConfig.getOutputFormat).mockReturnValue(OutputFormat.STREAM_JSON);
+            vi.spyOn(uiTelemetryService, 'getMetrics').mockReturnValue(MOCK_SESSION_METRICS);
+            const events = [
+                { type: GeminiEventType.Content, value: 'Partial content' },
+                {
+                    type: GeminiEventType.AgentExecutionStopped,
+                    value: { reason: 'Stopped by hook' },
+                },
+            ];
+            mockGeminiClient.sendMessageStream.mockReturnValue(createStreamFromEvents(events));
+            await runNonInteractive({
+                config: mockConfig,
+                settings: mockSettings,
+                input: 'test stop',
+                prompt_id: 'prompt-id-stop-stream',
+            });
+            const output = getWrittenOutput();
+            expect(output).toContain('"type":"result"');
+            expect(output).toContain('"status":"success"');
+        });
         it('should handle AgentExecutionBlocked event', async () => {
             const allEvents = [
                 {
@@ -1536,6 +1617,160 @@ describe('runNonInteractive', () => {
             expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledTimes(1);
             expect(getWrittenOutput()).toBe('Final answer\n');
         });
+        it('should emit ERROR event in STREAM_JSON mode when AgentExecutionBlocked occurs', async () => {
+            const allEvents = [
+                {
+                    type: GeminiEventType.AgentExecutionBlocked,
+                    value: { reason: 'Blocked by hook' },
+                },
+                { type: GeminiEventType.Content, value: 'Final answer' },
+                {
+                    type: GeminiEventType.Finished,
+                    value: { reason: undefined, usageMetadata: { totalTokenCount: 10 } },
+                },
+            ];
+            mockGeminiClient.sendMessageStream.mockReturnValue(createStreamFromEvents(allEvents));
+            vi.spyOn(uiTelemetryService, 'getMetrics').mockReturnValue(MOCK_SESSION_METRICS);
+            // Setup stream-json format
+            vi.mocked(mockConfig.getOutputFormat).mockReturnValue(OutputFormat.STREAM_JSON);
+            await runNonInteractive({
+                config: mockConfig,
+                settings: mockSettings,
+                input: 'test block',
+                prompt_id: 'prompt-id-block',
+            });
+            const calls = processStdoutSpy.mock.calls.map((call) => JSON.parse(call[0]));
+            const errorEvent = calls.find((c) => c.type === JsonStreamEventType.ERROR);
+            expect(errorEvent).toBeDefined();
+            expect(errorEvent.message).toContain('Agent execution blocked: Blocked by hook');
+            expect(errorEvent.severity).toBe('warning');
+        });
+        it('should include warning in JSON mode when AgentExecutionBlocked occurs', async () => {
+            const allEvents = [
+                {
+                    type: GeminiEventType.AgentExecutionBlocked,
+                    value: { reason: 'Blocked by hook' },
+                },
+                { type: GeminiEventType.Content, value: 'Final answer' },
+                {
+                    type: GeminiEventType.Finished,
+                    value: { reason: undefined, usageMetadata: { totalTokenCount: 10 } },
+                },
+            ];
+            mockGeminiClient.sendMessageStream.mockReturnValue(createStreamFromEvents(allEvents));
+            vi.mocked(mockConfig.getOutputFormat).mockReturnValue(OutputFormat.JSON);
+            await runNonInteractive({
+                config: mockConfig,
+                settings: mockSettings,
+                input: 'test block',
+                prompt_id: 'prompt-id-block',
+            });
+            const output = JSON.parse(getWrittenOutput());
+            expect(output.warnings).toBeDefined();
+            expect(output.warnings).toContain('Agent execution blocked: Blocked by hook');
+        });
+        it('should handle multiple AgentExecutionBlocked events and collect all warnings', async () => {
+            const allEvents = [
+                {
+                    type: GeminiEventType.AgentExecutionBlocked,
+                    value: { reason: 'Block 1', systemMessage: 'Reason 1' },
+                },
+                {
+                    type: GeminiEventType.AgentExecutionBlocked,
+                    value: { reason: 'Block 2', systemMessage: 'Reason 2' },
+                },
+                { type: GeminiEventType.Content, value: 'Final answer' },
+                {
+                    type: GeminiEventType.Finished,
+                    value: { reason: undefined, usageMetadata: { totalTokenCount: 10 } },
+                },
+            ];
+            mockGeminiClient.sendMessageStream.mockImplementation(() => createStreamFromEvents(allEvents));
+            vi.spyOn(uiTelemetryService, 'getMetrics').mockReturnValue(MOCK_SESSION_METRICS);
+            vi.mocked(mockConfig.getOutputFormat).mockReturnValue(OutputFormat.JSON);
+            await runNonInteractive({
+                config: mockConfig,
+                settings: mockSettings,
+                input: 'test',
+                prompt_id: 'test',
+            });
+            const output = JSON.parse(getWrittenOutput());
+            expect(output.warnings).toHaveLength(2);
+            expect(output.warnings).toContain('Agent execution blocked: Reason 1');
+            expect(output.warnings).toContain('Agent execution blocked: Reason 2');
+        });
+        it('should not include warnings field in JSON output if no blocks occur', async () => {
+            const allEvents = [
+                { type: GeminiEventType.Content, value: 'Clean answer' },
+                {
+                    type: GeminiEventType.Finished,
+                    value: { reason: undefined, usageMetadata: { totalTokenCount: 10 } },
+                },
+            ];
+            mockGeminiClient.sendMessageStream.mockImplementation(() => createStreamFromEvents(allEvents));
+            vi.spyOn(uiTelemetryService, 'getMetrics').mockReturnValue(MOCK_SESSION_METRICS);
+            vi.mocked(mockConfig.getOutputFormat).mockReturnValue(OutputFormat.JSON);
+            await runNonInteractive({
+                config: mockConfig,
+                settings: mockSettings,
+                input: 'test',
+                prompt_id: 'test',
+            });
+            const output = JSON.parse(getWrittenOutput());
+            expect(output.warnings).toBeUndefined();
+        });
+        it('should handle InvalidStream event gracefully in TEXT mode', async () => {
+            const events = [
+                { type: GeminiEventType.InvalidStream },
+            ];
+            mockGeminiClient.sendMessageStream.mockReturnValue(createStreamFromEvents(events));
+            await runNonInteractive({
+                config: mockConfig,
+                settings: mockSettings,
+                input: 'test invalid stream',
+                prompt_id: 'prompt-id-invalid',
+            });
+            expect(processStderrSpy).toHaveBeenCalledWith('[ERROR] Invalid stream: The model returned an empty response or malformed tool call.\n');
+            expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledTimes(1);
+        });
+        it('should handle InvalidStream event gracefully in STREAM_JSON mode', async () => {
+            vi.spyOn(uiTelemetryService, 'getMetrics').mockReturnValue(MOCK_SESSION_METRICS);
+            vi.spyOn(mockConfig, 'getOutputFormat').mockReturnValue(OutputFormat.STREAM_JSON);
+            const events = [
+                { type: GeminiEventType.InvalidStream },
+            ];
+            mockGeminiClient.sendMessageStream.mockReturnValue(createStreamFromEvents(events));
+            await runNonInteractive({
+                config: mockConfig,
+                settings: mockSettings,
+                input: 'test invalid stream',
+                prompt_id: 'prompt-id-invalid',
+            });
+            const output = getWrittenOutput();
+            expect(output).toContain('"type":"error"');
+            expect(output).toContain('"severity":"error"');
+            expect(output).toContain('Invalid stream: The model returned an empty response or malformed tool call.');
+            expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledTimes(1);
+        });
+        it('should handle InvalidStream event gracefully in JSON mode', async () => {
+            vi.spyOn(uiTelemetryService, 'getMetrics').mockReturnValue(MOCK_SESSION_METRICS);
+            vi.spyOn(mockConfig, 'getOutputFormat').mockReturnValue(OutputFormat.JSON);
+            const events = [
+                { type: GeminiEventType.InvalidStream },
+            ];
+            mockGeminiClient.sendMessageStream.mockReturnValue(createStreamFromEvents(events));
+            await runNonInteractive({
+                config: mockConfig,
+                settings: mockSettings,
+                input: 'test invalid stream',
+                prompt_id: 'prompt-id-invalid',
+            });
+            const output = getWrittenOutput();
+            expect(output).toContain('"error": {');
+            expect(output).toContain('"type": "INVALID_STREAM"');
+            expect(output).toContain('Invalid stream: The model returned an empty response or malformed tool call.');
+            expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledTimes(1);
+        });
     });
     describe('Output Sanitization', () => {
         const ANSI_SEQUENCE = '\u001B[31mRed Text\u001B[0m';
@@ -1672,7 +1907,7 @@ describe('runNonInteractive', () => {
             ];
             mockGeminiClient.sendMessageStream.mockReturnValue(createStreamFromEvents(events));
             vi.mocked(mockConfig.getOutputFormat).mockReturnValue(OutputFormat.STREAM_JSON);
-            vi.mocked(uiTelemetryService.getMetrics).mockReturnValue(MOCK_SESSION_METRICS);
+            vi.spyOn(uiTelemetryService, 'getMetrics').mockReturnValue(MOCK_SESSION_METRICS);
             await runNonInteractive({
                 config: mockConfig,
                 settings: mockSettings,