QwenLM · DragonnZhang · May 26, 2026 · May 25, 2026 · May 25, 2026 · May 25, 2026
diff --git a/packages/cli/src/nonInteractive/control/ControlContext.ts b/packages/cli/src/nonInteractive/control/ControlContext.ts
@@ -35,6 +35,7 @@ export interface IControlContext {
   readonly settings: LoadedSettings;
 
   permissionMode: PermissionMode;
+  sdkCanUseToolTimeoutMs?: number;
   sdkMcpServers: Set<string>;
   mcpClients: Map<string, { client: Client; config: MCPServerConfig }>;
   inputClosed: boolean;
@@ -54,6 +55,7 @@ export class ControlContext implements IControlContext {
   readonly settings: LoadedSettings;
 
   permissionMode: PermissionMode;
+  sdkCanUseToolTimeoutMs?: number;
   sdkMcpServers: Set<string>;
   mcpClients: Map<string, { client: Client; config: MCPServerConfig }>;
   inputClosed: boolean;

diff --git a/packages/cli/src/nonInteractive/control/controllers/permissionController.test.ts b/packages/cli/src/nonInteractive/control/controllers/permissionController.test.ts
@@ -0,0 +1,186 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, expect, it, vi } from 'vitest';
+import {
+  InputFormat,
+  ToolConfirmationOutcome,
+} from '@qwen-code/qwen-code-core';
+import { createMinimalSettings } from '../../../config/settings.js';
+import type { StreamJsonOutputAdapter } from '../../io/StreamJsonOutputAdapter.js';
+import type { IControlContext } from '../ControlContext.js';
+import type { IPendingRequestRegistry } from './baseController.js';
+import { PermissionController } from './permissionController.js';
+
+function createContext(canUseToolTimeoutMs?: number): IControlContext {
+  const abortController = new AbortController();
+
+  return {
+    config: {
+      getDebugMode: vi.fn().mockReturnValue(false),
+      getInputFormat: vi.fn().mockReturnValue(InputFormat.STREAM_JSON),
+    } as unknown as IControlContext['config'],
+    streamJson: {
+      send: vi.fn(),
+    } as unknown as StreamJsonOutputAdapter,
+    sessionId: 'test-session-id',
+    abortSignal: abortController.signal,
+    debugMode: false,
+    settings: createMinimalSettings(),
+    permissionMode: 'default',
+    sdkCanUseToolTimeoutMs: canUseToolTimeoutMs,
+    sdkMcpServers: new Set<string>(),
+    mcpClients: new Map(),
+    inputClosed: false,
+  };
+}
+
+function createRegistry(): IPendingRequestRegistry {
+  return {
+    registerIncomingRequest: vi.fn(),
+    deregisterIncomingRequest: vi.fn(),
+    registerOutgoingRequest: vi.fn(),
+    deregisterOutgoingRequest: vi.fn(),
+  };
+}
+
+describe('PermissionController', () => {
+  it('uses SDK canUseTool timeout for outgoing permission requests', async () => {
+    const context = createContext(120_000);
+    const controller = new PermissionController(
+      context,
+      createRegistry(),
+      'PermissionController',
+    );
+    const sendControlRequest = vi
+      .spyOn(controller, 'sendControlRequest')
+      .mockResolvedValue({
+        subtype: 'success',
+        request_id: 'request-1',
+        response: { behavior: 'allow' },
+      });
+    const onConfirm = vi.fn();
+
+    controller.getToolCallUpdateCallback()([
+      {
+        status: 'awaiting_approval',
+        request: {
+          callId: 'tool-call-1',
+          name: 'ask_user_question',
+          args: { questions: [] },
+        },
+        confirmationDetails: {
+          type: 'ask_user_question',
+          title: 'Please answer',
+          onConfirm,
+        },
+      },
+    ]);
+
+    await vi.waitFor(() => {
+      expect(sendControlRequest).toHaveBeenCalledWith(
+        expect.objectContaining({
+          subtype: 'can_use_tool',
+          tool_name: 'ask_user_question',
+        }),
+        120_000,
+        context.abortSignal,
+      );
+    });
+    await vi.waitFor(() => {
+      expect(onConfirm).toHaveBeenCalledWith(
+        ToolConfirmationOutcome.ProceedOnce,
+      );
+    });
+  });
+
+  it('uses default timeout when SDK canUseTool timeout is undefined', async () => {
+    const context = createContext(); // undefined timeout
+    const controller = new PermissionController(
+      context,
+      createRegistry(),
+      'PermissionController',
+    );
+    const sendControlRequest = vi
+      .spyOn(controller, 'sendControlRequest')
+      .mockResolvedValue({
+        subtype: 'success',
+        request_id: 'request-2',
+        response: { behavior: 'allow' },
+      });
+    const onConfirm = vi.fn();
+
+    controller.getToolCallUpdateCallback()([
+      {
+        status: 'awaiting_approval',
+        request: {
+          callId: 'tool-call-2',
+          name: 'ask_user_question',
+          args: { questions: [] },
+        },
+        confirmationDetails: {
+          type: 'ask_user_question',
+          title: 'Please answer',
+          onConfirm,
+        },
+      },
+    ]);
+
+    await vi.waitFor(() => {
+      expect(sendControlRequest).toHaveBeenCalledWith(
+        expect.objectContaining({
+          subtype: 'can_use_tool',
+          tool_name: 'ask_user_question',
+        }),
+        60_000, // DEFAULT_CAN_USE_TOOL_TIMEOUT_MS
+        context.abortSignal,
+      );
+    });
+    await vi.waitFor(() => {
+      expect(onConfirm).toHaveBeenCalledWith(
+        ToolConfirmationOutcome.ProceedOnce,
+      );
+    });
+  });
+
+  it('calls onConfirm with Cancel when sendControlRequest rejects', async () => {
+    const context = createContext(120_000);
+    const controller = new PermissionController(
+      context,
+      createRegistry(),
+      'PermissionController',
+    );
+    vi.spyOn(controller, 'sendControlRequest').mockRejectedValue(
+      new Error('Request timeout'),
+    );
+    const onConfirm = vi.fn();
+
+    controller.getToolCallUpdateCallback()([
+      {
+        status: 'awaiting_approval',
+        request: {
+          callId: 'tool-call-3',
+          name: 'ask_user_question',
+          args: { questions: [] },
+        },
+        confirmationDetails: {
+          type: 'ask_user_question',
+          title: 'Please answer',
+          onConfirm,
+        },
+      },
+    ]);
+
+    await vi.waitFor(() => {
+      expect(onConfirm).toHaveBeenCalledWith(
+        ToolConfirmationOutcome.Cancel,
+        expect.objectContaining({
+          cancelMessage: expect.stringContaining('Request timeout'),
+        }),
+      );
+    });
+  });
+});
diff --git a/packages/cli/src/nonInteractive/control/controllers/permissionController.ts b/packages/cli/src/nonInteractive/control/controllers/permissionController.ts
@@ -36,6 +36,8 @@ import { BaseController } from './baseController.js';
 // Import ToolCallConfirmationDetails types for type alignment
 type ToolConfirmationType = 'edit' | 'exec' | 'mcp' | 'info' | 'plan';
 
+const DEFAULT_CAN_USE_TOOL_TIMEOUT_MS = 60_000;
+
 export class PermissionController extends BaseController {
   private pendingOutgoingRequests = new Set<string>();
 
@@ -427,7 +429,7 @@ export class PermissionController extends BaseController {
           permission_suggestions: permissionSuggestions,
           blocked_path: null,
         } as CLIControlPermissionRequest,
-        undefined, // use default timeout
+        this.context.sdkCanUseToolTimeoutMs ?? DEFAULT_CAN_USE_TOOL_TIMEOUT_MS,
         this.context.abortSignal,
       );