@anthropic-ai/claude-agent-sdk 0.1.62 → 0.1.65

package/sdk.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 // (c) Anthropic PBC. All rights reserved. Use is subject to the Legal Agreements outlined here: https://code.claude.com/docs/en/legal-and-compliance.
 
-// Version: 0.1.62
+// Version: 0.1.65
 
 // Want to see the unminified source? We're hiring!
 // https://job-boards.greenhouse.io/anthropic/jobs/4816199008
@@ -6256,1448 +6256,1513 @@ import { createInterface } from "readline";
 // ../src/utils/fsOperations.ts
 import * as fs from "fs";
 import { stat as statPromise, open } from "fs/promises";
-var NodeFsOperations = {
-  cwd() {
-    return process.cwd();
-  },
-  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) {
-    const fileExists = fs.existsSync(fsPath);
-    if (!options.flush) {
-      const writeOptions = {
-        encoding: options.encoding
-      };
-      if (!fileExists) {
-        writeOptions.mode = options.mode ?? 384;
-      } else if (options.mode !== undefined) {
-        writeOptions.mode = options.mode;
-      }
-      fs.writeFileSync(fsPath, data, writeOptions);
-      return;
-    }
-    let fd;
-    try {
-      const mode = !fileExists ? options.mode ?? 384 : options.mode;
-      fd = fs.openSync(fsPath, "w", mode);
-      fs.writeFileSync(fd, data, { encoding: options.encoding });
-      fs.fsyncSync(fd);
-    } finally {
-      if (fd) {
-        fs.closeSync(fd);
-      }
-    }
-  },
-  appendFileSync(path, data, options) {
-    if (!fs.existsSync(path)) {
-      const mode = options?.mode ?? 384;
-      const fd = fs.openSync(path, "a", mode);
-      try {
-        fs.appendFileSync(fd, data);
-      } finally {
-        fs.closeSync(fd);
-      }
+
+// ../node_modules/lodash-es/_freeGlobal.js
+var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+var _freeGlobal_default = freeGlobal;
+
+// ../node_modules/lodash-es/_root.js
+var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+var root = _freeGlobal_default || freeSelf || Function("return this")();
+var _root_default = root;
+
+// ../node_modules/lodash-es/_Symbol.js
+var Symbol2 = _root_default.Symbol;
+var _Symbol_default = Symbol2;
+
+// ../node_modules/lodash-es/_getRawTag.js
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+var nativeObjectToString = objectProto.toString;
+var symToStringTag = _Symbol_default ? _Symbol_default.toStringTag : undefined;
+function getRawTag(value) {
+  var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+  try {
+    value[symToStringTag] = undefined;
+    var unmasked = true;
+  } catch (e) {}
+  var result = nativeObjectToString.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag] = tag;
     } else {
-      fs.appendFileSync(path, data);
-    }
-  },
-  copyFileSync(src, dest) {
-    fs.copyFileSync(src, dest);
-  },
-  unlinkSync(path) {
-    fs.unlinkSync(path);
-  },
-  renameSync(oldPath, newPath) {
-    fs.renameSync(oldPath, newPath);
-  },
-  linkSync(target, path) {
-    fs.linkSync(target, path);
-  },
-  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, mode: 448 });
+      delete value[symToStringTag];
     }
-  },
-  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);
-  },
-  createWriteStream(path) {
-    return fs.createWriteStream(path);
   }
-};
-var activeFs = NodeFsOperations;
-function getFsImplementation() {
-  return activeFs;
+  return result;
 }
+var _getRawTag_default = getRawTag;
 
-// ../src/entrypoints/agentSdkTypes.ts
-var HOOK_EVENTS = [
-  "PreToolUse",
-  "PostToolUse",
-  "PostToolUseFailure",
-  "Notification",
-  "UserPromptSubmit",
-  "SessionStart",
-  "SessionEnd",
-  "Stop",
-  "SubagentStart",
-  "SubagentStop",
-  "PreCompact",
-  "PermissionRequest"
-];
-var EXIT_REASONS = [
-  "clear",
-  "logout",
-  "prompt_input_exit",
-  "other",
-  "bypass_permissions_disabled"
-];
-class AbortError extends Error {
+// ../node_modules/lodash-es/_objectToString.js
+var objectProto2 = Object.prototype;
+var nativeObjectToString2 = objectProto2.toString;
+function objectToString(value) {
+  return nativeObjectToString2.call(value);
 }
+var _objectToString_default = objectToString;
 
-// ../src/utils/bundledMode.ts
-function isRunningWithBun() {
-  return process.versions.bun !== undefined;
+// ../node_modules/lodash-es/_baseGetTag.js
+var nullTag = "[object Null]";
+var undefinedTag = "[object Undefined]";
+var symToStringTag2 = _Symbol_default ? _Symbol_default.toStringTag : undefined;
+function baseGetTag(value) {
+  if (value == null) {
+    return value === undefined ? undefinedTag : nullTag;
+  }
+  return symToStringTag2 && symToStringTag2 in Object(value) ? _getRawTag_default(value) : _objectToString_default(value);
 }
+var _baseGetTag_default = baseGetTag;
 
-// ../src/utils/sdkDebug.ts
-import { randomUUID } from "crypto";
-import { appendFileSync as appendFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
-import { join as join2 } from "path";
-
-// ../src/utils/envUtils.ts
-import { join } from "path";
-import { homedir } from "os";
-function getClaudeConfigHomeDir() {
-  return process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude");
+// ../node_modules/lodash-es/isObject.js
+function isObject(value) {
+  var type = typeof value;
+  return value != null && (type == "object" || type == "function");
 }
-function isEnvTruthy(envVar) {
-  if (!envVar)
+var isObject_default = isObject;
+
+// ../node_modules/lodash-es/isFunction.js
+var asyncTag = "[object AsyncFunction]";
+var funcTag = "[object Function]";
+var genTag = "[object GeneratorFunction]";
+var proxyTag = "[object Proxy]";
+function isFunction(value) {
+  if (!isObject_default(value)) {
     return false;
-  if (typeof envVar === "boolean")
-    return envVar;
-  const normalizedValue = envVar.toLowerCase().trim();
-  return ["1", "true", "yes", "on"].includes(normalizedValue);
+  }
+  var tag = _baseGetTag_default(value);
+  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
 }
+var isFunction_default = isFunction;
 
-// ../src/utils/sdkDebug.ts
-var debugFilePath = null;
-var initialized = false;
-function getOrCreateDebugFile() {
-  if (initialized) {
-    return debugFilePath;
-  }
-  initialized = true;
-  if (!process.env.DEBUG_CLAUDE_AGENT_SDK) {
-    return null;
-  }
-  const debugDir = join2(getClaudeConfigHomeDir(), "debug");
-  debugFilePath = join2(debugDir, `sdk-${randomUUID()}.txt`);
-  if (!existsSync2(debugDir)) {
-    mkdirSync2(debugDir, { recursive: true });
-  }
-  process.stderr.write(`SDK debug logs: ${debugFilePath}
-`);
-  return debugFilePath;
+// ../node_modules/lodash-es/_coreJsData.js
+var coreJsData = _root_default["__core-js_shared__"];
+var _coreJsData_default = coreJsData;
+
+// ../node_modules/lodash-es/_isMasked.js
+var maskSrcKey = function() {
+  var uid = /[^.]+$/.exec(_coreJsData_default && _coreJsData_default.keys && _coreJsData_default.keys.IE_PROTO || "");
+  return uid ? "Symbol(src)_1." + uid : "";
+}();
+function isMasked(func) {
+  return !!maskSrcKey && maskSrcKey in func;
 }
-function logForSdkDebugging(message) {
-  const path = getOrCreateDebugFile();
-  if (!path) {
-    return;
+var _isMasked_default = isMasked;
+
+// ../node_modules/lodash-es/_toSource.js
+var funcProto = Function.prototype;
+var funcToString = funcProto.toString;
+function toSource(func) {
+  if (func != null) {
+    try {
+      return funcToString.call(func);
+    } catch (e) {}
+    try {
+      return func + "";
+    } catch (e) {}
   }
-  const timestamp = new Date().toISOString();
-  const output = `${timestamp} ${message}
-`;
-  appendFileSync2(path, output);
+  return "";
 }
+var _toSource_default = toSource;
 
-// ../src/transport/sandboxUtils.ts
-function mergeSandboxIntoExtraArgs(extraArgs, sandbox) {
-  const effectiveExtraArgs = { ...extraArgs };
-  if (sandbox) {
-    let settingsObj = { sandbox };
-    if (effectiveExtraArgs.settings) {
-      try {
-        const existingSettings = JSON.parse(effectiveExtraArgs.settings);
-        settingsObj = { ...existingSettings, sandbox };
-      } catch {}
-    }
-    effectiveExtraArgs.settings = JSON.stringify(settingsObj);
+// ../node_modules/lodash-es/_baseIsNative.js
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+var funcProto2 = Function.prototype;
+var objectProto3 = Object.prototype;
+var funcToString2 = funcProto2.toString;
+var hasOwnProperty2 = objectProto3.hasOwnProperty;
+var reIsNative = RegExp("^" + funcToString2.call(hasOwnProperty2).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
+function baseIsNative(value) {
+  if (!isObject_default(value) || _isMasked_default(value)) {
+    return false;
   }
-  return effectiveExtraArgs;
+  var pattern = isFunction_default(value) ? reIsNative : reIsHostCtor;
+  return pattern.test(_toSource_default(value));
 }
+var _baseIsNative_default = baseIsNative;
 
-// ../src/transport/ProcessTransport.ts
-class ProcessTransport {
-  options;
-  child;
-  childStdin;
-  childStdout;
-  ready = false;
-  abortController;
-  exitError;
-  exitListeners = [];
-  processExitHandler;
-  abortHandler;
-  constructor(options) {
-    this.options = options;
-    this.abortController = options.abortController || createAbortController();
-    this.initialize();
-  }
-  initialize() {
-    try {
-      const {
-        additionalDirectories = [],
-        betas,
-        cwd,
-        executable = isRunningWithBun() ? "bun" : "node",
-        executableArgs = [],
-        extraArgs = {},
-        pathToClaudeCodeExecutable,
-        env = { ...process.env },
-        stderr,
-        maxThinkingTokens,
-        maxTurns,
-        maxBudgetUsd,
-        model,
-        fallbackModel,
-        jsonSchema,
-        permissionMode,
-        allowDangerouslySkipPermissions,
-        permissionPromptToolName,
-        continueConversation,
-        resume,
-        settingSources,
-        allowedTools = [],
-        disallowedTools = [],
-        mcpServers,
-        strictMcpConfig,
-        canUseTool,
-        includePartialMessages,
-        plugins,
-        sandbox
-      } = this.options;
-      const args = [
-        "--output-format",
-        "stream-json",
-        "--verbose",
-        "--input-format",
-        "stream-json"
-      ];
-      if (maxThinkingTokens !== undefined) {
-        args.push("--max-thinking-tokens", maxThinkingTokens.toString());
-      }
-      if (maxTurns)
-        args.push("--max-turns", maxTurns.toString());
-      if (maxBudgetUsd !== undefined) {
-        args.push("--max-budget-usd", maxBudgetUsd.toString());
-      }
-      if (model)
-        args.push("--model", model);
-      if (betas && betas.length > 0) {
-        args.push("--betas", betas.join(","));
-      }
-      if (jsonSchema) {
-        args.push("--json-schema", JSON.stringify(jsonSchema));
-      }
-      if (env.DEBUG_CLAUDE_AGENT_SDK) {
-        args.push("--debug-to-stderr");
-      }
-      if (canUseTool) {
-        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(","));
-      }
-      const { tools } = this.options;
-      if (tools !== undefined) {
-        if (Array.isArray(tools)) {
-          if (tools.length === 0) {
-            args.push("--tools", "");
-          } else {
-            args.push("--tools", tools.join(","));
-          }
-        } else {
-          args.push("--tools", "default");
-        }
-      }
-      if (mcpServers && Object.keys(mcpServers).length > 0) {
-        args.push("--mcp-config", JSON.stringify({ mcpServers }));
-      }
-      if (settingSources) {
-        args.push("--setting-sources", settingSources.join(","));
-      }
-      if (strictMcpConfig) {
-        args.push("--strict-mcp-config");
-      }
-      if (permissionMode) {
-        args.push("--permission-mode", permissionMode);
-      }
-      if (allowDangerouslySkipPermissions) {
-        args.push("--allow-dangerously-skip-permissions");
-      }
-      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 (includePartialMessages) {
-        args.push("--include-partial-messages");
-      }
-      for (const dir of additionalDirectories) {
-        args.push("--add-dir", dir);
-      }
-      if (plugins && plugins.length > 0) {
-        for (const plugin of plugins) {
-          if (plugin.type === "local") {
-            args.push("--plugin-dir", plugin.path);
-          } else {
-            throw new Error(`Unsupported plugin type: ${plugin.type}`);
-          }
-        }
-      }
-      if (this.options.forkSession) {
-        args.push("--fork-session");
-      }
-      if (this.options.resumeSessionAt) {
-        args.push("--resume-session-at", this.options.resumeSessionAt);
-      }
-      const effectiveExtraArgs = mergeSandboxIntoExtraArgs(extraArgs ?? {}, sandbox);
-      for (const [flag, value] of Object.entries(effectiveExtraArgs)) {
-        if (value === null) {
-          args.push(`--${flag}`);
-        } else {
-          args.push(`--${flag}`, value);
-        }
-      }
-      if (!env.CLAUDE_CODE_ENTRYPOINT) {
-        env.CLAUDE_CODE_ENTRYPOINT = "sdk-ts";
-      }
-      delete env.NODE_OPTIONS;
-      if (env.DEBUG_CLAUDE_AGENT_SDK) {
-        env.DEBUG = "1";
-      } else {
-        delete env.DEBUG;
-      }
-      const fs2 = getFsImplementation();
-      if (!fs2.existsSync(pathToClaudeCodeExecutable)) {
-        const errorMessage = isNativeBinary(pathToClaudeCodeExecutable) ? `Claude Code native binary not found at ${pathToClaudeCodeExecutable}. Please ensure Claude Code is installed via native installer or specify a valid path with options.pathToClaudeCodeExecutable.` : `Claude Code executable not found at ${pathToClaudeCodeExecutable}. Is options.pathToClaudeCodeExecutable set?`;
-        throw new ReferenceError(errorMessage);
-      }
-      const isNative = isNativeBinary(pathToClaudeCodeExecutable);
-      const spawnCommand = isNative ? pathToClaudeCodeExecutable : executable;
-      const spawnArgs = isNative ? [...executableArgs, ...args] : [...executableArgs, pathToClaudeCodeExecutable, ...args];
-      const spawnMessage = isNative ? `Spawning Claude Code native binary: ${spawnCommand} ${spawnArgs.join(" ")}` : `Spawning Claude Code process: ${spawnCommand} ${spawnArgs.join(" ")}`;
-      logForSdkDebugging(spawnMessage);
-      if (stderr) {
-        stderr(spawnMessage);
-      }
-      const stderrMode = env.DEBUG_CLAUDE_AGENT_SDK || stderr ? "pipe" : "ignore";
-      this.child = spawn(spawnCommand, spawnArgs, {
-        cwd,
-        stdio: ["pipe", "pipe", stderrMode],
-        signal: this.abortController.signal,
-        env
-      });
-      this.childStdin = this.child.stdin;
-      this.childStdout = this.child.stdout;
-      if (env.DEBUG_CLAUDE_AGENT_SDK || stderr) {
-        this.child.stderr.on("data", (data) => {
-          const message = data.toString();
-          logForSdkDebugging(message);
-          if (stderr) {
-            stderr(message);
-          }
-        });
-      }
-      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}`);
-          logForSdkDebugging(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;
-            logForSdkDebugging(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;
-  }
-  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}`);
-    }
-    logForSdkDebugging(`[ProcessTransport] Writing to stdin: ${data.substring(0, 100)}`);
-    try {
-      const written = this.childStdin.write(data);
-      if (!written) {
-        logForSdkDebugging("[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);
-      }
-    };
+// ../node_modules/lodash-es/_getValue.js
+function getValue(object, key) {
+  return object == null ? undefined : object[key];
+}
+var _getValue_default = getValue;
+
+// ../node_modules/lodash-es/_getNative.js
+function getNative(object, key) {
+  var value = _getValue_default(object, key);
+  return _baseIsNative_default(value) ? value : undefined;
+}
+var _getNative_default = getNative;
+
+// ../node_modules/lodash-es/_nativeCreate.js
+var nativeCreate = _getNative_default(Object, "create");
+var _nativeCreate_default = nativeCreate;
+
+// ../node_modules/lodash-es/_hashClear.js
+function hashClear() {
+  this.__data__ = _nativeCreate_default ? _nativeCreate_default(null) : {};
+  this.size = 0;
+}
+var _hashClear_default = hashClear;
+
+// ../node_modules/lodash-es/_hashDelete.js
+function hashDelete(key) {
+  var result = this.has(key) && delete this.__data__[key];
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var _hashDelete_default = hashDelete;
+
+// ../node_modules/lodash-es/_hashGet.js
+var HASH_UNDEFINED = "__lodash_hash_undefined__";
+var objectProto4 = Object.prototype;
+var hasOwnProperty3 = objectProto4.hasOwnProperty;
+function hashGet(key) {
+  var data = this.__data__;
+  if (_nativeCreate_default) {
+    var result = data[key];
+    return result === HASH_UNDEFINED ? undefined : result;
   }
-  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);
-      });
-    });
+  return hasOwnProperty3.call(data, key) ? data[key] : undefined;
+}
+var _hashGet_default = hashGet;
+
+// ../node_modules/lodash-es/_hashHas.js
+var objectProto5 = Object.prototype;
+var hasOwnProperty4 = objectProto5.hasOwnProperty;
+function hashHas(key) {
+  var data = this.__data__;
+  return _nativeCreate_default ? data[key] !== undefined : hasOwnProperty4.call(data, key);
+}
+var _hashHas_default = hashHas;
+
+// ../node_modules/lodash-es/_hashSet.js
+var HASH_UNDEFINED2 = "__lodash_hash_undefined__";
+function hashSet(key, value) {
+  var data = this.__data__;
+  this.size += this.has(key) ? 0 : 1;
+  data[key] = _nativeCreate_default && value === undefined ? HASH_UNDEFINED2 : value;
+  return this;
+}
+var _hashSet_default = hashSet;
+
+// ../node_modules/lodash-es/_Hash.js
+function Hash(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
   }
 }
-function isNativeBinary(executablePath) {
-  const jsExtensions = [".js", ".mjs", ".tsx", ".ts", ".jsx"];
-  return !jsExtensions.some((ext) => executablePath.endsWith(ext));
+Hash.prototype.clear = _hashClear_default;
+Hash.prototype["delete"] = _hashDelete_default;
+Hash.prototype.get = _hashGet_default;
+Hash.prototype.has = _hashHas_default;
+Hash.prototype.set = _hashSet_default;
+var _Hash_default = Hash;
+
+// ../node_modules/lodash-es/_listCacheClear.js
+function listCacheClear() {
+  this.__data__ = [];
+  this.size = 0;
 }
+var _listCacheClear_default = listCacheClear;
 
-// ../src/utils/stream.ts
-class Stream {
-  returned;
-  queue = [];
-  readResolve;
-  readReject;
-  isDone = false;
-  hasError;
-  started = false;
-  constructor(returned) {
-    this.returned = returned;
-  }
-  [Symbol.asyncIterator]() {
-    if (this.started) {
-      throw new Error("Stream can only be iterated once");
-    }
-    this.started = true;
-    return this;
-  }
-  next() {
-    if (this.queue.length > 0) {
-      return Promise.resolve({
-        done: false,
-        value: this.queue.shift()
-      });
-    }
-    if (this.isDone) {
-      return Promise.resolve({ done: true, value: undefined });
-    }
-    if (this.hasError) {
-      return Promise.reject(this.hasError);
-    }
-    return new Promise((resolve, reject) => {
-      this.readResolve = resolve;
-      this.readReject = reject;
-    });
-  }
-  enqueue(value) {
-    if (this.readResolve) {
-      const resolve = this.readResolve;
-      this.readResolve = undefined;
-      this.readReject = undefined;
-      resolve({ done: false, value });
-    } else {
-      this.queue.push(value);
-    }
-  }
-  done() {
-    this.isDone = true;
-    if (this.readResolve) {
-      const resolve = this.readResolve;
-      this.readResolve = undefined;
-      this.readReject = undefined;
-      resolve({ done: true, value: undefined });
+// ../node_modules/lodash-es/eq.js
+function eq(value, other) {
+  return value === other || value !== value && other !== other;
+}
+var eq_default = eq;
+
+// ../node_modules/lodash-es/_assocIndexOf.js
+function assocIndexOf(array, key) {
+  var length = array.length;
+  while (length--) {
+    if (eq_default(array[length][0], key)) {
+      return length;
     }
   }
-  error(error) {
-    this.hasError = error;
-    if (this.readReject) {
-      const reject = this.readReject;
-      this.readResolve = undefined;
-      this.readReject = undefined;
-      reject(error);
-    }
+  return -1;
+}
+var _assocIndexOf_default = assocIndexOf;
+
+// ../node_modules/lodash-es/_listCacheDelete.js
+var arrayProto = Array.prototype;
+var splice = arrayProto.splice;
+function listCacheDelete(key) {
+  var data = this.__data__, index = _assocIndexOf_default(data, key);
+  if (index < 0) {
+    return false;
   }
-  return() {
-    this.isDone = true;
-    if (this.returned) {
-      this.returned();
-    }
-    return Promise.resolve({ done: true, value: undefined });
+  var lastIndex = data.length - 1;
+  if (index == lastIndex) {
+    data.pop();
+  } else {
+    splice.call(data, index, 1);
   }
+  --this.size;
+  return true;
 }
+var _listCacheDelete_default = listCacheDelete;
 
-// ../src/services/mcp/SdkControlTransport.ts
-class SdkControlServerTransport {
-  sendMcpMessage;
-  isClosed = false;
-  constructor(sendMcpMessage) {
-    this.sendMcpMessage = sendMcpMessage;
-  }
-  onclose;
-  onerror;
-  onmessage;
-  async start() {}
-  async send(message) {
-    if (this.isClosed) {
-      throw new Error("Transport is closed");
-    }
-    this.sendMcpMessage(message);
+// ../node_modules/lodash-es/_listCacheGet.js
+function listCacheGet(key) {
+  var data = this.__data__, index = _assocIndexOf_default(data, key);
+  return index < 0 ? undefined : data[index][1];
+}
+var _listCacheGet_default = listCacheGet;
+
+// ../node_modules/lodash-es/_listCacheHas.js
+function listCacheHas(key) {
+  return _assocIndexOf_default(this.__data__, key) > -1;
+}
+var _listCacheHas_default = listCacheHas;
+
+// ../node_modules/lodash-es/_listCacheSet.js
+function listCacheSet(key, value) {
+  var data = this.__data__, index = _assocIndexOf_default(data, key);
+  if (index < 0) {
+    ++this.size;
+    data.push([key, value]);
+  } else {
+    data[index][1] = value;
   }
-  async close() {
-    if (this.isClosed) {
-      return;
-    }
-    this.isClosed = true;
-    this.onclose?.();
+  return this;
+}
+var _listCacheSet_default = listCacheSet;
+
+// ../node_modules/lodash-es/_ListCache.js
+function ListCache(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
   }
 }
+ListCache.prototype.clear = _listCacheClear_default;
+ListCache.prototype["delete"] = _listCacheDelete_default;
+ListCache.prototype.get = _listCacheGet_default;
+ListCache.prototype.has = _listCacheHas_default;
+ListCache.prototype.set = _listCacheSet_default;
+var _ListCache_default = ListCache;
 
-// ../node_modules/lodash-es/_freeGlobal.js
-var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
-var _freeGlobal_default = freeGlobal;
+// ../node_modules/lodash-es/_Map.js
+var Map2 = _getNative_default(_root_default, "Map");
+var _Map_default = Map2;
 
-// ../node_modules/lodash-es/_root.js
-var freeSelf = typeof self == "object" && self && self.Object === Object && self;
-var root = _freeGlobal_default || freeSelf || Function("return this")();
-var _root_default = root;
+// ../node_modules/lodash-es/_mapCacheClear.js
+function mapCacheClear() {
+  this.size = 0;
+  this.__data__ = {
+    hash: new _Hash_default,
+    map: new (_Map_default || _ListCache_default),
+    string: new _Hash_default
+  };
+}
+var _mapCacheClear_default = mapCacheClear;
 
-// ../node_modules/lodash-es/_Symbol.js
-var Symbol2 = _root_default.Symbol;
-var _Symbol_default = Symbol2;
+// ../node_modules/lodash-es/_isKeyable.js
+function isKeyable(value) {
+  var type = typeof value;
+  return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+}
+var _isKeyable_default = isKeyable;
 
-// ../node_modules/lodash-es/_getRawTag.js
-var objectProto = Object.prototype;
-var hasOwnProperty = objectProto.hasOwnProperty;
-var nativeObjectToString = objectProto.toString;
-var symToStringTag = _Symbol_default ? _Symbol_default.toStringTag : undefined;
-function getRawTag(value) {
-  var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
-  try {
-    value[symToStringTag] = undefined;
-    var unmasked = true;
-  } catch (e) {}
-  var result = nativeObjectToString.call(value);
-  if (unmasked) {
-    if (isOwn) {
-      value[symToStringTag] = tag;
-    } else {
-      delete value[symToStringTag];
-    }
-  }
-  return result;
+// ../node_modules/lodash-es/_getMapData.js
+function getMapData(map, key) {
+  var data = map.__data__;
+  return _isKeyable_default(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
 }
-var _getRawTag_default = getRawTag;
+var _getMapData_default = getMapData;
 
-// ../node_modules/lodash-es/_objectToString.js
-var objectProto2 = Object.prototype;
-var nativeObjectToString2 = objectProto2.toString;
-function objectToString(value) {
-  return nativeObjectToString2.call(value);
+// ../node_modules/lodash-es/_mapCacheDelete.js
+function mapCacheDelete(key) {
+  var result = _getMapData_default(this, key)["delete"](key);
+  this.size -= result ? 1 : 0;
+  return result;
 }
-var _objectToString_default = objectToString;
+var _mapCacheDelete_default = mapCacheDelete;
 
-// ../node_modules/lodash-es/_baseGetTag.js
-var nullTag = "[object Null]";
-var undefinedTag = "[object Undefined]";
-var symToStringTag2 = _Symbol_default ? _Symbol_default.toStringTag : undefined;
-function baseGetTag(value) {
-  if (value == null) {
-    return value === undefined ? undefinedTag : nullTag;
-  }
-  return symToStringTag2 && symToStringTag2 in Object(value) ? _getRawTag_default(value) : _objectToString_default(value);
+// ../node_modules/lodash-es/_mapCacheGet.js
+function mapCacheGet(key) {
+  return _getMapData_default(this, key).get(key);
 }
-var _baseGetTag_default = baseGetTag;
+var _mapCacheGet_default = mapCacheGet;
 
-// ../node_modules/lodash-es/isObject.js
-function isObject(value) {
-  var type = typeof value;
-  return value != null && (type == "object" || type == "function");
+// ../node_modules/lodash-es/_mapCacheHas.js
+function mapCacheHas(key) {
+  return _getMapData_default(this, key).has(key);
 }
-var isObject_default = isObject;
+var _mapCacheHas_default = mapCacheHas;
 
-// ../node_modules/lodash-es/isFunction.js
-var asyncTag = "[object AsyncFunction]";
-var funcTag = "[object Function]";
-var genTag = "[object GeneratorFunction]";
-var proxyTag = "[object Proxy]";
-function isFunction(value) {
-  if (!isObject_default(value)) {
-    return false;
-  }
-  var tag = _baseGetTag_default(value);
-  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+// ../node_modules/lodash-es/_mapCacheSet.js
+function mapCacheSet(key, value) {
+  var data = _getMapData_default(this, key), size = data.size;
+  data.set(key, value);
+  this.size += data.size == size ? 0 : 1;
+  return this;
 }
-var isFunction_default = isFunction;
+var _mapCacheSet_default = mapCacheSet;
 
-// ../node_modules/lodash-es/_coreJsData.js
-var coreJsData = _root_default["__core-js_shared__"];
-var _coreJsData_default = coreJsData;
+// ../node_modules/lodash-es/_MapCache.js
+function MapCache(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+MapCache.prototype.clear = _mapCacheClear_default;
+MapCache.prototype["delete"] = _mapCacheDelete_default;
+MapCache.prototype.get = _mapCacheGet_default;
+MapCache.prototype.has = _mapCacheHas_default;
+MapCache.prototype.set = _mapCacheSet_default;
+var _MapCache_default = MapCache;
 
-// ../node_modules/lodash-es/_isMasked.js
-var maskSrcKey = function() {
-  var uid = /[^.]+$/.exec(_coreJsData_default && _coreJsData_default.keys && _coreJsData_default.keys.IE_PROTO || "");
-  return uid ? "Symbol(src)_1." + uid : "";
-}();
-function isMasked(func) {
-  return !!maskSrcKey && maskSrcKey in func;
+// ../node_modules/lodash-es/memoize.js
+var FUNC_ERROR_TEXT = "Expected a function";
+function memoize(func, resolver) {
+  if (typeof func != "function" || resolver != null && typeof resolver != "function") {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  var memoized = function() {
+    var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    var result = func.apply(this, args);
+    memoized.cache = cache.set(key, result) || cache;
+    return result;
+  };
+  memoized.cache = new (memoize.Cache || _MapCache_default);
+  return memoized;
 }
-var _isMasked_default = isMasked;
+memoize.Cache = _MapCache_default;
+var memoize_default = memoize;
 
-// ../node_modules/lodash-es/_toSource.js
-var funcProto = Function.prototype;
-var funcToString = funcProto.toString;
-function toSource(func) {
-  if (func != null) {
-    try {
-      return funcToString.call(func);
-    } catch (e) {}
-    try {
-      return func + "";
-    } catch (e) {}
+// ../src/utils/process.ts
+var CHUNK_SIZE = 2000;
+function writeToStderr(data) {
+  for (let i = 0;i < data.length; i += CHUNK_SIZE) {
+    process.stderr.write(data.substring(i, i + CHUNK_SIZE));
   }
-  return "";
 }
-var _toSource_default = toSource;
 
-// ../node_modules/lodash-es/_baseIsNative.js
-var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
-var reIsHostCtor = /^\[object .+?Constructor\]$/;
-var funcProto2 = Function.prototype;
-var objectProto3 = Object.prototype;
-var funcToString2 = funcProto2.toString;
-var hasOwnProperty2 = objectProto3.hasOwnProperty;
-var reIsNative = RegExp("^" + funcToString2.call(hasOwnProperty2).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
-function baseIsNative(value) {
-  if (!isObject_default(value) || _isMasked_default(value)) {
+// ../src/utils/debugFilter.ts
+var parseDebugFilter = memoize_default((filterString) => {
+  if (!filterString || filterString.trim() === "") {
+    return null;
+  }
+  const filters = filterString.split(",").map((f) => f.trim()).filter(Boolean);
+  if (filters.length === 0) {
+    return null;
+  }
+  const hasExclusive = filters.some((f) => f.startsWith("!"));
+  const hasInclusive = filters.some((f) => !f.startsWith("!"));
+  if (hasExclusive && hasInclusive) {
+    return null;
+  }
+  const cleanFilters = filters.map((f) => f.replace(/^!/, "").toLowerCase());
+  return {
+    include: hasExclusive ? [] : cleanFilters,
+    exclude: hasExclusive ? cleanFilters : [],
+    isExclusive: hasExclusive
+  };
+});
+function extractDebugCategories(message) {
+  const categories = [];
+  const mcpMatch = message.match(/^MCP server ["']([^"']+)["']/);
+  if (mcpMatch && mcpMatch[1]) {
+    categories.push("mcp");
+    categories.push(mcpMatch[1].toLowerCase());
+  } else {
+    const prefixMatch = message.match(/^([^:[]+):/);
+    if (prefixMatch && prefixMatch[1]) {
+      categories.push(prefixMatch[1].trim().toLowerCase());
+    }
+  }
+  const bracketMatch = message.match(/^\[([^\]]+)]/);
+  if (bracketMatch && bracketMatch[1]) {
+    categories.push(bracketMatch[1].trim().toLowerCase());
+  }
+  if (message.toLowerCase().includes("statsig event:")) {
+    categories.push("statsig");
+  }
+  const secondaryMatch = message.match(/:\s*([^:]+?)(?:\s+(?:type|mode|status|event))?:/);
+  if (secondaryMatch && secondaryMatch[1]) {
+    const secondary = secondaryMatch[1].trim().toLowerCase();
+    if (secondary.length < 30 && !secondary.includes(" ")) {
+      categories.push(secondary);
+    }
+  }
+  return Array.from(new Set(categories));
+}
+function shouldShowDebugCategories(categories, filter) {
+  if (!filter) {
+    return true;
+  }
+  if (categories.length === 0) {
     return false;
   }
-  var pattern = isFunction_default(value) ? reIsNative : reIsHostCtor;
-  return pattern.test(_toSource_default(value));
+  if (filter.isExclusive) {
+    return !categories.some((cat) => filter.exclude.includes(cat));
+  } else {
+    return categories.some((cat) => filter.include.includes(cat));
+  }
 }
-var _baseIsNative_default = baseIsNative;
-
-// ../node_modules/lodash-es/_getValue.js
-function getValue(object, key) {
-  return object == null ? undefined : object[key];
+function shouldShowDebugMessage(message, filter) {
+  if (!filter) {
+    return true;
+  }
+  const categories = extractDebugCategories(message);
+  return shouldShowDebugCategories(categories, filter);
 }
-var _getValue_default = getValue;
 
-// ../node_modules/lodash-es/_getNative.js
-function getNative(object, key) {
-  var value = _getValue_default(object, key);
-  return _baseIsNative_default(value) ? value : undefined;
+// ../src/utils/envUtils.ts
+import { join } from "path";
+import { homedir } from "os";
+function getClaudeConfigHomeDir() {
+  return process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude");
 }
-var _getNative_default = getNative;
-
-// ../node_modules/lodash-es/_nativeCreate.js
-var nativeCreate = _getNative_default(Object, "create");
-var _nativeCreate_default = nativeCreate;
-
-// ../node_modules/lodash-es/_hashClear.js
-function hashClear() {
-  this.__data__ = _nativeCreate_default ? _nativeCreate_default(null) : {};
-  this.size = 0;
+function isEnvTruthy(envVar) {
+  if (!envVar)
+    return false;
+  if (typeof envVar === "boolean")
+    return envVar;
+  const normalizedValue = envVar.toLowerCase().trim();
+  return ["1", "true", "yes", "on"].includes(normalizedValue);
 }
-var _hashClear_default = hashClear;
 
-// ../node_modules/lodash-es/_hashDelete.js
-function hashDelete(key) {
-  var result = this.has(key) && delete this.__data__[key];
-  this.size -= result ? 1 : 0;
-  return result;
-}
-var _hashDelete_default = hashDelete;
+// ../src/utils/debug.ts
+import { dirname, join as join2 } from "path";
 
-// ../node_modules/lodash-es/_hashGet.js
-var HASH_UNDEFINED = "__lodash_hash_undefined__";
-var objectProto4 = Object.prototype;
-var hasOwnProperty3 = objectProto4.hasOwnProperty;
-function hashGet(key) {
-  var data = this.__data__;
-  if (_nativeCreate_default) {
-    var result = data[key];
-    return result === HASH_UNDEFINED ? undefined : result;
+// ../src/bootstrap/state.ts
+import { cwd } from "process";
+import { realpathSync } from "fs";
+import { randomUUID } from "crypto";
+
+// ../src/bootstrap/envValidators.ts
+var bashMaxOutputLengthValidator = {
+  name: "BASH_MAX_OUTPUT_LENGTH",
+  default: 30000,
+  validate: (value) => {
+    const MAX_OUTPUT_LENGTH = 150000;
+    const DEFAULT_MAX_OUTPUT_LENGTH = 30000;
+    if (!value) {
+      return {
+        effective: DEFAULT_MAX_OUTPUT_LENGTH,
+        status: "valid"
+      };
+    }
+    const parsed = parseInt(value, 10);
+    if (isNaN(parsed) || parsed <= 0) {
+      return {
+        effective: DEFAULT_MAX_OUTPUT_LENGTH,
+        status: "invalid",
+        message: `Invalid value "${value}" (using default: ${DEFAULT_MAX_OUTPUT_LENGTH})`
+      };
+    }
+    if (parsed > MAX_OUTPUT_LENGTH) {
+      return {
+        effective: MAX_OUTPUT_LENGTH,
+        status: "capped",
+        message: `Capped from ${parsed} to ${MAX_OUTPUT_LENGTH}`
+      };
+    }
+    return { effective: parsed, status: "valid" };
+  }
+};
+var maxOutputTokensValidator = {
+  name: "CLAUDE_CODE_MAX_OUTPUT_TOKENS",
+  default: 32000,
+  validate: (value) => {
+    const MAX_OUTPUT_TOKENS = 64000;
+    const DEFAULT_MAX_OUTPUT_TOKENS = 32000;
+    if (!value) {
+      return { effective: DEFAULT_MAX_OUTPUT_TOKENS, status: "valid" };
+    }
+    const parsed = parseInt(value, 10);
+    if (isNaN(parsed) || parsed <= 0) {
+      return {
+        effective: DEFAULT_MAX_OUTPUT_TOKENS,
+        status: "invalid",
+        message: `Invalid value "${value}" (using default: ${DEFAULT_MAX_OUTPUT_TOKENS})`
+      };
+    }
+    if (parsed > MAX_OUTPUT_TOKENS) {
+      return {
+        effective: MAX_OUTPUT_TOKENS,
+        status: "capped",
+        message: `Capped from ${parsed} to ${MAX_OUTPUT_TOKENS}`
+      };
+    }
+    return { effective: parsed, status: "valid" };
   }
-  return hasOwnProperty3.call(data, key) ? data[key] : undefined;
-}
-var _hashGet_default = hashGet;
-
-// ../node_modules/lodash-es/_hashHas.js
-var objectProto5 = Object.prototype;
-var hasOwnProperty4 = objectProto5.hasOwnProperty;
-function hashHas(key) {
-  var data = this.__data__;
-  return _nativeCreate_default ? data[key] !== undefined : hasOwnProperty4.call(data, key);
-}
-var _hashHas_default = hashHas;
-
-// ../node_modules/lodash-es/_hashSet.js
-var HASH_UNDEFINED2 = "__lodash_hash_undefined__";
-function hashSet(key, value) {
-  var data = this.__data__;
-  this.size += this.has(key) ? 0 : 1;
-  data[key] = _nativeCreate_default && value === undefined ? HASH_UNDEFINED2 : value;
-  return this;
-}
-var _hashSet_default = hashSet;
+};
 
-// ../node_modules/lodash-es/_Hash.js
-function Hash(entries) {
-  var index = -1, length = entries == null ? 0 : entries.length;
-  this.clear();
-  while (++index < length) {
-    var entry = entries[index];
-    this.set(entry[0], entry[1]);
+// ../src/bootstrap/state.ts
+function getInitialState() {
+  let resolvedCwd = "";
+  if (typeof process !== "undefined" && typeof process.cwd === "function") {
+    resolvedCwd = realpathSync(cwd());
   }
+  return {
+    originalCwd: resolvedCwd,
+    totalCostUSD: 0,
+    totalAPIDuration: 0,
+    totalAPIDurationWithoutRetries: 0,
+    totalToolDuration: 0,
+    startTime: Date.now(),
+    lastInteractionTime: Date.now(),
+    totalLinesAdded: 0,
+    totalLinesRemoved: 0,
+    hasUnknownModelCost: false,
+    cwd: resolvedCwd,
+    modelUsage: {},
+    mainLoopModelOverride: undefined,
+    initialMainLoopModel: null,
+    modelStrings: null,
+    isInteractive: false,
+    clientType: "cli",
+    sessionIngressToken: undefined,
+    oauthTokenFromFd: undefined,
+    apiKeyFromFd: undefined,
+    flagSettingsPath: undefined,
+    allowedSettingSources: [
+      "userSettings",
+      "projectSettings",
+      "localSettings",
+      "flagSettings",
+      "policySettings"
+    ],
+    meter: null,
+    sessionCounter: null,
+    locCounter: null,
+    prCounter: null,
+    commitCounter: null,
+    costCounter: null,
+    tokenCounter: null,
+    codeEditToolDecisionCounter: null,
+    activeTimeCounter: null,
+    sessionId: randomUUID(),
+    loggerProvider: null,
+    eventLogger: null,
+    meterProvider: null,
+    tracerProvider: null,
+    agentColorMap: new Map,
+    agentColorIndex: 0,
+    envVarValidators: [bashMaxOutputLengthValidator, maxOutputTokensValidator],
+    lastAPIRequest: null,
+    inMemoryErrorLog: [],
+    inlinePlugins: [],
+    sessionBypassPermissionsMode: false,
+    sessionPersistenceDisabled: false,
+    hasExitedPlanMode: false,
+    needsPlanModeExitAttachment: false,
+    initJsonSchema: null,
+    registeredHooks: null,
+    planSlugCache: new Map
+  };
 }
-Hash.prototype.clear = _hashClear_default;
-Hash.prototype["delete"] = _hashDelete_default;
-Hash.prototype.get = _hashGet_default;
-Hash.prototype.has = _hashHas_default;
-Hash.prototype.set = _hashSet_default;
-var _Hash_default = Hash;
-
-// ../node_modules/lodash-es/_listCacheClear.js
-function listCacheClear() {
-  this.__data__ = [];
-  this.size = 0;
-}
-var _listCacheClear_default = listCacheClear;
-
-// ../node_modules/lodash-es/eq.js
-function eq(value, other) {
-  return value === other || value !== value && other !== other;
+var STATE = getInitialState();
+function getSessionId() {
+  return STATE.sessionId;
 }
-var eq_default = eq;
 
-// ../node_modules/lodash-es/_assocIndexOf.js
-function assocIndexOf(array, key) {
-  var length = array.length;
-  while (length--) {
-    if (eq_default(array[length][0], key)) {
-      return length;
+// ../src/utils/bufferedWriter.ts
+function createBufferedWriter({
+  writeFn,
+  flushIntervalMs = 1000,
+  maxBufferSize = 100,
+  immediateMode = false
+}) {
+  let buffer = [];
+  let flushTimer = null;
+  function clearTimer() {
+    if (flushTimer) {
+      clearTimeout(flushTimer);
+      flushTimer = null;
     }
   }
-  return -1;
-}
-var _assocIndexOf_default = assocIndexOf;
-
-// ../node_modules/lodash-es/_listCacheDelete.js
-var arrayProto = Array.prototype;
-var splice = arrayProto.splice;
-function listCacheDelete(key) {
-  var data = this.__data__, index = _assocIndexOf_default(data, key);
-  if (index < 0) {
-    return false;
+  function flush() {
+    if (buffer.length === 0)
+      return;
+    writeFn(buffer.join(""));
+    buffer = [];
+    clearTimer();
   }
-  var lastIndex = data.length - 1;
-  if (index == lastIndex) {
-    data.pop();
-  } else {
-    splice.call(data, index, 1);
+  function scheduleFlush() {
+    if (!flushTimer) {
+      flushTimer = setTimeout(flush, flushIntervalMs);
+    }
   }
-  --this.size;
-  return true;
+  return {
+    write(content) {
+      if (immediateMode) {
+        writeFn(content);
+        return;
+      }
+      buffer.push(content);
+      scheduleFlush();
+      if (buffer.length >= maxBufferSize) {
+        flush();
+      }
+    },
+    flush,
+    dispose() {
+      flush();
+    }
+  };
 }
-var _listCacheDelete_default = listCacheDelete;
 
-// ../node_modules/lodash-es/_listCacheGet.js
-function listCacheGet(key) {
-  var data = this.__data__, index = _assocIndexOf_default(data, key);
-  return index < 0 ? undefined : data[index][1];
+// ../src/utils/cleanupRegistry.ts
+var cleanupFunctions = new Set;
+function registerCleanup(cleanupFn) {
+  cleanupFunctions.add(cleanupFn);
+  return () => cleanupFunctions.delete(cleanupFn);
 }
-var _listCacheGet_default = listCacheGet;
 
-// ../node_modules/lodash-es/_listCacheHas.js
-function listCacheHas(key) {
-  return _assocIndexOf_default(this.__data__, key) > -1;
+// ../src/utils/debug.ts
+var isDebugMode = memoize_default(() => {
+  return isEnvTruthy(process.env.DEBUG) || isEnvTruthy(process.env.DEBUG_SDK) || process.argv.includes("--debug") || process.argv.includes("-d") || isDebugToStdErr() || process.argv.some((arg) => arg.startsWith("--debug="));
+});
+var getDebugFilter = memoize_default(() => {
+  const debugArg = process.argv.find((arg) => arg.startsWith("--debug="));
+  if (!debugArg) {
+    return null;
+  }
+  const filterPattern = debugArg.substring("--debug=".length);
+  return parseDebugFilter(filterPattern);
+});
+var isDebugToStdErr = memoize_default(() => {
+  return process.argv.includes("--debug-to-stderr") || process.argv.includes("-d2e");
+});
+function shouldLogDebugMessage(message) {
+  if (false) {}
+  if (typeof process === "undefined" || typeof process.versions === "undefined" || typeof process.versions.node === "undefined") {
+    return false;
+  }
+  const filter = getDebugFilter();
+  return shouldShowDebugMessage(message, filter);
 }
-var _listCacheHas_default = listCacheHas;
-
-// ../node_modules/lodash-es/_listCacheSet.js
-function listCacheSet(key, value) {
-  var data = this.__data__, index = _assocIndexOf_default(data, key);
-  if (index < 0) {
-    ++this.size;
-    data.push([key, value]);
-  } else {
-    data[index][1] = value;
+var hasFormattedOutput = false;
+var debugWriter = null;
+function getDebugWriter() {
+  if (!debugWriter) {
+    debugWriter = createBufferedWriter({
+      writeFn: (content) => {
+        const path = getDebugLogPath();
+        if (!getFsImplementation().existsSync(dirname(path))) {
+          getFsImplementation().mkdirSync(dirname(path));
+        }
+        getFsImplementation().appendFileSync(path, content);
+        updateLatestDebugLogSymlink();
+      },
+      flushIntervalMs: 1000,
+      maxBufferSize: 100,
+      immediateMode: isDebugMode()
+    });
+    registerCleanup(async () => debugWriter?.dispose());
   }
-  return this;
+  return debugWriter;
 }
-var _listCacheSet_default = listCacheSet;
-
-// ../node_modules/lodash-es/_ListCache.js
-function ListCache(entries) {
-  var index = -1, length = entries == null ? 0 : entries.length;
-  this.clear();
-  while (++index < length) {
-    var entry = entries[index];
-    this.set(entry[0], entry[1]);
+function logForDebugging(message, { level } = {
+  level: "debug"
+}) {
+  if (!shouldLogDebugMessage(message)) {
+    return;
   }
+  if (hasFormattedOutput && message.includes(`
+`)) {
+    message = JSON.stringify(message);
+  }
+  const timestamp = new Date().toISOString();
+  const output = `${timestamp} [${level.toUpperCase()}] ${message.trim()}
+`;
+  if (isDebugToStdErr()) {
+    writeToStderr(output);
+    return;
+  }
+  getDebugWriter().write(output);
 }
-ListCache.prototype.clear = _listCacheClear_default;
-ListCache.prototype["delete"] = _listCacheDelete_default;
-ListCache.prototype.get = _listCacheGet_default;
-ListCache.prototype.has = _listCacheHas_default;
-ListCache.prototype.set = _listCacheSet_default;
-var _ListCache_default = ListCache;
-
-// ../node_modules/lodash-es/_Map.js
-var Map2 = _getNative_default(_root_default, "Map");
-var _Map_default = Map2;
-
-// ../node_modules/lodash-es/_mapCacheClear.js
-function mapCacheClear() {
-  this.size = 0;
-  this.__data__ = {
-    hash: new _Hash_default,
-    map: new (_Map_default || _ListCache_default),
-    string: new _Hash_default
-  };
-}
-var _mapCacheClear_default = mapCacheClear;
-
-// ../node_modules/lodash-es/_isKeyable.js
-function isKeyable(value) {
-  var type = typeof value;
-  return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
-}
-var _isKeyable_default = isKeyable;
-
-// ../node_modules/lodash-es/_getMapData.js
-function getMapData(map, key) {
-  var data = map.__data__;
-  return _isKeyable_default(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+function getDebugLogPath() {
+  return process.env.CLAUDE_CODE_DEBUG_LOGS_DIR ?? join2(getClaudeConfigHomeDir(), "debug", `${getSessionId()}.txt`);
 }
-var _getMapData_default = getMapData;
+var updateLatestDebugLogSymlink = memoize_default(() => {
+  if (process.argv[2] === "--ripgrep") {
+    return;
+  }
+  try {
+    const debugLogPath = getDebugLogPath();
+    const debugLogsDir = dirname(debugLogPath);
+    const latestSymlinkPath = join2(debugLogsDir, "latest");
+    if (!getFsImplementation().existsSync(debugLogsDir)) {
+      getFsImplementation().mkdirSync(debugLogsDir);
+    }
+    if (getFsImplementation().existsSync(latestSymlinkPath)) {
+      try {
+        getFsImplementation().unlinkSync(latestSymlinkPath);
+      } catch {}
+    }
+    getFsImplementation().symlinkSync(debugLogPath, latestSymlinkPath);
+  } catch {}
+});
 
-// ../node_modules/lodash-es/_mapCacheDelete.js
-function mapCacheDelete(key) {
-  var result = _getMapData_default(this, key)["delete"](key);
-  this.size -= result ? 1 : 0;
-  return result;
+// ../src/utils/fsOperations.ts
+var SLOW_SYNC_THRESHOLD_MS = 5;
+function withSlowLogging(operation, fn) {
+  const startTime = performance.now();
+  try {
+    return fn();
+  } finally {
+    const duration = performance.now() - startTime;
+    if (duration > SLOW_SYNC_THRESHOLD_MS) {
+      logForDebugging(`[SLOW OPERATION DETECTED] fs.${operation} (${duration.toFixed(1)}ms)`);
+    }
+  }
 }
-var _mapCacheDelete_default = mapCacheDelete;
-
-// ../node_modules/lodash-es/_mapCacheGet.js
-function mapCacheGet(key) {
-  return _getMapData_default(this, key).get(key);
+var NodeFsOperations = {
+  cwd() {
+    return process.cwd();
+  },
+  existsSync(fsPath) {
+    return withSlowLogging("existsSync", () => fs.existsSync(fsPath));
+  },
+  async stat(fsPath) {
+    return statPromise(fsPath);
+  },
+  statSync(fsPath) {
+    return withSlowLogging("statSync", () => fs.statSync(fsPath));
+  },
+  lstatSync(fsPath) {
+    return withSlowLogging("lstatSync", () => fs.lstatSync(fsPath));
+  },
+  readFileSync(fsPath, options) {
+    return withSlowLogging("readFileSync", () => fs.readFileSync(fsPath, { encoding: options.encoding }));
+  },
+  readFileBytesSync(fsPath) {
+    return withSlowLogging("readFileBytesSync", () => fs.readFileSync(fsPath));
+  },
+  readSync(fsPath, options) {
+    return withSlowLogging("readSync", () => {
+      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) {
+    return withSlowLogging("writeFileSync", () => {
+      const fileExists = fs.existsSync(fsPath);
+      if (!options.flush) {
+        const writeOptions = {
+          encoding: options.encoding
+        };
+        if (!fileExists) {
+          writeOptions.mode = options.mode ?? 384;
+        } else if (options.mode !== undefined) {
+          writeOptions.mode = options.mode;
+        }
+        fs.writeFileSync(fsPath, data, writeOptions);
+        return;
+      }
+      let fd;
+      try {
+        const mode = !fileExists ? options.mode ?? 384 : options.mode;
+        fd = fs.openSync(fsPath, "w", mode);
+        fs.writeFileSync(fd, data, { encoding: options.encoding });
+        fs.fsyncSync(fd);
+      } finally {
+        if (fd) {
+          fs.closeSync(fd);
+        }
+      }
+    });
+  },
+  appendFileSync(path, data, options) {
+    return withSlowLogging("appendFileSync", () => {
+      if (!fs.existsSync(path)) {
+        const mode = options?.mode ?? 384;
+        const fd = fs.openSync(path, "a", mode);
+        try {
+          fs.appendFileSync(fd, data);
+        } finally {
+          fs.closeSync(fd);
+        }
+      } else {
+        fs.appendFileSync(path, data);
+      }
+    });
+  },
+  copyFileSync(src, dest) {
+    return withSlowLogging("copyFileSync", () => fs.copyFileSync(src, dest));
+  },
+  unlinkSync(path) {
+    return withSlowLogging("unlinkSync", () => fs.unlinkSync(path));
+  },
+  renameSync(oldPath, newPath) {
+    return withSlowLogging("renameSync", () => fs.renameSync(oldPath, newPath));
+  },
+  linkSync(target, path) {
+    return withSlowLogging("linkSync", () => fs.linkSync(target, path));
+  },
+  symlinkSync(target, path) {
+    return withSlowLogging("symlinkSync", () => fs.symlinkSync(target, path));
+  },
+  readlinkSync(path) {
+    return withSlowLogging("readlinkSync", () => fs.readlinkSync(path));
+  },
+  realpathSync(path) {
+    return withSlowLogging("realpathSync", () => fs.realpathSync(path));
+  },
+  mkdirSync(dirPath) {
+    return withSlowLogging("mkdirSync", () => {
+      if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true, mode: 448 });
+      }
+    });
+  },
+  readdirSync(dirPath) {
+    return withSlowLogging("readdirSync", () => fs.readdirSync(dirPath, { withFileTypes: true }));
+  },
+  readdirStringSync(dirPath) {
+    return withSlowLogging("readdirStringSync", () => fs.readdirSync(dirPath));
+  },
+  isDirEmptySync(dirPath) {
+    return withSlowLogging("isDirEmptySync", () => {
+      const files = this.readdirSync(dirPath);
+      return files.length === 0;
+    });
+  },
+  rmdirSync(dirPath) {
+    return withSlowLogging("rmdirSync", () => fs.rmdirSync(dirPath));
+  },
+  rmSync(path, options) {
+    return withSlowLogging("rmSync", () => fs.rmSync(path, options));
+  },
+  createWriteStream(path) {
+    return fs.createWriteStream(path);
+  }
+};
+var activeFs = NodeFsOperations;
+function getFsImplementation() {
+  return activeFs;
 }
-var _mapCacheGet_default = mapCacheGet;
 
-// ../node_modules/lodash-es/_mapCacheHas.js
-function mapCacheHas(key) {
-  return _getMapData_default(this, key).has(key);
+// ../src/entrypoints/agentSdkTypes.ts
+var HOOK_EVENTS = [
+  "PreToolUse",
+  "PostToolUse",
+  "PostToolUseFailure",
+  "Notification",
+  "UserPromptSubmit",
+  "SessionStart",
+  "SessionEnd",
+  "Stop",
+  "SubagentStart",
+  "SubagentStop",
+  "PreCompact",
+  "PermissionRequest"
+];
+var EXIT_REASONS = [
+  "clear",
+  "logout",
+  "prompt_input_exit",
+  "other",
+  "bypass_permissions_disabled"
+];
+class AbortError extends Error {
 }
-var _mapCacheHas_default = mapCacheHas;
 
-// ../node_modules/lodash-es/_mapCacheSet.js
-function mapCacheSet(key, value) {
-  var data = _getMapData_default(this, key), size = data.size;
-  data.set(key, value);
-  this.size += data.size == size ? 0 : 1;
-  return this;
+// ../src/utils/bundledMode.ts
+function isRunningWithBun() {
+  return process.versions.bun !== undefined;
 }
-var _mapCacheSet_default = mapCacheSet;
 
-// ../node_modules/lodash-es/_MapCache.js
-function MapCache(entries) {
-  var index = -1, length = entries == null ? 0 : entries.length;
-  this.clear();
-  while (++index < length) {
-    var entry = entries[index];
-    this.set(entry[0], entry[1]);
+// ../src/utils/sdkDebug.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { appendFileSync as appendFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join3 } from "path";
+var debugFilePath = null;
+var initialized = false;
+function getOrCreateDebugFile() {
+  if (initialized) {
+    return debugFilePath;
   }
-}
-MapCache.prototype.clear = _mapCacheClear_default;
-MapCache.prototype["delete"] = _mapCacheDelete_default;
-MapCache.prototype.get = _mapCacheGet_default;
-MapCache.prototype.has = _mapCacheHas_default;
-MapCache.prototype.set = _mapCacheSet_default;
-var _MapCache_default = MapCache;
-
-// ../node_modules/lodash-es/memoize.js
-var FUNC_ERROR_TEXT = "Expected a function";
-function memoize(func, resolver) {
-  if (typeof func != "function" || resolver != null && typeof resolver != "function") {
-    throw new TypeError(FUNC_ERROR_TEXT);
+  initialized = true;
+  if (!process.env.DEBUG_CLAUDE_AGENT_SDK) {
+    return null;
+  }
+  const debugDir = join3(getClaudeConfigHomeDir(), "debug");
+  debugFilePath = join3(debugDir, `sdk-${randomUUID2()}.txt`);
+  if (!existsSync2(debugDir)) {
+    mkdirSync2(debugDir, { recursive: true });
+  }
+  process.stderr.write(`SDK debug logs: ${debugFilePath}
+`);
+  return debugFilePath;
+}
+function logForSdkDebugging(message) {
+  const path = getOrCreateDebugFile();
+  if (!path) {
+    return;
   }
-  var memoized = function() {
-    var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
-    if (cache.has(key)) {
-      return cache.get(key);
-    }
-    var result = func.apply(this, args);
-    memoized.cache = cache.set(key, result) || cache;
-    return result;
-  };
-  memoized.cache = new (memoize.Cache || _MapCache_default);
-  return memoized;
+  const timestamp = new Date().toISOString();
+  const output = `${timestamp} ${message}
+`;
+  appendFileSync2(path, output);
 }
-memoize.Cache = _MapCache_default;
-var memoize_default = memoize;
 
-// ../src/utils/process.ts
-var CHUNK_SIZE = 2000;
-function writeToStderr(data) {
-  for (let i = 0;i < data.length; i += CHUNK_SIZE) {
-    process.stderr.write(data.substring(i, i + CHUNK_SIZE));
+// ../src/transport/sandboxUtils.ts
+function mergeSandboxIntoExtraArgs(extraArgs, sandbox) {
+  const effectiveExtraArgs = { ...extraArgs };
+  if (sandbox) {
+    let settingsObj = { sandbox };
+    if (effectiveExtraArgs.settings) {
+      try {
+        const existingSettings = JSON.parse(effectiveExtraArgs.settings);
+        settingsObj = { ...existingSettings, sandbox };
+      } catch {}
+    }
+    effectiveExtraArgs.settings = JSON.stringify(settingsObj);
   }
+  return effectiveExtraArgs;
 }
 
-// ../src/utils/debugFilter.ts
-var parseDebugFilter = memoize_default((filterString) => {
-  if (!filterString || filterString.trim() === "") {
-    return null;
-  }
-  const filters = filterString.split(",").map((f) => f.trim()).filter(Boolean);
-  if (filters.length === 0) {
-    return null;
+// ../src/transport/ProcessTransport.ts
+class ProcessTransport {
+  options;
+  process;
+  processStdin;
+  processStdout;
+  ready = false;
+  abortController;
+  exitError;
+  exitListeners = [];
+  processExitHandler;
+  abortHandler;
+  constructor(options) {
+    this.options = options;
+    this.abortController = options.abortController || createAbortController();
+    this.initialize();
   }
-  const hasExclusive = filters.some((f) => f.startsWith("!"));
-  const hasInclusive = filters.some((f) => !f.startsWith("!"));
-  if (hasExclusive && hasInclusive) {
-    return null;
+  getDefaultExecutable() {
+    return isRunningWithBun() ? "bun" : "node";
+  }
+  spawnLocalProcess(spawnOptions) {
+    const { command, args, cwd: cwd2, env, signal } = spawnOptions;
+    const stderrMode = env.DEBUG_CLAUDE_AGENT_SDK || this.options.stderr ? "pipe" : "ignore";
+    const childProcess = spawn(command, args, {
+      cwd: cwd2,
+      stdio: ["pipe", "pipe", stderrMode],
+      signal,
+      env
+    });
+    if (env.DEBUG_CLAUDE_AGENT_SDK || this.options.stderr) {
+      childProcess.stderr.on("data", (data) => {
+        const message = data.toString();
+        logForSdkDebugging(message);
+        if (this.options.stderr) {
+          this.options.stderr(message);
+        }
+      });
+    }
+    const mappedProcess = {
+      stdin: childProcess.stdin,
+      stdout: childProcess.stdout,
+      get killed() {
+        return childProcess.killed;
+      },
+      get exitCode() {
+        return childProcess.exitCode;
+      },
+      kill: childProcess.kill.bind(childProcess),
+      on: childProcess.on.bind(childProcess),
+      once: childProcess.once.bind(childProcess),
+      off: childProcess.off.bind(childProcess)
+    };
+    return mappedProcess;
   }
-  const cleanFilters = filters.map((f) => f.replace(/^!/, "").toLowerCase());
-  return {
-    include: hasExclusive ? [] : cleanFilters,
-    exclude: hasExclusive ? cleanFilters : [],
-    isExclusive: hasExclusive
-  };
-});
-function extractDebugCategories(message) {
-  const categories = [];
-  const mcpMatch = message.match(/^MCP server ["']([^"']+)["']/);
-  if (mcpMatch && mcpMatch[1]) {
-    categories.push("mcp");
-    categories.push(mcpMatch[1].toLowerCase());
-  } else {
-    const prefixMatch = message.match(/^([^:[]+):/);
-    if (prefixMatch && prefixMatch[1]) {
-      categories.push(prefixMatch[1].trim().toLowerCase());
+  initialize() {
+    try {
+      const {
+        additionalDirectories = [],
+        betas,
+        cwd: cwd2,
+        executable = this.getDefaultExecutable(),
+        executableArgs = [],
+        extraArgs = {},
+        pathToClaudeCodeExecutable,
+        env = { ...process.env },
+        stderr,
+        maxThinkingTokens,
+        maxTurns,
+        maxBudgetUsd,
+        model,
+        fallbackModel,
+        jsonSchema,
+        permissionMode,
+        allowDangerouslySkipPermissions,
+        permissionPromptToolName,
+        continueConversation,
+        resume,
+        settingSources,
+        allowedTools = [],
+        disallowedTools = [],
+        tools,
+        mcpServers,
+        strictMcpConfig,
+        canUseTool,
+        includePartialMessages,
+        plugins,
+        sandbox
+      } = this.options;
+      const args = [
+        "--output-format",
+        "stream-json",
+        "--verbose",
+        "--input-format",
+        "stream-json"
+      ];
+      if (maxThinkingTokens !== undefined) {
+        args.push("--max-thinking-tokens", maxThinkingTokens.toString());
+      }
+      if (maxTurns)
+        args.push("--max-turns", maxTurns.toString());
+      if (maxBudgetUsd !== undefined) {
+        args.push("--max-budget-usd", maxBudgetUsd.toString());
+      }
+      if (model)
+        args.push("--model", model);
+      if (betas && betas.length > 0) {
+        args.push("--betas", betas.join(","));
+      }
+      if (jsonSchema) {
+        args.push("--json-schema", JSON.stringify(jsonSchema));
+      }
+      if (env.DEBUG_CLAUDE_AGENT_SDK) {
+        args.push("--debug-to-stderr");
+      }
+      if (canUseTool) {
+        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 (tools !== undefined) {
+        if (Array.isArray(tools)) {
+          if (tools.length === 0) {
+            args.push("--tools", "");
+          } else {
+            args.push("--tools", tools.join(","));
+          }
+        } else {
+          args.push("--tools", "default");
+        }
+      }
+      if (mcpServers && Object.keys(mcpServers).length > 0) {
+        args.push("--mcp-config", JSON.stringify({ mcpServers }));
+      }
+      if (settingSources) {
+        args.push("--setting-sources", settingSources.join(","));
+      }
+      if (strictMcpConfig) {
+        args.push("--strict-mcp-config");
+      }
+      if (permissionMode) {
+        args.push("--permission-mode", permissionMode);
+      }
+      if (allowDangerouslySkipPermissions) {
+        args.push("--allow-dangerously-skip-permissions");
+      }
+      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 (includePartialMessages) {
+        args.push("--include-partial-messages");
+      }
+      for (const dir of additionalDirectories) {
+        args.push("--add-dir", dir);
+      }
+      if (plugins && plugins.length > 0) {
+        for (const plugin of plugins) {
+          if (plugin.type === "local") {
+            args.push("--plugin-dir", plugin.path);
+          } else {
+            throw new Error(`Unsupported plugin type: ${plugin.type}`);
+          }
+        }
+      }
+      if (this.options.forkSession) {
+        args.push("--fork-session");
+      }
+      if (this.options.resumeSessionAt) {
+        args.push("--resume-session-at", this.options.resumeSessionAt);
+      }
+      if (this.options.persistSession === false) {
+        args.push("--no-session-persistence");
+      }
+      const effectiveExtraArgs = mergeSandboxIntoExtraArgs(extraArgs ?? {}, sandbox);
+      for (const [flag, value] of Object.entries(effectiveExtraArgs)) {
+        if (value === null) {
+          args.push(`--${flag}`);
+        } else {
+          args.push(`--${flag}`, value);
+        }
+      }
+      if (!env.CLAUDE_CODE_ENTRYPOINT) {
+        env.CLAUDE_CODE_ENTRYPOINT = "sdk-ts";
+      }
+      delete env.NODE_OPTIONS;
+      if (env.DEBUG_CLAUDE_AGENT_SDK) {
+        env.DEBUG = "1";
+      } else {
+        delete env.DEBUG;
+      }
+      const isNative = isNativeBinary(pathToClaudeCodeExecutable);
+      const spawnCommand = isNative ? pathToClaudeCodeExecutable : executable;
+      const spawnArgs = isNative ? [...executableArgs, ...args] : [...executableArgs, pathToClaudeCodeExecutable, ...args];
+      const spawnOptions = {
+        command: spawnCommand,
+        args: spawnArgs,
+        cwd: cwd2,
+        env,
+        signal: this.abortController.signal
+      };
+      if (this.options.spawnClaudeCodeProcess) {
+        logForSdkDebugging(`Spawning Claude Code (custom): ${spawnCommand} ${spawnArgs.join(" ")}`);
+        this.process = this.options.spawnClaudeCodeProcess(spawnOptions);
+      } else {
+        const fs2 = getFsImplementation();
+        if (!fs2.existsSync(pathToClaudeCodeExecutable)) {
+          const errorMessage = isNative ? `Claude Code native binary not found at ${pathToClaudeCodeExecutable}. Please ensure Claude Code is installed via native installer or specify a valid path with options.pathToClaudeCodeExecutable.` : `Claude Code executable not found at ${pathToClaudeCodeExecutable}. Is options.pathToClaudeCodeExecutable set?`;
+          throw new ReferenceError(errorMessage);
+        }
+        const spawnMessage = `Spawning Claude Code: ${spawnCommand} ${spawnArgs.join(" ")}`;
+        logForSdkDebugging(spawnMessage);
+        if (stderr) {
+          stderr(spawnMessage);
+        }
+        this.process = this.spawnLocalProcess(spawnOptions);
+      }
+      this.processStdin = this.process.stdin;
+      this.processStdout = this.process.stdout;
+      const cleanup = () => {
+        if (this.process && !this.process.killed) {
+          this.process.kill("SIGTERM");
+        }
+      };
+      this.processExitHandler = cleanup;
+      this.abortHandler = cleanup;
+      process.on("exit", this.processExitHandler);
+      this.abortController.signal.addEventListener("abort", this.abortHandler);
+      this.process.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}`);
+          logForSdkDebugging(this.exitError.message);
+        }
+      });
+      this.process.on("exit", (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;
+            logForSdkDebugging(error.message);
+          }
+        }
+      });
+      this.ready = true;
+    } catch (error) {
+      this.ready = false;
+      throw error;
     }
   }
-  const bracketMatch = message.match(/^\[([^\]]+)]/);
-  if (bracketMatch && bracketMatch[1]) {
-    categories.push(bracketMatch[1].trim().toLowerCase());
-  }
-  if (message.toLowerCase().includes("statsig event:")) {
-    categories.push("statsig");
-  }
-  const secondaryMatch = message.match(/:\s*([^:]+?)(?:\s+(?:type|mode|status|event))?:/);
-  if (secondaryMatch && secondaryMatch[1]) {
-    const secondary = secondaryMatch[1].trim().toLowerCase();
-    if (secondary.length < 30 && !secondary.includes(" ")) {
-      categories.push(secondary);
+  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;
   }
-  return Array.from(new Set(categories));
-}
-function shouldShowDebugCategories(categories, filter) {
-  if (!filter) {
-    return true;
-  }
-  if (categories.length === 0) {
-    return false;
-  }
-  if (filter.isExclusive) {
-    return !categories.some((cat) => filter.exclude.includes(cat));
-  } else {
-    return categories.some((cat) => filter.include.includes(cat));
-  }
-}
-function shouldShowDebugMessage(message, filter) {
-  if (!filter) {
-    return true;
-  }
-  const categories = extractDebugCategories(message);
-  return shouldShowDebugCategories(categories, filter);
-}
-
-// ../src/utils/debug.ts
-import { dirname, join as join3 } from "path";
-
-// ../src/bootstrap/state.ts
-import { cwd } from "process";
-import { realpathSync as realpathSync2 } from "fs";
-import { randomUUID as randomUUID2 } from "crypto";
-
-// ../src/bootstrap/envValidators.ts
-var bashMaxOutputLengthValidator = {
-  name: "BASH_MAX_OUTPUT_LENGTH",
-  default: 30000,
-  validate: (value) => {
-    const MAX_OUTPUT_LENGTH = 150000;
-    const DEFAULT_MAX_OUTPUT_LENGTH = 30000;
-    if (!value) {
-      return {
-        effective: DEFAULT_MAX_OUTPUT_LENGTH,
-        status: "valid"
-      };
+  write(data) {
+    if (this.abortController.signal.aborted) {
+      throw new AbortError("Operation aborted");
     }
-    const parsed = parseInt(value, 10);
-    if (isNaN(parsed) || parsed <= 0) {
-      return {
-        effective: DEFAULT_MAX_OUTPUT_LENGTH,
-        status: "invalid",
-        message: `Invalid value "${value}" (using default: ${DEFAULT_MAX_OUTPUT_LENGTH})`
-      };
+    if (!this.ready || !this.processStdin) {
+      throw new Error("ProcessTransport is not ready for writing");
     }
-    if (parsed > MAX_OUTPUT_LENGTH) {
-      return {
-        effective: MAX_OUTPUT_LENGTH,
-        status: "capped",
-        message: `Capped from ${parsed} to ${MAX_OUTPUT_LENGTH}`
-      };
+    if (this.process?.killed || this.process?.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}`);
+    }
+    logForSdkDebugging(`[ProcessTransport] Writing to stdin: ${data.substring(0, 100)}`);
+    try {
+      const written = this.processStdin.write(data);
+      if (!written) {
+        logForSdkDebugging("[ProcessTransport] Write buffer full, data queued");
+      }
+    } catch (error) {
+      this.ready = false;
+      throw new Error(`Failed to write to process stdin: ${error.message}`);
     }
-    return { effective: parsed, status: "valid" };
   }
-};
-var maxOutputTokensValidator = {
-  name: "CLAUDE_CODE_MAX_OUTPUT_TOKENS",
-  default: 32000,
-  validate: (value) => {
-    const MAX_OUTPUT_TOKENS = 64000;
-    const DEFAULT_MAX_OUTPUT_TOKENS = 32000;
-    if (!value) {
-      return { effective: DEFAULT_MAX_OUTPUT_TOKENS, status: "valid" };
+  close() {
+    if (this.processStdin) {
+      this.processStdin.end();
+      this.processStdin = undefined;
     }
-    const parsed = parseInt(value, 10);
-    if (isNaN(parsed) || parsed <= 0) {
-      return {
-        effective: DEFAULT_MAX_OUTPUT_TOKENS,
-        status: "invalid",
-        message: `Invalid value "${value}" (using default: ${DEFAULT_MAX_OUTPUT_TOKENS})`
-      };
+    if (this.abortHandler) {
+      this.abortController.signal.removeEventListener("abort", this.abortHandler);
+      this.abortHandler = undefined;
     }
-    if (parsed > MAX_OUTPUT_TOKENS) {
-      return {
-        effective: MAX_OUTPUT_TOKENS,
-        status: "capped",
-        message: `Capped from ${parsed} to ${MAX_OUTPUT_TOKENS}`
-      };
+    for (const { handler } of this.exitListeners) {
+      this.process?.off("exit", handler);
+    }
+    this.exitListeners = [];
+    if (this.process && !this.process.killed) {
+      this.process.kill("SIGTERM");
+      setTimeout(() => {
+        if (this.process && !this.process.killed) {
+          this.process.kill("SIGKILL");
+        }
+      }, 5000);
+    }
+    this.ready = false;
+    if (this.processExitHandler) {
+      process.off("exit", this.processExitHandler);
+      this.processExitHandler = undefined;
     }
-    return { effective: parsed, status: "valid" };
   }
-};
-
-// ../src/bootstrap/state.ts
-function getInitialState() {
-  let resolvedCwd = "";
-  if (typeof process !== "undefined" && typeof process.cwd === "function") {
-    resolvedCwd = realpathSync2(cwd());
+  isReady() {
+    return this.ready;
   }
-  return {
-    originalCwd: resolvedCwd,
-    totalCostUSD: 0,
-    totalAPIDuration: 0,
-    totalAPIDurationWithoutRetries: 0,
-    totalToolDuration: 0,
-    startTime: Date.now(),
-    lastInteractionTime: Date.now(),
-    totalLinesAdded: 0,
-    totalLinesRemoved: 0,
-    hasUnknownModelCost: false,
-    cwd: resolvedCwd,
-    modelUsage: {},
-    mainLoopModelOverride: undefined,
-    initialMainLoopModel: null,
-    modelStrings: null,
-    isInteractive: false,
-    clientType: "cli",
-    sessionIngressToken: undefined,
-    oauthTokenFromFd: undefined,
-    apiKeyFromFd: undefined,
-    flagSettingsPath: undefined,
-    allowedSettingSources: [
-      "userSettings",
-      "projectSettings",
-      "localSettings",
-      "flagSettings",
-      "policySettings"
-    ],
-    meter: null,
-    sessionCounter: null,
-    locCounter: null,
-    prCounter: null,
-    commitCounter: null,
-    costCounter: null,
-    tokenCounter: null,
-    codeEditToolDecisionCounter: null,
-    activeTimeCounter: null,
-    sessionId: randomUUID2(),
-    loggerProvider: null,
-    eventLogger: null,
-    meterProvider: null,
-    tracerProvider: null,
-    agentColorMap: new Map,
-    agentColorIndex: 0,
-    envVarValidators: [bashMaxOutputLengthValidator, maxOutputTokensValidator],
-    lastAPIRequest: null,
-    inMemoryErrorLog: [],
-    inlinePlugins: [],
-    sessionBypassPermissionsMode: false,
-    hasExitedPlanMode: false,
-    needsPlanModeExitAttachment: false,
-    initJsonSchema: null,
-    registeredHooks: null,
-    planSlugCache: new Map
-  };
-}
-var STATE = getInitialState();
-function getSessionId() {
-  return STATE.sessionId;
-}
-
-// ../src/utils/bufferedWriter.ts
-function createBufferedWriter({
-  writeFn,
-  flushIntervalMs = 1000,
-  maxBufferSize = 100,
-  immediateMode = false
-}) {
-  let buffer = [];
-  let flushTimer = null;
-  function clearTimer() {
-    if (flushTimer) {
-      clearTimeout(flushTimer);
-      flushTimer = null;
+  async* readMessages() {
+    if (!this.processStdout) {
+      throw new Error("ProcessTransport output stream not available");
+    }
+    const rl = createInterface({ input: this.processStdout });
+    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.processStdin) {
+      this.processStdin.end();
     }
   }
-  function flush() {
-    if (buffer.length === 0)
+  getInputStream() {
+    return this.processStdin;
+  }
+  onExit(callback) {
+    if (!this.process)
+      return () => {};
+    const handler = (code, signal) => {
+      const error = this.getProcessExitError(code, signal);
+      callback(error);
+    };
+    this.process.on("exit", handler);
+    this.exitListeners.push({ callback, handler });
+    return () => {
+      if (this.process) {
+        this.process.off("exit", handler);
+      }
+      const index = this.exitListeners.findIndex((l) => l.handler === handler);
+      if (index !== -1) {
+        this.exitListeners.splice(index, 1);
+      }
+    };
+  }
+  async waitForExit() {
+    if (!this.process) {
+      if (this.exitError) {
+        throw this.exitError;
+      }
       return;
-    writeFn(buffer.join(""));
-    buffer = [];
-    clearTimer();
-  }
-  function scheduleFlush() {
-    if (!flushTimer) {
-      flushTimer = setTimeout(flush, flushIntervalMs);
     }
-  }
-  return {
-    write(content) {
-      if (immediateMode) {
-        writeFn(content);
-        return;
-      }
-      buffer.push(content);
-      scheduleFlush();
-      if (buffer.length >= maxBufferSize) {
-        flush();
+    if (this.process.exitCode !== null || this.process.killed) {
+      if (this.exitError) {
+        throw this.exitError;
       }
-    },
-    flush,
-    dispose() {
-      flush();
+      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.process.once("exit", exitHandler);
+      const errorHandler = (error) => {
+        this.process.off("exit", exitHandler);
+        reject(error);
+      };
+      this.process.once("error", errorHandler);
+      this.process.once("exit", () => {
+        this.process.off("error", errorHandler);
+      });
+    });
+  }
 }
-
-// ../src/utils/cleanupRegistry.ts
-var cleanupFunctions = new Set;
-function registerCleanup(cleanupFn) {
-  cleanupFunctions.add(cleanupFn);
-  return () => cleanupFunctions.delete(cleanupFn);
+function isNativeBinary(executablePath) {
+  const jsExtensions = [".js", ".mjs", ".tsx", ".ts", ".jsx"];
+  return !jsExtensions.some((ext) => executablePath.endsWith(ext));
 }
 
-// ../src/utils/debug.ts
-var isDebugMode = memoize_default(() => {
-  return isEnvTruthy(process.env.DEBUG) || isEnvTruthy(process.env.DEBUG_SDK) || process.argv.includes("--debug") || process.argv.includes("-d") || isDebugToStdErr() || process.argv.some((arg) => arg.startsWith("--debug="));
-});
-var getDebugFilter = memoize_default(() => {
-  const debugArg = process.argv.find((arg) => arg.startsWith("--debug="));
-  if (!debugArg) {
-    return null;
+// ../src/utils/stream.ts
+class Stream {
+  returned;
+  queue = [];
+  readResolve;
+  readReject;
+  isDone = false;
+  hasError;
+  started = false;
+  constructor(returned) {
+    this.returned = returned;
   }
-  const filterPattern = debugArg.substring("--debug=".length);
-  return parseDebugFilter(filterPattern);
-});
-var isDebugToStdErr = memoize_default(() => {
-  return process.argv.includes("--debug-to-stderr") || process.argv.includes("-d2e");
-});
-function shouldLogDebugMessage(message) {
-  if (false) {}
-  if (typeof process === "undefined" || typeof process.versions === "undefined" || typeof process.versions.node === "undefined") {
-    return false;
+  [Symbol.asyncIterator]() {
+    if (this.started) {
+      throw new Error("Stream can only be iterated once");
+    }
+    this.started = true;
+    return this;
   }
-  const filter = getDebugFilter();
-  return shouldShowDebugMessage(message, filter);
-}
-var hasFormattedOutput = false;
-var debugWriter = null;
-function getDebugWriter() {
-  if (!debugWriter) {
-    debugWriter = createBufferedWriter({
-      writeFn: (content) => {
-        const path = getDebugLogPath();
-        if (!getFsImplementation().existsSync(dirname(path))) {
-          getFsImplementation().mkdirSync(dirname(path));
-        }
-        getFsImplementation().appendFileSync(path, content);
-        updateLatestDebugLogSymlink();
-      },
-      flushIntervalMs: 1000,
-      maxBufferSize: 100,
-      immediateMode: isDebugMode()
+  next() {
+    if (this.queue.length > 0) {
+      return Promise.resolve({
+        done: false,
+        value: this.queue.shift()
+      });
+    }
+    if (this.isDone) {
+      return Promise.resolve({ done: true, value: undefined });
+    }
+    if (this.hasError) {
+      return Promise.reject(this.hasError);
+    }
+    return new Promise((resolve, reject) => {
+      this.readResolve = resolve;
+      this.readReject = reject;
     });
-    registerCleanup(async () => debugWriter?.dispose());
   }
-  return debugWriter;
-}
-function logForDebugging(message, { level } = {
-  level: "debug"
-}) {
-  if (!shouldLogDebugMessage(message)) {
-    return;
+  enqueue(value) {
+    if (this.readResolve) {
+      const resolve = this.readResolve;
+      this.readResolve = undefined;
+      this.readReject = undefined;
+      resolve({ done: false, value });
+    } else {
+      this.queue.push(value);
+    }
   }
-  if (hasFormattedOutput && message.includes(`
-`)) {
-    message = JSON.stringify(message);
+  done() {
+    this.isDone = true;
+    if (this.readResolve) {
+      const resolve = this.readResolve;
+      this.readResolve = undefined;
+      this.readReject = undefined;
+      resolve({ done: true, value: undefined });
+    }
   }
-  const timestamp = new Date().toISOString();
-  const output = `${timestamp} [${level.toUpperCase()}] ${message.trim()}
-`;
-  if (isDebugToStdErr()) {
-    writeToStderr(output);
-    return;
+  error(error) {
+    this.hasError = error;
+    if (this.readReject) {
+      const reject = this.readReject;
+      this.readResolve = undefined;
+      this.readReject = undefined;
+      reject(error);
+    }
+  }
+  return() {
+    this.isDone = true;
+    if (this.returned) {
+      this.returned();
+    }
+    return Promise.resolve({ done: true, value: undefined });
   }
-  getDebugWriter().write(output);
-}
-function getDebugLogPath() {
-  return process.env.CLAUDE_CODE_DEBUG_LOGS_DIR ?? join3(getClaudeConfigHomeDir(), "debug", `${getSessionId()}.txt`);
 }
-var updateLatestDebugLogSymlink = memoize_default(() => {
-  try {
-    const debugLogPath = getDebugLogPath();
-    const debugLogsDir = dirname(debugLogPath);
-    const latestSymlinkPath = join3(debugLogsDir, "latest");
-    if (!getFsImplementation().existsSync(debugLogsDir)) {
-      getFsImplementation().mkdirSync(debugLogsDir);
+
+// ../src/services/mcp/SdkControlTransport.ts
+class SdkControlServerTransport {
+  sendMcpMessage;
+  isClosed = false;
+  constructor(sendMcpMessage) {
+    this.sendMcpMessage = sendMcpMessage;
+  }
+  onclose;
+  onerror;
+  onmessage;
+  async start() {}
+  async send(message) {
+    if (this.isClosed) {
+      throw new Error("Transport is closed");
     }
-    if (getFsImplementation().existsSync(latestSymlinkPath)) {
-      try {
-        getFsImplementation().unlinkSync(latestSymlinkPath);
-      } catch {}
+    this.sendMcpMessage(message);
+  }
+  async close() {
+    if (this.isClosed) {
+      return;
     }
-    getFsImplementation().symlinkSync(debugLogPath, latestSymlinkPath);
-  } catch {}
-});
+    this.isClosed = true;
+    this.onclose?.();
+  }
+}
 
 // ../src/core/Query.ts
 import { randomUUID as randomUUID3 } from "crypto";
 
 class Query {
   transport;
-  isSingleUserTurn;
   canUseTool;
   hooks;
   abortController;
@@ -7713,18 +7778,23 @@ class Query {
   nextCallbackId = 0;
   sdkMcpTransports = new Map;
   pendingMcpResponses = new Map;
-  firstResultReceivedPromise;
-  firstResultReceivedResolve;
+  lastActivityTime = Date.now();
+  userInputEndedResolve;
   streamCloseTimeout;
-  constructor(transport, isSingleUserTurn, canUseTool, hooks, abortController, sdkMcpServers = new Map, jsonSchema, initConfig) {
+  resetLastActivityTime() {
+    this.lastActivityTime = Date.now();
+  }
+  hasBidirectionalNeeds() {
+    return this.sdkMcpTransports.size > 0 || this.hooks !== undefined && Object.keys(this.hooks).length > 0 || this.canUseTool !== undefined;
+  }
+  constructor(transport, _isSingleUserTurn, canUseTool, hooks, abortController, sdkMcpServers = new Map, jsonSchema, initConfig) {
     this.transport = transport;
-    this.isSingleUserTurn = isSingleUserTurn;
     this.canUseTool = canUseTool;
     this.hooks = hooks;
     this.abortController = abortController;
     this.jsonSchema = jsonSchema;
     this.initConfig = initConfig;
-    this.streamCloseTimeout = 60000;
+    this.streamCloseTimeout = 5000;
     if (typeof process !== "undefined" && process.env?.CLAUDE_CODE_STREAM_CLOSE_TIMEOUT) {
       this.streamCloseTimeout = parseInt(process.env.CLAUDE_CODE_STREAM_CLOSE_TIMEOUT);
     }
@@ -7734,9 +7804,6 @@ class Query {
       server.connect(sdkTransport);
     }
     this.sdkMessages = this.readSdkMessages();
-    this.firstResultReceivedPromise = new Promise((resolve) => {
-      this.firstResultReceivedResolve = resolve;
-    });
     this.readMessages();
     this.initialization = this.initialize();
     this.initialization.catch(() => {});
@@ -7785,6 +7852,7 @@ class Query {
   async readMessages() {
     try {
       for await (const message of this.transport.readMessages()) {
+        this.resetLastActivityTime();
         if (message.type === "control_response") {
           const handler = this.pendingControlResponses.get(message.response.request_id);
           if (handler) {
@@ -7800,19 +7868,17 @@ class Query {
         } else if (message.type === "keep_alive") {
           continue;
         }
-        if (message.type === "result") {
-          if (this.firstResultReceivedResolve) {
-            this.firstResultReceivedResolve();
-          }
-          if (this.isSingleUserTurn) {
-            this.transport.endInput();
-          }
-        }
         this.inputStream.enqueue(message);
       }
+      if (this.userInputEndedResolve) {
+        this.userInputEndedResolve();
+      }
       this.inputStream.done();
       this.cleanup();
     } catch (error) {
+      if (this.userInputEndedResolve) {
+        this.userInputEndedResolve();
+      }
       this.inputStream.error(error);
       this.cleanup(error);
     }
@@ -7955,9 +8021,9 @@ class Query {
       max_thinking_tokens: maxThinkingTokens
     });
   }
-  async rewindCode(userMessageId) {
+  async rewindFiles(userMessageId) {
     await this.request({
-      subtype: "rewind_code",
+      subtype: "rewind_files",
       user_message_id: userMessageId
     });
   }
@@ -8008,7 +8074,6 @@ class Query {
   }
   async streamInput(stream) {
     logForDebugging(`[Query.streamInput] Starting to process input stream`);
-    logForDebugging(`[Query.streamInput] this.sdkMcpTransports.size = ${this.sdkMcpTransports.size}`);
     try {
       let messageCount = 0;
       for await (const message of stream) {
@@ -8020,28 +8085,9 @@ class Query {
 `));
       }
       logForDebugging(`[Query.streamInput] Finished processing ${messageCount} messages from input stream`);
-      logForDebugging(`[Query.streamInput] About to check MCP servers. this.sdkMcpTransports.size = ${this.sdkMcpTransports.size}`);
-      const hasHooks = this.hooks && Object.keys(this.hooks).length > 0;
-      if ((this.sdkMcpTransports.size > 0 || hasHooks) && this.firstResultReceivedPromise) {
-        logForDebugging(`[Query.streamInput] Entering Promise.race to wait for result`);
-        let timeoutId;
-        await Promise.race([
-          this.firstResultReceivedPromise.then(() => {
-            logForDebugging(`[Query.streamInput] Received first result, closing input stream`);
-            if (timeoutId) {
-              clearTimeout(timeoutId);
-            }
-          }),
-          new Promise((resolve) => {
-            timeoutId = setTimeout(() => {
-              logForDebugging(`[Query.streamInput] Timed out waiting for first result, closing input stream`);
-              resolve();
-            }, this.streamCloseTimeout);
-          })
-        ]);
-        if (timeoutId) {
-          clearTimeout(timeoutId);
-        }
+      if (this.hasBidirectionalNeeds()) {
+        logForDebugging(`[Query.streamInput] Has bidirectional needs, waiting for inactivity`);
+        await this.waitForInactivity();
       }
       logForDebugging(`[Query] Calling transport.endInput() to close stdin to CLI process`);
       this.transport.endInput();
@@ -8051,6 +8097,43 @@ class Query {
       }
     }
   }
+  async handleSingleTurnInputComplete() {
+    if (this.hasBidirectionalNeeds()) {
+      logForDebugging(`[Query.handleSingleTurnInputComplete] Has bidirectional needs, waiting for inactivity`);
+      await this.waitForInactivity();
+    }
+    logForDebugging(`[Query.handleSingleTurnInputComplete] Calling transport.endInput()`);
+    this.transport.endInput();
+  }
+  async waitForInactivity() {
+    logForDebugging(`[Query.waitForInactivity] Waiting for inactivity (timeout: ${this.streamCloseTimeout}ms)`);
+    return new Promise((resolve) => {
+      this.userInputEndedResolve = resolve;
+      if (this.abortController?.signal.aborted) {
+        resolve();
+        return;
+      }
+      this.abortController?.signal.addEventListener("abort", () => resolve(), {
+        once: true
+      });
+      const checkInactivity = () => {
+        if (this.abortController?.signal.aborted) {
+          resolve();
+          return;
+        }
+        const elapsed = Date.now() - this.lastActivityTime;
+        if (elapsed >= this.streamCloseTimeout) {
+          logForDebugging(`[Query.waitForInactivity] Inactivity timeout reached (${elapsed}ms elapsed). ` + `Closing stdin. If your tools or hooks need more time, set CLAUDE_CODE_STREAM_CLOSE_TIMEOUT ` + `to a higher value (current: ${this.streamCloseTimeout}ms).`);
+          resolve();
+        } else {
+          const remaining = this.streamCloseTimeout - elapsed;
+          logForDebugging(`[Query.waitForInactivity] Still active, checking again in ${remaining}ms`);
+          setTimeout(checkInactivity, remaining);
+        }
+      };
+      checkInactivity();
+    });
+  }
   handleHookCallbacks(callbackId, input, toolUseID, abortSignal) {
     const callback = this.hookCallbacks.get(callbackId);
     if (!callback) {
@@ -8121,7 +8204,17 @@ class SessionImpl {
   query;
   queryIterator = null;
   abortController;
+  _sessionId = null;
+  get sessionId() {
+    if (this._sessionId === null) {
+      throw new Error("Session ID not available until after receiving messages");
+    }
+    return this._sessionId;
+  }
   constructor(options) {
+    if (options.resume) {
+      this._sessionId = options.resume;
+    }
     this.inputStream = new Stream;
     let pathToClaudeCodeExecutable = options.pathToClaudeCodeExecutable;
     if (!pathToClaudeCodeExecutable) {
@@ -8129,7 +8222,7 @@ class SessionImpl {
       const dirname2 = join4(filename, "..");
       pathToClaudeCodeExecutable = join4(dirname2, "cli.js");
     }
-    const processEnv = { ...process.env };
+    const processEnv = { ...options.env ?? process.env };
     if (!processEnv.CLAUDE_CODE_ENTRYPOINT) {
       processEnv.CLAUDE_CODE_ENTRYPOINT = "sdk-ts";
     }
@@ -8188,6 +8281,9 @@ class SessionImpl {
       if (done) {
         return;
       }
+      if (value.type === "system" && value.subtype === "init") {
+        this._sessionId = value.session_id;
+      }
       yield value;
       if (value.type === "result") {
         return;
@@ -15113,7 +15209,7 @@ function query({
     const dirname2 = join5(filename, "..");
     pathToClaudeCodeExecutable = join5(dirname2, "cli.js");
   }
-  process.env.CLAUDE_AGENT_SDK_VERSION = "0.1.62";
+  process.env.CLAUDE_AGENT_SDK_VERSION = "0.1.65";
   const {
     abortController = createAbortController(),
     additionalDirectories = [],
@@ -15130,9 +15226,11 @@ function query({
     executableArgs = [],
     extraArgs = {},
     fallbackModel,
+    enableFileCheckpointing,
     forkSession,
     hooks,
     includePartialMessages,
+    persistSession,
     maxThinkingTokens,
     maxTurns,
     maxBudgetUsd,
@@ -15156,6 +15254,9 @@ function query({
   if (!processEnv.CLAUDE_CODE_ENTRYPOINT) {
     processEnv.CLAUDE_CODE_ENTRYPOINT = "sdk-ts";
   }
+  if (enableFileCheckpointing) {
+    processEnv.CLAUDE_CODE_ENABLE_SDK_FILE_CHECKPOINTING = "true";
+  }
   if (!pathToClaudeCodeExecutable) {
     throw new Error("pathToClaudeCodeExecutable is required");
   }
@@ -15208,8 +15309,10 @@ function query({
     canUseTool: !!canUseTool,
     hooks: !!hooks,
     includePartialMessages,
+    persistSession,
     plugins,
-    sandbox
+    sandbox,
+    spawnClaudeCodeProcess: rest.spawnClaudeCodeProcess
   });
   const initConfig = {
     systemPrompt: customSystemPrompt,
@@ -15228,6 +15331,7 @@ function query({
       parent_tool_use_id: null
     }) + `
 `);
+    queryInstance.handleSingleTurnInputComplete();
   } else {
     queryInstance.streamInput(prompt);
   }