agentxjs 0.0.3 → 0.0.5

package/dist/index.js

@@ -1,8 +1,7 @@
-import { createLogger, setLoggerFactory } from '@agentxjs/common';
+import { LogLevel, isStateEvent, STREAM_EVENT_TYPE_NAMES } from '@agentxjs/types';
 import ky from 'ky';
-import { AgentInstance } from '@agentxjs/agent';
-import { AgentEngine } from '@agentxjs/engine';
-import { LogLevel, STREAM_EVENT_TYPE_NAMES } from '@agentxjs/types';
+import { Subject } from 'rxjs';
+import { filter, take } from 'rxjs/operators';
 
 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;
@@ -17,6 +16,170 @@ function defineAgent(input) {
     systemPrompt
   };
 }
+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;
+  }
+  debug(message, context) {
+    if (this.isDebugEnabled()) {
+      this.log("DEBUG", message, context);
+    }
+  }
+  info(message, context) {
+    if (this.isInfoEnabled()) {
+      this.log("INFO", message, context);
+    }
+  }
+  warn(message, context) {
+    if (this.isWarnEnabled()) {
+      this.log("WARN", message, context);
+    }
+  }
+  error(message, context) {
+    if (this.isErrorEnabled()) {
+      if (message instanceof Error) {
+        this.log("ERROR", message.message, { ...context, stack: message.stack });
+      } else {
+        this.log("ERROR", message, context);
+      }
+    }
+  }
+  isDebugEnabled() {
+    return this.level <= LogLevel.DEBUG;
+  }
+  isInfoEnabled() {
+    return this.level <= LogLevel.INFO;
+  }
+  isWarnEnabled() {
+    return this.level <= LogLevel.WARN;
+  }
+  isErrorEnabled() {
+    return this.level <= LogLevel.ERROR;
+  }
+  log(level, message, context) {
+    const parts = [];
+    if (this.timestamps) {
+      parts.push((/* @__PURE__ */ new Date()).toISOString());
+    }
+    if (this.colors) {
+      const color = _ConsoleLogger2.COLORS[level];
+      parts.push(`${color}${level.padEnd(5)}${_ConsoleLogger2.COLORS.RESET}`);
+    } else {
+      parts.push(level.padEnd(5));
+    }
+    parts.push(`[${this.name}]`);
+    parts.push(message);
+    const logLine = parts.join(" ");
+    const consoleMethod = this.getConsoleMethod(level);
+    if (context && Object.keys(context).length > 0) {
+      consoleMethod(logLine, context);
+    } else {
+      consoleMethod(logLine);
+    }
+  }
+  getConsoleMethod(level) {
+    switch (level) {
+      case "DEBUG":
+        return console.debug.bind(console);
+      case "INFO":
+        return console.info.bind(console);
+      case "WARN":
+        return console.warn.bind(console);
+      case "ERROR":
+        return console.error.bind(console);
+      default:
+        return console.log.bind(console);
+    }
+  }
+  isNodeEnvironment() {
+    return typeof process !== "undefined" && process.versions?.node !== void 0;
+  }
+};
+__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(config) {
+    this.config = { ...this.config, ...config };
+  }
+  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);
+      }
+      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()
+    };
+  }
+  static createLogger(name) {
+    if (externalFactory) {
+      return externalFactory.getLogger(name);
+    }
+    if (this.config.defaultImplementation) {
+      return this.config.defaultImplementation(name);
+    }
+    return new ConsoleLogger(name, {
+      level: this.config.defaultLevel,
+      ...this.config.consoleOptions
+    });
+  }
+};
+__publicField2(LoggerFactoryImpl, "loggers", /* @__PURE__ */ new Map());
+__publicField2(LoggerFactoryImpl, "config", {
+  defaultLevel: LogLevel.INFO
+});
+function setLoggerFactory(factory) {
+  externalFactory = factory;
+  LoggerFactoryImpl.reset();
+  externalFactory = factory;
+}
+function createLogger(name) {
+  return LoggerFactoryImpl.getLogger(name);
+}
+
+// src/managers/definition/DefinitionManagerImpl.ts
 var logger = createLogger("agentx/DefinitionManager");
 function generateMetaImageId(definitionName) {
   return `meta_${definitionName}`;
@@ -93,6 +256,8 @@ var DefinitionManagerImpl = class {
     return true;
   }
 };
+
+// src/managers/image/ImageManagerImpl.ts
 var logger2 = createLogger("agentx/ImageManager");
 function generateMetaImageId2(definitionName) {
   return `meta_${definitionName}`;
@@ -188,6 +353,8 @@ var ImageManagerImpl = class {
     return this.containerManager.run(image, containerId);
   }
 };
+
+// src/managers/agent/AgentManager.ts
 var logger3 = createLogger("agentx/AgentManager");
 var AgentManager = class {
   constructor(containerManager) {
@@ -229,6 +396,8 @@ var AgentManager = class {
     logger3.info("All agents destroyed", { count: agents.length });
   }
 };
+
+// src/managers/session/SessionManagerImpl.ts
 var logger4 = createLogger("agentx/SessionManager");
 function generateSessionId() {
   const timestamp = Date.now().toString(36);
@@ -443,6 +612,8 @@ var SessionManagerImpl = class {
     logger4.info("All sessions destroyed");
   }
 };
+
+// src/managers/error/ErrorManager.ts
 var logger5 = createLogger("agentx/ErrorManager");
 var ErrorManager = class {
   constructor() {
@@ -524,7 +695,1544 @@ function createHttpClient(options) {
     }
   });
 }
-var logger6 = createLogger("agentx/ContainerManager");
+var logger6 = 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;
+  }
+  /**
+   * 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;
+      logger6.debug("State transition", {
+        eventType: event.type,
+        from: prev,
+        to: next
+      });
+      this.notifyHandlers({ prev, current: next });
+    }
+  }
+  /**
+   * 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();
+  }
+  /**
+   * 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;
+    }
+  }
+  /**
+   * Notify all registered handlers of state change
+   */
+  notifyHandlers(change) {
+    for (const handler of this.handlers) {
+      try {
+        handler(change);
+      } catch (error) {
+        logger6.error("State change handler error", {
+          from: change.prev,
+          to: change.current,
+          error
+        });
+      }
+    }
+  }
+};
+var logger22 = 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);
+  }
+  // ===== Producer Methods =====
+  emit(event) {
+    if (this.isDestroyed) {
+      logger22.warn("Emit called on destroyed EventBus", { eventType: event.type });
+      return;
+    }
+    this.subject.next(event);
+  }
+  emitBatch(events) {
+    for (const event of events) {
+      this.emit(event);
+    }
+  }
+  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());
+  }
+  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 observable = this.subject.pipe(filter((e) => e.type === type));
+    if (filter$1) {
+      observable = observable.pipe(filter(filter$1));
+    }
+    if (once) {
+      observable = observable.pipe(take(1));
+    }
+    const subscription = observable.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 observable = this.subject.asObservable();
+    if (filter$1) {
+      observable = observable.pipe(filter(filter$1));
+    }
+    if (once) {
+      observable = observable.pipe(take(1));
+    }
+    const subscription = observable.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;
+  }
+  /**
+   * 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) {
+        logger22.error("Event handler error", { eventType: type, error });
+      }
+    }
+  }
+  /**
+   * 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) {
+        logger22.error("Global event handler error", { eventType: event.type, error });
+      }
+    }
+  }
+};
+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);
+    }
+    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);
+    }
+    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);
+  }
+  /**
+   * 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
+    };
+  }
+  /**
+   * 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
+      }
+    };
+  }
+};
+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);
+      }
+    };
+  }
+  /**
+   * 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);
+  }
+  /**
+   * Clear all middlewares
+   */
+  clear() {
+    this.middlewares.length = 0;
+  }
+  /**
+   * Get the number of middlewares
+   */
+  get size() {
+    return this.middlewares.length;
+  }
+};
+var logger32 = 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) {
+          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 eventHandlerMap;
+}
+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");
+    /**
+     * 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);
+    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");
+    }
+    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})`);
+    }
+    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);
+  }
+  /**
+   * 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;
+    }
+  }
+  /**
+   * 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;
+    }
+    return keys.every((key) => {
+      const value = arg[key];
+      return value === void 0 || typeof value === "function";
+    });
+  }
+  /**
+   * Subscribe to state changes (delegated to StateMachine)
+   *
+   * @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) {
+        logger42.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);
+    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._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);
+    }
+    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();
+  }
+};
+
+// ../engine/dist/index.js
+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);
+  }
+  /**
+   * Clear all stored states
+   */
+  clear() {
+    this.states.clear();
+  }
+  /**
+   * Get the number of stored states
+   */
+  get size() {
+    return this.states.size;
+  }
+  /**
+   * Get all stored IDs
+   */
+  keys() {
+    return this.states.keys();
+  }
+};
+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 combineInitialStates(initialStates) {
+  return () => {
+    const state = {};
+    for (const key in initialStates) {
+      state[key] = initialStates[key]();
+    }
+    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, []];
+  }
+};
+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?.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, []];
+  }
+  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, []];
+  }
+  let toolInput = {};
+  try {
+    toolInput = pendingContent.toolInputJson ? JSON.parse(pendingContent.toolInputJson) : {};
+  } catch {
+    toolInput = {};
+  }
+  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 }
+      }
+    },
+    outputs
+  ];
+}
+function handleToolResult(state, event) {
+  const { toolId, content, isError } = event.data;
+  const pendingToolCall = state.pendingToolCalls[toolId];
+  const toolName = 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(""));
+    }
+  }
+  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 : {}
+      },
+      []
+    ];
+  }
+  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, []];
+  }
+};
+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;
+  logger23.debug("message_stop received", { stopReason });
+  if (stopReason === "tool_use") {
+    logger23.debug("Skipping conversation_end (tool_use in progress)");
+    return [context, []];
+  }
+  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
+      }
+    }
+  };
+  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: {}
+    }
+  };
+  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, []];
+  }
+};
+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, []];
+  }
+  const stopReason = event.data.stopReason;
+  if (stopReason === "end_turn" || stopReason === "max_tokens" || stopReason === "stop_sequence") {
+    return completeTurn(state, event.agentId, event.timestamp);
+  }
+  return [state, []];
+}
+function completeTurn(state, agentId, completedAt) {
+  if (!state.pendingTurn) {
+    return [state, []];
+  }
+  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
+    }
+  };
+  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() {
+    __publicField(this, "store");
+    this.store = new MemoryStore();
+    logger33.debug("AgentEngine initialized");
+  }
+  /**
+   * Process a single stream event and return output events
+   *
+   * 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)
+   */
+  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;
+  }
+  /**
+   * Process chained events recursively
+   *
+   * Some processors produce events that trigger other processors:
+   * - MessageAssembler produces MessageEvents
+   * - TurnTracker consumes MessageEvents to produce TurnEvents
+   */
+  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 state for an agent
+   *
+   * Call this when an agent is destroyed to free memory.
+   */
+  clearState(agentId) {
+    logger33.debug("Clearing state", { agentId });
+    this.store.delete(agentId);
+  }
+  /**
+   * Check if state exists for an agent
+   */
+  hasState(agentId) {
+    return this.store.has(agentId);
+  }
+};
+
+// src/container/ContainerManagerImpl.ts
+var logger7 = createLogger("agentx/ContainerManager");
 function generateContainerId() {
   const timestamp = Date.now().toString(36);
   const random = Math.random().toString(36).substring(2, 8);
@@ -556,7 +2264,7 @@ var ContainerManagerImpl = class {
       config
     };
     await this.repository.saveContainer(record);
-    logger6.info("Container created", { containerId });
+    logger7.info("Container created", { containerId });
     return record;
   }
   async get(containerId) {
@@ -571,7 +2279,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) {
@@ -579,7 +2287,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
     });
@@ -601,7 +2309,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,
@@ -610,7 +2318,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
@@ -638,7 +2346,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,
@@ -649,13 +2357,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);
@@ -668,16 +2376,16 @@ 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 });
   }
 };
 
 // src/AgentX.ts
-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");
   }
@@ -688,7 +2396,7 @@ function createAgentX(runtime, options) {
   const agentManager = new AgentManager(containerManager);
   const imageManager = new ImageManagerImpl(repository, containerManager, options?.containerId);
   const sessionManager = new SessionManagerImpl(repository, containerManager, options?.containerId);
-  logger7.debug("AgentX instance created", { runtime: runtime.name });
+  logger8.debug("AgentX instance created", { runtime: runtime.name });
   return {
     mode: "local",
     containers: containerManager,
@@ -862,7 +2570,9 @@ function createSSEDriver(config) {
     }
   };
 }
-var logger8 = createLogger("agentx/RemoteRepository");
+
+// src/runtime/sse/repository/RemoteRepository.ts
+var logger9 = createLogger("agentx/RemoteRepository");
 var RemoteRepository = class {
   constructor(options) {
     __publicField(this, "client");
@@ -870,7 +2580,7 @@ var RemoteRepository = class {
       baseUrl: options.serverUrl,
       headers: options.headers
     });
-    logger8.debug("RemoteRepository created", { serverUrl: options.serverUrl });
+    logger9.debug("RemoteRepository created", { serverUrl: options.serverUrl });
   }
   // ==================== Definition ====================
   async saveDefinition(record) {
@@ -975,7 +2685,7 @@ var RemoteRepository = class {
    * Browser-side calls this but it does nothing to avoid duplicate saves.
    */
   async saveMessage(_record) {
-    logger8.debug("saveMessage called (noop in browser)");
+    logger9.debug("saveMessage called (noop in browser)");
   }
   async findMessageById(messageId) {
     try {
@@ -1183,12 +2893,14 @@ var BrowserLoggerFactory = class {
     if (this.loggers.has(name)) {
       return this.loggers.get(name);
     }
-    const logger10 = new BrowserLogger(name, this.options);
-    this.loggers.set(name, logger10);
-    return logger10;
+    const logger11 = new BrowserLogger(name, this.options);
+    this.loggers.set(name, logger11);
+    return logger11;
   }
 };
-var logger9 = createLogger("agentx/RemoteAgentIdResolver");
+
+// src/runtime/sse/RemoteAgentIdResolver.ts
+var logger10 = createLogger("agentx/RemoteAgentIdResolver");
 var RemoteAgentIdResolver = class {
   constructor(options) {
     __publicField(this, "client");
@@ -1198,19 +2910,19 @@ var RemoteAgentIdResolver = class {
     });
   }
   async resolveForRun(imageId, containerId) {
-    logger9.debug("Resolving agent ID for run", { imageId, containerId });
+    logger10.debug("Resolving agent ID for run", { imageId, containerId });
     const response = await this.client.post(`images/${imageId}/run`, {
       json: { containerId }
     }).json();
-    logger9.info("Agent ID resolved for run", { imageId, agentId: response.agentId });
+    logger10.info("Agent ID resolved for run", { imageId, agentId: response.agentId });
     return response.agentId;
   }
   async resolveForResume(sessionId, containerId) {
-    logger9.debug("Resolving agent ID for resume", { sessionId, containerId });
+    logger10.debug("Resolving agent ID for resume", { sessionId, containerId });
     const response = await this.client.post(`sessions/${sessionId}/resume`, {
       json: { containerId }
     }).json();
-    logger9.info("Agent ID resolved for resume", { sessionId, agentId: response.agentId });
+    logger10.info("Agent ID resolved for resume", { sessionId, agentId: response.agentId });
     return response.agentId;
   }
 };