@agentxjs/core 1.9.3-dev → 1.9.6-dev

package/dist/agent/index.d.ts

@@ -0,0 +1,244 @@
+export { A as AssistantMessage, C as ContentPart, E as ErrorMessage, F as FilePart, I as ImagePart, M as Message, i as MessageRole, j as MessageSubtype, d as TextPart, e as ThinkingPart, b as TokenUsage, T as ToolCallMessage, f as ToolCallPart, a as ToolResultMessage, g as ToolResultOutput, h as ToolResultPart, c as UserContentPart, U as UserMessage } from '../message-BMrMm1pq.js';
+import { a as AgentState, A as AgentOutput, U as Unsubscribe, S as StreamEvent } from '../event-CDuTzs__.js';
+export { e as AgentError, d as AgentErrorCategory, _ as AgentErrorOccurredEvent, c as AgentEvent, ad as AgentEventHandler, a6 as AgentMessageEvent, b as AgentOutputCallback, $ as AgentStateEvent, ac as AgentTurnEvent, a2 as AssistantMessageEvent, z as ConversationEndData, Q as ConversationEndEvent, B as ConversationInterruptedData, R as ConversationInterruptedEvent, C as ConversationQueuedData, L as ConversationQueuedEvent, y as ConversationRespondingData, P as ConversationRespondingEvent, w as ConversationStartData, N as ConversationStartEvent, x as ConversationThinkingData, O as ConversationThinkingEvent, E as EngineEvent, a5 as ErrorMessageEvent, J as ErrorOccurredData, Z as ErrorOccurredEvent, l as ErrorReceivedData, u as ErrorReceivedEvent, I as InputJsonDeltaData, r as InputJsonDeltaEvent, g as MessageDeltaData, n as MessageDeltaEvent, a0 as MessageEvent, M as MessageStartData, m as MessageStartEvent, h as MessageStopData, o as MessageStopEvent, K as StateEvent, f as StopReason, v as StreamEventType, T as TextDeltaData, p as TextDeltaEvent, a3 as ToolCallMessageEvent, G as ToolCompletedData, X as ToolCompletedEvent, F as ToolExecutingData, W as ToolExecutingEvent, H as ToolFailedData, Y as ToolFailedEvent, D as ToolPlannedData, V as ToolPlannedEvent, k as ToolResultData, t as ToolResultEvent, a4 as ToolResultMessageEvent, i as ToolUseStartData, q as ToolUseStartEvent, j as ToolUseStopData, s as ToolUseStopEvent, a9 as TurnEvent, a7 as TurnRequestData, aa as TurnRequestEvent, a8 as TurnResponseData, ab as TurnResponseEvent, a1 as UserMessageEvent, af as isMessageEvent, ae as isStateEvent, ag as isTurnEvent } from '../event-CDuTzs__.js';
+import { CreateAgentOptions, AgentEngine, StateChangeHandler } from './types/index.js';
+export { AgentEventBus, AgentInterceptor, AgentInterceptorNext, AgentMiddleware, AgentMiddlewareNext, AgentPresenter, AgentSource, AgentStateMachineInterface, EventHandlerMap, MessageQueue, ReactHandlerMap, StateChange } from './types/index.js';
+import { MessageAssemblerState, StateEventProcessorContext, TurnTrackerState, MessageAssemblerOutput, StateEventProcessorOutput, TurnTrackerOutput } from './engine/internal/index.js';
+export { MessageAssemblerInput, PendingContent, PendingTurn, StateEventProcessorInput, TurnTrackerInput, createInitialMessageAssemblerState, createInitialStateEventProcessorContext, createInitialTurnTrackerState, messageAssemblerProcessor, messageAssemblerProcessorDef, stateEventProcessor, stateEventProcessorDef, turnTrackerProcessor, turnTrackerProcessorDef } from './engine/internal/index.js';
+export { M as MemoryStore, a as Sink, b as SinkDefinition, c as Source, d as SourceDefinition, S as Store, g as chainProcessors, f as combineInitialStates, e as combineProcessors, h as filterProcessor, i as identityProcessor, m as mapOutput, w as withLogging } from '../combinators-nEa5dD0T.js';
+import { P as Processor } from '../Processor-DT0N1qI6.js';
+export { b as ProcessorDefinition, a as ProcessorResult } from '../Processor-DT0N1qI6.js';
+import 'commonxjs/logger';
+
+/**
+ * createAgent - Factory function to create an AgentEngine
+ *
+ * Creates an AgentEngine connected to EventBus:
+ * - receive() emits user_message to EventBus
+ * - Source subscribes to StreamEvent from EventBus
+ * - Presenter emits AgentOutput to EventBus
+ *
+ * ```
+ *                         EventBus
+ *                        ↗        ↘
+ *         emit          │          │     emit
+ *         user_message  │          │     AgentOutput
+ *              ↑        │          │      ↑
+ * ┌─────────────────────────────────────────────────────────────┐
+ * │                       AgentEngine                            │
+ * │                                                             │
+ * │   receive() ──► Source ──► MealyMachine ──► Presenter       │
+ * │                 (sub)                        (pub)          │
+ * └─────────────────────────────────────────────────────────────┘
+ * ```
+ */
+
+/**
+ * Create an AgentEngine instance connected to EventBus
+ */
+declare function createAgent(options: CreateAgentOptions): AgentEngine;
+
+/**
+ * AgentStateMachine - State management driven by StateEvents
+ *
+ * Manages agent state transitions driven by StateEvents.
+ * Single source of truth for agent state in AgentEngine.
+ *
+ * Flow:
+ * StreamEvent → MealyMachine → StateEvent → AgentStateMachine → state update
+ *
+ * Responsibilities:
+ * - Process StateEvents
+ * - Maintain current AgentState
+ * - Notify state change subscribers
+ */
+
+/**
+ * AgentStateMachine implementation
+ */
+declare class AgentStateMachine {
+    private _state;
+    private readonly handlers;
+    /**
+     * Current agent state
+     */
+    get state(): AgentState;
+    /**
+     * Process an event and update internal state if it's a StateEvent
+     *
+     * @param event - Event from MealyMachine (could be any AgentOutput)
+     */
+    process(event: AgentOutput): void;
+    /**
+     * Subscribe to state changes
+     *
+     * @param handler - Callback receiving { prev, current } state change
+     * @returns Unsubscribe function
+     */
+    onStateChange(handler: StateChangeHandler): Unsubscribe;
+    /**
+     * Reset state machine (used on destroy)
+     */
+    reset(): void;
+    /**
+     * Map StateEvent type to AgentState
+     *
+     * @param event - StateEvent from MealyMachine
+     * @returns New AgentState or null if no transition needed
+     */
+    private mapEventToState;
+    /**
+     * Notify all registered handlers of state change
+     */
+    private notifyHandlers;
+}
+
+/**
+ * MealyMachine - Pure Mealy Machine Event Processor
+ *
+ * MealyMachine is a stateless event processor that transforms StreamEvents
+ * into higher-level events (state, message, turn events).
+ *
+ * Key Design:
+ * - Engine is a pure Mealy Machine: process(agentId, event) → outputs
+ * - Engine does NOT hold driver or presenters (those belong to AgentEngine layer)
+ * - Engine manages intermediate processing state per agentId
+ * - Multiple agents can share the same MealyMachine instance
+ *
+ * Type Relationship:
+ * ```
+ * StreamEvent (from Driver)
+ * │
+ * └── message_start, text_delta, tool_use_start, message_stop...
+ *         ↓ MealyMachine processes
+ * AgentOutput (to AgentEngine/Presenter)
+ * │
+ * ├── StateEvent (conversation_start, conversation_end...)
+ * ├── MessageEvent (assistant_message, tool_call_message...)
+ * └── TurnEvent (turn_request, turn_response)
+ * ```
+ *
+ * State Management:
+ * - Processing state (pendingContents, etc.) is managed internally per agentId
+ * - Business data persistence is NOT handled here - that's AgentEngine layer's job
+ *
+ * Usage:
+ * ```typescript
+ * const machine = new MealyMachine();
+ *
+ * // AgentEngine layer coordinates:
+ * // 1. Driver produces StreamEvents
+ * // 2. MealyMachine processes events
+ * // 3. Presenters handle outputs
+ *
+ * for await (const streamEvent of driver.receive(message)) {
+ *   const outputs = machine.process(agentId, streamEvent);
+ *   for (const output of outputs) {
+ *     presenters.forEach(p => p.present(agentId, output));
+ *   }
+ * }
+ * ```
+ */
+
+/**
+ * MealyMachine - Pure Mealy Machine for event processing
+ *
+ * - Input: StreamEvent (from Driver)
+ * - Output: AgentOutput[] (state, message, turn events)
+ * - State: Managed internally per agentId
+ */
+declare class MealyMachine {
+    private readonly store;
+    constructor();
+    /**
+     * Process a single driveable event and return output events
+     *
+     * This is the core Mealy Machine operation:
+     * process(agentId, event) → outputs[]
+     *
+     * @param agentId - The agent identifier (for state isolation)
+     * @param event - StreamEvent to process
+     * @returns Array of output events (state, message, turn events)
+     */
+    process(agentId: string, event: StreamEvent): AgentOutput[];
+    /**
+     * Process chained events recursively
+     *
+     * Some processors produce events that trigger other processors:
+     * - MessageAssembler produces MessageEvents
+     * - TurnTracker consumes MessageEvents to produce TurnEvents
+     */
+    private processChained;
+    /**
+     * Clear state for an agent
+     *
+     * Call this when an agent is destroyed to free memory.
+     */
+    clearState(agentId: string): void;
+    /**
+     * Check if state exists for an agent
+     */
+    hasState(agentId: string): boolean;
+}
+/**
+ * Factory function to create MealyMachine
+ */
+declare function createMealyMachine(): MealyMachine;
+
+/**
+ * AgentProcessor
+ *
+ * Combined Mealy processor for the full AgentX engine.
+ * Composes MessageAssembler, StateMachine, and TurnTracker processors.
+ */
+
+/**
+ * Combined state type for the full agent engine
+ */
+type AgentEngineState = {
+    messageAssembler: MessageAssemblerState;
+    stateEventProcessor: StateEventProcessorContext;
+    turnTracker: TurnTrackerState;
+};
+/**
+ * Input event type for AgentProcessor
+ *
+ * Accepts:
+ * - StreamEventType: Raw stream events from Driver
+ * - MessageEventType: Re-injected message events (for TurnTracker)
+ *
+ * Note: AgentOutput is used because re-injected events can be any output type
+ */
+type AgentProcessorInput = AgentOutput;
+/**
+ * Output event type from AgentProcessor
+ *
+ * Produces:
+ * - MessageAssemblerOutput: Assembled message events
+ * - StateEventProcessorOutput: State transition events
+ * - TurnTrackerOutput: Turn analytics events
+ *
+ * Note: StreamEventType is NOT in output - it's passed through by AgentEngine
+ */
+type AgentProcessorOutput = MessageAssemblerOutput | StateEventProcessorOutput | TurnTrackerOutput;
+/**
+ * Combined processor for the full agent engine
+ *
+ * This combines:
+ * - MessageAssembler: Stream → Message events
+ * - StateEventProcessor: Stream → State events
+ * - TurnTracker: Message → Turn events
+ *
+ * Pattern: (state, input) => [newState, outputs]
+ * Key insight: State is means, outputs are the goal (Mealy Machine)
+ *
+ * Note: Raw StreamEvents are NOT output by this processor.
+ * The AgentEngine handles pass-through of original events.
+ */
+declare const agentProcessor: Processor<AgentEngineState, AgentProcessorInput, AgentProcessorOutput>;
+/**
+ * Initial state factory for the full agent engine
+ */
+declare const createInitialAgentEngineState: () => AgentEngineState;
+
+export { AgentEngine, type AgentEngineState, AgentOutput, type AgentProcessorInput, type AgentProcessorOutput, AgentState, AgentStateMachine, CreateAgentOptions, MealyMachine, MessageAssemblerOutput, MessageAssemblerState, Processor, StateChangeHandler, StateEventProcessorContext, StateEventProcessorOutput, StreamEvent, TurnTrackerOutput, TurnTrackerState, Unsubscribe, agentProcessor, createAgent, createInitialAgentEngineState, createMealyMachine };

package/dist/agent/index.js

@@ -0,0 +1,66 @@
+import {
+  AgentStateMachine,
+  MealyMachine,
+  agentProcessor,
+  createAgent,
+  createInitialAgentEngineState,
+  createMealyMachine
+} from "../chunk-AT5P47YA.js";
+import {
+  MemoryStore,
+  chainProcessors,
+  combineInitialStates,
+  combineProcessors,
+  filterProcessor,
+  identityProcessor,
+  mapOutput,
+  withLogging
+} from "../chunk-EKHT54KN.js";
+import {
+  createInitialMessageAssemblerState,
+  createInitialStateEventProcessorContext,
+  createInitialTurnTrackerState,
+  messageAssemblerProcessor,
+  messageAssemblerProcessorDef,
+  stateEventProcessor,
+  stateEventProcessorDef,
+  turnTrackerProcessor,
+  turnTrackerProcessorDef
+} from "../chunk-I7GYR3MN.js";
+import "../chunk-7ZDX3O6I.js";
+import {
+  isMessageEvent,
+  isStateEvent,
+  isTurnEvent
+} from "../chunk-K6WXQ2RW.js";
+import "../chunk-E5FPOAPO.js";
+import "../chunk-7D4SUZUM.js";
+export {
+  AgentStateMachine,
+  MealyMachine,
+  MemoryStore,
+  agentProcessor,
+  chainProcessors,
+  combineInitialStates,
+  combineProcessors,
+  createAgent,
+  createInitialAgentEngineState,
+  createInitialMessageAssemblerState,
+  createInitialStateEventProcessorContext,
+  createInitialTurnTrackerState,
+  createMealyMachine,
+  filterProcessor,
+  identityProcessor,
+  isMessageEvent,
+  isStateEvent,
+  isTurnEvent,
+  mapOutput,
+  messageAssemblerProcessor,
+  messageAssemblerProcessorDef,
+  stateEventProcessor,
+  stateEventProcessorDef,
+  turnTrackerProcessor,
+  turnTrackerProcessorDef,
+  withLogging
+};
+//# sourceMappingURL=index.js.map

package/dist/agent/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/agent/types/index.d.ts

@@ -0,0 +1,322 @@
+import { U as UserMessage } from '../../message-BMrMm1pq.js';
+export { A as AssistantMessage, C as ContentPart, E as ErrorMessage, F as FilePart, I as ImagePart, M as Message, i as MessageRole, j as MessageSubtype, d as TextPart, e as ThinkingPart, b as TokenUsage, T as ToolCallMessage, f as ToolCallPart, a as ToolResultMessage, g as ToolResultOutput, h as ToolResultPart, c as UserContentPart } from '../../message-BMrMm1pq.js';
+import { S as StreamEvent, A as AgentOutput, a as AgentState, b as AgentOutputCallback, U as Unsubscribe } from '../../event-CDuTzs__.js';
+export { e as AgentError, d as AgentErrorCategory, _ as AgentErrorOccurredEvent, c as AgentEvent, ad as AgentEventHandler, a6 as AgentMessageEvent, $ as AgentStateEvent, ac as AgentTurnEvent, a2 as AssistantMessageEvent, z as ConversationEndData, Q as ConversationEndEvent, B as ConversationInterruptedData, R as ConversationInterruptedEvent, C as ConversationQueuedData, L as ConversationQueuedEvent, y as ConversationRespondingData, P as ConversationRespondingEvent, w as ConversationStartData, N as ConversationStartEvent, x as ConversationThinkingData, O as ConversationThinkingEvent, E as EngineEvent, a5 as ErrorMessageEvent, J as ErrorOccurredData, Z as ErrorOccurredEvent, l as ErrorReceivedData, u as ErrorReceivedEvent, I as InputJsonDeltaData, r as InputJsonDeltaEvent, g as MessageDeltaData, n as MessageDeltaEvent, a0 as MessageEvent, M as MessageStartData, m as MessageStartEvent, h as MessageStopData, o as MessageStopEvent, K as StateEvent, f as StopReason, v as StreamEventType, T as TextDeltaData, p as TextDeltaEvent, a3 as ToolCallMessageEvent, G as ToolCompletedData, X as ToolCompletedEvent, F as ToolExecutingData, W as ToolExecutingEvent, H as ToolFailedData, Y as ToolFailedEvent, D as ToolPlannedData, V as ToolPlannedEvent, k as ToolResultData, t as ToolResultEvent, a4 as ToolResultMessageEvent, i as ToolUseStartData, q as ToolUseStartEvent, j as ToolUseStopData, s as ToolUseStopEvent, a9 as TurnEvent, a7 as TurnRequestData, aa as TurnRequestEvent, a8 as TurnResponseData, ab as TurnResponseEvent, a1 as UserMessageEvent, af as isMessageEvent, ae as isStateEvent, ag as isTurnEvent } from '../../event-CDuTzs__.js';
+
+/**
+ * Engine Types - AgentEngine, Driver, Presenter, and related infrastructure
+ *
+ * This file defines:
+ * - MessageQueue: Read-only view of message queue state
+ * - AgentEngine: Event processing unit interface
+ * - AgentDriver: Input adapter for external events
+ * - AgentPresenter: Output adapter for external systems
+ * - Middleware and Interceptor types
+ * - StateMachine interface
+ * - CreateAgentOptions: Factory options
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * MessageQueue interface
+ *
+ * Read-only view of the message queue state.
+ */
+interface MessageQueue {
+    /**
+     * Number of messages in queue
+     */
+    readonly length: number;
+    /**
+     * Whether queue is empty
+     */
+    readonly isEmpty: boolean;
+}
+/**
+ * Next function to continue the middleware chain
+ */
+type AgentMiddlewareNext = (message: UserMessage) => Promise<void>;
+/**
+ * Middleware function type
+ *
+ * @param message - The user message being processed
+ * @param next - Call to continue to next middleware or actual receive
+ */
+type AgentMiddleware = (message: UserMessage, next: AgentMiddlewareNext) => Promise<void>;
+/**
+ * Next function to continue the interceptor chain
+ */
+type AgentInterceptorNext = (event: AgentOutput) => void;
+/**
+ * Interceptor function type
+ *
+ * @param event - The event being dispatched
+ * @param next - Call to continue to next interceptor or actual dispatch
+ */
+type AgentInterceptor = (event: AgentOutput, next: AgentInterceptorNext) => void;
+/**
+ * State change event payload
+ */
+interface StateChange {
+    prev: AgentState;
+    current: AgentState;
+}
+/**
+ * State change handler type
+ */
+type StateChangeHandler = (change: StateChange) => void;
+/**
+ * AgentStateMachine interface
+ *
+ * Processes StateEvents to update internal agent state and notify subscribers.
+ */
+interface AgentStateMachineInterface {
+    /**
+     * Current agent state
+     */
+    readonly state: AgentState;
+    /**
+     * Process a StateEvent and update internal state
+     *
+     * @param event - StateEvent from MealyMachine
+     */
+    process(event: AgentOutput): void;
+    /**
+     * Subscribe to state changes
+     *
+     * @param handler - Callback receiving { prev, current } state change
+     * @returns Unsubscribe function
+     */
+    onStateChange(handler: StateChangeHandler): Unsubscribe;
+    /**
+     * Reset state machine (used on destroy)
+     */
+    reset(): void;
+}
+/**
+ * Event handler map for batch subscription
+ *
+ * Generic handler map - concrete event types are defined in runtime/event.
+ * AgentEngine package is independent of specific event type definitions.
+ *
+ * Usage:
+ * ```typescript
+ * engine.on({
+ *   text_delta: (event) => console.log(event.data.text),
+ *   assistant_message: (event) => setMessages(prev => [...prev, event.data]),
+ * });
+ * ```
+ */
+type EventHandlerMap = Record<string, ((event: AgentOutput) => void) | undefined>;
+/**
+ * React-style handler map for fluent event subscription
+ *
+ * Generic handler map - concrete event types are defined in runtime/event.
+ * AgentEngine package is independent of specific event type definitions.
+ *
+ * Usage:
+ * ```typescript
+ * engine.react({
+ *   onTextDelta: (event) => console.log(event.data.text),
+ *   onAssistantMessage: (event) => setMessages(prev => [...prev, event.data]),
+ * });
+ * ```
+ */
+type ReactHandlerMap = Record<string, ((event: AgentOutput) => void) | undefined>;
+/**
+ * AgentEngine interface - Event Processing Unit
+ *
+ * Core responsibilities:
+ * - State management (AgentState)
+ * - Event subscription and distribution
+ * - Middleware/Interceptor chain
+ */
+interface AgentEngine {
+    /**
+     * Unique agent instance ID
+     */
+    readonly agentId: string;
+    /**
+     * Creation timestamp
+     */
+    readonly createdAt: number;
+    /**
+     * Current conversation state
+     */
+    readonly state: AgentState;
+    /**
+     * Message queue for pending messages
+     */
+    readonly messageQueue: MessageQueue;
+    /**
+     * Receive a message from user
+     *
+     * @param message - String content or UserMessage object
+     * @deprecated Use handleStreamEvent for push-based event processing
+     */
+    receive(message: string | UserMessage): Promise<void>;
+    /**
+     * Handle a stream event from the driver
+     *
+     * This is the push-based API for event processing.
+     * Events are pushed by BusDriver when DriveableEvents arrive.
+     *
+     * @param event - StreamEvent to process through MealyMachine
+     */
+    handleStreamEvent(event: StreamEvent): void;
+    /**
+     * Subscribe to all events
+     */
+    on(handler: AgentOutputCallback): Unsubscribe;
+    /**
+     * Batch subscribe to multiple event types
+     */
+    on(handlers: EventHandlerMap): Unsubscribe;
+    /**
+     * Subscribe to specific event type by name
+     */
+    on(type: string, handler: AgentOutputCallback): Unsubscribe;
+    /**
+     * Subscribe to multiple event types by name
+     */
+    on(types: string[], handler: AgentOutputCallback): Unsubscribe;
+    /**
+     * Subscribe to state changes
+     *
+     * @param handler - Callback receiving { prev, current } state change
+     * @returns Unsubscribe function
+     */
+    onStateChange(handler: StateChangeHandler): Unsubscribe;
+    /**
+     * React-style fluent event subscription
+     */
+    react(handlers: ReactHandlerMap): Unsubscribe;
+    /**
+     * Subscribe to agent ready event
+     *
+     * Called when agent is ready to receive messages.
+     * If already ready, handler is called immediately.
+     */
+    onReady(handler: () => void): Unsubscribe;
+    /**
+     * Subscribe to agent destroy event
+     *
+     * Called when agent is destroyed.
+     */
+    onDestroy(handler: () => void): Unsubscribe;
+    /**
+     * Add middleware to intercept incoming messages (receive side)
+     */
+    use(middleware: AgentMiddleware): Unsubscribe;
+    /**
+     * Add interceptor to intercept outgoing events (event side)
+     */
+    intercept(interceptor: AgentInterceptor): Unsubscribe;
+    /**
+     * Interrupt - User-initiated stop
+     *
+     * Stops the current operation gracefully.
+     * The agent will return to idle state.
+     */
+    interrupt(): void;
+    /**
+     * Destroy - Clean up resources
+     */
+    destroy(): Promise<void>;
+}
+/**
+ * AgentSource interface
+ *
+ * Subscribes to EventBus for StreamEvents and forwards them to AgentEngine.
+ * This is the input adapter: EventBus → AgentEngine
+ *
+ * ```
+ * EventBus ──subscribe──► Source ──handleStreamEvent──► AgentEngine
+ * ```
+ */
+interface AgentSource {
+    /**
+     * Source name (for identification and logging)
+     */
+    readonly name: string;
+    /**
+     * Connect to EventBus and start forwarding StreamEvents
+     *
+     * @param onEvent - Callback to invoke when StreamEvent is received
+     */
+    connect(onEvent: (event: StreamEvent) => void): void;
+    /**
+     * Disconnect from EventBus
+     */
+    disconnect(): void;
+}
+/**
+ * AgentPresenter interface
+ *
+ * Publishes AgentOutput to EventBus.
+ * This is the output adapter: AgentEngine → EventBus
+ *
+ * ```
+ * AgentEngine ──present──► Presenter ──emit──► EventBus
+ * ```
+ */
+interface AgentPresenter {
+    /**
+     * Presenter name (for identification and logging)
+     */
+    readonly name: string;
+    /**
+     * Publish an agent output to EventBus
+     *
+     * @param agentId - The agent ID
+     * @param output - The output to publish
+     */
+    present(agentId: string, output: AgentOutput): void;
+}
+/**
+ * EventBus interface (minimal subset needed by AgentEngine)
+ */
+interface AgentEventBus {
+    /**
+     * Emit an event to the bus
+     */
+    emit(event: unknown): void;
+    /**
+     * Subscribe to events
+     */
+    on(type: string, handler: (event: unknown) => void): () => void;
+    /**
+     * Subscribe to all events
+     */
+    onAny(handler: (event: unknown) => void): () => void;
+}
+/**
+ * Options for creating an AgentEngine
+ */
+interface CreateAgentOptions {
+    /**
+     * Agent ID (optional, auto-generated if not provided)
+     */
+    agentId?: string;
+    /**
+     * EventBus connection
+     * AgentEngine uses this to:
+     * - emit user_message when receive() is called
+     * - Source subscribes to StreamEvent
+     * - Presenter emits AgentOutput
+     */
+    bus: AgentEventBus;
+    /**
+     * Source - Subscribes to EventBus, forwards StreamEvent to AgentEngine
+     * Optional: default implementation subscribes to StreamEvent types
+     */
+    source?: AgentSource;
+    /**
+     * Presenter - Publishes AgentOutput to EventBus
+     * Optional: default implementation emits to bus
+     */
+    presenter?: AgentPresenter;
+}
+
+export { type AgentEngine, type AgentEventBus, type AgentInterceptor, type AgentInterceptorNext, type AgentMiddleware, type AgentMiddlewareNext, AgentOutput, AgentOutputCallback, type AgentPresenter, type AgentSource, AgentState, type AgentStateMachineInterface, type CreateAgentOptions, type EventHandlerMap, type MessageQueue, type ReactHandlerMap, type StateChange, type StateChangeHandler, StreamEvent, Unsubscribe, UserMessage };

package/dist/agent/types/index.js

@@ -0,0 +1,12 @@
+import {
+  isMessageEvent,
+  isStateEvent,
+  isTurnEvent
+} from "../../chunk-K6WXQ2RW.js";
+import "../../chunk-7D4SUZUM.js";
+export {
+  isMessageEvent,
+  isStateEvent,
+  isTurnEvent
+};
+//# sourceMappingURL=index.js.map

package/dist/agent/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}