@agentxjs/core 1.9.10-dev → 2.0.0

package/dist/index-CuS1i5V-.d.ts

@@ -0,0 +1,609 @@
+import { M as Message, U as UserMessage } from './message-03TJzvIX.js';
+
+/**
+ * Persistence Types - Repository interfaces and record types
+ *
+ * Defines standard interfaces for data persistence.
+ * Implementations are provided by platform packages (node, cloudflare).
+ */
+
+/**
+ * Container configuration (extensible)
+ */
+interface ContainerConfig {
+    [key: string]: unknown;
+}
+/**
+ * ContainerRecord - Persistent container data
+ *
+ * Represents a logical container (resource isolation unit).
+ * Each container provides an isolated environment for running Agents.
+ */
+interface ContainerRecord {
+    /** Unique container identifier */
+    containerId: string;
+    /** Container creation timestamp (Unix milliseconds) */
+    createdAt: number;
+    /** Last update timestamp (Unix milliseconds) */
+    updatedAt: number;
+    /** Container configuration (extensible) */
+    config?: ContainerConfig;
+}
+/**
+ * Image metadata for storing provider-specific data
+ */
+interface ImageMetadata {
+    /** Driver session ID for conversation resume */
+    driverSessionId?: string;
+}
+/**
+ * ImageRecord - Persistent representation of a conversation
+ *
+ * Image is the primary entity users interact with (displayed as "conversation").
+ * Agent is a transient runtime instance created from Image.
+ *
+ * Lifecycle:
+ * - image_create → ImageRecord (persistent)
+ * - image_run → Agent (runtime, in-memory)
+ * - image_stop / server restart → Agent destroyed, Image remains
+ */
+interface ImageRecord {
+    /** Unique image identifier (pattern: `img_${nanoid()}`) */
+    imageId: string;
+    /** Container ID (user isolation boundary) */
+    containerId: string;
+    /** Session ID for message storage */
+    sessionId: string;
+    /** Conversation name (displayed to user) */
+    name: string;
+    /** Conversation description (optional) */
+    description?: string;
+    /** System prompt - controls agent behavior */
+    systemPrompt?: string;
+    /** Parent image ID (for fork/branch feature) */
+    parentImageId?: string;
+    /** MCP servers configuration */
+    mcpServers?: Record<string, McpServerConfig>;
+    /** Provider-specific metadata */
+    metadata?: ImageMetadata;
+    /** Application-specific custom data (favorites, sort order, tags, etc.) */
+    customData?: Record<string, unknown>;
+    /** Creation timestamp (Unix milliseconds) */
+    createdAt: number;
+    /** Last update timestamp (Unix milliseconds) */
+    updatedAt: number;
+}
+/**
+ * SessionRecord - Storage schema for Session persistence
+ *
+ * Session stores conversation messages for an Image.
+ * Each Image has exactly one Session.
+ */
+interface SessionRecord {
+    /** Unique session identifier */
+    sessionId: string;
+    /** Associated image ID (owner of this session) */
+    imageId: string;
+    /** Container this session belongs to */
+    containerId: string;
+    /** Creation timestamp (Unix milliseconds) */
+    createdAt: number;
+    /** Last update timestamp (Unix milliseconds) */
+    updatedAt: number;
+}
+/**
+ * ContainerRepository - Storage operations for containers
+ */
+interface ContainerRepository {
+    /** Save a container record (create or update) */
+    saveContainer(record: ContainerRecord): Promise<void>;
+    /** Find container by ID */
+    findContainerById(containerId: string): Promise<ContainerRecord | null>;
+    /** Find all containers */
+    findAllContainers(): Promise<ContainerRecord[]>;
+    /** Delete container by ID */
+    deleteContainer(containerId: string): Promise<void>;
+    /** Check if container exists */
+    containerExists(containerId: string): Promise<boolean>;
+}
+/**
+ * ImageRepository - Storage operations for images
+ */
+interface ImageRepository {
+    /** Save an image record (create or update) */
+    saveImage(record: ImageRecord): Promise<void>;
+    /** Find image by ID */
+    findImageById(imageId: string): Promise<ImageRecord | null>;
+    /** Find all images */
+    findAllImages(): Promise<ImageRecord[]>;
+    /** Find images by agent name */
+    findImagesByName(name: string): Promise<ImageRecord[]>;
+    /** Find images by container ID */
+    findImagesByContainerId(containerId: string): Promise<ImageRecord[]>;
+    /** Delete image by ID */
+    deleteImage(imageId: string): Promise<void>;
+    /** Check if image exists */
+    imageExists(imageId: string): Promise<boolean>;
+    /** Update image metadata (merges with existing) */
+    updateMetadata(imageId: string, metadata: Partial<ImageMetadata>): Promise<void>;
+}
+/**
+ * SessionRepository - Storage operations for sessions
+ */
+interface SessionRepository {
+    /** Save a session record (create or update) */
+    saveSession(record: SessionRecord): Promise<void>;
+    /** Find session by ID */
+    findSessionById(sessionId: string): Promise<SessionRecord | null>;
+    /** Find session by image ID */
+    findSessionByImageId(imageId: string): Promise<SessionRecord | null>;
+    /** Find all sessions for a container */
+    findSessionsByContainerId(containerId: string): Promise<SessionRecord[]>;
+    /** Find all sessions */
+    findAllSessions(): Promise<SessionRecord[]>;
+    /** Delete session by ID */
+    deleteSession(sessionId: string): Promise<void>;
+    /** Check if session exists */
+    sessionExists(sessionId: string): Promise<boolean>;
+    /** Add a message to a session */
+    addMessage(sessionId: string, message: Message): Promise<void>;
+    /** Get all messages for a session */
+    getMessages(sessionId: string): Promise<Message[]>;
+    /** Clear all messages for a session */
+    clearMessages(sessionId: string): Promise<void>;
+}
+
+/**
+ * Session - Manages conversation messages
+ */
+interface Session {
+    /**
+     * Unique session identifier
+     */
+    readonly sessionId: string;
+    /**
+     * Associated image ID
+     */
+    readonly imageId: string;
+    /**
+     * Container this session belongs to
+     */
+    readonly containerId: string;
+    /**
+     * Creation timestamp
+     */
+    readonly createdAt: number;
+    /**
+     * Initialize session in storage
+     */
+    initialize(): Promise<void>;
+    /**
+     * Add a message to the session
+     */
+    addMessage(message: Message): Promise<void>;
+    /**
+     * Get all messages in the session
+     */
+    getMessages(): Promise<Message[]>;
+    /**
+     * Clear all messages in the session
+     */
+    clear(): Promise<void>;
+}
+/**
+ * Configuration for creating a Session
+ */
+interface SessionConfig {
+    sessionId: string;
+    imageId: string;
+    containerId: string;
+    repository: SessionRepository;
+}
+
+/**
+ * Driver Types - LLM Communication Layer
+ *
+ * Driver is the bridge between AgentX and external LLM (Claude, OpenAI, etc.)
+ *
+ * ```
+ *                    AgentX
+ *                      │
+ *         receive()    │    AsyncIterable<StreamEvent>
+ *         ─────────►   │   ◄─────────────────────────
+ *                      │
+ *              ┌───────────────┐
+ *              │    Driver     │
+ *              │               │
+ *              │  UserMessage  │
+ *              │      ↓        │
+ *              │   [SDK call]  │
+ *              │      ↓        │
+ *              │  StreamEvent  │
+ *              └───────────────┘
+ *                      │
+ *                      ▼
+ *               External LLM
+ *               (Claude SDK)
+ * ```
+ *
+ * Key Design:
+ * - Driver = single session communication (like Kimi SDK's Session)
+ * - Clear input/output boundary (for recording/playback)
+ * - Configuration defined by us (capability boundary)
+ */
+
+/**
+ * ToolDefinition - Defines a tool for LLM tool calling
+ *
+ * Tools are injected into the Driver via DriverConfig.tools.
+ * The Driver passes tool schemas to the LLM and executes handlers
+ * when the LLM requests a tool call.
+ *
+ * @example
+ * ```typescript
+ * const calculator: ToolDefinition = {
+ *   name: "calculator",
+ *   description: "Evaluates a math expression",
+ *   parameters: {
+ *     type: "object",
+ *     properties: {
+ *       expression: { type: "string", description: "e.g. '123 * 456'" },
+ *     },
+ *     required: ["expression"],
+ *   },
+ *   execute: async (params) => {
+ *     const result = Function(`"use strict"; return (${params.expression})`)();
+ *     return { result: String(result) };
+ *   },
+ * };
+ * ```
+ */
+interface ToolDefinition {
+    /**
+     * Tool name (unique identifier)
+     */
+    name: string;
+    /**
+     * Description of what the tool does (sent to LLM)
+     */
+    description?: string;
+    /**
+     * JSON Schema for the tool's input parameters
+     */
+    parameters: {
+        type: "object";
+        properties: Record<string, unknown>;
+        required?: string[];
+    };
+    /**
+     * Function to execute when the LLM calls this tool
+     */
+    execute: (params: Record<string, unknown>) => Promise<unknown>;
+}
+/**
+ * Stdio transport — launches a local MCP server as a child process.
+ */
+interface McpStdioServerConfig {
+    /**
+     * Command to run the MCP server
+     */
+    command: string;
+    /**
+     * Command arguments
+     */
+    args?: string[];
+    /**
+     * Environment variables for the process
+     */
+    env?: Record<string, string>;
+}
+/**
+ * HTTP Streamable transport — connects to a remote MCP server over HTTP.
+ */
+interface McpHttpServerConfig {
+    /**
+     * Transport type discriminator
+     */
+    type: "http";
+    /**
+     * URL of the remote MCP server
+     */
+    url: string;
+    /**
+     * Additional HTTP headers (e.g. Authorization)
+     */
+    headers?: Record<string, string>;
+}
+/**
+ * MCP Server configuration.
+ *
+ * - Stdio: `{ command, args?, env? }` — local subprocess
+ * - HTTP:  `{ transport: "http", url, headers? }` — remote server
+ */
+type McpServerConfig = McpStdioServerConfig | McpHttpServerConfig;
+/**
+ * StopReason - Why the LLM stopped generating
+ */
+type StopReason = "end_turn" | "max_tokens" | "tool_use" | "stop_sequence" | "content_filter" | "error" | "other";
+/**
+ * StreamEvent - Lightweight event from Driver
+ *
+ * Only contains essential fields: type, timestamp, data
+ * No source, category, intent, context (those are added by upper layers)
+ */
+interface StreamEvent<T extends string = string, D = unknown> {
+    readonly type: T;
+    readonly timestamp: number;
+    readonly data: D;
+}
+interface MessageStartEvent extends StreamEvent<"message_start", {
+    messageId: string;
+    model: string;
+}> {
+}
+interface MessageStopEvent extends StreamEvent<"message_stop", {
+    stopReason: StopReason;
+}> {
+}
+interface TextDeltaEvent extends StreamEvent<"text_delta", {
+    text: string;
+}> {
+}
+interface ToolUseStartEvent extends StreamEvent<"tool_use_start", {
+    toolCallId: string;
+    toolName: string;
+}> {
+}
+interface InputJsonDeltaEvent extends StreamEvent<"input_json_delta", {
+    partialJson: string;
+}> {
+}
+interface ToolUseStopEvent extends StreamEvent<"tool_use_stop", {
+    toolCallId: string;
+    toolName: string;
+    input: Record<string, unknown>;
+}> {
+}
+interface ToolResultEvent extends StreamEvent<"tool_result", {
+    toolCallId: string;
+    result: unknown;
+    isError?: boolean;
+}> {
+}
+interface ErrorEvent extends StreamEvent<"error", {
+    message: string;
+    errorCode?: string;
+}> {
+}
+interface MessageDeltaEvent extends StreamEvent<"message_delta", {
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+}> {
+}
+interface InterruptedEvent extends StreamEvent<"interrupted", {
+    reason: "user" | "timeout" | "error";
+}> {
+}
+/**
+ * DriverStreamEvent - Union of all stream events from Driver
+ */
+type DriverStreamEvent = MessageStartEvent | MessageDeltaEvent | MessageStopEvent | TextDeltaEvent | ToolUseStartEvent | InputJsonDeltaEvent | ToolUseStopEvent | ToolResultEvent | ErrorEvent | InterruptedEvent;
+/**
+ * DriverStreamEventType - String literal union of event types
+ */
+type DriverStreamEventType = DriverStreamEvent["type"];
+/**
+ * DriverConfig - All configuration for creating a Driver
+ *
+ * This is our capability boundary - we define what we support.
+ * Specific implementations (Claude, OpenAI) must work within this.
+ *
+ * @typeParam TOptions - Driver-specific options type. Each driver implementation
+ * can define its own options interface and pass it as a type parameter.
+ *
+ * @example
+ * ```typescript
+ * // Define driver-specific options
+ * interface ClaudeDriverOptions {
+ *   claudeCodePath?: string;
+ *   maxTurns?: number;
+ * }
+ *
+ * // Use with type parameter
+ * const config: DriverConfig<ClaudeDriverOptions> = {
+ *   apiKey: "...",
+ *   agentId: "my-agent",
+ *   options: {
+ *     claudeCodePath: "/usr/local/bin/claude"
+ *   }
+ * };
+ * ```
+ */
+interface DriverConfig<TOptions = Record<string, unknown>> {
+    /**
+     * API key for authentication
+     */
+    apiKey: string;
+    /**
+     * Base URL for API endpoint (optional, for custom deployments)
+     */
+    baseUrl?: string;
+    /**
+     * Model identifier (e.g., "claude-sonnet-4-20250514")
+     */
+    model?: string;
+    /**
+     * Request timeout in milliseconds (default: 600000 = 10 minutes)
+     */
+    timeout?: number;
+    /**
+     * Agent ID (for identification and logging)
+     */
+    agentId: string;
+    /**
+     * System prompt for the agent
+     */
+    systemPrompt?: string;
+    /**
+     * Current working directory for tool execution
+     */
+    cwd?: string;
+    /**
+     * MCP servers configuration
+     */
+    mcpServers?: Record<string, McpServerConfig>;
+    /**
+     * Tool definitions for LLM tool calling
+     *
+     * Tools are passed to the LLM provider and executed when the LLM
+     * requests a tool call. Each tool includes its JSON Schema (sent to
+     * the LLM) and an execute function (called at runtime).
+     */
+    tools?: ToolDefinition[];
+    /**
+     * Session for message history access
+     *
+     * Stateless drivers (like MonoDriver) use this to read conversation history.
+     * Stateful drivers (like ClaudeDriver) may ignore this as they manage
+     * history internally via SDK.
+     *
+     * @example
+     * ```typescript
+     * // MonoDriver reads history from Session
+     * const history = await config.session?.getMessages();
+     * ```
+     */
+    session?: Session;
+    /**
+     * Session ID to resume (for conversation continuity)
+     *
+     * If provided, Driver will attempt to resume this session.
+     * If not provided, a new session is created.
+     */
+    resumeSessionId?: string;
+    /**
+     * Callback when SDK session ID is captured
+     *
+     * Called once when the session ID becomes available.
+     * Save this ID to enable session resume later.
+     */
+    onSessionIdCaptured?: (sessionId: string) => void;
+    /**
+     * Driver-specific options
+     *
+     * Each driver implementation can define its own options type.
+     * This allows drivers to have custom configuration without
+     * polluting the base DriverConfig interface.
+     *
+     * @example
+     * ```typescript
+     * // ClaudeDriver options
+     * interface ClaudeDriverOptions {
+     *   claudeCodePath?: string;
+     * }
+     *
+     * const config: DriverConfig<ClaudeDriverOptions> = {
+     *   apiKey: "...",
+     *   options: { claudeCodePath: "/usr/bin/claude" }
+     * };
+     * ```
+     */
+    options?: TOptions;
+}
+/**
+ * DriverState - Current state of the Driver
+ *
+ * - idle: Ready to receive messages
+ * - active: Currently processing a message
+ * - disposed: Driver has been disposed, cannot be used
+ */
+type DriverState = "idle" | "active" | "disposed";
+/**
+ * Driver - LLM Communication Interface
+ *
+ * Responsible for a single session's communication with LLM.
+ * Similar to Kimi SDK's Session concept.
+ *
+ * Lifecycle:
+ * 1. createDriver(config) → Driver instance
+ * 2. driver.initialize() → Start SDK, MCP servers
+ * 3. driver.receive(message) → Send message, get events
+ * 4. driver.dispose() → Cleanup
+ *
+ * @example
+ * ```typescript
+ * const driver = createDriver(config);
+ * await driver.initialize();
+ *
+ * const events = driver.receive(message);
+ * for await (const event of events) {
+ *   if (event.type === "text_delta") {
+ *     console.log(event.data.text);
+ *   }
+ * }
+ *
+ * await driver.dispose();
+ * ```
+ */
+interface Driver {
+    /**
+     * Driver name (for identification and logging)
+     */
+    readonly name: string;
+    /**
+     * SDK Session ID (available after first message)
+     */
+    readonly sessionId: string | null;
+    /**
+     * Current state
+     */
+    readonly state: DriverState;
+    /**
+     * Receive a user message and return stream of events
+     *
+     * @param message - User message to send
+     * @returns AsyncIterable of stream events
+     */
+    receive(message: UserMessage): AsyncIterable<DriverStreamEvent>;
+    /**
+     * Interrupt current operation
+     *
+     * Stops the current receive() operation gracefully.
+     * The AsyncIterable will emit an "interrupted" event and complete.
+     */
+    interrupt(): void;
+    /**
+     * Initialize the Driver
+     *
+     * Starts SDK subprocess, MCP servers, etc.
+     * Must be called before receive().
+     */
+    initialize(): Promise<void>;
+    /**
+     * Dispose and cleanup resources
+     *
+     * Stops SDK subprocess, MCP servers, etc.
+     * Driver cannot be used after dispose().
+     */
+    dispose(): Promise<void>;
+}
+/**
+ * CreateDriver - Factory function type for creating Driver instances
+ *
+ * Each implementation package exports a function of this type.
+ *
+ * @typeParam TOptions - Driver-specific options type
+ *
+ * @example
+ * ```typescript
+ * // @agentxjs/claude-driver
+ * export const createClaudeDriver: CreateDriver<ClaudeDriverOptions> = (config) => {
+ *   return new ClaudeDriver(config);
+ * };
+ * ```
+ */
+type CreateDriver<TOptions = Record<string, unknown>> = (config: DriverConfig<TOptions>) => Driver;
+
+export type { ContainerRecord as C, DriverConfig as D, ErrorEvent as E, ImageRepository as I, McpServerConfig as M, Session as S, ToolDefinition as T, SessionConfig as a, SessionRecord as b, SessionRepository as c, ContainerRepository as d, ContainerConfig as e, ImageRecord as f, ImageMetadata as g, CreateDriver as h, DriverState as i, Driver as j, StreamEvent as k, StopReason as l, MessageStartEvent as m, MessageStopEvent as n, TextDeltaEvent as o, ToolUseStartEvent as p, InputJsonDeltaEvent as q, ToolUseStopEvent as r, ToolResultEvent as s, InterruptedEvent as t, DriverStreamEvent as u, DriverStreamEventType as v };

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export * from 'commonxjs/logger';
 export { AgentEngineState, AgentProcessorInput, AgentProcessorOutput, AgentStateMachine, MealyMachine, agentProcessor, createAgent, createInitialAgentEngineState, createMealyMachine } from './agent/index.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, U as UserMessage } from './message-BMrMm1pq.js';
-export { e as AgentError, d as AgentErrorCategory, _ as AgentErrorOccurredEvent, c as AgentEvent, ad as AgentEventHandler, a6 as AgentMessageEvent, A as AgentOutput, b as AgentOutputCallback, a as AgentState, $ 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, S as StreamEvent, 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, U as Unsubscribe, a1 as UserMessageEvent, af as isMessageEvent, ae as isStateEvent, ag as isTurnEvent } from './event-CDuTzs__.js';
+export { A as AssistantMessage, C as ContentPart, E as ErrorMessage, F as FilePart, I as ImagePart, M as Message, h as MessageRole, i as MessageSubtype, c as TextPart, d as ThinkingPart, a as TokenUsage, e as ToolCallPart, T as ToolResultMessage, f as ToolResultOutput, g as ToolResultPart, b as UserContentPart, U as UserMessage } from './message-03TJzvIX.js';
+export { e as AgentError, d as AgentErrorCategory, _ as AgentErrorOccurredEvent, c as AgentEvent, ac as AgentEventHandler, a5 as AgentMessageEvent, A as AgentOutput, b as AgentOutputCallback, a as AgentState, $ as AgentStateEvent, ab 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, a4 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, S as StreamEvent, v as StreamEventType, T as TextDeltaData, p as TextDeltaEvent, 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, a3 as ToolResultMessageEvent, i as ToolUseStartData, q as ToolUseStartEvent, j as ToolUseStopData, s as ToolUseStopEvent, a8 as TurnEvent, a6 as TurnRequestData, a9 as TurnRequestEvent, a7 as TurnResponseData, aa as TurnResponseEvent, U as Unsubscribe, a1 as UserMessageEvent, ae as isMessageEvent, ad as isStateEvent, af as isTurnEvent } from './event-DNWOBSBO.js';
 export { AgentEngine, AgentEventBus, AgentInterceptor, AgentInterceptorNext, AgentMiddleware, AgentMiddlewareNext, AgentPresenter, AgentSource, AgentStateMachineInterface, CreateAgentOptions, EventHandlerMap, MessageQueue, ReactHandlerMap, StateChange, StateChangeHandler } from './agent/types/index.js';
 export { MessageAssemblerInput, MessageAssemblerOutput, MessageAssemblerState, PendingContent, PendingTurn, StateEventProcessorContext, StateEventProcessorInput, StateEventProcessorOutput, TurnTrackerInput, TurnTrackerOutput, TurnTrackerState, createInitialMessageAssemblerState, createInitialStateEventProcessorContext, createInitialTurnTrackerState, messageAssemblerProcessor, messageAssemblerProcessorDef, stateEventProcessor, stateEventProcessorDef, turnTrackerProcessor, turnTrackerProcessorDef } from './agent/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';

package/dist/index.js

@@ -1,4 +1,4 @@
-import "./chunk-RL3JRNXM.js";
+import "./chunk-SKS7S2RY.js";
 import {
   AgentStateMachine,
   MealyMachine,
@@ -6,17 +6,7 @@ import {
   createAgent,
   createInitialAgentEngineState,
   createMealyMachine
-} from "./chunk-AT5P47YA.js";
-import {
-  MemoryStore,
-  chainProcessors,
-  combineInitialStates,
-  combineProcessors,
-  filterProcessor,
-  identityProcessor,
-  mapOutput,
-  withLogging
-} from "./chunk-EKHT54KN.js";
+} from "./chunk-JTKCV7IS.js";
 import {
   createInitialMessageAssemblerState,
   createInitialStateEventProcessorContext,
@@ -27,15 +17,25 @@ import {
   stateEventProcessorDef,
   turnTrackerProcessor,
   turnTrackerProcessorDef
-} from "./chunk-I7GYR3MN.js";
+} from "./chunk-DEAR6N3O.js";
+import {
+  MemoryStore,
+  chainProcessors,
+  combineInitialStates,
+  combineProcessors,
+  filterProcessor,
+  identityProcessor,
+  mapOutput,
+  withLogging
+} from "./chunk-EKHT54KN.js";
 import {
   isMessageEvent,
   isStateEvent,
   isTurnEvent
-} from "./chunk-K6WXQ2RW.js";
+} from "./chunk-23UUBQXR.js";
+import "./chunk-RL3JRNXM.js";
 import "./chunk-7ZDX3O6I.js";
-import "./chunk-E5FPOAPO.js";
-import "./chunk-7D4SUZUM.js";
+import "./chunk-LTVNPHST.js";
 export {
   AgentStateMachine,
   MealyMachine,