@agentxjs/ui 0.0.3 → 0.0.4

package/dist/{index-CB5mSMCj.js → index-CRELszoW.js}

@@ -1,7 +1,4 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { c as createLogger, i as isStateEvent, L as LogLevel } from "./index-CyXGvO5F.js";
+import { L as LogLevel, i as isStateEvent } from "./index-O2e5VGwL.js";
 var extendStatics = function(d, b) {
   extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
     d2.__proto__ = b2;
@@ -745,2019 +742,2152 @@ function take(count) {
     }));
   });
 }
-var logger$1 = createLogger("core/AgentStateMachine");
-var AgentStateMachine = class {
-  constructor() {
-    __publicField(this, "_state", "idle");
-    __publicField(this, "handlers", /* @__PURE__ */ new Set());
-  }
-  /**
-   * Current agent state
-   */
-  get state() {
-    return this._state;
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp2 = Object.defineProperty;
+var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField2 = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
+var _ConsoleLogger = class _ConsoleLogger2 {
+  constructor(name, options = {}) {
+    __publicField2(this, "name");
+    __publicField2(this, "level");
+    __publicField2(this, "colors");
+    __publicField2(this, "timestamps");
+    this.name = name;
+    this.level = options.level ?? LogLevel.INFO;
+    this.colors = options.colors ?? this.isNodeEnvironment();
+    this.timestamps = options.timestamps ?? true;
   }
-  /**
-   * Process a StateEvent and update internal state
-   *
-   * @param event - StateEvent from Engine layer
-   */
-  process(event) {
-    const prev = this._state;
-    const next = this.mapEventToState(event);
-    if (next !== null && prev !== next) {
-      this._state = next;
-      logger$1.debug("State transition", {
-        eventType: event.type,
-        from: prev,
-        to: next
-      });
-      this.notifyHandlers({ prev, current: next });
+  debug(message, context) {
+    if (this.isDebugEnabled()) {
+      this.log("DEBUG", message, context);
     }
   }
-  /**
-   * Subscribe to state changes
-   *
-   * @param handler - Callback receiving { prev, current } state change
-   * @returns Unsubscribe function
-   */
-  onStateChange(handler) {
-    this.handlers.add(handler);
-    return () => {
-      this.handlers.delete(handler);
-    };
-  }
-  /**
-   * Reset state machine (used on destroy)
-   */
-  reset() {
-    this._state;
-    this._state = "idle";
-    this.handlers.clear();
+  info(message, context) {
+    if (this.isInfoEnabled()) {
+      this.log("INFO", message, context);
+    }
   }
-  /**
-   * Map StateEvent type to AgentState
-   *
-   * @param event - StateEvent from Engine
-   * @returns New AgentState or null if no transition needed
-   */
-  mapEventToState(event) {
-    switch (event.type) {
-      // Agent lifecycle
-      case "agent_initializing":
-        return "initializing";
-      case "agent_ready":
-        return "idle";
-      case "agent_destroyed":
-        return "idle";
-      // Conversation lifecycle
-      case "conversation_queued":
-        return "queued";
-      case "conversation_start":
-        return "conversation_active";
-      case "conversation_thinking":
-        return "thinking";
-      case "conversation_responding":
-        return "responding";
-      case "conversation_end":
-        return "idle";
-      case "conversation_interrupted":
-        return "idle";
-      // Return to idle on interrupt
-      // Tool lifecycle
-      case "tool_planned":
-        return "planning_tool";
-      case "tool_executing":
-        return "awaiting_tool_result";
-      case "tool_completed":
-        return "responding";
-      // Back to responding after tool completes
-      case "tool_failed":
-        return "responding";
-      // Continue responding after tool failure
-      // Error
-      case "error_occurred":
-        return "idle";
-      // Reset to idle on error
-      default:
-        return null;
+  warn(message, context) {
+    if (this.isWarnEnabled()) {
+      this.log("WARN", message, context);
     }
   }
-  /**
-   * Notify all registered handlers of state change
-   */
-  notifyHandlers(change) {
-    for (const handler of this.handlers) {
-      try {
-        handler(change);
-      } catch (error) {
-        logger$1.error("State change handler error", {
-          from: change.prev,
-          to: change.current,
-          error
-        });
+  error(message, context) {
+    if (this.isErrorEnabled()) {
+      if (message instanceof Error) {
+        this.log("ERROR", message.message, { ...context, stack: message.stack });
+      } else {
+        this.log("ERROR", message, context);
       }
     }
   }
-};
-var logger2$2 = createLogger("core/AgentEventBus");
-var AgentEventBus = class {
-  constructor() {
-    __publicField(this, "subject", new Subject());
-    __publicField(this, "typeSubscriptions", /* @__PURE__ */ new Map());
-    __publicField(this, "globalSubscriptions", []);
-    __publicField(this, "nextId", 0);
-    __publicField(this, "isDestroyed", false);
-    // Cached views
-    __publicField(this, "producerView", null);
-    __publicField(this, "consumerView", null);
+  isDebugEnabled() {
+    return this.level <= LogLevel.DEBUG;
   }
-  // ===== Producer Methods =====
-  emit(event) {
-    if (this.isDestroyed) {
-      logger2$2.warn("Emit called on destroyed EventBus", { eventType: event.type });
-      return;
-    }
-    this.subject.next(event);
+  isInfoEnabled() {
+    return this.level <= LogLevel.INFO;
   }
-  emitBatch(events) {
-    for (const event of events) {
-      this.emit(event);
-    }
+  isWarnEnabled() {
+    return this.level <= LogLevel.WARN;
   }
-  on(typeOrTypes, handler, options = {}) {
-    if (this.isDestroyed) {
-      logger2$2.warn("Subscribe called on destroyed EventBus");
-      return () => {
-      };
+  isErrorEnabled() {
+    return this.level <= LogLevel.ERROR;
+  }
+  log(level, message, context) {
+    const parts = [];
+    if (this.timestamps) {
+      parts.push((/* @__PURE__ */ new Date()).toISOString());
     }
-    const types = Array.isArray(typeOrTypes) ? typeOrTypes : [typeOrTypes];
-    const unsubscribes = [];
-    for (const type of types) {
-      const unsub = this.subscribeToType(type, handler, options);
-      unsubscribes.push(unsub);
+    if (this.colors) {
+      const color = _ConsoleLogger2.COLORS[level];
+      parts.push(`${color}${level.padEnd(5)}${_ConsoleLogger2.COLORS.RESET}`);
+    } else {
+      parts.push(level.padEnd(5));
     }
-    return () => unsubscribes.forEach((u) => u());
-  }
-  onAny(handler, options = {}) {
-    if (this.isDestroyed) {
-      logger2$2.warn("Subscribe called on destroyed EventBus");
-      return () => {
-      };
+    parts.push(`[${this.name}]`);
+    parts.push(message);
+    const logLine = parts.join(" ");
+    const consoleMethod = this.getConsoleMethod(level);
+    if (context && Object.keys(context).length > 0) {
+      consoleMethod(logLine, context);
+    } else {
+      consoleMethod(logLine);
     }
-    return this.subscribeGlobal(handler, options);
-  }
-  once(type, handler) {
-    return this.on(type, handler, { once: true });
   }
-  // ===== View Methods =====
-  asConsumer() {
-    if (!this.consumerView) {
-      this.consumerView = {
-        on: this.on.bind(this),
-        onAny: this.onAny.bind(this),
-        once: this.once.bind(this)
-      };
+  getConsoleMethod(level) {
+    switch (level) {
+      case "DEBUG":
+        return console.debug.bind(console);
+      case "INFO":
+        return console.info.bind(console);
+      case "WARN":
+        return console.warn.bind(console);
+      case "ERROR":
+        return console.error.bind(console);
+      default:
+        return console.log.bind(console);
     }
-    return this.consumerView;
   }
-  asProducer() {
-    if (!this.producerView) {
-      this.producerView = {
-        emit: this.emit.bind(this),
-        emitBatch: this.emitBatch.bind(this)
-      };
-    }
-    return this.producerView;
+  isNodeEnvironment() {
+    var _a;
+    return typeof process !== "undefined" && ((_a = process.versions) == null ? void 0 : _a.node) !== void 0;
   }
-  // ===== Lifecycle =====
-  destroy() {
-    if (this.isDestroyed) return;
-    this.isDestroyed = true;
-    for (const records of this.typeSubscriptions.values()) {
-      for (const record of records) {
-        record.unsubscribe();
+};
+__publicField2(_ConsoleLogger, "COLORS", {
+  DEBUG: "\x1B[36m",
+  INFO: "\x1B[32m",
+  WARN: "\x1B[33m",
+  ERROR: "\x1B[31m",
+  RESET: "\x1B[0m"
+});
+var ConsoleLogger = _ConsoleLogger;
+var externalFactory = null;
+var LoggerFactoryImpl = class {
+  static getLogger(nameOrClass) {
+    const name = typeof nameOrClass === "string" ? nameOrClass : nameOrClass.name;
+    if (this.loggers.has(name)) {
+      return this.loggers.get(name);
+    }
+    const lazyLogger = this.createLazyLogger(name);
+    this.loggers.set(name, lazyLogger);
+    return lazyLogger;
+  }
+  static configure(config2) {
+    this.config = { ...this.config, ...config2 };
+  }
+  static reset() {
+    this.loggers.clear();
+    this.config = { defaultLevel: LogLevel.INFO };
+    externalFactory = null;
+  }
+  static createLazyLogger(name) {
+    let realLogger = null;
+    const getRealLogger = () => {
+      if (!realLogger) {
+        realLogger = this.createLogger(name);
       }
-    }
-    this.typeSubscriptions.clear();
-    for (const record of this.globalSubscriptions) {
-      record.unsubscribe();
-    }
-    this.globalSubscriptions.length = 0;
-    this.subject.complete();
-    logger2$2.debug("EventBus destroyed");
+      return realLogger;
+    };
+    return {
+      name,
+      level: this.config.defaultLevel || LogLevel.INFO,
+      debug: (message, context) => getRealLogger().debug(message, context),
+      info: (message, context) => getRealLogger().info(message, context),
+      warn: (message, context) => getRealLogger().warn(message, context),
+      error: (message, context) => getRealLogger().error(message, context),
+      isDebugEnabled: () => getRealLogger().isDebugEnabled(),
+      isInfoEnabled: () => getRealLogger().isInfoEnabled(),
+      isWarnEnabled: () => getRealLogger().isWarnEnabled(),
+      isErrorEnabled: () => getRealLogger().isErrorEnabled()
+    };
   }
-  // ===== Private Methods =====
-  subscribeToType(type, handler, options) {
-    const { filter: filter$1, priority = 0, once = false } = options;
-    const id = this.nextId++;
-    let observable2 = this.subject.pipe(filter((e) => e.type === type));
-    if (filter$1) {
-      observable2 = observable2.pipe(filter(filter$1));
+  static createLogger(name) {
+    if (externalFactory) {
+      return externalFactory.getLogger(name);
     }
-    if (once) {
-      observable2 = observable2.pipe(take(1));
+    if (this.config.defaultImplementation) {
+      return this.config.defaultImplementation(name);
     }
-    const subscription = observable2.subscribe({
-      next: (event) => {
-        this.executeWithPriority(type, event, handler, id);
-      }
+    return new ConsoleLogger(name, {
+      level: this.config.defaultLevel,
+      ...this.config.consoleOptions
     });
-    const unsubscribe = () => {
-      subscription.unsubscribe();
-      const records2 = this.typeSubscriptions.get(type);
-      if (records2) {
-        const idx = records2.findIndex((r) => r.id === id);
-        if (idx !== -1) records2.splice(idx, 1);
-      }
-    };
-    if (!this.typeSubscriptions.has(type)) {
-      this.typeSubscriptions.set(type, []);
-    }
-    const record = { id, priority, handler, unsubscribe };
-    const records = this.typeSubscriptions.get(type);
-    records.push(record);
-    records.sort((a, b) => b.priority - a.priority);
-    return unsubscribe;
   }
-  subscribeGlobal(handler, options) {
-    const { filter: filter$1, priority = 0, once = false } = options;
-    const id = this.nextId++;
-    let observable2 = this.subject.asObservable();
-    if (filter$1) {
-      observable2 = observable2.pipe(filter(filter$1));
-    }
-    if (once) {
-      observable2 = observable2.pipe(take(1));
+};
+__publicField2(LoggerFactoryImpl, "loggers", /* @__PURE__ */ new Map());
+__publicField2(LoggerFactoryImpl, "config", {
+  defaultLevel: LogLevel.INFO
+});
+function createLogger(name) {
+  return LoggerFactoryImpl.getLogger(name);
+}
+var logger = createLogger("agentx/DefinitionManager");
+function generateMetaImageId(definitionName) {
+  return `meta_${definitionName}`;
+}
+function toDefinitionRecord(definition) {
+  const now = /* @__PURE__ */ new Date();
+  return {
+    name: definition.name,
+    description: definition.description,
+    systemPrompt: definition.systemPrompt,
+    definition,
+    source: "code",
+    createdAt: now,
+    updatedAt: now
+  };
+}
+var DefinitionManagerImpl = class {
+  constructor(repository) {
+    this.repository = repository;
+    __publicField(this, "cache", /* @__PURE__ */ new Map());
+  }
+  register(definition) {
+    if (this.cache.has(definition.name)) {
+      throw new Error(`Definition already exists: ${definition.name}`);
     }
-    const subscription = observable2.subscribe({
-      next: (event) => {
-        this.executeGlobalWithPriority(event, handler, id);
-      }
+    this.cache.set(definition.name, definition);
+    const definitionRecord = toDefinitionRecord(definition);
+    this.repository.saveDefinition(definitionRecord).catch((err) => {
+      logger.error("Failed to save definition", { name: definition.name, error: err });
     });
-    const unsubscribe = () => {
-      subscription.unsubscribe();
-      const idx = this.globalSubscriptions.findIndex((r) => r.id === id);
-      if (idx !== -1) this.globalSubscriptions.splice(idx, 1);
+    const metaImageId = generateMetaImageId(definition.name);
+    const imageRecord = {
+      imageId: metaImageId,
+      type: "meta",
+      definitionName: definition.name,
+      parentImageId: null,
+      definition,
+      config: {},
+      messages: [],
+      createdAt: /* @__PURE__ */ new Date()
     };
-    const record = { id, priority, handler, unsubscribe };
-    this.globalSubscriptions.push(record);
-    this.globalSubscriptions.sort((a, b) => b.priority - a.priority);
-    return unsubscribe;
+    this.repository.saveImage(imageRecord).catch((err) => {
+      logger.error("Failed to save MetaImage", { definitionName: definition.name, error: err });
+    });
+    logger.info("Definition registered", {
+      name: definition.name,
+      metaImageId
+    });
   }
-  /**
-   * Execute handler respecting priority order for typed subscriptions
-   */
-  executeWithPriority(type, event, handler, handlerId) {
-    const records = this.typeSubscriptions.get(type) || [];
-    const record = records.find((r) => r.id === handlerId);
-    if (record) {
-      try {
-        handler(event);
-      } catch (error) {
-        logger2$2.error("Event handler error", { eventType: type, error });
-      }
-    }
+  get(name) {
+    return this.cache.get(name);
   }
-  /**
-   * Execute handler respecting priority order for global subscriptions
-   */
-  executeGlobalWithPriority(event, handler, handlerId) {
-    const record = this.globalSubscriptions.find((r) => r.id === handlerId);
-    if (record) {
-      try {
-        handler(event);
-      } catch (error) {
-        logger2$2.error("Global event handler error", { eventType: event.type, error });
-      }
+  list() {
+    return Array.from(this.cache.values());
+  }
+  has(name) {
+    return this.cache.has(name);
+  }
+  unregister(name) {
+    const definition = this.cache.get(name);
+    if (!definition) {
+      return false;
     }
+    this.cache.delete(name);
+    this.repository.deleteDefinition(name).catch((err) => {
+      logger.error("Failed to delete definition", { name, error: err });
+    });
+    const metaImageId = generateMetaImageId(name);
+    this.repository.deleteImage(metaImageId).catch((err) => {
+      logger.error("Failed to delete MetaImage", { definitionName: name, error: err });
+    });
+    logger.info("Definition unregistered", { name });
+    return true;
   }
 };
-var AgentErrorClassifier = class {
-  constructor(agentId) {
-    this.agentId = agentId;
+var logger2 = createLogger("agentx/ImageManager");
+function generateMetaImageId2(definitionName) {
+  return `meta_${definitionName}`;
+}
+function toAgentImage(record) {
+  const definition = record.definition;
+  if (record.type === "meta") {
+    const metaImage = {
+      type: "meta",
+      imageId: record.imageId,
+      definitionName: record.definitionName,
+      definition,
+      config: record.config,
+      messages: [],
+      createdAt: record.createdAt
+    };
+    return metaImage;
+  } else {
+    return {
+      type: "derived",
+      imageId: record.imageId,
+      parentImageId: record.parentImageId,
+      definitionName: record.definitionName,
+      definition,
+      config: record.config,
+      messages: record.messages,
+      createdAt: record.createdAt
+    };
   }
-  /**
-   * Classify an unknown error into an AgentError
-   */
-  classify(error) {
-    const err = error instanceof Error ? error : new Error(String(error));
-    const message = err.message;
-    if (message.includes("rate limit") || message.includes("429")) {
-      return this.create("llm", "RATE_LIMITED", message, true, err);
-    }
-    if (message.includes("api key") || message.includes("401") || message.includes("unauthorized")) {
-      return this.create("llm", "INVALID_API_KEY", message, false, err);
-    }
-    if (message.includes("context") && message.includes("long")) {
-      return this.create("llm", "CONTEXT_TOO_LONG", message, true, err);
+}
+var ImageManagerImpl = class {
+  constructor(repository, containerManager, defaultContainerId) {
+    __publicField(this, "repository");
+    __publicField(this, "containerManager");
+    __publicField(this, "defaultContainerId");
+    this.repository = repository;
+    this.containerManager = containerManager;
+    this.defaultContainerId = defaultContainerId;
+  }
+  async get(imageId) {
+    const record = await this.repository.findImageById(imageId);
+    if (!record) {
+      return void 0;
     }
-    if (message.includes("overloaded") || message.includes("503")) {
-      return this.create("llm", "OVERLOADED", message, true, err);
+    return toAgentImage(record);
+  }
+  async getMetaImage(definitionName) {
+    const metaImageId = generateMetaImageId2(definitionName);
+    const record = await this.repository.findImageById(metaImageId);
+    if (!record || record.type !== "meta") {
+      return void 0;
     }
-    if (message.includes("timeout") || message.includes("ETIMEDOUT")) {
-      return this.create("network", "TIMEOUT", message, true, err);
+    return toAgentImage(record);
+  }
+  async list() {
+    const records = await this.repository.findAllImages();
+    return records.map(toAgentImage);
+  }
+  async listByDefinition(definitionName) {
+    const allRecords = await this.repository.findAllImages();
+    const filtered = allRecords.filter((r) => r.definitionName === definitionName);
+    return filtered.map(toAgentImage);
+  }
+  async exists(imageId) {
+    return this.repository.imageExists(imageId);
+  }
+  async delete(imageId) {
+    const record = await this.repository.findImageById(imageId);
+    if (!record) {
+      return false;
     }
-    if (message.includes("ECONNREFUSED") || message.includes("connection")) {
-      return this.create("network", "CONNECTION_FAILED", message, true, err);
+    if (record.type === "meta") {
+      logger2.warn("Cannot delete MetaImage directly", { imageId });
+      return false;
     }
-    if (message.includes("network") || message.includes("fetch")) {
-      return this.create("network", "CONNECTION_FAILED", message, true, err);
+    await this.repository.deleteImage(imageId);
+    logger2.info("Image deleted", { imageId });
+    return true;
+  }
+  async run(imageId, options) {
+    logger2.info("Running agent from image", { imageId, containerId: options == null ? void 0 : options.containerId });
+    const image = await this.get(imageId);
+    if (!image) {
+      throw new Error(`Image not found: ${imageId}`);
     }
-    if (message.includes("driver")) {
-      return this.create("driver", "RECEIVE_FAILED", message, true, err);
+    let containerId = (options == null ? void 0 : options.containerId) || this.defaultContainerId;
+    if (!containerId) {
+      const container = await this.containerManager.create();
+      containerId = container.containerId;
+      this.defaultContainerId = containerId;
+      logger2.debug("Auto-created default container", { containerId });
     }
-    return this.create("system", "UNKNOWN", message, true, err);
+    return this.containerManager.run(image, containerId);
+  }
+};
+var logger3 = createLogger("agentx/AgentManager");
+var AgentManager = class {
+  constructor(containerManager) {
+    this.containerManager = containerManager;
   }
   /**
-   * Create an AgentError with the specified category and code
+   * Get an existing agent by ID
    */
-  create(category, code, message, recoverable, cause) {
-    return {
-      category,
-      code,
-      message,
-      severity: recoverable ? "error" : "fatal",
-      recoverable,
-      cause
-    };
+  get(agentId) {
+    return this.containerManager.getAgent(agentId);
   }
   /**
-   * Create an ErrorEvent from an AgentError
-   *
-   * ErrorEvent is independent from Message layer and transportable via SSE.
+   * Check if an agent exists
    */
-  createEvent(error) {
-    return {
-      type: "error",
-      uuid: `${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
-      agentId: this.agentId,
-      timestamp: Date.now(),
-      data: {
-        error
-      }
-    };
-  }
-};
-var MiddlewareChain = class {
-  constructor() {
-    __publicField(this, "middlewares", []);
-  }
-  /**
-   * Add middleware to the chain
-   *
-   * @param middleware - Middleware function
-   * @returns Unsubscribe function to remove the middleware
-   */
-  use(middleware) {
-    this.middlewares.push(middleware);
-    return () => {
-      const index = this.middlewares.indexOf(middleware);
-      if (index !== -1) {
-        this.middlewares.splice(index, 1);
-      }
-    };
+  has(agentId) {
+    return this.containerManager.hasAgent(agentId);
   }
   /**
-   * Execute the middleware chain
-   *
-   * @param message - User message to process
-   * @param finalHandler - Handler called at the end of the chain
+   * List all agents
    */
-  async execute(message, finalHandler) {
-    let index = 0;
-    const next = async (msg) => {
-      if (index < this.middlewares.length) {
-        const middleware = this.middlewares[index++];
-        await middleware(msg, next);
-      } else {
-        await finalHandler(msg);
-      }
-    };
-    await next(message);
+  list() {
+    return this.containerManager.listAgents();
   }
   /**
-   * Clear all middlewares
+   * Destroy an agent by ID
    */
-  clear() {
-    this.middlewares.length = 0;
+  async destroy(agentId) {
+    logger3.debug("Destroying agent", { agentId });
+    await this.containerManager.destroyAgent(agentId);
+    logger3.info("Agent destroyed", { agentId });
   }
   /**
-   * Get the number of middlewares
+   * Destroy all agents
    */
-  get size() {
-    return this.middlewares.length;
+  async destroyAll() {
+    const agents = this.containerManager.listAgents();
+    logger3.debug("Destroying all agents", { count: agents.length });
+    await this.containerManager.destroyAllAgents();
+    logger3.info("All agents destroyed", { count: agents.length });
   }
 };
-var logger3$2 = createLogger("core/InterceptorChain");
-var InterceptorChain = class {
-  constructor(agentId) {
-    __publicField(this, "interceptors", []);
-    __publicField(this, "agentId");
-    this.agentId = agentId;
-  }
-  /**
-   * Add interceptor to the chain
-   *
-   * @param interceptor - Interceptor function
-   * @returns Unsubscribe function to remove the interceptor
-   */
-  intercept(interceptor) {
-    this.interceptors.push(interceptor);
-    return () => {
-      const index = this.interceptors.indexOf(interceptor);
-      if (index !== -1) {
-        this.interceptors.splice(index, 1);
-      }
-    };
-  }
-  /**
-   * Execute the interceptor chain
-   *
-   * @param event - Event to process
-   * @param finalHandler - Handler called at the end of the chain
-   */
-  execute(event, finalHandler) {
-    let index = 0;
-    const next = (e) => {
-      if (index < this.interceptors.length) {
-        const interceptor = this.interceptors[index++];
-        try {
-          interceptor(e, next);
-        } catch (error) {
-          logger3$2.error("Interceptor error", {
-            agentId: this.agentId,
-            eventType: e.type,
-            interceptorIndex: index - 1,
-            error
-          });
-          next(e);
-        }
-      } else {
-        finalHandler(e);
-      }
-    };
-    next(event);
+var logger4 = createLogger("agentx/SessionManager");
+function generateSessionId() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 8);
+  return `session_${timestamp}_${random}`;
+}
+function generateImageId() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 8);
+  return `image_${timestamp}_${random}`;
+}
+var SessionImpl = class _SessionImpl {
+  constructor(record, repository, containerManager, defaultContainerId) {
+    __publicField(this, "sessionId");
+    __publicField(this, "userId");
+    __publicField(this, "imageId");
+    __publicField(this, "createdAt");
+    __publicField(this, "_title");
+    __publicField(this, "_updatedAt");
+    __publicField(this, "repository");
+    __publicField(this, "containerManager");
+    __publicField(this, "defaultContainerId");
+    this.sessionId = record.sessionId;
+    this.userId = record.userId;
+    this.imageId = record.imageId;
+    this._title = record.title;
+    this.createdAt = record.createdAt.getTime();
+    this._updatedAt = record.updatedAt.getTime();
+    this.repository = repository;
+    this.containerManager = containerManager;
+    this.defaultContainerId = defaultContainerId;
   }
-  /**
-   * Clear all interceptors
-   */
-  clear() {
-    this.interceptors.length = 0;
+  get title() {
+    return this._title;
   }
-  /**
-   * Get the number of interceptors
-   */
-  get size() {
-    return this.interceptors.length;
+  get updatedAt() {
+    return this._updatedAt;
   }
-};
-var REACT_TO_EVENT_MAP = {
-  // Stream Layer Events
-  onMessageStart: "message_start",
-  onMessageDelta: "message_delta",
-  onMessageStop: "message_stop",
-  onTextContentBlockStart: "text_content_block_start",
-  onTextDelta: "text_delta",
-  onTextContentBlockStop: "text_content_block_stop",
-  onToolUseContentBlockStart: "tool_use_content_block_start",
-  onInputJsonDelta: "input_json_delta",
-  onToolUseContentBlockStop: "tool_use_content_block_stop",
-  onToolCall: "tool_call",
-  onToolResult: "tool_result",
-  // Message Layer Events
-  onUserMessage: "user_message",
-  onAssistantMessage: "assistant_message",
-  onToolCallMessage: "tool_call_message",
-  onToolResultMessage: "tool_result_message",
-  // Error Layer Events (independent, transportable via SSE)
-  onError: "error",
-  // Turn Layer Events
-  onTurnRequest: "turn_request",
-  onTurnResponse: "turn_response"
-};
-function mapReactHandlers(reactHandlers) {
-  const eventHandlerMap = {};
-  for (const [reactKey, eventKey] of Object.entries(REACT_TO_EVENT_MAP)) {
-    const handler = reactHandlers[reactKey];
-    if (handler) {
-      eventHandlerMap[eventKey] = handler;
+  async resume(options) {
+    logger4.info("Resuming agent from session", {
+      sessionId: this.sessionId,
+      imageId: this.imageId,
+      containerId: options == null ? void 0 : options.containerId
+    });
+    let containerId = (options == null ? void 0 : options.containerId) || this.defaultContainerId;
+    if (!containerId) {
+      const container = await this.containerManager.create();
+      containerId = container.containerId;
+      logger4.debug("Auto-created default container for session", {
+        containerId,
+        sessionId: this.sessionId
+      });
     }
+    const agent = await this.containerManager.resume(this, containerId);
+    this.collect(agent);
+    return agent;
   }
-  return eventHandlerMap;
-}
-var logger4$1 = createLogger("core/AgentInstance");
-var AgentInstance = class {
-  constructor(definition, context, engine, driver, sandbox) {
-    __publicField(this, "agentId");
-    __publicField(this, "definition");
-    __publicField(this, "context");
-    __publicField(this, "createdAt");
-    __publicField(this, "sandbox");
-    __publicField(this, "_lifecycle", "running");
-    __publicField(this, "engine");
-    /**
-     * Driver instance - created from definition.driver class
-     */
-    __publicField(this, "driver");
-    /**
-     * State machine - manages state transitions driven by StateEvents
-     */
-    __publicField(this, "stateMachine", new AgentStateMachine());
-    /**
-     * Event bus - centralized event pub/sub
-     */
-    __publicField(this, "eventBus", new AgentEventBus());
-    /**
-     * Error classifier - classifies and creates error events
-     */
-    __publicField(this, "errorClassifier");
-    /**
-     * Middleware chain for receive() interception
-     */
-    __publicField(this, "middlewareChain", new MiddlewareChain());
-    /**
-     * Interceptor chain for event dispatch interception
-     */
-    __publicField(this, "interceptorChain");
-    /**
-     * Lifecycle handlers for onReady
-     */
-    __publicField(this, "readyHandlers", /* @__PURE__ */ new Set());
-    /**
-     * Lifecycle handlers for onDestroy
-     */
-    __publicField(this, "destroyHandlers", /* @__PURE__ */ new Set());
-    this.agentId = context.agentId;
-    this.definition = definition;
-    this.context = context;
-    this.engine = engine;
-    this.createdAt = context.createdAt;
-    this.sandbox = sandbox;
-    this.driver = driver;
-    this.errorClassifier = new AgentErrorClassifier(this.agentId);
-    this.interceptorChain = new InterceptorChain(this.agentId);
-    logger4$1.debug("AgentInstance created", {
-      agentId: this.agentId,
-      definitionName: definition.name,
-      driverName: this.driver.name
+  collect(agent) {
+    logger4.debug("Collecting messages from agent", {
+      sessionId: this.sessionId,
+      agentId: agent.agentId
     });
+    const sessionId = this.sessionId;
+    const repository = this.repository;
+    const saveMessage = (data, role) => {
+      const record = {
+        messageId: data.id,
+        sessionId,
+        role,
+        content: data,
+        createdAt: new Date(data.timestamp ?? Date.now())
+      };
+      repository.saveMessage(record).catch((error) => {
+        logger4.error("Failed to persist message", {
+          sessionId,
+          messageId: record.messageId,
+          error
+        });
+      });
+    };
+    agent.on("user_message", (event) => saveMessage(event.data, "user"));
+    agent.on("assistant_message", (event) => saveMessage(event.data, "assistant"));
+    agent.on("tool_call_message", (event) => saveMessage(event.data, "tool"));
+    agent.on("tool_result_message", (event) => saveMessage(event.data, "tool"));
   }
-  /**
-   * Current lifecycle state
-   */
-  get lifecycle() {
-    return this._lifecycle;
+  async getMessages() {
+    logger4.debug("Getting messages for session", { sessionId: this.sessionId });
+    const records = await this.repository.findMessagesBySessionId(this.sessionId);
+    return records.map((record) => record.content);
   }
-  /**
-   * Current conversation state (delegated to StateMachine)
-   */
-  get state() {
-    return this.stateMachine.state;
+  async fork() {
+    logger4.info("Forking session", { sessionId: this.sessionId });
+    const imageRecord = await this.repository.findImageById(this.imageId);
+    if (!imageRecord) {
+      throw new Error(`Image not found: ${this.imageId}`);
+    }
+    const newImageId = generateImageId();
+    const newImageRecord = {
+      imageId: newImageId,
+      type: "derived",
+      definitionName: imageRecord.definitionName,
+      parentImageId: imageRecord.imageId,
+      definition: imageRecord.definition,
+      config: imageRecord.config,
+      messages: [...imageRecord.messages],
+      // Copy messages
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    await this.repository.saveImage(newImageRecord);
+    const newSessionId = generateSessionId();
+    const now = /* @__PURE__ */ new Date();
+    const newSessionRecord = {
+      sessionId: newSessionId,
+      userId: this.userId,
+      imageId: newImageId,
+      title: this._title ? `Fork of ${this._title}` : null,
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.repository.saveSession(newSessionRecord);
+    logger4.info("Session forked", {
+      originalSessionId: this.sessionId,
+      newSessionId,
+      newImageId
+    });
+    return new _SessionImpl(
+      newSessionRecord,
+      this.repository,
+      this.containerManager,
+      this.defaultContainerId
+    );
+  }
+  async setTitle(title) {
+    logger4.debug("Setting session title", { sessionId: this.sessionId, title });
+    const now = /* @__PURE__ */ new Date();
+    await this.repository.saveSession({
+      sessionId: this.sessionId,
+      userId: this.userId,
+      imageId: this.imageId,
+      title,
+      createdAt: new Date(this.createdAt),
+      updatedAt: now
+    });
+    this._title = title;
+    this._updatedAt = now.getTime();
+    logger4.info("Session title updated", { sessionId: this.sessionId, title });
+  }
+};
+var SessionManagerImpl = class {
+  constructor(repository, containerManager, defaultContainerId) {
+    __publicField(this, "repository");
+    __publicField(this, "containerManager");
+    __publicField(this, "defaultContainerId");
+    this.repository = repository;
+    this.containerManager = containerManager;
+    this.defaultContainerId = defaultContainerId;
+  }
+  async create(imageId, userId) {
+    const sessionId = generateSessionId();
+    const now = /* @__PURE__ */ new Date();
+    const record = {
+      sessionId,
+      userId,
+      imageId,
+      title: null,
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.repository.saveSession(record);
+    logger4.info("Session created", { sessionId, imageId, userId });
+    return new SessionImpl(record, this.repository, this.containerManager, this.defaultContainerId);
+  }
+  async get(sessionId) {
+    const record = await this.repository.findSessionById(sessionId);
+    if (!record) return void 0;
+    return new SessionImpl(record, this.repository, this.containerManager, this.defaultContainerId);
+  }
+  async has(sessionId) {
+    return this.repository.sessionExists(sessionId);
+  }
+  async list() {
+    const records = await this.repository.findAllSessions();
+    return records.map(
+      (r) => new SessionImpl(r, this.repository, this.containerManager, this.defaultContainerId)
+    );
+  }
+  async listByImage(imageId) {
+    const records = await this.repository.findSessionsByImageId(imageId);
+    return records.map(
+      (r) => new SessionImpl(r, this.repository, this.containerManager, this.defaultContainerId)
+    );
+  }
+  async listByUser(userId) {
+    const records = await this.repository.findSessionsByUserId(userId);
+    return records.map(
+      (r) => new SessionImpl(r, this.repository, this.containerManager, this.defaultContainerId)
+    );
+  }
+  async destroy(sessionId) {
+    await this.repository.deleteSession(sessionId);
+    logger4.info("Session destroyed", { sessionId });
+  }
+  async destroyByImage(imageId) {
+    await this.repository.deleteSessionsByImageId(imageId);
+    logger4.info("Sessions destroyed by image", { imageId });
+  }
+  async destroyAll() {
+    const sessions = await this.repository.findAllSessions();
+    for (const session of sessions) {
+      await this.repository.deleteSession(session.sessionId);
+    }
+    logger4.info("All sessions destroyed");
+  }
+};
+var logger5 = createLogger("agentx/ErrorManager");
+var ErrorManager = class {
+  constructor() {
+    __publicField(this, "handlers", /* @__PURE__ */ new Set());
   }
   /**
-   * Receive a message from user
-   *
-   * Runs through middleware chain before actual processing.
+   * Handle an error from any agent
    *
-   * Error Handling:
-   * - Errors are caught and converted to ErrorMessageEvent
-   * - Handlers receive the error event before re-throwing
-   * - This ensures UI can display errors
+   * Called internally when an agent emits an error event.
+   * 1. Default logging (always)
+   * 2. Custom handlers (user-registered)
    */
-  async receive(message) {
-    if (this._lifecycle === "destroyed") {
-      logger4$1.warn("Receive called on destroyed agent", { agentId: this.agentId });
-      const error = this.errorClassifier.create(
-        "system",
-        "AGENT_DESTROYED",
-        "Agent has been destroyed",
-        false
-      );
-      const errorEvent = this.errorClassifier.createEvent(error);
-      this.notifyHandlers(errorEvent);
-      throw new Error("[Agent] Agent has been destroyed");
-    }
-    if (this.state !== "idle") {
-      logger4$1.warn("Receive called while agent is busy", {
-        agentId: this.agentId,
-        currentState: this.state
-      });
-      const error = this.errorClassifier.create(
-        "system",
-        "AGENT_BUSY",
-        `Agent is busy (state: ${this.state}), please wait for current operation to complete`,
-        false
-      );
-      const errorEvent = this.errorClassifier.createEvent(error);
-      this.notifyHandlers(errorEvent);
-      throw new Error(`[Agent] Agent is busy (state: ${this.state})`);
+  handle(agentId, error, event) {
+    this.logError(agentId, error);
+    for (const handler of this.handlers) {
+      try {
+        handler.handle(agentId, error, event);
+      } catch (e) {
+        logger5.error("ErrorHandler failed", { error: e });
+      }
     }
-    const userMessage = typeof message === "string" ? {
-      id: `msg_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
-      role: "user",
-      subtype: "user",
-      content: message,
-      timestamp: Date.now()
-    } : message;
-    logger4$1.debug("Receiving message", {
-      agentId: this.agentId,
-      messageId: userMessage.id
-    });
-    const userMessageEvent = {
-      uuid: `evt_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
-      type: "user_message",
-      agentId: this.agentId,
-      timestamp: Date.now(),
-      data: userMessage
+  }
+  /**
+   * Add a custom error handler
+   */
+  addHandler(handler) {
+    this.handlers.add(handler);
+    return () => {
+      this.handlers.delete(handler);
     };
-    this.presentOutput(userMessageEvent);
-    this.notifyHandlers(userMessageEvent);
-    await this.executeMiddlewareChain(userMessage);
   }
   /**
-   * Execute middleware chain and then process the message
+   * Remove an error handler
    */
-  async executeMiddlewareChain(message) {
-    await this.middlewareChain.execute(message, (msg) => this.doReceive(msg));
+  removeHandler(handler) {
+    this.handlers.delete(handler);
   }
   /**
-   * Process a single stream event through the engine
-   *
-   * Used by:
-   * - doReceive() - normal message flow
-   * - AgentInterrupter - interrupt event injection
-   *
-   * @param streamEvent - Stream event to process
+   * Default error logging
    */
-  processStreamEvent(streamEvent) {
-    const outputs = this.engine.process(this.agentId, streamEvent);
-    for (const output of outputs) {
-      this.presentOutput(output);
-    }
-    for (const output of outputs) {
-      this.notifyHandlers(output);
+  logError(agentId, error) {
+    const prefix = `[${agentId}] ${error.category}/${error.code}`;
+    if (error.severity === "fatal") {
+      logger5.error(`${prefix}: ${error.message}`, { error });
+    } else if (error.severity === "error") {
+      logger5.error(`${prefix}: ${error.message}`);
+    } else {
+      logger5.warn(`${prefix}: ${error.message}`);
     }
   }
+};
+var logger6 = createLogger("core/AgentStateMachine");
+var AgentStateMachine = class {
+  constructor() {
+    __publicField(this, "_state", "idle");
+    __publicField(this, "handlers", /* @__PURE__ */ new Set());
+  }
   /**
-   * Actual message processing logic
+   * Current agent state
+   */
+  get state() {
+    return this._state;
+  }
+  /**
+   * Process a StateEvent and update internal state
    *
-   * Coordinates the flow:
-   * 1. Driver receives message → produces StreamEvents
-   * 2. Engine processes events → produces outputs
-   * 3. Presenters handle outputs
-   * 4. Handlers receive outputs
+   * @param event - StateEvent from Engine layer
    */
-  async doReceive(userMessage) {
-    try {
-      logger4$1.debug("Processing message through driver", {
-        agentId: this.agentId,
-        messageId: userMessage.id
-      });
-      const queuedEvent = {
-        type: "conversation_queued",
-        uuid: `${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
-        agentId: this.agentId,
-        timestamp: Date.now(),
-        data: {
-          userMessage
-        }
-      };
-      this.notifyHandlers(queuedEvent);
-      const streamEvents = this.driver.receive(userMessage);
-      for await (const streamEvent of streamEvents) {
-        this.processStreamEvent(streamEvent);
-      }
-      logger4$1.debug("Message processing completed", {
-        agentId: this.agentId,
-        messageId: userMessage.id
-      });
-    } catch (error) {
-      const agentError = this.errorClassifier.classify(error);
-      const errorEvent = this.errorClassifier.createEvent(agentError);
-      logger4$1.error("Message processing failed", {
-        agentId: this.agentId,
-        messageId: userMessage.id,
-        errorCategory: agentError.category,
-        errorCode: agentError.code,
-        error
+  process(event) {
+    const prev = this._state;
+    const next = this.mapEventToState(event);
+    if (next !== null && prev !== next) {
+      this._state = next;
+      logger6.debug("State transition", {
+        eventType: event.type,
+        from: prev,
+        to: next
       });
-      this.notifyHandlers(errorEvent);
-      throw error;
-    }
-  }
-  /**
-   * Send output to all presenters
-   *
-   * Note: Presenters are no longer part of AgentDefinition.
-   * This is a placeholder for future presenter injection via Runtime or middleware.
-   */
-  presentOutput(_output) {
-  }
-  on(typeOrHandlerOrMap, handler) {
-    if (typeof typeOrHandlerOrMap === "function") {
-      return this.eventBus.onAny(typeOrHandlerOrMap);
-    }
-    if (this.isEventHandlerMap(typeOrHandlerOrMap)) {
-      const unsubscribes = [];
-      for (const [eventType, eventHandler] of Object.entries(typeOrHandlerOrMap)) {
-        if (eventHandler) {
-          unsubscribes.push(this.eventBus.on(eventType, eventHandler));
-        }
-      }
-      return () => {
-        for (const unsub of unsubscribes) {
-          unsub();
-        }
-      };
-    }
-    const types = Array.isArray(typeOrHandlerOrMap) ? typeOrHandlerOrMap : [typeOrHandlerOrMap];
-    const h = handler;
-    return this.eventBus.on(types, h);
-  }
-  /**
-   * Check if the argument is an EventHandlerMap (object with event type keys)
-   */
-  isEventHandlerMap(arg) {
-    if (typeof arg !== "object" || arg === null || Array.isArray(arg)) {
-      return false;
-    }
-    const keys = Object.keys(arg);
-    if (keys.length === 0) {
-      return false;
+      this.notifyHandlers({ prev, current: next });
     }
-    return keys.every((key) => {
-      const value = arg[key];
-      return value === void 0 || typeof value === "function";
-    });
   }
   /**
-   * Subscribe to state changes (delegated to StateMachine)
+   * Subscribe to state changes
    *
    * @param handler - Callback receiving { prev, current } state change
    * @returns Unsubscribe function
    */
   onStateChange(handler) {
-    return this.stateMachine.onStateChange(handler);
-  }
-  /**
-   * React-style fluent event subscription
-   *
-   * Converts onXxx handlers to event type keys and delegates to on(handlers)
-   */
-  react(handlers) {
-    const eventHandlerMap = mapReactHandlers(handlers);
-    return this.on(eventHandlerMap);
-  }
-  /**
-   * Subscribe to agent ready event
-   *
-   * If already running, handler is called immediately.
-   */
-  onReady(handler) {
-    if (this._lifecycle === "running") {
-      try {
-        handler();
-      } catch (error) {
-        logger4$1.error("onReady handler error", {
-          agentId: this.agentId,
-          error
-        });
-      }
-    }
-    this.readyHandlers.add(handler);
-    return () => {
-      this.readyHandlers.delete(handler);
-    };
-  }
-  /**
-   * Subscribe to agent destroy event
-   */
-  onDestroy(handler) {
-    this.destroyHandlers.add(handler);
+    this.handlers.add(handler);
     return () => {
-      this.destroyHandlers.delete(handler);
+      this.handlers.delete(handler);
     };
   }
   /**
-   * Add middleware to intercept incoming messages
-   */
-  use(middleware) {
-    return this.middlewareChain.use(middleware);
-  }
-  /**
-   * Add interceptor to intercept outgoing events
+   * Reset state machine (used on destroy)
    */
-  intercept(interceptor) {
-    return this.interceptorChain.intercept(interceptor);
+  reset() {
+    this._state;
+    this._state = "idle";
+    this.handlers.clear();
   }
   /**
-   * Interrupt - User-initiated stop
+   * Map StateEvent type to AgentState
    *
-   * Stops the current operation gracefully.
-   * Flow:
-   * 1. Call driver.interrupt() to abort active requests
-   * 2. Driver yields InterruptedStreamEvent
-   * 3. Event flows through engine pipeline
-   * 4. StateEventProcessor generates conversation_interrupted
-   * 5. StateMachine transitions to idle state
-   * 6. UI receives state change notification
+   * @param event - StateEvent from Engine
+   * @returns New AgentState or null if no transition needed
    */
-  interrupt() {
-    logger4$1.debug("User interrupt requested", { agentId: this.agentId, currentState: this.state });
-    this.driver.interrupt();
+  mapEventToState(event) {
+    switch (event.type) {
+      // Agent lifecycle
+      case "agent_initializing":
+        return "initializing";
+      case "agent_ready":
+        return "idle";
+      case "agent_destroyed":
+        return "idle";
+      // Conversation lifecycle
+      case "conversation_queued":
+        return "queued";
+      case "conversation_start":
+        return "conversation_active";
+      case "conversation_thinking":
+        return "thinking";
+      case "conversation_responding":
+        return "responding";
+      case "conversation_end":
+        return "idle";
+      case "conversation_interrupted":
+        return "idle";
+      // Return to idle on interrupt
+      // Tool lifecycle
+      case "tool_planned":
+        return "planning_tool";
+      case "tool_executing":
+        return "awaiting_tool_result";
+      case "tool_completed":
+        return "responding";
+      // Back to responding after tool completes
+      case "tool_failed":
+        return "responding";
+      // Continue responding after tool failure
+      // Error
+      case "error_occurred":
+        return "idle";
+      // Reset to idle on error
+      default:
+        return null;
+    }
   }
   /**
-   * Destroy - Clean up resources
+   * Notify all registered handlers of state change
    */
-  async destroy() {
-    logger4$1.debug("Destroying agent", { agentId: this.agentId });
-    for (const handler of this.destroyHandlers) {
+  notifyHandlers(change) {
+    for (const handler of this.handlers) {
       try {
-        handler();
+        handler(change);
       } catch (error) {
-        logger4$1.error("onDestroy handler error", {
-          agentId: this.agentId,
+        logger6.error("State change handler error", {
+          from: change.prev,
+          to: change.current,
           error
         });
       }
     }
-    this._lifecycle = "destroyed";
-    this.stateMachine.reset();
-    this.eventBus.destroy();
-    this.readyHandlers.clear();
-    this.destroyHandlers.clear();
-    this.middlewareChain.clear();
-    this.interceptorChain.clear();
-    this.engine.clearState(this.agentId);
-    logger4$1.info("Agent destroyed", { agentId: this.agentId });
-  }
-  /**
-   * Notify all registered handlers
-   *
-   * Flow:
-   * 1. StateMachine processes StateEvents (for state transitions)
-   * 2. Interceptor chain can modify/filter events
-   * 3. EventBus emits to all subscribers
-   */
-  notifyHandlers(event) {
-    if (isStateEvent(event)) {
-      this.stateMachine.process(event);
-    }
-    this.executeInterceptorChain(event);
-  }
-  /**
-   * Execute interceptor chain and then emit to EventBus
-   */
-  executeInterceptorChain(event) {
-    this.interceptorChain.execute(event, (e) => this.eventBus.emit(e));
-  }
-  /**
-   * Get the event consumer for external subscriptions
-   *
-   * Use this to expose event subscription without emit capability.
-   */
-  getEventConsumer() {
-    return this.eventBus.asConsumer();
   }
 };
-var MemoryStore = class {
+var logger22 = createLogger("core/AgentEventBus");
+var AgentEventBus = class {
   constructor() {
-    __publicField(this, "states", /* @__PURE__ */ new Map());
-  }
-  get(id) {
-    return this.states.get(id);
+    __publicField(this, "subject", new Subject());
+    __publicField(this, "typeSubscriptions", /* @__PURE__ */ new Map());
+    __publicField(this, "globalSubscriptions", []);
+    __publicField(this, "nextId", 0);
+    __publicField(this, "isDestroyed", false);
+    __publicField(this, "producerView", null);
+    __publicField(this, "consumerView", null);
   }
-  set(id, state) {
-    this.states.set(id, state);
+  // ===== Producer Methods =====
+  emit(event) {
+    if (this.isDestroyed) {
+      logger22.warn("Emit called on destroyed EventBus", { eventType: event.type });
+      return;
+    }
+    this.subject.next(event);
   }
-  delete(id) {
-    this.states.delete(id);
+  emitBatch(events) {
+    for (const event of events) {
+      this.emit(event);
+    }
   }
-  has(id) {
-    return this.states.has(id);
+  on(typeOrTypes, handler, options = {}) {
+    if (this.isDestroyed) {
+      logger22.warn("Subscribe called on destroyed EventBus");
+      return () => {
+      };
+    }
+    const types = Array.isArray(typeOrTypes) ? typeOrTypes : [typeOrTypes];
+    const unsubscribes = [];
+    for (const type of types) {
+      const unsub = this.subscribeToType(type, handler, options);
+      unsubscribes.push(unsub);
+    }
+    return () => unsubscribes.forEach((u) => u());
   }
-  /**
-   * Clear all stored states
-   */
-  clear() {
-    this.states.clear();
+  onAny(handler, options = {}) {
+    if (this.isDestroyed) {
+      logger22.warn("Subscribe called on destroyed EventBus");
+      return () => {
+      };
+    }
+    return this.subscribeGlobal(handler, options);
+  }
+  once(type, handler) {
+    return this.on(type, handler, { once: true });
+  }
+  // ===== View Methods =====
+  asConsumer() {
+    if (!this.consumerView) {
+      this.consumerView = {
+        on: this.on.bind(this),
+        onAny: this.onAny.bind(this),
+        once: this.once.bind(this)
+      };
+    }
+    return this.consumerView;
+  }
+  asProducer() {
+    if (!this.producerView) {
+      this.producerView = {
+        emit: this.emit.bind(this),
+        emitBatch: this.emitBatch.bind(this)
+      };
+    }
+    return this.producerView;
+  }
+  // ===== Lifecycle =====
+  destroy() {
+    if (this.isDestroyed) return;
+    this.isDestroyed = true;
+    for (const records of this.typeSubscriptions.values()) {
+      for (const record of records) {
+        record.unsubscribe();
+      }
+    }
+    this.typeSubscriptions.clear();
+    for (const record of this.globalSubscriptions) {
+      record.unsubscribe();
+    }
+    this.globalSubscriptions.length = 0;
+    this.subject.complete();
+    logger22.debug("EventBus destroyed");
+  }
+  // ===== Private Methods =====
+  subscribeToType(type, handler, options) {
+    const { filter: filter$1, priority = 0, once = false } = options;
+    const id = this.nextId++;
+    let observable2 = this.subject.pipe(filter((e) => e.type === type));
+    if (filter$1) {
+      observable2 = observable2.pipe(filter(filter$1));
+    }
+    if (once) {
+      observable2 = observable2.pipe(take(1));
+    }
+    const subscription = observable2.subscribe({
+      next: (event) => {
+        this.executeWithPriority(type, event, handler, id);
+      }
+    });
+    const unsubscribe = () => {
+      subscription.unsubscribe();
+      const records2 = this.typeSubscriptions.get(type);
+      if (records2) {
+        const idx = records2.findIndex((r) => r.id === id);
+        if (idx !== -1) records2.splice(idx, 1);
+      }
+    };
+    if (!this.typeSubscriptions.has(type)) {
+      this.typeSubscriptions.set(type, []);
+    }
+    const record = { id, priority, handler, unsubscribe };
+    const records = this.typeSubscriptions.get(type);
+    records.push(record);
+    records.sort((a, b) => b.priority - a.priority);
+    return unsubscribe;
+  }
+  subscribeGlobal(handler, options) {
+    const { filter: filter$1, priority = 0, once = false } = options;
+    const id = this.nextId++;
+    let observable2 = this.subject.asObservable();
+    if (filter$1) {
+      observable2 = observable2.pipe(filter(filter$1));
+    }
+    if (once) {
+      observable2 = observable2.pipe(take(1));
+    }
+    const subscription = observable2.subscribe({
+      next: (event) => {
+        this.executeGlobalWithPriority(event, handler, id);
+      }
+    });
+    const unsubscribe = () => {
+      subscription.unsubscribe();
+      const idx = this.globalSubscriptions.findIndex((r) => r.id === id);
+      if (idx !== -1) this.globalSubscriptions.splice(idx, 1);
+    };
+    const record = { id, priority, handler, unsubscribe };
+    this.globalSubscriptions.push(record);
+    this.globalSubscriptions.sort((a, b) => b.priority - a.priority);
+    return unsubscribe;
   }
   /**
-   * Get the number of stored states
+   * Execute handler respecting priority order for typed subscriptions
    */
-  get size() {
-    return this.states.size;
+  executeWithPriority(type, event, handler, handlerId) {
+    const records = this.typeSubscriptions.get(type) || [];
+    const record = records.find((r) => r.id === handlerId);
+    if (record) {
+      try {
+        handler(event);
+      } catch (error) {
+        logger22.error("Event handler error", { eventType: type, error });
+      }
+    }
   }
   /**
-   * Get all stored IDs
+   * Execute handler respecting priority order for global subscriptions
    */
-  keys() {
-    return this.states.keys();
+  executeGlobalWithPriority(event, handler, handlerId) {
+    const record = this.globalSubscriptions.find((r) => r.id === handlerId);
+    if (record) {
+      try {
+        handler(event);
+      } catch (error) {
+        logger22.error("Global event handler error", { eventType: event.type, error });
+      }
+    }
   }
 };
-createLogger("engine/Mealy");
-function combineProcessors(processors) {
-  return (state, event) => {
-    const newState = {};
-    const allOutputs = [];
-    for (const key in processors) {
-      const processor = processors[key];
-      const subState = state[key];
-      const [newSubState, outputs] = processor(subState, event);
-      newState[key] = newSubState;
-      allOutputs.push(...outputs);
+var AgentErrorClassifier = class {
+  constructor(agentId) {
+    this.agentId = agentId;
+  }
+  /**
+   * Classify an unknown error into an AgentError
+   */
+  classify(error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    const message = err.message;
+    if (message.includes("rate limit") || message.includes("429")) {
+      return this.create("llm", "RATE_LIMITED", message, true, err);
     }
-    return [newState, allOutputs];
-  };
-}
-function combineInitialStates(initialStates) {
-  return () => {
-    const state = {};
-    for (const key in initialStates) {
-      state[key] = initialStates[key]();
+    if (message.includes("api key") || message.includes("401") || message.includes("unauthorized")) {
+      return this.create("llm", "INVALID_API_KEY", message, false, err);
     }
-    return state;
-  };
-}
-function createInitialMessageAssemblerState() {
-  return {
-    currentMessageId: null,
-    messageStartTime: null,
-    pendingContents: {},
-    pendingToolCalls: {}
-  };
-}
-function generateId() {
-  return `msg_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-}
-var messageAssemblerProcessor = (state, input) => {
-  switch (input.type) {
-    case "message_start":
-      return handleMessageStart(state, input);
-    case "text_delta":
-      return handleTextDelta(state, input);
-    case "tool_use_content_block_start":
-      return handleToolUseContentBlockStart(state, input);
-    case "input_json_delta":
-      return handleInputJsonDelta(state, input);
-    case "tool_use_content_block_stop":
-      return handleToolUseContentBlockStop(state, input);
-    case "tool_result":
-      return handleToolResult(state, input);
-    case "message_stop":
-      return handleMessageStop(state, input);
-    default:
-      return [state, []];
+    if (message.includes("context") && message.includes("long")) {
+      return this.create("llm", "CONTEXT_TOO_LONG", message, true, err);
+    }
+    if (message.includes("overloaded") || message.includes("503")) {
+      return this.create("llm", "OVERLOADED", message, true, err);
+    }
+    if (message.includes("timeout") || message.includes("ETIMEDOUT")) {
+      return this.create("network", "TIMEOUT", message, true, err);
+    }
+    if (message.includes("ECONNREFUSED") || message.includes("connection")) {
+      return this.create("network", "CONNECTION_FAILED", message, true, err);
+    }
+    if (message.includes("network") || message.includes("fetch")) {
+      return this.create("network", "CONNECTION_FAILED", message, true, err);
+    }
+    if (message.includes("driver")) {
+      return this.create("driver", "RECEIVE_FAILED", message, true, err);
+    }
+    return this.create("system", "UNKNOWN", message, true, err);
   }
-};
-function handleMessageStart(state, event) {
-  return [
-    {
-      ...state,
-      currentMessageId: generateId(),
-      messageStartTime: event.timestamp,
-      pendingContents: {}
-    },
-    []
-  ];
-}
-function handleTextDelta(state, event) {
-  const index = 0;
-  const existingContent = state.pendingContents[index];
-  const pendingContent = (existingContent == null ? void 0 : existingContent.type) === "text" ? {
-    ...existingContent,
-    textDeltas: [...existingContent.textDeltas || [], event.data.text]
-  } : {
-    type: "text",
-    index,
-    textDeltas: [event.data.text]
-  };
-  return [
-    {
-      ...state,
-      pendingContents: {
-        ...state.pendingContents,
-        [index]: pendingContent
-      }
-    },
-    []
-  ];
-}
-function handleToolUseContentBlockStart(state, event) {
-  const index = 1;
-  const pendingContent = {
-    type: "tool_use",
-    index,
-    toolId: event.data.id,
-    toolName: event.data.name,
-    toolInputJson: ""
-  };
-  return [
-    {
-      ...state,
-      pendingContents: {
-        ...state.pendingContents,
-        [index]: pendingContent
-      }
-    },
-    []
-  ];
-}
-function handleInputJsonDelta(state, event) {
-  const index = 1;
-  const existingContent = state.pendingContents[index];
-  if (!existingContent || existingContent.type !== "tool_use") {
-    return [state, []];
+  /**
+   * Create an AgentError with the specified category and code
+   */
+  create(category, code, message, recoverable, cause) {
+    return {
+      category,
+      code,
+      message,
+      severity: recoverable ? "error" : "fatal",
+      recoverable,
+      cause
+    };
   }
-  const pendingContent = {
-    ...existingContent,
-    toolInputJson: (existingContent.toolInputJson || "") + event.data.partialJson
-  };
-  return [
-    {
-      ...state,
-      pendingContents: {
-        ...state.pendingContents,
-        [index]: pendingContent
+  /**
+   * Create an ErrorEvent from an AgentError
+   *
+   * ErrorEvent is independent from Message layer and transportable via SSE.
+   */
+  createEvent(error) {
+    return {
+      type: "error",
+      uuid: `${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
+      agentId: this.agentId,
+      timestamp: Date.now(),
+      data: {
+        error
       }
-    },
-    []
-  ];
-}
-function handleToolUseContentBlockStop(state, event) {
-  const index = 1;
-  const pendingContent = state.pendingContents[index];
-  if (!pendingContent || pendingContent.type !== "tool_use") {
-    return [state, []];
+    };
   }
-  let toolInput = {};
-  try {
-    toolInput = pendingContent.toolInputJson ? JSON.parse(pendingContent.toolInputJson) : {};
-  } catch {
-    toolInput = {};
+};
+var MiddlewareChain = class {
+  constructor() {
+    __publicField(this, "middlewares", []);
   }
-  const outputs = [];
-  const toolId = pendingContent.toolId;
-  const toolName = pendingContent.toolName;
-  const toolCallEvent = {
-    type: "tool_call",
-    uuid: generateId(),
-    agentId: event.agentId,
-    timestamp: Date.now(),
-    data: {
-      id: toolId,
-      name: toolName,
-      input: toolInput
-    }
-  };
-  outputs.push(toolCallEvent);
-  const toolCall = {
-    type: "tool-call",
-    id: toolId,
-    name: toolName,
-    input: toolInput
-  };
-  const toolCallMessage = {
-    id: generateId(),
-    role: "assistant",
-    subtype: "tool-call",
-    toolCall,
-    timestamp: Date.now()
-  };
-  const toolCallMessageEvent = {
-    type: "tool_call_message",
-    uuid: generateId(),
-    agentId: event.agentId,
-    timestamp: Date.now(),
-    data: toolCallMessage
-  };
-  outputs.push(toolCallMessageEvent);
-  const { [index]: _, ...remainingContents } = state.pendingContents;
-  return [
-    {
-      ...state,
-      pendingContents: remainingContents,
-      pendingToolCalls: {
-        ...state.pendingToolCalls,
-        [toolId]: { id: toolId, name: toolName }
+  /**
+   * Add middleware to the chain
+   *
+   * @param middleware - Middleware function
+   * @returns Unsubscribe function to remove the middleware
+   */
+  use(middleware) {
+    this.middlewares.push(middleware);
+    return () => {
+      const index = this.middlewares.indexOf(middleware);
+      if (index !== -1) {
+        this.middlewares.splice(index, 1);
       }
-    },
-    outputs
-  ];
-}
-function handleToolResult(state, event) {
-  const { toolId, content, isError } = event.data;
-  const pendingToolCall = state.pendingToolCalls[toolId];
-  const toolName = (pendingToolCall == null ? void 0 : pendingToolCall.name) || "unknown";
-  const toolResult = {
-    type: "tool-result",
-    id: toolId,
-    name: toolName,
-    output: {
-      type: isError ? "error-text" : "text",
-      value: typeof content === "string" ? content : JSON.stringify(content)
-    }
-  };
-  const toolResultMessage = {
-    id: generateId(),
-    role: "tool",
-    subtype: "tool-result",
-    toolResult,
-    toolCallId: toolId,
-    timestamp: Date.now()
-  };
-  const toolResultMessageEvent = {
-    type: "tool_result_message",
-    uuid: generateId(),
-    agentId: event.agentId,
-    timestamp: Date.now(),
-    data: toolResultMessage
-  };
-  const { [toolId]: _, ...remainingToolCalls } = state.pendingToolCalls;
-  return [
-    {
-      ...state,
-      pendingToolCalls: remainingToolCalls
-    },
-    [toolResultMessageEvent]
-  ];
-}
-function handleMessageStop(state, event) {
-  if (!state.currentMessageId) {
-    return [state, []];
+    };
   }
-  const textParts = [];
-  const sortedContents = Object.values(state.pendingContents).sort((a, b) => a.index - b.index);
-  for (const pending of sortedContents) {
-    if (pending.type === "text" && pending.textDeltas) {
-      textParts.push(pending.textDeltas.join(""));
-    }
+  /**
+   * Execute the middleware chain
+   *
+   * @param message - User message to process
+   * @param finalHandler - Handler called at the end of the chain
+   */
+  async execute(message, finalHandler) {
+    let index = 0;
+    const next = async (msg) => {
+      if (index < this.middlewares.length) {
+        const middleware = this.middlewares[index++];
+        await middleware(msg, next);
+      } else {
+        await finalHandler(msg);
+      }
+    };
+    await next(message);
   }
-  const content = textParts.join("");
-  const stopReason = event.data.stopReason;
-  if (!content || content.trim().length === 0) {
-    const shouldPreserveToolCalls2 = stopReason === "tool_use";
-    return [
-      {
-        ...createInitialMessageAssemblerState(),
-        pendingToolCalls: shouldPreserveToolCalls2 ? state.pendingToolCalls : {}
-      },
-      []
-    ];
+  /**
+   * Clear all middlewares
+   */
+  clear() {
+    this.middlewares.length = 0;
   }
-  const assistantMessage = {
-    id: state.currentMessageId,
-    role: "assistant",
-    subtype: "assistant",
-    content,
-    timestamp: state.messageStartTime || Date.now(),
-    // Usage data is not available in message_stop event
-    // It would need to be tracked separately if needed
-    usage: void 0
-  };
-  const assistantEvent = {
-    type: "assistant_message",
-    uuid: generateId(),
-    agentId: event.agentId,
-    timestamp: Date.now(),
-    data: assistantMessage
-  };
-  const shouldPreserveToolCalls = stopReason === "tool_use";
-  return [
-    {
-      ...createInitialMessageAssemblerState(),
-      pendingToolCalls: shouldPreserveToolCalls ? state.pendingToolCalls : {}
-    },
-    [assistantEvent]
-  ];
-}
-var logger2$1 = createLogger("engine/stateEventProcessor");
-function createInitialStateEventProcessorContext() {
-  return {};
-}
-function generateId2() {
-  return `state_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-}
-var stateEventProcessor = (context, input) => {
-  logger2$1.debug(`[Stream Event] ${input.type}`, {
-    context,
-    eventData: "data" in input ? input.data : void 0
-  });
-  switch (input.type) {
-    case "message_start":
-      return handleMessageStart2(context, input);
-    case "message_delta":
-      return handleMessageDelta(context);
-    case "message_stop":
-      return handleMessageStop2(context, input);
-    case "text_content_block_start":
-      return handleTextContentBlockStart(context, input);
-    case "tool_use_content_block_start":
-      return handleToolUseContentBlockStart2(context, input);
-    case "tool_use_content_block_stop":
-      return handleToolUseContentBlockStop2(context);
-    case "tool_call":
-      return handleToolCall(context);
-    case "interrupted":
-      return handleInterrupted(context, input);
-    default:
-      logger2$1.debug(`[Stream Event] ${input.type} (unhandled)`);
-      return [context, []];
+  /**
+   * Get the number of middlewares
+   */
+  get size() {
+    return this.middlewares.length;
   }
 };
-function handleMessageStart2(context, event) {
-  const conversationStartEvent = {
-    type: "conversation_start",
-    uuid: generateId2(),
-    agentId: event.agentId,
-    timestamp: event.timestamp,
-    transition: {
-      reason: "conversation_started",
-      trigger: "message_start"
-    },
-    data: {
-      userMessage: {}
-      // Will be populated by higher-level component
-    }
-  };
-  return [context, [conversationStartEvent]];
-}
-function handleMessageDelta(context, _event) {
-  return [context, []];
-}
-function handleMessageStop2(context, event) {
-  const stopReason = event.data.stopReason;
-  logger2$1.debug("message_stop received", { stopReason });
-  if (stopReason === "tool_use") {
-    logger2$1.debug("Skipping conversation_end (tool_use in progress)");
-    return [context, []];
+var logger32 = createLogger("core/InterceptorChain");
+var InterceptorChain = class {
+  constructor(agentId) {
+    __publicField(this, "interceptors", []);
+    __publicField(this, "agentId");
+    this.agentId = agentId;
   }
-  const conversationEndEvent = {
-    type: "conversation_end",
-    uuid: generateId2(),
-    agentId: event.agentId,
-    timestamp: event.timestamp,
-    transition: {
-      reason: "conversation_completed",
-      trigger: "message_stop"
-    },
-    data: {
-      assistantMessage: {},
-      // Will be populated by higher-level component
-      durationMs: 0,
-      // Will be calculated by StateMachine or TurnTracker
-      durationApiMs: 0,
-      numTurns: 0,
-      result: "completed",
-      totalCostUsd: 0,
-      usage: {
-        input: 0,
-        output: 0
+  /**
+   * Add interceptor to the chain
+   *
+   * @param interceptor - Interceptor function
+   * @returns Unsubscribe function to remove the interceptor
+   */
+  intercept(interceptor) {
+    this.interceptors.push(interceptor);
+    return () => {
+      const index = this.interceptors.indexOf(interceptor);
+      if (index !== -1) {
+        this.interceptors.splice(index, 1);
+      }
+    };
+  }
+  /**
+   * Execute the interceptor chain
+   *
+   * @param event - Event to process
+   * @param finalHandler - Handler called at the end of the chain
+   */
+  execute(event, finalHandler) {
+    let index = 0;
+    const next = (e) => {
+      if (index < this.interceptors.length) {
+        const interceptor = this.interceptors[index++];
+        try {
+          interceptor(e, next);
+        } catch (error) {
+          logger32.error("Interceptor error", {
+            agentId: this.agentId,
+            eventType: e.type,
+            interceptorIndex: index - 1,
+            error
+          });
+          next(e);
+        }
+      } else {
+        finalHandler(e);
       }
+    };
+    next(event);
+  }
+  /**
+   * Clear all interceptors
+   */
+  clear() {
+    this.interceptors.length = 0;
+  }
+  /**
+   * Get the number of interceptors
+   */
+  get size() {
+    return this.interceptors.length;
+  }
+};
+var REACT_TO_EVENT_MAP = {
+  // Stream Layer Events
+  onMessageStart: "message_start",
+  onMessageDelta: "message_delta",
+  onMessageStop: "message_stop",
+  onTextContentBlockStart: "text_content_block_start",
+  onTextDelta: "text_delta",
+  onTextContentBlockStop: "text_content_block_stop",
+  onToolUseContentBlockStart: "tool_use_content_block_start",
+  onInputJsonDelta: "input_json_delta",
+  onToolUseContentBlockStop: "tool_use_content_block_stop",
+  onToolCall: "tool_call",
+  onToolResult: "tool_result",
+  // Message Layer Events
+  onUserMessage: "user_message",
+  onAssistantMessage: "assistant_message",
+  onToolCallMessage: "tool_call_message",
+  onToolResultMessage: "tool_result_message",
+  // Error Layer Events (independent, transportable via SSE)
+  onError: "error",
+  // Turn Layer Events
+  onTurnRequest: "turn_request",
+  onTurnResponse: "turn_response"
+};
+function mapReactHandlers(reactHandlers) {
+  const eventHandlerMap = {};
+  for (const [reactKey, eventKey] of Object.entries(REACT_TO_EVENT_MAP)) {
+    const handler = reactHandlers[reactKey];
+    if (handler) {
+      eventHandlerMap[eventKey] = handler;
     }
-  };
-  return [context, [conversationEndEvent]];
-}
-function handleTextContentBlockStart(context, event) {
-  const respondingEvent = {
-    type: "conversation_responding",
-    uuid: generateId2(),
-    agentId: event.agentId,
-    timestamp: Date.now(),
-    transition: {
-      reason: "assistant_responding",
-      trigger: "text_content_block_start"
-    },
-    data: {}
-  };
-  return [context, [respondingEvent]];
+  }
+  return eventHandlerMap;
 }
-function handleToolUseContentBlockStart2(context, event) {
-  const outputs = [];
-  const toolPlannedEvent = {
-    type: "tool_planned",
-    uuid: generateId2(),
-    agentId: event.agentId,
-    timestamp: event.timestamp,
-    data: {
-      id: event.data.id,
-      name: event.data.name,
-      input: {}
+var logger42 = createLogger("core/AgentInstance");
+var AgentInstance = class {
+  constructor(definition, context, engine, driver, sandbox) {
+    __publicField(this, "agentId");
+    __publicField(this, "definition");
+    __publicField(this, "context");
+    __publicField(this, "createdAt");
+    __publicField(this, "sandbox");
+    __publicField(this, "_lifecycle", "running");
+    __publicField(this, "engine");
+    __publicField(this, "driver");
+    __publicField(this, "stateMachine", new AgentStateMachine());
+    __publicField(this, "eventBus", new AgentEventBus());
+    __publicField(this, "errorClassifier");
+    __publicField(this, "middlewareChain", new MiddlewareChain());
+    __publicField(this, "interceptorChain");
+    __publicField(this, "readyHandlers", /* @__PURE__ */ new Set());
+    __publicField(this, "destroyHandlers", /* @__PURE__ */ new Set());
+    this.agentId = context.agentId;
+    this.definition = definition;
+    this.context = context;
+    this.engine = engine;
+    this.createdAt = context.createdAt;
+    this.sandbox = sandbox;
+    this.driver = driver;
+    this.errorClassifier = new AgentErrorClassifier(this.agentId);
+    this.interceptorChain = new InterceptorChain(this.agentId);
+    logger42.debug("AgentInstance created", {
+      agentId: this.agentId,
+      definitionName: definition.name,
+      driverName: this.driver.name
+    });
+  }
+  /**
+   * Current lifecycle state
+   */
+  get lifecycle() {
+    return this._lifecycle;
+  }
+  /**
+   * Current conversation state (delegated to StateMachine)
+   */
+  get state() {
+    return this.stateMachine.state;
+  }
+  /**
+   * Receive a message from user
+   *
+   * Runs through middleware chain before actual processing.
+   *
+   * Error Handling:
+   * - Errors are caught and converted to ErrorMessageEvent
+   * - Handlers receive the error event before re-throwing
+   * - This ensures UI can display errors
+   */
+  async receive(message) {
+    if (this._lifecycle === "destroyed") {
+      logger42.warn("Receive called on destroyed agent", { agentId: this.agentId });
+      const error = this.errorClassifier.create(
+        "system",
+        "AGENT_DESTROYED",
+        "Agent has been destroyed",
+        false
+      );
+      const errorEvent = this.errorClassifier.createEvent(error);
+      this.notifyHandlers(errorEvent);
+      throw new Error("[Agent] Agent has been destroyed");
     }
-  };
-  outputs.push(toolPlannedEvent);
-  const toolExecutingEvent = {
-    type: "tool_executing",
-    uuid: generateId2(),
-    agentId: event.agentId,
-    timestamp: event.timestamp,
-    transition: {
-      reason: "tool_planning_started",
-      trigger: "tool_use_content_block_start"
-    },
-    data: {}
-  };
-  outputs.push(toolExecutingEvent);
-  return [context, outputs];
-}
-function handleToolUseContentBlockStop2(context, _event) {
-  return [context, []];
-}
-function handleToolCall(context, _event) {
-  return [context, []];
-}
-function handleInterrupted(context, event) {
-  logger2$1.debug("interrupted event received", { reason: event.data.reason });
-  const conversationInterruptedEvent = {
-    type: "conversation_interrupted",
-    uuid: generateId2(),
-    agentId: event.agentId,
-    timestamp: event.timestamp,
-    transition: {
-      reason: event.data.reason,
-      trigger: "interrupted"
-    },
-    data: {
-      reason: event.data.reason
+    if (this.state !== "idle") {
+      logger42.warn("Receive called while agent is busy", {
+        agentId: this.agentId,
+        currentState: this.state
+      });
+      const error = this.errorClassifier.create(
+        "system",
+        "AGENT_BUSY",
+        `Agent is busy (state: ${this.state}), please wait for current operation to complete`,
+        false
+      );
+      const errorEvent = this.errorClassifier.createEvent(error);
+      this.notifyHandlers(errorEvent);
+      throw new Error(`[Agent] Agent is busy (state: ${this.state})`);
     }
-  };
-  return [context, [conversationInterruptedEvent]];
-}
-function createInitialTurnTrackerState() {
-  return {
-    pendingTurn: null,
-    costPerInputToken: 3e-6,
-    // $3 per 1M tokens
-    costPerOutputToken: 15e-6
-    // $15 per 1M tokens
-  };
-}
-function generateId3() {
-  return `turn_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-}
-function calculateCost(usage, costPerInputToken, costPerOutputToken) {
-  const inputCost = usage.input * costPerInputToken;
-  const outputCost = usage.output * costPerOutputToken;
-  return inputCost + outputCost;
-}
-var turnTrackerProcessor = (state, input) => {
-  switch (input.type) {
-    case "user_message":
-      return handleUserMessage(state, input);
-    case "message_stop":
-      return handleMessageStop3(state, input);
-    case "assistant_message":
-      return [state, []];
-    default:
-      return [state, []];
+    const userMessage = typeof message === "string" ? {
+      id: `msg_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
+      role: "user",
+      subtype: "user",
+      content: message,
+      timestamp: Date.now()
+    } : message;
+    logger42.debug("Receiving message", {
+      agentId: this.agentId,
+      messageId: userMessage.id
+    });
+    const userMessageEvent = {
+      uuid: `evt_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
+      type: "user_message",
+      agentId: this.agentId,
+      timestamp: Date.now(),
+      data: userMessage
+    };
+    this.presentOutput(userMessageEvent);
+    this.notifyHandlers(userMessageEvent);
+    await this.executeMiddlewareChain(userMessage);
   }
-};
-function handleUserMessage(state, event) {
-  const turnId = generateId3();
-  const pendingTurn = {
-    turnId,
-    userMessage: event.data,
-    requestedAt: event.timestamp
-  };
-  const turnRequestEvent = {
-    type: "turn_request",
-    uuid: generateId3(),
-    agentId: event.agentId,
-    timestamp: Date.now(),
-    turnId,
-    data: {
-      userMessage: event.data,
-      requestedAt: event.timestamp
+  /**
+   * Execute middleware chain and then process the message
+   */
+  async executeMiddlewareChain(message) {
+    await this.middlewareChain.execute(message, (msg) => this.doReceive(msg));
+  }
+  /**
+   * Process a single stream event through the engine
+   *
+   * Used by:
+   * - doReceive() - normal message flow
+   * - AgentInterrupter - interrupt event injection
+   *
+   * @param streamEvent - Stream event to process
+   */
+  processStreamEvent(streamEvent) {
+    const outputs = this.engine.process(this.agentId, streamEvent);
+    for (const output of outputs) {
+      this.presentOutput(output);
+    }
+    for (const output of outputs) {
+      this.notifyHandlers(output);
+    }
+  }
+  /**
+   * Actual message processing logic
+   *
+   * Coordinates the flow:
+   * 1. Driver receives message → produces StreamEvents
+   * 2. Engine processes events → produces outputs
+   * 3. Presenters handle outputs
+   * 4. Handlers receive outputs
+   */
+  async doReceive(userMessage) {
+    try {
+      logger42.debug("Processing message through driver", {
+        agentId: this.agentId,
+        messageId: userMessage.id
+      });
+      const queuedEvent = {
+        type: "conversation_queued",
+        uuid: `${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
+        agentId: this.agentId,
+        timestamp: Date.now(),
+        data: {
+          userMessage
+        }
+      };
+      this.notifyHandlers(queuedEvent);
+      const streamEvents = this.driver.receive(userMessage);
+      for await (const streamEvent of streamEvents) {
+        this.processStreamEvent(streamEvent);
+      }
+      logger42.debug("Message processing completed", {
+        agentId: this.agentId,
+        messageId: userMessage.id
+      });
+    } catch (error) {
+      const agentError = this.errorClassifier.classify(error);
+      const errorEvent = this.errorClassifier.createEvent(agentError);
+      logger42.error("Message processing failed", {
+        agentId: this.agentId,
+        messageId: userMessage.id,
+        errorCategory: agentError.category,
+        errorCode: agentError.code,
+        error
+      });
+      this.notifyHandlers(errorEvent);
+      throw error;
     }
-  };
-  return [
-    {
-      ...state,
-      pendingTurn
-    },
-    [turnRequestEvent]
-  ];
-}
-function handleMessageStop3(state, event) {
-  if (!state.pendingTurn) {
-    return [state, []];
   }
-  const stopReason = event.data.stopReason;
-  if (stopReason === "end_turn" || stopReason === "max_tokens" || stopReason === "stop_sequence") {
-    return completeTurn(state, event.agentId, event.timestamp);
+  /**
+   * Send output to all presenters
+   *
+   * Note: Presenters are no longer part of AgentDefinition.
+   * This is a placeholder for future presenter injection via Runtime or middleware.
+   */
+  presentOutput(_output) {
   }
-  return [state, []];
-}
-function completeTurn(state, agentId, completedAt) {
-  if (!state.pendingTurn) {
-    return [state, []];
+  on(typeOrHandlerOrMap, handler) {
+    if (typeof typeOrHandlerOrMap === "function") {
+      return this.eventBus.onAny(typeOrHandlerOrMap);
+    }
+    if (this.isEventHandlerMap(typeOrHandlerOrMap)) {
+      const unsubscribes = [];
+      for (const [eventType, eventHandler] of Object.entries(typeOrHandlerOrMap)) {
+        if (eventHandler) {
+          unsubscribes.push(this.eventBus.on(eventType, eventHandler));
+        }
+      }
+      return () => {
+        for (const unsub of unsubscribes) {
+          unsub();
+        }
+      };
+    }
+    const types = Array.isArray(typeOrHandlerOrMap) ? typeOrHandlerOrMap : [typeOrHandlerOrMap];
+    const h = handler;
+    return this.eventBus.on(types, h);
   }
-  const { turnId, requestedAt } = state.pendingTurn;
-  const duration = completedAt - requestedAt;
-  const usage = { input: 0, output: 0 };
-  const cost = calculateCost(usage, state.costPerInputToken, state.costPerOutputToken);
-  const turnResponseEvent = {
-    type: "turn_response",
-    uuid: generateId3(),
-    agentId,
-    timestamp: Date.now(),
-    turnId,
-    data: {
-      assistantMessage: {
-        id: generateId3(),
-        role: "assistant",
-        subtype: "assistant",
-        content: "",
-        timestamp: completedAt
-      },
-      respondedAt: completedAt,
-      durationMs: duration,
-      usage,
-      costUsd: cost
+  /**
+   * Check if the argument is an EventHandlerMap (object with event type keys)
+   */
+  isEventHandlerMap(arg) {
+    if (typeof arg !== "object" || arg === null || Array.isArray(arg)) {
+      return false;
     }
-  };
-  return [
-    {
-      ...state,
-      pendingTurn: null
-    },
-    [turnResponseEvent]
-  ];
-}
-var agentProcessor = combineProcessors({
-  messageAssembler: messageAssemblerProcessor,
-  stateEventProcessor,
-  turnTracker: turnTrackerProcessor
-});
-var createInitialAgentEngineState = combineInitialStates({
-  messageAssembler: createInitialMessageAssemblerState,
-  stateEventProcessor: createInitialStateEventProcessorContext,
-  turnTracker: createInitialTurnTrackerState
-});
-var logger3$1 = createLogger("engine/AgentEngine");
-var AgentEngine = class {
-  constructor() {
-    __publicField(this, "store");
-    this.store = new MemoryStore();
-    logger3$1.debug("AgentEngine initialized");
+    const keys = Object.keys(arg);
+    if (keys.length === 0) {
+      return false;
+    }
+    return keys.every((key) => {
+      const value = arg[key];
+      return value === void 0 || typeof value === "function";
+    });
   }
   /**
-   * Process a single stream event and return output events
+   * Subscribe to state changes (delegated to StateMachine)
    *
-   * This is the core Mealy Machine operation:
-   * process(agentId, event) → outputs[]
+   * @param handler - Callback receiving { prev, current } state change
+   * @returns Unsubscribe function
+   */
+  onStateChange(handler) {
+    return this.stateMachine.onStateChange(handler);
+  }
+  /**
+   * React-style fluent event subscription
    *
-   * @param agentId - The agent identifier (for state isolation)
-   * @param event - Stream event to process
-   * @returns Array of output events (state, message, turn events)
+   * Converts onXxx handlers to event type keys and delegates to on(handlers)
    */
-  process(agentId, event) {
-    const eventType = event.type || "unknown";
-    logger3$1.debug("Processing event", { agentId, eventType });
-    const isNewState = !this.store.has(agentId);
-    let state = this.store.get(agentId) ?? createInitialAgentEngineState();
-    if (isNewState) {
-      logger3$1.debug("Created initial state for agent", { agentId });
+  react(handlers) {
+    const eventHandlerMap = mapReactHandlers(handlers);
+    return this.on(eventHandlerMap);
+  }
+  /**
+   * Subscribe to agent ready event
+   *
+   * If already running, handler is called immediately.
+   */
+  onReady(handler) {
+    if (this._lifecycle === "running") {
+      try {
+        handler();
+      } catch (error) {
+        logger42.error("onReady handler error", {
+          agentId: this.agentId,
+          error
+        });
+      }
     }
-    const allOutputs = [];
-    allOutputs.push(event);
-    const [newState, outputs] = agentProcessor(state, event);
-    state = newState;
-    for (const output of outputs) {
-      allOutputs.push(output);
-      const [chainedState, chainedOutputs] = this.processChained(state, output);
-      state = chainedState;
-      allOutputs.push(...chainedOutputs);
+    this.readyHandlers.add(handler);
+    return () => {
+      this.readyHandlers.delete(handler);
+    };
+  }
+  /**
+   * Subscribe to agent destroy event
+   */
+  onDestroy(handler) {
+    this.destroyHandlers.add(handler);
+    return () => {
+      this.destroyHandlers.delete(handler);
+    };
+  }
+  /**
+   * Add middleware to intercept incoming messages
+   */
+  use(middleware) {
+    return this.middlewareChain.use(middleware);
+  }
+  /**
+   * Add interceptor to intercept outgoing events
+   */
+  intercept(interceptor) {
+    return this.interceptorChain.intercept(interceptor);
+  }
+  /**
+   * Interrupt - User-initiated stop
+   *
+   * Stops the current operation gracefully.
+   * Flow:
+   * 1. Call driver.interrupt() to abort active requests
+   * 2. Driver yields InterruptedStreamEvent
+   * 3. Event flows through engine pipeline
+   * 4. StateEventProcessor generates conversation_interrupted
+   * 5. StateMachine transitions to idle state
+   * 6. UI receives state change notification
+   */
+  interrupt() {
+    logger42.debug("User interrupt requested", { agentId: this.agentId, currentState: this.state });
+    this.driver.interrupt();
+  }
+  /**
+   * Destroy - Clean up resources
+   */
+  async destroy() {
+    logger42.debug("Destroying agent", { agentId: this.agentId });
+    for (const handler of this.destroyHandlers) {
+      try {
+        handler();
+      } catch (error) {
+        logger42.error("onDestroy handler error", {
+          agentId: this.agentId,
+          error
+        });
+      }
     }
-    this.store.set(agentId, state);
-    if (outputs.length > 0) {
-      logger3$1.debug("Produced outputs", {
-        agentId,
-        inputEvent: eventType,
-        outputCount: allOutputs.length,
-        processorOutputs: outputs.length
-      });
+    this._lifecycle = "destroyed";
+    this.stateMachine.reset();
+    this.eventBus.destroy();
+    this.readyHandlers.clear();
+    this.destroyHandlers.clear();
+    this.middlewareChain.clear();
+    this.interceptorChain.clear();
+    this.engine.clearState(this.agentId);
+    logger42.info("Agent destroyed", { agentId: this.agentId });
+  }
+  /**
+   * Notify all registered handlers
+   *
+   * Flow:
+   * 1. StateMachine processes StateEvents (for state transitions)
+   * 2. Interceptor chain can modify/filter events
+   * 3. EventBus emits to all subscribers
+   */
+  notifyHandlers(event) {
+    if (isStateEvent(event)) {
+      this.stateMachine.process(event);
     }
-    return allOutputs;
+    this.executeInterceptorChain(event);
+  }
+  /**
+   * Execute interceptor chain and then emit to EventBus
+   */
+  executeInterceptorChain(event) {
+    this.interceptorChain.execute(event, (e) => this.eventBus.emit(e));
+  }
+  /**
+   * Get the event consumer for external subscriptions
+   *
+   * Use this to expose event subscription without emit capability.
+   */
+  getEventConsumer() {
+    return this.eventBus.asConsumer();
+  }
+};
+var MemoryStore = class {
+  constructor() {
+    __publicField(this, "states", /* @__PURE__ */ new Map());
+  }
+  get(id) {
+    return this.states.get(id);
+  }
+  set(id, state) {
+    this.states.set(id, state);
+  }
+  delete(id) {
+    this.states.delete(id);
+  }
+  has(id) {
+    return this.states.has(id);
   }
   /**
-   * Process chained events recursively
-   *
-   * Some processors produce events that trigger other processors:
-   * - MessageAssembler produces MessageEvents
-   * - TurnTracker consumes MessageEvents to produce TurnEvents
+   * Clear all stored states
    */
-  processChained(state, event) {
-    const [newState, outputs] = agentProcessor(state, event);
-    if (outputs.length === 0) {
-      return [newState, []];
-    }
-    const allOutputs = [...outputs];
-    let currentState = newState;
-    for (const output of outputs) {
-      const [chainedState, chainedOutputs] = this.processChained(currentState, output);
-      currentState = chainedState;
-      allOutputs.push(...chainedOutputs);
-    }
-    return [currentState, allOutputs];
+  clear() {
+    this.states.clear();
   }
   /**
-   * Clear state for an agent
-   *
-   * Call this when an agent is destroyed to free memory.
+   * Get the number of stored states
    */
-  clearState(agentId) {
-    logger3$1.debug("Clearing state", { agentId });
-    this.store.delete(agentId);
+  get size() {
+    return this.states.size;
   }
   /**
-   * Check if state exists for an agent
+   * Get all stored IDs
    */
-  hasState(agentId) {
-    return this.store.has(agentId);
+  keys() {
+    return this.states.keys();
   }
 };
-var __defProp2 = Object.defineProperty;
-var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField2 = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
-var logger = createLogger("agentx/DefinitionManager");
-function generateMetaImageId(definitionName) {
-  return `meta_${definitionName}`;
+createLogger("engine/Mealy");
+function combineProcessors(processors) {
+  return (state, event) => {
+    const newState = {};
+    const allOutputs = [];
+    for (const key in processors) {
+      const processor = processors[key];
+      const subState = state[key];
+      const [newSubState, outputs] = processor(subState, event);
+      newState[key] = newSubState;
+      allOutputs.push(...outputs);
+    }
+    return [newState, allOutputs];
+  };
 }
-function toDefinitionRecord(definition) {
-  const now = /* @__PURE__ */ new Date();
+function combineInitialStates(initialStates) {
+  return () => {
+    const state = {};
+    for (const key in initialStates) {
+      state[key] = initialStates[key]();
+    }
+    return state;
+  };
+}
+function createInitialMessageAssemblerState() {
   return {
-    name: definition.name,
-    description: definition.description,
-    systemPrompt: definition.systemPrompt,
-    definition,
-    source: "code",
-    createdAt: now,
-    updatedAt: now
+    currentMessageId: null,
+    messageStartTime: null,
+    pendingContents: {},
+    pendingToolCalls: {}
   };
 }
-var DefinitionManagerImpl = class {
-  constructor(repository) {
-    this.repository = repository;
-    __publicField2(this, "cache", /* @__PURE__ */ new Map());
-  }
-  register(definition) {
-    if (this.cache.has(definition.name)) {
-      throw new Error(`Definition already exists: ${definition.name}`);
-    }
-    this.cache.set(definition.name, definition);
-    const definitionRecord = toDefinitionRecord(definition);
-    this.repository.saveDefinition(definitionRecord).catch((err) => {
-      logger.error("Failed to save definition", { name: definition.name, error: err });
-    });
-    const metaImageId = generateMetaImageId(definition.name);
-    const imageRecord = {
-      imageId: metaImageId,
-      type: "meta",
-      definitionName: definition.name,
-      parentImageId: null,
-      definition,
-      config: {},
-      messages: [],
-      createdAt: /* @__PURE__ */ new Date()
-    };
-    this.repository.saveImage(imageRecord).catch((err) => {
-      logger.error("Failed to save MetaImage", { definitionName: definition.name, error: err });
-    });
-    logger.info("Definition registered", {
-      name: definition.name,
-      metaImageId
-    });
-  }
-  get(name) {
-    return this.cache.get(name);
-  }
-  list() {
-    return Array.from(this.cache.values());
-  }
-  has(name) {
-    return this.cache.has(name);
-  }
-  unregister(name) {
-    const definition = this.cache.get(name);
-    if (!definition) {
-      return false;
-    }
-    this.cache.delete(name);
-    this.repository.deleteDefinition(name).catch((err) => {
-      logger.error("Failed to delete definition", { name, error: err });
-    });
-    const metaImageId = generateMetaImageId(name);
-    this.repository.deleteImage(metaImageId).catch((err) => {
-      logger.error("Failed to delete MetaImage", { definitionName: name, error: err });
-    });
-    logger.info("Definition unregistered", { name });
-    return true;
+function generateId() {
+  return `msg_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+var messageAssemblerProcessor = (state, input) => {
+  switch (input.type) {
+    case "message_start":
+      return handleMessageStart(state, input);
+    case "text_delta":
+      return handleTextDelta(state, input);
+    case "tool_use_content_block_start":
+      return handleToolUseContentBlockStart(state, input);
+    case "input_json_delta":
+      return handleInputJsonDelta(state, input);
+    case "tool_use_content_block_stop":
+      return handleToolUseContentBlockStop(state, input);
+    case "tool_result":
+      return handleToolResult(state, input);
+    case "message_stop":
+      return handleMessageStop(state, input);
+    default:
+      return [state, []];
   }
 };
-var logger2 = createLogger("agentx/ImageManager");
-function generateMetaImageId2(definitionName) {
-  return `meta_${definitionName}`;
+function handleMessageStart(state, event) {
+  return [
+    {
+      ...state,
+      currentMessageId: generateId(),
+      messageStartTime: event.timestamp,
+      pendingContents: {}
+    },
+    []
+  ];
 }
-function toAgentImage(record) {
-  const definition = record.definition;
-  if (record.type === "meta") {
-    const metaImage = {
-      type: "meta",
-      imageId: record.imageId,
-      definitionName: record.definitionName,
-      definition,
-      config: record.config,
-      messages: [],
-      createdAt: record.createdAt
-    };
-    return metaImage;
-  } else {
-    return {
-      type: "derived",
-      imageId: record.imageId,
-      parentImageId: record.parentImageId,
-      definitionName: record.definitionName,
-      definition,
-      config: record.config,
-      messages: record.messages,
-      createdAt: record.createdAt
-    };
-  }
+function handleTextDelta(state, event) {
+  const index = 0;
+  const existingContent = state.pendingContents[index];
+  const pendingContent = (existingContent == null ? void 0 : existingContent.type) === "text" ? {
+    ...existingContent,
+    textDeltas: [...existingContent.textDeltas || [], event.data.text]
+  } : {
+    type: "text",
+    index,
+    textDeltas: [event.data.text]
+  };
+  return [
+    {
+      ...state,
+      pendingContents: {
+        ...state.pendingContents,
+        [index]: pendingContent
+      }
+    },
+    []
+  ];
 }
-var ImageManagerImpl = class {
-  constructor(repository, containerManager, defaultContainerId) {
-    __publicField2(this, "repository");
-    __publicField2(this, "containerManager");
-    __publicField2(this, "defaultContainerId");
-    this.repository = repository;
-    this.containerManager = containerManager;
-    this.defaultContainerId = defaultContainerId;
-  }
-  async get(imageId) {
-    const record = await this.repository.findImageById(imageId);
-    if (!record) {
-      return void 0;
-    }
-    return toAgentImage(record);
-  }
-  async getMetaImage(definitionName) {
-    const metaImageId = generateMetaImageId2(definitionName);
-    const record = await this.repository.findImageById(metaImageId);
-    if (!record || record.type !== "meta") {
-      return void 0;
-    }
-    return toAgentImage(record);
-  }
-  async list() {
-    const records = await this.repository.findAllImages();
-    return records.map(toAgentImage);
+function handleToolUseContentBlockStart(state, event) {
+  const index = 1;
+  const pendingContent = {
+    type: "tool_use",
+    index,
+    toolId: event.data.id,
+    toolName: event.data.name,
+    toolInputJson: ""
+  };
+  return [
+    {
+      ...state,
+      pendingContents: {
+        ...state.pendingContents,
+        [index]: pendingContent
+      }
+    },
+    []
+  ];
+}
+function handleInputJsonDelta(state, event) {
+  const index = 1;
+  const existingContent = state.pendingContents[index];
+  if (!existingContent || existingContent.type !== "tool_use") {
+    return [state, []];
   }
-  async listByDefinition(definitionName) {
-    const allRecords = await this.repository.findAllImages();
-    const filtered = allRecords.filter((r) => r.definitionName === definitionName);
-    return filtered.map(toAgentImage);
+  const pendingContent = {
+    ...existingContent,
+    toolInputJson: (existingContent.toolInputJson || "") + event.data.partialJson
+  };
+  return [
+    {
+      ...state,
+      pendingContents: {
+        ...state.pendingContents,
+        [index]: pendingContent
+      }
+    },
+    []
+  ];
+}
+function handleToolUseContentBlockStop(state, event) {
+  const index = 1;
+  const pendingContent = state.pendingContents[index];
+  if (!pendingContent || pendingContent.type !== "tool_use") {
+    return [state, []];
   }
-  async exists(imageId) {
-    return this.repository.imageExists(imageId);
+  let toolInput = {};
+  try {
+    toolInput = pendingContent.toolInputJson ? JSON.parse(pendingContent.toolInputJson) : {};
+  } catch {
+    toolInput = {};
   }
-  async delete(imageId) {
-    const record = await this.repository.findImageById(imageId);
-    if (!record) {
-      return false;
+  const outputs = [];
+  const toolId = pendingContent.toolId;
+  const toolName = pendingContent.toolName;
+  const toolCallEvent = {
+    type: "tool_call",
+    uuid: generateId(),
+    agentId: event.agentId,
+    timestamp: Date.now(),
+    data: {
+      id: toolId,
+      name: toolName,
+      input: toolInput
     }
-    if (record.type === "meta") {
-      logger2.warn("Cannot delete MetaImage directly", { imageId });
-      return false;
+  };
+  outputs.push(toolCallEvent);
+  const toolCall = {
+    type: "tool-call",
+    id: toolId,
+    name: toolName,
+    input: toolInput
+  };
+  const toolCallMessage = {
+    id: generateId(),
+    role: "assistant",
+    subtype: "tool-call",
+    toolCall,
+    timestamp: Date.now()
+  };
+  const toolCallMessageEvent = {
+    type: "tool_call_message",
+    uuid: generateId(),
+    agentId: event.agentId,
+    timestamp: Date.now(),
+    data: toolCallMessage
+  };
+  outputs.push(toolCallMessageEvent);
+  const { [index]: _, ...remainingContents } = state.pendingContents;
+  return [
+    {
+      ...state,
+      pendingContents: remainingContents,
+      pendingToolCalls: {
+        ...state.pendingToolCalls,
+        [toolId]: { id: toolId, name: toolName }
+      }
+    },
+    outputs
+  ];
+}
+function handleToolResult(state, event) {
+  const { toolId, content, isError } = event.data;
+  const pendingToolCall = state.pendingToolCalls[toolId];
+  const toolName = (pendingToolCall == null ? void 0 : pendingToolCall.name) || "unknown";
+  const toolResult = {
+    type: "tool-result",
+    id: toolId,
+    name: toolName,
+    output: {
+      type: isError ? "error-text" : "text",
+      value: typeof content === "string" ? content : JSON.stringify(content)
     }
-    await this.repository.deleteImage(imageId);
-    logger2.info("Image deleted", { imageId });
-    return true;
+  };
+  const toolResultMessage = {
+    id: generateId(),
+    role: "tool",
+    subtype: "tool-result",
+    toolResult,
+    toolCallId: toolId,
+    timestamp: Date.now()
+  };
+  const toolResultMessageEvent = {
+    type: "tool_result_message",
+    uuid: generateId(),
+    agentId: event.agentId,
+    timestamp: Date.now(),
+    data: toolResultMessage
+  };
+  const { [toolId]: _, ...remainingToolCalls } = state.pendingToolCalls;
+  return [
+    {
+      ...state,
+      pendingToolCalls: remainingToolCalls
+    },
+    [toolResultMessageEvent]
+  ];
+}
+function handleMessageStop(state, event) {
+  if (!state.currentMessageId) {
+    return [state, []];
   }
-  async run(imageId, options) {
-    logger2.info("Running agent from image", { imageId, containerId: options == null ? void 0 : options.containerId });
-    const image = await this.get(imageId);
-    if (!image) {
-      throw new Error(`Image not found: ${imageId}`);
-    }
-    let containerId = (options == null ? void 0 : options.containerId) || this.defaultContainerId;
-    if (!containerId) {
-      const container = await this.containerManager.create();
-      containerId = container.containerId;
-      this.defaultContainerId = containerId;
-      logger2.debug("Auto-created default container", { containerId });
+  const textParts = [];
+  const sortedContents = Object.values(state.pendingContents).sort((a, b) => a.index - b.index);
+  for (const pending of sortedContents) {
+    if (pending.type === "text" && pending.textDeltas) {
+      textParts.push(pending.textDeltas.join(""));
     }
-    return this.containerManager.run(image, containerId);
-  }
-};
-var logger3 = createLogger("agentx/AgentManager");
-var AgentManager = class {
-  constructor(containerManager) {
-    this.containerManager = containerManager;
-  }
-  /**
-   * Get an existing agent by ID
-   */
-  get(agentId) {
-    return this.containerManager.getAgent(agentId);
-  }
-  /**
-   * Check if an agent exists
-   */
-  has(agentId) {
-    return this.containerManager.hasAgent(agentId);
-  }
-  /**
-   * List all agents
-   */
-  list() {
-    return this.containerManager.listAgents();
   }
-  /**
-   * Destroy an agent by ID
-   */
-  async destroy(agentId) {
-    logger3.debug("Destroying agent", { agentId });
-    await this.containerManager.destroyAgent(agentId);
-    logger3.info("Agent destroyed", { agentId });
+  const content = textParts.join("");
+  const stopReason = event.data.stopReason;
+  if (!content || content.trim().length === 0) {
+    const shouldPreserveToolCalls2 = stopReason === "tool_use";
+    return [
+      {
+        ...createInitialMessageAssemblerState(),
+        pendingToolCalls: shouldPreserveToolCalls2 ? state.pendingToolCalls : {}
+      },
+      []
+    ];
   }
-  /**
-   * Destroy all agents
-   */
-  async destroyAll() {
-    const agents = this.containerManager.listAgents();
-    logger3.debug("Destroying all agents", { count: agents.length });
-    await this.containerManager.destroyAllAgents();
-    logger3.info("All agents destroyed", { count: agents.length });
+  const assistantMessage = {
+    id: state.currentMessageId,
+    role: "assistant",
+    subtype: "assistant",
+    content,
+    timestamp: state.messageStartTime || Date.now(),
+    // Usage data is not available in message_stop event
+    // It would need to be tracked separately if needed
+    usage: void 0
+  };
+  const assistantEvent = {
+    type: "assistant_message",
+    uuid: generateId(),
+    agentId: event.agentId,
+    timestamp: Date.now(),
+    data: assistantMessage
+  };
+  const shouldPreserveToolCalls = stopReason === "tool_use";
+  return [
+    {
+      ...createInitialMessageAssemblerState(),
+      pendingToolCalls: shouldPreserveToolCalls ? state.pendingToolCalls : {}
+    },
+    [assistantEvent]
+  ];
+}
+var logger23 = createLogger("engine/stateEventProcessor");
+function createInitialStateEventProcessorContext() {
+  return {};
+}
+function generateId2() {
+  return `state_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+var stateEventProcessor = (context, input) => {
+  logger23.debug(`[Stream Event] ${input.type}`, {
+    context,
+    eventData: "data" in input ? input.data : void 0
+  });
+  switch (input.type) {
+    case "message_start":
+      return handleMessageStart2(context, input);
+    case "message_delta":
+      return handleMessageDelta(context);
+    case "message_stop":
+      return handleMessageStop2(context, input);
+    case "text_content_block_start":
+      return handleTextContentBlockStart(context, input);
+    case "tool_use_content_block_start":
+      return handleToolUseContentBlockStart2(context, input);
+    case "tool_use_content_block_stop":
+      return handleToolUseContentBlockStop2(context);
+    case "tool_call":
+      return handleToolCall(context);
+    case "interrupted":
+      return handleInterrupted(context, input);
+    default:
+      logger23.debug(`[Stream Event] ${input.type} (unhandled)`);
+      return [context, []];
   }
 };
-var logger4 = createLogger("agentx/SessionManager");
-function generateSessionId() {
-  const timestamp = Date.now().toString(36);
-  const random = Math.random().toString(36).substring(2, 8);
-  return `session_${timestamp}_${random}`;
+function handleMessageStart2(context, event) {
+  const conversationStartEvent = {
+    type: "conversation_start",
+    uuid: generateId2(),
+    agentId: event.agentId,
+    timestamp: event.timestamp,
+    transition: {
+      reason: "conversation_started",
+      trigger: "message_start"
+    },
+    data: {
+      userMessage: {}
+      // Will be populated by higher-level component
+    }
+  };
+  return [context, [conversationStartEvent]];
 }
-function generateImageId() {
-  const timestamp = Date.now().toString(36);
-  const random = Math.random().toString(36).substring(2, 8);
-  return `image_${timestamp}_${random}`;
+function handleMessageDelta(context, _event) {
+  return [context, []];
 }
-var SessionImpl = class _SessionImpl {
-  constructor(record, repository, containerManager, defaultContainerId) {
-    __publicField2(this, "sessionId");
-    __publicField2(this, "userId");
-    __publicField2(this, "imageId");
-    __publicField2(this, "createdAt");
-    __publicField2(this, "_title");
-    __publicField2(this, "_updatedAt");
-    __publicField2(this, "repository");
-    __publicField2(this, "containerManager");
-    __publicField2(this, "defaultContainerId");
-    this.sessionId = record.sessionId;
-    this.userId = record.userId;
-    this.imageId = record.imageId;
-    this._title = record.title;
-    this.createdAt = record.createdAt.getTime();
-    this._updatedAt = record.updatedAt.getTime();
-    this.repository = repository;
-    this.containerManager = containerManager;
-    this.defaultContainerId = defaultContainerId;
-  }
-  get title() {
-    return this._title;
-  }
-  get updatedAt() {
-    return this._updatedAt;
+function handleMessageStop2(context, event) {
+  const stopReason = event.data.stopReason;
+  logger23.debug("message_stop received", { stopReason });
+  if (stopReason === "tool_use") {
+    logger23.debug("Skipping conversation_end (tool_use in progress)");
+    return [context, []];
   }
-  async resume(options) {
-    logger4.info("Resuming agent from session", {
-      sessionId: this.sessionId,
-      imageId: this.imageId,
-      containerId: options == null ? void 0 : options.containerId
-    });
-    let containerId = (options == null ? void 0 : options.containerId) || this.defaultContainerId;
-    if (!containerId) {
-      const container = await this.containerManager.create();
-      containerId = container.containerId;
-      logger4.debug("Auto-created default container for session", {
-        containerId,
-        sessionId: this.sessionId
-      });
+  const conversationEndEvent = {
+    type: "conversation_end",
+    uuid: generateId2(),
+    agentId: event.agentId,
+    timestamp: event.timestamp,
+    transition: {
+      reason: "conversation_completed",
+      trigger: "message_stop"
+    },
+    data: {
+      assistantMessage: {},
+      // Will be populated by higher-level component
+      durationMs: 0,
+      // Will be calculated by StateMachine or TurnTracker
+      durationApiMs: 0,
+      numTurns: 0,
+      result: "completed",
+      totalCostUsd: 0,
+      usage: {
+        input: 0,
+        output: 0
+      }
     }
-    const agent = await this.containerManager.resume(this, containerId);
-    this.collect(agent);
-    return agent;
-  }
-  collect(agent) {
-    logger4.debug("Collecting messages from agent", {
-      sessionId: this.sessionId,
-      agentId: agent.agentId
-    });
-    const sessionId = this.sessionId;
-    const repository = this.repository;
-    const saveMessage = (data, role) => {
-      const record = {
-        messageId: data.id,
-        sessionId,
-        role,
-        content: data,
-        createdAt: new Date(data.timestamp ?? Date.now())
-      };
-      repository.saveMessage(record).catch((error) => {
-        logger4.error("Failed to persist message", {
-          sessionId,
-          messageId: record.messageId,
-          error
-        });
-      });
-    };
-    agent.on("user_message", (event) => saveMessage(event.data, "user"));
-    agent.on("assistant_message", (event) => saveMessage(event.data, "assistant"));
-    agent.on("tool_call_message", (event) => saveMessage(event.data, "tool"));
-    agent.on("tool_result_message", (event) => saveMessage(event.data, "tool"));
-  }
-  async getMessages() {
-    logger4.debug("Getting messages for session", { sessionId: this.sessionId });
-    const records = await this.repository.findMessagesBySessionId(this.sessionId);
-    return records.map((record) => record.content);
-  }
-  async fork() {
-    logger4.info("Forking session", { sessionId: this.sessionId });
-    const imageRecord = await this.repository.findImageById(this.imageId);
-    if (!imageRecord) {
-      throw new Error(`Image not found: ${this.imageId}`);
+  };
+  return [context, [conversationEndEvent]];
+}
+function handleTextContentBlockStart(context, event) {
+  const respondingEvent = {
+    type: "conversation_responding",
+    uuid: generateId2(),
+    agentId: event.agentId,
+    timestamp: Date.now(),
+    transition: {
+      reason: "assistant_responding",
+      trigger: "text_content_block_start"
+    },
+    data: {}
+  };
+  return [context, [respondingEvent]];
+}
+function handleToolUseContentBlockStart2(context, event) {
+  const outputs = [];
+  const toolPlannedEvent = {
+    type: "tool_planned",
+    uuid: generateId2(),
+    agentId: event.agentId,
+    timestamp: event.timestamp,
+    data: {
+      id: event.data.id,
+      name: event.data.name,
+      input: {}
     }
-    const newImageId = generateImageId();
-    const newImageRecord = {
-      imageId: newImageId,
-      type: "derived",
-      definitionName: imageRecord.definitionName,
-      parentImageId: imageRecord.imageId,
-      definition: imageRecord.definition,
-      config: imageRecord.config,
-      messages: [...imageRecord.messages],
-      // Copy messages
-      createdAt: /* @__PURE__ */ new Date()
-    };
-    await this.repository.saveImage(newImageRecord);
-    const newSessionId = generateSessionId();
-    const now = /* @__PURE__ */ new Date();
-    const newSessionRecord = {
-      sessionId: newSessionId,
-      userId: this.userId,
-      imageId: newImageId,
-      title: this._title ? `Fork of ${this._title}` : null,
-      createdAt: now,
-      updatedAt: now
-    };
-    await this.repository.saveSession(newSessionRecord);
-    logger4.info("Session forked", {
-      originalSessionId: this.sessionId,
-      newSessionId,
-      newImageId
-    });
-    return new _SessionImpl(
-      newSessionRecord,
-      this.repository,
-      this.containerManager,
-      this.defaultContainerId
-    );
-  }
-  async setTitle(title) {
-    logger4.debug("Setting session title", { sessionId: this.sessionId, title });
-    const now = /* @__PURE__ */ new Date();
-    await this.repository.saveSession({
-      sessionId: this.sessionId,
-      userId: this.userId,
-      imageId: this.imageId,
-      title,
-      createdAt: new Date(this.createdAt),
-      updatedAt: now
-    });
-    this._title = title;
-    this._updatedAt = now.getTime();
-    logger4.info("Session title updated", { sessionId: this.sessionId, title });
+  };
+  outputs.push(toolPlannedEvent);
+  const toolExecutingEvent = {
+    type: "tool_executing",
+    uuid: generateId2(),
+    agentId: event.agentId,
+    timestamp: event.timestamp,
+    transition: {
+      reason: "tool_planning_started",
+      trigger: "tool_use_content_block_start"
+    },
+    data: {}
+  };
+  outputs.push(toolExecutingEvent);
+  return [context, outputs];
+}
+function handleToolUseContentBlockStop2(context, _event) {
+  return [context, []];
+}
+function handleToolCall(context, _event) {
+  return [context, []];
+}
+function handleInterrupted(context, event) {
+  logger23.debug("interrupted event received", { reason: event.data.reason });
+  const conversationInterruptedEvent = {
+    type: "conversation_interrupted",
+    uuid: generateId2(),
+    agentId: event.agentId,
+    timestamp: event.timestamp,
+    transition: {
+      reason: event.data.reason,
+      trigger: "interrupted"
+    },
+    data: {
+      reason: event.data.reason
+    }
+  };
+  return [context, [conversationInterruptedEvent]];
+}
+function createInitialTurnTrackerState() {
+  return {
+    pendingTurn: null,
+    costPerInputToken: 3e-6,
+    // $3 per 1M tokens
+    costPerOutputToken: 15e-6
+    // $15 per 1M tokens
+  };
+}
+function generateId3() {
+  return `turn_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+function calculateCost(usage, costPerInputToken, costPerOutputToken) {
+  const inputCost = usage.input * costPerInputToken;
+  const outputCost = usage.output * costPerOutputToken;
+  return inputCost + outputCost;
+}
+var turnTrackerProcessor = (state, input) => {
+  switch (input.type) {
+    case "user_message":
+      return handleUserMessage(state, input);
+    case "message_stop":
+      return handleMessageStop3(state, input);
+    case "assistant_message":
+      return [state, []];
+    default:
+      return [state, []];
   }
 };
-var SessionManagerImpl = class {
-  constructor(repository, containerManager, defaultContainerId) {
-    __publicField2(this, "repository");
-    __publicField2(this, "containerManager");
-    __publicField2(this, "defaultContainerId");
-    this.repository = repository;
-    this.containerManager = containerManager;
-    this.defaultContainerId = defaultContainerId;
-  }
-  async create(imageId, userId) {
-    const sessionId = generateSessionId();
-    const now = /* @__PURE__ */ new Date();
-    const record = {
-      sessionId,
-      userId,
-      imageId,
-      title: null,
-      createdAt: now,
-      updatedAt: now
-    };
-    await this.repository.saveSession(record);
-    logger4.info("Session created", { sessionId, imageId, userId });
-    return new SessionImpl(record, this.repository, this.containerManager, this.defaultContainerId);
-  }
-  async get(sessionId) {
-    const record = await this.repository.findSessionById(sessionId);
-    if (!record) return void 0;
-    return new SessionImpl(record, this.repository, this.containerManager, this.defaultContainerId);
-  }
-  async has(sessionId) {
-    return this.repository.sessionExists(sessionId);
-  }
-  async list() {
-    const records = await this.repository.findAllSessions();
-    return records.map(
-      (r) => new SessionImpl(r, this.repository, this.containerManager, this.defaultContainerId)
-    );
-  }
-  async listByImage(imageId) {
-    const records = await this.repository.findSessionsByImageId(imageId);
-    return records.map(
-      (r) => new SessionImpl(r, this.repository, this.containerManager, this.defaultContainerId)
-    );
-  }
-  async listByUser(userId) {
-    const records = await this.repository.findSessionsByUserId(userId);
-    return records.map(
-      (r) => new SessionImpl(r, this.repository, this.containerManager, this.defaultContainerId)
-    );
+function handleUserMessage(state, event) {
+  const turnId = generateId3();
+  const pendingTurn = {
+    turnId,
+    userMessage: event.data,
+    requestedAt: event.timestamp
+  };
+  const turnRequestEvent = {
+    type: "turn_request",
+    uuid: generateId3(),
+    agentId: event.agentId,
+    timestamp: Date.now(),
+    turnId,
+    data: {
+      userMessage: event.data,
+      requestedAt: event.timestamp
+    }
+  };
+  return [
+    {
+      ...state,
+      pendingTurn
+    },
+    [turnRequestEvent]
+  ];
+}
+function handleMessageStop3(state, event) {
+  if (!state.pendingTurn) {
+    return [state, []];
   }
-  async destroy(sessionId) {
-    await this.repository.deleteSession(sessionId);
-    logger4.info("Session destroyed", { sessionId });
+  const stopReason = event.data.stopReason;
+  if (stopReason === "end_turn" || stopReason === "max_tokens" || stopReason === "stop_sequence") {
+    return completeTurn(state, event.agentId, event.timestamp);
   }
-  async destroyByImage(imageId) {
-    await this.repository.deleteSessionsByImageId(imageId);
-    logger4.info("Sessions destroyed by image", { imageId });
+  return [state, []];
+}
+function completeTurn(state, agentId, completedAt) {
+  if (!state.pendingTurn) {
+    return [state, []];
   }
-  async destroyAll() {
-    const sessions = await this.repository.findAllSessions();
-    for (const session of sessions) {
-      await this.repository.deleteSession(session.sessionId);
+  const { turnId, requestedAt } = state.pendingTurn;
+  const duration = completedAt - requestedAt;
+  const usage = { input: 0, output: 0 };
+  const cost = calculateCost(usage, state.costPerInputToken, state.costPerOutputToken);
+  const turnResponseEvent = {
+    type: "turn_response",
+    uuid: generateId3(),
+    agentId,
+    timestamp: Date.now(),
+    turnId,
+    data: {
+      assistantMessage: {
+        id: generateId3(),
+        role: "assistant",
+        subtype: "assistant",
+        content: "",
+        timestamp: completedAt
+      },
+      respondedAt: completedAt,
+      durationMs: duration,
+      usage,
+      costUsd: cost
     }
-    logger4.info("All sessions destroyed");
-  }
-};
-var logger5 = createLogger("agentx/ErrorManager");
-var ErrorManager = class {
+  };
+  return [
+    {
+      ...state,
+      pendingTurn: null
+    },
+    [turnResponseEvent]
+  ];
+}
+var agentProcessor = combineProcessors({
+  messageAssembler: messageAssemblerProcessor,
+  stateEventProcessor,
+  turnTracker: turnTrackerProcessor
+});
+var createInitialAgentEngineState = combineInitialStates({
+  messageAssembler: createInitialMessageAssemblerState,
+  stateEventProcessor: createInitialStateEventProcessorContext,
+  turnTracker: createInitialTurnTrackerState
+});
+var logger33 = createLogger("engine/AgentEngine");
+var AgentEngine = class {
   constructor() {
-    __publicField2(this, "handlers", /* @__PURE__ */ new Set());
+    __publicField(this, "store");
+    this.store = new MemoryStore();
+    logger33.debug("AgentEngine initialized");
   }
   /**
-   * Handle an error from any agent
+   * Process a single stream event and return output events
    *
-   * Called internally when an agent emits an error event.
-   * 1. Default logging (always)
-   * 2. Custom handlers (user-registered)
+   * This is the core Mealy Machine operation:
+   * process(agentId, event) → outputs[]
+   *
+   * @param agentId - The agent identifier (for state isolation)
+   * @param event - Stream event to process
+   * @returns Array of output events (state, message, turn events)
    */
-  handle(agentId, error, event) {
-    this.logError(agentId, error);
-    for (const handler of this.handlers) {
-      try {
-        handler.handle(agentId, error, event);
-      } catch (e) {
-        logger5.error("ErrorHandler failed", { error: e });
-      }
+  process(agentId, event) {
+    const eventType = event.type || "unknown";
+    logger33.debug("Processing event", { agentId, eventType });
+    const isNewState = !this.store.has(agentId);
+    let state = this.store.get(agentId) ?? createInitialAgentEngineState();
+    if (isNewState) {
+      logger33.debug("Created initial state for agent", { agentId });
+    }
+    const allOutputs = [];
+    allOutputs.push(event);
+    const [newState, outputs] = agentProcessor(state, event);
+    state = newState;
+    for (const output of outputs) {
+      allOutputs.push(output);
+      const [chainedState, chainedOutputs] = this.processChained(state, output);
+      state = chainedState;
+      allOutputs.push(...chainedOutputs);
+    }
+    this.store.set(agentId, state);
+    if (outputs.length > 0) {
+      logger33.debug("Produced outputs", {
+        agentId,
+        inputEvent: eventType,
+        outputCount: allOutputs.length,
+        processorOutputs: outputs.length
+      });
     }
+    return allOutputs;
   }
   /**
-   * Add a custom error handler
+   * Process chained events recursively
+   *
+   * Some processors produce events that trigger other processors:
+   * - MessageAssembler produces MessageEvents
+   * - TurnTracker consumes MessageEvents to produce TurnEvents
    */
-  addHandler(handler) {
-    this.handlers.add(handler);
-    return () => {
-      this.handlers.delete(handler);
-    };
+  processChained(state, event) {
+    const [newState, outputs] = agentProcessor(state, event);
+    if (outputs.length === 0) {
+      return [newState, []];
+    }
+    const allOutputs = [...outputs];
+    let currentState = newState;
+    for (const output of outputs) {
+      const [chainedState, chainedOutputs] = this.processChained(currentState, output);
+      currentState = chainedState;
+      allOutputs.push(...chainedOutputs);
+    }
+    return [currentState, allOutputs];
   }
   /**
-   * Remove an error handler
+   * Clear state for an agent
+   *
+   * Call this when an agent is destroyed to free memory.
    */
-  removeHandler(handler) {
-    this.handlers.delete(handler);
+  clearState(agentId) {
+    logger33.debug("Clearing state", { agentId });
+    this.store.delete(agentId);
   }
   /**
-   * Default error logging
+   * Check if state exists for an agent
    */
-  logError(agentId, error) {
-    const prefix = `[${agentId}] ${error.category}/${error.code}`;
-    if (error.severity === "fatal") {
-      logger5.error(`${prefix}: ${error.message}`, { error });
-    } else if (error.severity === "error") {
-      logger5.error(`${prefix}: ${error.message}`);
-    } else {
-      logger5.warn(`${prefix}: ${error.message}`);
-    }
+  hasState(agentId) {
+    return this.store.has(agentId);
   }
 };
-var logger6 = createLogger("agentx/ContainerManager");
+var logger7 = createLogger("agentx/ContainerManager");
 function generateContainerId() {
   const timestamp = Date.now().toString(36);
   const random = Math.random().toString(36).substring(2, 8);
@@ -2770,10 +2900,10 @@ function generateAgentId() {
 }
 var ContainerManagerImpl = class {
   constructor(runtime, repository) {
-    __publicField2(this, "agents", /* @__PURE__ */ new Map());
-    __publicField2(this, "engine");
-    __publicField2(this, "runtime");
-    __publicField2(this, "repository");
+    __publicField(this, "agents", /* @__PURE__ */ new Map());
+    __publicField(this, "engine");
+    __publicField(this, "runtime");
+    __publicField(this, "repository");
     this.runtime = runtime;
     this.repository = repository;
     this.engine = new AgentEngine();
@@ -2789,7 +2919,7 @@ var ContainerManagerImpl = class {
       config: config2
     };
     await this.repository.saveContainer(record);
-    logger6.info("Container created", { containerId });
+    logger7.info("Container created", { containerId });
     return record;
   }
   async get(containerId) {
@@ -2804,7 +2934,7 @@ var ContainerManagerImpl = class {
       return false;
     }
     await this.repository.deleteContainer(containerId);
-    logger6.info("Container deleted", { containerId });
+    logger7.info("Container deleted", { containerId });
     return true;
   }
   async exists(containerId) {
@@ -2812,7 +2942,7 @@ var ContainerManagerImpl = class {
   }
   // ==================== Agent Runtime ====================
   async run(image, containerId) {
-    logger6.info("Running agent from image", {
+    logger7.info("Running agent from image", {
       imageId: image.imageId,
       containerId
     });
@@ -2834,7 +2964,7 @@ var ContainerManagerImpl = class {
     const driver = this.runtime.createDriver(image.definition, context, sandbox);
     const agent = new AgentInstance(image.definition, context, this.engine, driver, sandbox);
     this.agents.set(agentId, agent);
-    logger6.info("Agent started", {
+    logger7.info("Agent started", {
       agentId,
       imageId: image.imageId,
       containerId,
@@ -2843,7 +2973,7 @@ var ContainerManagerImpl = class {
     return agent;
   }
   async resume(session, containerId) {
-    logger6.info("Resuming agent from session", {
+    logger7.info("Resuming agent from session", {
       sessionId: session.sessionId,
       imageId: session.imageId,
       containerId
@@ -2871,7 +3001,7 @@ var ContainerManagerImpl = class {
     const driver = this.runtime.createDriver(definition, context, sandbox);
     const agent = new AgentInstance(definition, context, this.engine, driver, sandbox);
     this.agents.set(agentId, agent);
-    logger6.info("Agent resumed", {
+    logger7.info("Agent resumed", {
       agentId,
       sessionId: session.sessionId,
       imageId: session.imageId,
@@ -2882,13 +3012,13 @@ var ContainerManagerImpl = class {
   async destroyAgent(agentId) {
     const agent = this.agents.get(agentId);
     if (!agent) {
-      logger6.warn("Agent not found for destroy", { agentId });
+      logger7.warn("Agent not found for destroy", { agentId });
       return;
     }
-    logger6.debug("Destroying agent", { agentId });
+    logger7.debug("Destroying agent", { agentId });
     await agent.destroy();
     this.agents.delete(agentId);
-    logger6.info("Agent destroyed", { agentId });
+    logger7.info("Agent destroyed", { agentId });
   }
   getAgent(agentId) {
     return this.agents.get(agentId);
@@ -2901,14 +3031,14 @@ var ContainerManagerImpl = class {
   }
   async destroyAllAgents() {
     const agentIds = Array.from(this.agents.keys());
-    logger6.debug("Destroying all agents", { count: agentIds.length });
+    logger7.debug("Destroying all agents", { count: agentIds.length });
     await Promise.all(agentIds.map((id) => this.destroyAgent(id)));
-    logger6.info("All agents destroyed", { count: agentIds.length });
+    logger7.info("All agents destroyed", { count: agentIds.length });
   }
 };
-var logger7 = createLogger("agentx/AgentX");
+var logger8 = createLogger("agentx/AgentX");
 function createAgentX(runtime, options) {
-  logger7.info("Creating AgentX instance", { runtime: runtime.name });
+  logger8.info("Creating AgentX instance", { runtime: runtime.name });
   if (!runtime.repository) {
     throw new Error("Runtime must have a repository for persistence");
   }
@@ -2919,7 +3049,7 @@ function createAgentX(runtime, options) {
   const agentManager = new AgentManager(containerManager);
   const imageManager = new ImageManagerImpl(repository, containerManager, options == null ? void 0 : options.containerId);
   const sessionManager = new SessionManagerImpl(repository, containerManager, options == null ? void 0 : options.containerId);
-  logger7.debug("AgentX instance created", { runtime: runtime.name });
+  logger8.debug("AgentX instance created", { runtime: runtime.name });
   return {
     mode: "local",
     containers: containerManager,
@@ -2933,9 +3063,9 @@ function createAgentX(runtime, options) {
 createLogger("agentx/RemoteRepository");
 var _BrowserLogger = class _BrowserLogger2 {
   constructor(name, options = {}) {
-    __publicField2(this, "name");
-    __publicField2(this, "level");
-    __publicField2(this, "collapsed");
+    __publicField(this, "name");
+    __publicField(this, "level");
+    __publicField(this, "collapsed");
     this.name = name;
     this.level = options.level ?? LogLevel.INFO;
     this.collapsed = options.collapsed ?? true;
@@ -3013,7 +3143,7 @@ var _BrowserLogger = class _BrowserLogger2 {
     }
   }
 };
-__publicField2(_BrowserLogger, "STYLES", {
+__publicField(_BrowserLogger, "STYLES", {
   DEBUG: "color: #6B7280; font-weight: normal;",
   // gray
   INFO: "color: #10B981; font-weight: normal;",
@@ -3028,7 +3158,7 @@ __publicField2(_BrowserLogger, "STYLES", {
   // purple
   MESSAGE: "color: inherit; font-weight: normal;"
 });
-__publicField2(_BrowserLogger, "BADGE_STYLES", {
+__publicField(_BrowserLogger, "BADGE_STYLES", {
   DEBUG: "background: #E5E7EB; color: #374151; padding: 2px 6px; border-radius: 3px; font-size: 11px;",
   INFO: "background: #D1FAE5; color: #065F46; padding: 2px 6px; border-radius: 3px; font-size: 11px;",
   WARN: "background: #FEF3C7; color: #92400E; padding: 2px 6px; border-radius: 3px; font-size: 11px;",
@@ -3038,4 +3168,4 @@ createLogger("agentx/RemoteAgentIdResolver");
 export {
   createAgentX
 };
-//# sourceMappingURL=index-CB5mSMCj.js.map
+//# sourceMappingURL=index-CRELszoW.js.map