@agentxjs/core 1.9.3-dev → 1.9.6-dev

package/dist/chunk-AT5P47YA.js

@@ -0,0 +1,543 @@
+import {
+  MemoryStore,
+  combineInitialStates,
+  combineProcessors
+} from "./chunk-EKHT54KN.js";
+import {
+  createInitialMessageAssemblerState,
+  createInitialStateEventProcessorContext,
+  createInitialTurnTrackerState,
+  messageAssemblerProcessor,
+  stateEventProcessor,
+  turnTrackerProcessor
+} from "./chunk-I7GYR3MN.js";
+import {
+  isStateEvent
+} from "./chunk-K6WXQ2RW.js";
+import {
+  isDriveableEvent
+} from "./chunk-E5FPOAPO.js";
+
+// src/agent/engine/AgentProcessor.ts
+var agentProcessor = combineProcessors({
+  messageAssembler: messageAssemblerProcessor,
+  stateEventProcessor,
+  turnTracker: turnTrackerProcessor
+});
+var createInitialAgentEngineState = combineInitialStates({
+  messageAssembler: createInitialMessageAssemblerState,
+  stateEventProcessor: createInitialStateEventProcessorContext,
+  turnTracker: createInitialTurnTrackerState
+});
+
+// src/agent/engine/MealyMachine.ts
+import { createLogger } from "commonxjs/logger";
+var logger = createLogger("engine/MealyMachine");
+var MealyMachine = class {
+  store;
+  constructor() {
+    this.store = new MemoryStore();
+    logger.debug("MealyMachine initialized");
+  }
+  /**
+   * Process a single driveable 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 - StreamEvent to process
+   * @returns Array of output events (state, message, turn events)
+   */
+  process(agentId, event) {
+    const eventType = event.type || "unknown";
+    logger.debug("Processing event", { agentId, eventType });
+    const isNewState = !this.store.has(agentId);
+    let state = this.store.get(agentId) ?? createInitialAgentEngineState();
+    if (isNewState) {
+      logger.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) {
+      logger.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) {
+    logger.debug("Clearing state", { agentId });
+    this.store.delete(agentId);
+  }
+  /**
+   * Check if state exists for an agent
+   */
+  hasState(agentId) {
+    return this.store.has(agentId);
+  }
+};
+function createMealyMachine() {
+  return new MealyMachine();
+}
+
+// src/agent/AgentStateMachine.ts
+import { createLogger as createLogger2 } from "commonxjs/logger";
+var logger2 = createLogger2("agent/AgentStateMachine");
+var AgentStateMachine = class {
+  _state = "idle";
+  handlers = /* @__PURE__ */ new Set();
+  /**
+   * Current agent state
+   */
+  get state() {
+    return this._state;
+  }
+  /**
+   * Process an event and update internal state if it's a StateEvent
+   *
+   * @param event - Event from MealyMachine (could be any AgentOutput)
+   */
+  process(event) {
+    if (!isStateEvent(event)) {
+      return;
+    }
+    const prev = this._state;
+    const next = this.mapEventToState(event);
+    if (next !== null && prev !== next) {
+      this._state = next;
+      logger2.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() {
+    const prev = this._state;
+    this._state = "idle";
+    if (prev !== "idle") {
+      this.notifyHandlers({ prev, current: "idle" });
+    }
+    this.handlers.clear();
+  }
+  /**
+   * Map StateEvent type to AgentState
+   *
+   * @param event - StateEvent from MealyMachine
+   * @returns New AgentState or null if no transition needed
+   */
+  mapEventToState(event) {
+    switch (event.type) {
+      // Conversation lifecycle
+      case "conversation_start":
+        return "thinking";
+      case "conversation_thinking":
+        return "thinking";
+      case "conversation_responding":
+        return "responding";
+      case "conversation_end":
+        return "idle";
+      case "conversation_interrupted":
+        return "idle";
+      // Tool lifecycle
+      case "tool_planned":
+        return "planning_tool";
+      case "tool_executing":
+        return "awaiting_tool_result";
+      case "tool_completed":
+        return "responding";
+      case "tool_failed":
+        return "responding";
+      // Error
+      case "error_occurred":
+        return "error";
+      default:
+        return null;
+    }
+  }
+  /**
+   * Notify all registered handlers of state change
+   */
+  notifyHandlers(change) {
+    for (const handler of this.handlers) {
+      try {
+        handler(change);
+      } catch (error) {
+        logger2.error("State change handler error", {
+          from: change.prev,
+          to: change.current,
+          error
+        });
+      }
+    }
+  }
+};
+
+// src/agent/createAgent.ts
+import { createLogger as createLogger3 } from "commonxjs/logger";
+var logger3 = createLogger3("agent/AgentEngine");
+function generateAgentId() {
+  return `agent_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+var STREAM_EVENT_TYPES = [
+  "message_start",
+  "message_delta",
+  "message_stop",
+  "text_delta",
+  "tool_use_start",
+  "input_json_delta",
+  "tool_use_stop",
+  "tool_result",
+  "error_received"
+];
+var DefaultSource = class {
+  constructor(bus, agentId) {
+    this.bus = bus;
+    this.agentId = agentId;
+  }
+  name = "DefaultSource";
+  unsubscribes = [];
+  connect(onEvent) {
+    for (const type of STREAM_EVENT_TYPES) {
+      const unsub = this.bus.on(type, (event) => {
+        if (!isDriveableEvent(event)) {
+          return;
+        }
+        const e = event;
+        if (e.context?.agentId && e.context.agentId !== this.agentId) {
+          return;
+        }
+        onEvent(event);
+      });
+      this.unsubscribes.push(unsub);
+    }
+    logger3.debug("DefaultSource connected", { agentId: this.agentId });
+  }
+  disconnect() {
+    for (const unsub of this.unsubscribes) {
+      unsub();
+    }
+    this.unsubscribes = [];
+    logger3.debug("DefaultSource disconnected", { agentId: this.agentId });
+  }
+};
+var DefaultPresenter = class {
+  constructor(bus) {
+    this.bus = bus;
+  }
+  name = "DefaultPresenter";
+  present(agentId, output) {
+    this.bus.emit({
+      ...output,
+      source: "agent",
+      context: { agentId }
+    });
+  }
+};
+var SimpleMessageQueue = class {
+  queue = [];
+  get length() {
+    return this.queue.length;
+  }
+  get isEmpty() {
+    return this.queue.length === 0;
+  }
+  enqueue(message) {
+    this.queue.push(message);
+  }
+  dequeue() {
+    return this.queue.shift();
+  }
+  clear() {
+    this.queue = [];
+  }
+};
+var AgentEngineImpl = class {
+  agentId;
+  createdAt;
+  messageQueue;
+  _messageQueue = new SimpleMessageQueue();
+  bus;
+  source;
+  presenter;
+  machine;
+  stateMachine;
+  handlers = /* @__PURE__ */ new Set();
+  typeHandlers = /* @__PURE__ */ new Map();
+  readyHandlers = /* @__PURE__ */ new Set();
+  destroyHandlers = /* @__PURE__ */ new Set();
+  middlewares = [];
+  interceptors = [];
+  isDestroyed = false;
+  constructor(options) {
+    this.agentId = options.agentId ?? generateAgentId();
+    this.createdAt = Date.now();
+    this.messageQueue = this._messageQueue;
+    this.bus = options.bus;
+    this.machine = new MealyMachine();
+    this.stateMachine = new AgentStateMachine();
+    this.source = options.source ?? new DefaultSource(this.bus, this.agentId);
+    this.presenter = options.presenter ?? new DefaultPresenter(this.bus);
+    this.source.connect((event) => this.handleStreamEvent(event));
+    logger3.debug("AgentEngine created", { agentId: this.agentId });
+  }
+  get state() {
+    return this.stateMachine.state;
+  }
+  async receive(message) {
+    if (this.isDestroyed) {
+      throw new Error("Cannot receive message on destroyed agent");
+    }
+    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;
+    logger3.debug("Receiving message", { messageId: userMessage.id });
+    let processedMessage = userMessage;
+    for (const middleware of this.middlewares) {
+      let nextCalled = false;
+      await middleware(processedMessage, async (msg) => {
+        nextCalled = true;
+        processedMessage = msg;
+      });
+      if (!nextCalled) {
+        logger3.debug("Middleware blocked message", { messageId: userMessage.id });
+        return;
+      }
+    }
+    this.bus.emit({
+      type: "user_message",
+      timestamp: Date.now(),
+      source: "agent",
+      data: processedMessage,
+      context: { agentId: this.agentId }
+    });
+    logger3.debug("user_message emitted to EventBus", { messageId: userMessage.id });
+  }
+  /**
+   * Handle a stream event (called by Source)
+   */
+  handleStreamEvent(event) {
+    if (this.isDestroyed) return;
+    logger3.debug("handleStreamEvent", { type: event.type });
+    const outputs = this.machine.process(this.agentId, event);
+    logger3.debug("MealyMachine outputs", {
+      count: outputs.length,
+      types: outputs.map((o) => o.type)
+    });
+    for (const output of outputs) {
+      this.stateMachine.process(output);
+      this.emitOutput(output);
+    }
+  }
+  emitOutput(output) {
+    let currentOutput = output;
+    const runInterceptor = (index, out) => {
+      if (index >= this.interceptors.length) {
+        currentOutput = out;
+        return;
+      }
+      this.interceptors[index](out, (nextOut) => {
+        runInterceptor(index + 1, nextOut);
+      });
+    };
+    runInterceptor(0, output);
+    if (!currentOutput) return;
+    this.presenter.present(this.agentId, currentOutput);
+    for (const handler of this.handlers) {
+      try {
+        handler(currentOutput);
+      } catch (e) {
+        logger3.error("Event handler error", { error: e });
+      }
+    }
+    const typeSet = this.typeHandlers.get(currentOutput.type);
+    if (typeSet) {
+      for (const handler of typeSet) {
+        try {
+          handler(currentOutput);
+        } catch (e) {
+          logger3.error("Event handler error", { error: e });
+        }
+      }
+    }
+  }
+  on(typeOrHandler, handler) {
+    if (typeof typeOrHandler === "function") {
+      this.handlers.add(typeOrHandler);
+      return () => this.handlers.delete(typeOrHandler);
+    }
+    if (typeof typeOrHandler === "object" && !Array.isArray(typeOrHandler)) {
+      const unsubscribes = [];
+      for (const [type, h2] of Object.entries(typeOrHandler)) {
+        if (h2) {
+          unsubscribes.push(this.on(type, h2));
+        }
+      }
+      return () => unsubscribes.forEach((u) => u());
+    }
+    const types = Array.isArray(typeOrHandler) ? typeOrHandler : [typeOrHandler];
+    const h = handler;
+    for (const type of types) {
+      if (!this.typeHandlers.has(type)) {
+        this.typeHandlers.set(type, /* @__PURE__ */ new Set());
+      }
+      this.typeHandlers.get(type).add(h);
+    }
+    return () => {
+      for (const type of types) {
+        this.typeHandlers.get(type)?.delete(h);
+      }
+    };
+  }
+  onStateChange(handler) {
+    return this.stateMachine.onStateChange(handler);
+  }
+  react(handlers) {
+    const eventHandlerMap = {};
+    for (const [key, handler] of Object.entries(handlers)) {
+      if (handler && key.startsWith("on")) {
+        const eventType = key.slice(2).replace(/([A-Z])/g, "_$1").toLowerCase().slice(1);
+        eventHandlerMap[eventType] = handler;
+      }
+    }
+    return this.on(eventHandlerMap);
+  }
+  onReady(handler) {
+    try {
+      handler();
+    } catch (e) {
+      logger3.error("onReady handler error", { error: e });
+    }
+    this.readyHandlers.add(handler);
+    return () => this.readyHandlers.delete(handler);
+  }
+  onDestroy(handler) {
+    this.destroyHandlers.add(handler);
+    return () => this.destroyHandlers.delete(handler);
+  }
+  use(middleware) {
+    this.middlewares.push(middleware);
+    return () => {
+      const index = this.middlewares.indexOf(middleware);
+      if (index >= 0) {
+        this.middlewares.splice(index, 1);
+      }
+    };
+  }
+  intercept(interceptor) {
+    this.interceptors.push(interceptor);
+    return () => {
+      const index = this.interceptors.indexOf(interceptor);
+      if (index >= 0) {
+        this.interceptors.splice(index, 1);
+      }
+    };
+  }
+  interrupt() {
+    if (this.state === "idle" || this.isDestroyed) {
+      return;
+    }
+    this.bus.emit({
+      type: "interrupt_request",
+      timestamp: Date.now(),
+      source: "agent",
+      data: {},
+      context: { agentId: this.agentId }
+    });
+    logger3.debug("Interrupt requested", { agentId: this.agentId });
+  }
+  async destroy() {
+    if (this.isDestroyed) return;
+    this.isDestroyed = true;
+    this.source.disconnect();
+    for (const handler of this.destroyHandlers) {
+      try {
+        handler();
+      } catch (e) {
+        logger3.error("onDestroy handler error", { error: e });
+      }
+    }
+    this.machine.clearState(this.agentId);
+    this.stateMachine.reset();
+    this._messageQueue.clear();
+    this.handlers.clear();
+    this.typeHandlers.clear();
+    this.readyHandlers.clear();
+    this.destroyHandlers.clear();
+    this.middlewares.length = 0;
+    this.interceptors.length = 0;
+    logger3.debug("AgentEngine destroyed", { agentId: this.agentId });
+  }
+};
+function createAgent(options) {
+  return new AgentEngineImpl(options);
+}
+
+export {
+  agentProcessor,
+  createInitialAgentEngineState,
+  MealyMachine,
+  createMealyMachine,
+  AgentStateMachine,
+  createAgent
+};
+//# sourceMappingURL=chunk-AT5P47YA.js.map

package/dist/chunk-AT5P47YA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/agent/engine/AgentProcessor.ts","../src/agent/engine/MealyMachine.ts","../src/agent/AgentStateMachine.ts","../src/agent/createAgent.ts"],"sourcesContent":["/**\n * AgentProcessor\n *\n * Combined Mealy processor for the full AgentX engine.\n * Composes MessageAssembler, StateMachine, and TurnTracker processors.\n */\n\nimport { combineProcessors, combineInitialStates, type Processor } from \"./mealy\";\n// Note: StreamEventType and MessageEventType are part of AgentOutput (from Presenter)\n// They flow through the system but AgentProcessor doesn't need to import them directly\nimport {\n  messageAssemblerProcessor,\n  stateEventProcessor,\n  turnTrackerProcessor,\n  createInitialMessageAssemblerState,\n  createInitialStateEventProcessorContext,\n  createInitialTurnTrackerState,\n  type MessageAssemblerState,\n  type StateEventProcessorContext,\n  type TurnTrackerState,\n  type MessageAssemblerOutput,\n  type StateEventProcessorOutput,\n  type TurnTrackerOutput,\n} from \"./internal\";\nimport type { AgentOutput } from \"../types\";\n\n/**\n * Combined state type for the full agent engine\n */\nexport type AgentEngineState = {\n  messageAssembler: MessageAssemblerState;\n  stateEventProcessor: StateEventProcessorContext;\n  turnTracker: TurnTrackerState;\n};\n\n/**\n * Input event type for AgentProcessor\n *\n * Accepts:\n * - StreamEventType: Raw stream events from Driver\n * - MessageEventType: Re-injected message events (for TurnTracker)\n *\n * Note: AgentOutput is used because re-injected events can be any output type\n */\nexport type AgentProcessorInput = AgentOutput;\n\n/**\n * Output event type from AgentProcessor\n *\n * Produces:\n * - MessageAssemblerOutput: Assembled message events\n * - StateEventProcessorOutput: State transition events\n * - TurnTrackerOutput: Turn analytics events\n *\n * Note: StreamEventType is NOT in output - it's passed through by AgentEngine\n */\nexport type AgentProcessorOutput =\n  | MessageAssemblerOutput\n  | StateEventProcessorOutput\n  | TurnTrackerOutput;\n\n/**\n * Combined processor for the full agent engine\n *\n * This combines:\n * - MessageAssembler: Stream → Message events\n * - StateEventProcessor: Stream → State events\n * - TurnTracker: Message → Turn events\n *\n * Pattern: (state, input) => [newState, outputs]\n * Key insight: State is means, outputs are the goal (Mealy Machine)\n *\n * Note: Raw StreamEvents are NOT output by this processor.\n * The AgentEngine handles pass-through of original events.\n */\nexport const agentProcessor: Processor<\n  AgentEngineState,\n  AgentProcessorInput,\n  AgentProcessorOutput\n> = combineProcessors<AgentEngineState, AgentProcessorInput, AgentProcessorOutput>({\n  messageAssembler: messageAssemblerProcessor as unknown as Processor<\n    AgentEngineState[\"messageAssembler\"],\n    AgentProcessorInput,\n    AgentProcessorOutput\n  >,\n  stateEventProcessor: stateEventProcessor as unknown as Processor<\n    AgentEngineState[\"stateEventProcessor\"],\n    AgentProcessorInput,\n    AgentProcessorOutput\n  >,\n  turnTracker: turnTrackerProcessor as unknown as Processor<\n    AgentEngineState[\"turnTracker\"],\n    AgentProcessorInput,\n    AgentProcessorOutput\n  >,\n});\n\n/**\n * Initial state factory for the full agent engine\n */\nexport const createInitialAgentEngineState: () => AgentEngineState =\n  combineInitialStates<AgentEngineState>({\n    messageAssembler: createInitialMessageAssemblerState,\n    stateEventProcessor: createInitialStateEventProcessorContext,\n    turnTracker: createInitialTurnTrackerState,\n  });\n","/**\n * MealyMachine - Pure Mealy Machine Event Processor\n *\n * MealyMachine is a stateless event processor that transforms StreamEvents\n * into higher-level events (state, message, turn events).\n *\n * Key Design:\n * - Engine is a pure Mealy Machine: process(agentId, event) → outputs\n * - Engine does NOT hold driver or presenters (those belong to AgentEngine layer)\n * - Engine manages intermediate processing state per agentId\n * - Multiple agents can share the same MealyMachine instance\n *\n * Type Relationship:\n * ```\n * StreamEvent (from Driver)\n * │\n * └── message_start, text_delta, tool_use_start, message_stop...\n *         ↓ MealyMachine processes\n * AgentOutput (to AgentEngine/Presenter)\n * │\n * ├── StateEvent (conversation_start, conversation_end...)\n * ├── MessageEvent (assistant_message, tool_call_message...)\n * └── TurnEvent (turn_request, turn_response)\n * ```\n *\n * State Management:\n * - Processing state (pendingContents, etc.) is managed internally per agentId\n * - Business data persistence is NOT handled here - that's AgentEngine layer's job\n *\n * Usage:\n * ```typescript\n * const machine = new MealyMachine();\n *\n * // AgentEngine layer coordinates:\n * // 1. Driver produces StreamEvents\n * // 2. MealyMachine processes events\n * // 3. Presenters handle outputs\n *\n * for await (const streamEvent of driver.receive(message)) {\n *   const outputs = machine.process(agentId, streamEvent);\n *   for (const output of outputs) {\n *     presenters.forEach(p => p.present(agentId, output));\n *   }\n * }\n * ```\n */\n\nimport {\n  agentProcessor,\n  createInitialAgentEngineState,\n  type AgentEngineState,\n} from \"./AgentProcessor\";\nimport { MemoryStore } from \"./mealy\";\nimport type { AgentOutput, StreamEvent } from \"../types\";\nimport { createLogger } from \"commonxjs/logger\";\n\nconst logger = createLogger(\"engine/MealyMachine\");\n\n/**\n * MealyMachine - Pure Mealy Machine for event processing\n *\n * - Input: StreamEvent (from Driver)\n * - Output: AgentOutput[] (state, message, turn events)\n * - State: Managed internally per agentId\n */\nexport class MealyMachine {\n  private readonly store: MemoryStore<AgentEngineState>;\n\n  constructor() {\n    this.store = new MemoryStore<AgentEngineState>();\n    logger.debug(\"MealyMachine initialized\");\n  }\n\n  /**\n   * Process a single driveable event and return output events\n   *\n   * This is the core Mealy Machine operation:\n   * process(agentId, event) → outputs[]\n   *\n   * @param agentId - The agent identifier (for state isolation)\n   * @param event - StreamEvent to process\n   * @returns Array of output events (state, message, turn events)\n   */\n  process(agentId: string, event: StreamEvent): AgentOutput[] {\n    const eventType = (event as { type?: string }).type || \"unknown\";\n    logger.debug(\"Processing event\", { agentId, eventType });\n\n    // Get current state or create initial state\n    const isNewState = !this.store.has(agentId);\n    let state = this.store.get(agentId) ?? createInitialAgentEngineState();\n\n    if (isNewState) {\n      logger.debug(\"Created initial state for agent\", { agentId });\n    }\n\n    // Collect all outputs\n    const allOutputs: AgentOutput[] = [];\n\n    // Pass-through: original stream event is also an output\n    allOutputs.push(event);\n\n    // Process through Mealy Machine\n    const [newState, outputs] = agentProcessor(state, event);\n    state = newState;\n\n    // Collect processor outputs\n    for (const output of outputs) {\n      allOutputs.push(output);\n\n      // Re-inject for event chaining (e.g., TurnTracker needs MessageEvents)\n      const [chainedState, chainedOutputs] = this.processChained(state, output);\n      state = chainedState;\n      allOutputs.push(...chainedOutputs);\n    }\n\n    // Store updated state\n    this.store.set(agentId, state);\n\n    if (outputs.length > 0) {\n      logger.debug(\"Produced outputs\", {\n        agentId,\n        inputEvent: eventType,\n        outputCount: allOutputs.length,\n        processorOutputs: outputs.length,\n      });\n    }\n\n    return allOutputs;\n  }\n\n  /**\n   * Process chained events recursively\n   *\n   * Some processors produce events that trigger other processors:\n   * - MessageAssembler produces MessageEvents\n   * - TurnTracker consumes MessageEvents to produce TurnEvents\n   */\n  private processChained(\n    state: AgentEngineState,\n    event: AgentOutput\n  ): [AgentEngineState, AgentOutput[]] {\n    const [newState, outputs] = agentProcessor(state, event);\n\n    if (outputs.length === 0) {\n      return [newState, []];\n    }\n\n    // Process outputs recursively\n    const allOutputs: AgentOutput[] = [...outputs];\n    let currentState = newState;\n\n    for (const output of outputs) {\n      const [chainedState, chainedOutputs] = this.processChained(currentState, output);\n      currentState = chainedState;\n      allOutputs.push(...chainedOutputs);\n    }\n\n    return [currentState, allOutputs];\n  }\n\n  /**\n   * Clear state for an agent\n   *\n   * Call this when an agent is destroyed to free memory.\n   */\n  clearState(agentId: string): void {\n    logger.debug(\"Clearing state\", { agentId });\n    this.store.delete(agentId);\n  }\n\n  /**\n   * Check if state exists for an agent\n   */\n  hasState(agentId: string): boolean {\n    return this.store.has(agentId);\n  }\n}\n\n/**\n * Factory function to create MealyMachine\n */\nexport function createMealyMachine(): MealyMachine {\n  return new MealyMachine();\n}\n","/**\n * AgentStateMachine - State management driven by StateEvents\n *\n * Manages agent state transitions driven by StateEvents.\n * Single source of truth for agent state in AgentEngine.\n *\n * Flow:\n * StreamEvent → MealyMachine → StateEvent → AgentStateMachine → state update\n *\n * Responsibilities:\n * - Process StateEvents\n * - Maintain current AgentState\n * - Notify state change subscribers\n */\n\nimport type {\n  AgentState,\n  StateChange,\n  StateChangeHandler,\n  AgentOutput,\n  Unsubscribe,\n} from \"./types\";\nimport { isStateEvent } from \"./types\";\nimport { createLogger } from \"commonxjs/logger\";\n\nconst logger = createLogger(\"agent/AgentStateMachine\");\n\n/**\n * AgentStateMachine implementation\n */\nexport class AgentStateMachine {\n  private _state: AgentState = \"idle\";\n  private readonly handlers = new Set<StateChangeHandler>();\n\n  /**\n   * Current agent state\n   */\n  get state(): AgentState {\n    return this._state;\n  }\n\n  /**\n   * Process an event and update internal state if it's a StateEvent\n   *\n   * @param event - Event from MealyMachine (could be any AgentOutput)\n   */\n  process(event: AgentOutput): void {\n    // Only process StateEvents\n    if (!isStateEvent(event)) {\n      return;\n    }\n\n    const prev = this._state;\n    const next = this.mapEventToState(event);\n\n    if (next !== null && prev !== next) {\n      this._state = next;\n      logger.debug(\"State transition\", {\n        eventType: event.type,\n        from: prev,\n        to: next,\n      });\n      this.notifyHandlers({ prev, current: next });\n    }\n  }\n\n  /**\n   * Subscribe to state changes\n   *\n   * @param handler - Callback receiving { prev, current } state change\n   * @returns Unsubscribe function\n   */\n  onStateChange(handler: StateChangeHandler): Unsubscribe {\n    this.handlers.add(handler);\n    return () => {\n      this.handlers.delete(handler);\n    };\n  }\n\n  /**\n   * Reset state machine (used on destroy)\n   */\n  reset(): void {\n    const prev = this._state;\n    this._state = \"idle\";\n\n    // Notify handlers of reset to idle\n    if (prev !== \"idle\") {\n      this.notifyHandlers({ prev, current: \"idle\" });\n    }\n\n    this.handlers.clear();\n  }\n\n  /**\n   * Map StateEvent type to AgentState\n   *\n   * @param event - StateEvent from MealyMachine\n   * @returns New AgentState or null if no transition needed\n   */\n  private mapEventToState(event: AgentOutput): AgentState | null {\n    switch (event.type) {\n      // Conversation lifecycle\n      case \"conversation_start\":\n        return \"thinking\";\n      case \"conversation_thinking\":\n        return \"thinking\";\n      case \"conversation_responding\":\n        return \"responding\";\n      case \"conversation_end\":\n        return \"idle\";\n      case \"conversation_interrupted\":\n        return \"idle\";\n\n      // Tool lifecycle\n      case \"tool_planned\":\n        return \"planning_tool\";\n      case \"tool_executing\":\n        return \"awaiting_tool_result\";\n      case \"tool_completed\":\n        return \"responding\";\n      case \"tool_failed\":\n        return \"responding\";\n\n      // Error\n      case \"error_occurred\":\n        return \"error\";\n\n      default:\n        // Unknown event type, no state change\n        return null;\n    }\n  }\n\n  /**\n   * Notify all registered handlers of state change\n   */\n  private notifyHandlers(change: StateChange): void {\n    for (const handler of this.handlers) {\n      try {\n        handler(change);\n      } catch (error) {\n        logger.error(\"State change handler error\", {\n          from: change.prev,\n          to: change.current,\n          error,\n        });\n      }\n    }\n  }\n}\n","/**\n * createAgent - Factory function to create an AgentEngine\n *\n * Creates an AgentEngine connected to EventBus:\n * - receive() emits user_message to EventBus\n * - Source subscribes to StreamEvent from EventBus\n * - Presenter emits AgentOutput to EventBus\n *\n * ```\n *                         EventBus\n *                        ↗        ↘\n *         emit          │          │     emit\n *         user_message  │          │     AgentOutput\n *              ↑        │          │      ↑\n * ┌─────────────────────────────────────────────────────────────┐\n * │                       AgentEngine                            │\n * │                                                             │\n * │   receive() ──► Source ──► MealyMachine ──► Presenter       │\n * │                 (sub)                        (pub)          │\n * └─────────────────────────────────────────────────────────────┘\n * ```\n */\n\nimport type {\n  AgentEngine,\n  AgentState,\n  AgentOutputCallback,\n  UserMessage,\n  MessageQueue,\n  StateChangeHandler,\n  EventHandlerMap,\n  ReactHandlerMap,\n  AgentOutput,\n  CreateAgentOptions,\n  AgentSource,\n  AgentPresenter,\n  AgentEventBus,\n  StreamEvent,\n  Unsubscribe,\n  AgentMiddleware,\n  AgentInterceptor,\n} from \"./types\";\nimport { MealyMachine } from \"./engine/MealyMachine\";\nimport { AgentStateMachine } from \"./AgentStateMachine\";\nimport { createLogger } from \"commonxjs/logger\";\nimport { isDriveableEvent } from \"../event\";\n\nconst logger = createLogger(\"agent/AgentEngine\");\n\n/**\n * Generate unique agent ID\n */\nfunction generateAgentId(): string {\n  return `agent_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;\n}\n\n/**\n * StreamEvent types that Source should subscribe to\n */\nconst STREAM_EVENT_TYPES = [\n  \"message_start\",\n  \"message_delta\",\n  \"message_stop\",\n  \"text_delta\",\n  \"tool_use_start\",\n  \"input_json_delta\",\n  \"tool_use_stop\",\n  \"tool_result\",\n  \"error_received\",\n];\n\n/**\n * Default Source implementation\n * Subscribes to StreamEvent from EventBus\n */\nclass DefaultSource implements AgentSource {\n  readonly name = \"DefaultSource\";\n  private unsubscribes: Unsubscribe[] = [];\n\n  constructor(\n    private readonly bus: AgentEventBus,\n    private readonly agentId: string\n  ) {}\n\n  connect(onEvent: (event: StreamEvent) => void): void {\n    // Subscribe to each StreamEvent type\n    for (const type of STREAM_EVENT_TYPES) {\n      const unsub = this.bus.on(type, (event: unknown) => {\n        // Only process DriveableEvents (source: \"driver\", category: \"stream\")\n        // This prevents circular processing of AgentOutput events\n        if (!isDriveableEvent(event as { source?: string; category?: string })) {\n          return;\n        }\n\n        // Filter by agentId if present in context\n        const e = event as { context?: { agentId?: string } };\n        if (e.context?.agentId && e.context.agentId !== this.agentId) {\n          return;\n        }\n        onEvent(event as StreamEvent);\n      });\n      this.unsubscribes.push(unsub);\n    }\n\n    logger.debug(\"DefaultSource connected\", { agentId: this.agentId });\n  }\n\n  disconnect(): void {\n    for (const unsub of this.unsubscribes) {\n      unsub();\n    }\n    this.unsubscribes = [];\n    logger.debug(\"DefaultSource disconnected\", { agentId: this.agentId });\n  }\n}\n\n/**\n * Default Presenter implementation\n * Emits AgentOutput to EventBus\n */\nclass DefaultPresenter implements AgentPresenter {\n  readonly name = \"DefaultPresenter\";\n\n  constructor(private readonly bus: AgentEventBus) {}\n\n  present(agentId: string, output: AgentOutput): void {\n    // Emit to EventBus with agent context\n    this.bus.emit({\n      ...output,\n      source: \"agent\",\n      context: { agentId },\n    });\n  }\n}\n\n/**\n * Simple MessageQueue implementation\n */\nclass SimpleMessageQueue implements MessageQueue {\n  private queue: UserMessage[] = [];\n\n  get length(): number {\n    return this.queue.length;\n  }\n\n  get isEmpty(): boolean {\n    return this.queue.length === 0;\n  }\n\n  enqueue(message: UserMessage): void {\n    this.queue.push(message);\n  }\n\n  dequeue(): UserMessage | undefined {\n    return this.queue.shift();\n  }\n\n  clear(): void {\n    this.queue = [];\n  }\n}\n\n/**\n * AgentEngineImpl - EventBus-based AgentEngine implementation\n */\nclass AgentEngineImpl implements AgentEngine {\n  readonly agentId: string;\n  readonly createdAt: number;\n  readonly messageQueue: MessageQueue;\n\n  private readonly _messageQueue = new SimpleMessageQueue();\n  private readonly bus: AgentEventBus;\n  private readonly source: AgentSource;\n  private readonly presenter: AgentPresenter;\n  private readonly machine: MealyMachine;\n  private readonly stateMachine: AgentStateMachine;\n\n  private readonly handlers: Set<AgentOutputCallback> = new Set();\n  private readonly typeHandlers: Map<string, Set<AgentOutputCallback>> = new Map();\n  private readonly readyHandlers: Set<() => void> = new Set();\n  private readonly destroyHandlers: Set<() => void> = new Set();\n  private readonly middlewares: AgentMiddleware[] = [];\n  private readonly interceptors: AgentInterceptor[] = [];\n\n  private isDestroyed = false;\n\n  constructor(options: CreateAgentOptions) {\n    this.agentId = options.agentId ?? generateAgentId();\n    this.createdAt = Date.now();\n    this.messageQueue = this._messageQueue;\n    this.bus = options.bus;\n    this.machine = new MealyMachine();\n    this.stateMachine = new AgentStateMachine();\n\n    // Use provided Source/Presenter or create defaults\n    this.source = options.source ?? new DefaultSource(this.bus, this.agentId);\n    this.presenter = options.presenter ?? new DefaultPresenter(this.bus);\n\n    // Connect Source to receive StreamEvents\n    this.source.connect((event) => this.handleStreamEvent(event));\n\n    logger.debug(\"AgentEngine created\", { agentId: this.agentId });\n  }\n\n  get state(): AgentState {\n    return this.stateMachine.state;\n  }\n\n  async receive(message: string | UserMessage): Promise<void> {\n    if (this.isDestroyed) {\n      throw new Error(\"Cannot receive message on destroyed agent\");\n    }\n\n    const userMessage: UserMessage =\n      typeof message === \"string\"\n        ? {\n            id: `msg_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,\n            role: \"user\",\n            subtype: \"user\",\n            content: message,\n            timestamp: Date.now(),\n          }\n        : message;\n\n    logger.debug(\"Receiving message\", { messageId: userMessage.id });\n\n    // Run through middleware chain\n    let processedMessage = userMessage;\n    for (const middleware of this.middlewares) {\n      let nextCalled = false;\n      await middleware(processedMessage, async (msg) => {\n        nextCalled = true;\n        processedMessage = msg;\n      });\n      if (!nextCalled) {\n        logger.debug(\"Middleware blocked message\", { messageId: userMessage.id });\n        return;\n      }\n    }\n\n    // Emit user_message to EventBus\n    // This triggers Driver to send to LLM\n    this.bus.emit({\n      type: \"user_message\",\n      timestamp: Date.now(),\n      source: \"agent\",\n      data: processedMessage,\n      context: { agentId: this.agentId },\n    });\n\n    logger.debug(\"user_message emitted to EventBus\", { messageId: userMessage.id });\n  }\n\n  /**\n   * Handle a stream event (called by Source)\n   */\n  handleStreamEvent(event: StreamEvent): void {\n    if (this.isDestroyed) return;\n\n    logger.debug(\"handleStreamEvent\", { type: event.type });\n\n    // Process through MealyMachine\n    const outputs = this.machine.process(this.agentId, event);\n\n    logger.debug(\"MealyMachine outputs\", {\n      count: outputs.length,\n      types: outputs.map((o) => o.type),\n    });\n\n    // Emit all outputs\n    for (const output of outputs) {\n      this.stateMachine.process(output);\n      this.emitOutput(output);\n    }\n  }\n\n  private emitOutput(output: AgentOutput): void {\n    // Run through interceptor chain\n    let currentOutput: AgentOutput | null = output;\n\n    const runInterceptor = (index: number, out: AgentOutput): void => {\n      if (index >= this.interceptors.length) {\n        currentOutput = out;\n        return;\n      }\n      this.interceptors[index](out, (nextOut) => {\n        runInterceptor(index + 1, nextOut);\n      });\n    };\n\n    runInterceptor(0, output);\n    if (!currentOutput) return;\n\n    // Send to presenter (emits to EventBus)\n    this.presenter.present(this.agentId, currentOutput);\n\n    // Notify local handlers\n    for (const handler of this.handlers) {\n      try {\n        handler(currentOutput);\n      } catch (e) {\n        logger.error(\"Event handler error\", { error: e });\n      }\n    }\n\n    // Notify type-specific handlers\n    const typeSet = this.typeHandlers.get(currentOutput.type);\n    if (typeSet) {\n      for (const handler of typeSet) {\n        try {\n          handler(currentOutput);\n        } catch (e) {\n          logger.error(\"Event handler error\", { error: e });\n        }\n      }\n    }\n  }\n\n  on(handler: AgentOutputCallback): Unsubscribe;\n  on(handlers: EventHandlerMap): Unsubscribe;\n  on(type: string, handler: AgentOutputCallback): Unsubscribe;\n  on(types: string[], handler: AgentOutputCallback): Unsubscribe;\n  on(\n    typeOrHandler: string | string[] | AgentOutputCallback | EventHandlerMap,\n    handler?: AgentOutputCallback\n  ): Unsubscribe {\n    if (typeof typeOrHandler === \"function\") {\n      this.handlers.add(typeOrHandler);\n      return () => this.handlers.delete(typeOrHandler);\n    }\n\n    if (typeof typeOrHandler === \"object\" && !Array.isArray(typeOrHandler)) {\n      const unsubscribes: Unsubscribe[] = [];\n      for (const [type, h] of Object.entries(typeOrHandler)) {\n        if (h) {\n          unsubscribes.push(this.on(type, h));\n        }\n      }\n      return () => unsubscribes.forEach((u) => u());\n    }\n\n    const types = Array.isArray(typeOrHandler) ? typeOrHandler : [typeOrHandler];\n    const h = handler!;\n\n    for (const type of types) {\n      if (!this.typeHandlers.has(type)) {\n        this.typeHandlers.set(type, new Set());\n      }\n      this.typeHandlers.get(type)!.add(h);\n    }\n\n    return () => {\n      for (const type of types) {\n        this.typeHandlers.get(type)?.delete(h);\n      }\n    };\n  }\n\n  onStateChange(handler: StateChangeHandler): Unsubscribe {\n    return this.stateMachine.onStateChange(handler);\n  }\n\n  react(handlers: ReactHandlerMap): Unsubscribe {\n    const eventHandlerMap: EventHandlerMap = {};\n    for (const [key, handler] of Object.entries(handlers)) {\n      if (handler && key.startsWith(\"on\")) {\n        const eventType = key\n          .slice(2)\n          .replace(/([A-Z])/g, \"_$1\")\n          .toLowerCase()\n          .slice(1);\n        eventHandlerMap[eventType] = handler;\n      }\n    }\n    return this.on(eventHandlerMap);\n  }\n\n  onReady(handler: () => void): Unsubscribe {\n    try {\n      handler();\n    } catch (e) {\n      logger.error(\"onReady handler error\", { error: e });\n    }\n    this.readyHandlers.add(handler);\n    return () => this.readyHandlers.delete(handler);\n  }\n\n  onDestroy(handler: () => void): Unsubscribe {\n    this.destroyHandlers.add(handler);\n    return () => this.destroyHandlers.delete(handler);\n  }\n\n  use(middleware: AgentMiddleware): Unsubscribe {\n    this.middlewares.push(middleware);\n    return () => {\n      const index = this.middlewares.indexOf(middleware);\n      if (index >= 0) {\n        this.middlewares.splice(index, 1);\n      }\n    };\n  }\n\n  intercept(interceptor: AgentInterceptor): Unsubscribe {\n    this.interceptors.push(interceptor);\n    return () => {\n      const index = this.interceptors.indexOf(interceptor);\n      if (index >= 0) {\n        this.interceptors.splice(index, 1);\n      }\n    };\n  }\n\n  interrupt(): void {\n    if (this.state === \"idle\" || this.isDestroyed) {\n      return;\n    }\n\n    // Emit interrupt event to EventBus\n    this.bus.emit({\n      type: \"interrupt_request\",\n      timestamp: Date.now(),\n      source: \"agent\",\n      data: {},\n      context: { agentId: this.agentId },\n    });\n\n    logger.debug(\"Interrupt requested\", { agentId: this.agentId });\n  }\n\n  async destroy(): Promise<void> {\n    if (this.isDestroyed) return;\n    this.isDestroyed = true;\n\n    // Disconnect Source\n    this.source.disconnect();\n\n    // Notify destroy handlers\n    for (const handler of this.destroyHandlers) {\n      try {\n        handler();\n      } catch (e) {\n        logger.error(\"onDestroy handler error\", { error: e });\n      }\n    }\n\n    // Clear state\n    this.machine.clearState(this.agentId);\n    this.stateMachine.reset();\n\n    this._messageQueue.clear();\n    this.handlers.clear();\n    this.typeHandlers.clear();\n    this.readyHandlers.clear();\n    this.destroyHandlers.clear();\n    this.middlewares.length = 0;\n    this.interceptors.length = 0;\n\n    logger.debug(\"AgentEngine destroyed\", { agentId: this.agentId });\n  }\n}\n\n/**\n * Create an AgentEngine instance connected to EventBus\n */\nexport function createAgent(options: CreateAgentOptions): AgentEngine {\n  return new AgentEngineImpl(options);\n}\n"],"mappings":"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","names":["createLogger","logger","createLogger","logger","createLogger","h"]}