@agentxjs/core 1.9.5-dev → 1.9.6-dev

package/dist/Processor-DT0N1qI6.d.ts

@@ -0,0 +1,64 @@
+/**
+ * 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;
+}
+
+export type { Processor as P, ProcessorResult as a, ProcessorDefinition as b };

package/dist/agent/engine/internal/index.d.ts

@@ -0,0 +1,223 @@
+import { P as Processor, b as ProcessorDefinition } from '../../../Processor-DT0N1qI6.js';
+import { a2 as AssistantMessageEvent, a3 as ToolCallMessageEvent, a4 as ToolResultMessageEvent, a5 as ErrorMessageEvent, S as StreamEvent, N as ConversationStartEvent, P as ConversationRespondingEvent, Q as ConversationEndEvent, R as ConversationInterruptedEvent, V as ToolPlannedEvent, W as ToolExecutingEvent, Z as ErrorOccurredEvent, aa as TurnRequestEvent, ab as TurnResponseEvent, a6 as AgentMessageEvent } from '../../../event-CDuTzs__.js';
+import '../../../message-BMrMm1pq.js';
+
+/**
+ * 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>;
+
+export { type MessageAssemblerInput, type MessageAssemblerOutput, type MessageAssemblerState, type PendingContent, type PendingTurn, type StateEventProcessorContext, type StateEventProcessorInput, type StateEventProcessorOutput, type TurnTrackerInput, type TurnTrackerOutput, type TurnTrackerState, createInitialMessageAssemblerState, createInitialStateEventProcessorContext, createInitialTurnTrackerState, messageAssemblerProcessor, messageAssemblerProcessorDef, stateEventProcessor, stateEventProcessorDef, turnTrackerProcessor, turnTrackerProcessorDef };

package/dist/agent/engine/internal/index.js

@@ -0,0 +1,24 @@
+import {
+  createInitialMessageAssemblerState,
+  createInitialStateEventProcessorContext,
+  createInitialTurnTrackerState,
+  messageAssemblerProcessor,
+  messageAssemblerProcessorDef,
+  stateEventProcessor,
+  stateEventProcessorDef,
+  turnTrackerProcessor,
+  turnTrackerProcessorDef
+} from "../../../chunk-I7GYR3MN.js";
+import "../../../chunk-7D4SUZUM.js";
+export {
+  createInitialMessageAssemblerState,
+  createInitialStateEventProcessorContext,
+  createInitialTurnTrackerState,
+  messageAssemblerProcessor,
+  messageAssemblerProcessorDef,
+  stateEventProcessor,
+  stateEventProcessorDef,
+  turnTrackerProcessor,
+  turnTrackerProcessorDef
+};
+//# sourceMappingURL=index.js.map

package/dist/agent/engine/internal/index.js.map

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

package/dist/agent/engine/mealy/index.d.ts

@@ -0,0 +1,157 @@
+import { S as Store, a as Sink, b as SinkDefinition } from '../../../combinators-nEa5dD0T.js';
+export { M as MemoryStore, c as Source, d as SourceDefinition, 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';
+
+/**
+ * Mealy - The Mealy Machine runtime
+ *
+ * A Mealy Machine is a finite-state machine where outputs depend on
+ * both the current state AND the input: (state, input) => (state, output)
+ *
+ * This runtime orchestrates the complete processing pipeline:
+ * 1. Sources receive external input (side effects)
+ * 2. Processors process inputs (pure Mealy transition functions)
+ * 3. Sinks produce output effects (side effects)
+ *
+ * Architecture:
+ * - Inputs enter through Sources (input adapters)
+ * - Processors transform inputs (pure functions, state is means)
+ * - Sinks produce actions (output adapters)
+ *
+ * @template TState - The state type (accumulator, means to an end)
+ * @template TInput - The input/output type for Processors
+ *
+ * @example
+ * ```typescript
+ * const mealy = createMealy({
+ *   processor: messageProcessor,
+ *   store: new MemoryStore(),
+ *   initialState: { text: '' },
+ *   sinks: [sseSink, logSink],
+ * });
+ *
+ * // Process an input
+ * mealy.process('agent_123', input);
+ * ```
+ */
+
+/**
+ * MealyConfig - Configuration for creating a Mealy instance
+ */
+interface MealyConfig<TState, TInput> {
+    /**
+     * The processor function to execute (pure Mealy transition function)
+     */
+    processor: Processor<TState, TInput, TInput>;
+    /**
+     * The store for state persistence
+     */
+    store: Store<TState>;
+    /**
+     * Initial state for new IDs
+     */
+    initialState: TState;
+    /**
+     * Sinks to receive outputs
+     * Can be simple Sink functions or SinkDefinitions with filter/name
+     */
+    sinks?: (Sink<TInput> | SinkDefinition<TInput>)[];
+    /**
+     * Whether to recursively process outputs
+     * If true, outputs are fed back into the processor
+     *
+     * @default true
+     */
+    recursive?: boolean;
+    /**
+     * Maximum recursion depth to prevent infinite loops
+     *
+     * @default 100
+     */
+    maxDepth?: number;
+}
+/**
+ * ProcessResult - Result of processing an input
+ */
+interface ProcessResult<TState, TOutput> {
+    /**
+     * The new state after processing
+     */
+    state: TState;
+    /**
+     * All outputs produced (including from recursion)
+     */
+    outputs: TOutput[];
+    /**
+     * Number of processor invocations (including recursion)
+     */
+    processCount: number;
+}
+/**
+ * Mealy - Mealy Machine runtime
+ *
+ * Implements the Mealy Machine pattern: (state, input) => (state, output)
+ * where output depends on both current state and input.
+ */
+declare class Mealy<TState, TInput> {
+    private readonly processor;
+    private readonly store;
+    private readonly initialState;
+    private readonly sinks;
+    private readonly recursive;
+    private readonly maxDepth;
+    constructor(config: MealyConfig<TState, TInput>);
+    /**
+     * Process an input through the Mealy Machine
+     *
+     * @param id - Unique identifier (e.g., agentId)
+     * @param input - The input to process
+     * @returns Result containing new state and all outputs
+     */
+    process(id: string, input: TInput): ProcessResult<TState, TInput>;
+    /**
+     * Internal process with depth tracking
+     */
+    private processInternal;
+    /**
+     * Send outputs to all sinks
+     */
+    private sendToSinks;
+    /**
+     * Get current state for an ID (without processing)
+     */
+    getState(id: string): TState | undefined;
+    /**
+     * Check if state exists for an ID
+     */
+    hasState(id: string): boolean;
+    /**
+     * Delete state for an ID (cleanup)
+     */
+    cleanup(id: string): void;
+    /**
+     * Add a sink at runtime
+     */
+    addSink(sink: Sink<TInput> | SinkDefinition<TInput>): void;
+    /**
+     * Remove a sink by name (only works for SinkDefinitions)
+     */
+    removeSink(name: string): boolean;
+}
+/**
+ * createMealy - Factory function for creating Mealy Machine instances
+ *
+ * @example
+ * ```typescript
+ * const mealy = createMealy({
+ *   processor: myProcessor,
+ *   store: new MemoryStore(),
+ *   initialState: { count: 0 },
+ *   sinks: [logSink],
+ * });
+ * ```
+ */
+declare function createMealy<TState, TInput>(config: MealyConfig<TState, TInput>): Mealy<TState, TInput>;
+
+export { Mealy, type MealyConfig, type ProcessResult, Processor, Sink, SinkDefinition, Store, createMealy };

package/dist/agent/engine/mealy/index.js

@@ -0,0 +1,26 @@
+import {
+  Mealy,
+  MemoryStore,
+  chainProcessors,
+  combineInitialStates,
+  combineProcessors,
+  createMealy,
+  filterProcessor,
+  identityProcessor,
+  mapOutput,
+  withLogging
+} from "../../../chunk-EKHT54KN.js";
+import "../../../chunk-7D4SUZUM.js";
+export {
+  Mealy,
+  MemoryStore,
+  chainProcessors,
+  combineInitialStates,
+  combineProcessors,
+  createMealy,
+  filterProcessor,
+  identityProcessor,
+  mapOutput,
+  withLogging
+};
+//# sourceMappingURL=index.js.map

package/dist/agent/engine/mealy/index.js.map

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