happy-imou-cloud 2.1.49 → 2.1.51

package/dist/claude-BKNT-2fG.cjs

@@ -0,0 +1,1080 @@
+'use strict';
+
+var node_crypto = require('node:crypto');
+var path = require('node:path');
+var node_child_process = require('node:child_process');
+var node_readline = require('node:readline');
+var fs = require('node:fs');
+var index = require('./index-B_JYgMUS.cjs');
+var persistence = require('./types-CttABk32.cjs');
+var future = require('./future-Dq4Ha1Dn.cjs');
+var RuntimeShell = require('./RuntimeShell-D_Te12wq.cjs');
+
+class Stream {
+  constructor(returned) {
+    this.returned = returned;
+  }
+  queue = [];
+  readResolve;
+  readReject;
+  isDone = false;
+  hasError;
+  started = false;
+  /**
+   * Implements async iterable protocol
+   */
+  [Symbol.asyncIterator]() {
+    if (this.started) {
+      throw new Error("Stream can only be iterated once");
+    }
+    this.started = true;
+    return this;
+  }
+  /**
+   * Gets the next value from the stream
+   */
+  async next() {
+    if (this.queue.length > 0) {
+      return Promise.resolve({
+        done: false,
+        value: this.queue.shift()
+      });
+    }
+    if (this.isDone) {
+      return Promise.resolve({ done: true, value: void 0 });
+    }
+    if (this.hasError) {
+      return Promise.reject(this.hasError);
+    }
+    return new Promise((resolve, reject) => {
+      this.readResolve = resolve;
+      this.readReject = reject;
+    });
+  }
+  /**
+   * Adds a value to the stream
+   */
+  enqueue(value) {
+    if (this.readResolve) {
+      const resolve = this.readResolve;
+      this.readResolve = void 0;
+      this.readReject = void 0;
+      resolve({ done: false, value });
+    } else {
+      this.queue.push(value);
+    }
+  }
+  /**
+   * Marks the stream as complete
+   */
+  done() {
+    this.isDone = true;
+    if (this.readResolve) {
+      const resolve = this.readResolve;
+      this.readResolve = void 0;
+      this.readReject = void 0;
+      resolve({ done: true, value: void 0 });
+    }
+  }
+  /**
+   * Propagates an error through the stream
+   */
+  error(error) {
+    this.hasError = error;
+    if (this.readReject) {
+      const reject = this.readReject;
+      this.readResolve = void 0;
+      this.readReject = void 0;
+      reject(error);
+    }
+  }
+  /**
+   * Implements async iterator cleanup
+   */
+  async return() {
+    this.isDone = true;
+    if (this.returned) {
+      this.returned();
+    }
+    return Promise.resolve({ done: true, value: void 0 });
+  }
+}
+
+class AbortError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AbortError";
+  }
+}
+
+class Query {
+  constructor(childStdin, childStdout, processExitPromise, canCallTool) {
+    this.childStdin = childStdin;
+    this.childStdout = childStdout;
+    this.processExitPromise = processExitPromise;
+    this.canCallTool = canCallTool;
+    this.readMessages();
+    this.sdkMessages = this.readSdkMessages();
+  }
+  pendingControlResponses = /* @__PURE__ */ new Map();
+  cancelControllers = /* @__PURE__ */ new Map();
+  controlTasks = /* @__PURE__ */ new Set();
+  sdkMessages;
+  inputStream = new Stream();
+  canCallTool;
+  /**
+   * Set an error on the stream
+   */
+  setError(error) {
+    this.inputStream.error(error);
+  }
+  /**
+   * AsyncIterableIterator implementation
+   */
+  next(...args) {
+    return this.sdkMessages.next(...args);
+  }
+  return(value) {
+    if (this.sdkMessages.return) {
+      return this.sdkMessages.return(value);
+    }
+    return Promise.resolve({ done: true, value: void 0 });
+  }
+  throw(e) {
+    if (this.sdkMessages.throw) {
+      return this.sdkMessages.throw(e);
+    }
+    return Promise.reject(e);
+  }
+  [Symbol.asyncIterator]() {
+    return this.sdkMessages;
+  }
+  /**
+   * Read messages from Claude process stdout
+   */
+  async readMessages() {
+    const rl = node_readline.createInterface({ input: this.childStdout });
+    try {
+      for await (const line of rl) {
+        if (line.trim()) {
+          try {
+            const message = JSON.parse(line);
+            if (message.type === "control_response") {
+              const controlResponse = message;
+              const handler = this.pendingControlResponses.get(controlResponse.response.request_id);
+              if (handler) {
+                handler(controlResponse.response);
+              }
+              continue;
+            } else if (message.type === "control_request") {
+              const controlTask = this.handleControlRequest(message).catch((error) => {
+                persistence.logger.debug("[ClaudeSDK] Failed to handle control request:", error);
+              }).finally(() => {
+                this.controlTasks.delete(controlTask);
+              });
+              this.controlTasks.add(controlTask);
+              continue;
+            } else if (message.type === "control_cancel_request") {
+              this.handleControlCancelRequest(message);
+              continue;
+            }
+            this.inputStream.enqueue(message);
+          } catch (e) {
+            persistence.logger.debug(line);
+          }
+        }
+      }
+      await this.processExitPromise;
+    } catch (error) {
+      this.inputStream.error(error);
+    } finally {
+      this.cleanupControllers();
+      if (this.controlTasks.size > 0) {
+        await Promise.allSettled(Array.from(this.controlTasks));
+      }
+      this.inputStream.done();
+      rl.close();
+    }
+  }
+  /**
+   * Async generator for SDK messages
+   */
+  async *readSdkMessages() {
+    for await (const message of this.inputStream) {
+      yield message;
+    }
+  }
+  /**
+   * Send interrupt request to Claude
+   */
+  async interrupt() {
+    if (!this.childStdin) {
+      throw new Error("Interrupt requires --input-format stream-json");
+    }
+    await this.request({
+      subtype: "interrupt"
+    }, this.childStdin);
+  }
+  /**
+   * Send control request to Claude process
+   */
+  request(request, childStdin) {
+    const requestId = Math.random().toString(36).substring(2, 15);
+    const sdkRequest = {
+      request_id: requestId,
+      type: "control_request",
+      request
+    };
+    return new Promise((resolve, reject) => {
+      this.pendingControlResponses.set(requestId, (response) => {
+        if (response.subtype === "success") {
+          resolve(response);
+        } else {
+          reject(new Error(response.error));
+        }
+      });
+      childStdin.write(JSON.stringify(sdkRequest) + "\n");
+    });
+  }
+  /**
+   * Handle incoming control requests for tool permissions
+   * Replicates the exact logic from the SDK's handleControlRequest method
+   */
+  async handleControlRequest(request) {
+    if (!this.childStdin) {
+      index.logDebug("Cannot handle control request - no stdin available");
+      return;
+    }
+    const controller = new AbortController();
+    this.cancelControllers.set(request.request_id, controller);
+    try {
+      const response = await this.processControlRequest(request, controller.signal);
+      const controlResponse = {
+        type: "control_response",
+        response: {
+          subtype: "success",
+          request_id: request.request_id,
+          response
+        }
+      };
+      this.writeControlResponse(controlResponse);
+    } catch (error) {
+      const controlErrorResponse = {
+        type: "control_response",
+        response: {
+          subtype: "error",
+          request_id: request.request_id,
+          error: error instanceof Error ? error.message : String(error)
+        }
+      };
+      this.writeControlResponse(controlErrorResponse);
+    } finally {
+      this.cancelControllers.delete(request.request_id);
+    }
+  }
+  writeControlResponse(response) {
+    if (!this.childStdin || this.childStdin.destroyed || !this.childStdin.writable) {
+      return;
+    }
+    try {
+      this.childStdin.write(JSON.stringify(response) + "\n");
+    } catch (error) {
+      persistence.logger.debug("[ClaudeSDK] Failed to write control response:", error);
+    }
+  }
+  /**
+   * Handle control cancel requests
+   * Replicates the exact logic from the SDK's handleControlCancelRequest method
+   */
+  handleControlCancelRequest(request) {
+    const controller = this.cancelControllers.get(request.request_id);
+    if (controller) {
+      controller.abort();
+      this.cancelControllers.delete(request.request_id);
+    }
+  }
+  /**
+   * Process control requests based on subtype
+   * Replicates the exact logic from the SDK's processControlRequest method
+   */
+  async processControlRequest(request, signal) {
+    if (request.request.subtype === "can_use_tool") {
+      if (!this.canCallTool) {
+        throw new Error("canCallTool callback is not provided.");
+      }
+      return this.canCallTool(request.request.tool_name, request.request.input, {
+        signal,
+        requestId: request.request_id
+      });
+    }
+    throw new Error("Unsupported control request subtype: " + request.request.subtype);
+  }
+  /**
+   * Cleanup method to abort all pending control requests
+   */
+  cleanupControllers() {
+    for (const [requestId, controller] of this.cancelControllers.entries()) {
+      controller.abort();
+      this.cancelControllers.delete(requestId);
+    }
+  }
+}
+function query(config) {
+  const {
+    prompt,
+    options: {
+      allowedTools = [],
+      appendSystemPrompt,
+      customSystemPrompt,
+      cwd,
+      disallowedTools = [],
+      env,
+      executable = "node",
+      executableArgs = [],
+      maxTurns,
+      mcpServers,
+      pathToClaudeCodeExecutable = index.getDefaultClaudeCodePath(),
+      permissionMode,
+      continue: continueConversation,
+      resume,
+      model,
+      fallbackModel,
+      strictMcpConfig,
+      canCallTool,
+      settingsPath,
+      extraArgs = []
+    } = {}
+  } = config;
+  if (!process.env.CLAUDE_CODE_ENTRYPOINT) {
+    process.env.CLAUDE_CODE_ENTRYPOINT = "sdk-ts";
+  }
+  const args = [...extraArgs, "--output-format", "stream-json", "--verbose"];
+  if (customSystemPrompt) args.push("--system-prompt", customSystemPrompt);
+  if (appendSystemPrompt) args.push("--append-system-prompt", appendSystemPrompt);
+  if (maxTurns) args.push("--max-turns", maxTurns.toString());
+  if (model) args.push("--model", model);
+  if (canCallTool) {
+    if (typeof prompt === "string") {
+      throw new Error("canCallTool callback requires --input-format stream-json. Please set prompt as an AsyncIterable.");
+    }
+    args.push("--permission-prompt-tool", "stdio");
+  }
+  if (continueConversation) args.push("--continue");
+  if (resume) args.push("--resume", resume);
+  if (allowedTools.length > 0) args.push("--allowedTools", allowedTools.join(","));
+  if (disallowedTools.length > 0) args.push("--disallowedTools", disallowedTools.join(","));
+  if (mcpServers && Object.keys(mcpServers).length > 0) {
+    args.push("--mcp-config", JSON.stringify({ mcpServers }));
+  }
+  if (strictMcpConfig) args.push("--strict-mcp-config");
+  if (permissionMode) args.push("--permission-mode", permissionMode);
+  if (settingsPath) args.push("--settings", settingsPath);
+  if (fallbackModel) {
+    if (model && fallbackModel === model) {
+      throw new Error("Fallback model cannot be the same as the main model. Please specify a different model for fallbackModel option.");
+    }
+    args.push("--fallback-model", fallbackModel);
+  }
+  if (typeof prompt === "string") {
+    args.push("--print", prompt.trim());
+  } else {
+    args.push("--input-format", "stream-json");
+  }
+  const isJsFile = pathToClaudeCodeExecutable.endsWith(".js") || pathToClaudeCodeExecutable.endsWith(".cjs");
+  const isCommandOnly = pathToClaudeCodeExecutable === "claude";
+  if (!isCommandOnly && !fs.existsSync(pathToClaudeCodeExecutable)) {
+    throw new ReferenceError(`Claude Code executable not found at ${pathToClaudeCodeExecutable}. Is options.pathToClaudeCodeExecutable set?`);
+  }
+  const spawnCommand = isJsFile ? executable : pathToClaudeCodeExecutable;
+  const spawnArgs = isJsFile ? [...executableArgs, pathToClaudeCodeExecutable, ...args] : args;
+  const spawnEnv = {
+    ...isCommandOnly ? index.getCleanEnv() : process.env,
+    ...env
+  };
+  index.logDebug(`Spawning Claude Code process: ${spawnCommand} ${spawnArgs.join(" ")} (using ${isCommandOnly ? "clean" : "normal"} env)`);
+  const child = node_child_process.spawn(spawnCommand, spawnArgs, {
+    cwd,
+    stdio: ["pipe", "pipe", "pipe"],
+    signal: config.options?.abort,
+    env: spawnEnv,
+    // Use shell on Windows for global binaries and command-only mode
+    shell: !isJsFile && process.platform === "win32",
+    windowsHide: true
+  });
+  let childStdin = null;
+  if (typeof prompt === "string") {
+    child.stdin.end();
+  } else {
+    index.streamToStdin(prompt, child.stdin, config.options?.abort);
+    childStdin = child.stdin;
+  }
+  if (process.env.DEBUG) {
+    child.stderr.on("data", (data) => {
+      console.error("Claude Code stderr:", data.toString());
+    });
+  }
+  const cleanup = () => {
+    if (!child.killed) {
+      child.kill("SIGTERM");
+    }
+  };
+  config.options?.abort?.addEventListener("abort", cleanup);
+  process.on("exit", cleanup);
+  const processExitPromise = new Promise((resolve) => {
+    child.on("close", (code) => {
+      if (config.options?.abort?.aborted) {
+        query2.setError(new AbortError("Claude Code process aborted by user"));
+      }
+      if (code !== 0) {
+        query2.setError(new Error(`Claude Code process exited with code ${code}`));
+      } else {
+        resolve();
+      }
+    });
+  });
+  const query2 = new Query(childStdin, child.stdout, processExitPromise, canCallTool);
+  child.on("error", (error) => {
+    if (config.options?.abort?.aborted) {
+      query2.setError(new AbortError("Claude Code process aborted by user"));
+    } else {
+      query2.setError(new Error(`Failed to spawn Claude Code process: ${error.message}`));
+    }
+  });
+  processExitPromise.finally(() => {
+    cleanup();
+    config.options?.abort?.removeEventListener("abort", cleanup);
+    if (process.env.CLAUDE_SDK_MCP_SERVERS) {
+      delete process.env.CLAUDE_SDK_MCP_SERVERS;
+    }
+  });
+  return query2;
+}
+
+class PushableAsyncIterable {
+  queue = [];
+  waiters = [];
+  isDone = false;
+  error = null;
+  started = false;
+  constructor() {
+  }
+  /**
+   * Push a value to the iterable
+   */
+  push(value) {
+    if (this.isDone) {
+      throw new Error("Cannot push to completed iterable");
+    }
+    if (this.error) {
+      throw this.error;
+    }
+    const waiter = this.waiters.shift();
+    if (waiter) {
+      waiter.resolve({ done: false, value });
+    } else {
+      this.queue.push(value);
+    }
+  }
+  /**
+   * Mark the iterable as complete
+   */
+  end() {
+    if (this.isDone) {
+      return;
+    }
+    this.isDone = true;
+    this.cleanup();
+  }
+  /**
+   * Set an error on the iterable
+   */
+  setError(err) {
+    if (this.isDone) {
+      return;
+    }
+    this.error = err;
+    this.isDone = true;
+    this.cleanup();
+  }
+  /**
+   * Cleanup waiting consumers
+   */
+  cleanup() {
+    while (this.waiters.length > 0) {
+      const waiter = this.waiters.shift();
+      if (this.error) {
+        waiter.reject(this.error);
+      } else {
+        waiter.resolve({ done: true, value: void 0 });
+      }
+    }
+  }
+  /**
+   * AsyncIterableIterator implementation
+   */
+  async next() {
+    if (this.queue.length > 0) {
+      return { done: false, value: this.queue.shift() };
+    }
+    if (this.isDone) {
+      if (this.error) {
+        throw this.error;
+      }
+      return { done: true, value: void 0 };
+    }
+    return new Promise((resolve, reject) => {
+      this.waiters.push({ resolve, reject });
+    });
+  }
+  /**
+   * AsyncIterableIterator return implementation
+   */
+  async return(_value) {
+    this.end();
+    return { done: true, value: void 0 };
+  }
+  /**
+   * AsyncIterableIterator throw implementation
+   */
+  async throw(e) {
+    this.setError(e instanceof Error ? e : new Error(String(e)));
+    throw this.error;
+  }
+  /**
+   * Make this iterable
+   */
+  [Symbol.asyncIterator]() {
+    if (this.started) {
+      throw new Error("PushableAsyncIterable can only be iterated once");
+    }
+    this.started = true;
+    return this;
+  }
+  /**
+   * Check if the iterable is done
+   */
+  get done() {
+    return this.isDone;
+  }
+  /**
+   * Check if the iterable has an error
+   */
+  get hasError() {
+    return this.error !== null;
+  }
+  /**
+   * Get the current queue size
+   */
+  get queueSize() {
+    return this.queue.length;
+  }
+  /**
+   * Get the number of waiting consumers
+   */
+  get waiterCount() {
+    return this.waiters.length;
+  }
+}
+
+function normalizeClaudeBackendError(error) {
+  const record = typeof error === "object" && error !== null ? error : null;
+  const text = RuntimeShell.formatDisplayMessage(error).trim();
+  const stderrText = record ? RuntimeShell.formatDisplayMessage(record.stderr).trim() : "";
+  const detailText = record ? RuntimeShell.formatDisplayMessage(record.detail).trim() : "";
+  const searchable = [text, stderrText, detailText].filter(Boolean).join("\n").trim();
+  return searchable || "Claude runtime backend exited unexpectedly";
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function extractClaudeToolResultText(value) {
+  if (typeof value === "string") {
+    return value.length > 0 ? value : null;
+  }
+  if (Array.isArray(value)) {
+    const parts = value.map((item) => extractClaudeToolResultText(item)).filter((item) => Boolean(item));
+    return parts.length > 0 ? parts.join("") : null;
+  }
+  if (!isRecord(value)) {
+    return null;
+  }
+  if (typeof value.text === "string" && value.text.length > 0) {
+    return value.text;
+  }
+  if ("content" in value) {
+    return extractClaudeToolResultText(value.content);
+  }
+  return null;
+}
+function normalizeClaudeToolResultContent(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  const extractedText = extractClaudeToolResultText(value);
+  if (extractedText) {
+    return extractedText;
+  }
+  return value;
+}
+function createTimeoutError(timeoutMs) {
+  return new Error(`Claude response did not complete within ${timeoutMs}ms`);
+}
+const CLAUDE_RESPONSE_PROGRESS_POLL_MS = 1e3;
+function normalizePermissionResult(input, decision) {
+  if (decision === "approved" || decision === "approved_for_session") {
+    return {
+      behavior: "allow",
+      updatedInput: isRecord(input) ? input : {}
+    };
+  }
+  return {
+    behavior: "deny",
+    message: decision === "denied" ? "The user denied this tool request." : "The tool request was aborted."
+  };
+}
+function getClaudeExecutablePath(command) {
+  if (command === "claude") {
+    return path.resolve(path.join(index.projectPath(), "scripts", "claude_remote_launcher.cjs"));
+  }
+  return command;
+}
+class ClaudeCodeBackend {
+  constructor(options) {
+    this.options = options;
+  }
+  listeners = /* @__PURE__ */ new Set();
+  toolNamesByCallId = /* @__PURE__ */ new Map();
+  runtimeSessionId = node_crypto.randomUUID();
+  messageStream = null;
+  queryInstance = null;
+  runtimeAbortController = null;
+  consumeTask = null;
+  activeResponse = null;
+  responseCompletionOutcome = null;
+  responseLastProgressAt = null;
+  disposed = false;
+  lastStatus = null;
+  onMessage(handler) {
+    this.listeners.add(handler);
+  }
+  offMessage(handler) {
+    this.listeners.delete(handler);
+  }
+  async startSession(initialPrompt) {
+    if (initialPrompt) {
+      await this.sendPrompt(this.runtimeSessionId, initialPrompt);
+    }
+    return { sessionId: this.runtimeSessionId };
+  }
+  async sendPrompt(_sessionId, prompt) {
+    if (this.disposed) {
+      throw new Error("Claude runtime backend has already been disposed");
+    }
+    if (this.activeResponse) {
+      throw new Error("Claude runtime backend is already processing a prompt");
+    }
+    await this.ensureQueryStarted();
+    this.responseCompletionOutcome = null;
+    this.activeResponse = new future.Future();
+    this.responseLastProgressAt = Date.now();
+    void this.activeResponse.promise.catch(() => {
+    });
+    this.emitStatus("running");
+    this.messageStream.push({
+      type: "user",
+      message: {
+        role: "user",
+        content: prompt
+      }
+    });
+  }
+  async cancel(_sessionId) {
+    if (!this.queryInstance) {
+      return;
+    }
+    try {
+      await this.queryInstance.interrupt();
+    } catch (error) {
+      persistence.logger.debug("[ClaudeRuntimeBackend] Error interrupting Claude query:", error);
+    }
+  }
+  async waitForResponseComplete(timeoutMs = 10 * 6e4) {
+    if (this.responseCompletionOutcome) {
+      const outcome = this.responseCompletionOutcome;
+      if (outcome.kind === "rejected") {
+        throw outcome.error;
+      }
+      return;
+    }
+    if (!this.activeResponse) {
+      return;
+    }
+    while (this.activeResponse) {
+      const elapsedSinceProgress = Date.now() - (this.responseLastProgressAt ?? Date.now());
+      const remainingMs = timeoutMs - elapsedSinceProgress;
+      if (remainingMs <= 0) {
+        const timeoutError = createTimeoutError(timeoutMs);
+        this.rejectActiveResponse(timeoutError);
+        throw timeoutError;
+      }
+      await Promise.race([
+        this.activeResponse.promise,
+        new Promise((resolve2) => {
+          setTimeout(resolve2, Math.min(CLAUDE_RESPONSE_PROGRESS_POLL_MS, remainingMs));
+        })
+      ]);
+    }
+    const completionOutcome = this.responseCompletionOutcome;
+    const rejectedError = completionOutcome && typeof completionOutcome === "object" && "error" in completionOutcome ? completionOutcome.error : null;
+    if (rejectedError) {
+      throw rejectedError;
+    }
+  }
+  async dispose() {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    const activeQuery = this.queryInstance;
+    this.rejectActiveResponse(new Error("Claude runtime backend disposed"));
+    this.messageStream?.end();
+    this.runtimeAbortController?.abort();
+    if (activeQuery && typeof activeQuery.return === "function") {
+      try {
+        await activeQuery.return();
+      } catch (error) {
+        persistence.logger.debug("[ClaudeRuntimeBackend] Error closing Claude query iterator:", error);
+      }
+    }
+    try {
+      await this.consumeTask;
+    } catch (error) {
+      persistence.logger.debug("[ClaudeRuntimeBackend] Error while disposing backend:", error);
+    } finally {
+      this.queryInstance = null;
+      this.messageStream = null;
+      this.runtimeAbortController = null;
+      this.consumeTask = null;
+      this.toolNamesByCallId.clear();
+      this.emitStatus("stopped");
+    }
+  }
+  emit(message) {
+    for (const listener of this.listeners) {
+      listener(message);
+    }
+  }
+  emitStatus(status, detail) {
+    if (this.lastStatus?.status === status && this.lastStatus.detail === detail) {
+      return;
+    }
+    const message = {
+      type: "status",
+      status,
+      ...detail ? { detail } : {}
+    };
+    this.lastStatus = message;
+    this.emit(message);
+  }
+  async ensureQueryStarted() {
+    if (this.queryInstance) {
+      return;
+    }
+    this.emitStatus("starting");
+    this.runtimeAbortController = new AbortController();
+    this.messageStream = new PushableAsyncIterable();
+    this.queryInstance = query({
+      prompt: this.messageStream,
+      options: {
+        cwd: this.options.cwd,
+        env: this.options.env,
+        allowedTools: this.options.allowedTools,
+        appendSystemPrompt: this.options.appendSystemPrompt,
+        customSystemPrompt: this.options.customSystemPrompt,
+        disallowedTools: this.options.disallowedTools,
+        extraArgs: this.options.args,
+        fallbackModel: this.options.fallbackModel,
+        mcpServers: this.options.mcpServers,
+        model: this.options.model,
+        pathToClaudeCodeExecutable: getClaudeExecutablePath(this.options.command),
+        permissionMode: this.options.permissionMode,
+        settingsPath: this.options.settingsPath,
+        canCallTool: this.options.permissionHandler ? async (toolName, input, requestOptions) => {
+          const requestId = requestOptions.requestId ?? node_crypto.randomUUID();
+          this.emit({
+            type: "permission-request",
+            id: requestId,
+            reason: `Claude wants to use ${toolName}`,
+            payload: {
+              toolName,
+              input
+            }
+          });
+          const decision = await this.options.permissionHandler.handleToolCall(requestId, toolName, input);
+          this.emit({
+            type: "permission-response",
+            id: requestId,
+            approved: decision.decision === "approved" || decision.decision === "approved_for_session"
+          });
+          return normalizePermissionResult(input, decision.decision);
+        } : void 0,
+        abort: this.runtimeAbortController.signal
+      }
+    });
+    this.consumeTask = this.consumeMessages(this.queryInstance);
+  }
+  async consumeMessages(activeQuery) {
+    try {
+      for await (const message of activeQuery) {
+        this.handleMessage(message);
+      }
+    } catch (error) {
+      const aborted = this.runtimeAbortController?.signal.aborted === true;
+      if (!aborted) {
+        const detail = normalizeClaudeBackendError(error);
+        this.emitStatus("error", detail);
+        this.rejectActiveResponse(new Error(detail));
+      }
+    } finally {
+      if (!this.disposed && this.activeResponse) {
+        const detail = "Claude runtime backend stopped before completing the response";
+        this.emitStatus("error", detail);
+        this.rejectActiveResponse(new Error(detail));
+      }
+      if (!this.disposed) {
+        this.queryInstance = null;
+        this.messageStream = null;
+        this.runtimeAbortController = null;
+        this.consumeTask = null;
+        this.emitStatus("stopped");
+      }
+    }
+  }
+  handleMessage(message) {
+    this.markResponseProgress();
+    switch (message.type) {
+      case "system":
+        this.handleSystemMessage(message);
+        return;
+      case "assistant":
+        this.handleAssistantMessage(message);
+        return;
+      case "user":
+        this.handleUserMessage(message);
+        return;
+      case "result":
+        this.handleResultMessage(message);
+        return;
+      default:
+        return;
+    }
+  }
+  handleSystemMessage(message) {
+    if (message.subtype === "init") {
+      this.emitStatus("running");
+      this.emit({
+        type: "event",
+        name: "session-init",
+        payload: {
+          sessionId: message.session_id,
+          cwd: message.cwd,
+          model: message.model,
+          tools: message.tools
+        }
+      });
+    }
+  }
+  handleAssistantMessage(message) {
+    for (const block of message.message.content ?? []) {
+      if (block.type === "text" && typeof block.text === "string" && block.text.length > 0) {
+        this.emit({
+          type: "model-output",
+          textDelta: block.text
+        });
+        continue;
+      }
+      if (block.type === "thinking") {
+        const thinkingText = isRecord(block) && typeof block.thinking === "string" ? block.thinking : "";
+        if (thinkingText) {
+          this.emit({
+            type: "event",
+            name: "thinking",
+            payload: { text: thinkingText }
+          });
+        }
+        continue;
+      }
+      if (block.type === "tool_use" && block.id && block.name) {
+        this.toolNamesByCallId.set(block.id, block.name);
+        this.emit({
+          type: "tool-call",
+          toolName: block.name,
+          args: isRecord(block.input) ? block.input : {},
+          callId: block.id
+        });
+      }
+    }
+  }
+  handleUserMessage(message) {
+    const content = Array.isArray(message.message.content) ? message.message.content : [];
+    for (const block of content) {
+      if (block.type !== "tool_result" || !block.tool_use_id) {
+        continue;
+      }
+      const toolName = this.toolNamesByCallId.get(block.tool_use_id) ?? "unknown";
+      this.emit({
+        type: "tool-result",
+        toolName,
+        result: normalizeClaudeToolResultContent(block.content),
+        callId: block.tool_use_id
+      });
+      if (toolName === "Bash" && isRecord(message.tool_use_result)) {
+        const toolResult = message.tool_use_result;
+        const stdout = RuntimeShell.formatDisplayMessage(toolResult.stdout).trim();
+        const stderr = RuntimeShell.formatDisplayMessage(toolResult.stderr).trim();
+        const combined = [stdout, stderr].filter(Boolean).join("\n");
+        if (combined) {
+          this.emit({
+            type: "terminal-output",
+            data: combined,
+            callId: block.tool_use_id
+          });
+        }
+      }
+    }
+  }
+  handleResultMessage(message) {
+    if (message.usage) {
+      this.emit({
+        type: "token-count",
+        ...message.usage,
+        duration_ms: message.duration_ms,
+        duration_api_ms: message.duration_api_ms,
+        total_cost_usd: message.total_cost_usd,
+        session_id: message.session_id
+      });
+    }
+    if (message.is_error) {
+      const detail = typeof message.result === "string" && message.result.trim().length > 0 ? message.result : message.subtype;
+      this.emitStatus("error", detail);
+      this.rejectActiveResponse(new Error(detail));
+      return;
+    }
+    this.emitStatus("idle");
+    this.resolveActiveResponse();
+  }
+  resolveActiveResponse() {
+    this.responseCompletionOutcome = { kind: "resolved" };
+    this.responseLastProgressAt = null;
+    if (!this.activeResponse) {
+      return;
+    }
+    const active = this.activeResponse;
+    this.activeResponse = null;
+    active.resolve(void 0);
+  }
+  rejectActiveResponse(error) {
+    this.responseCompletionOutcome = { kind: "rejected", error };
+    this.responseLastProgressAt = null;
+    if (!this.activeResponse) {
+      return;
+    }
+    const active = this.activeResponse;
+    this.activeResponse = null;
+    active.reject(error);
+  }
+  markResponseProgress() {
+    if (!this.activeResponse) {
+      return;
+    }
+    this.responseLastProgressAt = Date.now();
+  }
+}
+
+function mapToClaudeMode(mode) {
+  const codexToClaudeMap = {
+    "yolo": "bypassPermissions",
+    "safe-yolo": "default",
+    "read-only": "default"
+  };
+  return codexToClaudeMap[mode] ?? mode;
+}
+
+function defaultClaudeCommand() {
+  return process.env.HAPPY_CLAUDE_COMMAND ?? process.env.HAPPY_CLAUDE_ACP_COMMAND ?? "claude";
+}
+function appendStringFlag(args, flag, value) {
+  if (value && value.trim().length > 0) {
+    args.push(flag, value);
+  }
+}
+function appendListFlag(args, flag, values) {
+  if (values && values.length > 0) {
+    args.push(flag, values.join(","));
+  }
+}
+function normalizeClaudePassthroughArgs(options) {
+  const sourceArgs = options.args ?? options.baseArgs ?? [];
+  return sourceArgs.filter((arg) => arg !== "--experimental-acp");
+}
+function resolveClaudeCliArgs(options) {
+  const args = [
+    "--output-format",
+    "stream-json",
+    "--verbose",
+    "--input-format",
+    "stream-json",
+    ...normalizeClaudePassthroughArgs(options)
+  ];
+  if (options.permissionHandler) {
+    args.push("--permission-prompt-tool", "stdio");
+  }
+  appendStringFlag(args, "--system-prompt", options.customSystemPrompt);
+  appendStringFlag(args, "--append-system-prompt", options.appendSystemPrompt);
+  appendStringFlag(args, "--model", options.model);
+  appendStringFlag(args, "--fallback-model", options.fallbackModel);
+  appendListFlag(args, "--allowedTools", options.allowedTools);
+  appendListFlag(args, "--disallowedTools", options.disallowedTools);
+  appendStringFlag(args, "--settings", options.settingsPath);
+  if (options.permissionMode) {
+    args.push("--permission-mode", mapToClaudeMode(options.permissionMode));
+  }
+  return args;
+}
+function createClaudeBackend(options) {
+  const command = options.command ?? defaultClaudeCommand();
+  const args = resolveClaudeCliArgs(options);
+  return {
+    backend: new ClaudeCodeBackend({
+      cwd: options.cwd,
+      env: {
+        ...options.env,
+        NODE_ENV: "production"
+      },
+      command,
+      args: normalizeClaudePassthroughArgs(options),
+      model: options.model,
+      fallbackModel: options.fallbackModel,
+      permissionMode: options.permissionMode ? mapToClaudeMode(options.permissionMode) : void 0,
+      customSystemPrompt: options.customSystemPrompt,
+      appendSystemPrompt: options.appendSystemPrompt,
+      allowedTools: options.allowedTools,
+      disallowedTools: options.disallowedTools,
+      settingsPath: options.settingsPath,
+      mcpServers: options.mcpServers,
+      permissionHandler: options.permissionHandler
+    }),
+    command,
+    args
+  };
+}
+function registerClaudeAgent() {
+  RuntimeShell.agentRegistry.register("claude", (opts) => createClaudeBackend(opts).backend);
+}
+
+exports.AbortError = AbortError;
+exports.PushableAsyncIterable = PushableAsyncIterable;
+exports.createClaudeBackend = createClaudeBackend;
+exports.mapToClaudeMode = mapToClaudeMode;
+exports.query = query;
+exports.registerClaudeAgent = registerClaudeAgent;