@agentxjs/runtime 0.1.1

package/dist/index.cjs

@@ -0,0 +1,3214 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createPersistence: () => createPersistence,
+  createRuntime: () => createRuntime
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/internal/SystemBusImpl.ts
+var import_rxjs = require("rxjs");
+var import_common = require("@agentxjs/common");
+var logger = (0, import_common.createLogger)("runtime/SystemBusImpl");
+var SystemBusImpl = class {
+  subject = new import_rxjs.Subject();
+  subscriptions = [];
+  nextId = 0;
+  isDestroyed = false;
+  // Cached restricted views
+  producerView = null;
+  consumerView = null;
+  constructor() {
+    this.subject.subscribe((event) => {
+      this.dispatch(event);
+    });
+  }
+  emit(event) {
+    if (this.isDestroyed) return;
+    this.subject.next(event);
+  }
+  emitBatch(events) {
+    for (const event of events) {
+      this.emit(event);
+    }
+  }
+  on(typeOrTypes, handler, options) {
+    if (this.isDestroyed) return () => {
+    };
+    const subscription = {
+      id: this.nextId++,
+      type: typeOrTypes,
+      handler,
+      filter: options?.filter,
+      priority: options?.priority ?? 0,
+      once: options?.once ?? false
+    };
+    this.subscriptions.push(subscription);
+    this.sortByPriority();
+    return () => this.removeSubscription(subscription.id);
+  }
+  onAny(handler, options) {
+    if (this.isDestroyed) return () => {
+    };
+    const subscription = {
+      id: this.nextId++,
+      type: "*",
+      handler,
+      filter: options?.filter,
+      priority: options?.priority ?? 0,
+      once: options?.once ?? false
+    };
+    this.subscriptions.push(subscription);
+    this.sortByPriority();
+    return () => this.removeSubscription(subscription.id);
+  }
+  once(type, handler) {
+    return this.on(type, handler, { once: true });
+  }
+  onCommand(type, handler) {
+    return this.on(type, handler);
+  }
+  emitCommand(type, data) {
+    this.emit({
+      type,
+      timestamp: Date.now(),
+      data,
+      source: "command",
+      category: type.endsWith("_response") ? "response" : "request",
+      intent: type.endsWith("_response") ? "result" : "request"
+    });
+  }
+  request(type, data, timeout = 3e4) {
+    return new Promise((resolve, reject) => {
+      const requestId = `req_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
+      const responseType = type.replace("_request", "_response");
+      const timer = setTimeout(() => {
+        unsubscribe();
+        reject(new Error(`Request timeout: ${type}`));
+      }, timeout);
+      const unsubscribe = this.onCommand(responseType, (event) => {
+        if (event.data.requestId === requestId) {
+          clearTimeout(timer);
+          unsubscribe();
+          resolve(event);
+        }
+      });
+      this.emitCommand(type, { ...data, requestId });
+    });
+  }
+  destroy() {
+    if (this.isDestroyed) return;
+    this.isDestroyed = true;
+    this.subscriptions = [];
+    this.subject.complete();
+  }
+  dispatch(event) {
+    const toRemove = [];
+    for (const sub of this.subscriptions) {
+      if (!this.matchesType(sub.type, event.type)) continue;
+      if (sub.filter && !sub.filter(event)) continue;
+      try {
+        sub.handler(event);
+      } catch (err) {
+        logger.error("Event handler error", {
+          eventType: event.type,
+          subscriptionType: sub.type,
+          error: err instanceof Error ? err.message : String(err),
+          stack: err instanceof Error ? err.stack : void 0
+        });
+      }
+      if (sub.once) {
+        toRemove.push(sub.id);
+      }
+    }
+    for (const id of toRemove) {
+      this.removeSubscription(id);
+    }
+  }
+  matchesType(subscriptionType, eventType) {
+    if (subscriptionType === "*") return true;
+    if (Array.isArray(subscriptionType)) return subscriptionType.includes(eventType);
+    return subscriptionType === eventType;
+  }
+  sortByPriority() {
+    this.subscriptions.sort((a, b) => b.priority - a.priority);
+  }
+  removeSubscription(id) {
+    this.subscriptions = this.subscriptions.filter((s) => s.id !== id);
+  }
+  /**
+   * Get a read-only consumer view (only subscribe methods)
+   */
+  asConsumer() {
+    if (!this.consumerView) {
+      this.consumerView = {
+        on: this.on.bind(this),
+        onAny: this.onAny.bind(this),
+        once: this.once.bind(this),
+        onCommand: this.onCommand.bind(this),
+        request: this.request.bind(this)
+      };
+    }
+    return this.consumerView;
+  }
+  /**
+   * Get a write-only producer view (only emit methods)
+   */
+  asProducer() {
+    if (!this.producerView) {
+      this.producerView = {
+        emit: this.emit.bind(this),
+        emitBatch: this.emitBatch.bind(this),
+        emitCommand: this.emitCommand.bind(this)
+      };
+    }
+    return this.producerView;
+  }
+};
+
+// src/internal/BusDriver.ts
+var import_common2 = require("@agentxjs/common");
+var logger2 = (0, import_common2.createLogger)("runtime/BusDriver");
+var BusDriver = class {
+  name = "BusDriver";
+  description = "Driver that listens to SystemBus for DriveableEvents";
+  config;
+  unsubscribe;
+  constructor(consumer, config) {
+    this.config = config;
+    logger2.debug("BusDriver created, subscribing to bus", {
+      agentId: config.agentId
+    });
+    this.unsubscribe = consumer.onAny(((event) => {
+      this.handleEvent(event);
+    }));
+  }
+  /**
+   * Handle incoming event from bus
+   */
+  handleEvent(event) {
+    if (!this.isDriveableEventForThisAgent(event)) {
+      return;
+    }
+    const driveableEvent = event;
+    logger2.debug("BusDriver received DriveableEvent", {
+      type: driveableEvent.type,
+      agentId: this.config.agentId,
+      requestId: driveableEvent.requestId
+    });
+    const streamEvent = this.toStreamEvent(driveableEvent);
+    this.config.onStreamEvent(streamEvent);
+    if (driveableEvent.type === "message_stop") {
+      this.config.onStreamComplete?.("message_stop");
+    } else if (driveableEvent.type === "interrupted") {
+      this.config.onStreamComplete?.("interrupted");
+    }
+  }
+  /**
+   * Check if event is a DriveableEvent for this agent
+   *
+   * Must check:
+   * 1. source === "environment" (from Claude)
+   * 2. context.agentId === this.config.agentId (for this agent)
+   */
+  isDriveableEventForThisAgent(event) {
+    const driveableTypes = [
+      "message_start",
+      "message_delta",
+      "message_stop",
+      "text_content_block_start",
+      "text_delta",
+      "text_content_block_stop",
+      "tool_use_content_block_start",
+      "input_json_delta",
+      "tool_use_content_block_stop",
+      "tool_call",
+      "tool_result",
+      "interrupted",
+      "error_received"
+    ];
+    if (event === null || typeof event !== "object" || !("type" in event) || typeof event.type !== "string") {
+      return false;
+    }
+    const e = event;
+    if (e.source !== "environment") {
+      return false;
+    }
+    if (!driveableTypes.includes(e.type)) {
+      return false;
+    }
+    if (e.context?.agentId !== this.config.agentId) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Convert DriveableEvent to StreamEvent
+   */
+  toStreamEvent(event) {
+    const { type, timestamp, data } = event;
+    switch (type) {
+      case "message_start": {
+        const d = data;
+        return {
+          type: "message_start",
+          timestamp,
+          data: {
+            messageId: d.message?.id ?? "",
+            model: d.message?.model ?? ""
+          }
+        };
+      }
+      case "message_stop": {
+        const d = data;
+        return {
+          type: "message_stop",
+          timestamp,
+          data: {
+            stopReason: d.stopReason
+          }
+        };
+      }
+      case "text_delta": {
+        const d = data;
+        return {
+          type: "text_delta",
+          timestamp,
+          data: { text: d.text }
+        };
+      }
+      case "tool_use_content_block_start": {
+        const d = data;
+        return {
+          type: "tool_use_start",
+          timestamp,
+          data: {
+            toolCallId: d.toolCallId ?? d.id ?? "",
+            toolName: d.toolName ?? d.name ?? ""
+          }
+        };
+      }
+      case "input_json_delta": {
+        const d = data;
+        return {
+          type: "input_json_delta",
+          timestamp,
+          data: { partialJson: d.partialJson }
+        };
+      }
+      case "tool_use_content_block_stop": {
+        const d = data;
+        return {
+          type: "tool_use_stop",
+          timestamp,
+          data: {
+            toolCallId: d.toolCallId ?? d.id ?? "",
+            toolName: d.toolName ?? d.name ?? "",
+            input: d.input ?? {}
+          }
+        };
+      }
+      case "tool_result": {
+        const d = data;
+        return {
+          type: "tool_result",
+          timestamp,
+          data: {
+            toolCallId: d.toolCallId ?? d.toolUseId ?? "",
+            result: d.result,
+            isError: d.isError
+          }
+        };
+      }
+      case "interrupted": {
+        return {
+          type: "message_stop",
+          timestamp,
+          data: { stopReason: "end_turn" }
+          // Use valid StopReason
+        };
+      }
+      case "error_received": {
+        const d = data;
+        return {
+          type: "error_received",
+          timestamp,
+          data: {
+            message: d.message,
+            errorCode: d.errorCode
+          }
+        };
+      }
+      default:
+        return { type, timestamp, data };
+    }
+  }
+  /**
+   * Dispose and stop listening
+   */
+  dispose() {
+    logger2.debug("BusDriver disposing", { agentId: this.config.agentId });
+    this.unsubscribe();
+  }
+};
+
+// src/internal/AgentInteractor.ts
+var import_common3 = require("@agentxjs/common");
+var logger3 = (0, import_common3.createLogger)("runtime/AgentInteractor");
+var AgentInteractor = class {
+  producer;
+  session;
+  context;
+  constructor(producer, session, context) {
+    this.producer = producer;
+    this.session = session;
+    this.context = context;
+    logger3.debug("AgentInteractor created", { agentId: context.agentId });
+  }
+  /**
+   * Receive user message
+   *
+   * @param content - Message content
+   * @param requestId - Request ID for correlation
+   */
+  async receive(content, requestId) {
+    logger3.debug("AgentInteractor.receive", {
+      requestId,
+      agentId: this.context.agentId,
+      contentPreview: content.substring(0, 50)
+    });
+    const userMessage = {
+      id: `msg_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
+      role: "user",
+      subtype: "user",
+      content,
+      timestamp: Date.now()
+    };
+    await this.session.addMessage(userMessage);
+    logger3.debug("UserMessage persisted", {
+      messageId: userMessage.id,
+      requestId
+    });
+    const eventContext = {
+      agentId: this.context.agentId,
+      imageId: this.context.imageId,
+      containerId: this.context.containerId,
+      sessionId: this.context.sessionId
+    };
+    this.producer.emit({
+      type: "user_message",
+      timestamp: Date.now(),
+      data: userMessage,
+      source: "agent",
+      category: "message",
+      intent: "request",
+      requestId,
+      context: eventContext,
+      broadcastable: false
+      // Internal event for ClaudeEffector
+    });
+    logger3.info("user_message event emitted to bus", {
+      messageId: userMessage.id,
+      requestId,
+      agentId: this.context.agentId,
+      eventType: "user_message"
+    });
+    return userMessage;
+  }
+  /**
+   * Interrupt current operation
+   *
+   * @param requestId - Optional request ID for correlation
+   */
+  interrupt(requestId) {
+    logger3.debug("AgentInteractor.interrupt", {
+      requestId,
+      agentId: this.context.agentId
+    });
+    const eventContext = {
+      agentId: this.context.agentId,
+      imageId: this.context.imageId,
+      containerId: this.context.containerId,
+      sessionId: this.context.sessionId
+    };
+    this.producer.emit({
+      type: "interrupt",
+      timestamp: Date.now(),
+      data: { agentId: this.context.agentId },
+      source: "agent",
+      category: "action",
+      intent: "request",
+      requestId,
+      context: eventContext,
+      broadcastable: false
+    });
+  }
+};
+
+// src/internal/RuntimeAgent.ts
+var import_agent = require("@agentxjs/agent");
+var import_common6 = require("@agentxjs/common");
+
+// src/environment/ClaudeReceptor.ts
+var import_common4 = require("@agentxjs/common");
+var logger4 = (0, import_common4.createLogger)("ecosystem/ClaudeReceptor");
+var ClaudeReceptor = class {
+  producer = null;
+  currentMeta = null;
+  /** Context for tracking content block state */
+  blockContext = {
+    currentBlockType: null,
+    currentBlockIndex: 0,
+    currentToolId: null,
+    currentToolName: null,
+    lastStopReason: null,
+    lastStopSequence: null
+  };
+  /**
+   * Connect to SystemBus producer to emit events
+   */
+  connect(producer) {
+    this.producer = producer;
+    logger4.debug("ClaudeReceptor connected to SystemBusProducer");
+  }
+  /**
+   * Feed SDK message to receptor with correlation metadata
+   * @param sdkMsg - SDK message from Claude
+   * @param meta - Request metadata for event correlation
+   */
+  feed(sdkMsg, meta) {
+    this.currentMeta = meta;
+    this.processStreamEvent(sdkMsg);
+  }
+  /**
+   * Emit interrupted event
+   */
+  emitInterrupted(reason, meta) {
+    const eventMeta = meta || this.currentMeta;
+    this.emitToBus({
+      type: "interrupted",
+      timestamp: Date.now(),
+      source: "environment",
+      category: "stream",
+      intent: "notification",
+      broadcastable: false,
+      requestId: eventMeta?.requestId,
+      context: eventMeta?.context,
+      data: { reason }
+    });
+  }
+  /**
+   * Emit error_received event
+   *
+   * Used when an error is received from the environment (e.g., Claude API error).
+   * This drives the MealyMachine to produce error_occurred + error_message events.
+   */
+  emitError(message, errorCode, meta) {
+    const eventMeta = meta || this.currentMeta;
+    this.emitToBus({
+      type: "error_received",
+      timestamp: Date.now(),
+      source: "environment",
+      category: "stream",
+      intent: "notification",
+      broadcastable: false,
+      requestId: eventMeta?.requestId,
+      context: eventMeta?.context,
+      data: { message, errorCode }
+    });
+  }
+  /**
+   * Feed SDK user message (contains tool_result) to receptor
+   * @param sdkMsg - SDK user message from Claude
+   * @param meta - Request metadata for event correlation
+   */
+  feedUserMessage(sdkMsg, meta) {
+    this.currentMeta = meta;
+    const { requestId, context } = meta;
+    if (!sdkMsg.message || !Array.isArray(sdkMsg.message.content)) {
+      return;
+    }
+    for (const block of sdkMsg.message.content) {
+      if (block && typeof block === "object" && "type" in block && block.type === "tool_result") {
+        const toolResultBlock = block;
+        this.emitToBus({
+          type: "tool_result",
+          timestamp: Date.now(),
+          source: "environment",
+          category: "stream",
+          intent: "notification",
+          broadcastable: false,
+          requestId,
+          context,
+          data: {
+            toolUseId: toolResultBlock.tool_use_id,
+            result: toolResultBlock.content,
+            isError: toolResultBlock.is_error || false
+          }
+        });
+      }
+    }
+  }
+  /**
+   * Process stream_event from SDK and emit corresponding DriveableEvent
+   *
+   * Uses currentMeta for requestId and context correlation.
+   */
+  processStreamEvent(sdkMsg) {
+    const event = sdkMsg.event;
+    const { requestId, context } = this.currentMeta || {};
+    switch (event.type) {
+      case "message_start":
+        this.blockContext = {
+          currentBlockType: null,
+          currentBlockIndex: 0,
+          currentToolId: null,
+          currentToolName: null,
+          lastStopReason: null,
+          lastStopSequence: null
+        };
+        this.emitToBus({
+          type: "message_start",
+          timestamp: Date.now(),
+          source: "environment",
+          category: "stream",
+          intent: "notification",
+          broadcastable: false,
+          requestId,
+          context,
+          data: {
+            message: {
+              id: event.message.id,
+              model: event.message.model
+            }
+          }
+        });
+        break;
+      case "content_block_start": {
+        const contentBlock = event.content_block;
+        this.blockContext.currentBlockIndex = event.index;
+        logger4.debug("content_block_start received", { contentBlock, index: event.index });
+        if (contentBlock.type === "text") {
+          this.blockContext.currentBlockType = "text";
+          this.emitToBus({
+            type: "text_content_block_start",
+            timestamp: Date.now(),
+            source: "environment",
+            category: "stream",
+            intent: "notification",
+            broadcastable: false,
+            index: event.index,
+            requestId,
+            context,
+            data: {}
+          });
+        } else if (contentBlock.type === "tool_use") {
+          this.blockContext.currentBlockType = "tool_use";
+          this.blockContext.currentToolId = contentBlock.id || null;
+          this.blockContext.currentToolName = contentBlock.name || null;
+          this.emitToBus({
+            type: "tool_use_content_block_start",
+            timestamp: Date.now(),
+            source: "environment",
+            category: "stream",
+            intent: "notification",
+            broadcastable: false,
+            index: event.index,
+            requestId,
+            context,
+            data: {
+              id: contentBlock.id || "",
+              name: contentBlock.name || ""
+            }
+          });
+        }
+        break;
+      }
+      case "content_block_delta": {
+        const delta = event.delta;
+        if (delta.type === "text_delta") {
+          this.emitToBus({
+            type: "text_delta",
+            timestamp: Date.now(),
+            source: "environment",
+            category: "stream",
+            intent: "notification",
+            broadcastable: false,
+            requestId,
+            context,
+            data: { text: delta.text || "" }
+          });
+        } else if (delta.type === "input_json_delta") {
+          this.emitToBus({
+            type: "input_json_delta",
+            timestamp: Date.now(),
+            source: "environment",
+            category: "stream",
+            intent: "notification",
+            broadcastable: false,
+            index: this.blockContext.currentBlockIndex,
+            requestId,
+            context,
+            data: { partialJson: delta.partial_json || "" }
+          });
+        }
+        break;
+      }
+      case "content_block_stop":
+        if (this.blockContext.currentBlockType === "tool_use" && this.blockContext.currentToolId) {
+          this.emitToBus({
+            type: "tool_use_content_block_stop",
+            timestamp: Date.now(),
+            source: "environment",
+            category: "stream",
+            intent: "notification",
+            broadcastable: false,
+            index: this.blockContext.currentBlockIndex,
+            requestId,
+            context,
+            data: {}
+          });
+        } else {
+          this.emitToBus({
+            type: "text_content_block_stop",
+            timestamp: Date.now(),
+            source: "environment",
+            category: "stream",
+            intent: "notification",
+            broadcastable: false,
+            index: this.blockContext.currentBlockIndex,
+            requestId,
+            context,
+            data: {}
+          });
+        }
+        this.blockContext.currentBlockType = null;
+        this.blockContext.currentToolId = null;
+        this.blockContext.currentToolName = null;
+        break;
+      case "message_delta": {
+        const msgDelta = event.delta;
+        if (msgDelta.stop_reason) {
+          this.blockContext.lastStopReason = msgDelta.stop_reason;
+          this.blockContext.lastStopSequence = msgDelta.stop_sequence || null;
+        }
+        break;
+      }
+      case "message_stop":
+        this.emitToBus({
+          type: "message_stop",
+          timestamp: Date.now(),
+          source: "environment",
+          category: "stream",
+          intent: "notification",
+          broadcastable: false,
+          requestId,
+          context,
+          data: {
+            stopReason: this.blockContext.lastStopReason || "end_turn",
+            stopSequence: this.blockContext.lastStopSequence || void 0
+          }
+        });
+        this.blockContext.lastStopReason = null;
+        this.blockContext.lastStopSequence = null;
+        break;
+    }
+  }
+  emitToBus(event) {
+    if (this.producer) {
+      this.producer.emit(event);
+    }
+  }
+};
+
+// src/environment/ClaudeEffector.ts
+var import_claude_agent_sdk = require("@anthropic-ai/claude-agent-sdk");
+var import_rxjs2 = require("rxjs");
+var import_common5 = require("@agentxjs/common");
+
+// src/environment/buildOptions.ts
+function buildOptions(context, abortController) {
+  const options = {
+    abortController,
+    includePartialMessages: true
+  };
+  if (context.cwd) {
+    options.cwd = context.cwd;
+  }
+  const env = {
+    ...process.env
+  };
+  if (context.baseUrl) {
+    env.ANTHROPIC_BASE_URL = context.baseUrl;
+  }
+  if (context.apiKey) {
+    env.ANTHROPIC_API_KEY = context.apiKey;
+  }
+  options.env = env;
+  options.executable = process.execPath;
+  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.permissionMode) {
+    options.permissionMode = context.permissionMode;
+  } else {
+    options.permissionMode = "bypassPermissions";
+  }
+  return options;
+}
+
+// src/environment/helpers.ts
+function buildPrompt(message) {
+  if (typeof message.content === "string") {
+    return message.content;
+  }
+  if (Array.isArray(message.content)) {
+    return message.content.filter((part) => part.type === "text").map((part) => part.text ?? "").join("\n");
+  }
+  return "";
+}
+function buildSDKUserMessage(message, sessionId) {
+  return {
+    type: "user",
+    message: { role: "user", content: buildPrompt(message) },
+    parent_tool_use_id: null,
+    session_id: sessionId
+  };
+}
+
+// src/environment/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/environment/ClaudeEffector.ts
+var logger5 = (0, import_common5.createLogger)("ecosystem/ClaudeEffector");
+var DEFAULT_TIMEOUT = 3e4;
+var ClaudeEffector = class {
+  config;
+  receptor;
+  promptSubject = new import_rxjs2.Subject();
+  currentAbortController = null;
+  claudeQuery = null;
+  isInitialized = false;
+  wasInterrupted = false;
+  currentMeta = null;
+  constructor(config, receptor) {
+    this.config = config;
+    this.receptor = receptor;
+  }
+  /**
+   * Connect to SystemBus consumer to subscribe to events
+   */
+  connect(consumer) {
+    logger5.debug("ClaudeEffector connected to SystemBusConsumer", {
+      agentId: this.config.agentId
+    });
+    consumer.on("user_message", async (event) => {
+      const typedEvent = event;
+      logger5.debug("user_message event received", {
+        eventAgentId: typedEvent.context?.agentId,
+        myAgentId: this.config.agentId,
+        matches: typedEvent.context?.agentId === this.config.agentId
+      });
+      if (typedEvent.context?.agentId !== this.config.agentId) {
+        return;
+      }
+      const message = typedEvent.data;
+      const meta = {
+        requestId: typedEvent.requestId || "",
+        context: typedEvent.context || {}
+      };
+      await this.send(message, meta);
+    });
+    consumer.on("interrupt", (event) => {
+      const typedEvent = event;
+      if (typedEvent.context?.agentId !== this.config.agentId) {
+        return;
+      }
+      const meta = {
+        requestId: typedEvent.requestId || "",
+        context: typedEvent.context || {}
+      };
+      this.interrupt(meta);
+    });
+  }
+  /**
+   * Send a message to Claude SDK
+   */
+  async send(message, meta) {
+    this.wasInterrupted = false;
+    this.currentAbortController = new AbortController();
+    this.currentMeta = meta;
+    const timeout = this.config.timeout ?? DEFAULT_TIMEOUT;
+    const timeoutId = setTimeout(() => {
+      logger5.warn("Request timeout", { timeout });
+      this.currentAbortController?.abort(new Error(`Request timeout after ${timeout}ms`));
+    }, timeout);
+    try {
+      await this.initialize(this.currentAbortController);
+      const sessionId = this.config.sessionId || "default";
+      const sdkUserMessage = buildSDKUserMessage(message, sessionId);
+      logger5.debug("Sending message to Claude", {
+        content: typeof message.content === "string" ? message.content.substring(0, 80) : "[structured]",
+        timeout,
+        requestId: meta.requestId
+      });
+      this.promptSubject.next(sdkUserMessage);
+    } finally {
+      clearTimeout(timeoutId);
+      this.currentAbortController = null;
+      this.wasInterrupted = false;
+    }
+  }
+  /**
+   * Interrupt current operation
+   */
+  interrupt(meta) {
+    if (this.claudeQuery) {
+      logger5.debug("Interrupting Claude query", { requestId: meta?.requestId });
+      this.wasInterrupted = true;
+      if (meta) {
+        this.currentMeta = meta;
+      }
+      this.claudeQuery.interrupt().catch((err) => {
+        logger5.debug("SDK interrupt() error (may be expected)", { error: err });
+      });
+    }
+  }
+  /**
+   * Initialize the Claude SDK query (lazy initialization)
+   */
+  async initialize(abortController) {
+    if (this.isInitialized) return;
+    logger5.info("Initializing ClaudeEffector");
+    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
+    };
+    const sdkOptions = buildOptions(context, abortController);
+    const promptStream = observableToAsyncIterable(this.promptSubject);
+    this.claudeQuery = (0, import_claude_agent_sdk.query)({
+      prompt: promptStream,
+      options: sdkOptions
+    });
+    this.isInitialized = true;
+    this.startBackgroundListener();
+    logger5.info("ClaudeEffector initialized");
+  }
+  /**
+   * Start background listener for SDK responses
+   */
+  startBackgroundListener() {
+    (async () => {
+      try {
+        for await (const sdkMsg of this.claudeQuery) {
+          logger5.debug("SDK message received", {
+            type: sdkMsg.type,
+            subtype: sdkMsg.subtype,
+            sessionId: sdkMsg.session_id,
+            hasCurrentMeta: !!this.currentMeta
+          });
+          if (sdkMsg.type === "stream_event" && this.currentMeta) {
+            this.receptor.feed(sdkMsg, this.currentMeta);
+          }
+          if (sdkMsg.type === "user" && this.currentMeta) {
+            this.receptor.feedUserMessage(sdkMsg, this.currentMeta);
+          }
+          if (sdkMsg.session_id && this.config.onSessionIdCaptured) {
+            this.config.onSessionIdCaptured(sdkMsg.session_id);
+          }
+          if (sdkMsg.type === "result") {
+            const resultMsg = sdkMsg;
+            logger5.info("SDK result received (full)", {
+              fullResult: JSON.stringify(sdkMsg, null, 2)
+            });
+            logger5.info("SDK result received", {
+              subtype: resultMsg.subtype,
+              isError: resultMsg.is_error,
+              errors: resultMsg.errors,
+              wasInterrupted: this.wasInterrupted
+            });
+            if (resultMsg.subtype === "error_during_execution" && this.wasInterrupted) {
+              this.receptor.emitInterrupted("user_interrupt", this.currentMeta || void 0);
+            } else if (resultMsg.is_error && this.currentMeta) {
+              const fullResult = sdkMsg;
+              const errorMessage = fullResult.error?.message || fullResult.errors?.join(", ") || (typeof fullResult.result === "string" ? fullResult.result : null) || "An error occurred";
+              const errorCode = fullResult.error?.type || resultMsg.subtype || "api_error";
+              this.receptor.emitError(errorMessage, errorCode, this.currentMeta);
+            }
+          }
+        }
+      } catch (error) {
+        if (this.isAbortError(error)) {
+          logger5.debug("Background listener aborted (expected during interrupt)");
+          this.resetState();
+        } else {
+          logger5.error("Background listener error", { error });
+          if (this.currentMeta) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            this.receptor.emitError(errorMessage, "runtime_error", this.currentMeta);
+          }
+        }
+      }
+    })();
+  }
+  /**
+   * 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;
+  }
+  /**
+   * Reset state after abort
+   */
+  resetState() {
+    this.isInitialized = false;
+    this.claudeQuery = null;
+    this.promptSubject = new import_rxjs2.Subject();
+  }
+  /**
+   * Dispose and cleanup resources
+   */
+  dispose() {
+    logger5.debug("Disposing ClaudeEffector");
+    if (this.currentAbortController) {
+      this.currentAbortController.abort();
+    }
+    this.promptSubject.complete();
+    this.resetState();
+  }
+};
+
+// src/environment/ClaudeEnvironment.ts
+var ClaudeEnvironment = class {
+  name = "claude";
+  receptor;
+  effector;
+  claudeEffector;
+  constructor(config) {
+    const claudeReceptor = new ClaudeReceptor();
+    const claudeEffector = new ClaudeEffector(config, claudeReceptor);
+    this.receptor = claudeReceptor;
+    this.effector = claudeEffector;
+    this.claudeEffector = claudeEffector;
+  }
+  /**
+   * Dispose environment resources
+   */
+  dispose() {
+    this.claudeEffector.dispose();
+  }
+};
+
+// src/internal/RuntimeAgent.ts
+var logger6 = (0, import_common6.createLogger)("runtime/RuntimeAgent");
+var BusPresenter = class {
+  constructor(producer, session, agentId, imageId, containerId) {
+    this.producer = producer;
+    this.session = session;
+    this.agentId = agentId;
+    this.imageId = imageId;
+    this.containerId = containerId;
+  }
+  name = "BusPresenter";
+  description = "Forwards AgentOutput to SystemBus and collects messages";
+  present(_agentId, output) {
+    const category = this.getCategoryForOutput(output);
+    if (output.type === "user_message") {
+      return;
+    }
+    let data = output.data;
+    if (category === "message") {
+      data = this.convertToMessage(output);
+    }
+    const systemEvent = {
+      type: output.type,
+      timestamp: output.timestamp,
+      data,
+      source: "agent",
+      category,
+      intent: "notification",
+      context: {
+        containerId: this.containerId,
+        imageId: this.imageId,
+        agentId: this.agentId,
+        sessionId: this.session.sessionId
+      }
+    };
+    this.producer.emit(systemEvent);
+    if (category === "message") {
+      this.session.addMessage(data).catch((err) => {
+        logger6.error("Failed to persist message", { error: err, messageType: output.type });
+      });
+    }
+  }
+  /**
+   * Convert AgentOutput to proper Message type for persistence
+   */
+  convertToMessage(output) {
+    const eventData = output.data;
+    const messageId = eventData.messageId ?? eventData.id;
+    const timestamp = eventData.timestamp || output.timestamp;
+    switch (output.type) {
+      case "assistant_message": {
+        const content = eventData.content;
+        return {
+          id: messageId,
+          role: "assistant",
+          subtype: "assistant",
+          content,
+          timestamp
+        };
+      }
+      case "tool_call_message": {
+        const toolCalls = eventData.toolCalls;
+        const toolCall = toolCalls[0];
+        return {
+          id: messageId,
+          role: "assistant",
+          subtype: "tool-call",
+          toolCall,
+          timestamp
+        };
+      }
+      case "tool_result_message": {
+        const results = eventData.results;
+        const toolResult = results[0];
+        return {
+          id: messageId,
+          role: "tool",
+          subtype: "tool-result",
+          toolCallId: toolResult.id,
+          toolResult,
+          timestamp
+        };
+      }
+      case "error_message": {
+        const content = eventData.content;
+        const errorCode = eventData.errorCode;
+        return {
+          id: messageId,
+          role: "error",
+          subtype: "error",
+          content,
+          errorCode,
+          timestamp
+        };
+      }
+      default:
+        logger6.warn("Unknown message type, passing through", { type: output.type });
+        return eventData;
+    }
+  }
+  /**
+   * Determine event category from output type
+   */
+  getCategoryForOutput(output) {
+    const type = output.type;
+    if (type === "message_start" || type === "message_delta" || type === "message_stop" || type === "text_delta" || type === "tool_use_start" || type === "input_json_delta" || type === "tool_use_stop" || type === "tool_result") {
+      return "stream";
+    }
+    if (type === "user_message" || type === "assistant_message" || type === "tool_call_message" || type === "tool_result_message" || type === "error_message") {
+      return "message";
+    }
+    if (type === "turn_request" || type === "turn_response") {
+      return "turn";
+    }
+    return "state";
+  }
+};
+var RuntimeAgent = class {
+  agentId;
+  imageId;
+  name;
+  containerId;
+  createdAt;
+  _lifecycle = "running";
+  interactor;
+  driver;
+  engine;
+  producer;
+  environment;
+  imageRepository;
+  session;
+  config;
+  constructor(config) {
+    this.agentId = config.agentId;
+    this.imageId = config.imageId;
+    this.name = config.config.name ?? `agent-${config.agentId}`;
+    this.containerId = config.containerId;
+    this.createdAt = Date.now();
+    this.producer = config.bus.asProducer();
+    this.session = config.session;
+    this.config = config.config;
+    this.imageRepository = config.imageRepository;
+    const resumeSessionId = config.image.metadata?.claudeSdkSessionId;
+    this.environment = new ClaudeEnvironment({
+      agentId: this.agentId,
+      apiKey: config.llmConfig.apiKey,
+      baseUrl: config.llmConfig.baseUrl,
+      model: config.llmConfig.model,
+      systemPrompt: config.config.systemPrompt,
+      resumeSessionId,
+      onSessionIdCaptured: (sdkSessionId) => {
+        this.saveSessionId(sdkSessionId);
+      }
+    });
+    this.environment.receptor.connect(config.bus.asProducer());
+    this.environment.effector.connect(config.bus.asConsumer());
+    logger6.info("ClaudeEnvironment created for agent", {
+      agentId: this.agentId,
+      imageId: this.imageId,
+      resumeSessionId: resumeSessionId ?? "none",
+      isResume: !!resumeSessionId,
+      imageMetadata: config.image.metadata
+    });
+    const presenter = new BusPresenter(
+      this.producer,
+      config.session,
+      this.agentId,
+      this.imageId,
+      this.containerId
+    );
+    this.engine = (0, import_agent.createAgent)({
+      driver: {
+        name: "DummyDriver",
+        description: "Placeholder driver for push-based event handling",
+        receive: async function* () {
+        },
+        interrupt: () => {
+        }
+      },
+      presenter
+    });
+    this.interactor = new AgentInteractor(this.producer, config.session, {
+      agentId: this.agentId,
+      imageId: this.imageId,
+      containerId: this.containerId,
+      sessionId: config.session.sessionId
+    });
+    this.driver = new BusDriver(config.bus.asConsumer(), {
+      agentId: this.agentId,
+      onStreamEvent: (event) => {
+        logger6.debug("BusDriver \u2192 Engine.handleStreamEvent", { type: event.type });
+        this.engine.handleStreamEvent(event);
+      },
+      onStreamComplete: (reason) => {
+        logger6.debug("Stream completed", { reason, agentId: this.agentId });
+      }
+    });
+    logger6.debug("RuntimeAgent created", {
+      agentId: this.agentId,
+      imageId: this.imageId
+    });
+  }
+  /**
+   * Save SDK session ID to image metadata for future resume
+   */
+  saveSessionId(sdkSessionId) {
+    logger6.info("Saving SDK session ID to image metadata", {
+      agentId: this.agentId,
+      imageId: this.imageId,
+      sdkSessionId
+    });
+    this.imageRepository.updateMetadata(this.imageId, { claudeSdkSessionId: sdkSessionId }).catch((err) => {
+      logger6.error("Failed to save SDK session ID", { error: err, imageId: this.imageId });
+    });
+  }
+  get lifecycle() {
+    return this._lifecycle;
+  }
+  /**
+   * Receive a message from user
+   *
+   * @param content - Message content
+   * @param requestId - Request ID for correlation
+   */
+  async receive(content, requestId) {
+    logger6.debug("RuntimeAgent.receive called", {
+      agentId: this.agentId,
+      contentPreview: content.substring(0, 50),
+      requestId
+    });
+    if (this._lifecycle !== "running") {
+      throw new Error(`Cannot send message to ${this._lifecycle} agent`);
+    }
+    await this.interactor.receive(content, requestId || `req_${Date.now()}`);
+    logger6.debug("RuntimeAgent.receive completed", { agentId: this.agentId });
+  }
+  /**
+   * Interrupt current operation
+   */
+  interrupt(requestId) {
+    logger6.debug("RuntimeAgent.interrupt called", { agentId: this.agentId, requestId });
+    this.interactor.interrupt(requestId);
+    this.producer.emit({
+      type: "interrupted",
+      timestamp: Date.now(),
+      source: "agent",
+      category: "lifecycle",
+      intent: "notification",
+      data: {
+        agentId: this.agentId,
+        containerId: this.containerId
+      },
+      context: {
+        containerId: this.containerId,
+        imageId: this.imageId,
+        agentId: this.agentId,
+        sessionId: this.session.sessionId
+      }
+    });
+  }
+  async stop() {
+    if (this._lifecycle === "destroyed") {
+      throw new Error("Cannot stop destroyed agent");
+    }
+    this._lifecycle = "stopped";
+  }
+  async resume() {
+    if (this._lifecycle === "destroyed") {
+      throw new Error("Cannot resume destroyed agent");
+    }
+    this._lifecycle = "running";
+    this.producer.emit({
+      type: "session_resumed",
+      timestamp: Date.now(),
+      source: "session",
+      category: "lifecycle",
+      intent: "notification",
+      data: {
+        sessionId: this.session.sessionId,
+        agentId: this.agentId,
+        containerId: this.containerId
+      },
+      context: {
+        containerId: this.containerId,
+        imageId: this.imageId,
+        agentId: this.agentId,
+        sessionId: this.session.sessionId
+      }
+    });
+  }
+  async destroy() {
+    if (this._lifecycle !== "destroyed") {
+      this.driver.dispose();
+      this.environment.dispose();
+      await this.engine.destroy();
+      this._lifecycle = "destroyed";
+      this.producer.emit({
+        type: "session_destroyed",
+        timestamp: Date.now(),
+        source: "session",
+        category: "lifecycle",
+        intent: "notification",
+        data: {
+          sessionId: this.session.sessionId,
+          agentId: this.agentId,
+          containerId: this.containerId
+        },
+        context: {
+          containerId: this.containerId,
+          imageId: this.imageId,
+          agentId: this.agentId,
+          sessionId: this.session.sessionId
+        }
+      });
+    }
+  }
+};
+
+// src/internal/RuntimeSession.ts
+var RuntimeSession = class {
+  sessionId;
+  imageId;
+  containerId;
+  createdAt;
+  repository;
+  producer;
+  constructor(config) {
+    this.sessionId = config.sessionId;
+    this.imageId = config.imageId;
+    this.containerId = config.containerId;
+    this.createdAt = Date.now();
+    this.repository = config.repository;
+    this.producer = config.producer;
+  }
+  /**
+   * Initialize session in storage
+   */
+  async initialize() {
+    const record = {
+      sessionId: this.sessionId,
+      imageId: this.imageId,
+      containerId: this.containerId,
+      createdAt: this.createdAt,
+      updatedAt: this.createdAt
+    };
+    await this.repository.saveSession(record);
+    this.producer.emit({
+      type: "session_created",
+      timestamp: this.createdAt,
+      source: "session",
+      category: "lifecycle",
+      intent: "notification",
+      data: {
+        sessionId: this.sessionId,
+        imageId: this.imageId,
+        containerId: this.containerId,
+        createdAt: this.createdAt
+      },
+      context: {
+        containerId: this.containerId,
+        sessionId: this.sessionId
+      }
+    });
+  }
+  async addMessage(message) {
+    await this.repository.addMessage(this.sessionId, message);
+    this.producer.emit({
+      type: "message_persisted",
+      timestamp: Date.now(),
+      source: "session",
+      category: "persist",
+      intent: "result",
+      data: {
+        sessionId: this.sessionId,
+        messageId: message.id,
+        savedAt: Date.now()
+      },
+      context: {
+        containerId: this.containerId,
+        sessionId: this.sessionId
+      }
+    });
+  }
+  async getMessages() {
+    return this.repository.getMessages(this.sessionId);
+  }
+  async clear() {
+    await this.repository.clearMessages(this.sessionId);
+  }
+};
+
+// src/internal/RuntimeSandbox.ts
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+var RuntimeWorkdir = class {
+  id;
+  name;
+  path;
+  constructor(agentId, path) {
+    this.id = agentId;
+    this.name = `workdir_${agentId}`;
+    this.path = path;
+  }
+};
+var RuntimeSandbox = class {
+  name;
+  workdir;
+  initialized = false;
+  constructor(config) {
+    this.name = `sandbox_${config.agentId}`;
+    const workdirPath = (0, import_node_path.join)(
+      config.basePath,
+      "containers",
+      config.containerId,
+      "workdirs",
+      config.agentId
+    );
+    this.workdir = new RuntimeWorkdir(config.agentId, workdirPath);
+  }
+  /**
+   * Initialize sandbox - create directories
+   */
+  async initialize() {
+    if (this.initialized) return;
+    await (0, import_promises.mkdir)(this.workdir.path, { recursive: true });
+    this.initialized = true;
+  }
+  /**
+   * Cleanup sandbox - remove directories (optional)
+   */
+  async cleanup() {
+  }
+};
+
+// src/internal/RuntimeImage.ts
+var import_common7 = require("@agentxjs/common");
+var logger7 = (0, import_common7.createLogger)("runtime/RuntimeImage");
+var RuntimeImage = class _RuntimeImage {
+  constructor(record, context) {
+    this.record = record;
+    this.context = context;
+  }
+  // ==================== Getters ====================
+  get imageId() {
+    return this.record.imageId;
+  }
+  get containerId() {
+    return this.record.containerId;
+  }
+  get sessionId() {
+    return this.record.sessionId;
+  }
+  get name() {
+    return this.record.name;
+  }
+  get description() {
+    return this.record.description;
+  }
+  get systemPrompt() {
+    return this.record.systemPrompt;
+  }
+  get createdAt() {
+    return this.record.createdAt;
+  }
+  get updatedAt() {
+    return this.record.updatedAt;
+  }
+  // ==================== Static Factory Methods ====================
+  /**
+   * Create a new image (conversation)
+   */
+  static async create(config, context) {
+    const now = Date.now();
+    const imageId = _RuntimeImage.generateImageId();
+    const sessionId = _RuntimeImage.generateSessionId();
+    const record = {
+      imageId,
+      containerId: config.containerId,
+      sessionId,
+      name: config.name ?? "New Conversation",
+      description: config.description,
+      systemPrompt: config.systemPrompt,
+      createdAt: now,
+      updatedAt: now
+    };
+    await context.imageRepository.saveImage(record);
+    await context.sessionRepository.saveSession({
+      sessionId,
+      imageId,
+      containerId: config.containerId,
+      createdAt: now,
+      updatedAt: now
+    });
+    logger7.info("Image created", {
+      imageId,
+      sessionId,
+      containerId: config.containerId,
+      name: record.name
+    });
+    return new _RuntimeImage(record, context);
+  }
+  /**
+   * Load an existing image from storage
+   */
+  static async load(imageId, context) {
+    const record = await context.imageRepository.findImageById(imageId);
+    if (!record) {
+      logger7.debug("Image not found", { imageId });
+      return null;
+    }
+    logger7.debug("Image loaded", { imageId, name: record.name });
+    return new _RuntimeImage(record, context);
+  }
+  /**
+   * List all images in a container
+   */
+  static async listByContainer(containerId, context) {
+    return context.imageRepository.findImagesByContainerId(containerId);
+  }
+  /**
+   * List all images
+   */
+  static async listAll(context) {
+    return context.imageRepository.findAllImages();
+  }
+  // ==================== Instance Methods ====================
+  /**
+   * Get messages for this conversation
+   */
+  async getMessages() {
+    return this.context.sessionRepository.getMessages(this.sessionId);
+  }
+  /**
+   * Update image metadata
+   */
+  async update(updates) {
+    const now = Date.now();
+    const updatedRecord = {
+      ...this.record,
+      name: updates.name ?? this.record.name,
+      description: updates.description ?? this.record.description,
+      updatedAt: now
+    };
+    await this.context.imageRepository.saveImage(updatedRecord);
+    logger7.info("Image updated", { imageId: this.imageId, updates });
+    return new _RuntimeImage(updatedRecord, this.context);
+  }
+  /**
+   * Delete this image and its session
+   */
+  async delete() {
+    await this.context.sessionRepository.deleteSession(this.sessionId);
+    await this.context.imageRepository.deleteImage(this.imageId);
+    logger7.info("Image deleted", { imageId: this.imageId, sessionId: this.sessionId });
+  }
+  /**
+   * Get the underlying record
+   */
+  toRecord() {
+    return { ...this.record };
+  }
+  // ==================== Private Helpers ====================
+  static generateImageId() {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).substring(2, 8);
+    return `img_${timestamp}_${random}`;
+  }
+  static generateSessionId() {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).substring(2, 8);
+    return `sess_${timestamp}_${random}`;
+  }
+};
+
+// src/internal/RuntimeContainer.ts
+var import_common8 = require("@agentxjs/common");
+var logger8 = (0, import_common8.createLogger)("runtime/RuntimeContainer");
+var RuntimeContainer = class _RuntimeContainer {
+  containerId;
+  createdAt;
+  /** Map of agentId → RuntimeAgent */
+  agents = /* @__PURE__ */ new Map();
+  /** Map of imageId → agentId (for quick lookup) */
+  imageToAgent = /* @__PURE__ */ new Map();
+  context;
+  constructor(containerId, createdAt, context) {
+    this.containerId = containerId;
+    this.createdAt = createdAt;
+    this.context = context;
+  }
+  /**
+   * Create a new container and persist it
+   */
+  static async create(containerId, context) {
+    const now = Date.now();
+    const record = {
+      containerId,
+      createdAt: now,
+      updatedAt: now
+    };
+    await context.persistence.containers.saveContainer(record);
+    const container = new _RuntimeContainer(containerId, now, context);
+    context.bus.emit({
+      type: "container_created",
+      timestamp: now,
+      source: "container",
+      category: "lifecycle",
+      intent: "notification",
+      data: {
+        containerId,
+        createdAt: now
+      },
+      context: {
+        containerId
+      }
+    });
+    logger8.info("Container created", { containerId });
+    return container;
+  }
+  /**
+   * Load an existing container from persistence
+   */
+  static async load(containerId, context) {
+    const record = await context.persistence.containers.findContainerById(containerId);
+    if (!record) return null;
+    logger8.info("Container loaded", { containerId });
+    return new _RuntimeContainer(containerId, record.createdAt, context);
+  }
+  // ==================== Image → Agent Lifecycle ====================
+  /**
+   * Run an image - create or reuse an Agent for the given Image
+   * @returns { agent, reused } - the agent and whether it was reused
+   */
+  async runImage(image) {
+    const existingAgentId = this.imageToAgent.get(image.imageId);
+    if (existingAgentId) {
+      const existingAgent = this.agents.get(existingAgentId);
+      if (existingAgent) {
+        logger8.info("Reusing existing agent for image", {
+          containerId: this.containerId,
+          imageId: image.imageId,
+          agentId: existingAgentId
+        });
+        return { agent: existingAgent, reused: true };
+      }
+      this.imageToAgent.delete(image.imageId);
+    }
+    const agentId = this.generateAgentId();
+    const sandbox = new RuntimeSandbox({
+      agentId,
+      containerId: this.containerId,
+      basePath: this.context.basePath
+    });
+    await sandbox.initialize();
+    const session = new RuntimeSession({
+      sessionId: image.sessionId,
+      imageId: image.imageId,
+      containerId: this.containerId,
+      repository: this.context.persistence.sessions,
+      producer: this.context.bus.asProducer()
+    });
+    const agent = new RuntimeAgent({
+      agentId,
+      imageId: image.imageId,
+      containerId: this.containerId,
+      config: {
+        name: image.name,
+        description: image.description,
+        systemPrompt: image.systemPrompt
+      },
+      bus: this.context.bus,
+      sandbox,
+      session,
+      llmConfig: this.context.llmConfig,
+      image,
+      // Pass full image record for metadata access
+      imageRepository: this.context.persistence.images
+    });
+    this.agents.set(agentId, agent);
+    this.imageToAgent.set(image.imageId, agentId);
+    this.context.bus.emit({
+      type: "agent_registered",
+      timestamp: Date.now(),
+      source: "container",
+      category: "lifecycle",
+      intent: "notification",
+      data: {
+        containerId: this.containerId,
+        agentId,
+        definitionName: image.name,
+        registeredAt: Date.now()
+      },
+      context: {
+        containerId: this.containerId,
+        agentId
+      }
+    });
+    logger8.info("Agent created for image", {
+      containerId: this.containerId,
+      imageId: image.imageId,
+      agentId
+    });
+    return { agent, reused: false };
+  }
+  /**
+   * Stop an image - destroy the Agent but keep the Image
+   */
+  async stopImage(imageId) {
+    const agentId = this.imageToAgent.get(imageId);
+    if (!agentId) {
+      logger8.debug("Image not running, nothing to stop", {
+        imageId,
+        containerId: this.containerId
+      });
+      return false;
+    }
+    logger8.info("Stopping image", { imageId, agentId, containerId: this.containerId });
+    const success = await this.destroyAgent(agentId);
+    if (success) {
+      this.imageToAgent.delete(imageId);
+      logger8.info("Image stopped", { imageId, agentId, containerId: this.containerId });
+    }
+    return success;
+  }
+  /**
+   * Get agent ID for an image (if running)
+   */
+  getAgentIdForImage(imageId) {
+    return this.imageToAgent.get(imageId);
+  }
+  /**
+   * Check if an image has a running agent
+   */
+  isImageOnline(imageId) {
+    const agentId = this.imageToAgent.get(imageId);
+    return agentId !== void 0 && this.agents.has(agentId);
+  }
+  /**
+   * Get imageId for an agent (reverse lookup)
+   */
+  getImageIdForAgent(agentId) {
+    for (const [imageId, mappedAgentId] of this.imageToAgent.entries()) {
+      if (mappedAgentId === agentId) {
+        return imageId;
+      }
+    }
+    return void 0;
+  }
+  getAgent(agentId) {
+    return this.agents.get(agentId);
+  }
+  listAgents() {
+    return Array.from(this.agents.values());
+  }
+  get agentCount() {
+    return this.agents.size;
+  }
+  async destroyAgent(agentId) {
+    const agent = this.agents.get(agentId);
+    if (!agent) return false;
+    await agent.destroy();
+    this.agents.delete(agentId);
+    this.context.bus.emit({
+      type: "agent_unregistered",
+      timestamp: Date.now(),
+      source: "container",
+      category: "lifecycle",
+      intent: "notification",
+      data: {
+        containerId: this.containerId,
+        agentId
+      },
+      context: {
+        containerId: this.containerId,
+        agentId
+      }
+    });
+    logger8.info("Agent destroyed", { containerId: this.containerId, agentId });
+    return true;
+  }
+  async destroyAllAgents() {
+    const agentIds = Array.from(this.agents.keys());
+    for (const agentId of agentIds) {
+      await this.destroyAgent(agentId);
+    }
+  }
+  // ==================== Container Lifecycle ====================
+  async dispose() {
+    const agentCount = this.agents.size;
+    await this.destroyAllAgents();
+    this.context.bus.emit({
+      type: "container_destroyed",
+      timestamp: Date.now(),
+      source: "container",
+      category: "lifecycle",
+      intent: "notification",
+      data: {
+        containerId: this.containerId,
+        agentCount
+      },
+      context: {
+        containerId: this.containerId
+      }
+    });
+    this.context.onDisposed?.(this.containerId);
+    logger8.info("Container disposed", { containerId: this.containerId, agentCount });
+  }
+  // ==================== Private Helpers ====================
+  generateAgentId() {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).substring(2, 8);
+    return `agent_${timestamp}_${random}`;
+  }
+};
+
+// src/internal/BaseEventHandler.ts
+var import_common9 = require("@agentxjs/common");
+var logger9 = (0, import_common9.createLogger)("runtime/BaseEventHandler");
+var BaseEventHandler = class {
+  bus;
+  unsubscribes = [];
+  constructor(bus) {
+    this.bus = bus;
+  }
+  /**
+   * Safe execution wrapper for synchronous handlers
+   *
+   * Automatically catches errors and emits ErrorEvent.
+   */
+  safeHandle(handler, context) {
+    try {
+      return handler();
+    } catch (err) {
+      this.handleError(err, context);
+      return void 0;
+    }
+  }
+  /**
+   * Safe execution wrapper for asynchronous handlers
+   *
+   * Automatically catches errors and emits ErrorEvent.
+   */
+  async safeHandleAsync(handler, context) {
+    try {
+      return await handler();
+    } catch (err) {
+      this.handleError(err, context);
+      return void 0;
+    }
+  }
+  /**
+   * Handle error: log + emit ErrorEvent + optional callback
+   */
+  handleError(err, context) {
+    const message = err instanceof Error ? err.message : String(err);
+    const stack = err instanceof Error ? err.stack : void 0;
+    logger9.error(`Error in ${context.operation || "handler"}`, {
+      message,
+      requestId: context.requestId,
+      details: context.details
+    });
+    const errorEvent = {
+      type: "system_error",
+      timestamp: Date.now(),
+      source: context.source || "command",
+      category: "error",
+      intent: "notification",
+      data: {
+        message,
+        requestId: context.requestId,
+        severity: context.severity || "error",
+        details: {
+          operation: context.operation,
+          stack,
+          ...context.details
+        }
+      }
+    };
+    this.bus.emit(errorEvent);
+    if (context.onError) {
+      try {
+        context.onError(err);
+      } catch (callbackErr) {
+        logger9.error("Error in onError callback", { error: callbackErr });
+      }
+    }
+  }
+  /**
+   * Register subscription and track for cleanup
+   */
+  subscribe(unsubscribe) {
+    this.unsubscribes.push(unsubscribe);
+  }
+  /**
+   * Dispose handler and cleanup all subscriptions
+   */
+  dispose() {
+    for (const unsubscribe of this.unsubscribes) {
+      unsubscribe();
+    }
+    this.unsubscribes = [];
+    logger9.debug(`${this.constructor.name} disposed`);
+  }
+};
+
+// src/internal/CommandHandler.ts
+var import_common10 = require("@agentxjs/common");
+var logger10 = (0, import_common10.createLogger)("runtime/CommandHandler");
+function createResponse(type, data) {
+  return {
+    type,
+    timestamp: Date.now(),
+    data,
+    source: "command",
+    category: "response",
+    intent: "result"
+  };
+}
+function createSystemError(message, requestId, context, stack) {
+  return {
+    type: "system_error",
+    timestamp: Date.now(),
+    source: "command",
+    category: "error",
+    intent: "notification",
+    data: {
+      message,
+      requestId,
+      severity: "error",
+      details: stack
+    },
+    context
+  };
+}
+var CommandHandler = class extends BaseEventHandler {
+  ops;
+  constructor(bus, operations) {
+    super(bus);
+    this.ops = operations;
+    this.bindHandlers();
+    logger10.debug("CommandHandler created");
+  }
+  /**
+   * Log error and emit system_error event
+   */
+  emitError(operation, err, requestId, context) {
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    const stack = err instanceof Error ? err.stack : void 0;
+    logger10.error(operation, {
+      requestId,
+      ...context,
+      error: errorMessage,
+      stack
+    });
+    this.bus.emit(createSystemError(errorMessage, requestId, context, stack));
+  }
+  /**
+   * Bind all command handlers to the bus
+   */
+  bindHandlers() {
+    this.subscribe(
+      this.bus.onCommand("container_create_request", (event) => this.handleContainerCreate(event))
+    );
+    this.subscribe(
+      this.bus.onCommand("container_get_request", (event) => this.handleContainerGet(event))
+    );
+    this.subscribe(
+      this.bus.onCommand("container_list_request", (event) => this.handleContainerList(event))
+    );
+    this.subscribe(this.bus.onCommand("agent_get_request", (event) => this.handleAgentGet(event)));
+    this.subscribe(
+      this.bus.onCommand("agent_list_request", (event) => this.handleAgentList(event))
+    );
+    this.subscribe(
+      this.bus.onCommand("agent_destroy_request", (event) => this.handleAgentDestroy(event))
+    );
+    this.subscribe(
+      this.bus.onCommand("agent_destroy_all_request", (event) => this.handleAgentDestroyAll(event))
+    );
+    this.subscribe(
+      this.bus.onCommand("message_send_request", (event) => this.handleMessageSend(event))
+    );
+    this.subscribe(
+      this.bus.onCommand("agent_interrupt_request", (event) => this.handleAgentInterrupt(event))
+    );
+    this.subscribe(
+      this.bus.onCommand("image_create_request", (event) => this.handleImageCreate(event))
+    );
+    this.subscribe(this.bus.onCommand("image_run_request", (event) => this.handleImageRun(event)));
+    this.subscribe(
+      this.bus.onCommand("image_stop_request", (event) => this.handleImageStop(event))
+    );
+    this.subscribe(
+      this.bus.onCommand("image_update_request", (event) => this.handleImageUpdate(event))
+    );
+    this.subscribe(
+      this.bus.onCommand("image_list_request", (event) => this.handleImageList(event))
+    );
+    this.subscribe(this.bus.onCommand("image_get_request", (event) => this.handleImageGet(event)));
+    this.subscribe(
+      this.bus.onCommand("image_delete_request", (event) => this.handleImageDelete(event))
+    );
+    this.subscribe(
+      this.bus.onCommand("image_messages_request", (event) => this.handleImageMessages(event))
+    );
+    logger10.debug("Command handlers bound");
+  }
+  // ==================== Container Handlers ====================
+  async handleContainerCreate(event) {
+    const { requestId, containerId } = event.data;
+    logger10.debug("Handling container_create_request", { requestId, containerId });
+    try {
+      await this.ops.createContainer(containerId);
+      this.bus.emit(
+        createResponse("container_create_response", {
+          requestId,
+          containerId
+        })
+      );
+    } catch (err) {
+      this.emitError("Failed to create container", err, requestId, { containerId });
+      this.bus.emit(
+        createResponse("container_create_response", {
+          requestId,
+          containerId,
+          error: err instanceof Error ? err.message : String(err)
+        })
+      );
+    }
+  }
+  handleContainerGet(event) {
+    const { requestId, containerId } = event.data;
+    logger10.debug("Handling container_get_request", { requestId, containerId });
+    const container = this.ops.getContainer(containerId);
+    this.bus.emit(
+      createResponse("container_get_response", {
+        requestId,
+        containerId: container?.containerId,
+        exists: !!container
+      })
+    );
+  }
+  handleContainerList(event) {
+    const { requestId } = event.data;
+    logger10.debug("Handling container_list_request", { requestId });
+    const containers = this.ops.listContainers();
+    this.bus.emit(
+      createResponse("container_list_response", {
+        requestId,
+        containerIds: containers.map((c) => c.containerId)
+      })
+    );
+  }
+  // ==================== Agent Handlers ====================
+  handleAgentGet(event) {
+    const { requestId, agentId } = event.data;
+    logger10.debug("Handling agent_get_request", { requestId, agentId });
+    const agent = this.ops.getAgent(agentId);
+    this.bus.emit(
+      createResponse("agent_get_response", {
+        requestId,
+        agentId: agent?.agentId,
+        containerId: agent?.containerId,
+        exists: !!agent
+      })
+    );
+  }
+  handleAgentList(event) {
+    const { requestId, containerId } = event.data;
+    logger10.debug("Handling agent_list_request", { requestId, containerId });
+    const agents = this.ops.listAgents(containerId);
+    this.bus.emit(
+      createResponse("agent_list_response", {
+        requestId,
+        agents: agents.map((a) => ({
+          agentId: a.agentId,
+          containerId: a.containerId,
+          imageId: a.imageId
+        }))
+      })
+    );
+  }
+  async handleAgentDestroy(event) {
+    const { requestId, agentId } = event.data;
+    logger10.debug("Handling agent_destroy_request", { requestId, agentId });
+    try {
+      const success = await this.ops.destroyAgent(agentId);
+      this.bus.emit(
+        createResponse("agent_destroy_response", {
+          requestId,
+          agentId,
+          success
+        })
+      );
+    } catch (err) {
+      this.emitError("Failed to destroy agent", err, requestId, { agentId });
+      this.bus.emit(
+        createResponse("agent_destroy_response", {
+          requestId,
+          agentId,
+          success: false,
+          error: err instanceof Error ? err.message : String(err)
+        })
+      );
+    }
+  }
+  async handleAgentDestroyAll(event) {
+    const { requestId, containerId } = event.data;
+    logger10.debug("Handling agent_destroy_all_request", { requestId, containerId });
+    try {
+      await this.ops.destroyAllAgents(containerId);
+      this.bus.emit(
+        createResponse("agent_destroy_all_response", {
+          requestId,
+          containerId
+        })
+      );
+    } catch (err) {
+      this.emitError("Failed to destroy all agents", err, requestId, { containerId });
+      this.bus.emit(
+        createResponse("agent_destroy_all_response", {
+          requestId,
+          containerId,
+          error: err instanceof Error ? err.message : String(err)
+        })
+      );
+    }
+  }
+  async handleMessageSend(event) {
+    const { requestId, imageId, agentId, content } = event.data;
+    logger10.debug("Handling message_send_request", { requestId, imageId, agentId });
+    try {
+      const result = await this.ops.receiveMessage(imageId, agentId, content, requestId);
+      this.bus.emit(
+        createResponse("message_send_response", {
+          requestId,
+          imageId: result.imageId,
+          agentId: result.agentId
+        })
+      );
+    } catch (err) {
+      this.emitError("Failed to send message", err, requestId, { imageId, agentId });
+      this.bus.emit(
+        createResponse("message_send_response", {
+          requestId,
+          imageId,
+          agentId: agentId ?? "",
+          error: err instanceof Error ? err.message : String(err)
+        })
+      );
+    }
+  }
+  handleAgentInterrupt(event) {
+    const { requestId, imageId, agentId } = event.data;
+    logger10.debug("Handling agent_interrupt_request", { requestId, imageId, agentId });
+    try {
+      const result = this.ops.interruptAgent(imageId, agentId, requestId);
+      this.bus.emit(
+        createResponse("agent_interrupt_response", {
+          requestId,
+          imageId: result.imageId,
+          agentId: result.agentId
+        })
+      );
+    } catch (err) {
+      this.emitError("Failed to interrupt agent", err, requestId, { imageId, agentId });
+      this.bus.emit(
+        createResponse("agent_interrupt_response", {
+          requestId,
+          imageId,
+          agentId,
+          error: err instanceof Error ? err.message : String(err)
+        })
+      );
+    }
+  }
+  // ==================== Image Handlers ====================
+  async handleImageCreate(event) {
+    const { requestId, containerId, config } = event.data;
+    logger10.debug("Handling image_create_request", { requestId, containerId });
+    try {
+      const record = await this.ops.createImage(containerId, config);
+      this.bus.emit(
+        createResponse("image_create_response", {
+          requestId,
+          record
+        })
+      );
+    } catch (err) {
+      this.emitError("Failed to create image", err, requestId, { containerId });
+      this.bus.emit(
+        createResponse("image_create_response", {
+          requestId,
+          record: null,
+          error: err instanceof Error ? err.message : String(err)
+        })
+      );
+    }
+  }
+  async handleImageRun(event) {
+    const { requestId, imageId } = event.data;
+    logger10.debug("Handling image_run_request", { requestId, imageId });
+    try {
+      const result = await this.ops.runImage(imageId);
+      this.bus.emit(
+        createResponse("image_run_response", {
+          requestId,
+          imageId: result.imageId,
+          agentId: result.agentId,
+          reused: result.reused
+        })
+      );
+    } catch (err) {
+      this.emitError("Failed to run image", err, requestId, { imageId });
+      this.bus.emit(
+        createResponse("image_run_response", {
+          requestId,
+          imageId,
+          agentId: "",
+          reused: false,
+          error: err instanceof Error ? err.message : String(err)
+        })
+      );
+    }
+  }
+  async handleImageStop(event) {
+    const { requestId, imageId } = event.data;
+    logger10.debug("Handling image_stop_request", { requestId, imageId });
+    try {
+      await this.ops.stopImage(imageId);
+      this.bus.emit(
+        createResponse("image_stop_response", {
+          requestId,
+          imageId
+        })
+      );
+    } catch (err) {
+      this.emitError("Failed to stop image", err, requestId, { imageId });
+      this.bus.emit(
+        createResponse("image_stop_response", {
+          requestId,
+          imageId,
+          error: err instanceof Error ? err.message : String(err)
+        })
+      );
+    }
+  }
+  async handleImageUpdate(event) {
+    const { requestId, imageId, updates } = event.data;
+    logger10.debug("Handling image_update_request", { requestId, imageId });
+    try {
+      const record = await this.ops.updateImage(imageId, updates);
+      this.bus.emit(
+        createResponse("image_update_response", {
+          requestId,
+          record
+        })
+      );
+    } catch (err) {
+      this.emitError("Failed to update image", err, requestId, { imageId });
+      this.bus.emit(
+        createResponse("image_update_response", {
+          requestId,
+          record: null,
+          error: err instanceof Error ? err.message : String(err)
+        })
+      );
+    }
+  }
+  async handleImageList(event) {
+    const { requestId, containerId } = event.data;
+    logger10.debug("Handling image_list_request", { requestId, containerId });
+    try {
+      const images = await this.ops.listImages(containerId);
+      this.bus.emit(
+        createResponse("image_list_response", {
+          requestId,
+          records: images
+        })
+      );
+    } catch (err) {
+      this.emitError("Failed to list images", err, requestId, { containerId });
+      this.bus.emit(
+        createResponse("image_list_response", {
+          requestId,
+          records: [],
+          error: err instanceof Error ? err.message : String(err)
+        })
+      );
+    }
+  }
+  async handleImageGet(event) {
+    const { requestId, imageId } = event.data;
+    logger10.debug("Handling image_get_request", { requestId, imageId });
+    try {
+      const image = await this.ops.getImage(imageId);
+      this.bus.emit(
+        createResponse("image_get_response", {
+          requestId,
+          record: image
+        })
+      );
+    } catch (err) {
+      this.emitError("Failed to get image", err, requestId, { imageId });
+      this.bus.emit(
+        createResponse("image_get_response", {
+          requestId,
+          error: err instanceof Error ? err.message : String(err)
+        })
+      );
+    }
+  }
+  async handleImageDelete(event) {
+    const { requestId, imageId } = event.data;
+    logger10.debug("Handling image_delete_request", { requestId, imageId });
+    try {
+      await this.ops.deleteImage(imageId);
+      this.bus.emit(
+        createResponse("image_delete_response", {
+          requestId,
+          imageId
+        })
+      );
+    } catch (err) {
+      this.emitError("Failed to delete image", err, requestId, { imageId });
+      this.bus.emit(
+        createResponse("image_delete_response", {
+          requestId,
+          imageId,
+          error: err instanceof Error ? err.message : String(err)
+        })
+      );
+    }
+  }
+  async handleImageMessages(event) {
+    const { requestId, imageId } = event.data;
+    logger10.info("Handling image_messages_request", { requestId, imageId });
+    try {
+      const messages = await this.ops.getImageMessages(imageId);
+      logger10.info("Got messages for image", { imageId, count: messages.length });
+      this.bus.emit(
+        createResponse("image_messages_response", {
+          requestId,
+          imageId,
+          messages
+        })
+      );
+      logger10.info("Emitted image_messages_response", { requestId, imageId });
+    } catch (err) {
+      this.emitError("Failed to get image messages", err, requestId, { imageId });
+      this.bus.emit(
+        createResponse("image_messages_response", {
+          requestId,
+          imageId,
+          messages: [],
+          error: err instanceof Error ? err.message : String(err)
+        })
+      );
+    }
+  }
+  // Lifecycle is handled by BaseEventHandler.dispose()
+};
+
+// src/RuntimeImpl.ts
+var import_common11 = require("@agentxjs/common");
+var import_node_os = require("os");
+var import_node_path2 = require("path");
+var logger11 = (0, import_common11.createLogger)("runtime/RuntimeImpl");
+var RuntimeImpl = class {
+  persistence;
+  llmProvider;
+  bus;
+  llmConfig;
+  basePath;
+  commandHandler;
+  /** Container registry: containerId -> RuntimeContainer */
+  containerRegistry = /* @__PURE__ */ new Map();
+  constructor(config) {
+    logger11.info("RuntimeImpl constructor start");
+    this.persistence = config.persistence;
+    this.llmProvider = config.llmProvider;
+    this.basePath = (0, import_node_path2.join)((0, import_node_os.homedir)(), ".agentx");
+    logger11.info("Creating SystemBus");
+    this.bus = new SystemBusImpl();
+    this.llmConfig = this.llmProvider.provide();
+    logger11.info("LLM config loaded", {
+      hasApiKey: !!this.llmConfig.apiKey,
+      model: this.llmConfig.model
+    });
+    logger11.info("Creating CommandHandler");
+    this.commandHandler = new CommandHandler(this.bus, this.createRuntimeOperations());
+    logger11.info("RuntimeImpl constructor done");
+  }
+  // ==================== SystemBus delegation ====================
+  emit(event) {
+    this.bus.emit(event);
+  }
+  emitBatch(events) {
+    this.bus.emitBatch(events);
+  }
+  on(typeOrTypes, handler, options) {
+    return this.bus.on(typeOrTypes, handler, options);
+  }
+  onAny(handler, options) {
+    return this.bus.onAny(handler, options);
+  }
+  once(type, handler) {
+    return this.bus.once(type, handler);
+  }
+  onCommand(type, handler) {
+    return this.bus.onCommand(type, handler);
+  }
+  emitCommand(type, data) {
+    this.bus.emitCommand(type, data);
+  }
+  request(type, data, timeout) {
+    return this.bus.request(type, data, timeout);
+  }
+  asConsumer() {
+    return this.bus.asConsumer();
+  }
+  asProducer() {
+    return this.bus.asProducer();
+  }
+  destroy() {
+    this.bus.destroy();
+  }
+  // ==================== Runtime Operations (for CommandHandler) ====================
+  createRuntimeOperations() {
+    return {
+      // Container operations
+      createContainer: async (containerId) => {
+        const container = await this.getOrCreateContainer(containerId);
+        return { containerId: container.containerId };
+      },
+      getContainer: (containerId) => {
+        const container = this.containerRegistry.get(containerId);
+        return container ? { containerId: container.containerId } : void 0;
+      },
+      listContainers: () => {
+        return Array.from(this.containerRegistry.values()).map((c) => ({
+          containerId: c.containerId
+        }));
+      },
+      // Agent operations (by agentId)
+      getAgent: (agentId) => {
+        const agent = this.findAgent(agentId);
+        if (!agent) return void 0;
+        const imageId = this.findImageIdForAgent(agentId);
+        return { agentId: agent.agentId, containerId: agent.containerId, imageId: imageId ?? "" };
+      },
+      listAgents: (containerId) => {
+        const container = this.containerRegistry.get(containerId);
+        if (!container) return [];
+        return container.listAgents().map((a) => {
+          const imageId = this.findImageIdForAgent(a.agentId);
+          return { agentId: a.agentId, containerId: a.containerId, imageId: imageId ?? "" };
+        });
+      },
+      destroyAgent: async (agentId) => {
+        for (const container of this.containerRegistry.values()) {
+          if (container.getAgent(agentId)) {
+            return container.destroyAgent(agentId);
+          }
+        }
+        return false;
+      },
+      destroyAllAgents: async (containerId) => {
+        const container = this.containerRegistry.get(containerId);
+        await container?.destroyAllAgents();
+      },
+      // Agent operations (by imageId - with auto-activation)
+      receiveMessage: async (imageId, agentId, content, requestId) => {
+        if (imageId) {
+          logger11.debug("Receiving message by imageId", {
+            imageId,
+            contentLength: content.length,
+            requestId
+          });
+          const record = await this.persistence.images.findImageById(imageId);
+          if (!record) throw new Error(`Image not found: ${imageId}`);
+          const container = await this.getOrCreateContainer(record.containerId);
+          const { agent, reused } = await container.runImage(record);
+          logger11.info("Message routed to agent", {
+            imageId,
+            agentId: agent.agentId,
+            reused,
+            requestId
+          });
+          await agent.receive(content, requestId);
+          return { agentId: agent.agentId, imageId };
+        }
+        if (agentId) {
+          logger11.debug("Receiving message by agentId (legacy)", {
+            agentId,
+            contentLength: content.length,
+            requestId
+          });
+          const agent = this.findAgent(agentId);
+          if (!agent) throw new Error(`Agent not found: ${agentId}`);
+          await agent.receive(content, requestId);
+          const foundImageId = this.findImageIdForAgent(agentId);
+          return { agentId, imageId: foundImageId };
+        }
+        throw new Error("Either imageId or agentId must be provided");
+      },
+      interruptAgent: (imageId, agentId, requestId) => {
+        if (imageId) {
+          const foundAgentId = this.findAgentIdForImage(imageId);
+          if (!foundAgentId) {
+            logger11.debug("Image is offline, nothing to interrupt", { imageId });
+            return { imageId, agentId: void 0 };
+          }
+          const agent = this.findAgent(foundAgentId);
+          if (agent) {
+            logger11.info("Interrupting agent by imageId", {
+              imageId,
+              agentId: foundAgentId,
+              requestId
+            });
+            agent.interrupt(requestId);
+          }
+          return { imageId, agentId: foundAgentId };
+        }
+        if (agentId) {
+          const agent = this.findAgent(agentId);
+          if (!agent) throw new Error(`Agent not found: ${agentId}`);
+          logger11.info("Interrupting agent by agentId (legacy)", { agentId, requestId });
+          agent.interrupt(requestId);
+          const foundImageId = this.findImageIdForAgent(agentId);
+          return { agentId, imageId: foundImageId };
+        }
+        throw new Error("Either imageId or agentId must be provided");
+      },
+      // Image operations (new model)
+      createImage: async (containerId, config) => {
+        logger11.debug("Creating image", { containerId, name: config.name });
+        await this.getOrCreateContainer(containerId);
+        const image = await RuntimeImage.create(
+          { containerId, ...config },
+          this.createImageContext()
+        );
+        logger11.info("Image created via RuntimeOps", { imageId: image.imageId, containerId });
+        return this.toImageListItemResult(image.toRecord(), false);
+      },
+      runImage: async (imageId) => {
+        logger11.debug("Running image", { imageId });
+        const record = await this.persistence.images.findImageById(imageId);
+        if (!record) throw new Error(`Image not found: ${imageId}`);
+        const container = await this.getOrCreateContainer(record.containerId);
+        const { agent, reused } = await container.runImage(record);
+        logger11.info("Image running", { imageId, agentId: agent.agentId, reused });
+        return { imageId, agentId: agent.agentId, reused };
+      },
+      stopImage: async (imageId) => {
+        logger11.debug("Stopping image", { imageId });
+        const record = await this.persistence.images.findImageById(imageId);
+        if (!record) throw new Error(`Image not found: ${imageId}`);
+        const container = this.containerRegistry.get(record.containerId);
+        if (container) {
+          await container.stopImage(imageId);
+          logger11.info("Image stopped via RuntimeOps", { imageId });
+        }
+      },
+      updateImage: async (imageId, updates) => {
+        const image = await RuntimeImage.load(imageId, this.createImageContext());
+        if (!image) throw new Error(`Image not found: ${imageId}`);
+        const updatedImage = await image.update(updates);
+        const online = this.isImageOnline(imageId);
+        return this.toImageListItemResult(updatedImage.toRecord(), online);
+      },
+      listImages: async (containerId) => {
+        const records = containerId ? await RuntimeImage.listByContainer(containerId, this.createImageContext()) : await RuntimeImage.listAll(this.createImageContext());
+        return records.map((r) => {
+          const online = this.isImageOnline(r.imageId);
+          return this.toImageListItemResult(r, online);
+        });
+      },
+      getImage: async (imageId) => {
+        const record = await this.persistence.images.findImageById(imageId);
+        if (!record) return null;
+        const online = this.isImageOnline(imageId);
+        return this.toImageListItemResult(record, online);
+      },
+      deleteImage: async (imageId) => {
+        logger11.debug("Deleting image", { imageId });
+        const agentId = this.findAgentIdForImage(imageId);
+        if (agentId) {
+          logger11.debug("Stopping running agent before delete", { imageId, agentId });
+          for (const container of this.containerRegistry.values()) {
+            if (container.getAgent(agentId)) {
+              await container.destroyAgent(agentId);
+              break;
+            }
+          }
+        }
+        const image = await RuntimeImage.load(imageId, this.createImageContext());
+        if (image) {
+          await image.delete();
+          logger11.info("Image deleted via RuntimeOps", { imageId });
+        }
+      },
+      getImageMessages: async (imageId) => {
+        logger11.debug("Getting messages for image", { imageId });
+        const image = await RuntimeImage.load(imageId, this.createImageContext());
+        if (!image) {
+          throw new Error(`Image not found: ${imageId}`);
+        }
+        const messages = await image.getMessages();
+        logger11.debug("Got messages from storage", { imageId, count: messages.length });
+        return messages.map((m) => {
+          let content;
+          let role = m.role;
+          let errorCode;
+          if (m.subtype === "user" || m.subtype === "assistant") {
+            content = m.content;
+          } else if (m.subtype === "tool-call") {
+            content = m.toolCall;
+            role = "tool_call";
+          } else if (m.subtype === "tool-result") {
+            content = m.toolResult;
+            role = "tool_result";
+          } else if (m.subtype === "error") {
+            content = m.content;
+            role = "error";
+            errorCode = m.errorCode;
+          }
+          return {
+            id: m.id,
+            role,
+            content,
+            timestamp: m.timestamp,
+            errorCode
+          };
+        });
+      }
+    };
+  }
+  // ==================== Internal Helpers ====================
+  async getOrCreateContainer(containerId) {
+    const existing = this.containerRegistry.get(containerId);
+    if (existing) return existing;
+    const loaded = await RuntimeContainer.load(containerId, this.createContainerContext());
+    if (loaded) {
+      this.containerRegistry.set(containerId, loaded);
+      return loaded;
+    }
+    const container = await RuntimeContainer.create(containerId, this.createContainerContext());
+    this.containerRegistry.set(containerId, container);
+    return container;
+  }
+  findAgent(agentId) {
+    for (const container of this.containerRegistry.values()) {
+      const agent = container.getAgent(agentId);
+      if (agent) return agent;
+    }
+    return void 0;
+  }
+  /**
+   * Find imageId for a given agentId (reverse lookup)
+   */
+  findImageIdForAgent(agentId) {
+    for (const container of this.containerRegistry.values()) {
+      const imageId = container.getImageIdForAgent(agentId);
+      if (imageId) return imageId;
+    }
+    return void 0;
+  }
+  /**
+   * Find agentId for a given imageId
+   */
+  findAgentIdForImage(imageId) {
+    for (const container of this.containerRegistry.values()) {
+      const agentId = container.getAgentIdForImage(imageId);
+      if (agentId) return agentId;
+    }
+    return void 0;
+  }
+  /**
+   * Check if an image has a running agent
+   */
+  isImageOnline(imageId) {
+    for (const container of this.containerRegistry.values()) {
+      if (container.isImageOnline(imageId)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Convert ImageRecord to ImageListItemResult
+   */
+  toImageListItemResult(record, online) {
+    const agentId = online ? this.findAgentIdForImage(record.imageId) : void 0;
+    return {
+      imageId: record.imageId,
+      containerId: record.containerId,
+      sessionId: record.sessionId,
+      name: record.name,
+      description: record.description,
+      systemPrompt: record.systemPrompt,
+      createdAt: record.createdAt,
+      updatedAt: record.updatedAt,
+      online,
+      agentId
+    };
+  }
+  createContainerContext() {
+    return {
+      persistence: this.persistence,
+      bus: this.bus,
+      llmConfig: this.llmConfig,
+      basePath: this.basePath,
+      onDisposed: (containerId) => {
+        this.containerRegistry.delete(containerId);
+      }
+    };
+  }
+  createImageContext() {
+    return {
+      imageRepository: this.persistence.images,
+      sessionRepository: this.persistence.sessions
+    };
+  }
+  // ==================== Lifecycle ====================
+  async dispose() {
+    logger11.info("Disposing RuntimeImpl");
+    this.commandHandler.dispose();
+    for (const container of this.containerRegistry.values()) {
+      await container.dispose();
+    }
+    this.bus.destroy();
+    this.containerRegistry.clear();
+    logger11.info("RuntimeImpl disposed");
+  }
+};
+
+// src/createRuntime.ts
+function createRuntime(config) {
+  return new RuntimeImpl(config);
+}
+
+// src/internal/persistence/PersistenceImpl.ts
+var import_unstorage = require("unstorage");
+var import_common15 = require("@agentxjs/common");
+
+// src/internal/persistence/repository/StorageImageRepository.ts
+var import_common12 = require("@agentxjs/common");
+var logger12 = (0, import_common12.createLogger)("persistence/ImageRepository");
+var PREFIX = "images";
+var INDEX_BY_NAME = "idx:images:name";
+var INDEX_BY_CONTAINER = "idx:images:container";
+var StorageImageRepository = class {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  key(imageId) {
+    return `${PREFIX}:${imageId}`;
+  }
+  nameIndexKey(name, imageId) {
+    return `${INDEX_BY_NAME}:${name}:${imageId}`;
+  }
+  containerIndexKey(containerId, imageId) {
+    return `${INDEX_BY_CONTAINER}:${containerId}:${imageId}`;
+  }
+  async saveImage(record) {
+    await this.storage.setItem(this.key(record.imageId), record);
+    await this.storage.setItem(this.nameIndexKey(record.name, record.imageId), record.imageId);
+    await this.storage.setItem(
+      this.containerIndexKey(record.containerId, record.imageId),
+      record.imageId
+    );
+    logger12.debug("Image saved", { imageId: record.imageId });
+  }
+  async findImageById(imageId) {
+    const record = await this.storage.getItem(this.key(imageId));
+    return record ?? null;
+  }
+  async findAllImages() {
+    const keys = await this.storage.getKeys(PREFIX);
+    const records = [];
+    for (const key of keys) {
+      if (key.startsWith("idx:")) continue;
+      const record = await this.storage.getItem(key);
+      if (record) {
+        records.push(record);
+      }
+    }
+    return records.sort((a, b) => b.createdAt - a.createdAt);
+  }
+  async findImagesByName(name) {
+    const indexPrefix = `${INDEX_BY_NAME}:${name}`;
+    const keys = await this.storage.getKeys(indexPrefix);
+    const records = [];
+    for (const key of keys) {
+      const imageId = await this.storage.getItem(key);
+      if (imageId) {
+        const record = await this.findImageById(imageId);
+        if (record) {
+          records.push(record);
+        }
+      }
+    }
+    return records.sort((a, b) => b.createdAt - a.createdAt);
+  }
+  async findImagesByContainerId(containerId) {
+    const indexPrefix = `${INDEX_BY_CONTAINER}:${containerId}`;
+    const keys = await this.storage.getKeys(indexPrefix);
+    const records = [];
+    for (const key of keys) {
+      const imageId = await this.storage.getItem(key);
+      if (imageId) {
+        const record = await this.findImageById(imageId);
+        if (record) {
+          records.push(record);
+        }
+      }
+    }
+    return records.sort((a, b) => b.createdAt - a.createdAt);
+  }
+  async deleteImage(imageId) {
+    const record = await this.findImageById(imageId);
+    await this.storage.removeItem(this.key(imageId));
+    if (record) {
+      await this.storage.removeItem(this.nameIndexKey(record.name, imageId));
+      await this.storage.removeItem(this.containerIndexKey(record.containerId, imageId));
+    }
+    logger12.debug("Image deleted", { imageId });
+  }
+  async imageExists(imageId) {
+    return await this.storage.hasItem(this.key(imageId));
+  }
+  async updateMetadata(imageId, metadata) {
+    const record = await this.findImageById(imageId);
+    if (!record) {
+      throw new Error(`Image not found: ${imageId}`);
+    }
+    const updatedRecord = {
+      ...record,
+      metadata: {
+        ...record.metadata,
+        ...metadata
+      },
+      updatedAt: Date.now()
+    };
+    await this.storage.setItem(this.key(imageId), updatedRecord);
+    logger12.debug("Image metadata updated", { imageId, metadata });
+  }
+};
+
+// src/internal/persistence/repository/StorageContainerRepository.ts
+var import_common13 = require("@agentxjs/common");
+var logger13 = (0, import_common13.createLogger)("persistence/ContainerRepository");
+var PREFIX2 = "containers";
+var StorageContainerRepository = class {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  key(containerId) {
+    return `${PREFIX2}:${containerId}`;
+  }
+  async saveContainer(record) {
+    await this.storage.setItem(this.key(record.containerId), record);
+    logger13.debug("Container saved", { containerId: record.containerId });
+  }
+  async findContainerById(containerId) {
+    const record = await this.storage.getItem(this.key(containerId));
+    return record ?? null;
+  }
+  async findAllContainers() {
+    const keys = await this.storage.getKeys(PREFIX2);
+    const records = [];
+    for (const key of keys) {
+      const record = await this.storage.getItem(key);
+      if (record) {
+        records.push(record);
+      }
+    }
+    return records.sort((a, b) => b.createdAt - a.createdAt);
+  }
+  async deleteContainer(containerId) {
+    await this.storage.removeItem(this.key(containerId));
+    logger13.debug("Container deleted", { containerId });
+  }
+  async containerExists(containerId) {
+    return await this.storage.hasItem(this.key(containerId));
+  }
+};
+
+// src/internal/persistence/repository/StorageSessionRepository.ts
+var import_common14 = require("@agentxjs/common");
+var logger14 = (0, import_common14.createLogger)("persistence/SessionRepository");
+var PREFIX3 = "sessions";
+var MESSAGES_PREFIX = "messages";
+var INDEX_BY_IMAGE = "idx:sessions:image";
+var INDEX_BY_CONTAINER2 = "idx:sessions:container";
+var StorageSessionRepository = class {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  key(sessionId) {
+    return `${PREFIX3}:${sessionId}`;
+  }
+  messagesKey(sessionId) {
+    return `${MESSAGES_PREFIX}:${sessionId}`;
+  }
+  imageIndexKey(imageId, sessionId) {
+    return `${INDEX_BY_IMAGE}:${imageId}:${sessionId}`;
+  }
+  containerIndexKey(containerId, sessionId) {
+    return `${INDEX_BY_CONTAINER2}:${containerId}:${sessionId}`;
+  }
+  async saveSession(record) {
+    await this.storage.setItem(this.key(record.sessionId), record);
+    await this.storage.setItem(
+      this.imageIndexKey(record.imageId, record.sessionId),
+      record.sessionId
+    );
+    await this.storage.setItem(
+      this.containerIndexKey(record.containerId, record.sessionId),
+      record.sessionId
+    );
+    logger14.debug("Session saved", { sessionId: record.sessionId });
+  }
+  async findSessionById(sessionId) {
+    const record = await this.storage.getItem(this.key(sessionId));
+    return record ?? null;
+  }
+  async findSessionByImageId(imageId) {
+    const indexPrefix = `${INDEX_BY_IMAGE}:${imageId}`;
+    const keys = await this.storage.getKeys(indexPrefix);
+    if (keys.length === 0) return null;
+    const sessionId = await this.storage.getItem(keys[0]);
+    if (!sessionId) return null;
+    return this.findSessionById(sessionId);
+  }
+  async findSessionsByContainerId(containerId) {
+    const indexPrefix = `${INDEX_BY_CONTAINER2}:${containerId}`;
+    const keys = await this.storage.getKeys(indexPrefix);
+    const records = [];
+    for (const key of keys) {
+      const sessionId = await this.storage.getItem(key);
+      if (sessionId) {
+        const record = await this.findSessionById(sessionId);
+        if (record) {
+          records.push(record);
+        }
+      }
+    }
+    return records.sort((a, b) => b.createdAt - a.createdAt);
+  }
+  async findAllSessions() {
+    const keys = await this.storage.getKeys(PREFIX3);
+    const records = [];
+    for (const key of keys) {
+      if (key.startsWith("idx:")) continue;
+      const record = await this.storage.getItem(key);
+      if (record) {
+        records.push(record);
+      }
+    }
+    return records.sort((a, b) => b.createdAt - a.createdAt);
+  }
+  async deleteSession(sessionId) {
+    const record = await this.findSessionById(sessionId);
+    await this.storage.removeItem(this.key(sessionId));
+    await this.storage.removeItem(this.messagesKey(sessionId));
+    if (record) {
+      await this.storage.removeItem(this.imageIndexKey(record.imageId, sessionId));
+      await this.storage.removeItem(this.containerIndexKey(record.containerId, sessionId));
+    }
+    logger14.debug("Session deleted", { sessionId });
+  }
+  async sessionExists(sessionId) {
+    return await this.storage.hasItem(this.key(sessionId));
+  }
+  // ==================== Message Operations ====================
+  async addMessage(sessionId, message) {
+    const messages = await this.getMessages(sessionId);
+    messages.push(message);
+    await this.storage.setItem(this.messagesKey(sessionId), messages);
+    logger14.debug("Message added to session", { sessionId, subtype: message.subtype });
+  }
+  async getMessages(sessionId) {
+    const messages = await this.storage.getItem(this.messagesKey(sessionId));
+    if (!messages || !Array.isArray(messages)) {
+      if (messages) {
+        logger14.warn("Messages data is not an array, resetting", {
+          sessionId,
+          type: typeof messages
+        });
+      }
+      return [];
+    }
+    return messages;
+  }
+  async clearMessages(sessionId) {
+    await this.storage.removeItem(this.messagesKey(sessionId));
+    logger14.debug("Messages cleared for session", { sessionId });
+  }
+};
+
+// src/internal/persistence/PersistenceImpl.ts
+var logger15 = (0, import_common15.createLogger)("persistence/Persistence");
+var PersistenceImpl = class _PersistenceImpl {
+  images;
+  containers;
+  sessions;
+  storage;
+  /**
+   * Private constructor - use createPersistence() factory function
+   */
+  constructor(storage, driverName) {
+    this.storage = storage;
+    this.images = new StorageImageRepository(this.storage);
+    this.containers = new StorageContainerRepository(this.storage);
+    this.sessions = new StorageSessionRepository(this.storage);
+    logger15.info("Persistence created", { driver: driverName });
+  }
+  /**
+   * Create a PersistenceImpl instance (async factory)
+   */
+  static async create(config = {}) {
+    const driverName = config.driver ?? "memory";
+    const storage = config.storage ?? await createStorageFromConfig(config);
+    return new _PersistenceImpl(storage, driverName);
+  }
+  /**
+   * Get the underlying storage instance
+   */
+  getStorage() {
+    return this.storage;
+  }
+  /**
+   * Dispose and cleanup resources
+   */
+  async dispose() {
+    await this.storage.dispose();
+    logger15.info("Persistence disposed");
+  }
+};
+async function createStorageFromConfig(config) {
+  const driver = config.driver ?? "memory";
+  switch (driver) {
+    case "memory":
+      return (0, import_unstorage.createStorage)();
+    case "fs": {
+      const { default: fsDriver } = await import("unstorage/drivers/fs");
+      return (0, import_unstorage.createStorage)({
+        driver: fsDriver({ base: config.path ?? "./data" })
+      });
+    }
+    case "redis": {
+      const { default: redisDriver } = await import("unstorage/drivers/redis");
+      return (0, import_unstorage.createStorage)({
+        driver: redisDriver({ url: config.url ?? "redis://localhost:6379" })
+      });
+    }
+    case "mongodb": {
+      const { default: mongoDriver } = await import("unstorage/drivers/mongodb");
+      return (0, import_unstorage.createStorage)({
+        driver: mongoDriver({
+          connectionString: config.url ?? "mongodb://localhost:27017",
+          databaseName: "agentx",
+          collectionName: "storage"
+        })
+      });
+    }
+    case "sqlite": {
+      const { default: db0Driver } = await import("unstorage/drivers/db0");
+      const { createDatabase } = await import("db0");
+      const { default: sqliteConnector } = await import("db0/connectors/better-sqlite3");
+      const database = createDatabase(sqliteConnector({ path: config.path ?? "./data.db" }));
+      return (0, import_unstorage.createStorage)({
+        driver: db0Driver({ database })
+      });
+    }
+    case "mysql": {
+      const { default: db0Driver } = await import("unstorage/drivers/db0");
+      const { createDatabase } = await import("db0");
+      const { default: mysqlConnector } = await import("db0/connectors/mysql2");
+      const database = createDatabase(
+        mysqlConnector({ uri: config.url ?? "mysql://localhost:3306/agentx" })
+      );
+      return (0, import_unstorage.createStorage)({
+        driver: db0Driver({ database })
+      });
+    }
+    case "postgresql": {
+      const { default: db0Driver } = await import("unstorage/drivers/db0");
+      const { createDatabase } = await import("db0");
+      const { default: pgConnector } = await import("db0/connectors/postgresql");
+      const database = createDatabase(
+        pgConnector({ connectionString: config.url ?? "postgres://localhost:5432/agentx" })
+      );
+      return (0, import_unstorage.createStorage)({
+        driver: db0Driver({ database })
+      });
+    }
+    default:
+      throw new Error(`Unknown storage driver: ${driver}`);
+  }
+}
+async function createPersistence(config) {
+  return PersistenceImpl.create(config);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createPersistence,
+  createRuntime
+});
+//# sourceMappingURL=index.cjs.map