@agentxjs/core 1.9.5-dev → 1.9.7-dev

package/dist/chunk-EKHT54KN.js

@@ -0,0 +1,272 @@
+// src/agent/engine/mealy/Store.ts
+var MemoryStore = class {
+  states = /* @__PURE__ */ new Map();
+  get(id) {
+    return this.states.get(id);
+  }
+  set(id, state) {
+    this.states.set(id, state);
+  }
+  delete(id) {
+    this.states.delete(id);
+  }
+  has(id) {
+    return this.states.has(id);
+  }
+  /**
+   * Clear all stored states
+   */
+  clear() {
+    this.states.clear();
+  }
+  /**
+   * Get the number of stored states
+   */
+  get size() {
+    return this.states.size;
+  }
+  /**
+   * Get all stored IDs
+   */
+  keys() {
+    return this.states.keys();
+  }
+};
+
+// src/agent/engine/mealy/Mealy.ts
+import { createLogger } from "commonxjs/logger";
+var logger = createLogger("engine/Mealy");
+var Mealy = class {
+  processor;
+  store;
+  initialState;
+  sinks;
+  recursive;
+  maxDepth;
+  constructor(config) {
+    this.processor = config.processor;
+    this.store = config.store;
+    this.initialState = config.initialState;
+    this.sinks = config.sinks ?? [];
+    this.recursive = config.recursive ?? true;
+    this.maxDepth = config.maxDepth ?? 100;
+    logger.debug("Mealy instance created", {
+      sinkCount: this.sinks.length,
+      recursive: this.recursive,
+      maxDepth: this.maxDepth
+    });
+  }
+  /**
+   * 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, input) {
+    return this.processInternal(id, input, 0);
+  }
+  /**
+   * Internal process with depth tracking
+   */
+  processInternal(id, input, depth) {
+    if (depth >= this.maxDepth) {
+      logger.warn("Max recursion depth reached", {
+        id,
+        maxDepth: this.maxDepth,
+        depth
+      });
+      return {
+        state: this.store.get(id) ?? this.initialState,
+        outputs: [],
+        processCount: 0
+      };
+    }
+    let state = this.store.get(id);
+    if (state === void 0) {
+      state = this.initialState;
+    }
+    const [newState, outputs] = this.processor(state, input);
+    this.store.set(id, newState);
+    const allOutputs = [...outputs];
+    let processCount = 1;
+    if (outputs.length > 0) {
+      this.sendToSinks(id, outputs);
+    }
+    if (this.recursive) {
+      for (const output of outputs) {
+        const result = this.processInternal(id, output, depth + 1);
+        allOutputs.push(...result.outputs);
+        processCount += result.processCount;
+      }
+    }
+    return {
+      state: newState,
+      outputs: allOutputs,
+      processCount
+    };
+  }
+  /**
+   * Send outputs to all sinks
+   */
+  sendToSinks(id, outputs) {
+    for (const sink of this.sinks) {
+      if (typeof sink === "function") {
+        try {
+          const result = sink(id, outputs);
+          if (result instanceof Promise) {
+            result.catch((error) => {
+              logger.error("Sink error (async)", { id, error });
+            });
+          }
+        } catch (error) {
+          logger.error("Sink error (sync)", { id, error });
+        }
+      } else {
+        const filteredOutputs = sink.filter ? outputs.filter(sink.filter) : outputs;
+        if (filteredOutputs.length === 0) {
+          continue;
+        }
+        try {
+          const result = sink.sink(id, filteredOutputs);
+          if (result instanceof Promise) {
+            result.catch((error) => {
+              logger.error("Named sink error (async)", {
+                id,
+                sinkName: sink.name,
+                error
+              });
+            });
+          }
+        } catch (error) {
+          logger.error("Named sink error (sync)", {
+            id,
+            sinkName: sink.name,
+            error
+          });
+        }
+      }
+    }
+  }
+  /**
+   * Get current state for an ID (without processing)
+   */
+  getState(id) {
+    return this.store.get(id);
+  }
+  /**
+   * Check if state exists for an ID
+   */
+  hasState(id) {
+    return this.store.has(id);
+  }
+  /**
+   * Delete state for an ID (cleanup)
+   */
+  cleanup(id) {
+    logger.debug("Cleaning up state", { id });
+    this.store.delete(id);
+  }
+  /**
+   * Add a sink at runtime
+   */
+  addSink(sink) {
+    const sinkName = typeof sink === "function" ? "(anonymous)" : sink.name;
+    logger.debug("Adding sink", { sinkName });
+    this.sinks.push(sink);
+  }
+  /**
+   * Remove a sink by name (only works for SinkDefinitions)
+   */
+  removeSink(name) {
+    const index = this.sinks.findIndex((s) => typeof s !== "function" && s.name === name);
+    if (index !== -1) {
+      this.sinks.splice(index, 1);
+      logger.debug("Removed sink", { name });
+      return true;
+    }
+    logger.debug("Sink not found for removal", { name });
+    return false;
+  }
+};
+function createMealy(config) {
+  return new Mealy(config);
+}
+
+// src/agent/engine/mealy/combinators.ts
+function combineProcessors(processors) {
+  return (state, event) => {
+    const newState = {};
+    const allOutputs = [];
+    for (const key in processors) {
+      const processor = processors[key];
+      const subState = state[key];
+      const [newSubState, outputs] = processor(subState, event);
+      newState[key] = newSubState;
+      allOutputs.push(...outputs);
+    }
+    return [newState, allOutputs];
+  };
+}
+function combineInitialStates(initialStates) {
+  return () => {
+    const state = {};
+    for (const key in initialStates) {
+      state[key] = initialStates[key]();
+    }
+    return state;
+  };
+}
+function chainProcessors(...processors) {
+  return (state, event) => {
+    let currentState = state;
+    const finalOutputs = [];
+    for (const processor of processors) {
+      const [newState, outputs] = processor(currentState, event);
+      currentState = newState;
+      finalOutputs.push(...outputs);
+    }
+    return [currentState, finalOutputs];
+  };
+}
+function filterProcessor(predicate, processor) {
+  return (state, event) => {
+    if (predicate(event)) {
+      return processor(state, event);
+    }
+    return [state, []];
+  };
+}
+function mapOutput(processor, mapper) {
+  return (state, event) => {
+    const [newState, outputs] = processor(state, event);
+    return [newState, outputs.map(mapper)];
+  };
+}
+function withLogging(processor, name, logger2 = console) {
+  return (state, event) => {
+    logger2.debug(`[${name}] Input:`, { event, state });
+    const [newState, outputs] = processor(state, event);
+    logger2.debug(`[${name}] Output:`, { newState, outputs });
+    return [newState, outputs];
+  };
+}
+function identityProcessor() {
+  return (state, _event) => {
+    return [state, []];
+  };
+}
+
+export {
+  MemoryStore,
+  Mealy,
+  createMealy,
+  combineProcessors,
+  combineInitialStates,
+  chainProcessors,
+  filterProcessor,
+  mapOutput,
+  withLogging,
+  identityProcessor
+};
+//# sourceMappingURL=chunk-EKHT54KN.js.map

package/dist/chunk-EKHT54KN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/agent/engine/mealy/Store.ts","../src/agent/engine/mealy/Mealy.ts","../src/agent/engine/mealy/combinators.ts"],"sourcesContent":["/**\n * Store - State storage interface for stream processing\n *\n * A Store abstracts state persistence, allowing processors to be stateless\n * while maintaining state externally.\n *\n * @template T - The state type to store\n *\n * @example\n * ```typescript\n * const store = new MemoryStore<AgentState>();\n * store.set('agent_123', { count: 0 });\n * const state = store.get('agent_123');\n * ```\n */\nexport interface Store<T> {\n  /**\n   * Get state by ID\n   * @param id - Unique identifier (e.g., agentId, sessionId)\n   * @returns The stored state or undefined if not found\n   */\n  get(id: string): T | undefined;\n\n  /**\n   * Set state for an ID\n   * @param id - Unique identifier\n   * @param state - The state to store\n   */\n  set(id: string, state: T): void;\n\n  /**\n   * Delete state for an ID\n   * @param id - Unique identifier\n   */\n  delete(id: string): void;\n\n  /**\n   * Check if state exists for an ID\n   * @param id - Unique identifier\n   * @returns True if state exists\n   */\n  has(id: string): boolean;\n}\n\n/**\n * MemoryStore - In-memory implementation of Store\n *\n * Stores state in a Map. Suitable for development and single-process deployments.\n * For production multi-process scenarios, use RedisStore or PostgresStore.\n *\n * @template T - The state type to store\n *\n * @example\n * ```typescript\n * const store = new MemoryStore<MyState>();\n * store.set('session_1', { count: 0 });\n * ```\n */\nexport class MemoryStore<T> implements Store<T> {\n  private states = new Map<string, T>();\n\n  get(id: string): T | undefined {\n    return this.states.get(id);\n  }\n\n  set(id: string, state: T): void {\n    this.states.set(id, state);\n  }\n\n  delete(id: string): void {\n    this.states.delete(id);\n  }\n\n  has(id: string): boolean {\n    return this.states.has(id);\n  }\n\n  /**\n   * Clear all stored states\n   */\n  clear(): void {\n    this.states.clear();\n  }\n\n  /**\n   * Get the number of stored states\n   */\n  get size(): number {\n    return this.states.size;\n  }\n\n  /**\n   * Get all stored IDs\n   */\n  keys(): IterableIterator<string> {\n    return this.states.keys();\n  }\n}\n","/**\n * Mealy - The Mealy Machine runtime\n *\n * A Mealy Machine is a finite-state machine where outputs depend on\n * both the current state AND the input: (state, input) => (state, output)\n *\n * This runtime orchestrates the complete processing pipeline:\n * 1. Sources receive external input (side effects)\n * 2. Processors process inputs (pure Mealy transition functions)\n * 3. Sinks produce output effects (side effects)\n *\n * Architecture:\n * - Inputs enter through Sources (input adapters)\n * - Processors transform inputs (pure functions, state is means)\n * - Sinks produce actions (output adapters)\n *\n * @template TState - The state type (accumulator, means to an end)\n * @template TInput - The input/output type for Processors\n *\n * @example\n * ```typescript\n * const mealy = createMealy({\n *   processor: messageProcessor,\n *   store: new MemoryStore(),\n *   initialState: { text: '' },\n *   sinks: [sseSink, logSink],\n * });\n *\n * // Process an input\n * mealy.process('agent_123', input);\n * ```\n */\n\nimport type { Processor } from \"./Processor\";\nimport type { Store } from \"./Store\";\nimport type { Sink, SinkDefinition } from \"./Sink\";\nimport { createLogger } from \"commonxjs/logger\";\n\nconst logger = createLogger(\"engine/Mealy\");\n\n/**\n * MealyConfig - Configuration for creating a Mealy instance\n */\nexport interface MealyConfig<TState, TInput> {\n  /**\n   * The processor function to execute (pure Mealy transition function)\n   */\n  processor: Processor<TState, TInput, TInput>;\n\n  /**\n   * The store for state persistence\n   */\n  store: Store<TState>;\n\n  /**\n   * Initial state for new IDs\n   */\n  initialState: TState;\n\n  /**\n   * Sinks to receive outputs\n   * Can be simple Sink functions or SinkDefinitions with filter/name\n   */\n  sinks?: (Sink<TInput> | SinkDefinition<TInput>)[];\n\n  /**\n   * Whether to recursively process outputs\n   * If true, outputs are fed back into the processor\n   *\n   * @default true\n   */\n  recursive?: boolean;\n\n  /**\n   * Maximum recursion depth to prevent infinite loops\n   *\n   * @default 100\n   */\n  maxDepth?: number;\n}\n\n/**\n * ProcessResult - Result of processing an input\n */\nexport interface ProcessResult<TState, TOutput> {\n  /**\n   * The new state after processing\n   */\n  state: TState;\n\n  /**\n   * All outputs produced (including from recursion)\n   */\n  outputs: TOutput[];\n\n  /**\n   * Number of processor invocations (including recursion)\n   */\n  processCount: number;\n}\n\n/**\n * Mealy - Mealy Machine runtime\n *\n * Implements the Mealy Machine pattern: (state, input) => (state, output)\n * where output depends on both current state and input.\n */\nexport class Mealy<TState, TInput> {\n  private readonly processor: Processor<TState, TInput, TInput>;\n  private readonly store: Store<TState>;\n  private readonly initialState: TState;\n  private readonly sinks: (Sink<TInput> | SinkDefinition<TInput>)[];\n  private readonly recursive: boolean;\n  private readonly maxDepth: number;\n\n  constructor(config: MealyConfig<TState, TInput>) {\n    this.processor = config.processor;\n    this.store = config.store;\n    this.initialState = config.initialState;\n    this.sinks = config.sinks ?? [];\n    this.recursive = config.recursive ?? true;\n    this.maxDepth = config.maxDepth ?? 100;\n\n    logger.debug(\"Mealy instance created\", {\n      sinkCount: this.sinks.length,\n      recursive: this.recursive,\n      maxDepth: this.maxDepth,\n    });\n  }\n\n  /**\n   * Process an input through the Mealy Machine\n   *\n   * @param id - Unique identifier (e.g., agentId)\n   * @param input - The input to process\n   * @returns Result containing new state and all outputs\n   */\n  process(id: string, input: TInput): ProcessResult<TState, TInput> {\n    return this.processInternal(id, input, 0);\n  }\n\n  /**\n   * Internal process with depth tracking\n   */\n  private processInternal(id: string, input: TInput, depth: number): ProcessResult<TState, TInput> {\n    // Guard against infinite recursion\n    if (depth >= this.maxDepth) {\n      logger.warn(\"Max recursion depth reached\", {\n        id,\n        maxDepth: this.maxDepth,\n        depth,\n      });\n      return {\n        state: this.store.get(id) ?? this.initialState,\n        outputs: [],\n        processCount: 0,\n      };\n    }\n\n    // 1. Get current state (or initialize)\n    let state = this.store.get(id);\n    if (state === undefined) {\n      state = this.initialState;\n    }\n\n    // 2. Execute pure processor function (Mealy transition)\n    const [newState, outputs] = this.processor(state, input);\n\n    // 3. Save new state to store\n    this.store.set(id, newState);\n\n    // 4. Collect all outputs\n    const allOutputs: TInput[] = [...outputs];\n    let processCount = 1;\n\n    // 5. Send outputs to sinks\n    if (outputs.length > 0) {\n      this.sendToSinks(id, outputs);\n    }\n\n    // 6. Optionally recurse on outputs\n    if (this.recursive) {\n      for (const output of outputs) {\n        const result = this.processInternal(id, output, depth + 1);\n        allOutputs.push(...result.outputs);\n        processCount += result.processCount;\n      }\n    }\n\n    return {\n      state: newState,\n      outputs: allOutputs,\n      processCount,\n    };\n  }\n\n  /**\n   * Send outputs to all sinks\n   */\n  private sendToSinks(id: string, outputs: TInput[]): void {\n    for (const sink of this.sinks) {\n      // Check if sink is a function or SinkDefinition\n      if (typeof sink === \"function\") {\n        // Simple Sink function: (id, outputs) => void\n        try {\n          const result = sink(id, outputs);\n          if (result instanceof Promise) {\n            result.catch((error) => {\n              logger.error(\"Sink error (async)\", { id, error });\n            });\n          }\n        } catch (error) {\n          logger.error(\"Sink error (sync)\", { id, error });\n        }\n      } else {\n        // SinkDefinition with filter/name\n        const filteredOutputs = sink.filter ? outputs.filter(sink.filter) : outputs;\n\n        if (filteredOutputs.length === 0) {\n          continue;\n        }\n\n        try {\n          const result = sink.sink(id, filteredOutputs);\n          if (result instanceof Promise) {\n            result.catch((error) => {\n              logger.error(\"Named sink error (async)\", {\n                id,\n                sinkName: sink.name,\n                error,\n              });\n            });\n          }\n        } catch (error) {\n          logger.error(\"Named sink error (sync)\", {\n            id,\n            sinkName: sink.name,\n            error,\n          });\n        }\n      }\n    }\n  }\n\n  /**\n   * Get current state for an ID (without processing)\n   */\n  getState(id: string): TState | undefined {\n    return this.store.get(id);\n  }\n\n  /**\n   * Check if state exists for an ID\n   */\n  hasState(id: string): boolean {\n    return this.store.has(id);\n  }\n\n  /**\n   * Delete state for an ID (cleanup)\n   */\n  cleanup(id: string): void {\n    logger.debug(\"Cleaning up state\", { id });\n    this.store.delete(id);\n  }\n\n  /**\n   * Add a sink at runtime\n   */\n  addSink(sink: Sink<TInput> | SinkDefinition<TInput>): void {\n    const sinkName = typeof sink === \"function\" ? \"(anonymous)\" : sink.name;\n    logger.debug(\"Adding sink\", { sinkName });\n    this.sinks.push(sink);\n  }\n\n  /**\n   * Remove a sink by name (only works for SinkDefinitions)\n   */\n  removeSink(name: string): boolean {\n    const index = this.sinks.findIndex((s) => typeof s !== \"function\" && s.name === name);\n    if (index !== -1) {\n      this.sinks.splice(index, 1);\n      logger.debug(\"Removed sink\", { name });\n      return true;\n    }\n    logger.debug(\"Sink not found for removal\", { name });\n    return false;\n  }\n}\n\n/**\n * createMealy - Factory function for creating Mealy Machine instances\n *\n * @example\n * ```typescript\n * const mealy = createMealy({\n *   processor: myProcessor,\n *   store: new MemoryStore(),\n *   initialState: { count: 0 },\n *   sinks: [logSink],\n * });\n * ```\n */\nexport function createMealy<TState, TInput>(\n  config: MealyConfig<TState, TInput>\n): Mealy<TState, TInput> {\n  return new Mealy(config);\n}\n","/**\n * Combinators - Functions to compose multiple Processors\n *\n * These utilities allow building complex stream processing pipelines\n * from simple, composable Processor functions.\n */\n\nimport type { Processor } from \"./Processor\";\n\n/**\n * combineProcessors - Combine multiple processors into one\n *\n * Each sub-processor manages its own slice of state.\n * All processors receive the same event and their outputs are merged.\n *\n * @example\n * ```typescript\n * interface CombinedState {\n *   message: MessageState;\n *   state: StateMachineState;\n *   turn: TurnState;\n * }\n *\n * const combinedProcessor = combineProcessors<CombinedState, Event, Event>({\n *   message: messageProcessor,\n *   state: stateMachineProcessor,\n *   turn: turnTrackerProcessor,\n * });\n * ```\n */\nexport function combineProcessors<\n  TState extends Record<string, unknown>,\n  TInput,\n  TOutput,\n>(processors: {\n  [K in keyof TState]: Processor<TState[K], TInput, TOutput>;\n}): Processor<TState, TInput, TOutput> {\n  return (state: Readonly<TState>, event: TInput): [TState, TOutput[]] => {\n    const newState = {} as TState;\n    const allOutputs: TOutput[] = [];\n\n    for (const key in processors) {\n      const processor = processors[key];\n      const subState = state[key];\n      const [newSubState, outputs] = processor(subState, event);\n\n      newState[key] = newSubState;\n      allOutputs.push(...outputs);\n    }\n\n    return [newState, allOutputs];\n  };\n}\n\n/**\n * combineInitialStates - Helper to create initial state for combined processors\n */\nexport function combineInitialStates<TState extends Record<string, unknown>>(initialStates: {\n  [K in keyof TState]: () => TState[K];\n}): () => TState {\n  return () => {\n    const state = {} as TState;\n    for (const key in initialStates) {\n      state[key] = initialStates[key]();\n    }\n    return state;\n  };\n}\n\n/**\n * chainProcessors - Chain processors where output of one feeds into the next\n *\n * Useful for layered event processing:\n * Stream Events → Message Events → Turn Events\n *\n * @example\n * ```typescript\n * const pipeline = chainProcessors(\n *   streamToMessageProcessor,\n *   messageToTurnProcessor,\n * );\n * ```\n */\nexport function chainProcessors<TState, TEvent>(\n  ...processors: Processor<TState, TEvent, TEvent>[]\n): Processor<TState, TEvent, TEvent> {\n  return (state: Readonly<TState>, event: TEvent): [TState, TEvent[]] => {\n    let currentState = state as TState;\n    const finalOutputs: TEvent[] = [];\n\n    // Run the event through all processors\n    for (const processor of processors) {\n      const [newState, outputs] = processor(currentState, event);\n      currentState = newState;\n      finalOutputs.push(...outputs);\n    }\n\n    return [currentState, finalOutputs];\n  };\n}\n\n/**\n * filterProcessor - Create a processor that only processes certain events\n *\n * @example\n * ```typescript\n * const textOnlyProcessor = filterProcessor(\n *   (event) => event.type === 'text_delta',\n *   textProcessor,\n * );\n * ```\n */\nexport function filterProcessor<TState, TInput, TOutput>(\n  predicate: (event: TInput) => boolean,\n  processor: Processor<TState, TInput, TOutput>\n): Processor<TState, TInput, TOutput> {\n  return (state: Readonly<TState>, event: TInput): [TState, TOutput[]] => {\n    if (predicate(event)) {\n      return processor(state, event);\n    }\n    return [state as TState, []];\n  };\n}\n\n/**\n * mapOutput - Transform output events\n *\n * @example\n * ```typescript\n * const withTimestamp = mapOutput(\n *   myProcessor,\n *   (output) => ({ ...output, processedAt: Date.now() }),\n * );\n * ```\n */\nexport function mapOutput<TState, TInput, TOutput, TMapped>(\n  processor: Processor<TState, TInput, TOutput>,\n  mapper: (output: TOutput) => TMapped\n): Processor<TState, TInput, TMapped> {\n  return (state: Readonly<TState>, event: TInput): [TState, TMapped[]] => {\n    const [newState, outputs] = processor(state, event);\n    return [newState, outputs.map(mapper)];\n  };\n}\n\n/**\n * withLogging - Add logging to a processor (for debugging)\n *\n * @example\n * ```typescript\n * const debugProcessor = withLogging(myProcessor, 'MyProcessor');\n * ```\n */\nexport function withLogging<TState, TInput, TOutput>(\n  processor: Processor<TState, TInput, TOutput>,\n  name: string,\n  logger: {\n    debug: (message: string, data?: unknown) => void;\n  } = console\n): Processor<TState, TInput, TOutput> {\n  return (state: Readonly<TState>, event: TInput): [TState, TOutput[]] => {\n    logger.debug(`[${name}] Input:`, { event, state });\n    const [newState, outputs] = processor(state, event);\n    logger.debug(`[${name}] Output:`, { newState, outputs });\n    return [newState, outputs];\n  };\n}\n\n/**\n * identityProcessor - A processor that does nothing (useful as default)\n */\nexport function identityProcessor<TState, TEvent>(): Processor<TState, TEvent, TEvent> {\n  return (state: Readonly<TState>, _event: TEvent): [TState, TEvent[]] => {\n    return [state as TState, []];\n  };\n}\n"],"mappings":"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","names":["logger"]}