@agentxjs/agent 0.1.6

package/dist/index.d.ts

@@ -0,0 +1,772 @@
+import { CreateAgentOptions, AgentEngine, AgentState, AgentOutput, StateChangeHandler, Unsubscribe, StreamEvent, AssistantMessageEvent, ToolCallMessageEvent, ToolResultMessageEvent, ErrorMessageEvent, ConversationStartEvent, ConversationRespondingEvent, ConversationEndEvent, ConversationInterruptedEvent, ToolPlannedEvent, ToolExecutingEvent, ErrorOccurredEvent, TurnRequestEvent, TurnResponseEvent, AgentMessageEvent } from '@agentxjs/types/agent';
+export { AgentEngine, CreateAgentOptions } from '@agentxjs/types/agent';
+
+/**
+ * createAgent - Factory function to create an AgentEngine
+ *
+ * Creates a standalone AgentEngine instance with:
+ * - Driver: produces StreamEvents
+ * - Presenter: consumes AgentOutput
+ *
+ * AgentEngine is independent of Runtime (Container, Session, Bus).
+ * It can be tested in isolation with mock Driver and Presenter.
+ */
+
+/**
+ * Create an AgentEngine instance
+ */
+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;
+
+/**
+ * Source - Input adapter for Mealy Machine
+ *
+ * A Source transforms external requests into internal events.
+ * This is a pure function type - lifecycle management belongs to higher layers.
+ *
+ * Pattern: (request) => AsyncIterable<input>
+ *
+ * @template TInput - The event type produced for Processors
+ * @template TRequest - The request type received from external (default: void)
+ *
+ * @example
+ * ```typescript
+ * // Simple source (no request)
+ * const timerSource: Source<TimerEvent> = async function* () {
+ *   while (true) {
+ *     yield { type: 'tick', timestamp: Date.now() };
+ *     await sleep(1000);
+ *   }
+ * };
+ *
+ * // Source with request
+ * const apiSource: Source<ApiEvent, ApiRequest> = async function* (request) {
+ *   const response = await fetch(request.url);
+ *   yield { type: 'response', data: await response.json() };
+ * };
+ * ```
+ */
+type Source<TInput, TRequest = void> = (request: TRequest) => AsyncIterable<TInput>;
+/**
+ * SourceDefinition - Named Source with metadata
+ *
+ * Use this when you need to identify sources by name.
+ */
+interface SourceDefinition<TInput, TRequest = void> {
+    /**
+     * Unique name for this source
+     */
+    name: string;
+    /**
+     * Optional description
+     */
+    description?: string;
+    /**
+     * The source function
+     */
+    source: Source<TInput, TRequest>;
+}
+
+/**
+ * Processor - Core pure function type for stream processing
+ *
+ * A Processor is a pure function that takes a state and an input,
+ * and returns a new state along with outputs.
+ *
+ * Pattern: (state, input) => [newState, outputs]
+ *
+ * Key properties:
+ * - Pure function (no side effects)
+ * - Deterministic (same input → same output)
+ * - State is a means (accumulator), outputs are the goal
+ *
+ * @template TState - The state type (internal accumulator)
+ * @template TInput - The input type
+ * @template TOutput - The output type (emissions)
+ *
+ * @example
+ * ```typescript
+ * const messageProcessor: Processor<MsgState, StreamEvent, MsgEvent> =
+ *   (state, input) => {
+ *     switch (input.type) {
+ *       case 'text_delta':
+ *         return [{ ...state, buffer: state.buffer + input.data.text }, []];
+ *       case 'message_stop':
+ *         return [{ buffer: '' }, [{ type: 'assistant_message', content: state.buffer }]];
+ *       default:
+ *         return [state, []];
+ *     }
+ *   };
+ * ```
+ */
+type Processor<TState, TInput, TOutput> = (state: Readonly<TState>, input: TInput) => [TState, TOutput[]];
+/**
+ * ProcessorResult - The return type of a Processor
+ *
+ * A tuple containing:
+ * - [0] newState: The updated state after processing
+ * - [1] outputs: Array of outputs to emit
+ */
+type ProcessorResult<TState, TOutput> = [TState, TOutput[]];
+/**
+ * ProcessorDefinition - Metadata for a Processor
+ */
+interface ProcessorDefinition<TState, TInput, TOutput> {
+    /**
+     * Unique name for this processor
+     */
+    name: string;
+    /**
+     * The pure processor function
+     */
+    processor: Processor<TState, TInput, TOutput>;
+    /**
+     * Initial state factory
+     */
+    initialState: () => TState;
+    /**
+     * Optional description
+     */
+    description?: string;
+}
+
+/**
+ * Sink - Output adapter for Mealy Machine
+ *
+ * A Sink receives outputs from Processors and produces external effects.
+ * This is a pure function type - lifecycle management belongs to higher layers.
+ *
+ * Pattern: (id, outputs) => void | Promise<void>
+ *
+ * @template TOutput - The output type received from Processors
+ *
+ * @example
+ * ```typescript
+ * // Sync sink (logging)
+ * const logSink: Sink<AgentEvent> = (id, outputs) => {
+ *   outputs.forEach(output => console.log(`[${id}]`, output));
+ * };
+ *
+ * // Async sink (network)
+ * const sseSink: Sink<AgentEvent> = async (id, outputs) => {
+ *   for (const output of outputs) {
+ *     await sseConnection.send(id, output);
+ *   }
+ * };
+ * ```
+ */
+type Sink<TOutput> = (id: string, outputs: TOutput[]) => void | Promise<void>;
+/**
+ * SinkDefinition - Named Sink with metadata
+ *
+ * Use this when you need to identify sinks by name.
+ */
+interface SinkDefinition<TOutput> {
+    /**
+     * Unique name for this sink
+     */
+    name: string;
+    /**
+     * Optional description
+     */
+    description?: string;
+    /**
+     * Optional filter to select which outputs to process
+     *
+     * If not provided, all outputs are processed.
+     * Return true to process the output, false to skip.
+     */
+    filter?: (output: TOutput) => boolean;
+    /**
+     * The sink function
+     */
+    sink: Sink<TOutput>;
+}
+
+/**
+ * Store - State storage interface for stream processing
+ *
+ * A Store abstracts state persistence, allowing processors to be stateless
+ * while maintaining state externally.
+ *
+ * @template T - The state type to store
+ *
+ * @example
+ * ```typescript
+ * const store = new MemoryStore<AgentState>();
+ * store.set('agent_123', { count: 0 });
+ * const state = store.get('agent_123');
+ * ```
+ */
+interface Store<T> {
+    /**
+     * Get state by ID
+     * @param id - Unique identifier (e.g., agentId, sessionId)
+     * @returns The stored state or undefined if not found
+     */
+    get(id: string): T | undefined;
+    /**
+     * Set state for an ID
+     * @param id - Unique identifier
+     * @param state - The state to store
+     */
+    set(id: string, state: T): void;
+    /**
+     * Delete state for an ID
+     * @param id - Unique identifier
+     */
+    delete(id: string): void;
+    /**
+     * Check if state exists for an ID
+     * @param id - Unique identifier
+     * @returns True if state exists
+     */
+    has(id: string): boolean;
+}
+/**
+ * MemoryStore - In-memory implementation of Store
+ *
+ * Stores state in a Map. Suitable for development and single-process deployments.
+ * For production multi-process scenarios, use RedisStore or PostgresStore.
+ *
+ * @template T - The state type to store
+ *
+ * @example
+ * ```typescript
+ * const store = new MemoryStore<MyState>();
+ * store.set('session_1', { count: 0 });
+ * ```
+ */
+declare class MemoryStore<T> implements Store<T> {
+    private states;
+    get(id: string): T | undefined;
+    set(id: string, state: T): void;
+    delete(id: string): void;
+    has(id: string): boolean;
+    /**
+     * Clear all stored states
+     */
+    clear(): void;
+    /**
+     * Get the number of stored states
+     */
+    get size(): number;
+    /**
+     * Get all stored IDs
+     */
+    keys(): IterableIterator<string>;
+}
+
+/**
+ * Combinators - Functions to compose multiple Processors
+ *
+ * These utilities allow building complex stream processing pipelines
+ * from simple, composable Processor functions.
+ */
+
+/**
+ * combineProcessors - Combine multiple processors into one
+ *
+ * Each sub-processor manages its own slice of state.
+ * All processors receive the same event and their outputs are merged.
+ *
+ * @example
+ * ```typescript
+ * interface CombinedState {
+ *   message: MessageState;
+ *   state: StateMachineState;
+ *   turn: TurnState;
+ * }
+ *
+ * const combinedProcessor = combineProcessors<CombinedState, Event, Event>({
+ *   message: messageProcessor,
+ *   state: stateMachineProcessor,
+ *   turn: turnTrackerProcessor,
+ * });
+ * ```
+ */
+declare function combineProcessors<TState extends Record<string, unknown>, TInput, TOutput>(processors: {
+    [K in keyof TState]: Processor<TState[K], TInput, TOutput>;
+}): Processor<TState, TInput, TOutput>;
+/**
+ * combineInitialStates - Helper to create initial state for combined processors
+ */
+declare function combineInitialStates<TState extends Record<string, unknown>>(initialStates: {
+    [K in keyof TState]: () => TState[K];
+}): () => TState;
+/**
+ * chainProcessors - Chain processors where output of one feeds into the next
+ *
+ * Useful for layered event processing:
+ * Stream Events → Message Events → Turn Events
+ *
+ * @example
+ * ```typescript
+ * const pipeline = chainProcessors(
+ *   streamToMessageProcessor,
+ *   messageToTurnProcessor,
+ * );
+ * ```
+ */
+declare function chainProcessors<TState, TEvent>(...processors: Processor<TState, TEvent, TEvent>[]): Processor<TState, TEvent, TEvent>;
+/**
+ * filterProcessor - Create a processor that only processes certain events
+ *
+ * @example
+ * ```typescript
+ * const textOnlyProcessor = filterProcessor(
+ *   (event) => event.type === 'text_delta',
+ *   textProcessor,
+ * );
+ * ```
+ */
+declare function filterProcessor<TState, TInput, TOutput>(predicate: (event: TInput) => boolean, processor: Processor<TState, TInput, TOutput>): Processor<TState, TInput, TOutput>;
+/**
+ * mapOutput - Transform output events
+ *
+ * @example
+ * ```typescript
+ * const withTimestamp = mapOutput(
+ *   myProcessor,
+ *   (output) => ({ ...output, processedAt: Date.now() }),
+ * );
+ * ```
+ */
+declare function mapOutput<TState, TInput, TOutput, TMapped>(processor: Processor<TState, TInput, TOutput>, mapper: (output: TOutput) => TMapped): Processor<TState, TInput, TMapped>;
+/**
+ * withLogging - Add logging to a processor (for debugging)
+ *
+ * @example
+ * ```typescript
+ * const debugProcessor = withLogging(myProcessor, 'MyProcessor');
+ * ```
+ */
+declare function withLogging<TState, TInput, TOutput>(processor: Processor<TState, TInput, TOutput>, name: string, logger?: {
+    debug: (message: string, data?: unknown) => void;
+}): Processor<TState, TInput, TOutput>;
+/**
+ * identityProcessor - A processor that does nothing (useful as default)
+ */
+declare function identityProcessor<TState, TEvent>(): Processor<TState, TEvent, TEvent>;
+
+/**
+ * messageAssemblerProcessor
+ *
+ * Pure Mealy transition function that assembles complete Message Layer events
+ * from Stream Layer events.
+ *
+ * Input Events (Stream Layer):
+ * - message_start
+ * - text_delta
+ * - tool_use_start
+ * - input_json_delta
+ * - tool_use_stop
+ * - tool_result
+ * - message_stop
+ *
+ * Output Events (Message Layer):
+ * - tool_call_message (Message - AI's request to call a tool)
+ * - tool_result_message (Message - tool execution result)
+ * - assistant_message (Message - complete assistant response)
+ */
+
+/**
+ * Pending content accumulator
+ */
+interface PendingContent {
+    type: "text" | "tool_use";
+    index: number;
+    textDeltas?: string[];
+    toolId?: string;
+    toolName?: string;
+    toolInputJson?: string;
+}
+/**
+ * Pending tool call info (for matching with tool_result)
+ */
+interface PendingToolCall {
+    id: string;
+    name: string;
+}
+/**
+ * MessageAssemblerState
+ *
+ * Tracks the state of message assembly from stream events.
+ */
+interface MessageAssemblerState {
+    /**
+     * Current message ID being assembled
+     */
+    currentMessageId: string | null;
+    /**
+     * Timestamp when the current message started
+     */
+    messageStartTime: number | null;
+    /**
+     * Pending content blocks being accumulated
+     * Key is the content block index
+     */
+    pendingContents: Record<number, PendingContent>;
+    /**
+     * Pending tool calls waiting for results
+     * Key is the tool call ID
+     */
+    pendingToolCalls: Record<string, PendingToolCall>;
+}
+/**
+ * Initial state factory for MessageAssembler
+ */
+declare function createInitialMessageAssemblerState(): MessageAssemblerState;
+/**
+ * Output event types from MessageAssembler
+ */
+type MessageAssemblerOutput = AssistantMessageEvent | ToolCallMessageEvent | ToolResultMessageEvent | ErrorMessageEvent;
+/**
+ * Input event types for MessageAssembler
+ */
+type MessageAssemblerInput = StreamEvent;
+/**
+ * messageAssemblerProcessor
+ *
+ * Pure Mealy transition function for message assembly.
+ * Pattern: (state, input) => [newState, outputs]
+ */
+declare const messageAssemblerProcessor: Processor<MessageAssemblerState, MessageAssemblerInput, MessageAssemblerOutput>;
+/**
+ * MessageAssembler Processor Definition
+ */
+declare const messageAssemblerProcessorDef: ProcessorDefinition<MessageAssemblerState, MessageAssemblerInput, MessageAssemblerOutput>;
+
+/**
+ * stateEventProcessor
+ *
+ * Stateless event transformer: Stream Events → State Events
+ *
+ * Input Events (Stream Layer):
+ * - message_start
+ * - message_stop
+ * - text_delta (triggers responding state)
+ * - tool_use_start
+ * - tool_use_stop
+ *
+ * Output Events (State Layer):
+ * - conversation_start
+ * - conversation_responding
+ * - conversation_end
+ * - tool_planned
+ * - tool_executing
+ */
+
+/**
+ * StateEventProcessorContext
+ *
+ * Minimal context needed for event transformation logic.
+ * Does NOT track agent state - only auxiliary info for decision-making.
+ *
+ * Currently empty - no context needed as all information comes from events.
+ */
+interface StateEventProcessorContext {
+}
+/**
+ * Initial context factory for StateEventProcessor
+ */
+declare function createInitialStateEventProcessorContext(): StateEventProcessorContext;
+/**
+ * Output event types from StateEventProcessor
+ */
+type StateEventProcessorOutput = ConversationStartEvent | ConversationRespondingEvent | ConversationEndEvent | ConversationInterruptedEvent | ToolPlannedEvent | ToolExecutingEvent | ErrorOccurredEvent;
+/**
+ * Input event types for StateEventProcessor
+ */
+type StateEventProcessorInput = StreamEvent;
+/**
+ * stateEventProcessor
+ *
+ * Stateless event transformer: Stream Events → State Events
+ *
+ * Design:
+ * - Does NOT track agent state (that's StateMachine's job)
+ * - Only maintains auxiliary context (timestamps, etc.)
+ * - Emits State Events that StateMachine consumes
+ *
+ * Pattern: (context, input) => [newContext, outputs]
+ */
+declare const stateEventProcessor: Processor<StateEventProcessorContext, StateEventProcessorInput, StateEventProcessorOutput>;
+/**
+ * StateEvent Processor Definition
+ *
+ * Stateless event transformer: Stream Events → State Events
+ */
+declare const stateEventProcessorDef: ProcessorDefinition<StateEventProcessorContext, StateEventProcessorInput, StateEventProcessorOutput>;
+
+/**
+ * turnTrackerProcessor
+ *
+ * Pure Mealy transition function that tracks request-response turn pairs.
+ *
+ * Input Events:
+ * - user_message (Message Layer)
+ * - message_stop (Stream Layer - contains stop reason)
+ * - assistant_message (Message Layer)
+ *
+ * Output Events (Turn Layer):
+ * - turn_request
+ * - turn_response
+ */
+
+/**
+ * Pending turn tracking
+ */
+interface PendingTurn {
+    turnId: string;
+    messageId: string;
+    content: string;
+    requestedAt: number;
+}
+/**
+ * TurnTrackerState
+ *
+ * Tracks the current turn state.
+ */
+interface TurnTrackerState {
+    /**
+     * Currently pending turn (waiting for response)
+     */
+    pendingTurn: PendingTurn | null;
+    /**
+     * Cost per input token (USD)
+     */
+    costPerInputToken: number;
+    /**
+     * Cost per output token (USD)
+     */
+    costPerOutputToken: number;
+}
+/**
+ * Initial state factory for TurnTracker
+ */
+declare function createInitialTurnTrackerState(): TurnTrackerState;
+/**
+ * Output event types from TurnTracker
+ */
+type TurnTrackerOutput = TurnRequestEvent | TurnResponseEvent;
+/**
+ * Input event types for TurnTracker
+ * Accepts both Stream and Message layer events
+ */
+type TurnTrackerInput = StreamEvent | AgentMessageEvent;
+/**
+ * turnTrackerProcessor
+ *
+ * Pure Mealy transition function for turn tracking.
+ * Pattern: (state, input) => [newState, outputs]
+ */
+declare const turnTrackerProcessor: Processor<TurnTrackerState, TurnTrackerInput, TurnTrackerOutput>;
+/**
+ * TurnTracker Processor Definition
+ */
+declare const turnTrackerProcessorDef: ProcessorDefinition<TurnTrackerState, TurnTrackerInput, TurnTrackerOutput>;
+
+/**
+ * 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, AgentOutput, AgentProcessorOutput>;
+/**
+ * Initial state factory for the full agent engine
+ */
+declare const createInitialAgentEngineState: () => AgentEngineState;
+
+export { type AgentEngineState, type AgentProcessorInput, type AgentProcessorOutput, AgentStateMachine, MealyMachine, MemoryStore, type MessageAssemblerInput, type MessageAssemblerOutput, type MessageAssemblerState, type PendingContent, type PendingTurn, type Processor, type ProcessorDefinition, type ProcessorResult, type Sink, type SinkDefinition, type Source, type SourceDefinition, type StateEventProcessorContext, type StateEventProcessorInput, type StateEventProcessorOutput, type Store, type TurnTrackerInput, type TurnTrackerOutput, type TurnTrackerState, agentProcessor, chainProcessors, combineInitialStates, combineProcessors, createAgent, createInitialAgentEngineState, createInitialMessageAssemblerState, createInitialStateEventProcessorContext, createInitialTurnTrackerState, createMealyMachine, filterProcessor, identityProcessor, mapOutput, messageAssemblerProcessor, messageAssemblerProcessorDef, stateEventProcessor, stateEventProcessorDef, turnTrackerProcessor, turnTrackerProcessorDef, withLogging };