@agentxjs/claude-driver 1.9.3-dev → 1.9.6-dev

package/dist/index.js

@@ -0,0 +1,994 @@
+// src/ClaudeDriver.ts
+import { Subject as Subject2 } from "rxjs";
+
+// ../../node_modules/commonxjs/dist/logger/index.js
+var ConsoleLogger = class _ConsoleLogger {
+  name;
+  level;
+  colors;
+  timestamps;
+  static COLORS = {
+    DEBUG: "\x1B[36m",
+    INFO: "\x1B[32m",
+    WARN: "\x1B[33m",
+    ERROR: "\x1B[31m",
+    RESET: "\x1B[0m"
+  };
+  constructor(name, options = {}) {
+    this.name = name;
+    this.level = options.level ?? "info";
+    this.colors = options.colors ?? this.isNodeEnvironment();
+    this.timestamps = options.timestamps ?? true;
+  }
+  debug(message, context) {
+    if (this.isDebugEnabled()) {
+      this.log("DEBUG", message, context);
+    }
+  }
+  info(message, context) {
+    if (this.isInfoEnabled()) {
+      this.log("INFO", message, context);
+    }
+  }
+  warn(message, context) {
+    if (this.isWarnEnabled()) {
+      this.log("WARN", message, context);
+    }
+  }
+  error(message, context) {
+    if (this.isErrorEnabled()) {
+      if (message instanceof Error) {
+        this.log("ERROR", message.message, { ...context, stack: message.stack });
+      } else {
+        this.log("ERROR", message, context);
+      }
+    }
+  }
+  isDebugEnabled() {
+    return this.getLevelValue(this.level) <= this.getLevelValue("debug");
+  }
+  isInfoEnabled() {
+    return this.getLevelValue(this.level) <= this.getLevelValue("info");
+  }
+  isWarnEnabled() {
+    return this.getLevelValue(this.level) <= this.getLevelValue("warn");
+  }
+  isErrorEnabled() {
+    return this.getLevelValue(this.level) <= this.getLevelValue("error");
+  }
+  getLevelValue(level) {
+    const levels = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3,
+      silent: 4
+    };
+    return levels[level];
+  }
+  log(level, message, context) {
+    const parts = [];
+    if (this.timestamps) {
+      parts.push((/* @__PURE__ */ new Date()).toISOString());
+    }
+    if (this.colors) {
+      const color = _ConsoleLogger.COLORS[level];
+      parts.push(`${color}${level.padEnd(5)}${_ConsoleLogger.COLORS.RESET}`);
+    } else {
+      parts.push(level.padEnd(5));
+    }
+    parts.push(`[${this.name}]`);
+    parts.push(message);
+    const logLine = parts.join(" ");
+    const consoleMethod = this.getConsoleMethod(level);
+    if (context && Object.keys(context).length > 0) {
+      consoleMethod(logLine, context);
+    } else {
+      consoleMethod(logLine);
+    }
+  }
+  getConsoleMethod(level) {
+    switch (level) {
+      case "DEBUG":
+        return console.debug.bind(console);
+      case "INFO":
+        return console.info.bind(console);
+      case "WARN":
+        return console.warn.bind(console);
+      case "ERROR":
+        return console.error.bind(console);
+      default:
+        return console.log.bind(console);
+    }
+  }
+  isNodeEnvironment() {
+    return typeof process !== "undefined" && process.versions?.node !== void 0;
+  }
+};
+var externalFactory = null;
+var factoryVersion = 0;
+var LoggerFactoryImpl = class {
+  static loggers = /* @__PURE__ */ new Map();
+  static config = {
+    defaultLevel: "info"
+  };
+  static getLogger(nameOrClass) {
+    const name = typeof nameOrClass === "string" ? nameOrClass : nameOrClass.name;
+    if (this.loggers.has(name)) {
+      return this.loggers.get(name);
+    }
+    const lazyLogger = this.createLazyLogger(name);
+    this.loggers.set(name, lazyLogger);
+    return lazyLogger;
+  }
+  static configure(config) {
+    this.config = { ...this.config, ...config };
+  }
+  static reset() {
+    this.loggers.clear();
+    this.config = { defaultLevel: "info" };
+    externalFactory = null;
+    factoryVersion++;
+  }
+  static createLazyLogger(name) {
+    let realLogger = null;
+    let loggerVersion = -1;
+    const getRealLogger = () => {
+      if (!realLogger || loggerVersion !== factoryVersion) {
+        realLogger = this.createLogger(name);
+        loggerVersion = factoryVersion;
+      }
+      return realLogger;
+    };
+    return {
+      name,
+      level: this.config.defaultLevel || "info",
+      debug: (message, context) => getRealLogger().debug(message, context),
+      info: (message, context) => getRealLogger().info(message, context),
+      warn: (message, context) => getRealLogger().warn(message, context),
+      error: (message, context) => getRealLogger().error(message, context),
+      isDebugEnabled: () => getRealLogger().isDebugEnabled(),
+      isInfoEnabled: () => getRealLogger().isInfoEnabled(),
+      isWarnEnabled: () => getRealLogger().isWarnEnabled(),
+      isErrorEnabled: () => getRealLogger().isErrorEnabled()
+    };
+  }
+  static createLogger(name) {
+    if (externalFactory) {
+      return externalFactory.getLogger(name);
+    }
+    if (this.config.defaultImplementation) {
+      return this.config.defaultImplementation(name);
+    }
+    return new ConsoleLogger(name, {
+      level: this.config.defaultLevel,
+      ...this.config.consoleOptions
+    });
+  }
+};
+function createLogger(name) {
+  return LoggerFactoryImpl.getLogger(name);
+}
+
+// src/helpers.ts
+function isTextPart(part) {
+  return part.type === "text";
+}
+function isImagePart(part) {
+  return part.type === "image";
+}
+function isFilePart(part) {
+  return part.type === "file";
+}
+function buildSDKContent(message) {
+  if (typeof message.content === "string") {
+    return message.content;
+  }
+  if (!Array.isArray(message.content)) {
+    return "";
+  }
+  const parts = message.content;
+  const hasNonTextParts = parts.some((p) => !isTextPart(p));
+  if (!hasNonTextParts) {
+    return parts.filter(isTextPart).map((p) => p.text).join("\n");
+  }
+  return parts.map((part) => {
+    if (isTextPart(part)) {
+      return {
+        type: "text",
+        text: part.text
+      };
+    }
+    if (isImagePart(part)) {
+      return {
+        type: "image",
+        source: {
+          type: "base64",
+          media_type: part.mediaType,
+          data: part.data
+        }
+      };
+    }
+    if (isFilePart(part)) {
+      return {
+        type: "document",
+        source: {
+          type: "base64",
+          media_type: part.mediaType,
+          data: part.data
+        }
+      };
+    }
+    return { type: "text", text: "" };
+  });
+}
+function buildSDKUserMessage(message, sessionId) {
+  return {
+    type: "user",
+    message: { role: "user", content: buildSDKContent(message) },
+    parent_tool_use_id: null,
+    session_id: sessionId
+  };
+}
+
+// src/SDKQueryLifecycle.ts
+import {
+  query
+} from "@anthropic-ai/claude-agent-sdk";
+import { Subject } from "rxjs";
+
+// src/buildOptions.ts
+var logger = createLogger("claude-driver/buildOptions");
+function buildOptions(context, abortController) {
+  const options = {
+    abortController,
+    includePartialMessages: true
+  };
+  if (context.cwd) {
+    options.cwd = context.cwd;
+  }
+  const env = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (value !== void 0) {
+      env[key] = value;
+    }
+  }
+  if (!env.PATH && process.env.PATH) {
+    env.PATH = process.env.PATH;
+  }
+  env.AGENTX_ENVIRONMENT = "true";
+  if (context.baseUrl) {
+    env.ANTHROPIC_BASE_URL = context.baseUrl;
+  }
+  if (context.apiKey) {
+    env.ANTHROPIC_API_KEY = context.apiKey;
+  }
+  options.env = env;
+  logger.info("buildOptions called", {
+    hasPath: !!env.PATH,
+    pathLength: env.PATH?.length,
+    hasApiKey: !!env.ANTHROPIC_API_KEY,
+    hasBaseUrl: !!env.ANTHROPIC_BASE_URL,
+    baseUrl: env.ANTHROPIC_BASE_URL,
+    model: context.model,
+    permissionMode: context.permissionMode || "bypassPermissions",
+    cwd: context.cwd,
+    systemPrompt: context.systemPrompt,
+    mcpServers: context.mcpServers ? Object.keys(context.mcpServers) : []
+  });
+  options.stderr = (data) => {
+    logger.info("SDK stderr", { data: data.trim() });
+  };
+  if (context.claudeCodePath) {
+    options.pathToClaudeCodeExecutable = context.claudeCodePath;
+    logger.info("Claude Code path configured", { path: context.claudeCodePath });
+  }
+  if (context.model) options.model = context.model;
+  if (context.systemPrompt) options.systemPrompt = context.systemPrompt;
+  if (context.maxTurns) options.maxTurns = context.maxTurns;
+  if (context.maxThinkingTokens) options.maxThinkingTokens = context.maxThinkingTokens;
+  if (context.resume) options.resume = context.resume;
+  if (context.mcpServers) {
+    options.mcpServers = context.mcpServers;
+    logger.info("MCP servers configured", {
+      serverNames: Object.keys(context.mcpServers)
+    });
+  }
+  if (context.permissionMode) {
+    options.permissionMode = context.permissionMode;
+    if (context.permissionMode === "bypassPermissions") {
+      options.allowDangerouslySkipPermissions = true;
+    }
+  } else {
+    options.permissionMode = "bypassPermissions";
+    options.allowDangerouslySkipPermissions = true;
+  }
+  logger.info("SDK Options built", {
+    model: options.model,
+    systemPrompt: options.systemPrompt,
+    permissionMode: options.permissionMode,
+    cwd: options.cwd,
+    resume: options.resume,
+    maxTurns: options.maxTurns,
+    mcpServers: options.mcpServers ? Object.keys(options.mcpServers) : []
+  });
+  return options;
+}
+
+// src/observableToAsyncIterable.ts
+async function* observableToAsyncIterable(observable) {
+  const queue = [];
+  let resolve = null;
+  let reject = null;
+  let done = false;
+  let error = null;
+  const subscription = observable.subscribe({
+    next: (value) => {
+      if (resolve) {
+        resolve({ value, done: false });
+        resolve = null;
+        reject = null;
+      } else {
+        queue.push(value);
+      }
+    },
+    error: (err) => {
+      error = err instanceof Error ? err : new Error(String(err));
+      done = true;
+      if (reject) {
+        reject(error);
+        resolve = null;
+        reject = null;
+      }
+    },
+    complete: () => {
+      done = true;
+      if (resolve) {
+        resolve({ value: void 0, done: true });
+        resolve = null;
+        reject = null;
+      }
+    }
+  });
+  try {
+    while (!done || queue.length > 0) {
+      if (error) {
+        throw error;
+      }
+      if (queue.length > 0) {
+        yield queue.shift();
+      } else if (!done) {
+        const result = await new Promise((res, rej) => {
+          resolve = (iterResult) => {
+            if (iterResult.done) {
+              done = true;
+              res({ done: true });
+            } else {
+              res({ value: iterResult.value, done: false });
+            }
+          };
+          reject = rej;
+        });
+        if (!result.done) {
+          yield result.value;
+        }
+      }
+    }
+  } finally {
+    subscription.unsubscribe();
+  }
+}
+
+// src/SDKQueryLifecycle.ts
+var logger2 = createLogger("claude-driver/SDKQueryLifecycle");
+var SDKQueryLifecycle = class {
+  config;
+  _callbacks;
+  promptSubject = new Subject();
+  claudeQuery = null;
+  isInitialized = false;
+  abortController = null;
+  capturedSessionId = null;
+  constructor(config, callbacks = {}) {
+    this.config = config;
+    this._callbacks = callbacks;
+  }
+  /**
+   * Get current callbacks (for reading/modification)
+   */
+  get callbacks() {
+    return this._callbacks;
+  }
+  /**
+   * Update callbacks
+   *
+   * Allows changing callbacks after initialization.
+   * Useful for per-turn callback setup.
+   */
+  setCallbacks(callbacks) {
+    this._callbacks = { ...this._callbacks, ...callbacks };
+  }
+  /**
+   * Check if the query is initialized
+   */
+  get initialized() {
+    return this.isInitialized;
+  }
+  /**
+   * Warmup the SDK query (pre-initialize)
+   *
+   * Call this early to start the SDK subprocess before the first message.
+   * This reduces latency for the first user message.
+   *
+   * @returns Promise that resolves when SDK is ready
+   */
+  async warmup() {
+    logger2.info("Warming up SDKQueryLifecycle");
+    await this.initialize();
+    logger2.info("SDKQueryLifecycle warmup complete");
+  }
+  /**
+   * Initialize the SDK query (lazy initialization)
+   *
+   * Creates the query and starts the background listener.
+   * Safe to call multiple times - will only initialize once.
+   */
+  async initialize() {
+    if (this.isInitialized) return;
+    logger2.info("Initializing SDKQueryLifecycle");
+    this.abortController = new AbortController();
+    const context = {
+      apiKey: this.config.apiKey,
+      baseUrl: this.config.baseUrl,
+      model: this.config.model,
+      systemPrompt: this.config.systemPrompt,
+      cwd: this.config.cwd,
+      resume: this.config.resumeSessionId,
+      mcpServers: this.config.mcpServers,
+      claudeCodePath: this.config.claudeCodePath
+    };
+    const sdkOptions = buildOptions(context, this.abortController);
+    const promptStream = observableToAsyncIterable(this.promptSubject);
+    this.claudeQuery = query({
+      prompt: promptStream,
+      options: sdkOptions
+    });
+    this.isInitialized = true;
+    this.startBackgroundListener();
+    logger2.info("SDKQueryLifecycle initialized");
+  }
+  /**
+   * Send a message to the SDK
+   *
+   * Must call initialize() first.
+   */
+  send(message) {
+    if (!this.isInitialized) {
+      throw new Error("SDKQueryLifecycle not initialized. Call initialize() first.");
+    }
+    this.promptSubject.next(message);
+  }
+  /**
+   * Interrupt the current SDK operation
+   */
+  interrupt() {
+    if (this.claudeQuery) {
+      logger2.debug("Interrupting SDK query");
+      this.claudeQuery.interrupt().catch((err) => {
+        logger2.debug("SDK interrupt() error (may be expected)", { error: err });
+      });
+    }
+  }
+  /**
+   * Reset state and cleanup resources
+   *
+   * This properly terminates the Claude subprocess by:
+   * 1. Completing the prompt stream (signals end of input)
+   * 2. Interrupting any ongoing operation
+   * 3. Resetting state for potential reuse
+   */
+  reset() {
+    logger2.debug("Resetting SDKQueryLifecycle");
+    this.promptSubject.complete();
+    if (this.claudeQuery) {
+      this.claudeQuery.interrupt().catch((err) => {
+        logger2.debug("SDK interrupt() during reset (may be expected)", { error: err });
+      });
+    }
+    this.isInitialized = false;
+    this.claudeQuery = null;
+    this.abortController = null;
+    this.promptSubject = new Subject();
+  }
+  /**
+   * Dispose and cleanup all resources
+   *
+   * Should be called when the lifecycle is no longer needed.
+   */
+  dispose() {
+    logger2.debug("Disposing SDKQueryLifecycle");
+    if (this.claudeQuery) {
+      this.claudeQuery.interrupt().catch((err) => {
+        logger2.debug("SDK interrupt() during dispose (may be expected)", { error: err });
+      });
+    }
+    if (this.abortController) {
+      this.abortController.abort();
+    }
+    this.reset();
+    logger2.debug("SDKQueryLifecycle disposed");
+  }
+  /**
+   * Start the background listener for SDK responses
+   */
+  startBackgroundListener() {
+    (async () => {
+      try {
+        for await (const sdkMsg of this.claudeQuery) {
+          logger2.debug("SDK message received", {
+            type: sdkMsg.type,
+            subtype: sdkMsg.subtype,
+            sessionId: sdkMsg.session_id
+          });
+          if (sdkMsg.session_id && this._callbacks.onSessionIdCaptured && this.capturedSessionId !== sdkMsg.session_id) {
+            this.capturedSessionId = sdkMsg.session_id;
+            this._callbacks.onSessionIdCaptured(sdkMsg.session_id);
+          }
+          if (sdkMsg.type === "stream_event") {
+            this._callbacks.onStreamEvent?.(sdkMsg);
+          }
+          if (sdkMsg.type === "user") {
+            this._callbacks.onUserMessage?.(sdkMsg);
+          }
+          if (sdkMsg.type === "result") {
+            logger2.info("SDK result received", {
+              subtype: sdkMsg.subtype,
+              is_error: sdkMsg.is_error
+            });
+            this._callbacks.onResult?.(sdkMsg);
+          }
+        }
+        this._callbacks.onListenerExit?.("normal");
+      } catch (error) {
+        if (this.isAbortError(error)) {
+          logger2.debug("Background listener aborted (expected during interrupt)");
+          this._callbacks.onListenerExit?.("abort");
+        } else {
+          logger2.error("Background listener error", { error });
+          this._callbacks.onError?.(error instanceof Error ? error : new Error(String(error)));
+          this._callbacks.onListenerExit?.("error");
+        }
+        this.reset();
+      }
+    })();
+  }
+  /**
+   * Check if an error is an abort error
+   */
+  isAbortError(error) {
+    if (error instanceof Error) {
+      if (error.name === "AbortError") return true;
+      if (error.message.includes("aborted")) return true;
+      if (error.message.includes("abort")) return true;
+    }
+    return false;
+  }
+};
+
+// src/ClaudeDriver.ts
+var logger3 = createLogger("claude-driver/ClaudeDriver");
+var ClaudeDriver = class {
+  name = "ClaudeDriver";
+  _sessionId = null;
+  _state = "idle";
+  config;
+  queryLifecycle = null;
+  // For interrupt handling
+  currentTurnSubject = null;
+  constructor(config) {
+    this.config = config;
+  }
+  // ============================================================================
+  // Driver Interface Properties
+  // ============================================================================
+  get sessionId() {
+    return this._sessionId;
+  }
+  get state() {
+    return this._state;
+  }
+  // ============================================================================
+  // Lifecycle Methods
+  // ============================================================================
+  /**
+   * Initialize the Driver
+   *
+   * Starts SDK subprocess and MCP servers.
+   * Must be called before receive().
+   */
+  async initialize() {
+    if (this._state !== "idle") {
+      throw new Error(`Cannot initialize: Driver is in "${this._state}" state`);
+    }
+    logger3.info("Initializing ClaudeDriver", { agentId: this.config.agentId });
+    logger3.info("ClaudeDriver initialized");
+  }
+  /**
+   * Dispose and cleanup resources
+   *
+   * Stops SDK subprocess and MCP servers.
+   * Driver cannot be used after dispose().
+   */
+  async dispose() {
+    if (this._state === "disposed") {
+      return;
+    }
+    logger3.info("Disposing ClaudeDriver", { agentId: this.config.agentId });
+    if (this.currentTurnSubject) {
+      this.currentTurnSubject.complete();
+      this.currentTurnSubject = null;
+    }
+    if (this.queryLifecycle) {
+      this.queryLifecycle.dispose();
+      this.queryLifecycle = null;
+    }
+    this._state = "disposed";
+    logger3.info("ClaudeDriver disposed");
+  }
+  // ============================================================================
+  // Core Methods
+  // ============================================================================
+  /**
+   * Receive a user message and return stream of events
+   *
+   * This is the main method for communication.
+   * Returns an AsyncIterable that yields DriverStreamEvent.
+   *
+   * @param message - User message to send
+   * @returns AsyncIterable of stream events
+   */
+  async *receive(message) {
+    if (this._state === "disposed") {
+      throw new Error("Cannot receive: Driver is disposed");
+    }
+    if (this._state === "active") {
+      throw new Error("Cannot receive: Driver is already processing a message");
+    }
+    this._state = "active";
+    try {
+      await this.ensureLifecycle();
+      const turnSubject = new Subject2();
+      this.currentTurnSubject = turnSubject;
+      let isComplete = false;
+      let turnError = null;
+      this.setupTurnCallbacks(turnSubject, () => {
+        isComplete = true;
+      }, (error) => {
+        turnError = error;
+        isComplete = true;
+      });
+      const sessionId = this._sessionId || "default";
+      const sdkMessage = buildSDKUserMessage(message, sessionId);
+      logger3.debug("Sending message to Claude", {
+        content: typeof message.content === "string" ? message.content.substring(0, 80) : "[structured]",
+        agentId: this.config.agentId
+      });
+      this.queryLifecycle.send(sdkMessage);
+      yield* this.yieldFromSubject(turnSubject, () => isComplete, () => turnError);
+    } finally {
+      this._state = "idle";
+      this.currentTurnSubject = null;
+    }
+  }
+  /**
+   * Interrupt current operation
+   *
+   * Stops the current receive() operation gracefully.
+   * The AsyncIterable will emit an "interrupted" event and complete.
+   */
+  interrupt() {
+    if (this._state !== "active") {
+      logger3.debug("Interrupt called but no active operation");
+      return;
+    }
+    logger3.debug("Interrupting ClaudeDriver");
+    if (this.currentTurnSubject) {
+      this.currentTurnSubject.next({
+        type: "interrupted",
+        timestamp: Date.now(),
+        data: { reason: "user" }
+      });
+      this.currentTurnSubject.complete();
+    }
+    if (this.queryLifecycle) {
+      this.queryLifecycle.interrupt();
+    }
+  }
+  // ============================================================================
+  // Private Methods
+  // ============================================================================
+  /**
+   * Ensure SDK lifecycle is initialized
+   */
+  async ensureLifecycle() {
+    if (this.queryLifecycle && this.queryLifecycle.initialized) {
+      return;
+    }
+    this.queryLifecycle = new SDKQueryLifecycle(
+      {
+        apiKey: this.config.apiKey,
+        baseUrl: this.config.baseUrl,
+        model: this.config.model,
+        systemPrompt: this.config.systemPrompt,
+        cwd: this.config.cwd,
+        resumeSessionId: this.config.resumeSessionId,
+        mcpServers: this.config.mcpServers
+      },
+      {
+        onSessionIdCaptured: (sessionId) => {
+          this._sessionId = sessionId;
+          this.config.onSessionIdCaptured?.(sessionId);
+        }
+      }
+    );
+    await this.queryLifecycle.initialize();
+  }
+  /**
+   * Setup callbacks for a single turn
+   */
+  setupTurnCallbacks(subject, onComplete, onError) {
+    if (!this.queryLifecycle) return;
+    const blockContext = {
+      currentBlockType: null,
+      currentToolId: null,
+      currentToolName: null,
+      lastStopReason: null,
+      accumulatedToolInput: ""
+    };
+    this.queryLifecycle.setCallbacks({
+      onStreamEvent: (msg) => {
+        const event = this.convertStreamEvent(msg, blockContext);
+        if (event) {
+          subject.next(event);
+        }
+      },
+      onUserMessage: (msg) => {
+        const events = this.convertUserMessage(msg);
+        for (const event of events) {
+          subject.next(event);
+        }
+      },
+      onResult: (msg) => {
+        const resultMsg = msg;
+        if (resultMsg.is_error) {
+          subject.next({
+            type: "error",
+            timestamp: Date.now(),
+            data: {
+              message: resultMsg.error?.message || "Unknown error",
+              errorCode: "sdk_error"
+            }
+          });
+        }
+        subject.complete();
+        onComplete();
+      },
+      onError: (error) => {
+        subject.next({
+          type: "error",
+          timestamp: Date.now(),
+          data: {
+            message: error.message,
+            errorCode: "runtime_error"
+          }
+        });
+        subject.complete();
+        onError(error);
+      }
+    });
+  }
+  /**
+   * Convert SDK stream_event to DriverStreamEvent
+   */
+  convertStreamEvent(sdkMsg, blockContext) {
+    const event = sdkMsg.event;
+    const timestamp = Date.now();
+    switch (event.type) {
+      case "message_start":
+        return {
+          type: "message_start",
+          timestamp,
+          data: {
+            messageId: event.message.id,
+            model: event.message.model
+          }
+        };
+      case "content_block_start": {
+        const contentBlock = event.content_block;
+        if (contentBlock.type === "text") {
+          blockContext.currentBlockType = "text";
+          return null;
+        } else if (contentBlock.type === "tool_use") {
+          blockContext.currentBlockType = "tool_use";
+          blockContext.currentToolId = contentBlock.id || null;
+          blockContext.currentToolName = contentBlock.name || null;
+          blockContext.accumulatedToolInput = "";
+          return {
+            type: "tool_use_start",
+            timestamp,
+            data: {
+              toolCallId: contentBlock.id || "",
+              toolName: contentBlock.name || ""
+            }
+          };
+        }
+        return null;
+      }
+      case "content_block_delta": {
+        const delta = event.delta;
+        if (delta.type === "text_delta") {
+          return {
+            type: "text_delta",
+            timestamp,
+            data: { text: delta.text || "" }
+          };
+        } else if (delta.type === "input_json_delta") {
+          blockContext.accumulatedToolInput += delta.partial_json || "";
+          return {
+            type: "input_json_delta",
+            timestamp,
+            data: { partialJson: delta.partial_json || "" }
+          };
+        }
+        return null;
+      }
+      case "content_block_stop":
+        if (blockContext.currentBlockType === "tool_use" && blockContext.currentToolId) {
+          let input = {};
+          try {
+            if (blockContext.accumulatedToolInput) {
+              input = JSON.parse(blockContext.accumulatedToolInput);
+            }
+          } catch {
+            logger3.warn("Failed to parse tool input JSON", {
+              input: blockContext.accumulatedToolInput
+            });
+          }
+          const event2 = {
+            type: "tool_use_stop",
+            timestamp,
+            data: {
+              toolCallId: blockContext.currentToolId,
+              toolName: blockContext.currentToolName || "",
+              input
+            }
+          };
+          blockContext.currentBlockType = null;
+          blockContext.currentToolId = null;
+          blockContext.currentToolName = null;
+          blockContext.accumulatedToolInput = "";
+          return event2;
+        }
+        blockContext.currentBlockType = null;
+        return null;
+      case "message_delta": {
+        const msgDelta = event.delta;
+        if (msgDelta.stop_reason) {
+          blockContext.lastStopReason = msgDelta.stop_reason;
+        }
+        return null;
+      }
+      case "message_stop":
+        return {
+          type: "message_stop",
+          timestamp,
+          data: {
+            stopReason: this.mapStopReason(blockContext.lastStopReason)
+          }
+        };
+      default:
+        return null;
+    }
+  }
+  /**
+   * Convert SDK user message (contains tool_result)
+   */
+  convertUserMessage(msg) {
+    const events = [];
+    const sdkMsg = msg;
+    if (!sdkMsg.message || !Array.isArray(sdkMsg.message.content)) {
+      return events;
+    }
+    for (const block of sdkMsg.message.content) {
+      if (block && typeof block === "object" && "type" in block && block.type === "tool_result") {
+        const toolResultBlock = block;
+        events.push({
+          type: "tool_result",
+          timestamp: Date.now(),
+          data: {
+            toolCallId: toolResultBlock.tool_use_id,
+            result: toolResultBlock.content,
+            isError: toolResultBlock.is_error
+          }
+        });
+      }
+    }
+    return events;
+  }
+  /**
+   * Map SDK stop reason to our StopReason type
+   */
+  mapStopReason(sdkReason) {
+    switch (sdkReason) {
+      case "end_turn":
+        return "end_turn";
+      case "max_tokens":
+        return "max_tokens";
+      case "tool_use":
+        return "tool_use";
+      case "stop_sequence":
+        return "stop_sequence";
+      default:
+        return "other";
+    }
+  }
+  /**
+   * Yield events from Subject as AsyncIterable
+   */
+  async *yieldFromSubject(subject, _isComplete, getError) {
+    const queue = [];
+    let resolve = null;
+    let done = false;
+    const subscription = subject.subscribe({
+      next: (value) => {
+        if (resolve) {
+          resolve({ value, done: false });
+          resolve = null;
+        } else {
+          queue.push(value);
+        }
+      },
+      complete: () => {
+        done = true;
+        if (resolve) {
+          resolve({ value: void 0, done: true });
+          resolve = null;
+        }
+      },
+      error: (_err) => {
+        done = true;
+      }
+    });
+    try {
+      while (!done || queue.length > 0) {
+        const error = getError();
+        if (error) {
+          throw error;
+        }
+        if (queue.length > 0) {
+          yield queue.shift();
+        } else if (!done) {
+          const result = await new Promise((res) => {
+            resolve = res;
+          });
+          if (!result.done) {
+            yield result.value;
+          }
+        }
+      }
+    } finally {
+      subscription.unsubscribe();
+    }
+  }
+};
+function createClaudeDriver(config) {
+  return new ClaudeDriver(config);
+}
+export {
+  ClaudeDriver,
+  SDKQueryLifecycle,
+  buildSDKContent,
+  buildSDKUserMessage,
+  createClaudeDriver
+};
+//# sourceMappingURL=index.js.map