@agentxjs/agent 0.1.6

package/dist/index.cjs

@@ -0,0 +1,1099 @@
+'use strict';
+
+var common = require('@agentxjs/common');
+var agent = require('@agentxjs/types/agent');
+
+// src/engine/mealy/Store.ts
+var MemoryStore = class {
+  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();
+  }
+};
+common.createLogger("engine/Mealy");
+
+// src/engine/mealy/combinators.ts
+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 chainProcessors(...processors) {
+  return (state, event) => {
+    let currentState = state;
+    const finalOutputs = [];
+    for (const processor of processors) {
+      const [newState, outputs] = processor(currentState, event);
+      currentState = newState;
+      finalOutputs.push(...outputs);
+    }
+    return [currentState, finalOutputs];
+  };
+}
+function filterProcessor(predicate, processor) {
+  return (state, event) => {
+    if (predicate(event)) {
+      return processor(state, event);
+    }
+    return [state, []];
+  };
+}
+function mapOutput(processor, mapper) {
+  return (state, event) => {
+    const [newState, outputs] = processor(state, event);
+    return [newState, outputs.map(mapper)];
+  };
+}
+function withLogging(processor, name, logger6 = console) {
+  return (state, event) => {
+    logger6.debug(`[${name}] Input:`, { event, state });
+    const [newState, outputs] = processor(state, event);
+    logger6.debug(`[${name}] Output:`, { newState, outputs });
+    return [newState, outputs];
+  };
+}
+function identityProcessor() {
+  return (state, _event) => {
+    return [state, []];
+  };
+}
+
+// src/engine/internal/messageAssemblerProcessor.ts
+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_start":
+      return handleToolUseStart(state, input);
+    case "input_json_delta":
+      return handleInputJsonDelta(state, input);
+    case "tool_use_stop":
+      return handleToolUseStop(state);
+    case "tool_result":
+      return handleToolResult(state, input);
+    case "message_stop":
+      return handleMessageStop(state, input);
+    case "error_received":
+      return handleErrorReceived(state, input);
+    default:
+      return [state, []];
+  }
+};
+function handleMessageStart(state, event) {
+  const data = event.data;
+  return [
+    {
+      ...state,
+      currentMessageId: data.messageId,
+      messageStartTime: event.timestamp,
+      pendingContents: {}
+    },
+    []
+  ];
+}
+function handleTextDelta(state, event) {
+  const data = event.data;
+  const index = 0;
+  const existingContent = state.pendingContents[index];
+  const pendingContent = existingContent?.type === "text" ? {
+    ...existingContent,
+    textDeltas: [...existingContent.textDeltas || [], data.text]
+  } : {
+    type: "text",
+    index,
+    textDeltas: [data.text]
+  };
+  return [
+    {
+      ...state,
+      pendingContents: {
+        ...state.pendingContents,
+        [index]: pendingContent
+      }
+    },
+    []
+  ];
+}
+function handleToolUseStart(state, event) {
+  const data = event.data;
+  const index = 1;
+  const pendingContent = {
+    type: "tool_use",
+    index,
+    toolId: data.toolCallId,
+    toolName: data.toolName,
+    toolInputJson: ""
+  };
+  return [
+    {
+      ...state,
+      pendingContents: {
+        ...state.pendingContents,
+        [index]: pendingContent
+      }
+    },
+    []
+  ];
+}
+function handleInputJsonDelta(state, event) {
+  const data = event.data;
+  const index = 1;
+  const existingContent = state.pendingContents[index];
+  if (!existingContent || existingContent.type !== "tool_use") {
+    return [state, []];
+  }
+  const pendingContent = {
+    ...existingContent,
+    toolInputJson: (existingContent.toolInputJson || "") + data.partialJson
+  };
+  return [
+    {
+      ...state,
+      pendingContents: {
+        ...state.pendingContents,
+        [index]: pendingContent
+      }
+    },
+    []
+  ];
+}
+function handleToolUseStop(state, _event) {
+  const index = 1;
+  const pendingContent = state.pendingContents[index];
+  if (!pendingContent || pendingContent.type !== "tool_use") {
+    return [state, []];
+  }
+  const toolId = pendingContent.toolId || "";
+  const toolName = pendingContent.toolName || "";
+  let toolInput = {};
+  try {
+    toolInput = pendingContent.toolInputJson ? JSON.parse(pendingContent.toolInputJson) : {};
+  } catch {
+    toolInput = {};
+  }
+  const toolCall = {
+    type: "tool-call",
+    id: toolId,
+    name: toolName,
+    input: toolInput
+  };
+  const messageId = generateId();
+  const timestamp = Date.now();
+  const toolCallMessage = {
+    id: messageId,
+    role: "assistant",
+    subtype: "tool-call",
+    toolCall,
+    timestamp,
+    parentId: state.currentMessageId || void 0
+  };
+  const toolCallMessageEvent = {
+    type: "tool_call_message",
+    timestamp,
+    data: toolCallMessage
+  };
+  const { [index]: _, ...remainingContents } = state.pendingContents;
+  return [
+    {
+      ...state,
+      pendingContents: remainingContents,
+      pendingToolCalls: {
+        ...state.pendingToolCalls,
+        [toolId]: { id: toolId, name: toolName }
+      }
+    },
+    [toolCallMessageEvent]
+  ];
+}
+function handleToolResult(state, event) {
+  const data = event.data;
+  const { toolCallId, result, isError } = data;
+  const pendingToolCall = state.pendingToolCalls[toolCallId];
+  const toolName = pendingToolCall?.name || "unknown";
+  const toolResult = {
+    type: "tool-result",
+    id: toolCallId,
+    name: toolName,
+    output: {
+      type: isError ? "error-text" : "text",
+      value: typeof result === "string" ? result : JSON.stringify(result)
+    }
+  };
+  const messageId = generateId();
+  const timestamp = Date.now();
+  const toolResultMessage = {
+    id: messageId,
+    role: "tool",
+    subtype: "tool-result",
+    toolCallId,
+    toolResult,
+    timestamp
+  };
+  const toolResultMessageEvent = {
+    type: "tool_result_message",
+    timestamp,
+    data: toolResultMessage
+  };
+  const { [toolCallId]: _, ...remainingToolCalls } = state.pendingToolCalls;
+  return [
+    {
+      ...state,
+      pendingToolCalls: remainingToolCalls
+    },
+    [toolResultMessageEvent]
+  ];
+}
+function handleMessageStop(state, event) {
+  const data = event.data;
+  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 textContent = textParts.join("");
+  const stopReason = data.stopReason;
+  if (!textContent || textContent.trim().length === 0) {
+    const shouldPreserveToolCalls2 = stopReason === "tool_use";
+    return [
+      {
+        ...createInitialMessageAssemblerState(),
+        pendingToolCalls: shouldPreserveToolCalls2 ? state.pendingToolCalls : {}
+      },
+      []
+    ];
+  }
+  const contentParts = [
+    {
+      type: "text",
+      text: textContent
+    }
+  ];
+  const timestamp = state.messageStartTime || Date.now();
+  const assistantMessage = {
+    id: state.currentMessageId,
+    role: "assistant",
+    subtype: "assistant",
+    content: contentParts,
+    timestamp
+  };
+  const assistantEvent = {
+    type: "assistant_message",
+    timestamp,
+    data: assistantMessage
+  };
+  const shouldPreserveToolCalls = stopReason === "tool_use";
+  return [
+    {
+      ...createInitialMessageAssemblerState(),
+      pendingToolCalls: shouldPreserveToolCalls ? state.pendingToolCalls : {}
+    },
+    [assistantEvent]
+  ];
+}
+function handleErrorReceived(_state, event) {
+  const data = event.data;
+  const messageId = generateId();
+  const timestamp = Date.now();
+  const errorMessage = {
+    id: messageId,
+    role: "error",
+    subtype: "error",
+    content: data.message,
+    errorCode: data.errorCode,
+    timestamp
+  };
+  const errorMessageEvent = {
+    type: "error_message",
+    timestamp,
+    data: errorMessage
+  };
+  return [createInitialMessageAssemblerState(), [errorMessageEvent]];
+}
+var messageAssemblerProcessorDef = {
+  name: "MessageAssembler",
+  description: "Assembles complete messages from stream events",
+  initialState: createInitialMessageAssemblerState,
+  processor: messageAssemblerProcessor
+};
+var logger2 = common.createLogger("engine/stateEventProcessor");
+function createInitialStateEventProcessorContext() {
+  return {};
+}
+var stateEventProcessor = (context, input) => {
+  logger2.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_delta":
+      return handleTextDelta2(context);
+    case "tool_use_start":
+      return handleToolUseStart2(context, input);
+    case "tool_use_stop":
+      return handleToolUseStop2(context);
+    case "error_received":
+      return handleErrorReceived2(context, input);
+    default:
+      logger2.debug(`[Stream Event] ${input.type} (unhandled)`);
+      return [context, []];
+  }
+};
+function handleMessageStart2(context, event) {
+  const data = event.data;
+  const conversationStartEvent = {
+    type: "conversation_start",
+    timestamp: Date.now(),
+    data: {
+      messageId: data.messageId
+    }
+  };
+  return [context, [conversationStartEvent]];
+}
+function handleMessageDelta(context) {
+  return [context, []];
+}
+function handleMessageStop2(context, event) {
+  const data = event.data;
+  const stopReason = data.stopReason;
+  logger2.debug("message_stop received", { stopReason });
+  if (stopReason === "tool_use") {
+    logger2.debug("Skipping conversation_end (tool_use in progress)");
+    return [context, []];
+  }
+  const conversationEndEvent = {
+    type: "conversation_end",
+    timestamp: Date.now(),
+    data: {
+      reason: "completed"
+    }
+  };
+  return [context, [conversationEndEvent]];
+}
+function handleTextDelta2(context) {
+  const respondingEvent = {
+    type: "conversation_responding",
+    timestamp: Date.now(),
+    data: {}
+  };
+  return [context, [respondingEvent]];
+}
+function handleToolUseStart2(context, event) {
+  const data = event.data;
+  const outputs = [];
+  const toolPlannedEvent = {
+    type: "tool_planned",
+    timestamp: Date.now(),
+    data: {
+      toolId: data.toolCallId,
+      toolName: data.toolName
+    }
+  };
+  outputs.push(toolPlannedEvent);
+  const toolExecutingEvent = {
+    type: "tool_executing",
+    timestamp: Date.now(),
+    data: {
+      toolId: data.toolCallId,
+      toolName: data.toolName,
+      input: {}
+    }
+  };
+  outputs.push(toolExecutingEvent);
+  return [context, outputs];
+}
+function handleToolUseStop2(context) {
+  return [context, []];
+}
+function handleErrorReceived2(context, event) {
+  const data = event.data;
+  const errorOccurredEvent = {
+    type: "error_occurred",
+    timestamp: Date.now(),
+    data: {
+      code: data.errorCode || "unknown_error",
+      message: data.message,
+      recoverable: true
+    }
+  };
+  return [context, [errorOccurredEvent]];
+}
+var stateEventProcessorDef = {
+  name: "StateEventProcessor",
+  description: "Transform Stream Events into State Events",
+  initialState: createInitialStateEventProcessorContext,
+  processor: stateEventProcessor
+};
+
+// src/engine/internal/turnTrackerProcessor.ts
+function createInitialTurnTrackerState() {
+  return {
+    pendingTurn: null,
+    costPerInputToken: 3e-6,
+    // $3 per 1M tokens
+    costPerOutputToken: 15e-6
+    // $15 per 1M tokens
+  };
+}
+function generateId2() {
+  return `turn_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+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 data = event.data;
+  const turnId = generateId2();
+  const contentText = typeof data.content === "string" ? data.content : "";
+  const pendingTurn = {
+    turnId,
+    messageId: data.id,
+    content: contentText,
+    requestedAt: event.timestamp
+  };
+  const turnRequestEvent = {
+    type: "turn_request",
+    timestamp: Date.now(),
+    data: {
+      turnId,
+      messageId: data.id,
+      content: contentText,
+      timestamp: event.timestamp
+    }
+  };
+  return [
+    {
+      ...state,
+      pendingTurn
+    },
+    [turnRequestEvent]
+  ];
+}
+function handleMessageStop3(state, event) {
+  if (!state.pendingTurn) {
+    return [state, []];
+  }
+  const data = event.data;
+  const stopReason = data.stopReason;
+  if (stopReason === "end_turn" || stopReason === "max_tokens" || stopReason === "stop_sequence") {
+    return completeTurn(state, event.timestamp);
+  }
+  return [state, []];
+}
+function completeTurn(state, completedAt) {
+  if (!state.pendingTurn) {
+    return [state, []];
+  }
+  const { turnId, messageId, requestedAt } = state.pendingTurn;
+  const duration = completedAt - requestedAt;
+  const usage = { inputTokens: 0, outputTokens: 0 };
+  const turnResponseEvent = {
+    type: "turn_response",
+    timestamp: Date.now(),
+    data: {
+      turnId,
+      messageId,
+      duration,
+      usage,
+      timestamp: completedAt
+    }
+  };
+  return [
+    {
+      ...state,
+      pendingTurn: null
+    },
+    [turnResponseEvent]
+  ];
+}
+var turnTrackerProcessorDef = {
+  name: "TurnTracker",
+  description: "Tracks request-response turn pairs",
+  initialState: createInitialTurnTrackerState,
+  processor: turnTrackerProcessor
+};
+
+// src/engine/AgentProcessor.ts
+var agentProcessor = combineProcessors({
+  messageAssembler: messageAssemblerProcessor,
+  stateEventProcessor,
+  turnTracker: turnTrackerProcessor
+});
+var createInitialAgentEngineState = combineInitialStates({
+  messageAssembler: createInitialMessageAssemblerState,
+  stateEventProcessor: createInitialStateEventProcessorContext,
+  turnTracker: createInitialTurnTrackerState
+});
+var logger3 = common.createLogger("engine/MealyMachine");
+var MealyMachine = class {
+  store;
+  constructor() {
+    this.store = new MemoryStore();
+    logger3.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";
+    logger3.debug("Processing event", { agentId, eventType });
+    const isNewState = !this.store.has(agentId);
+    let state = this.store.get(agentId) ?? createInitialAgentEngineState();
+    if (isNewState) {
+      logger3.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) {
+      logger3.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) {
+    logger3.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();
+}
+var logger4 = common.createLogger("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 (!agent.isStateEvent(event)) {
+      return;
+    }
+    const prev = this._state;
+    const next = this.mapEventToState(event);
+    if (next !== null && prev !== next) {
+      this._state = next;
+      logger4.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) {
+        logger4.error("State change handler error", {
+          from: change.prev,
+          to: change.current,
+          error
+        });
+      }
+    }
+  }
+};
+var logger5 = common.createLogger("agent/SimpleAgent");
+function generateAgentId() {
+  return `agent_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+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 SimpleAgent = class {
+  agentId;
+  createdAt;
+  messageQueue;
+  _messageQueue = new SimpleMessageQueue();
+  driver;
+  presenter;
+  machine;
+  stateMachine;
+  handlers = /* @__PURE__ */ new Set();
+  typeHandlers = /* @__PURE__ */ new Map();
+  readyHandlers = /* @__PURE__ */ new Set();
+  destroyHandlers = /* @__PURE__ */ new Set();
+  middlewares = [];
+  interceptors = [];
+  isProcessing = false;
+  constructor(options) {
+    this.agentId = generateAgentId();
+    this.createdAt = Date.now();
+    this.messageQueue = this._messageQueue;
+    this.driver = options.driver;
+    this.presenter = options.presenter;
+    this.machine = new MealyMachine();
+    this.stateMachine = new AgentStateMachine();
+  }
+  get state() {
+    return this.stateMachine.state;
+  }
+  async receive(message) {
+    console.log(
+      "[SimpleAgent.receive] CALLED with message:",
+      typeof message === "string" ? message : message.content
+    );
+    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;
+    this._messageQueue.enqueue(userMessage);
+    console.log("[SimpleAgent.receive] Message queued, isProcessing:", this.isProcessing);
+    if (this.isProcessing) {
+      return new Promise((resolve, reject) => {
+        userMessage._resolve = resolve;
+        userMessage._reject = reject;
+      });
+    }
+    console.log("[SimpleAgent.receive] Starting processQueue");
+    await this.processQueue();
+  }
+  async processQueue() {
+    if (this.isProcessing) return;
+    this.isProcessing = true;
+    console.log("[SimpleAgent.processQueue] Starting, queue size:", this._messageQueue.length);
+    while (!this._messageQueue.isEmpty) {
+      const message = this._messageQueue.dequeue();
+      if (!message) break;
+      console.log("[SimpleAgent.processQueue] Processing message:", message.id);
+      try {
+        await this.processMessage(message);
+        if (message._resolve) {
+          message._resolve();
+        }
+      } catch (error) {
+        if (message._reject) {
+          message._reject(error);
+        }
+        throw error;
+      }
+    }
+    this.isProcessing = false;
+    console.log("[SimpleAgent.processQueue] Finished");
+  }
+  async processMessage(message) {
+    console.log("[SimpleAgent.processMessage] START, message:", message.id);
+    let processedMessage = message;
+    for (const middleware of this.middlewares) {
+      let nextCalled = false;
+      await middleware(processedMessage, async (msg) => {
+        nextCalled = true;
+        processedMessage = msg;
+      });
+      if (!nextCalled) {
+        console.log("[SimpleAgent.processMessage] Middleware blocked message");
+        return;
+      }
+    }
+    console.log("[SimpleAgent.processMessage] Getting driver stream...");
+    const driverStream = this.driver.receive(processedMessage);
+    console.log("[SimpleAgent.processMessage] Driver stream:", driverStream);
+    try {
+      console.log("[SimpleAgent.processMessage] Starting for-await loop...");
+      for await (const streamEvent of driverStream) {
+        this.handleStreamEvent(streamEvent);
+      }
+      console.log("[SimpleAgent.processMessage] For-await loop completed");
+    } catch (error) {
+      console.log("[SimpleAgent.processMessage] ERROR:", error);
+      throw error;
+    }
+    console.log("[SimpleAgent.processMessage] END");
+  }
+  /**
+   * Handle a stream event from the driver (push-based API)
+   *
+   * This method processes a single StreamEvent through the MealyMachine
+   * and emits all resulting outputs to presenter and handlers.
+   */
+  handleStreamEvent(event) {
+    logger5.info("handleStreamEvent", { type: event.type });
+    const outputs = this.machine.process(this.agentId, event);
+    logger5.info("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) {
+        console.error("Event handler error:", e);
+      }
+    }
+    const typeSet = this.typeHandlers.get(currentOutput.type);
+    if (typeSet) {
+      for (const handler of typeSet) {
+        try {
+          handler(currentOutput);
+        } catch (e) {
+          console.error("Event handler 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) {
+      console.error("onReady handler 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") {
+      return;
+    }
+    this.driver.interrupt();
+  }
+  async destroy() {
+    if (this.state !== "idle") {
+      this.interrupt();
+    }
+    for (const handler of this.destroyHandlers) {
+      try {
+        handler();
+      } catch (e) {
+        console.error("onDestroy handler 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;
+  }
+};
+function createAgent(options) {
+  return new SimpleAgent(options);
+}
+
+exports.AgentStateMachine = AgentStateMachine;
+exports.MealyMachine = MealyMachine;
+exports.MemoryStore = MemoryStore;
+exports.agentProcessor = agentProcessor;
+exports.chainProcessors = chainProcessors;
+exports.combineInitialStates = combineInitialStates;
+exports.combineProcessors = combineProcessors;
+exports.createAgent = createAgent;
+exports.createInitialAgentEngineState = createInitialAgentEngineState;
+exports.createInitialMessageAssemblerState = createInitialMessageAssemblerState;
+exports.createInitialStateEventProcessorContext = createInitialStateEventProcessorContext;
+exports.createInitialTurnTrackerState = createInitialTurnTrackerState;
+exports.createMealyMachine = createMealyMachine;
+exports.filterProcessor = filterProcessor;
+exports.identityProcessor = identityProcessor;
+exports.mapOutput = mapOutput;
+exports.messageAssemblerProcessor = messageAssemblerProcessor;
+exports.messageAssemblerProcessorDef = messageAssemblerProcessorDef;
+exports.stateEventProcessor = stateEventProcessor;
+exports.stateEventProcessorDef = stateEventProcessorDef;
+exports.turnTrackerProcessor = turnTrackerProcessor;
+exports.turnTrackerProcessorDef = turnTrackerProcessorDef;
+exports.withLogging = withLogging;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map