@rdmind/rdmind 0.1.3-alpha.6 → 0.1.3

package/cli.js

@@ -156760,10 +156760,8 @@ var init_deepseek = __esm({
           ...baseRequest,
           messages,
           /* @ts-expect-error DeepSeek exclusive */
-          extra_body: {
-            chat_template_kwargs: {
-              thinking: true
-            }
+          chat_template_kwargs: {
+            thinking: true
           }
         };
       }
@@ -160787,7 +160785,7 @@ function createContentGeneratorConfig(config2, authType, generationConfig) {
   };
 }
 async function createContentGenerator(config2, gcConfig, isInitialAuth) {
-  const version3 = "0.1.3-alpha.6";
+  const version3 = "0.1.3";
   const userAgent2 = `QwenCode/${version3} (${process.platform}; ${process.arch})`;
   const baseHeaders = {
     "User-Agent": userAgent2
@@ -214581,6 +214579,119 @@ var init_sa_impersonation_provider = __esm({
   }
 });
 
+// packages/core/src/tools/sdk-control-client-transport.ts
+var SdkControlClientTransport;
+var init_sdk_control_client_transport = __esm({
+  "packages/core/src/tools/sdk-control-client-transport.ts"() {
+    "use strict";
+    init_esbuild_shims();
+    SdkControlClientTransport = class {
+      static {
+        __name(this, "SdkControlClientTransport");
+      }
+      serverName;
+      sendMcpMessage;
+      debugMode;
+      started = false;
+      // Transport interface callbacks
+      onmessage;
+      onerror;
+      onclose;
+      constructor(options2) {
+        this.serverName = options2.serverName;
+        this.sendMcpMessage = options2.sendMcpMessage;
+        this.debugMode = options2.debugMode ?? false;
+      }
+      /**
+       * Start the transport
+       * For SDK transport, this just marks it as ready - no subprocess to spawn
+       */
+      async start() {
+        if (this.started) {
+          return;
+        }
+        this.started = true;
+        if (this.debugMode) {
+          console.error(
+            `[SdkControlClientTransport] Started for server '${this.serverName}'`
+          );
+        }
+      }
+      /**
+       * Send a message to the SDK MCP server via control plane
+       *
+       * Routes the message through the control plane and delivers
+       * the response via onmessage callback.
+       */
+      async send(message) {
+        if (!this.started) {
+          throw new Error(
+            `SdkControlClientTransport (${this.serverName}) not started. Call start() first.`
+          );
+        }
+        if (this.debugMode) {
+          console.error(
+            `[SdkControlClientTransport] Sending message to '${this.serverName}':`,
+            JSON.stringify(message)
+          );
+        }
+        try {
+          const response = await this.sendMcpMessage(this.serverName, message);
+          if (this.debugMode) {
+            console.error(
+              `[SdkControlClientTransport] Received response from '${this.serverName}':`,
+              JSON.stringify(response)
+            );
+          }
+          if (this.onmessage) {
+            this.onmessage(response);
+          }
+        } catch (error2) {
+          if (this.debugMode) {
+            console.error(
+              `[SdkControlClientTransport] Error sending to '${this.serverName}':`,
+              error2
+            );
+          }
+          if (this.onerror) {
+            this.onerror(error2 instanceof Error ? error2 : new Error(String(error2)));
+          }
+          throw error2;
+        }
+      }
+      /**
+       * Close the transport
+       */
+      async close() {
+        if (!this.started) {
+          return;
+        }
+        this.started = false;
+        if (this.debugMode) {
+          console.error(
+            `[SdkControlClientTransport] Closed for server '${this.serverName}'`
+          );
+        }
+        if (this.onclose) {
+          this.onclose();
+        }
+      }
+      /**
+       * Check if transport is started
+       */
+      isStarted() {
+        return this.started;
+      }
+      /**
+       * Get server name
+       */
+      getServerName() {
+        return this.serverName;
+      }
+    };
+  }
+});
+
 // packages/core/src/utils/secure-browser-launcher.ts
 import { execFile as execFile8 } from "node:child_process";
 import { promisify as promisify7 } from "node:util";
@@ -215932,7 +216043,7 @@ function populateMcpServerCommand(mcpServers, mcpServerCommand) {
   }
   return mcpServers;
 }
-async function connectAndDiscover(mcpServerName, mcpServerConfig, toolRegistry, promptRegistry, debugMode, workspaceContext, cliConfig) {
+async function connectAndDiscover(mcpServerName, mcpServerConfig, toolRegistry, promptRegistry, debugMode, workspaceContext, cliConfig, sendSdkMcpMessage) {
   updateMCPServerStatus(mcpServerName, "connecting" /* CONNECTING */);
   let mcpClient;
   try {
@@ -215940,7 +216051,8 @@ async function connectAndDiscover(mcpServerName, mcpServerConfig, toolRegistry,
       mcpServerName,
       mcpServerConfig,
       debugMode,
-      workspaceContext
+      workspaceContext,
+      sendSdkMcpMessage
     );
     mcpClient.onerror = (error2) => {
       console.error(`MCP ERROR (${mcpServerName}):`, error2.toString());
@@ -216074,7 +216186,7 @@ async function invokeMcpPrompt(mcpServerName, mcpClient, promptName, promptParam
 function hasNetworkTransport(config2) {
   return !!(config2.url || config2.httpUrl);
 }
-async function connectToMcpServer(mcpServerName, mcpServerConfig, debugMode, workspaceContext) {
+async function connectToMcpServer(mcpServerName, mcpServerConfig, debugMode, workspaceContext, sendSdkMcpMessage) {
   const mcpClient = new Client({
     name: "qwen-code-mcp-client",
     version: "0.0.1"
@@ -216116,7 +216228,8 @@ async function connectToMcpServer(mcpServerName, mcpServerConfig, debugMode, wor
     const transport = await createTransport(
       mcpServerName,
       mcpServerConfig,
-      debugMode
+      debugMode,
+      sendSdkMcpMessage
     );
     try {
       await mcpClient.connect(transport, {
@@ -216416,7 +216529,19 @@ async function connectToMcpServer(mcpServerName, mcpServerConfig, debugMode, wor
     }
   }
 }
-async function createTransport(mcpServerName, mcpServerConfig, debugMode) {
+async function createTransport(mcpServerName, mcpServerConfig, debugMode, sendSdkMcpMessage) {
+  if (isSdkMcpServerConfig(mcpServerConfig)) {
+    if (!sendSdkMcpMessage) {
+      throw new Error(
+        `SDK MCP server '${mcpServerName}' requires sendSdkMcpMessage callback`
+      );
+    }
+    return new SdkControlClientTransport({
+      serverName: mcpServerName,
+      sendMcpMessage: sendSdkMcpMessage,
+      debugMode
+    });
+  }
   if (mcpServerConfig.authProviderType === "service_account_impersonation" /* SERVICE_ACCOUNT_IMPERSONATION */) {
     const provider = new ServiceAccountImpersonationProvider(mcpServerConfig);
     const transportOptions = {
@@ -216578,6 +216703,7 @@ var init_mcp_client = __esm({
     init_google_auth_provider();
     init_sa_impersonation_provider();
     init_mcp_tool();
+    init_sdk_control_client_transport();
     init_node();
     init_oauth_provider();
     init_oauth_token_storage();
@@ -216597,13 +216723,14 @@ var init_mcp_client = __esm({
       return MCPDiscoveryState2;
     })(MCPDiscoveryState || {});
     McpClient = class {
-      constructor(serverName, serverConfig, toolRegistry, promptRegistry, workspaceContext, debugMode) {
+      constructor(serverName, serverConfig, toolRegistry, promptRegistry, workspaceContext, debugMode, sendSdkMcpMessage) {
         this.serverName = serverName;
         this.serverConfig = serverConfig;
         this.toolRegistry = toolRegistry;
         this.promptRegistry = promptRegistry;
         this.workspaceContext = workspaceContext;
         this.debugMode = debugMode;
+        this.sendSdkMcpMessage = sendSdkMcpMessage;
         this.client = new Client({
           name: `rdmind-cli-mcp-client-${this.serverName}`,
           version: "0.0.1"
@@ -216693,7 +216820,12 @@ var init_mcp_client = __esm({
         updateMCPServerStatus(this.serverName, status);
       }
       async createTransport() {
-        return createTransport(this.serverName, this.serverConfig, this.debugMode);
+        return createTransport(
+          this.serverName,
+          this.serverConfig,
+          this.debugMode,
+          this.sendSdkMcpMessage
+        );
       }
       async discoverTools(cliConfig) {
         return discoverTools(
@@ -216739,6 +216871,7 @@ var init_mcp_client_manager = __esm({
   "packages/core/src/tools/mcp-client-manager.ts"() {
     "use strict";
     init_esbuild_shims();
+    init_config3();
     init_mcp_client();
     init_errors();
     McpClientManager = class {
@@ -216754,7 +216887,8 @@ var init_mcp_client_manager = __esm({
       workspaceContext;
       discoveryState = "not_started" /* NOT_STARTED */;
       eventEmitter;
-      constructor(mcpServers, mcpServerCommand, toolRegistry, promptRegistry, debugMode, workspaceContext, eventEmitter) {
+      sendSdkMcpMessage;
+      constructor(mcpServers, mcpServerCommand, toolRegistry, promptRegistry, debugMode, workspaceContext, eventEmitter, sendSdkMcpMessage) {
         this.mcpServers = mcpServers;
         this.mcpServerCommand = mcpServerCommand;
         this.toolRegistry = toolRegistry;
@@ -216762,6 +216896,7 @@ var init_mcp_client_manager = __esm({
         this.debugMode = debugMode;
         this.workspaceContext = workspaceContext;
         this.eventEmitter = eventEmitter;
+        this.sendSdkMcpMessage = sendSdkMcpMessage;
       }
       /**
        * Initiates the tool discovery process for all configured MCP servers.
@@ -216781,13 +216916,15 @@ var init_mcp_client_manager = __esm({
         this.eventEmitter?.emit("mcp-client-update", this.clients);
         const discoveryPromises = Object.entries(servers).map(
           async ([name3, config2]) => {
+            const sdkCallback = isSdkMcpServerConfig(config2) ? this.sendSdkMcpMessage : void 0;
             const client = new McpClient(
               name3,
               config2,
               this.toolRegistry,
               this.promptRegistry,
               this.workspaceContext,
-              this.debugMode
+              this.debugMode,
+              sdkCallback
             );
             this.clients.set(name3, client);
             this.eventEmitter?.emit("mcp-client-update", this.clients);
@@ -216974,7 +217111,7 @@ Signal: Signal number or \`(none)\` if no signal was received.
       tools = /* @__PURE__ */ new Map();
       config;
       mcpClientManager;
-      constructor(config2, eventEmitter) {
+      constructor(config2, eventEmitter, sendSdkMcpMessage) {
         this.config = config2;
         this.mcpClientManager = new McpClientManager(
           this.config.getMcpServers() ?? {},
@@ -216983,7 +217120,8 @@ Signal: Signal number or \`(none)\` if no signal was received.
           this.config.getPromptRegistry(),
           this.config.getDebugMode(),
           this.config.getWorkspaceContext(),
-          eventEmitter
+          eventEmitter,
+          sendSdkMcpMessage
         );
       }
       /**
@@ -225625,6 +225763,9 @@ var init_workspaceContext = __esm({
 import * as path54 from "node:path";
 import process12 from "node:process";
 import { randomUUID as randomUUID6 } from "node:crypto";
+function isSdkMcpServerConfig(config2) {
+  return config2.type === "sdk";
+}
 function normalizeConfigOutputFormat(format4) {
   if (!format4) {
     return void 0;
@@ -225723,7 +225864,7 @@ var init_config3 = __esm({
     DEFAULT_TRUNCATE_TOOL_OUTPUT_THRESHOLD = 25e3;
     DEFAULT_TRUNCATE_TOOL_OUTPUT_LINES = 1e3;
     MCPServerConfig = class {
-      constructor(command2, args, env7, cwd7, url3, httpUrl, headers, tcp, timeout2, trust, description, includeTools, excludeTools, extensionName, oauth, authProviderType, targetAudience, targetServiceAccount) {
+      constructor(command2, args, env7, cwd7, url3, httpUrl, headers, tcp, timeout2, trust, description, includeTools, excludeTools, extensionName, oauth, authProviderType, targetAudience, targetServiceAccount, type) {
         this.command = command2;
         this.args = args;
         this.env = env7;
@@ -225742,11 +225883,13 @@ var init_config3 = __esm({
         this.authProviderType = authProviderType;
         this.targetAudience = targetAudience;
         this.targetServiceAccount = targetServiceAccount;
+        this.type = type;
       }
       static {
         __name(this, "MCPServerConfig");
       }
     };
+    __name(isSdkMcpServerConfig, "isSdkMcpServerConfig");
     AuthProviderType = /* @__PURE__ */ ((AuthProviderType2) => {
       AuthProviderType2["DYNAMIC_DISCOVERY"] = "dynamic_discovery";
       AuthProviderType2["GOOGLE_CREDENTIALS"] = "google_credentials";
@@ -225963,8 +226106,9 @@ var init_config3 = __esm({
       }
       /**
        * Must only be called once, throws if called again.
+       * @param options Optional initialization options including sendSdkMcpMessage callback
        */
-      async initialize() {
+      async initialize(options2) {
         if (this.initialized) {
           throw Error("Config was already initialized");
         }
@@ -225978,7 +226122,9 @@ var init_config3 = __esm({
         if (this.sessionSubagents.length > 0) {
           this.subagentManager.loadSessionSubagents(this.sessionSubagents);
         }
-        this.toolRegistry = await this.createToolRegistry();
+        this.toolRegistry = await this.createToolRegistry(
+          options2?.sendSdkMcpMessage
+        );
         await this.geminiClient.initialize();
         logStartSession(this, new StartSessionEvent(this));
       }
@@ -226447,8 +226593,12 @@ var init_config3 = __esm({
       getSubagentManager() {
         return this.subagentManager;
       }
-      async createToolRegistry() {
-        const registry2 = new ToolRegistry(this, this.eventEmitter);
+      async createToolRegistry(sendSdkMcpMessage) {
+        const registry2 = new ToolRegistry(
+          this,
+          this.eventEmitter,
+          sendSdkMcpMessage
+        );
         const coreToolsConfig = this.getCoreTools();
         const excludeToolsConfig = this.getExcludeTools();
         const registerCoreTool = /* @__PURE__ */ __name((ToolClass, ...args) => {
@@ -226519,6 +226669,7 @@ var init_config3 = __esm({
           registerCoreTool(WebSearchTool, this);
         }
         await registry2.discoverAllTools();
+        console.debug("ToolRegistry created", registry2.getAllToolNames());
         return registry2;
       }
     };
@@ -235631,7 +235782,9 @@ var init_src2 = __esm({
     init_read_many_files();
     init_read_knowledge_ext();
     init_mcp_client();
+    init_mcp_client_manager();
     init_mcp_tool();
+    init_sdk_control_client_transport();
     init_task();
     init_todoWrite();
     init_exitPlanMode();
@@ -235778,8 +235931,8 @@ var init_git_commit = __esm({
   "packages/core/src/generated/git-commit.ts"() {
     "use strict";
     init_esbuild_shims();
-    GIT_COMMIT_INFO = "72a170b5";
-    CLI_VERSION = "0.1.3-alpha.6";
+    GIT_COMMIT_INFO = "aeac6827";
+    CLI_VERSION = "0.1.3";
   }
 });
 
@@ -236781,6 +236934,7 @@ __export(core_exports4, {
   MUTATOR_KINDS: () => MUTATOR_KINDS,
   MarkdownParser: () => MarkdownParser,
   McpClient: () => McpClient,
+  McpClientManager: () => McpClientManager,
   MemoryMetricType: () => MemoryMetricType,
   MemoryTool: () => MemoryTool,
   MessageSenderType: () => MessageSenderType,
@@ -236817,6 +236971,7 @@ __export(core_exports4, {
   SUPPORTED_IMAGE_MIME_TYPES: () => SUPPORTED_IMAGE_MIME_TYPES,
   SYSTEM_FILE_EXCLUDES: () => SYSTEM_FILE_EXCLUDES,
   SchemaValidator: () => SchemaValidator,
+  SdkControlClientTransport: () => SdkControlClientTransport,
   SemanticAttributes: () => SemanticAttributes,
   SessionService: () => SessionService,
   ShellExecutionService: () => ShellExecutionService,
@@ -236976,6 +237131,7 @@ __export(core_exports4, {
   isQwenQuotaExceededError: () => isQwenQuotaExceededError,
   isQwenThrottlingError: () => isQwenThrottlingError,
   isSchemaDepthError: () => isSchemaDepthError,
+  isSdkMcpServerConfig: () => isSdkMcpServerConfig,
   isStructuredError: () => isStructuredError,
   isSubpath: () => isSubpath,
   isSupportedImageMimeType: () => isSupportedImageMimeType,
@@ -346248,7 +346404,7 @@ __name(getPackageJson, "getPackageJson");
 // packages/cli/src/utils/version.ts
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "0.1.3-alpha.6";
+  return "0.1.3";
 }
 __name(getCliVersion, "getCliVersion");
 
@@ -352615,7 +352771,7 @@ var formatDuration = /* @__PURE__ */ __name((milliseconds) => {
 
 // packages/cli/src/generated/git-commit.ts
 init_esbuild_shims();
-var GIT_COMMIT_INFO2 = "72a170b5";
+var GIT_COMMIT_INFO2 = "aeac6827";
 
 // packages/cli/src/utils/systemInfo.ts
 async function getNpmVersion() {
@@ -355464,21 +355620,17 @@ This is a **NON-NEGOTIABLE** requirement. Even if the user writes in English, sa
 
 **Tool outputs**: All descriptive text from \`read_file\`, \`write_file\`, \`codebase_search\`, \`run_terminal_cmd\`, \`todo_write\`, \`web_search\`, etc. MUST be in ${language}.
 
-**Thinking/Thoughts content**: If the model supports thinking mode or generates thoughts, ALL thinking and reasoning content MUST also be in ${language}. This applies to internal reasoning, thought processes, and any cognitive steps displayed to the user.
-
 ## Examples
 
 ### \u2705 CORRECT:
 - User says "hi" \u2192 Respond in ${language} (e.g., "Bonjour" if ${language} is French)
 - Tool result \u2192 "\u5DF2\u6210\u529F\u8BFB\u53D6\u6587\u4EF6 config.json" (if ${language} is Chinese)
 - Error \u2192 "\u65E0\u6CD5\u627E\u5230\u6307\u5B9A\u7684\u6587\u4EF6" (if ${language} is Chinese)
-- Thinking content \u2192 "\u6211\u6B63\u5728\u5206\u6790\u7528\u6237\u7684\u95EE\u9898..." (if ${language} is Chinese)
 
 ### \u274C WRONG:
 - User says "hi" \u2192 "Hello" in English
 - Tool result \u2192 "Successfully read file" in English
 - Error \u2192 "File not found" in English
-- Thinking content \u2192 "I'm analyzing the user's question..." in English
 
 ## Notes
 
@@ -362133,11 +362285,30 @@ var BaseController = class {
    * Send an outgoing control request to SDK
    *
    * Manages lifecycle: register -> send -> wait for response -> deregister
+   * Respects the provided AbortSignal for cancellation.
    */
-  async sendControlRequest(payload, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
+  async sendControlRequest(payload, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS, signal) {
+    if (signal?.aborted) {
+      throw new Error("Request aborted");
+    }
     const requestId = randomUUID9();
     return new Promise((resolve26, reject) => {
+      const abortHandler = /* @__PURE__ */ __name(() => {
+        this.registry.deregisterOutgoingRequest(requestId);
+        reject(new Error("Request aborted"));
+        if (this.context.debugMode) {
+          console.error(
+            `[${this.controllerName}] Outgoing request aborted: ${requestId}`
+          );
+        }
+      }, "abortHandler");
+      if (signal) {
+        signal.addEventListener("abort", abortHandler, { once: true });
+      }
       const timeoutId = setTimeout(() => {
+        if (signal) {
+          signal.removeEventListener("abort", abortHandler);
+        }
         this.registry.deregisterOutgoingRequest(requestId);
         reject(new Error("Control request timeout"));
         if (this.context.debugMode) {
@@ -362146,11 +362317,23 @@ var BaseController = class {
           );
         }
       }, timeoutMs);
+      const wrappedResolve = /* @__PURE__ */ __name((response) => {
+        if (signal) {
+          signal.removeEventListener("abort", abortHandler);
+        }
+        resolve26(response);
+      }, "wrappedResolve");
+      const wrappedReject = /* @__PURE__ */ __name((error2) => {
+        if (signal) {
+          signal.removeEventListener("abort", abortHandler);
+        }
+        reject(error2);
+      }, "wrappedReject");
       this.registry.registerOutgoingRequest(
         requestId,
         this.controllerName,
-        resolve26,
-        reject,
+        wrappedResolve,
+        wrappedReject,
         timeoutId
       );
       const request4 = {
@@ -362161,6 +362344,9 @@ var BaseController = class {
       try {
         this.context.streamJson.send(request4);
       } catch (error2) {
+        if (signal) {
+          signal.removeEventListener("abort", abortHandler);
+        }
         this.registry.deregisterOutgoingRequest(requestId);
         reject(error2);
       }
@@ -362174,6 +362360,7 @@ var BaseController = class {
 };
 
 // packages/cli/src/nonInteractive/control/controllers/systemController.ts
+init_core4();
 var SystemController = class extends BaseController {
   static {
     __name(this, "SystemController");
@@ -362181,16 +362368,25 @@ var SystemController = class extends BaseController {
   /**
    * Handle system control requests
    */
-  async handleRequestPayload(payload, _signal) {
+  async handleRequestPayload(payload, signal) {
+    if (signal.aborted) {
+      throw new Error("Request aborted");
+    }
     switch (payload.subtype) {
       case "initialize":
-        return this.handleInitialize(payload);
+        return this.handleInitialize(
+          payload,
+          signal
+        );
       case "interrupt":
         return this.handleInterrupt();
       case "set_model":
-        return this.handleSetModel(payload);
+        return this.handleSetModel(
+          payload,
+          signal
+        );
       case "supported_commands":
-        return this.handleSupportedCommands();
+        return this.handleSupportedCommands(signal);
       default:
         throw new Error(`Unsupported request subtype in SystemController`);
     }
@@ -362198,41 +362394,108 @@ var SystemController = class extends BaseController {
   /**
    * Handle initialize request
    *
-   * Registers SDK MCP servers and returns capabilities
+   * Processes SDK MCP servers config.
+   * SDK servers are registered in context.sdkMcpServers
+   * and added to config.mcpServers with the sdk type flag.
+   * External MCP servers are configured separately in settings.
    */
-  async handleInitialize(payload) {
+  async handleInitialize(payload, signal) {
+    if (signal.aborted) {
+      throw new Error("Request aborted");
+    }
     this.context.config.setSdkMode(true);
-    if (payload.sdkMcpServers && typeof payload.sdkMcpServers === "object") {
-      for (const serverName of Object.keys(payload.sdkMcpServers)) {
-        this.context.sdkMcpServers.add(serverName);
+    if (payload.sdkMcpServers && typeof payload.sdkMcpServers === "object" && payload.sdkMcpServers !== null) {
+      const sdkServers = {};
+      for (const [key, wireConfig] of Object.entries(payload.sdkMcpServers)) {
+        const name3 = typeof wireConfig?.name === "string" && wireConfig.name.trim().length ? wireConfig.name : key;
+        this.context.sdkMcpServers.add(name3);
+        sdkServers[name3] = new MCPServerConfig(
+          void 0,
+          // command
+          void 0,
+          // args
+          void 0,
+          // env
+          void 0,
+          // cwd
+          void 0,
+          // url
+          void 0,
+          // httpUrl
+          void 0,
+          // headers
+          void 0,
+          // tcp
+          void 0,
+          // timeout
+          true,
+          // trust - SDK servers are trusted
+          void 0,
+          // description
+          void 0,
+          // includeTools
+          void 0,
+          // excludeTools
+          void 0,
+          // extensionName
+          void 0,
+          // oauth
+          void 0,
+          // authProviderType
+          void 0,
+          // targetAudience
+          void 0,
+          // targetServiceAccount
+          "sdk"
+          // type
+        );
       }
-      try {
-        this.context.config.addMcpServers(payload.sdkMcpServers);
-        if (this.context.debugMode) {
-          console.error(
-            `[SystemController] Added ${Object.keys(payload.sdkMcpServers).length} SDK MCP servers to config`
-          );
-        }
-      } catch (error2) {
-        if (this.context.debugMode) {
-          console.error(
-            "[SystemController] Failed to add SDK MCP servers:",
-            error2
-          );
+      const sdkServerCount = Object.keys(sdkServers).length;
+      if (sdkServerCount > 0) {
+        try {
+          this.context.config.addMcpServers(sdkServers);
+          if (this.context.debugMode) {
+            console.error(
+              `[SystemController] Added ${sdkServerCount} SDK MCP servers to config`
+            );
+          }
+        } catch (error2) {
+          if (this.context.debugMode) {
+            console.error(
+              "[SystemController] Failed to add SDK MCP servers:",
+              error2
+            );
+          }
         }
       }
     }
-    if (payload.mcpServers && typeof payload.mcpServers === "object") {
-      try {
-        this.context.config.addMcpServers(payload.mcpServers);
-        if (this.context.debugMode) {
-          console.error(
-            `[SystemController] Added ${Object.keys(payload.mcpServers).length} MCP servers to config`
-          );
+    if (payload.mcpServers && typeof payload.mcpServers === "object" && payload.mcpServers !== null) {
+      const externalServers = {};
+      for (const [name3, serverConfig] of Object.entries(payload.mcpServers)) {
+        const normalized2 = this.normalizeMcpServerConfig(
+          name3,
+          serverConfig
+        );
+        if (normalized2) {
+          externalServers[name3] = normalized2;
         }
-      } catch (error2) {
-        if (this.context.debugMode) {
-          console.error("[SystemController] Failed to add MCP servers:", error2);
+      }
+      const externalCount = Object.keys(externalServers).length;
+      if (externalCount > 0) {
+        try {
+          this.context.config.addMcpServers(externalServers);
+          if (this.context.debugMode) {
+            console.error(
+              `[SystemController] Added ${externalCount} external MCP servers to config`
+            );
+          }
+        } catch (error2) {
+          if (this.context.debugMode) {
+            console.error(
+              "[SystemController] Failed to add external MCP servers:",
+              error2
+            );
+          }
         }
       }
     }
@@ -362277,11 +362540,80 @@ var SystemController = class extends BaseController {
       can_handle_hook_callback: false,
       can_set_permission_mode: typeof this.context.config.setApprovalMode === "function",
       can_set_model: typeof this.context.config.setModel === "function",
-      /* TODO: sdkMcpServers support */
-      can_handle_mcp_message: false
+      // SDK MCP servers are supported - messages routed through control plane
+      can_handle_mcp_message: true
     };
     return capabilities;
   }
+  normalizeMcpServerConfig(serverName, config2) {
+    if (!config2 || typeof config2 !== "object") {
+      if (this.context.debugMode) {
+        console.error(
+          `[SystemController] Ignoring invalid MCP server config for '${serverName}'`
+        );
+      }
+      return null;
+    }
+    const authProvider = this.normalizeAuthProviderType(
+      config2.authProviderType
+    );
+    const oauthConfig = this.normalizeOAuthConfig(config2.oauth);
+    return new MCPServerConfig(
+      config2.command,
+      config2.args,
+      config2.env,
+      config2.cwd,
+      config2.url,
+      config2.httpUrl,
+      config2.headers,
+      config2.tcp,
+      config2.timeout,
+      config2.trust,
+      config2.description,
+      config2.includeTools,
+      config2.excludeTools,
+      config2.extensionName,
+      oauthConfig,
+      authProvider,
+      config2.targetAudience,
+      config2.targetServiceAccount
+    );
+  }
+  normalizeAuthProviderType(value) {
+    if (!value) {
+      return void 0;
+    }
+    switch (value) {
+      case "dynamic_discovery" /* DYNAMIC_DISCOVERY */:
+      case "google_credentials" /* GOOGLE_CREDENTIALS */:
+      case "service_account_impersonation" /* SERVICE_ACCOUNT_IMPERSONATION */:
+        return value;
+      default:
+        if (this.context.debugMode) {
+          console.error(
+            `[SystemController] Unsupported authProviderType '${value}', skipping`
+          );
+        }
+        return void 0;
+    }
+  }
+  normalizeOAuthConfig(oauth) {
+    if (!oauth) {
+      return void 0;
+    }
+    return {
+      enabled: oauth.enabled,
+      clientId: oauth.clientId,
+      clientSecret: oauth.clientSecret,
+      authorizationUrl: oauth.authorizationUrl,
+      tokenUrl: oauth.tokenUrl,
+      scopes: oauth.scopes,
+      audiences: oauth.audiences,
+      redirectUri: oauth.redirectUri,
+      tokenParamName: oauth.tokenParamName,
+      registrationUrl: oauth.registrationUrl
+    };
+  }
   /**
    * Handle interrupt request
    *
@@ -362306,7 +362638,10 @@ var SystemController = class extends BaseController {
    *
    * Implements actual model switching with validation and error handling
    */
-  async handleSetModel(payload) {
+  async handleSetModel(payload, signal) {
+    if (signal.aborted) {
+      throw new Error("Request aborted");
+    }
     const model = payload.model;
     if (typeof model !== "string" || model.trim() === "") {
       throw new Error("Invalid model specified for set_model request");
@@ -362336,8 +362671,11 @@ var SystemController = class extends BaseController {
    *
    * Returns list of supported slash commands loaded dynamically
    */
-  async handleSupportedCommands() {
-    const slashCommands = await this.loadSlashCommandNames();
+  async handleSupportedCommands(signal) {
+    if (signal.aborted) {
+      throw new Error("Request aborted");
+    }
+    const slashCommands = await this.loadSlashCommandNames(signal);
     return {
       subtype: "supported_commands",
       commands: slashCommands
@@ -362346,15 +362684,21 @@ var SystemController = class extends BaseController {
   /**
    * Load slash command names using CommandService
    *
+   * @param signal - AbortSignal to respect for cancellation
    * @returns Promise resolving to array of slash command names
    */
-  async loadSlashCommandNames() {
-    const controller = new AbortController();
+  async loadSlashCommandNames(signal) {
+    if (signal.aborted) {
+      return [];
+    }
     try {
       const service = await CommandService.create(
         [new BuiltinCommandLoader(this.context.config)],
-        controller.signal
+        signal
       );
+      if (signal.aborted) {
+        return [];
+      }
       const names = /* @__PURE__ */ new Set();
       const commands = service.getCommands();
       for (const command2 of commands) {
@@ -362362,6 +362706,9 @@ var SystemController = class extends BaseController {
       }
       return Array.from(names).sort();
     } catch (error2) {
+      if (signal.aborted) {
+        return [];
+      }
       if (this.context.debugMode) {
         console.error(
           "[SystemController] Failed to load slash commands:",
@@ -362369,8 +362716,6 @@ var SystemController = class extends BaseController {
         );
       }
       return [];
-    } finally {
-      controller.abort();
     }
   }
 };
@@ -362386,13 +362731,20 @@ var PermissionController = class extends BaseController {
   /**
    * Handle permission control requests
    */
-  async handleRequestPayload(payload, _signal) {
+  async handleRequestPayload(payload, signal) {
+    if (signal.aborted) {
+      throw new Error("Request aborted");
+    }
     switch (payload.subtype) {
       case "can_use_tool":
-        return this.handleCanUseTool(payload);
+        return this.handleCanUseTool(
+          payload,
+          signal
+        );
       case "set_permission_mode":
         return this.handleSetPermissionMode(
-          payload
+          payload,
+          signal
         );
       default:
         throw new Error(`Unsupported request subtype in PermissionController`);
@@ -362406,7 +362758,10 @@ var PermissionController = class extends BaseController {
    * - Tool registry validation
    * - Error handling with safe defaults
    */
-  async handleCanUseTool(payload) {
+  async handleCanUseTool(payload, signal) {
+    if (signal.aborted) {
+      throw new Error("Request aborted");
+    }
     const toolName = payload.tool_name;
     if (!toolName || typeof toolName !== "string" || toolName.trim().length === 0) {
       return {
@@ -362493,7 +362848,10 @@ var PermissionController = class extends BaseController {
    *
    * Updates the permission mode in the context
    */
-  async handleSetPermissionMode(payload) {
+  async handleSetPermissionMode(payload, signal) {
+    if (signal.aborted) {
+      throw new Error("Request aborted");
+    }
     const mode = payload.mode;
     const validModes = [
       "default",
@@ -362641,6 +362999,12 @@ var PermissionController = class extends BaseController {
    */
   async handleOutgoingPermissionRequest(toolCall) {
     try {
+      if (this.context.abortSignal?.aborted) {
+        await toolCall.confirmationDetails.onConfirm(
+          "cancel" /* Cancel */
+        );
+        return;
+      }
       const inputFormat = this.context.config.getInputFormat?.();
       const isStreamJsonMode = inputFormat === "stream-json" /* STREAM_JSON */;
       if (!isStreamJsonMode) {
@@ -362652,14 +363016,19 @@ var PermissionController = class extends BaseController {
       const permissionSuggestions = this.buildPermissionSuggestions(
         toolCall.confirmationDetails
       );
-      const response = await this.sendControlRequest({
-        subtype: "can_use_tool",
-        tool_name: toolCall.request.name,
-        tool_use_id: toolCall.request.callId,
-        input: toolCall.request.args,
-        permission_suggestions: permissionSuggestions,
-        blocked_path: null
-      });
+      const response = await this.sendControlRequest(
+        {
+          subtype: "can_use_tool",
+          tool_name: toolCall.request.name,
+          tool_use_id: toolCall.request.callId,
+          input: toolCall.request.args,
+          permission_suggestions: permissionSuggestions,
+          blocked_path: null
+        },
+        void 0,
+        // use default timeout
+        this.context.abortSignal
+      );
       if (response.subtype !== "success") {
         await toolCall.confirmationDetails.onConfirm(
           "cancel" /* Cancel */
@@ -362708,6 +363077,98 @@ var PermissionController = class extends BaseController {
   }
 };
 
+// packages/cli/src/nonInteractive/control/controllers/sdkMcpController.ts
+init_esbuild_shims();
+var MCP_REQUEST_TIMEOUT = 3e4;
+var SdkMcpController = class extends BaseController {
+  static {
+    __name(this, "SdkMcpController");
+  }
+  /**
+   * Handle SDK MCP control requests from ControlDispatcher
+   *
+   * Note: mcp_message requests are NOT handled here. CLI MCP clients
+   * send messages via the sendSdkMcpMessage callback directly, not
+   * through the control dispatcher.
+   */
+  async handleRequestPayload(payload, signal) {
+    if (signal.aborted) {
+      throw new Error("Request aborted");
+    }
+    switch (payload.subtype) {
+      case "mcp_server_status":
+        return this.handleMcpStatus();
+      default:
+        throw new Error(`Unsupported request subtype in SdkMcpController`);
+    }
+  }
+  /**
+   * Handle mcp_server_status request
+   *
+   * Returns status of all registered SDK MCP servers.
+   * SDK servers are considered "connected" if they are registered.
+   */
+  async handleMcpStatus() {
+    const status = {};
+    for (const serverName of this.context.sdkMcpServers) {
+      status[serverName] = "connected";
+    }
+    return {
+      subtype: "mcp_server_status",
+      status
+    };
+  }
+  /**
+   * Send MCP message to SDK server via control plane
+   *
+   * @param serverName - Name of the SDK MCP server
+   * @param message - MCP JSON-RPC message to send
+   * @returns MCP JSON-RPC response from SDK server
+   */
+  async sendMcpMessageToSdk(serverName, message) {
+    if (this.context.debugMode) {
+      console.error(
+        `[SdkMcpController] Sending MCP message to SDK server '${serverName}':`,
+        JSON.stringify(message)
+      );
+    }
+    const response = await this.sendControlRequest(
+      {
+        subtype: "mcp_message",
+        server_name: serverName,
+        message
+      },
+      MCP_REQUEST_TIMEOUT,
+      this.context.abortSignal
+    );
+    const responsePayload = response.response;
+    const mcpResponse = responsePayload?.["mcp_response"];
+    if (!mcpResponse) {
+      throw new Error(
+        `Invalid MCP response from SDK for server '${serverName}'`
+      );
+    }
+    if (this.context.debugMode) {
+      console.error(
+        `[SdkMcpController] Received MCP response from SDK server '${serverName}':`,
+        JSON.stringify(mcpResponse)
+      );
+    }
+    return mcpResponse;
+  }
+  /**
+   * Create a callback function for sending MCP messages to SDK servers.
+   *
+   * This callback is used by McpClientManager/SdkControlClientTransport to send
+   * MCP messages from CLI MCP clients to SDK MCP servers via the control plane.
+   *
+   * @returns A function that sends MCP messages to SDK and returns the response
+   */
+  createSendSdkMcpMessage() {
+    return (serverName, message) => this.sendMcpMessageToSdk(serverName, message);
+  }
+};
+
 // packages/cli/src/nonInteractive/control/ControlDispatcher.ts
 var ControlDispatcher = class {
   static {
@@ -362717,7 +363178,7 @@ var ControlDispatcher = class {
   // Make controllers publicly accessible
   systemController;
   permissionController;
-  // readonly mcpController: MCPController;
+  sdkMcpController;
   // readonly hookController: HookController;
   // Central pending request registries
   pendingIncomingRequests = /* @__PURE__ */ new Map();
@@ -362734,6 +363195,11 @@ var ControlDispatcher = class {
       this,
       "PermissionController"
     );
+    this.sdkMcpController = new SdkMcpController(
+      context2,
+      this,
+      "SdkMcpController"
+    );
     this.context.abortSignal.addEventListener("abort", () => {
       this.shutdown();
     });
@@ -362839,6 +363305,7 @@ var ControlDispatcher = class {
     this.pendingOutgoingRequests.clear();
     this.systemController.cleanup();
     this.permissionController.cleanup();
+    this.sdkMcpController.cleanup();
   }
   /**
    * Registers an incoming request in the pending registry
@@ -362881,6 +363348,40 @@ var ControlDispatcher = class {
       this.pendingOutgoingRequests.delete(requestId);
     }
   }
+  /**
+   * Get count of pending incoming requests (for debugging)
+   */
+  getPendingIncomingRequestCount() {
+    return this.pendingIncomingRequests.size;
+  }
+  /**
+   * Wait for all incoming request handlers to complete.
+   *
+   * Uses polling since we don't have direct Promise references to handlers.
+   * The pendingIncomingRequests map is managed by BaseController:
+   * - Registered when handler starts (in handleRequest)
+   * - Deregistered when handler completes (success or error)
+   *
+   * @param pollIntervalMs - How often to check (default 50ms)
+   * @param timeoutMs - Maximum wait time (default 30s)
+   */
+  async waitForPendingIncomingRequests(pollIntervalMs = 50, timeoutMs = 3e4) {
+    const startTime = Date.now();
+    while (this.pendingIncomingRequests.size > 0) {
+      if (Date.now() - startTime > timeoutMs) {
+        if (this.context.debugMode) {
+          console.error(
+            `[ControlDispatcher] Timeout waiting for ${this.pendingIncomingRequests.size} pending incoming requests`
+          );
+        }
+        break;
+      }
+      await new Promise((resolve26) => setTimeout(resolve26, pollIntervalMs));
+    }
+    if (this.context.debugMode && this.pendingIncomingRequests.size === 0) {
+      console.error("[ControlDispatcher] All incoming requests completed");
+    }
+  }
   /**
    * Returns the controller that handles the given request subtype
    */
@@ -362894,9 +363395,8 @@ var ControlDispatcher = class {
       case "can_use_tool":
       case "set_permission_mode":
         return this.permissionController;
-      // case 'mcp_message':
-      // case 'mcp_server_status':
-      //   return this.mcpController;
+      case "mcp_server_status":
+        return this.sdkMcpController;
       // case 'hook_callback':
       //   return this.hookController;
       default:
@@ -363175,6 +363675,11 @@ var Session2 = class {
   processingPromise = null;
   isShuttingDown = false;
   configInitialized = false;
+  // Single initialization promise that resolves when session is ready for user messages.
+  // Created lazily once initialization actually starts.
+  initializationPromise = null;
+  initializationResolve = null;
+  initializationReject = null;
   constructor(config2, initialPrompt) {
     this.config = config2;
     this.sessionId = config2.getSessionId();
@@ -363188,11 +363693,28 @@ var Session2 = class {
     );
     this.setupSignalHandlers();
   }
+  ensureInitializationPromise() {
+    if (this.initializationPromise) {
+      return;
+    }
+    this.initializationPromise = new Promise((resolve26, reject) => {
+      this.initializationResolve = () => {
+        resolve26();
+        this.initializationResolve = null;
+        this.initializationReject = null;
+      };
+      this.initializationReject = (error2) => {
+        reject(error2);
+        this.initializationResolve = null;
+        this.initializationReject = null;
+      };
+    });
+  }
   getNextPromptId() {
     this.promptIdCounter++;
     return `${this.sessionId}########${this.promptIdCounter}`;
   }
-  async ensureConfigInitialized() {
+  async ensureConfigInitialized(options2) {
     if (this.configInitialized) {
       return;
     }
@@ -363200,7 +363722,7 @@ var Session2 = class {
       console.error("[Session] Initializing config");
     }
     try {
-      await this.config.initialize();
+      await this.config.initialize(options2);
       this.configInitialized = true;
     } catch (error2) {
       if (this.debugMode) {
@@ -363209,6 +363731,41 @@ var Session2 = class {
       throw error2;
     }
   }
+  /**
+   * Mark initialization as complete
+   */
+  completeInitialization() {
+    if (this.initializationResolve) {
+      if (this.debugMode) {
+        console.error("[Session] Initialization complete");
+      }
+      this.initializationResolve();
+      this.initializationResolve = null;
+      this.initializationReject = null;
+    }
+  }
+  /**
+   * Mark initialization as failed
+   */
+  failInitialization(error2) {
+    if (this.initializationReject) {
+      if (this.debugMode) {
+        console.error("[Session] Initialization failed:", error2);
+      }
+      this.initializationReject(error2);
+      this.initializationResolve = null;
+      this.initializationReject = null;
+    }
+  }
+  /**
+   * Wait for session to be ready for user messages
+   */
+  async waitForInitialization() {
+    if (!this.initializationPromise) {
+      return;
+    }
+    await this.initializationPromise;
+  }
   ensureControlSystem() {
     if (this.controlContext && this.dispatcher && this.controlService) {
       return;
@@ -363236,33 +363793,81 @@ var Session2 = class {
     }
     return this.dispatcher;
   }
-  async handleFirstMessage(message) {
+  /**
+   * Handle the first message to determine session mode (SDK vs direct).
+   * This is synchronous from the message loop's perspective - it starts
+   * async work but does not return a promise that the loop awaits.
+   *
+   * The initialization completes asynchronously and resolves initializationPromise
+   * when ready for user messages.
+   */
+  handleFirstMessage(message) {
     if (isControlRequest(message)) {
       const request4 = message;
       this.controlSystemEnabled = true;
       this.ensureControlSystem();
       if (request4.request.subtype === "initialize") {
-        await this.dispatcher?.dispatch(request4);
-        await this.ensureConfigInitialized();
-        return true;
+        void this.initializeSdkMode(request4);
+        return;
       }
       if (this.debugMode) {
         console.error(
           "[Session] Ignoring non-initialize control request during initialization"
         );
       }
-      return true;
+      return;
     }
     if (isCLIUserMessage(message)) {
       this.controlSystemEnabled = false;
-      await this.ensureConfigInitialized();
-      this.enqueueUserMessage(message);
-      return true;
+      void this.initializeDirectMode(message);
+      return;
     }
     this.controlSystemEnabled = false;
-    return false;
   }
-  async handleControlRequest(request4) {
+  /**
+   * SDK mode initialization flow
+   * Dispatches initialize request and initializes config with MCP support
+   */
+  async initializeSdkMode(request4) {
+    this.ensureInitializationPromise();
+    try {
+      await this.dispatcher?.dispatch(request4);
+      const sendSdkMcpMessage = this.dispatcher?.sdkMcpController.createSendSdkMcpMessage();
+      await this.ensureConfigInitialized({ sendSdkMcpMessage });
+      this.completeInitialization();
+    } catch (error2) {
+      if (this.debugMode) {
+        console.error("[Session] SDK mode initialization failed:", error2);
+      }
+      this.failInitialization(
+        error2 instanceof Error ? error2 : new Error(String(error2))
+      );
+    }
+  }
+  /**
+   * Direct mode initialization flow
+   * Initializes config and enqueues the first user message
+   */
+  async initializeDirectMode(userMessage) {
+    this.ensureInitializationPromise();
+    try {
+      await this.ensureConfigInitialized();
+      this.completeInitialization();
+      this.enqueueUserMessage(userMessage);
+    } catch (error2) {
+      if (this.debugMode) {
+        console.error("[Session] Direct mode initialization failed:", error2);
+      }
+      this.failInitialization(
+        error2 instanceof Error ? error2 : new Error(String(error2))
+      );
+    }
+  }
+  /**
+   * Handle control request asynchronously (fire-and-forget from main loop).
+   * Errors are handled internally and responses sent by dispatcher.
+   */
+  handleControlRequestAsync(request4) {
     const dispatcher = this.getDispatcher();
     if (!dispatcher) {
       if (this.debugMode) {
@@ -363270,8 +363875,16 @@ var Session2 = class {
       }
       return;
     }
-    await dispatcher.dispatch(request4);
+    void dispatcher.dispatch(request4).catch((error2) => {
+      if (this.debugMode) {
+        console.error("[Session] Control request dispatch error:", error2);
+      }
+    });
   }
+  /**
+   * Handle control response - MUST be synchronous
+   * This resolves pending outgoing requests, breaking the deadlock cycle.
+   */
   handleControlResponse(response) {
     const dispatcher = this.getDispatcher();
     if (!dispatcher) {
@@ -363294,7 +363907,7 @@ var Session2 = class {
       }
       return;
     }
-    await this.ensureConfigInitialized();
+    await this.waitForInitialization();
     const promptId = this.getNextPromptId();
     try {
       await runNonInteractive(
@@ -363374,23 +363987,45 @@ var Session2 = class {
     process.on("SIGINT", this.shutdownHandler);
     process.on("SIGTERM", this.shutdownHandler);
   }
-  async shutdown() {
-    if (this.debugMode) {
-      console.error("[Session] Shutting down");
+  /**
+   * Wait for all pending work to complete before shutdown
+   */
+  async waitForAllPendingWork() {
+    try {
+      await this.waitForInitialization();
+    } catch (error2) {
+      if (this.debugMode) {
+        console.error("[Session] Initialization error during shutdown:", error2);
+      }
     }
-    this.isShuttingDown = true;
-    if (this.processingPromise) {
+    if (this.dispatcher) {
+      const pendingCount = this.dispatcher.getPendingIncomingRequestCount();
+      if (pendingCount > 0 && this.debugMode) {
+        console.error(
+          `[Session] Waiting for ${pendingCount} pending control request handlers`
+        );
+      }
+      await this.dispatcher.waitForPendingIncomingRequests();
+    }
+    while (this.processingPromise) {
+      if (this.debugMode) {
+        console.error("[Session] Waiting for user message processing");
+      }
       try {
         await this.processingPromise;
       } catch (error2) {
         if (this.debugMode) {
-          console.error(
-            "[Session] Error waiting for processing to complete:",
-            error2
-          );
+          console.error("[Session] Error in user message processing:", error2);
         }
       }
     }
+  }
+  async shutdown() {
+    if (this.debugMode) {
+      console.error("[Session] Shutting down");
+    }
+    this.isShuttingDown = true;
+    await this.waitForAllPendingWork();
     this.dispatcher?.shutdown();
     this.cleanupSignalHandlers();
   }
@@ -363401,36 +364036,44 @@ var Session2 = class {
       this.shutdownHandler = null;
     }
   }
+  /**
+   * Main message processing loop
+   *
+   * CRITICAL: This loop must NEVER await handlers that might need to
+   * send control requests and wait for responses. Such handlers must
+   * be started in fire-and-forget mode, allowing the loop to continue
+   * reading responses that resolve pending requests.
+   *
+   * Message handling order:
+   * 1. control_response - FIRST, synchronously resolves pending requests
+   * 2. First message - determines mode, starts async initialization
+   * 3. control_request - fire-and-forget, tracked by dispatcher
+   * 4. control_cancel - synchronous
+   * 5. user_message - enqueued for processing
+   */
   async run() {
     try {
       if (this.debugMode) {
         console.error("[Session] Starting session", this.sessionId);
       }
       if (this.initialPrompt !== null) {
-        const handled = await this.handleFirstMessage(this.initialPrompt);
-        if (handled && this.isShuttingDown) {
-          await this.shutdown();
-          return;
-        }
+        this.handleFirstMessage(this.initialPrompt);
       }
       try {
         for await (const message of this.inputReader.read()) {
           if (this.abortController.signal.aborted) {
             break;
           }
+          if (isControlResponse(message)) {
+            this.handleControlResponse(message);
+            continue;
+          }
           if (this.controlSystemEnabled === null) {
-            const handled = await this.handleFirstMessage(message);
-            if (handled) {
-              if (this.isShuttingDown) {
-                break;
-              }
-              continue;
-            }
+            this.handleFirstMessage(message);
+            continue;
           }
           if (isControlRequest(message)) {
-            await this.handleControlRequest(message);
-          } else if (isControlResponse(message)) {
-            this.handleControlResponse(message);
+            this.handleControlRequestAsync(message);
           } else if (isControlCancel(message)) {
             this.handleControlCancel(message);
           } else if (isCLIUserMessage(message)) {
@@ -363453,18 +364096,7 @@ var Session2 = class {
         }
         throw streamError;
       }
-      while (this.processingPromise) {
-        if (this.debugMode) {
-          console.error("[Session] Waiting for final processing to complete");
-        }
-        try {
-          await this.processingPromise;
-        } catch (error2) {
-          if (this.debugMode) {
-            console.error("[Session] Error in final processing:", error2);
-          }
-        }
-      }
+      await this.waitForAllPendingWork();
       await this.shutdown();
     } catch (error2) {
       if (this.debugMode) {
@@ -407874,7 +408506,7 @@ var GeminiAgent = class {
       name: APPROVAL_MODE_INFO[mode].name,
       description: APPROVAL_MODE_INFO[mode].description
     }));
-    const version3 = "0.1.3-alpha.6";
+    const version3 = "0.1.3";
     return {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {
@@ -408214,8 +408846,9 @@ async function main() {
           process.exit(1);
         }
       }
+      const inputFormat = argv.inputFormat;
       let stdinData = "";
-      if (!process.stdin.isTTY) {
+      if (!process.stdin.isTTY && inputFormat !== "stream-json") {
         stdinData = await readStdin();
       }
       const injectStdinIntoArgs = /* @__PURE__ */ __name((args, stdinData2) => {
@@ -408471,12 +409104,12 @@ main().catch((error2) => {
  */
 /**
  * @license
- * Copyright 2025 RDMind
+ * Copyright 2025 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */
 /**
  * @license
- * Copyright 2025 Qwen Team
+ * Copyright 2025 RDMind
  * SPDX-License-Identifier: Apache-2.0
  */
 /*! Bundled license information: