fix(openai-responses): emit reasoning blocks from responses stream

packages/cli/src/nonInteractiveCli.test.ts

@@ -200,6 +200,38 @@ describe('runNonInteractive', () => {
     expect(mockShutdownTelemetry).toHaveBeenCalled();
   });
 
+  it('should coalesce thought output before content', async () => {
+    mockConfig.getEphemeralSetting = vi
+      .fn<(key: string) => boolean | undefined>()
+      .mockReturnValue(true);
+
+    const events: ServerGeminiStreamEvent[] = [
+      {
+        type: GeminiEventType.Thought,
+        value: { subject: 'First', description: '' },
+      },
+      {
+        type: GeminiEventType.Thought,
+        value: { subject: 'Second', description: '' },
+      },
+      { type: GeminiEventType.Content, value: 'Content' },
+    ];
+    mockGeminiClient.sendMessageStream.mockReturnValue(
+      createStreamFromEvents(events),
+    );
+
+    await runNonInteractive({
+      config: mockConfig,
+      settings: mockSettings,
+      input: 'Test input',
+      prompt_id: 'prompt-id-thought',
+    });
+
+    const writes = processStdoutSpy.mock.calls.map(([value]) => value);
+    const output = writes.join('');
+    expect(output).toContain('<think>First Second</think>');
+  });
+
   it('should handle a single tool call and respond', async () => {
     const toolCallEvent: ServerGeminiStreamEvent = {
       type: GeminiEventType.ToolCallRequest,
@@ -726,6 +758,108 @@ describe('runNonInteractive', () => {
     expect(processStdoutSpy).toHaveBeenCalledWith('file.txt');
   });
 
+  // Skipped tests from issue922 branch - thought buffering tests for deduplication
+  it.skip('should accumulate multiple Thought events and flush once on content boundary', async () => {
+    const thoughtEvent1: ServerGeminiStreamEvent = {
+      type: GeminiEventType.Thought,
+      value: {
+        subject: 'First',
+        description: 'thought',
+      },
+    };
+    const thoughtEvent2: ServerGeminiStreamEvent = {
+      type: GeminiEventType.Thought,
+      value: {
+        subject: 'Second',
+        description: 'thought',
+      },
+    };
+    const contentEvent: ServerGeminiStreamEvent = {
+      type: GeminiEventType.Content,
+      value: 'Response text',
+    };
+    const finishedEvent: ServerGeminiStreamEvent = {
+      type: GeminiEventType.Finished,
+      value: { reason: undefined, usageMetadata: { totalTokenCount: 10 } },
+    };
+
+    mockGeminiClient.sendMessageStream.mockReturnValueOnce(
+      createStreamFromEvents([
+        thoughtEvent1,
+        thoughtEvent2,
+        contentEvent,
+        finishedEvent,
+      ]),
+    );
+
+    await runNonInteractive({
+      config: mockConfig,
+      settings: mockSettings,
+      input: 'test query',
+      prompt_id: 'test-prompt-id',
+    });
+
+    const thinkingOutputs = processStdoutSpy.mock.calls.filter(
+      ([output]: [string]) => output.includes('<think>'),
+    );
+
+    expect(thinkingOutputs).toHaveLength(1);
+    const thinkingText = thinkingOutputs[0][0];
+    expect(thinkingText).toContain('First thought');
+    expect(thinkingText).toContain('Second thought');
+  });
+
+  it.skip('should NOT emit pyramid-style repeated prefixes in non-interactive CLI', async () => {
+    const thoughtEvent1: ServerGeminiStreamEvent = {
+      type: GeminiEventType.Thought,
+      value: {
+        subject: 'Analyzing',
+        description: '',
+      },
+    };
+    const thoughtEvent2: ServerGeminiStreamEvent = {
+      type: GeminiEventType.Thought,
+      value: {
+        subject: 'request',
+        description: '',
+      },
+    };
+    const contentEvent: ServerGeminiStreamEvent = {
+      type: GeminiEventType.Content,
+      value: 'Response',
+    };
+    const finishedEvent: ServerGeminiStreamEvent = {
+      type: GeminiEventType.Finished,
+      value: { reason: undefined, usageMetadata: { totalTokenCount: 10 } },
+    };
+
+    mockGeminiClient.sendMessageStream.mockReturnValueOnce(
+      createStreamFromEvents([
+        thoughtEvent1,
+        thoughtEvent2,
+        contentEvent,
+        finishedEvent,
+      ]),
+    );
+
+    await runNonInteractive({
+      config: mockConfig,
+      settings: mockSettings,
+      input: 'test query',
+      prompt_id: 'test-prompt-id',
+    });
+
+    const thinkingOutputs = processStdoutSpy.mock.calls.filter(
+      ([output]: [string]) => output.includes('<think>'),
+    );
+
+    expect(thinkingOutputs).toHaveLength(1);
+    const thinkingText = thinkingOutputs[0][0];
+    const thoughtCount = (thinkingText.match(/Analyzing/g) || []).length;
+    expect(thoughtCount).toBe(1);
+  });
+
+  // Tests from main branch
   it('should display a deprecation warning if hasDeprecatedPromptArg is true', async () => {
     const events: ServerGeminiStreamEvent[] = [
       { type: GeminiEventType.Content, value: 'Final Answer' },

packages/cli/src/nonInteractiveCli.ts

@@ -277,6 +277,28 @@ export async function runNonInteractive({
         );
       }
       const functionCalls: ToolCallRequestInfo[] = [];
+      let thoughtBuffer = '';
+      // Only emit thinking in plain text mode (not JSON or STREAM_JSON)
+      // In STREAM_JSON mode, thinking would corrupt the JSON event stream
+      const includeThinking =
+        !jsonOutput &&
+        !streamJsonOutput &&
+        (typeof config.getEphemeralSetting === 'function'
+          ? config.getEphemeralSetting('reasoning.includeInResponse') !== false
+          : true);
+
+      const flushThoughtBuffer = () => {
+        if (!includeThinking) {
+          thoughtBuffer = '';
+          return;
+        }
+        if (!thoughtBuffer.trim()) {
+          thoughtBuffer = '';
+          return;
+        }
+        process.stdout.write(`<think>${thoughtBuffer.trim()}</think>\n`);
+        thoughtBuffer = '';
+      };
 
       const responseStream = geminiClient.sendMessageStream(
         currentMessages[0]?.parts || [],
@@ -291,17 +313,6 @@ export async function runNonInteractive({
         }
 
         if (event.type === GeminiEventType.Thought) {
-          // Output thinking/reasoning content with <think> tags
-          // Check if reasoning.includeInResponse is enabled
-          if (jsonOutput) {
-            continue;
-          }
-          const includeThinking =
-            typeof config.getEphemeralSetting === 'function'
-              ? (config.getEphemeralSetting('reasoning.includeInResponse') ??
-                true)
-              : true;
-
           if (includeThinking) {
             const thoughtEvent = event as ServerGeminiThoughtEvent;
             const thought = thoughtEvent.value;
@@ -312,6 +323,7 @@ export async function runNonInteractive({
                 : thought.subject || thought.description || '';
 
             if (thoughtText.trim()) {
+              // Apply emoji filter if enabled
               if (emojiFilter) {
                 const filterResult = emojiFilter.filterText(thoughtText);
                 if (filterResult.blocked) {
@@ -321,19 +333,20 @@ export async function runNonInteractive({
                   thoughtText = filterResult.filtered;
                 }
               }
-              process.stdout.write(`<think>${thoughtText}</think>\n`);
+              // Buffer thoughts to prevent duplicate/pyramid output
+              thoughtBuffer = thoughtBuffer
+                ? `${thoughtBuffer} ${thoughtText}`
+                : thoughtText;
             }
           }
         } else if (event.type === GeminiEventType.Content) {
-          // Apply emoji filtering to content output
-          // Note: <think> tags are preserved in output to show thinking vs non-thinking content
+          flushThoughtBuffer();
           let outputValue = event.value;
 
           if (emojiFilter) {
             const filterResult = emojiFilter.filterStreamChunk(outputValue);
 
             if (filterResult.blocked) {
-              // In error mode: output error message and continue
               if (!jsonOutput) {
                 process.stderr.write(
                   '[Error: Response blocked due to emoji detection]\n',
@@ -347,7 +360,6 @@ export async function runNonInteractive({
                 ? (filterResult.filtered as string)
                 : '';
 
-            // Output system feedback if needed
             if (filterResult.systemFeedback) {
               if (!jsonOutput) {
                 process.stderr.write(
@@ -371,6 +383,7 @@ export async function runNonInteractive({
             process.stdout.write(outputValue);
           }
         } else if (event.type === GeminiEventType.ToolCallRequest) {
+          flushThoughtBuffer();
           const toolCallRequest = event.value;
           if (streamFormatter) {
             streamFormatter.emitEvent({
@@ -411,6 +424,8 @@ export async function runNonInteractive({
         }
       }
 
+      flushThoughtBuffer();
+
       const remainingBuffered = emojiFilter?.flushBuffer?.();
       if (remainingBuffered) {
         if (jsonOutput) {

packages/cli/src/providers/aliases/codex.config

@@ -7,6 +7,8 @@
   "description": "OpenAI Codex (ChatGPT backend with OAuth)",
   "ephemeralSettings": {
     "context-limit": 262144,
-    "prompt-caching": "24h"
+    "prompt-caching": "24h",
+    "reasoning.effort": "medium",
+    "reasoning.summary": "auto"
   }
 }

packages/cli/src/providers/providerAliases.codex.reasoningSummary.test.ts

@@ -0,0 +1,45 @@
+/**
+ * @license
+ * Copyright 2025 Vybestack LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * TDD tests for codex.config reasoning.summary default
+ * @issue #922 - GPT-5.2-Codex thinking blocks not visible
+ */
+
+import { describe, it, expect } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import stripJsonComments from 'strip-json-comments';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+describe('codex.config reasoning.summary default @issue:922', () => {
+  it('should have a codex.config file', () => {
+    const codexConfigPath = path.join(__dirname, 'aliases', 'codex.config');
+    expect(fs.existsSync(codexConfigPath)).toBe(true);
+  });
+
+  it('should set reasoning.summary=auto in ephemerals', () => {
+    // Read the config file directly to avoid vitest module resolution issues
+    const codexConfigPath = path.join(__dirname, 'aliases', 'codex.config');
+    const raw = fs.readFileSync(codexConfigPath, 'utf-8');
+    const config = JSON.parse(stripJsonComments(raw));
+
+    expect(config.ephemeralSettings).toBeDefined();
+    expect(config.ephemeralSettings['reasoning.summary']).toBe('auto');
+  });
+
+  it('should set reasoning.effort in ephemerals (existing behavior)', () => {
+    // Read the config file directly to avoid vitest module resolution issues
+    const codexConfigPath = path.join(__dirname, 'aliases', 'codex.config');
+    const raw = fs.readFileSync(codexConfigPath, 'utf-8');
+    const config = JSON.parse(stripJsonComments(raw));
+
+    expect(config.ephemeralSettings).toBeDefined();
+    // Codex should have some default effort level
+    expect(config.ephemeralSettings['reasoning.effort']).toBeDefined();
+  });
+});

packages/cli/src/runtime/runtimeSettings.reasoningSummary.test.ts

@@ -0,0 +1,34 @@
+/**
+ * @license
+ * Copyright 2025 Vybestack LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * TDD tests for reasoning.summary profile save/load
+ * @issue #922 - GPT-5.2-Codex thinking blocks not visible
+ */
+
+import { describe, it, expect } from 'vitest';
+import { PROFILE_EPHEMERAL_KEYS } from './runtimeSettings.js';
+
+describe('reasoning.summary profile save/load @issue:922', () => {
+  it('should include reasoning.summary in PROFILE_EPHEMERAL_KEYS', () => {
+    expect(PROFILE_EPHEMERAL_KEYS).toContain('reasoning.summary');
+  });
+
+  it('should include all reasoning.* keys in PROFILE_EPHEMERAL_KEYS', () => {
+    // Verify all reasoning settings are saveable
+    expect(PROFILE_EPHEMERAL_KEYS).toContain('reasoning.enabled');
+    expect(PROFILE_EPHEMERAL_KEYS).toContain('reasoning.includeInContext');
+    expect(PROFILE_EPHEMERAL_KEYS).toContain('reasoning.includeInResponse');
+    expect(PROFILE_EPHEMERAL_KEYS).toContain('reasoning.format');
+    expect(PROFILE_EPHEMERAL_KEYS).toContain('reasoning.stripFromContext');
+    expect(PROFILE_EPHEMERAL_KEYS).toContain('reasoning.effort');
+    expect(PROFILE_EPHEMERAL_KEYS).toContain('reasoning.maxTokens');
+    expect(PROFILE_EPHEMERAL_KEYS).toContain('reasoning.summary');
+  });
+
+  it('should include text.verbosity in PROFILE_EPHEMERAL_KEYS', () => {
+    // text.verbosity is for OpenAI Responses API response verbosity control
+    expect(PROFILE_EPHEMERAL_KEYS).toContain('text.verbosity');
+  });
+});

packages/cli/src/runtime/runtimeSettings.ts

@@ -894,6 +894,7 @@ export function clearActiveModelParam(name: string): void {
   settingsService.setProviderSetting(providerName, name, undefined);
 }
 
+// Use centralized settings registry for profile-persistable keys
 export const PROFILE_EPHEMERAL_KEYS: readonly string[] =
   getProfilePersistableKeys();