Structured JSON Output (#8119)

packages/cli/src/nonInteractiveCli.test.ts

@@ -8,12 +8,16 @@ import type {
   Config,
   ToolRegistry,
   ServerGeminiStreamEvent,
+  SessionMetrics,
 } from '@google/gemini-cli-core';
 import {
   executeToolCall,
   ToolErrorType,
   shutdownTelemetry,
   GeminiEventType,
+  OutputFormat,
+  uiTelemetryService,
+  FatalInputError,
 } from '@google/gemini-cli-core';
 import type { Part } from '@google/genai';
 import { runNonInteractive } from './nonInteractiveCli.js';
@@ -38,6 +42,9 @@ vi.mock('@google/gemini-cli-core', async (importOriginal) => {
     shutdownTelemetry: vi.fn(),
     isTelemetrySdkInitialized: vi.fn().mockReturnValue(true),
     ChatRecordingService: MockChatRecordingService,
+    uiTelemetryService: {
+      getMetrics: vi.fn(),
+    },
   };
 });
 
@@ -61,6 +68,9 @@ describe('runNonInteractive', () => {
     processStdoutSpy = vi
       .spyOn(process.stdout, 'write')
       .mockImplementation(() => true);
+    vi.spyOn(process, 'exit').mockImplementation((code) => {
+      throw new Error(`process.exit(${code}) called`);
+    });
 
     mockToolRegistry = {
       getTool: vi.fn(),
@@ -91,6 +101,7 @@ describe('runNonInteractive', () => {
       getFullContext: vi.fn().mockReturnValue(false),
       getContentGeneratorConfig: vi.fn().mockReturnValue({}),
       getDebugMode: vi.fn().mockReturnValue(false),
+      getOutputFormat: vi.fn().mockReturnValue('text'),
     } as unknown as Config;
 
     const { handleAtCommand } = await import(
@@ -312,9 +323,7 @@ describe('runNonInteractive', () => {
     vi.mocked(mockConfig.getMaxSessionTurns).mockReturnValue(0);
     await expect(
       runNonInteractive(mockConfig, 'Trigger loop', 'prompt-id-6'),
-    ).rejects.toThrow(
-      'Reached max session turns for this session. Increase the number of turns by specifying maxSessionTurns in settings.json.',
-    );
+    ).rejects.toThrow('process.exit(53) called');
   });
 
   it('should preprocess @include commands before sending to the model', async () => {
@@ -364,4 +373,274 @@ describe('runNonInteractive', () => {
     // 6. Assert the final output is correct
     expect(processStdoutSpy).toHaveBeenCalledWith('Summary complete.');
   });
+
+  it('should process input and write JSON output with stats', async () => {
+    const events: ServerGeminiStreamEvent[] = [
+      { type: GeminiEventType.Content, value: 'Hello World' },
+      {
+        type: GeminiEventType.Finished,
+        value: { reason: undefined, usageMetadata: { totalTokenCount: 10 } },
+      },
+    ];
+    mockGeminiClient.sendMessageStream.mockReturnValue(
+      createStreamFromEvents(events),
+    );
+    vi.mocked(mockConfig.getOutputFormat).mockReturnValue(OutputFormat.JSON);
+    const mockMetrics: SessionMetrics = {
+      models: {},
+      tools: {
+        totalCalls: 0,
+        totalSuccess: 0,
+        totalFail: 0,
+        totalDurationMs: 0,
+        totalDecisions: {
+          accept: 0,
+          reject: 0,
+          modify: 0,
+          auto_accept: 0,
+        },
+        byName: {},
+      },
+      files: {
+        totalLinesAdded: 0,
+        totalLinesRemoved: 0,
+      },
+    };
+    vi.mocked(uiTelemetryService.getMetrics).mockReturnValue(mockMetrics);
+
+    await runNonInteractive(mockConfig, 'Test input', 'prompt-id-1');
+
+    expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledWith(
+      [{ text: 'Test input' }],
+      expect.any(AbortSignal),
+      'prompt-id-1',
+    );
+    expect(processStdoutSpy).toHaveBeenCalledWith(
+      JSON.stringify({ response: 'Hello World', stats: mockMetrics }, null, 2),
+    );
+  });
+
+  it('should write JSON output with stats for tool-only commands (no text response)', async () => {
+    // Test the scenario where a command completes successfully with only tool calls
+    // but no text response - this would have caught the original bug
+    const toolCallEvent: ServerGeminiStreamEvent = {
+      type: GeminiEventType.ToolCallRequest,
+      value: {
+        callId: 'tool-1',
+        name: 'testTool',
+        args: { arg1: 'value1' },
+        isClientInitiated: false,
+        prompt_id: 'prompt-id-tool-only',
+      },
+    };
+    const toolResponse: Part[] = [{ text: 'Tool executed successfully' }];
+    mockCoreExecuteToolCall.mockResolvedValue({ responseParts: toolResponse });
+
+    // First call returns only tool call, no content
+    const firstCallEvents: ServerGeminiStreamEvent[] = [
+      toolCallEvent,
+      {
+        type: GeminiEventType.Finished,
+        value: { reason: undefined, usageMetadata: { totalTokenCount: 5 } },
+      },
+    ];
+
+    // Second call returns no content (tool-only completion)
+    const secondCallEvents: ServerGeminiStreamEvent[] = [
+      {
+        type: GeminiEventType.Finished,
+        value: { reason: undefined, usageMetadata: { totalTokenCount: 3 } },
+      },
+    ];
+
+    mockGeminiClient.sendMessageStream
+      .mockReturnValueOnce(createStreamFromEvents(firstCallEvents))
+      .mockReturnValueOnce(createStreamFromEvents(secondCallEvents));
+
+    vi.mocked(mockConfig.getOutputFormat).mockReturnValue(OutputFormat.JSON);
+    const mockMetrics: SessionMetrics = {
+      models: {},
+      tools: {
+        totalCalls: 1,
+        totalSuccess: 1,
+        totalFail: 0,
+        totalDurationMs: 100,
+        totalDecisions: {
+          accept: 1,
+          reject: 0,
+          modify: 0,
+          auto_accept: 0,
+        },
+        byName: {
+          testTool: {
+            count: 1,
+            success: 1,
+            fail: 0,
+            durationMs: 100,
+            decisions: {
+              accept: 1,
+              reject: 0,
+              modify: 0,
+              auto_accept: 0,
+            },
+          },
+        },
+      },
+      files: {
+        totalLinesAdded: 0,
+        totalLinesRemoved: 0,
+      },
+    };
+    vi.mocked(uiTelemetryService.getMetrics).mockReturnValue(mockMetrics);
+
+    await runNonInteractive(
+      mockConfig,
+      'Execute tool only',
+      'prompt-id-tool-only',
+    );
+
+    expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledTimes(2);
+    expect(mockCoreExecuteToolCall).toHaveBeenCalledWith(
+      mockConfig,
+      expect.objectContaining({ name: 'testTool' }),
+      expect.any(AbortSignal),
+    );
+
+    // This should output JSON with empty response but include stats
+    expect(processStdoutSpy).toHaveBeenCalledWith(
+      JSON.stringify({ response: '', stats: mockMetrics }, null, 2),
+    );
+  });
+
+  it('should write JSON output with stats for empty response commands', async () => {
+    // Test the scenario where a command completes but produces no content at all
+    const events: ServerGeminiStreamEvent[] = [
+      {
+        type: GeminiEventType.Finished,
+        value: { reason: undefined, usageMetadata: { totalTokenCount: 1 } },
+      },
+    ];
+    mockGeminiClient.sendMessageStream.mockReturnValue(
+      createStreamFromEvents(events),
+    );
+    vi.mocked(mockConfig.getOutputFormat).mockReturnValue(OutputFormat.JSON);
+    const mockMetrics: SessionMetrics = {
+      models: {},
+      tools: {
+        totalCalls: 0,
+        totalSuccess: 0,
+        totalFail: 0,
+        totalDurationMs: 0,
+        totalDecisions: {
+          accept: 0,
+          reject: 0,
+          modify: 0,
+          auto_accept: 0,
+        },
+        byName: {},
+      },
+      files: {
+        totalLinesAdded: 0,
+        totalLinesRemoved: 0,
+      },
+    };
+    vi.mocked(uiTelemetryService.getMetrics).mockReturnValue(mockMetrics);
+
+    await runNonInteractive(
+      mockConfig,
+      'Empty response test',
+      'prompt-id-empty',
+    );
+
+    expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledWith(
+      [{ text: 'Empty response test' }],
+      expect.any(AbortSignal),
+      'prompt-id-empty',
+    );
+
+    // This should output JSON with empty response but include stats
+    expect(processStdoutSpy).toHaveBeenCalledWith(
+      JSON.stringify({ response: '', stats: mockMetrics }, null, 2),
+    );
+  });
+
+  it('should handle errors in JSON format', async () => {
+    vi.mocked(mockConfig.getOutputFormat).mockReturnValue(OutputFormat.JSON);
+    const testError = new Error('Invalid input provided');
+
+    mockGeminiClient.sendMessageStream.mockImplementation(() => {
+      throw testError;
+    });
+
+    // Mock console.error to capture JSON error output
+    const consoleErrorJsonSpy = vi
+      .spyOn(console, 'error')
+      .mockImplementation(() => {});
+
+    let thrownError: Error | null = null;
+    try {
+      await runNonInteractive(mockConfig, 'Test input', 'prompt-id-error');
+      // Should not reach here
+      expect.fail('Expected process.exit to be called');
+    } catch (error) {
+      thrownError = error as Error;
+    }
+
+    // Should throw because of mocked process.exit
+    expect(thrownError?.message).toBe('process.exit(1) called');
+
+    expect(consoleErrorJsonSpy).toHaveBeenCalledWith(
+      JSON.stringify(
+        {
+          error: {
+            type: 'Error',
+            message: 'Invalid input provided',
+            code: 1,
+          },
+        },
+        null,
+        2,
+      ),
+    );
+  });
+
+  it('should handle FatalInputError with custom exit code in JSON format', async () => {
+    vi.mocked(mockConfig.getOutputFormat).mockReturnValue(OutputFormat.JSON);
+    const fatalError = new FatalInputError('Invalid command syntax provided');
+
+    mockGeminiClient.sendMessageStream.mockImplementation(() => {
+      throw fatalError;
+    });
+
+    // Mock console.error to capture JSON error output
+    const consoleErrorJsonSpy = vi
+      .spyOn(console, 'error')
+      .mockImplementation(() => {});
+
+    let thrownError: Error | null = null;
+    try {
+      await runNonInteractive(mockConfig, 'Invalid syntax', 'prompt-id-fatal');
+      // Should not reach here
+      expect.fail('Expected process.exit to be called');
+    } catch (error) {
+      thrownError = error as Error;
+    }
+
+    // Should throw because of mocked process.exit with custom exit code
+    expect(thrownError?.message).toBe('process.exit(42) called');
+
+    expect(consoleErrorJsonSpy).toHaveBeenCalledWith(
+      JSON.stringify(
+        {
+          error: {
+            type: 'FatalInputError',
+            message: 'Invalid command syntax provided',
+            code: 42,
+          },
+        },
+        null,
+        2,
+      ),
+    );
+  });
 });