@anthropic-ai/claude-code 1.0.84 → 1.0.86

package/sdk.mjs

@@ -2,17 +2,14 @@
 
 // (c) Anthropic PBC. All rights reserved. Use is subject to Anthropic's Commercial Terms of Service (https://www.anthropic.com/legal/commercial-terms).
 
-// Version: 1.0.84
+// Version: 1.0.86
 
 // Want to see the unminified source? We're hiring!
 // https://job-boards.greenhouse.io/anthropic/jobs/4816199008
 
 // src/entrypoints/sdk.ts
-import { spawn } from "child_process";
-import { join } from "path";
-import { fileURLToPath } from "url";
-import { createInterface } from "readline";
-import { existsSync } from "fs";
+import { join as join2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/utils/stream.ts
 class Stream {
@@ -97,36 +94,478 @@ function createAbortController(maxListeners = DEFAULT_MAX_LISTENERS) {
   return controller;
 }
 
+// src/transport/ProcessTransport.ts
+import { spawn } from "child_process";
+import { join } from "path";
+import { fileURLToPath } from "url";
+import { createInterface } from "readline";
+
+// src/utils/fsOperations.ts
+import * as fs from "fs";
+import { stat as statPromise } from "fs/promises";
+var NodeFsOperations = {
+  accessSync(fsPath, mode) {
+    fs.accessSync(fsPath, mode);
+  },
+  cwd() {
+    return process.cwd();
+  },
+  chmodSync(fsPath, mode) {
+    fs.chmodSync(fsPath, mode);
+  },
+  existsSync(fsPath) {
+    return fs.existsSync(fsPath);
+  },
+  async stat(fsPath) {
+    return statPromise(fsPath);
+  },
+  statSync(fsPath) {
+    return fs.statSync(fsPath);
+  },
+  readFileSync(fsPath, options) {
+    return fs.readFileSync(fsPath, { encoding: options.encoding });
+  },
+  readFileBytesSync(fsPath) {
+    return fs.readFileSync(fsPath);
+  },
+  readSync(fsPath, options) {
+    let fd = undefined;
+    try {
+      fd = fs.openSync(fsPath, "r");
+      const buffer = Buffer.alloc(options.length);
+      const bytesRead = fs.readSync(fd, buffer, 0, options.length, 0);
+      return { buffer, bytesRead };
+    } finally {
+      if (fd)
+        fs.closeSync(fd);
+    }
+  },
+  writeFileSync(fsPath, data, options) {
+    if (!options.flush) {
+      fs.writeFileSync(fsPath, data, { encoding: options.encoding });
+      return;
+    }
+    let fd;
+    try {
+      fd = fs.openSync(fsPath, "w");
+      fs.writeFileSync(fd, data, { encoding: options.encoding });
+      fs.fsyncSync(fd);
+    } finally {
+      if (fd) {
+        fs.closeSync(fd);
+      }
+    }
+  },
+  appendFileSync(path, data) {
+    fs.appendFileSync(path, data);
+  },
+  copyFileSync(src, dest) {
+    fs.copyFileSync(src, dest);
+  },
+  unlinkSync(path) {
+    fs.unlinkSync(path);
+  },
+  renameSync(oldPath, newPath) {
+    fs.renameSync(oldPath, newPath);
+  },
+  symlinkSync(target, path) {
+    fs.symlinkSync(target, path);
+  },
+  readlinkSync(path) {
+    return fs.readlinkSync(path);
+  },
+  realpathSync(path) {
+    return fs.realpathSync(path);
+  },
+  mkdirSync(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true });
+    }
+  },
+  readdirSync(dirPath) {
+    return fs.readdirSync(dirPath, { withFileTypes: true });
+  },
+  readdirStringSync(dirPath) {
+    return fs.readdirSync(dirPath);
+  },
+  isDirEmptySync(dirPath) {
+    const files = this.readdirSync(dirPath);
+    return files.length === 0;
+  },
+  rmdirSync(dirPath) {
+    fs.rmdirSync(dirPath);
+  },
+  rmSync(path, options) {
+    fs.rmSync(path, options);
+  }
+};
+var activeFs = NodeFsOperations;
+function getFsImplementation() {
+  return activeFs;
+}
+
 // src/entrypoints/sdkTypes.ts
 class AbortError extends Error {
 }
 
+// src/transport/ProcessTransport.ts
+class ProcessTransport {
+  options;
+  child;
+  childStdin;
+  childStdout;
+  ready = false;
+  abortController;
+  exitError;
+  exitListeners = [];
+  processExitHandler;
+  abortHandler;
+  isStreaming;
+  constructor(options) {
+    this.options = options;
+    this.abortController = options.abortController || createAbortController();
+    this.isStreaming = typeof options.prompt !== "string";
+    this.initialize();
+  }
+  initialize() {
+    try {
+      const {
+        prompt,
+        additionalDirectories = [],
+        cwd,
+        executable = this.isRunningWithBun() ? "bun" : "node",
+        executableArgs = [],
+        pathToClaudeCodeExecutable,
+        env = { ...process.env },
+        stderr,
+        customSystemPrompt,
+        appendSystemPrompt,
+        maxTurns,
+        model,
+        fallbackModel,
+        permissionMode,
+        permissionPromptToolName,
+        continueConversation,
+        resume,
+        allowedTools = [],
+        disallowedTools = [],
+        mcpServers,
+        strictMcpConfig,
+        canUseTool
+      } = this.options;
+      const args = ["--output-format", "stream-json", "--verbose"];
+      if (customSystemPrompt)
+        args.push("--system-prompt", customSystemPrompt);
+      if (appendSystemPrompt)
+        args.push("--append-system-prompt", appendSystemPrompt);
+      if (maxTurns)
+        args.push("--max-turns", maxTurns.toString());
+      if (model)
+        args.push("--model", model);
+      if (env.DEBUG)
+        args.push("--debug-to-stderr");
+      if (canUseTool) {
+        if (typeof prompt === "string") {
+          throw new Error("canUseTool callback requires --input-format stream-json. Please set prompt as an AsyncIterable.");
+        }
+        if (permissionPromptToolName) {
+          throw new Error("canUseTool callback cannot be used with permissionPromptToolName. Please use one or the other.");
+        }
+        args.push("--permission-prompt-tool", "stdio");
+      } else if (permissionPromptToolName) {
+        args.push("--permission-prompt-tool", permissionPromptToolName);
+      }
+      if (continueConversation)
+        args.push("--continue");
+      if (resume)
+        args.push("--resume", resume);
+      if (allowedTools.length > 0) {
+        args.push("--allowedTools", allowedTools.join(","));
+      }
+      if (disallowedTools.length > 0) {
+        args.push("--disallowedTools", disallowedTools.join(","));
+      }
+      if (mcpServers && Object.keys(mcpServers).length > 0) {
+        args.push("--mcp-config", JSON.stringify({ mcpServers }));
+      }
+      if (strictMcpConfig) {
+        args.push("--strict-mcp-config");
+      }
+      if (permissionMode && permissionMode !== "default") {
+        args.push("--permission-mode", permissionMode);
+      }
+      if (fallbackModel) {
+        if (model && fallbackModel === model) {
+          throw new Error("Fallback model cannot be the same as the main model. Please specify a different model for fallbackModel option.");
+        }
+        args.push("--fallback-model", fallbackModel);
+      }
+      if (typeof prompt === "string") {
+        args.push("--print");
+        args.push("--", prompt.trim());
+      } else {
+        args.push("--input-format", "stream-json");
+      }
+      for (const dir of additionalDirectories) {
+        args.push("--add-dir", dir);
+      }
+      if (!env.CLAUDE_CODE_ENTRYPOINT) {
+        env.CLAUDE_CODE_ENTRYPOINT = "sdk-ts";
+      }
+      const claudeCodePath = pathToClaudeCodeExecutable || this.getDefaultExecutablePath();
+      const fs2 = getFsImplementation();
+      if (!fs2.existsSync(claudeCodePath)) {
+        throw new Error(`Claude Code executable not found at ${claudeCodePath}. Is options.pathToClaudeCodeExecutable set?`);
+      }
+      this.logDebug(`Spawning Claude Code process: ${executable} ${[...executableArgs, claudeCodePath, ...args].join(" ")}`);
+      const stderrMode = env.DEBUG || stderr ? "pipe" : "ignore";
+      this.child = spawn(executable, [...executableArgs, claudeCodePath, ...args], {
+        cwd,
+        stdio: ["pipe", "pipe", stderrMode],
+        signal: this.abortController.signal,
+        env
+      });
+      this.childStdin = this.child.stdin;
+      this.childStdout = this.child.stdout;
+      if (typeof prompt === "string") {
+        this.childStdin.end();
+        this.childStdin = undefined;
+      }
+      if (env.DEBUG || stderr) {
+        this.child.stderr.on("data", (data) => {
+          this.logDebug(`Claude Code stderr: ${data.toString()}`);
+          if (stderr) {
+            stderr(data.toString());
+          }
+        });
+      }
+      const cleanup = () => {
+        if (this.child && !this.child.killed) {
+          this.child.kill("SIGTERM");
+        }
+      };
+      this.processExitHandler = cleanup;
+      this.abortHandler = cleanup;
+      process.on("exit", this.processExitHandler);
+      this.abortController.signal.addEventListener("abort", this.abortHandler);
+      this.child.on("error", (error) => {
+        this.ready = false;
+        if (this.abortController.signal.aborted) {
+          this.exitError = new AbortError("Claude Code process aborted by user");
+        } else {
+          this.exitError = new Error(`Failed to spawn Claude Code process: ${error.message}`);
+          this.logDebug(this.exitError.message);
+        }
+      });
+      this.child.on("close", (code, signal) => {
+        this.ready = false;
+        if (this.abortController.signal.aborted) {
+          this.exitError = new AbortError("Claude Code process aborted by user");
+        } else {
+          const error = this.getProcessExitError(code, signal);
+          if (error) {
+            this.exitError = error;
+            this.logDebug(error.message);
+          }
+        }
+      });
+      this.ready = true;
+    } catch (error) {
+      this.ready = false;
+      throw error;
+    }
+  }
+  getProcessExitError(code, signal) {
+    if (code !== 0 && code !== null) {
+      return new Error(`Claude Code process exited with code ${code}`);
+    } else if (signal) {
+      return new Error(`Claude Code process terminated by signal ${signal}`);
+    }
+    return;
+  }
+  getDefaultExecutablePath() {
+    const filename = fileURLToPath(import.meta.url);
+    const dirname = join(filename, "..", "..");
+    return join(dirname, "entrypoints", "cli.js");
+  }
+  isRunningWithBun() {
+    return process.versions.bun !== undefined || process.env.BUN_INSTALL !== undefined;
+  }
+  logDebug(message) {
+    if (process.env.DEBUG) {
+      process.stderr.write(`${message}
+`);
+    }
+  }
+  write(data) {
+    if (this.abortController.signal.aborted) {
+      throw new AbortError("Operation aborted");
+    }
+    if (!this.ready || !this.childStdin) {
+      throw new Error("ProcessTransport is not ready for writing");
+    }
+    if (this.child?.killed || this.child?.exitCode !== null) {
+      throw new Error("Cannot write to terminated process");
+    }
+    if (this.exitError) {
+      throw new Error(`Cannot write to process that exited with error: ${this.exitError.message}`);
+    }
+    if (process.env.DEBUG_SDK) {
+      process.stderr.write(`[ProcessTransport] Writing to stdin: ${data.substring(0, 100)}
+`);
+    }
+    try {
+      const written = this.childStdin.write(data);
+      if (!written && process.env.DEBUG_SDK) {
+        console.warn("[ProcessTransport] Write buffer full, data queued");
+      }
+    } catch (error) {
+      this.ready = false;
+      throw new Error(`Failed to write to process stdin: ${error.message}`);
+    }
+  }
+  close() {
+    if (this.childStdin) {
+      this.childStdin.end();
+      this.childStdin = undefined;
+    }
+    if (this.processExitHandler) {
+      process.off("exit", this.processExitHandler);
+      this.processExitHandler = undefined;
+    }
+    if (this.abortHandler) {
+      this.abortController.signal.removeEventListener("abort", this.abortHandler);
+      this.abortHandler = undefined;
+    }
+    for (const { handler } of this.exitListeners) {
+      this.child?.off("exit", handler);
+    }
+    this.exitListeners = [];
+    if (this.child && !this.child.killed) {
+      this.child.kill("SIGTERM");
+      setTimeout(() => {
+        if (this.child && !this.child.killed) {
+          this.child.kill("SIGKILL");
+        }
+      }, 5000);
+    }
+    this.ready = false;
+  }
+  isReady() {
+    return this.ready;
+  }
+  async* readMessages() {
+    if (!this.childStdout) {
+      throw new Error("ProcessTransport output stream not available");
+    }
+    const rl = createInterface({ input: this.childStdout });
+    try {
+      for await (const line of rl) {
+        if (line.trim()) {
+          const message = JSON.parse(line);
+          yield message;
+        }
+      }
+      await this.waitForExit();
+    } catch (error) {
+      throw error;
+    } finally {
+      rl.close();
+    }
+  }
+  endInput() {
+    if (this.childStdin) {
+      this.childStdin.end();
+    }
+  }
+  getInputStream() {
+    return this.childStdin;
+  }
+  onExit(callback) {
+    if (!this.child)
+      return () => {};
+    const handler = (code, signal) => {
+      const error = this.getProcessExitError(code, signal);
+      callback(error);
+    };
+    this.child.on("exit", handler);
+    this.exitListeners.push({ callback, handler });
+    return () => {
+      if (this.child) {
+        this.child.off("exit", handler);
+      }
+      const index = this.exitListeners.findIndex((l) => l.handler === handler);
+      if (index !== -1) {
+        this.exitListeners.splice(index, 1);
+      }
+    };
+  }
+  async waitForExit() {
+    if (!this.child) {
+      if (this.exitError) {
+        throw this.exitError;
+      }
+      return;
+    }
+    if (this.child.exitCode !== null || this.child.killed) {
+      if (this.exitError) {
+        throw this.exitError;
+      }
+      return;
+    }
+    return new Promise((resolve, reject) => {
+      const exitHandler = (code, signal) => {
+        if (this.abortController.signal.aborted) {
+          reject(new AbortError("Operation aborted"));
+          return;
+        }
+        const error = this.getProcessExitError(code, signal);
+        if (error) {
+          reject(error);
+        } else {
+          resolve();
+        }
+      };
+      this.child.once("exit", exitHandler);
+      const errorHandler = (error) => {
+        this.child.off("exit", exitHandler);
+        reject(error);
+      };
+      this.child.once("error", errorHandler);
+      this.child.once("exit", () => {
+        this.child.off("error", errorHandler);
+      });
+    });
+  }
+}
+
 // src/entrypoints/sdk.ts
 function query({
   prompt,
   options: {
     abortController = createAbortController(),
+    additionalDirectories = [],
     allowedTools = [],
     appendSystemPrompt,
+    canUseTool,
+    continue: continueConversation,
     customSystemPrompt,
     cwd,
     disallowedTools = [],
+    env,
     executable = isRunningWithBun() ? "bun" : "node",
     executableArgs = [],
+    fallbackModel,
+    hooks,
     maxTurns,
     mcpServers,
+    model,
     pathToClaudeCodeExecutable,
     permissionMode = "default",
     permissionPromptToolName,
-    canUseTool,
-    continue: continueConversation,
     resume,
-    model,
-    fallbackModel,
-    strictMcpConfig,
     stderr,
-    env,
-    additionalDirectories = []
+    strictMcpConfig
   } = {}
 }) {
   if (!env) {
@@ -136,151 +575,87 @@ function query({
     env.CLAUDE_CODE_ENTRYPOINT = "sdk-ts";
   }
   if (pathToClaudeCodeExecutable === undefined) {
-    const filename = fileURLToPath(import.meta.url);
-    const dirname = join(filename, "..");
-    pathToClaudeCodeExecutable = join(dirname, "cli.js");
-  }
-  const args = ["--output-format", "stream-json", "--verbose"];
-  if (customSystemPrompt)
-    args.push("--system-prompt", customSystemPrompt);
-  if (appendSystemPrompt)
-    args.push("--append-system-prompt", appendSystemPrompt);
-  if (maxTurns)
-    args.push("--max-turns", maxTurns.toString());
-  if (model)
-    args.push("--model", model);
-  if (canUseTool) {
-    if (typeof prompt === "string") {
-      throw new Error("canUseTool callback requires --input-format stream-json. Please set prompt as an AsyncIterable.");
-    }
-    if (permissionPromptToolName) {
-      throw new Error("canUseTool callback cannot be used with permissionPromptToolName. Please use one or the other.");
-    }
-    permissionPromptToolName = "stdio";
-  }
-  if (permissionPromptToolName) {
-    args.push("--permission-prompt-tool", permissionPromptToolName);
-  }
-  if (continueConversation)
-    args.push("--continue");
-  if (resume)
-    args.push("--resume", resume);
-  if (allowedTools.length > 0) {
-    args.push("--allowedTools", allowedTools.join(","));
-  }
-  if (disallowedTools.length > 0) {
-    args.push("--disallowedTools", disallowedTools.join(","));
-  }
-  if (mcpServers && Object.keys(mcpServers).length > 0) {
-    args.push("--mcp-config", JSON.stringify({ mcpServers }));
-  }
-  if (strictMcpConfig) {
-    args.push("--strict-mcp-config");
-  }
-  if (permissionMode !== "default") {
-    args.push("--permission-mode", permissionMode);
-  }
-  if (fallbackModel) {
-    if (model && fallbackModel === model) {
-      throw new Error("Fallback model cannot be the same as the main model. Please specify a different model for fallbackModel option.");
-    }
-    args.push("--fallback-model", fallbackModel);
-  }
-  if (typeof prompt === "string") {
-    args.push("--print");
-    args.push("--", prompt.trim());
-  } else {
-    args.push("--input-format", "stream-json");
-  }
-  for (const dir of additionalDirectories) {
-    args.push("--add-dir", dir);
-  }
-  if (!existsSync(pathToClaudeCodeExecutable)) {
-    throw new ReferenceError(`Claude Code executable not found at ${pathToClaudeCodeExecutable}. Is options.pathToClaudeCodeExecutable set?`);
-  }
-  logDebug(`Spawning Claude Code process: ${executable} ${[...executableArgs, pathToClaudeCodeExecutable, ...args].join(" ")}`);
-  const stderrMode = env.DEBUG || stderr ? "pipe" : "ignore";
-  const child = spawn(executable, [...executableArgs, pathToClaudeCodeExecutable, ...args], {
+    const filename = fileURLToPath2(import.meta.url);
+    const dirname = join2(filename, "..");
+    pathToClaudeCodeExecutable = join2(dirname, "cli.js");
+  }
+  const isStreamingMode = typeof prompt !== "string";
+  const transport = new ProcessTransport({
+    prompt,
+    abortController,
+    additionalDirectories,
     cwd,
-    stdio: ["pipe", "pipe", stderrMode],
-    signal: abortController.signal,
-    env
+    executable,
+    executableArgs,
+    pathToClaudeCodeExecutable,
+    env,
+    stderr,
+    customSystemPrompt,
+    appendSystemPrompt,
+    maxTurns,
+    model,
+    fallbackModel,
+    permissionMode,
+    permissionPromptToolName,
+    continueConversation,
+    resume,
+    allowedTools,
+    disallowedTools,
+    mcpServers,
+    strictMcpConfig,
+    canUseTool: !!canUseTool,
+    hooks: !!hooks
   });
-  let childStdin;
-  if (typeof prompt === "string") {
-    child.stdin.end();
-  } else {
-    streamToStdin(prompt, child.stdin, abortController);
-    childStdin = child.stdin;
-  }
-  if (env.DEBUG || stderr) {
-    child.stderr.on("data", (data) => {
-      if (env.DEBUG) {
-        console.error("Claude Code stderr:", data.toString());
-      }
-      if (stderr) {
-        stderr(data.toString());
-      }
-    });
+  const query2 = new Query(transport, isStreamingMode, canUseTool, hooks, abortController);
+  if (typeof prompt !== "string") {
+    query2.streamInput(prompt);
   }
-  const cleanup = () => {
-    if (!child.killed) {
-      child.kill("SIGTERM");
-    }
-  };
-  abortController.signal.addEventListener("abort", cleanup);
-  process.on("exit", cleanup);
-  const processExitPromise = new Promise((resolve) => {
-    child.on("close", (code) => {
-      if (abortController.signal.aborted) {
-        query2.setError(new AbortError("Claude Code process aborted by user"));
-      }
-      if (code !== 0) {
-        query2.setError(new Error(`Claude Code process exited with code ${code}`));
-      } else {
-        resolve();
-      }
-    });
-  });
-  const query2 = new Query(childStdin, child.stdout, processExitPromise, canUseTool);
-  child.on("error", (error) => {
-    if (abortController.signal.aborted) {
-      query2.setError(new AbortError("Claude Code process aborted by user"));
-    } else {
-      query2.setError(new Error(`Failed to spawn Claude Code process: ${error.message}`));
-    }
-  });
-  processExitPromise.finally(() => {
-    cleanup();
-    abortController.signal.removeEventListener("abort", cleanup);
-  });
   return query2;
 }
 
 class Query {
-  childStdin;
-  childStdout;
-  processExitPromise;
+  transport;
+  isStreamingMode;
   canUseTool;
+  hooks;
+  abortController;
   pendingControlResponses = new Map;
+  cleanupPerformed = false;
   sdkMessages;
   inputStream = new Stream;
   intialization;
   cancelControllers = new Map;
-  constructor(childStdin, childStdout, processExitPromise, canUseTool) {
-    this.childStdin = childStdin;
-    this.childStdout = childStdout;
-    this.processExitPromise = processExitPromise;
+  hookCallbacks = new Map;
+  nextCallbackId = 0;
+  constructor(transport, isStreamingMode, canUseTool, hooks, abortController) {
+    this.transport = transport;
+    this.isStreamingMode = isStreamingMode;
     this.canUseTool = canUseTool;
-    this.readMessages();
+    this.hooks = hooks;
+    this.abortController = abortController;
     this.sdkMessages = this.readSdkMessages();
-    if (this.childStdin) {
+    this.readMessages();
+    if (this.isStreamingMode) {
       this.intialization = this.initialize();
     }
   }
   setError(error) {
     this.inputStream.error(error);
   }
+  cleanup(error) {
+    if (this.cleanupPerformed)
+      return;
+    this.cleanupPerformed = true;
+    try {
+      this.transport.close();
+      this.pendingControlResponses.clear();
+      if (error) {
+        this.inputStream.error(error);
+      } else {
+        this.inputStream.done();
+      }
+    } catch (_error) {}
+  }
   next(...[value]) {
     return this.sdkMessages.next(...[value]);
   }
@@ -297,33 +672,28 @@ class Query {
     return this.sdkMessages[Symbol.asyncDispose]();
   }
   async readMessages() {
-    const rl = createInterface({ input: this.childStdout });
     try {
-      for await (const line of rl) {
-        if (line.trim()) {
-          const message = JSON.parse(line);
-          if (message.type === "control_response") {
-            const handler = this.pendingControlResponses.get(message.response.request_id);
-            if (handler) {
-              handler(message.response);
-            }
-            continue;
-          } else if (message.type === "control_request") {
-            this.handleControlRequest(message);
-            continue;
-          } else if (message.type === "control_cancel_request") {
-            this.handleControlCancelRequest(message);
-            continue;
+      for await (const message of this.transport.readMessages()) {
+        if (message.type === "control_response") {
+          const handler = this.pendingControlResponses.get(message.response.request_id);
+          if (handler) {
+            handler(message.response);
           }
-          this.inputStream.enqueue(message);
+          continue;
+        } else if (message.type === "control_request") {
+          this.handleControlRequest(message);
+          continue;
+        } else if (message.type === "control_cancel_request") {
+          this.handleControlCancelRequest(message);
+          continue;
         }
+        this.inputStream.enqueue(message);
       }
-      await this.processExitPromise;
+      this.inputStream.done();
+      this.cleanup();
     } catch (error) {
       this.inputStream.error(error);
-    } finally {
-      this.inputStream.done();
-      rl.close();
+      this.cleanup(error);
     }
   }
   async handleControlRequest(request) {
@@ -339,7 +709,7 @@ class Query {
           response
         }
       };
-      this.childStdin?.write(JSON.stringify(controlResponse) + `
+      this.transport.write(JSON.stringify(controlResponse) + `
 `);
     } catch (error) {
       const controlErrorResponse = {
@@ -350,7 +720,7 @@ class Query {
           error: error.message || String(error)
         }
       };
-      this.childStdin?.write(JSON.stringify(controlErrorResponse) + `
+      this.transport.write(JSON.stringify(controlErrorResponse) + `
 `);
     } finally {
       this.cancelControllers.delete(request.request_id);
@@ -371,6 +741,9 @@ class Query {
       return this.canUseTool(request.request.tool_name, request.request.input, {
         signal
       });
+    } else if (request.request.subtype === "hook_callback") {
+      const result = await this.handleHookCallbacks(request.request.callback_id, request.request.input, request.request.tool_use_id, signal);
+      return result;
     }
     throw new Error("Unsupported control request subtype: " + request.request.subtype);
   }
@@ -380,24 +753,51 @@ class Query {
     }
   }
   async initialize() {
-    if (!this.childStdin) {
-      throw new Error("Cannot initialize without child stdin");
+    let hooks;
+    if (this.hooks) {
+      hooks = {};
+      for (const [event, matchers] of Object.entries(this.hooks)) {
+        if (matchers.length > 0) {
+          hooks[event] = matchers.map((matcher) => {
+            const callbackIds = [];
+            for (const callback of matcher.hooks) {
+              const callbackId = `hook_${this.nextCallbackId++}`;
+              this.hookCallbacks.set(callbackId, callback);
+              callbackIds.push(callbackId);
+            }
+            return {
+              matcher: matcher.matcher,
+              hookCallbackIds: callbackIds
+            };
+          });
+        }
+      }
     }
     const initRequest = {
-      subtype: "initialize"
+      subtype: "initialize",
+      hooks
     };
-    const response = await this.request(initRequest, this.childStdin);
+    const response = await this.request(initRequest);
     return response.response;
   }
   async interrupt() {
-    if (!this.childStdin) {
+    if (!this.isStreamingMode) {
       throw new Error("Interrupt requires --input-format stream-json");
     }
     await this.request({
       subtype: "interrupt"
-    }, this.childStdin);
+    });
+  }
+  async setPermissionMode(mode) {
+    if (!this.isStreamingMode) {
+      throw new Error("setPermissionMode requires --input-format stream-json");
+    }
+    await this.request({
+      subtype: "set_permission_mode",
+      mode
+    });
   }
-  request(request, childStdin) {
+  request(request) {
     const requestId = Math.random().toString(36).substring(2, 15);
     const sdkRequest = {
       request_id: requestId,
@@ -412,29 +812,42 @@ class Query {
           reject(new Error(response.error));
         }
       });
-      childStdin.write(JSON.stringify(sdkRequest) + `
+      this.transport.write(JSON.stringify(sdkRequest) + `
 `);
     });
   }
   async supportedCommands() {
+    if (!this.isStreamingMode) {
+      throw new Error("supportedCommands requires --input-format stream-json");
+    }
     if (!this.intialization) {
-      throw new Error("Interrupt requires --input-format stream-json");
+      throw new Error("supportedCommands requires transport with bidirectional communication");
     }
     return (await this.intialization).commands;
   }
-}
-async function streamToStdin(stream, stdin, abortController) {
-  for await (const message of stream) {
-    if (abortController.signal.aborted)
-      break;
-    stdin.write(JSON.stringify(message) + `
+  async streamInput(stream) {
+    try {
+      for await (const message of stream) {
+        if (this.abortController?.signal.aborted)
+          break;
+        this.transport.write(JSON.stringify(message) + `
 `);
+      }
+      this.transport.endInput();
+    } catch (error) {
+      if (!(error instanceof AbortError)) {
+        throw error;
+      }
+    }
   }
-  stdin.end();
-}
-function logDebug(message) {
-  if (process.env.DEBUG) {
-    console.debug(message);
+  handleHookCallbacks(callbackId, input, toolUseID, abortSignal) {
+    const callback = this.hookCallbacks.get(callbackId);
+    if (!callback) {
+      throw new Error(`No hook callback found for ID: ${callbackId}`);
+    }
+    return callback(input, toolUseID, {
+      signal: abortSignal
+    });
   }
 }
 function isRunningWithBun() {
@@ -442,5 +855,6 @@ function isRunningWithBun() {
 }
 export {
   query,
-  Query
+  Query,
+  AbortError
 };