fix: missing whitespaces for stream-json/json output format via GLM 4.7 model

packages/cli/src/config/config.test.ts

@@ -1597,58 +1597,6 @@ describe('Approval mode tool exclusion logic', () => {
     expect(excludedTools).toContain(WriteFileTool.Name);
   });
 
-  it('should not exclude a tool explicitly allowed in tools.allowed', async () => {
-    process.argv = ['node', 'script.js', '-p', 'test'];
-    const argv = await parseArguments({} as Settings);
-    const settings: Settings = {
-      tools: {
-        allowed: [ShellTool.Name],
-      },
-    };
-    const extensions: Extension[] = [];
-
-    const config = await loadCliConfig(
-      settings,
-      extensions,
-      new ExtensionEnablementManager(
-        ExtensionStorage.getUserExtensionsDir(),
-        argv.extensions,
-      ),
-      argv,
-    );
-
-    const excludedTools = config.getExcludeTools();
-    expect(excludedTools).not.toContain(ShellTool.Name);
-    expect(excludedTools).toContain(EditTool.Name);
-    expect(excludedTools).toContain(WriteFileTool.Name);
-  });
-
-  it('should not exclude a tool explicitly allowed in tools.core', async () => {
-    process.argv = ['node', 'script.js', '-p', 'test'];
-    const argv = await parseArguments({} as Settings);
-    const settings: Settings = {
-      tools: {
-        core: [ShellTool.Name],
-      },
-    };
-    const extensions: Extension[] = [];
-
-    const config = await loadCliConfig(
-      settings,
-      extensions,
-      new ExtensionEnablementManager(
-        ExtensionStorage.getUserExtensionsDir(),
-        argv.extensions,
-      ),
-      argv,
-    );
-
-    const excludedTools = config.getExcludeTools();
-    expect(excludedTools).not.toContain(ShellTool.Name);
-    expect(excludedTools).toContain(EditTool.Name);
-    expect(excludedTools).toContain(WriteFileTool.Name);
-  });
-
   it('should exclude only shell tools in non-interactive mode with auto-edit approval mode', async () => {
     process.argv = [
       'node',

packages/cli/src/config/config.ts

@@ -10,24 +10,22 @@ import {
   Config,
   DEFAULT_QWEN_EMBEDDING_MODEL,
   DEFAULT_MEMORY_FILE_FILTERING_OPTIONS,
+  EditTool,
   FileDiscoveryService,
   getCurrentGeminiMdFilename,
   loadServerHierarchicalMemory,
   setGeminiMdFilename as setServerGeminiMdFilename,
+  ShellTool,
+  WriteFileTool,
   resolveTelemetrySettings,
   FatalConfigError,
   Storage,
   InputFormat,
   OutputFormat,
-  isToolEnabled,
   SessionService,
   type ResumedSessionData,
   type FileFilteringOptions,
   type MCPServerConfig,
-  type ToolName,
-  EditTool,
-  ShellTool,
-  WriteFileTool,
 } from '@qwen-code/qwen-code-core';
 import { extensionsCommand } from '../commands/extensions.js';
 import type { Settings } from './settings.js';
@@ -820,28 +818,6 @@ export async function loadCliConfig(
   // However, if stream-json input is used, control can be requested via JSON messages,
   // so tools should not be excluded in that case.
   const extraExcludes: string[] = [];
-  const resolvedCoreTools = argv.coreTools || settings.tools?.core || [];
-  const resolvedAllowedTools =
-    argv.allowedTools || settings.tools?.allowed || [];
-  const isExplicitlyEnabled = (toolName: ToolName): boolean => {
-    if (resolvedCoreTools.length > 0) {
-      if (isToolEnabled(toolName, resolvedCoreTools, [])) {
-        return true;
-      }
-    }
-    if (resolvedAllowedTools.length > 0) {
-      if (isToolEnabled(toolName, resolvedAllowedTools, [])) {
-        return true;
-      }
-    }
-    return false;
-  };
-  const excludeUnlessExplicit = (toolName: ToolName): void => {
-    if (!isExplicitlyEnabled(toolName)) {
-      extraExcludes.push(toolName);
-    }
-  };
-
   if (
     !interactive &&
     !argv.experimentalAcp &&
@@ -850,15 +826,12 @@ export async function loadCliConfig(
     switch (approvalMode) {
       case ApprovalMode.PLAN:
       case ApprovalMode.DEFAULT:
-        // In default non-interactive mode, all tools that require approval are excluded,
-        // unless explicitly enabled via coreTools/allowedTools.
-        excludeUnlessExplicit(ShellTool.Name as ToolName);
-        excludeUnlessExplicit(EditTool.Name as ToolName);
-        excludeUnlessExplicit(WriteFileTool.Name as ToolName);
+        // In default non-interactive mode, all tools that require approval are excluded.
+        extraExcludes.push(ShellTool.Name, EditTool.Name, WriteFileTool.Name);
         break;
       case ApprovalMode.AUTO_EDIT:
         // In auto-edit non-interactive mode, only tools that still require a prompt are excluded.
-        excludeUnlessExplicit(ShellTool.Name as ToolName);
+        extraExcludes.push(ShellTool.Name);
         break;
       case ApprovalMode.YOLO:
         // No extra excludes for YOLO mode.

packages/cli/src/nonInteractive/io/BaseJsonOutputAdapter.test.ts

@@ -630,6 +630,67 @@ describe('BaseJsonOutputAdapter', () => {
 
       expect(state.blocks).toHaveLength(0);
     });
+
+    it('should preserve whitespace in thinking content', () => {
+      const state = adapter.exposeCreateMessageState();
+      adapter.startAssistantMessage();
+
+      adapter.exposeAppendThinking(
+        state,
+        '',
+        'The user just said "Hello"',
+        null,
+      );
+
+      expect(state.blocks).toHaveLength(1);
+      expect(state.blocks[0]).toMatchObject({
+        type: 'thinking',
+        thinking: 'The user just said "Hello"',
+      });
+      // Verify spaces are preserved
+      const block = state.blocks[0] as { thinking: string };
+      expect(block.thinking).toContain('user just');
+      expect(block.thinking).not.toContain('userjust');
+    });
+
+    it('should preserve whitespace when appending multiple thinking fragments', () => {
+      const state = adapter.exposeCreateMessageState();
+      adapter.startAssistantMessage();
+
+      // Simulate streaming thinking content in fragments
+      adapter.exposeAppendThinking(state, '', 'The user just', null);
+      adapter.exposeAppendThinking(state, '', ' said "Hello"', null);
+      adapter.exposeAppendThinking(
+        state,
+        '',
+        '. This is a simple greeting',
+        null,
+      );
+
+      expect(state.blocks).toHaveLength(1);
+      const block = state.blocks[0] as { thinking: string };
+      // Verify the complete text with all spaces preserved
+      expect(block.thinking).toBe(
+        'The user just said "Hello". This is a simple greeting',
+      );
+      // Verify specific space preservation
+      expect(block.thinking).toContain('user just ');
+      expect(block.thinking).toContain(' said');
+      expect(block.thinking).toContain('". This');
+      expect(block.thinking).not.toContain('userjust');
+      expect(block.thinking).not.toContain('justsaid');
+    });
+
+    it('should preserve leading and trailing whitespace in description', () => {
+      const state = adapter.exposeCreateMessageState();
+      adapter.startAssistantMessage();
+
+      adapter.exposeAppendThinking(state, '', '  content with spaces  ', null);
+
+      expect(state.blocks).toHaveLength(1);
+      const block = state.blocks[0] as { thinking: string };
+      expect(block.thinking).toBe('  content with spaces  ');
+    });
   });
 
   describe('appendToolUse', () => {

packages/cli/src/nonInteractive/io/BaseJsonOutputAdapter.ts

@@ -816,9 +816,18 @@ export abstract class BaseJsonOutputAdapter {
     parentToolUseId?: string | null,
   ): void {
     const actualParentToolUseId = parentToolUseId ?? null;
-    const fragment = [subject?.trim(), description?.trim()]
-      .filter((value) => value && value.length > 0)
-      .join(': ');
+
+    // Build fragment without trimming to preserve whitespace in streaming content
+    // Only filter out null/undefined/empty values
+    const parts: string[] = [];
+    if (subject && subject.length > 0) {
+      parts.push(subject);
+    }
+    if (description && description.length > 0) {
+      parts.push(description);
+    }
+
+    const fragment = parts.join(': ');
     if (!fragment) {
       return;
     }

packages/cli/src/nonInteractive/io/StreamJsonOutputAdapter.test.ts

@@ -323,6 +323,68 @@ describe('StreamJsonOutputAdapter', () => {
       });
     });
 
+    it('should preserve whitespace in thinking content (issue #1356)', () => {
+      adapter.processEvent({
+        type: GeminiEventType.Thought,
+        value: {
+          subject: '',
+          description: 'The user just said "Hello"',
+        },
+      });
+
+      const message = adapter.finalizeAssistantMessage();
+      expect(message.message.content).toHaveLength(1);
+      const block = message.message.content[0] as {
+        type: string;
+        thinking: string;
+      };
+      expect(block.type).toBe('thinking');
+      expect(block.thinking).toBe('The user just said "Hello"');
+      // Verify spaces are preserved
+      expect(block.thinking).toContain('user just');
+      expect(block.thinking).not.toContain('userjust');
+    });
+
+    it('should preserve whitespace when streaming multiple thinking fragments (issue #1356)', () => {
+      // Simulate streaming thinking content in multiple events
+      adapter.processEvent({
+        type: GeminiEventType.Thought,
+        value: {
+          subject: '',
+          description: 'The user just',
+        },
+      });
+      adapter.processEvent({
+        type: GeminiEventType.Thought,
+        value: {
+          subject: '',
+          description: ' said "Hello"',
+        },
+      });
+      adapter.processEvent({
+        type: GeminiEventType.Thought,
+        value: {
+          subject: '',
+          description: '. This is a simple greeting',
+        },
+      });
+
+      const message = adapter.finalizeAssistantMessage();
+      expect(message.message.content).toHaveLength(1);
+      const block = message.message.content[0] as {
+        type: string;
+        thinking: string;
+      };
+      expect(block.thinking).toBe(
+        'The user just said "Hello". This is a simple greeting',
+      );
+      // Verify specific spaces are preserved
+      expect(block.thinking).toContain('user just ');
+      expect(block.thinking).toContain(' said');
+      expect(block.thinking).not.toContain('userjust');
+      expect(block.thinking).not.toContain('justsaid');
+    });
+
     it('should append tool use from ToolCallRequest events', () => {
       adapter.processEvent({
         type: GeminiEventType.ToolCallRequest,

packages/cli/src/services/prompt-processors/shellProcessor.test.ts

@@ -72,7 +72,6 @@ describe('ShellProcessor', () => {
       getApprovalMode: vi.fn().mockReturnValue(ApprovalMode.DEFAULT),
       getShouldUseNodePtyShell: vi.fn().mockReturnValue(false),
       getShellExecutionConfig: vi.fn().mockReturnValue({}),
-      getAllowedTools: vi.fn().mockReturnValue([]),
     };
 
     context = createMockCommandContext({
@@ -197,35 +196,6 @@ describe('ShellProcessor', () => {
     );
   });
 
-  it('should NOT throw ConfirmationRequiredError when a command matches allowedTools', async () => {
-    const processor = new ShellProcessor('test-command');
-    const prompt: PromptPipelineContent = createPromptPipelineContent(
-      'Do something dangerous: !{rm -rf /}',
-    );
-    mockCheckCommandPermissions.mockReturnValue({
-      allAllowed: false,
-      disallowedCommands: ['rm -rf /'],
-    });
-    (mockConfig.getAllowedTools as Mock).mockReturnValue([
-      'ShellTool(rm -rf /)',
-    ]);
-    mockShellExecute.mockReturnValue({
-      result: Promise.resolve({ ...SUCCESS_RESULT, output: 'deleted' }),
-    });
-
-    const result = await processor.process(prompt, context);
-
-    expect(mockShellExecute).toHaveBeenCalledWith(
-      'rm -rf /',
-      expect.any(String),
-      expect.any(Function),
-      expect.any(Object),
-      false,
-      expect.any(Object),
-    );
-    expect(result).toEqual([{ text: 'Do something dangerous: deleted' }]);
-  });
-
   it('should NOT throw ConfirmationRequiredError if a command is not allowed but approval mode is YOLO', async () => {
     const processor = new ShellProcessor('test-command');
     const prompt: PromptPipelineContent = createPromptPipelineContent(

packages/cli/src/services/prompt-processors/shellProcessor.ts

@@ -7,13 +7,11 @@
 import {
   ApprovalMode,
   checkCommandPermissions,
-  doesToolInvocationMatch,
   escapeShellArg,
   getShellConfiguration,
   ShellExecutionService,
   flatMapTextParts,
 } from '@qwen-code/qwen-code-core';
-import type { AnyToolInvocation } from '@qwen-code/qwen-code-core';
 
 import type { CommandContext } from '../../ui/commands/types.js';
 import type { IPromptProcessor, PromptPipelineContent } from './types.js';
@@ -126,15 +124,6 @@ export class ShellProcessor implements IPromptProcessor {
       // Security check on the final, escaped command string.
       const { allAllowed, disallowedCommands, blockReason, isHardDenial } =
         checkCommandPermissions(command, config, sessionShellAllowlist);
-      const allowedTools = config.getAllowedTools() || [];
-      const invocation = {
-        params: { command },
-      } as AnyToolInvocation;
-      const isAllowedBySettings = doesToolInvocationMatch(
-        'run_shell_command',
-        invocation,
-        allowedTools,
-      );
 
       if (!allAllowed) {
         if (isHardDenial) {
@@ -143,17 +132,10 @@ export class ShellProcessor implements IPromptProcessor {
           );
         }
 
-        // If the command is allowed by settings, skip confirmation.
-        if (isAllowedBySettings) {
-          continue;
-        }
-
         // If not a hard denial, respect YOLO mode and auto-approve.
-        if (config.getApprovalMode() === ApprovalMode.YOLO) {
-          continue;
+        if (config.getApprovalMode() !== ApprovalMode.YOLO) {
+          disallowedCommands.forEach((uc) => commandsToConfirm.add(uc));
         }
-
-        disallowedCommands.forEach((uc) => commandsToConfirm.add(uc));
       }
     }
 

packages/core/src/core/coreToolScheduler.ts

@@ -824,6 +824,7 @@ export class CoreToolScheduler {
              */
             const shouldAutoDeny =
               !this.config.isInteractive() &&
+              !this.config.getIdeMode() &&
               !this.config.getExperimentalZedIntegration() &&
               this.config.getInputFormat() !== InputFormat.STREAM_JSON;
 

packages/core/src/index.ts

@@ -38,7 +38,6 @@ export * from './utils/quotaErrorDetection.js';
 export * from './utils/fileUtils.js';
 export * from './utils/retry.js';
 export * from './utils/shell-utils.js';
-export * from './utils/tool-utils.js';
 export * from './utils/terminalSerializer.js';
 export * from './utils/systemEncoding.js';
 export * from './utils/textUtils.js';

packages/core/src/tools/shell.test.ts

@@ -169,44 +169,6 @@ describe('ShellTool', () => {
       });
       expect(invocation.getDescription()).not.toContain('[background]');
     });
-
-    describe('is_background parameter coercion', () => {
-      it('should accept string "true" as boolean true', () => {
-        const invocation = shellTool.build({
-          command: 'npm run dev',
-          is_background: 'true' as unknown as boolean,
-        });
-        expect(invocation).toBeDefined();
-        expect(invocation.getDescription()).toContain('[background]');
-      });
-
-      it('should accept string "false" as boolean false', () => {
-        const invocation = shellTool.build({
-          command: 'npm run build',
-          is_background: 'false' as unknown as boolean,
-        });
-        expect(invocation).toBeDefined();
-        expect(invocation.getDescription()).not.toContain('[background]');
-      });
-
-      it('should accept string "True" as boolean true', () => {
-        const invocation = shellTool.build({
-          command: 'npm run dev',
-          is_background: 'True' as unknown as boolean,
-        });
-        expect(invocation).toBeDefined();
-        expect(invocation.getDescription()).toContain('[background]');
-      });
-
-      it('should accept string "False" as boolean false', () => {
-        const invocation = shellTool.build({
-          command: 'npm run build',
-          is_background: 'False' as unknown as boolean,
-        });
-        expect(invocation).toBeDefined();
-        expect(invocation.getDescription()).not.toContain('[background]');
-      });
-    });
   });
 
   describe('execute', () => {

packages/core/src/utils/schemaValidator.test.ts

@@ -122,91 +122,4 @@ describe('SchemaValidator', () => {
     };
     expect(SchemaValidator.validate(schema, params)).not.toBeNull();
   });
-
-  describe('boolean string coercion', () => {
-    const booleanSchema = {
-      type: 'object',
-      properties: {
-        is_background: {
-          type: 'boolean',
-        },
-      },
-      required: ['is_background'],
-    };
-
-    it('should coerce string "true" to boolean true', () => {
-      const params = { is_background: 'true' };
-      expect(SchemaValidator.validate(booleanSchema, params)).toBeNull();
-      expect(params.is_background).toBe(true);
-    });
-
-    it('should coerce string "True" to boolean true', () => {
-      const params = { is_background: 'True' };
-      expect(SchemaValidator.validate(booleanSchema, params)).toBeNull();
-      expect(params.is_background).toBe(true);
-    });
-
-    it('should coerce string "TRUE" to boolean true', () => {
-      const params = { is_background: 'TRUE' };
-      expect(SchemaValidator.validate(booleanSchema, params)).toBeNull();
-      expect(params.is_background).toBe(true);
-    });
-
-    it('should coerce string "false" to boolean false', () => {
-      const params = { is_background: 'false' };
-      expect(SchemaValidator.validate(booleanSchema, params)).toBeNull();
-      expect(params.is_background).toBe(false);
-    });
-
-    it('should coerce string "False" to boolean false', () => {
-      const params = { is_background: 'False' };
-      expect(SchemaValidator.validate(booleanSchema, params)).toBeNull();
-      expect(params.is_background).toBe(false);
-    });
-
-    it('should coerce string "FALSE" to boolean false', () => {
-      const params = { is_background: 'FALSE' };
-      expect(SchemaValidator.validate(booleanSchema, params)).toBeNull();
-      expect(params.is_background).toBe(false);
-    });
-
-    it('should handle nested objects with string booleans', () => {
-      const nestedSchema = {
-        type: 'object',
-        properties: {
-          options: {
-            type: 'object',
-            properties: {
-              enabled: { type: 'boolean' },
-            },
-          },
-        },
-      };
-      const params = { options: { enabled: 'true' } };
-      expect(SchemaValidator.validate(nestedSchema, params)).toBeNull();
-      expect((params.options as unknown as { enabled: boolean }).enabled).toBe(
-        true,
-      );
-    });
-
-    it('should not affect non-boolean strings', () => {
-      const mixedSchema = {
-        type: 'object',
-        properties: {
-          name: { type: 'string' },
-          is_active: { type: 'boolean' },
-        },
-      };
-      const params = { name: 'trueman', is_active: 'true' };
-      expect(SchemaValidator.validate(mixedSchema, params)).toBeNull();
-      expect(params.name).toBe('trueman');
-      expect(params.is_active).toBe(true);
-    });
-
-    it('should pass through actual boolean values unchanged', () => {
-      const params = { is_background: true };
-      expect(SchemaValidator.validate(booleanSchema, params)).toBeNull();
-      expect(params.is_background).toBe(true);
-    });
-  });
 });

packages/core/src/utils/schemaValidator.ts

@@ -41,12 +41,14 @@ export class SchemaValidator {
       return 'Value of params must be an object';
     }
     const validate = ajValidator.compile(schema);
-    let valid = validate(data);
+    const valid = validate(data);
     if (!valid && validate.errors) {
-      // Coerce string boolean values ("true"/"false") to actual booleans
-      fixBooleanValues(data as Record<string, unknown>);
+      // Find any True or False values and lowercase them
+      fixBooleanCasing(data as Record<string, unknown>);
+
+      const validate = ajValidator.compile(schema);
+      const valid = validate(data);
 
-      valid = validate(data);
       if (!valid && validate.errors) {
         return ajValidator.errorsText(validate.errors, { dataVar: 'params' });
       }
@@ -55,29 +57,13 @@ export class SchemaValidator {
   }
 }
 
-/**
- * Coerces string boolean values to actual booleans.
- * This handles cases where LLMs return "true"/"false" strings instead of boolean values,
- * which is common with self-hosted LLMs.
- *
- * Converts:
- * - "true", "True", "TRUE" -> true
- * - "false", "False", "FALSE" -> false
- */
-function fixBooleanValues(data: Record<string, unknown>) {
+function fixBooleanCasing(data: Record<string, unknown>) {
   for (const key of Object.keys(data)) {
     if (!(key in data)) continue;
-    const value = data[key];
 
-    if (typeof value === 'object' && value !== null) {
-      fixBooleanValues(value as Record<string, unknown>);
-    } else if (typeof value === 'string') {
-      const lower = value.toLowerCase();
-      if (lower === 'true') {
-        data[key] = true;
-      } else if (lower === 'false') {
-        data[key] = false;
-      }
-    }
+    if (typeof data[key] === 'object') {
+      fixBooleanCasing(data[key] as Record<string, unknown>);
+    } else if (data[key] === 'True') data[key] = 'true';
+    else if (data[key] === 'False') data[key] = 'false';
   }
 }