@agentxjs/core 1.9.10-dev → 2.0.0

package/dist/{chunk-I7GYR3MN.js → chunk-DEAR6N3O.js}

@@ -3,13 +3,19 @@ function createInitialMessageAssemblerState() {
   return {
     currentMessageId: null,
     messageStartTime: null,
-    pendingContents: {},
+    pendingContents: [],
     pendingToolCalls: {}
   };
 }
 function generateId() {
   return `msg_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
 }
+function findLastIndex(arr, predicate) {
+  for (let i = arr.length - 1; i >= 0; i--) {
+    if (predicate(arr[i])) return i;
+  }
+  return -1;
+}
 var messageAssemblerProcessor = (state, input) => {
   switch (input.type) {
     case "message_start":
@@ -39,83 +45,74 @@ function handleMessageStart(state, event) {
       ...state,
       currentMessageId: data.messageId,
       messageStartTime: event.timestamp,
-      pendingContents: {}
+      pendingContents: []
     },
     []
   ];
 }
 function handleTextDelta(state, event) {
   const { data } = event;
-  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]
-  };
+  const lastContent = state.pendingContents[state.pendingContents.length - 1];
+  if (lastContent?.type === "text") {
+    const updated = [...state.pendingContents];
+    updated[updated.length - 1] = {
+      ...lastContent,
+      textDeltas: [...lastContent.textDeltas || [], data.text]
+    };
+    return [{ ...state, pendingContents: updated }, []];
+  }
   return [
     {
       ...state,
-      pendingContents: {
-        ...state.pendingContents,
-        [index]: pendingContent
-      }
+      pendingContents: [...state.pendingContents, { type: "text", textDeltas: [data.text] }]
     },
     []
   ];
 }
 function handleToolUseStart(state, event) {
   const { data } = event;
-  const index = 1;
-  const pendingContent = {
-    type: "tool_use",
-    index,
-    toolId: data.toolCallId,
-    toolName: data.toolName,
-    toolInputJson: ""
-  };
   return [
     {
       ...state,
-      pendingContents: {
+      pendingContents: [
         ...state.pendingContents,
-        [index]: pendingContent
-      }
+        {
+          type: "tool_use",
+          toolId: data.toolCallId,
+          toolName: data.toolName,
+          toolInputJson: ""
+        }
+      ]
     },
     []
   ];
 }
 function handleInputJsonDelta(state, event) {
   const { data } = event;
-  const index = 1;
-  const existingContent = state.pendingContents[index];
-  if (!existingContent || existingContent.type !== "tool_use") {
+  const lastToolIndex = findLastIndex(
+    state.pendingContents,
+    (c) => c.type === "tool_use" && !c.assembled
+  );
+  if (lastToolIndex === -1) {
     return [state, []];
   }
-  const pendingContent = {
+  const existingContent = state.pendingContents[lastToolIndex];
+  const updated = [...state.pendingContents];
+  updated[lastToolIndex] = {
     ...existingContent,
     toolInputJson: (existingContent.toolInputJson || "") + data.partialJson
   };
-  return [
-    {
-      ...state,
-      pendingContents: {
-        ...state.pendingContents,
-        [index]: pendingContent
-      }
-    },
-    []
-  ];
+  return [{ ...state, pendingContents: updated }, []];
 }
 function handleToolUseStop(state, _event) {
-  const index = 1;
-  const pendingContent = state.pendingContents[index];
-  if (!pendingContent || pendingContent.type !== "tool_use") {
+  const lastToolIndex = findLastIndex(
+    state.pendingContents,
+    (c) => c.type === "tool_use" && !c.assembled
+  );
+  if (lastToolIndex === -1) {
     return [state, []];
   }
+  const pendingContent = state.pendingContents[lastToolIndex];
   const toolId = pendingContent.toolId || "";
   const toolName = pendingContent.toolName || "";
   let toolInput = {};
@@ -124,38 +121,23 @@ function handleToolUseStop(state, _event) {
   } catch {
     toolInput = {};
   }
-  const toolCall = {
-    type: "tool-call",
-    id: toolId,
-    name: toolName,
-    input: toolInput
+  const updated = [...state.pendingContents];
+  updated[lastToolIndex] = {
+    ...pendingContent,
+    assembled: true,
+    parsedInput: 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,
+      pendingContents: updated,
       pendingToolCalls: {
         ...state.pendingToolCalls,
         [toolId]: { id: toolId, name: toolName }
       }
     },
-    [toolCallMessageEvent]
+    []
+    // No event emitted
   ];
 }
 function handleToolResult(state, event) {
@@ -201,16 +183,26 @@ 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) {
+  const contentParts = [];
+  for (const pending of state.pendingContents) {
     if (pending.type === "text" && pending.textDeltas) {
-      textParts.push(pending.textDeltas.join(""));
+      const text = pending.textDeltas.join("");
+      if (text.trim().length > 0) {
+        contentParts.push({ type: "text", text });
+      }
+    } else if (pending.type === "tool_use" && pending.assembled) {
+      contentParts.push({
+        type: "tool-call",
+        id: pending.toolId || "",
+        name: pending.toolName || "",
+        input: pending.parsedInput || {}
+      });
     }
   }
-  const textContent = textParts.join("");
+  const hasToolCalls = contentParts.some((p) => p.type === "tool-call");
+  const hasText = contentParts.some((p) => p.type === "text");
   const stopReason = data.stopReason;
-  if (!textContent || textContent.trim().length === 0) {
+  if (!hasText && !hasToolCalls) {
     const shouldPreserveToolCalls2 = stopReason === "tool_use";
     return [
       {
@@ -220,12 +212,6 @@ function handleMessageStop(state, event) {
       []
     ];
   }
-  const contentParts = [
-    {
-      type: "text",
-      text: textContent
-    }
-  ];
   const timestamp = state.messageStartTime || Date.now();
   const assistantMessage = {
     id: state.currentMessageId,
@@ -406,24 +392,24 @@ function generateId2() {
 }
 var turnTrackerProcessor = (state, input) => {
   switch (input.type) {
-    case "user_message":
-      return handleUserMessage(state, input);
+    case "message_start":
+      return handleMessageStart3(state, input);
     case "message_stop":
       return handleMessageStop3(state, input);
-    case "assistant_message":
-      return [state, []];
     default:
       return [state, []];
   }
 };
-function handleUserMessage(state, event) {
-  const { data } = event;
+function handleMessageStart3(state, event) {
+  if (state.pendingTurn) {
+    return [state, []];
+  }
   const turnId = generateId2();
-  const contentText = typeof data.content === "string" ? data.content : "";
+  const messageId = event.data.messageId ?? "";
   const pendingTurn = {
     turnId,
-    messageId: data.id,
-    content: contentText,
+    messageId,
+    content: "",
     requestedAt: event.timestamp
   };
   const turnRequestEvent = {
@@ -431,8 +417,8 @@ function handleUserMessage(state, event) {
     timestamp: Date.now(),
     data: {
       turnId,
-      messageId: data.id,
-      content: contentText,
+      messageId,
+      content: "",
       timestamp: event.timestamp
     }
   };
@@ -499,4 +485,4 @@ export {
   turnTrackerProcessor,
   turnTrackerProcessorDef
 };
-//# sourceMappingURL=chunk-I7GYR3MN.js.map
+//# sourceMappingURL=chunk-DEAR6N3O.js.map

package/dist/chunk-DEAR6N3O.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/agent/engine/internal/messageAssemblerProcessor.ts","../src/agent/engine/internal/stateEventProcessor.ts","../src/agent/engine/internal/turnTrackerProcessor.ts"],"sourcesContent":["/**\n * messageAssemblerProcessor\n *\n * Pure Mealy transition function that assembles complete Message Layer events\n * from Stream Layer events.\n *\n * Input Events (Stream Layer):\n * - message_start\n * - text_delta\n * - tool_use_start\n * - input_json_delta\n * - tool_use_stop\n * - tool_result\n * - message_stop\n *\n * Output Events (Message Layer):\n * - assistant_message (Message - includes text and tool calls in content)\n * - tool_result_message (Message - tool execution result)\n */\n\nimport type { Processor, ProcessorDefinition } from \"../mealy\";\nimport type {\n  // Input: StreamEvent (from agent layer)\n  StreamEvent,\n  MessageStartEvent,\n  TextDeltaEvent,\n  ToolUseStartEvent,\n  InputJsonDeltaEvent,\n  ToolResultEvent,\n  MessageStopEvent,\n  // Output: Message events\n  AssistantMessageEvent,\n  ToolResultMessageEvent,\n  ErrorMessageEvent,\n  // Message types\n  AssistantMessage,\n  ToolResultMessage,\n  ErrorMessage,\n  // Content parts\n  TextPart,\n  ToolCallPart,\n  ToolResultPart,\n} from \"../../types\";\n\n// ===== State Types =====\n\n/**\n * Pending content accumulator\n *\n * Tracks content blocks in the order they appear in the stream.\n * Text and tool_use blocks may be interleaved.\n */\nexport interface PendingContent {\n  type: \"text\" | \"tool_use\";\n  // For text content\n  textDeltas?: string[];\n  // For tool use\n  toolId?: string;\n  toolName?: string;\n  toolInputJson?: string;\n  /** True when tool_use_stop has been processed and input is fully parsed */\n  assembled?: boolean;\n  /** Parsed tool input (set at tool_use_stop time) */\n  parsedInput?: Record<string, unknown>;\n}\n\n/**\n * Pending tool call info (for matching with tool_result)\n */\nexport interface PendingToolCall {\n  id: string;\n  name: string;\n}\n\n/**\n * MessageAssemblerState\n *\n * Tracks the state of message assembly from stream events.\n */\nexport interface MessageAssemblerState {\n  /**\n   * Current message ID being assembled\n   */\n  currentMessageId: string | null;\n\n  /**\n   * Timestamp when the current message started\n   */\n  messageStartTime: number | null;\n\n  /**\n   * Pending content blocks in stream order.\n   * Preserves the interleaved order of text and tool_use blocks.\n   */\n  pendingContents: PendingContent[];\n\n  /**\n   * Pending tool calls waiting for results\n   * Key is the tool call ID\n   */\n  pendingToolCalls: Record<string, PendingToolCall>;\n}\n\n/**\n * Initial state factory for MessageAssembler\n */\nexport function createInitialMessageAssemblerState(): MessageAssemblerState {\n  return {\n    currentMessageId: null,\n    messageStartTime: null,\n    pendingContents: [],\n    pendingToolCalls: {},\n  };\n}\n\n// ===== Processor Implementation =====\n\n/**\n * Generate a unique ID\n */\nfunction generateId(): string {\n  return `msg_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;\n}\n\n/**\n * Find last index matching a predicate (Array.findLastIndex polyfill)\n */\nfunction findLastIndex<T>(arr: readonly T[], predicate: (item: T) => boolean): number {\n  for (let i = arr.length - 1; i >= 0; i--) {\n    if (predicate(arr[i])) return i;\n  }\n  return -1;\n}\n\n/**\n * Output event types from MessageAssembler\n */\nexport type MessageAssemblerOutput =\n  | AssistantMessageEvent\n  | ToolResultMessageEvent\n  | ErrorMessageEvent;\n\n/**\n * Input event types for MessageAssembler\n */\nexport type MessageAssemblerInput = StreamEvent;\n\n/**\n * messageAssemblerProcessor\n *\n * Pure Mealy transition function for message assembly.\n * Pattern: (state, input) => [newState, outputs]\n */\nexport const messageAssemblerProcessor: Processor<\n  MessageAssemblerState,\n  MessageAssemblerInput,\n  MessageAssemblerOutput\n> = (state, input): [MessageAssemblerState, MessageAssemblerOutput[]] => {\n  switch (input.type) {\n    case \"message_start\":\n      return handleMessageStart(state, input);\n\n    case \"text_delta\":\n      return handleTextDelta(state, input);\n\n    case \"tool_use_start\":\n      return handleToolUseStart(state, input);\n\n    case \"input_json_delta\":\n      return handleInputJsonDelta(state, input);\n\n    case \"tool_use_stop\":\n      return handleToolUseStop(state, input);\n\n    case \"tool_result\":\n      return handleToolResult(state, input);\n\n    case \"message_stop\":\n      return handleMessageStop(state, input);\n\n    case \"error_received\":\n      return handleErrorReceived(state, input);\n\n    default:\n      // Pass through unhandled events (no state change, no output)\n      return [state, []];\n  }\n};\n\n/**\n * Handle message_start event\n */\nfunction handleMessageStart(\n  state: Readonly<MessageAssemblerState>,\n  event: StreamEvent\n): [MessageAssemblerState, MessageAssemblerOutput[]] {\n  const { data } = event as MessageStartEvent;\n  return [\n    {\n      ...state,\n      currentMessageId: data.messageId,\n      messageStartTime: event.timestamp,\n      pendingContents: [],\n    },\n    [],\n  ];\n}\n\n/**\n * Handle text_delta event\n *\n * Appends to the last text block if one exists, otherwise creates a new one.\n * This preserves the interleaved order: text after a tool_use gets its own block.\n */\nfunction handleTextDelta(\n  state: Readonly<MessageAssemblerState>,\n  event: StreamEvent\n): [MessageAssemblerState, MessageAssemblerOutput[]] {\n  const { data } = event as TextDeltaEvent;\n  const lastContent = state.pendingContents[state.pendingContents.length - 1];\n\n  // Append to last text block if it exists\n  if (lastContent?.type === \"text\") {\n    const updated = [...state.pendingContents];\n    updated[updated.length - 1] = {\n      ...lastContent,\n      textDeltas: [...(lastContent.textDeltas || []), data.text],\n    };\n    return [{ ...state, pendingContents: updated }, []];\n  }\n\n  // Create a new text block (preserves position after any preceding tool_use)\n  return [\n    {\n      ...state,\n      pendingContents: [...state.pendingContents, { type: \"text\", textDeltas: [data.text] }],\n    },\n    [],\n  ];\n}\n\n/**\n * Handle tool_use_start event\n */\nfunction handleToolUseStart(\n  state: Readonly<MessageAssemblerState>,\n  event: StreamEvent\n): [MessageAssemblerState, MessageAssemblerOutput[]] {\n  const { data } = event as ToolUseStartEvent;\n\n  return [\n    {\n      ...state,\n      pendingContents: [\n        ...state.pendingContents,\n        {\n          type: \"tool_use\",\n          toolId: data.toolCallId,\n          toolName: data.toolName,\n          toolInputJson: \"\",\n        },\n      ],\n    },\n    [],\n  ];\n}\n\n/**\n * Handle input_json_delta event\n */\nfunction handleInputJsonDelta(\n  state: Readonly<MessageAssemblerState>,\n  event: StreamEvent\n): [MessageAssemblerState, MessageAssemblerOutput[]] {\n  const { data } = event as InputJsonDeltaEvent;\n\n  // Find the last tool_use content in the array\n  const lastToolIndex = findLastIndex(\n    state.pendingContents,\n    (c) => c.type === \"tool_use\" && !c.assembled\n  );\n  if (lastToolIndex === -1) {\n    return [state, []];\n  }\n\n  const existingContent = state.pendingContents[lastToolIndex];\n  const updated = [...state.pendingContents];\n  updated[lastToolIndex] = {\n    ...existingContent,\n    toolInputJson: (existingContent.toolInputJson || \"\") + data.partialJson,\n  };\n\n  return [{ ...state, pendingContents: updated }, []];\n}\n\n/**\n * Handle tool_use_stop event\n *\n * Marks the tool_use entry as assembled with parsed input.\n * The entry stays in pendingContents to preserve its position.\n * No event is emitted — tool calls are part of the assistant message.\n */\nfunction handleToolUseStop(\n  state: Readonly<MessageAssemblerState>,\n  _event: StreamEvent\n): [MessageAssemblerState, MessageAssemblerOutput[]] {\n  // Find the last unassembled tool_use content\n  const lastToolIndex = findLastIndex(\n    state.pendingContents,\n    (c) => c.type === \"tool_use\" && !c.assembled\n  );\n  if (lastToolIndex === -1) {\n    return [state, []];\n  }\n\n  const pendingContent = state.pendingContents[lastToolIndex];\n  const toolId = pendingContent.toolId || \"\";\n  const toolName = pendingContent.toolName || \"\";\n\n  // Parse tool input JSON\n  let toolInput: Record<string, unknown> = {};\n  try {\n    toolInput = pendingContent.toolInputJson ? JSON.parse(pendingContent.toolInputJson) : {};\n  } catch {\n    toolInput = {};\n  }\n\n  // Mark as assembled in-place (preserves position)\n  const updated = [...state.pendingContents];\n  updated[lastToolIndex] = {\n    ...pendingContent,\n    assembled: true,\n    parsedInput: toolInput,\n  };\n\n  return [\n    {\n      ...state,\n      pendingContents: updated,\n      pendingToolCalls: {\n        ...state.pendingToolCalls,\n        [toolId]: { id: toolId, name: toolName },\n      },\n    },\n    [], // No event emitted\n  ];\n}\n\n/**\n * Handle tool_result event\n *\n * Emits:\n * - tool_result_message (Message Event) - for UI display\n */\nfunction handleToolResult(\n  state: Readonly<MessageAssemblerState>,\n  event: StreamEvent\n): [MessageAssemblerState, MessageAssemblerOutput[]] {\n  const { data } = event as ToolResultEvent;\n  const { toolCallId, result, isError } = data;\n\n  // Find pending tool call\n  const pendingToolCall = state.pendingToolCalls[toolCallId];\n  const toolName = pendingToolCall?.name || \"unknown\";\n\n  // Create tool result part\n  const toolResult: ToolResultPart = {\n    type: \"tool-result\",\n    id: toolCallId,\n    name: toolName,\n    output: {\n      type: isError ? \"error-text\" : \"text\",\n      value: typeof result === \"string\" ? result : JSON.stringify(result),\n    },\n  };\n\n  // Create ToolResultMessage (complete Message object)\n  const messageId = generateId();\n  const timestamp = Date.now();\n  const toolResultMessage: ToolResultMessage = {\n    id: messageId,\n    role: \"tool\",\n    subtype: \"tool-result\",\n    toolCallId,\n    toolResult,\n    timestamp,\n  };\n\n  // Emit tool_result_message event - data is complete Message object\n  const toolResultMessageEvent: ToolResultMessageEvent = {\n    type: \"tool_result_message\",\n    timestamp,\n    data: toolResultMessage,\n  };\n\n  // Remove from pending tool calls\n  const { [toolCallId]: _, ...remainingToolCalls } = state.pendingToolCalls;\n\n  return [\n    {\n      ...state,\n      pendingToolCalls: remainingToolCalls,\n    },\n    [toolResultMessageEvent],\n  ];\n}\n\n/**\n * Handle message_stop event\n *\n * Assembles the complete AssistantMessage from pendingContents in stream order.\n * Text and tool call parts are interleaved as they appeared in the stream.\n */\nfunction handleMessageStop(\n  state: Readonly<MessageAssemblerState>,\n  event: StreamEvent\n): [MessageAssemblerState, MessageAssemblerOutput[]] {\n  const { data } = event as MessageStopEvent;\n\n  if (!state.currentMessageId) {\n    return [state, []];\n  }\n\n  // Build content parts in stream order from pendingContents\n  const contentParts: Array<TextPart | ToolCallPart> = [];\n\n  for (const pending of state.pendingContents) {\n    if (pending.type === \"text\" && pending.textDeltas) {\n      const text = pending.textDeltas.join(\"\");\n      if (text.trim().length > 0) {\n        contentParts.push({ type: \"text\", text });\n      }\n    } else if (pending.type === \"tool_use\" && pending.assembled) {\n      contentParts.push({\n        type: \"tool-call\",\n        id: pending.toolId || \"\",\n        name: pending.toolName || \"\",\n        input: pending.parsedInput || {},\n      });\n    }\n  }\n\n  const hasToolCalls = contentParts.some((p) => p.type === \"tool-call\");\n  const hasText = contentParts.some((p) => p.type === \"text\");\n\n  // Skip truly empty messages (no text AND no tool calls)\n  const stopReason = data.stopReason;\n  if (!hasText && !hasToolCalls) {\n    const shouldPreserveToolCalls = stopReason === \"tool_use\";\n    return [\n      {\n        ...createInitialMessageAssemblerState(),\n        pendingToolCalls: shouldPreserveToolCalls ? state.pendingToolCalls : {},\n      },\n      [],\n    ];\n  }\n\n  // Create AssistantMessage with interleaved content\n  const timestamp = state.messageStartTime || Date.now();\n  const assistantMessage: AssistantMessage = {\n    id: state.currentMessageId,\n    role: \"assistant\",\n    subtype: \"assistant\",\n    content: contentParts,\n    timestamp,\n  };\n\n  // Emit AssistantMessageEvent\n  const assistantEvent: AssistantMessageEvent = {\n    type: \"assistant_message\",\n    timestamp,\n    data: assistantMessage,\n  };\n\n  // Reset state, but preserve pendingToolCalls if stopReason is \"tool_use\"\n  // (tool_result events arrive after message_stop in tool call scenarios)\n  const shouldPreserveToolCalls = stopReason === \"tool_use\";\n\n  return [\n    {\n      ...createInitialMessageAssemblerState(),\n      pendingToolCalls: shouldPreserveToolCalls ? state.pendingToolCalls : {},\n    },\n    [assistantEvent],\n  ];\n}\n\n/**\n * Handle error_received event\n *\n * Emits: error_message (Message Event) - for UI display\n */\nfunction handleErrorReceived(\n  _state: Readonly<MessageAssemblerState>,\n  event: StreamEvent\n): [MessageAssemblerState, MessageAssemblerOutput[]] {\n  const data = event.data as { message: string; errorCode?: string };\n\n  // Create ErrorMessage (complete Message object)\n  const messageId = generateId();\n  const timestamp = Date.now();\n  const errorMessage: ErrorMessage = {\n    id: messageId,\n    role: \"error\",\n    subtype: \"error\",\n    content: data.message,\n    errorCode: data.errorCode,\n    timestamp,\n  };\n\n  // Emit error_message event - data is complete Message object\n  const errorMessageEvent: ErrorMessageEvent = {\n    type: \"error_message\",\n    timestamp,\n    data: errorMessage,\n  };\n\n  // Reset state on error\n  return [createInitialMessageAssemblerState(), [errorMessageEvent]];\n}\n\n/**\n * MessageAssembler Processor Definition\n */\nexport const messageAssemblerProcessorDef: ProcessorDefinition<\n  MessageAssemblerState,\n  MessageAssemblerInput,\n  MessageAssemblerOutput\n> = {\n  name: \"MessageAssembler\",\n  description: \"Assembles complete messages from stream events\",\n  initialState: createInitialMessageAssemblerState,\n  processor: messageAssemblerProcessor,\n};\n","/**\n * stateEventProcessor\n *\n * Stateless event transformer: Stream Events → State Events\n *\n * Input Events (Stream Layer):\n * - message_start\n * - message_stop\n * - text_delta (triggers responding state)\n * - tool_use_start\n * - tool_use_stop\n *\n * Output Events (State Layer):\n * - conversation_start\n * - conversation_responding\n * - conversation_end\n * - tool_planned\n * - tool_executing\n */\n\nimport type { Processor, ProcessorDefinition } from \"../mealy\";\nimport type {\n  // Base type\n  EngineEvent,\n  // Input: StreamEvent (from agent layer)\n  StreamEvent,\n  MessageStartEvent,\n  MessageStopEvent,\n  ToolUseStartEvent,\n  // Output: State events\n  ConversationStartEvent,\n  ConversationRespondingEvent,\n  ConversationEndEvent,\n  ConversationInterruptedEvent,\n  ToolPlannedEvent,\n  ToolExecutingEvent,\n  ErrorOccurredEvent,\n} from \"../../types\";\nimport { createLogger } from \"commonxjs/logger\";\n\nconst logger = createLogger(\"engine/stateEventProcessor\");\n\n// ===== State Types =====\n\n/**\n * StateEventProcessorContext\n *\n * Minimal context needed for event transformation logic.\n * Does NOT track agent state - only auxiliary info for decision-making.\n *\n * Currently empty - no context needed as all information comes from events.\n */\nexport interface StateEventProcessorContext {\n  // Empty - all information comes from events\n}\n\n/**\n * Initial context factory for StateEventProcessor\n */\nexport function createInitialStateEventProcessorContext(): StateEventProcessorContext {\n  return {};\n}\n\n// ===== Processor Implementation =====\n\n/**\n * Output event types from StateEventProcessor\n */\nexport type StateEventProcessorOutput =\n  | ConversationStartEvent\n  | ConversationRespondingEvent\n  | ConversationEndEvent\n  | ConversationInterruptedEvent\n  | ToolPlannedEvent\n  | ToolExecutingEvent\n  | ErrorOccurredEvent;\n\n/**\n * Input event types for StateEventProcessor\n */\nexport type StateEventProcessorInput = StreamEvent;\n\n/**\n * stateEventProcessor\n *\n * Stateless event transformer: Stream Events → State Events\n *\n * Design:\n * - Does NOT track agent state (that's StateMachine's job)\n * - Only maintains auxiliary context (timestamps, etc.)\n * - Emits State Events that StateMachine consumes\n *\n * Pattern: (context, input) => [newContext, outputs]\n */\nexport const stateEventProcessor: Processor<\n  StateEventProcessorContext,\n  StateEventProcessorInput,\n  StateEventProcessorOutput\n> = (context, input): [StateEventProcessorContext, StateEventProcessorOutput[]] => {\n  // Log all incoming Stream Events\n  logger.debug(`[Stream Event] ${input.type}`, {\n    context,\n    eventData: \"data\" in input ? input.data : undefined,\n  });\n\n  switch (input.type) {\n    case \"message_start\":\n      return handleMessageStart(context, input);\n\n    case \"message_delta\":\n      return handleMessageDelta(context);\n\n    case \"message_stop\":\n      return handleMessageStop(context, input);\n\n    case \"text_delta\":\n      return handleTextDelta(context);\n\n    case \"tool_use_start\":\n      return handleToolUseStart(context, input);\n\n    case \"tool_use_stop\":\n      return handleToolUseStop(context);\n\n    case \"error_received\":\n      return handleErrorReceived(context, input);\n\n    default:\n      // Pass through unhandled events\n      logger.debug(`[Stream Event] ${input.type} (unhandled)`);\n      return [context, []];\n  }\n};\n\n/**\n * Handle message_start event\n *\n * Emits: conversation_start\n */\nfunction handleMessageStart(\n  context: Readonly<StateEventProcessorContext>,\n  event: StreamEvent\n): [StateEventProcessorContext, StateEventProcessorOutput[]] {\n  const { data } = event as MessageStartEvent;\n\n  const conversationStartEvent: ConversationStartEvent = {\n    type: \"conversation_start\",\n    timestamp: Date.now(),\n    data: {\n      messageId: data.messageId,\n    },\n  };\n\n  return [context, [conversationStartEvent]];\n}\n\n/**\n * Handle message_delta event\n *\n * No longer needed as stopReason is now in message_stop event.\n * Kept for compatibility with event routing.\n */\nfunction handleMessageDelta(\n  context: Readonly<StateEventProcessorContext>\n): [StateEventProcessorContext, StateEventProcessorOutput[]] {\n  // No-op: stopReason now comes from message_stop\n  return [context, []];\n}\n\n/**\n * Handle message_stop event\n *\n * Emits: conversation_end (only if stopReason is NOT \"tool_use\")\n *\n * This event signals that Claude has finished streaming a message.\n * However, if stopReason is \"tool_use\", the conversation continues\n * because Claude will execute tools and send more messages.\n */\nfunction handleMessageStop(\n  context: Readonly<StateEventProcessorContext>,\n  event: StreamEvent\n): [StateEventProcessorContext, StateEventProcessorOutput[]] {\n  const { data } = event as MessageStopEvent;\n  const stopReason = data.stopReason;\n\n  logger.debug(\"message_stop received\", { stopReason });\n\n  // If stopReason is \"tool_use\", don't emit conversation_end\n  // The conversation continues after tool execution\n  if (stopReason === \"tool_use\") {\n    logger.debug(\"Skipping conversation_end (tool_use in progress)\");\n    return [context, []];\n  }\n\n  // For all other cases (end_turn, max_tokens, etc.), emit conversation_end\n  const conversationEndEvent: ConversationEndEvent = {\n    type: \"conversation_end\",\n    timestamp: Date.now(),\n    data: {\n      reason: \"completed\",\n    },\n  };\n\n  return [context, [conversationEndEvent]];\n}\n\n/**\n * Handle text_delta event\n *\n * Emits: conversation_responding\n */\nfunction handleTextDelta(\n  context: Readonly<StateEventProcessorContext>\n): [StateEventProcessorContext, StateEventProcessorOutput[]] {\n  const respondingEvent: ConversationRespondingEvent = {\n    type: \"conversation_responding\",\n    timestamp: Date.now(),\n    data: {},\n  };\n\n  return [context, [respondingEvent]];\n}\n\n/**\n * Handle tool_use_start event\n *\n * Emits: tool_planned, tool_executing\n */\nfunction handleToolUseStart(\n  context: Readonly<StateEventProcessorContext>,\n  event: StreamEvent\n): [StateEventProcessorContext, StateEventProcessorOutput[]] {\n  const { data } = event as ToolUseStartEvent;\n  const outputs: StateEventProcessorOutput[] = [];\n\n  // Emit ToolPlannedEvent\n  const toolPlannedEvent: ToolPlannedEvent = {\n    type: \"tool_planned\",\n    timestamp: Date.now(),\n    data: {\n      toolId: data.toolCallId,\n      toolName: data.toolName,\n    },\n  };\n  outputs.push(toolPlannedEvent);\n\n  // Emit ToolExecutingEvent\n  const toolExecutingEvent: ToolExecutingEvent = {\n    type: \"tool_executing\",\n    timestamp: Date.now(),\n    data: {\n      toolId: data.toolCallId,\n      toolName: data.toolName,\n      input: {},\n    },\n  };\n  outputs.push(toolExecutingEvent);\n\n  return [context, outputs];\n}\n\n/**\n * Handle tool_use_stop event\n *\n * Pass through - no State Event emitted.\n * StateMachine handles the state transition internally.\n */\nfunction handleToolUseStop(\n  context: Readonly<StateEventProcessorContext>\n): [StateEventProcessorContext, StateEventProcessorOutput[]] {\n  // Pass through - no State Event\n  return [context, []];\n}\n\n/**\n * Handle error_received event\n *\n * Emits: error_occurred\n */\nfunction handleErrorReceived(\n  context: Readonly<StateEventProcessorContext>,\n  event: StreamEvent\n): [StateEventProcessorContext, StateEventProcessorOutput[]] {\n  const { data } = event as EngineEvent<\"error_received\", { message: string; errorCode?: string }>;\n\n  const errorOccurredEvent: ErrorOccurredEvent = {\n    type: \"error_occurred\",\n    timestamp: Date.now(),\n    data: {\n      code: data.errorCode || \"unknown_error\",\n      message: data.message,\n      recoverable: true,\n    },\n  };\n\n  return [context, [errorOccurredEvent]];\n}\n\n/**\n * StateEvent Processor Definition\n *\n * Stateless event transformer: Stream Events → State Events\n */\nexport const stateEventProcessorDef: ProcessorDefinition<\n  StateEventProcessorContext,\n  StateEventProcessorInput,\n  StateEventProcessorOutput\n> = {\n  name: \"StateEventProcessor\",\n  description: \"Transform Stream Events into State Events\",\n  initialState: createInitialStateEventProcessorContext,\n  processor: stateEventProcessor,\n};\n","/**\n * turnTrackerProcessor\n *\n * Pure Mealy transition function that tracks request-response turn pairs.\n * Derives turn events entirely from stream-layer events (no external injection).\n *\n * Input Events (Stream Layer):\n * - message_start → emit turn_request (a new turn begins)\n * - message_stop  → emit turn_response (turn completes, based on stop reason)\n *\n * Output Events (Turn Layer):\n * - turn_request\n * - turn_response\n */\n\nimport type { Processor, ProcessorDefinition } from \"../mealy\";\nimport type {\n  StreamEvent,\n  MessageStartEvent,\n  MessageStopEvent,\n  // Output: Turn events\n  TurnRequestEvent,\n  TurnResponseEvent,\n  // Data types\n  TokenUsage,\n} from \"../../types\";\n\n// ===== State Types =====\n\n/**\n * Pending turn tracking\n */\nexport interface PendingTurn {\n  turnId: string;\n  messageId: string;\n  content: string;\n  requestedAt: number;\n}\n\n/**\n * TurnTrackerState\n *\n * Tracks the current turn state.\n */\nexport interface TurnTrackerState {\n  /**\n   * Currently pending turn (waiting for response)\n   */\n  pendingTurn: PendingTurn | null;\n\n  /**\n   * Cost per input token (USD)\n   */\n  costPerInputToken: number;\n\n  /**\n   * Cost per output token (USD)\n   */\n  costPerOutputToken: number;\n}\n\n/**\n * Initial state factory for TurnTracker\n */\nexport function createInitialTurnTrackerState(): TurnTrackerState {\n  return {\n    pendingTurn: null,\n    costPerInputToken: 0.000003, // $3 per 1M tokens\n    costPerOutputToken: 0.000015, // $15 per 1M tokens\n  };\n}\n\n// ===== Processor Implementation =====\n\n/**\n * Generate a unique ID\n */\nfunction generateId(): string {\n  return `turn_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;\n}\n\n/**\n * Output event types from TurnTracker\n */\nexport type TurnTrackerOutput = TurnRequestEvent | TurnResponseEvent;\n\n/**\n * Input event types for TurnTracker\n * Only stream-layer events — turn events are derived, not injected.\n */\nexport type TurnTrackerInput = StreamEvent;\n\n/**\n * turnTrackerProcessor\n *\n * Pure Mealy transition function for turn tracking.\n * Pattern: (state, input) => [newState, outputs]\n */\nexport const turnTrackerProcessor: Processor<\n  TurnTrackerState,\n  TurnTrackerInput,\n  TurnTrackerOutput\n> = (state, input): [TurnTrackerState, TurnTrackerOutput[]] => {\n  switch (input.type) {\n    case \"message_start\":\n      return handleMessageStart(state, input as MessageStartEvent);\n\n    case \"message_stop\":\n      return handleMessageStop(state, input as StreamEvent);\n\n    default:\n      return [state, []];\n  }\n};\n\n/**\n * Handle message_start event — a new turn begins\n */\nfunction handleMessageStart(\n  state: Readonly<TurnTrackerState>,\n  event: MessageStartEvent\n): [TurnTrackerState, TurnTrackerOutput[]] {\n  // If there's already a pending turn (e.g. tool_use didn't end the turn),\n  // don't start a new one\n  if (state.pendingTurn) {\n    return [state, []];\n  }\n\n  const turnId = generateId();\n  const messageId = event.data.messageId ?? \"\";\n\n  const pendingTurn: PendingTurn = {\n    turnId,\n    messageId,\n    content: \"\",\n    requestedAt: event.timestamp,\n  };\n\n  const turnRequestEvent: TurnRequestEvent = {\n    type: \"turn_request\",\n    timestamp: Date.now(),\n    data: {\n      turnId,\n      messageId,\n      content: \"\",\n      timestamp: event.timestamp,\n    },\n  };\n\n  return [\n    {\n      ...state,\n      pendingTurn,\n    },\n    [turnRequestEvent],\n  ];\n}\n\n/**\n * Handle message_stop event\n */\nfunction handleMessageStop(\n  state: Readonly<TurnTrackerState>,\n  event: StreamEvent\n): [TurnTrackerState, TurnTrackerOutput[]] {\n  if (!state.pendingTurn) {\n    return [state, []];\n  }\n\n  const { data } = event as MessageStopEvent;\n  const stopReason = data.stopReason;\n\n  // Complete turn based on stop reason\n  // - \"end_turn\": Normal completion (no tool use)\n  // - \"tool_use\": Tool calling in progress, DON'T complete yet\n  // - \"max_tokens\": Hit token limit, complete turn\n  // - \"stop_sequence\": Hit stop sequence, complete turn\n  if (stopReason === \"end_turn\" || stopReason === \"max_tokens\" || stopReason === \"stop_sequence\") {\n    return completeTurn(state, event.timestamp);\n  }\n\n  // For tool_use, don't complete turn yet\n  return [state, []];\n}\n\n/**\n * Complete the turn and emit TurnResponseEvent\n */\nfunction completeTurn(\n  state: Readonly<TurnTrackerState>,\n  completedAt: number\n): [TurnTrackerState, TurnTrackerOutput[]] {\n  if (!state.pendingTurn) {\n    return [state, []];\n  }\n\n  const { turnId, messageId, requestedAt } = state.pendingTurn;\n  const duration = completedAt - requestedAt;\n\n  const usage: TokenUsage = { inputTokens: 0, outputTokens: 0 };\n\n  const turnResponseEvent: TurnResponseEvent = {\n    type: \"turn_response\",\n    timestamp: Date.now(),\n    data: {\n      turnId,\n      messageId,\n      duration,\n      usage,\n      timestamp: completedAt,\n    },\n  };\n\n  return [\n    {\n      ...state,\n      pendingTurn: null,\n    },\n    [turnResponseEvent],\n  ];\n}\n\n/**\n * TurnTracker Processor Definition\n */\nexport const turnTrackerProcessorDef: ProcessorDefinition<\n  TurnTrackerState,\n  TurnTrackerInput,\n  TurnTrackerOutput\n> = {\n  name: \"TurnTracker\",\n  description: \"Tracks request-response turn pairs\",\n  initialState: createInitialTurnTrackerState,\n  processor: turnTrackerProcessor,\n};\n"],"mappings":"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","names":["shouldPreserveToolCalls","handleMessageStart","handleMessageStop","handleTextDelta","handleToolUseStart","handleToolUseStop","handleErrorReceived","generateId","handleMessageStart","handleMessageStop"]}

package/dist/chunk-FI7WQFGV.js

@@ -0,0 +1,37 @@
+// src/bash/tool.ts
+function createBashTool(provider) {
+  return {
+    name: "bash",
+    description: "Execute a shell command and return stdout, stderr, and exit code. Use this for running CLI tools, scripts, file operations, etc.",
+    parameters: {
+      type: "object",
+      properties: {
+        command: {
+          type: "string",
+          description: "Shell command to execute (e.g. 'ls -la', 'cat file.txt')"
+        },
+        cwd: {
+          type: "string",
+          description: "Working directory for the command (optional)"
+        },
+        timeout: {
+          type: "number",
+          description: "Timeout in milliseconds (optional, default 30000)"
+        }
+      },
+      required: ["command"]
+    },
+    execute: async (params) => {
+      const result = await provider.execute(params.command, {
+        cwd: params.cwd,
+        timeout: params.timeout
+      });
+      return result;
+    }
+  };
+}
+
+export {
+  createBashTool
+};
+//# sourceMappingURL=chunk-FI7WQFGV.js.map

package/dist/chunk-FI7WQFGV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/bash/tool.ts"],"sourcesContent":["/**\n * Bash Tool Definition\n *\n * Creates a ToolDefinition that wraps a BashProvider.\n * The tool schema is sent to the LLM, the execute function\n * delegates to the platform-provided BashProvider via closure.\n */\n\nimport type { ToolDefinition } from \"../driver/types\";\nimport type { BashProvider } from \"./types\";\n\n/**\n * Create a bash ToolDefinition from a BashProvider\n *\n * @param provider - Platform-provided BashProvider\n * @returns ToolDefinition ready for DriverConfig.tools\n *\n * @example\n * ```typescript\n * if (platform.bashProvider) {\n *   tools.push(createBashTool(platform.bashProvider));\n * }\n * ```\n */\nexport function createBashTool(provider: BashProvider): ToolDefinition {\n  return {\n    name: \"bash\",\n    description:\n      \"Execute a shell command and return stdout, stderr, and exit code. \" +\n      \"Use this for running CLI tools, scripts, file operations, etc.\",\n    parameters: {\n      type: \"object\",\n      properties: {\n        command: {\n          type: \"string\",\n          description: \"Shell command to execute (e.g. 'ls -la', 'cat file.txt')\",\n        },\n        cwd: {\n          type: \"string\",\n          description: \"Working directory for the command (optional)\",\n        },\n        timeout: {\n          type: \"number\",\n          description: \"Timeout in milliseconds (optional, default 30000)\",\n        },\n      },\n      required: [\"command\"],\n    },\n    execute: async (params) => {\n      const result = await provider.execute(params.command as string, {\n        cwd: params.cwd as string | undefined,\n        timeout: params.timeout as number | undefined,\n      });\n      return result;\n    },\n  };\n}\n"],"mappings":";AAwBO,SAAS,eAAe,UAAwC;AACrE,SAAO;AAAA,IACL,MAAM;AAAA,IACN,aACE;AAAA,IAEF,YAAY;AAAA,MACV,MAAM;AAAA,MACN,YAAY;AAAA,QACV,SAAS;AAAA,UACP,MAAM;AAAA,UACN,aAAa;AAAA,QACf;AAAA,QACA,KAAK;AAAA,UACH,MAAM;AAAA,UACN,aAAa;AAAA,QACf;AAAA,QACA,SAAS;AAAA,UACP,MAAM;AAAA,UACN,aAAa;AAAA,QACf;AAAA,MACF;AAAA,MACA,UAAU,CAAC,SAAS;AAAA,IACtB;AAAA,IACA,SAAS,OAAO,WAAW;AACzB,YAAM,SAAS,MAAM,SAAS,QAAQ,OAAO,SAAmB;AAAA,QAC9D,KAAK,OAAO;AAAA,QACZ,SAAS,OAAO;AAAA,MAClB,CAAC;AACD,aAAO;AAAA,IACT;AAAA,EACF;AACF;","names":[]}

package/dist/{chunk-AT5P47YA.js → chunk-JTKCV7IS.js}

@@ -1,8 +1,3 @@
-import {
-  MemoryStore,
-  combineInitialStates,
-  combineProcessors
-} from "./chunk-EKHT54KN.js";
 import {
   createInitialMessageAssemblerState,
   createInitialStateEventProcessorContext,
@@ -10,13 +5,18 @@ import {
   messageAssemblerProcessor,
   stateEventProcessor,
   turnTrackerProcessor
-} from "./chunk-I7GYR3MN.js";
+} from "./chunk-DEAR6N3O.js";
+import {
+  MemoryStore,
+  combineInitialStates,
+  combineProcessors
+} from "./chunk-EKHT54KN.js";
 import {
   isStateEvent
-} from "./chunk-K6WXQ2RW.js";
+} from "./chunk-23UUBQXR.js";
 import {
   isDriveableEvent
-} from "./chunk-E5FPOAPO.js";
+} from "./chunk-LTVNPHST.js";
 
 // src/agent/engine/AgentProcessor.ts
 var agentProcessor = combineProcessors({
@@ -540,4 +540,4 @@ export {
   AgentStateMachine,
   createAgent
 };
-//# sourceMappingURL=chunk-AT5P47YA.js.map
+//# sourceMappingURL=chunk-JTKCV7IS.js.map

package/dist/chunk-JTKCV7IS.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_result_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"]}

package/dist/{chunk-E5FPOAPO.js → chunk-LTVNPHST.js}

@@ -120,4 +120,4 @@ export {
   isCommandRequest,
   isCommandResponse
 };
-//# sourceMappingURL=chunk-E5FPOAPO.js.map
+//# sourceMappingURL=chunk-LTVNPHST.js.map