@agentxjs/core 1.9.5-dev → 1.9.7-dev

package/dist/chunk-I7GYR3MN.js

@@ -0,0 +1,502 @@
+// src/agent/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, input);
+    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;
+  return [
+    {
+      ...state,
+      currentMessageId: data.messageId,
+      messageStartTime: event.timestamp,
+      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]
+  };
+  return [
+    {
+      ...state,
+      pendingContents: {
+        ...state.pendingContents,
+        [index]: pendingContent
+      }
+    },
+    []
+  ];
+}
+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: {
+        ...state.pendingContents,
+        [index]: pendingContent
+      }
+    },
+    []
+  ];
+}
+function handleInputJsonDelta(state, event) {
+  const { data } = event;
+  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;
+  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;
+  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
+};
+
+// src/agent/engine/internal/stateEventProcessor.ts
+import { createLogger } from "commonxjs/logger";
+var logger = createLogger("engine/stateEventProcessor");
+function createInitialStateEventProcessorContext() {
+  return {};
+}
+var stateEventProcessor = (context, input) => {
+  logger.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:
+      logger.debug(`[Stream Event] ${input.type} (unhandled)`);
+      return [context, []];
+  }
+};
+function handleMessageStart2(context, event) {
+  const { data } = event;
+  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;
+  const stopReason = data.stopReason;
+  logger.debug("message_stop received", { stopReason });
+  if (stopReason === "tool_use") {
+    logger.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;
+  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;
+  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/agent/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;
+  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;
+  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
+};
+
+export {
+  createInitialMessageAssemblerState,
+  messageAssemblerProcessor,
+  messageAssemblerProcessorDef,
+  createInitialStateEventProcessorContext,
+  stateEventProcessor,
+  stateEventProcessorDef,
+  createInitialTurnTrackerState,
+  turnTrackerProcessor,
+  turnTrackerProcessorDef
+};
+//# sourceMappingURL=chunk-I7GYR3MN.js.map

package/dist/chunk-I7GYR3MN.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 * - tool_call_message (Message - AI's request to call a tool)\n * - tool_result_message (Message - tool execution result)\n * - assistant_message (Message - complete assistant response)\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  ToolCallMessageEvent,\n  ToolResultMessageEvent,\n  ErrorMessageEvent,\n  // Message types\n  AssistantMessage,\n  ToolCallMessage,\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 */\nexport interface PendingContent {\n  type: \"text\" | \"tool_use\";\n  index: number;\n  // For text content\n  textDeltas?: string[];\n  // For tool use\n  toolId?: string;\n  toolName?: string;\n  toolInputJson?: string;\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 being accumulated\n   * Key is the content block index\n   */\n  pendingContents: Record<number, 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 * Output event types from MessageAssembler\n */\nexport type MessageAssemblerOutput =\n  | AssistantMessageEvent\n  | ToolCallMessageEvent\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 */\nfunction handleTextDelta(\n  state: Readonly<MessageAssemblerState>,\n  event: StreamEvent\n): [MessageAssemblerState, MessageAssemblerOutput[]] {\n  const { data } = event as TextDeltaEvent;\n  const index = 0; // Text content uses index 0\n  const existingContent = state.pendingContents[index];\n\n  const pendingContent: PendingContent =\n    existingContent?.type === \"text\"\n      ? {\n          ...existingContent,\n          textDeltas: [...(existingContent.textDeltas || []), data.text],\n        }\n      : {\n          type: \"text\",\n          index,\n          textDeltas: [data.text],\n        };\n\n  return [\n    {\n      ...state,\n      pendingContents: {\n        ...state.pendingContents,\n        [index]: pendingContent,\n      },\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  const index = 1; // Tool use uses index 1\n\n  const pendingContent: PendingContent = {\n    type: \"tool_use\",\n    index,\n    toolId: data.toolCallId,\n    toolName: data.toolName,\n    toolInputJson: \"\",\n  };\n\n  return [\n    {\n      ...state,\n      pendingContents: {\n        ...state.pendingContents,\n        [index]: pendingContent,\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  const index = 1; // Tool use uses index 1\n  const existingContent = state.pendingContents[index];\n\n  if (!existingContent || existingContent.type !== \"tool_use\") {\n    // No pending tool_use content, ignore\n    return [state, []];\n  }\n\n  const pendingContent: PendingContent = {\n    ...existingContent,\n    toolInputJson: (existingContent.toolInputJson || \"\") + data.partialJson,\n  };\n\n  return [\n    {\n      ...state,\n      pendingContents: {\n        ...state.pendingContents,\n        [index]: pendingContent,\n      },\n    },\n    [],\n  ];\n}\n\n/**\n * Handle tool_use_stop event\n *\n * Emits:\n * - tool_call_message (Message Event) - for UI display and tool execution\n */\nfunction handleToolUseStop(\n  state: Readonly<MessageAssemblerState>,\n  _event: StreamEvent\n): [MessageAssemblerState, MessageAssemblerOutput[]] {\n  const index = 1;\n  const pendingContent = state.pendingContents[index];\n\n  if (!pendingContent || pendingContent.type !== \"tool_use\") {\n    return [state, []];\n  }\n\n  // Get tool info from pendingContent (saved during tool_use_start)\n  const toolId = pendingContent.toolId || \"\";\n  const toolName = pendingContent.toolName || \"\";\n\n  // Parse tool input JSON (accumulated during input_json_delta)\n  let toolInput: Record<string, unknown> = {};\n  try {\n    toolInput = pendingContent.toolInputJson ? JSON.parse(pendingContent.toolInputJson) : {};\n  } catch {\n    // Failed to parse, use empty object\n    toolInput = {};\n  }\n\n  // Create ToolCallPart\n  const toolCall: ToolCallPart = {\n    type: \"tool-call\",\n    id: toolId,\n    name: toolName,\n    input: toolInput,\n  };\n\n  // Create ToolCallMessage (complete Message object)\n  // parentId links this tool call to its parent assistant message\n  const messageId = generateId();\n  const timestamp = Date.now();\n  const toolCallMessage: ToolCallMessage = {\n    id: messageId,\n    role: \"assistant\",\n    subtype: \"tool-call\",\n    toolCall,\n    timestamp,\n    parentId: state.currentMessageId || undefined,\n  };\n\n  // Emit tool_call_message event - data is complete Message object\n  const toolCallMessageEvent: ToolCallMessageEvent = {\n    type: \"tool_call_message\",\n    timestamp,\n    data: toolCallMessage,\n  };\n\n  // Remove from pending contents, add to pending tool calls\n  const { [index]: _, ...remainingContents } = state.pendingContents;\n\n  return [\n    {\n      ...state,\n      pendingContents: remainingContents,\n      pendingToolCalls: {\n        ...state.pendingToolCalls,\n        [toolId]: { id: toolId, name: toolName },\n      },\n    },\n    [toolCallMessageEvent],\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 */\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  // Assemble all text content\n  const textParts: string[] = [];\n  const sortedContents = Object.values(state.pendingContents).sort((a, b) => a.index - b.index);\n\n  for (const pending of sortedContents) {\n    if (pending.type === \"text\" && pending.textDeltas) {\n      textParts.push(pending.textDeltas.join(\"\"));\n    }\n  }\n\n  const textContent = textParts.join(\"\");\n\n  // Skip empty messages (but preserve pendingToolCalls if stopReason is \"tool_use\")\n  const stopReason = data.stopReason;\n  if (!textContent || textContent.trim().length === 0) {\n    const shouldPreserveToolCalls = stopReason === \"tool_use\";\n    return [\n      {\n        ...createInitialMessageAssemblerState(),\n        pendingToolCalls: shouldPreserveToolCalls ? state.pendingToolCalls : {},\n      },\n      [],\n    ];\n  }\n\n  // Create content parts (new structure uses ContentPart[])\n  const contentParts: TextPart[] = [\n    {\n      type: \"text\",\n      text: textContent,\n    },\n  ];\n\n  // Create AssistantMessage (complete Message object)\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 - data is complete Message object\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 *\n * Input Events:\n * - user_message (Message Layer)\n * - message_stop (Stream Layer - contains stop reason)\n * - assistant_message (Message Layer)\n *\n * Output Events (Turn Layer):\n * - turn_request\n * - turn_response\n */\n\nimport type { Processor, ProcessorDefinition } from \"../mealy\";\nimport type {\n  // Input: combined stream and message events\n  StreamEvent,\n  AgentMessageEvent,\n  MessageStopEvent,\n  UserMessageEvent,\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 * Accepts both Stream and Message layer events\n */\nexport type TurnTrackerInput = StreamEvent | AgentMessageEvent;\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 \"user_message\":\n      return handleUserMessage(state, input as AgentMessageEvent);\n\n    case \"message_stop\":\n      return handleMessageStop(state, input as StreamEvent);\n\n    case \"assistant_message\":\n      // Turn completion is handled in message_stop\n      // This handler is kept for potential future use\n      return [state, []];\n\n    default:\n      return [state, []];\n  }\n};\n\n/**\n * Handle user_message event\n */\nfunction handleUserMessage(\n  state: Readonly<TurnTrackerState>,\n  event: AgentMessageEvent\n): [TurnTrackerState, TurnTrackerOutput[]] {\n  const { data } = event as UserMessageEvent;\n  const turnId = generateId();\n\n  // Extract content as string (UserMessage.content can be string or array)\n  const contentText = typeof data.content === \"string\" ? data.content : \"\";\n\n  const pendingTurn: PendingTurn = {\n    turnId,\n    messageId: data.id,\n    content: contentText,\n    requestedAt: event.timestamp,\n  };\n\n  const turnRequestEvent: TurnRequestEvent = {\n    type: \"turn_request\",\n    timestamp: Date.now(),\n    data: {\n      turnId,\n      messageId: data.id,\n      content: contentText,\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","handleMessageStop"]}

package/dist/chunk-K6WXQ2RW.js

@@ -0,0 +1,38 @@
+// src/agent/types/event.ts
+function isStateEvent(event) {
+  const stateTypes = [
+    "conversation_queued",
+    "conversation_start",
+    "conversation_thinking",
+    "conversation_responding",
+    "conversation_end",
+    "conversation_interrupted",
+    "tool_planned",
+    "tool_executing",
+    "tool_completed",
+    "tool_failed",
+    "error_occurred"
+  ];
+  return stateTypes.includes(event.type);
+}
+function isMessageEvent(event) {
+  const messageTypes = [
+    "user_message",
+    "assistant_message",
+    "tool_call_message",
+    "tool_result_message",
+    "error_message"
+  ];
+  return messageTypes.includes(event.type);
+}
+function isTurnEvent(event) {
+  const turnTypes = ["turn_request", "turn_response"];
+  return turnTypes.includes(event.type);
+}
+
+export {
+  isStateEvent,
+  isMessageEvent,
+  isTurnEvent
+};
+//# sourceMappingURL=chunk-K6WXQ2RW.js.map

package/dist/chunk-K6WXQ2RW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/agent/types/event.ts"],"sourcesContent":["/**\n * Event Types - Stream, State, Message, and Turn Events\n *\n * This file defines all event types for the AgentEngine:\n * - Base EngineEvent type\n * - Stream Events: message_start, text_delta, tool_use_*, etc.\n * - State Events: conversation_*, tool_*, error_*\n * - Message Events: user_message, assistant_message, etc.\n * - Turn Events: turn_request, turn_response\n * - AgentOutput: Union of all output events\n *\n * @packageDocumentation\n */\n\nimport type {\n  UserMessage,\n  AssistantMessage,\n  ToolCallMessage,\n  ToolResultMessage,\n  ErrorMessage,\n  TokenUsage,\n} from \"./message\";\n\n// =============================================================================\n// Base Types\n// =============================================================================\n\n/**\n * EngineEvent - Lightweight event base for AgentEngine domain\n *\n * EngineEvent is the simplified event structure used inside AgentEngine.\n * It only contains: type, timestamp, data\n *\n * This is a self-contained type without external dependencies.\n * All specific event types (StreamEvent, StateEvent, etc.) extend this base.\n */\nexport interface EngineEvent<T extends string = string, D = unknown> {\n  /**\n   * Event type identifier (e.g., \"text_delta\", \"assistant_message\")\n   */\n  readonly type: T;\n\n  /**\n   * Event timestamp (Unix milliseconds)\n   */\n  readonly timestamp: number;\n\n  /**\n   * Event payload data\n   */\n  readonly data: D;\n}\n\n/**\n * @deprecated Use EngineEvent instead\n */\nexport type AgentEvent<T extends string = string, D = unknown> = EngineEvent<T, D>;\n\n// =============================================================================\n// Agent State\n// =============================================================================\n\n/**\n * AgentState\n *\n * Agent conversation states for fine-grained monitoring.\n *\n * State transitions:\n * ```\n * idle -> thinking -> responding -> idle\n *                        |\n *               planning_tool -> awaiting_tool_result\n *                        |\n *                    thinking -> responding -> idle\n *\n * Any state can transition to error:\n * thinking/responding/planning_tool/awaiting_tool_result -> error -> idle\n * ```\n */\nexport type AgentState =\n  | \"idle\" // Waiting for user input\n  | \"thinking\" // LLM is thinking\n  | \"responding\" // LLM is generating response\n  | \"planning_tool\" // Generating tool call parameters\n  | \"awaiting_tool_result\" // Waiting for tool execution result\n  | \"error\"; // Error occurred during processing\n\n// =============================================================================\n// Agent Error\n// =============================================================================\n\n/**\n * Error category\n */\nexport type AgentErrorCategory =\n  | \"network\" // Network/API errors\n  | \"validation\" // Input validation errors\n  | \"system\" // Internal system errors\n  | \"business\"; // Business logic errors\n\n/**\n * AgentError - Standardized error structure\n */\nexport interface AgentError {\n  /**\n   * Error category\n   */\n  category: AgentErrorCategory;\n\n  /**\n   * Error code (e.g., \"NETWORK_TIMEOUT\", \"INVALID_INPUT\")\n   */\n  code: string;\n\n  /**\n   * Human-readable error message\n   */\n  message: string;\n\n  /**\n   * Whether the error is recoverable\n   */\n  recoverable: boolean;\n\n  /**\n   * Original error (if any)\n   */\n  cause?: Error;\n\n  /**\n   * Additional context\n   */\n  context?: Record<string, unknown>;\n}\n\n// =============================================================================\n// Stream Events\n// =============================================================================\n\n/**\n * Stop reason for message completion\n */\nexport type StopReason = \"end_turn\" | \"max_tokens\" | \"stop_sequence\" | \"tool_use\";\n\n// --- Stream Event Data Types ---\n\nexport interface MessageStartData {\n  messageId: string;\n  model: string;\n}\n\nexport interface MessageDeltaData {\n  usage?: {\n    inputTokens: number;\n    outputTokens: number;\n  };\n}\n\nexport interface MessageStopData {\n  stopReason?: StopReason;\n}\n\nexport interface TextDeltaData {\n  text: string;\n}\n\nexport interface ToolUseStartData {\n  toolCallId: string;\n  toolName: string;\n}\n\nexport interface InputJsonDeltaData {\n  partialJson: string;\n}\n\nexport interface ToolUseStopData {\n  toolCallId: string;\n  toolName: string;\n  input: Record<string, unknown>;\n}\n\nexport interface ToolResultData {\n  toolCallId: string;\n  result: unknown;\n  isError?: boolean;\n}\n\nexport interface ErrorReceivedData {\n  message: string;\n  errorCode?: string;\n}\n\n// --- Stream Event Types ---\n\nexport type MessageStartEvent = EngineEvent<\"message_start\", MessageStartData>;\nexport type MessageDeltaEvent = EngineEvent<\"message_delta\", MessageDeltaData>;\nexport type MessageStopEvent = EngineEvent<\"message_stop\", MessageStopData>;\nexport type TextDeltaEvent = EngineEvent<\"text_delta\", TextDeltaData>;\nexport type ToolUseStartEvent = EngineEvent<\"tool_use_start\", ToolUseStartData>;\nexport type InputJsonDeltaEvent = EngineEvent<\"input_json_delta\", InputJsonDeltaData>;\nexport type ToolUseStopEvent = EngineEvent<\"tool_use_stop\", ToolUseStopData>;\nexport type ToolResultEvent = EngineEvent<\"tool_result\", ToolResultData>;\nexport type ErrorReceivedEvent = EngineEvent<\"error_received\", ErrorReceivedData>;\n\n/**\n * StreamEvent - All lightweight stream events\n */\nexport type StreamEvent =\n  | MessageStartEvent\n  | MessageDeltaEvent\n  | MessageStopEvent\n  | TextDeltaEvent\n  | ToolUseStartEvent\n  | InputJsonDeltaEvent\n  | ToolUseStopEvent\n  | ToolResultEvent\n  | ErrorReceivedEvent;\n\n/**\n * StreamEventType - String literal union\n */\nexport type StreamEventType = StreamEvent[\"type\"];\n\n// =============================================================================\n// State Events\n// =============================================================================\n\n// --- State Event Data Types ---\n\nexport interface ConversationQueuedData {\n  messageId: string;\n}\n\nexport interface ConversationStartData {\n  messageId: string;\n}\n\nexport interface ConversationThinkingData {\n  // Empty\n}\n\nexport interface ConversationRespondingData {\n  // Empty\n}\n\nexport interface ConversationEndData {\n  reason: \"completed\" | \"interrupted\" | \"error\";\n}\n\nexport interface ConversationInterruptedData {\n  reason: string;\n}\n\nexport interface ToolPlannedData {\n  toolId: string;\n  toolName: string;\n}\n\nexport interface ToolExecutingData {\n  toolId: string;\n  toolName: string;\n  input: Record<string, unknown>;\n}\n\nexport interface ToolCompletedData {\n  toolId: string;\n  toolName: string;\n  result: unknown;\n}\n\nexport interface ToolFailedData {\n  toolId: string;\n  toolName: string;\n  error: string;\n}\n\nexport interface ErrorOccurredData {\n  code: string;\n  message: string;\n  recoverable: boolean;\n  category?: string;\n}\n\n/**\n * StateEvent - Base type for state events\n * @deprecated Use specific event types instead\n */\nexport interface StateEvent<T extends string = string, D = unknown> extends EngineEvent<T, D> {}\n\n// --- State Event Types ---\n\nexport type ConversationQueuedEvent = EngineEvent<\"conversation_queued\", ConversationQueuedData>;\nexport type ConversationStartEvent = EngineEvent<\"conversation_start\", ConversationStartData>;\nexport type ConversationThinkingEvent = EngineEvent<\n  \"conversation_thinking\",\n  ConversationThinkingData\n>;\nexport type ConversationRespondingEvent = EngineEvent<\n  \"conversation_responding\",\n  ConversationRespondingData\n>;\nexport type ConversationEndEvent = EngineEvent<\"conversation_end\", ConversationEndData>;\nexport type ConversationInterruptedEvent = EngineEvent<\n  \"conversation_interrupted\",\n  ConversationInterruptedData\n>;\nexport type ToolPlannedEvent = EngineEvent<\"tool_planned\", ToolPlannedData>;\nexport type ToolExecutingEvent = EngineEvent<\"tool_executing\", ToolExecutingData>;\nexport type ToolCompletedEvent = EngineEvent<\"tool_completed\", ToolCompletedData>;\nexport type ToolFailedEvent = EngineEvent<\"tool_failed\", ToolFailedData>;\nexport type ErrorOccurredEvent = EngineEvent<\"error_occurred\", ErrorOccurredData>;\n\n/**\n * Alias for ErrorOccurredEvent (legacy compatibility)\n */\nexport type AgentErrorOccurredEvent = ErrorOccurredEvent;\n\n/**\n * AgentStateEvent - All lightweight state events\n */\nexport type AgentStateEvent =\n  // Conversation\n  | ConversationQueuedEvent\n  | ConversationStartEvent\n  | ConversationThinkingEvent\n  | ConversationRespondingEvent\n  | ConversationEndEvent\n  | ConversationInterruptedEvent\n  // Tool\n  | ToolPlannedEvent\n  | ToolExecutingEvent\n  | ToolCompletedEvent\n  | ToolFailedEvent\n  // Error\n  | ErrorOccurredEvent;\n\n/**\n * Type guard: is this a state event?\n */\nexport function isStateEvent(event: EngineEvent): event is AgentStateEvent {\n  const stateTypes = [\n    \"conversation_queued\",\n    \"conversation_start\",\n    \"conversation_thinking\",\n    \"conversation_responding\",\n    \"conversation_end\",\n    \"conversation_interrupted\",\n    \"tool_planned\",\n    \"tool_executing\",\n    \"tool_completed\",\n    \"tool_failed\",\n    \"error_occurred\",\n  ];\n  return stateTypes.includes(event.type);\n}\n\n// =============================================================================\n// Message Events\n// =============================================================================\n\n/**\n * MessageEvent - Base type for message events\n * @deprecated Use specific event types instead\n */\nexport interface MessageEvent<T extends string = string, D = unknown> extends EngineEvent<T, D> {}\n\n// --- Message Event Types ---\n\nexport type UserMessageEvent = EngineEvent<\"user_message\", UserMessage>;\nexport type AssistantMessageEvent = EngineEvent<\"assistant_message\", AssistantMessage>;\nexport type ToolCallMessageEvent = EngineEvent<\"tool_call_message\", ToolCallMessage>;\nexport type ToolResultMessageEvent = EngineEvent<\"tool_result_message\", ToolResultMessage>;\nexport type ErrorMessageEvent = EngineEvent<\"error_message\", ErrorMessage>;\n\n/**\n * AgentMessageEvent - All lightweight message events\n */\nexport type AgentMessageEvent =\n  | UserMessageEvent\n  | AssistantMessageEvent\n  | ToolCallMessageEvent\n  | ToolResultMessageEvent\n  | ErrorMessageEvent;\n\n/**\n * Type guard: is this a message event?\n */\nexport function isMessageEvent(event: EngineEvent): event is AgentMessageEvent {\n  const messageTypes = [\n    \"user_message\",\n    \"assistant_message\",\n    \"tool_call_message\",\n    \"tool_result_message\",\n    \"error_message\",\n  ];\n  return messageTypes.includes(event.type);\n}\n\n// =============================================================================\n// Turn Events\n// =============================================================================\n\n// --- Turn Event Data Types ---\n\nexport interface TurnRequestData {\n  turnId: string;\n  messageId: string;\n  content: string;\n  timestamp: number;\n}\n\nexport interface TurnResponseData {\n  turnId: string;\n  messageId: string;\n  duration: number;\n  usage?: TokenUsage;\n  model?: string;\n  stopReason?: string;\n  timestamp: number;\n}\n\n/**\n * TurnEvent - Base type for turn events\n * @deprecated Use specific event types instead\n */\nexport interface TurnEvent<T extends string = string, D = unknown> extends EngineEvent<T, D> {}\n\n// --- Turn Event Types ---\n\nexport type TurnRequestEvent = EngineEvent<\"turn_request\", TurnRequestData>;\nexport type TurnResponseEvent = EngineEvent<\"turn_response\", TurnResponseData>;\n\n/**\n * AgentTurnEvent - All lightweight turn events\n */\nexport type AgentTurnEvent = TurnRequestEvent | TurnResponseEvent;\n\n/**\n * Type guard: is this a turn event?\n */\nexport function isTurnEvent(event: EngineEvent): event is AgentTurnEvent {\n  const turnTypes = [\"turn_request\", \"turn_response\"];\n  return turnTypes.includes(event.type);\n}\n\n// =============================================================================\n// Agent Output\n// =============================================================================\n\n/**\n * AgentOutput - Union of all possible agent output events\n *\n * Includes all event layers:\n * - Stream: Real-time streaming events from Driver\n * - State: State machine transitions\n * - Message: Assembled messages\n * - Turn: Turn analytics\n */\nexport type AgentOutput = StreamEvent | AgentStateEvent | AgentMessageEvent | AgentTurnEvent;\n\n// =============================================================================\n// Event Handling Types\n// =============================================================================\n\n/**\n * Unsubscribe function returned by on()\n */\nexport type Unsubscribe = () => void;\n\n/**\n * Agent output event callback function type\n */\nexport type AgentOutputCallback<T extends AgentOutput = AgentOutput> = (event: T) => void;\n\n/**\n * @deprecated Use AgentOutputCallback instead\n */\nexport type AgentEventHandler<T extends AgentOutput = AgentOutput> = AgentOutputCallback<T>;\n"],"mappings":";AAmVO,SAAS,aAAa,OAA8C;AACzE,QAAM,aAAa;AAAA,IACjB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACA,SAAO,WAAW,SAAS,MAAM,IAAI;AACvC;AAiCO,SAAS,eAAe,OAAgD;AAC7E,QAAM,eAAe;AAAA,IACnB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACA,SAAO,aAAa,SAAS,MAAM,IAAI;AACzC;AA4CO,SAAS,YAAY,OAA6C;AACvE,QAAM,YAAY,CAAC,gBAAgB,eAAe;AAClD,SAAO,UAAU,SAAS,MAAM,IAAI;AACtC;","names":[]}

package/dist/chunk-RL3JRNXM.js

@@ -0,0 +1,3 @@
+// src/common/index.ts
+export * from "commonxjs/logger";
+//# sourceMappingURL=chunk-RL3JRNXM.js.map

package/dist/chunk-RL3JRNXM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/common/index.ts"],"sourcesContent":["/**\n * Common utilities module\n *\n * Re-exports from commonxjs for backward compatibility.\n * Prefer importing directly from \"commonxjs/logger\".\n */\n\nexport * from \"commonxjs/logger\";\n"],"mappings":";AAOA,cAAc;","names":[]}