@agentxjs/core 2.0.0 → 2.0.1

package/src/agent/engine/internal/stateEventProcessor.ts

@@ -18,25 +18,25 @@
  * - tool_executing
  */
 
-import type { Processor, ProcessorDefinition } from "../mealy";
+import { createLogger } from "commonxjs/logger";
 import type {
+  ConversationEndEvent,
+  ConversationInterruptedEvent,
+  ConversationRespondingEvent,
+  // Output: State events
+  ConversationStartEvent,
   // Base type
   EngineEvent,
-  // Input: StreamEvent (from agent layer)
-  StreamEvent,
+  ErrorOccurredEvent,
   MessageStartEvent,
   MessageStopEvent,
-  ToolUseStartEvent,
-  // Output: State events
-  ConversationStartEvent,
-  ConversationRespondingEvent,
-  ConversationEndEvent,
-  ConversationInterruptedEvent,
-  ToolPlannedEvent,
+  // Input: StreamEvent (from agent layer)
+  StreamEvent,
   ToolExecutingEvent,
-  ErrorOccurredEvent,
+  ToolPlannedEvent,
+  ToolUseStartEvent,
 } from "../../types";
-import { createLogger } from "commonxjs/logger";
+import type { Processor, ProcessorDefinition } from "../mealy";
 
 const logger = createLogger("engine/stateEventProcessor");
 
@@ -50,9 +50,7 @@ const logger = createLogger("engine/stateEventProcessor");
  *
  * Currently empty - no context needed as all information comes from events.
  */
-export interface StateEventProcessorContext {
-  // Empty - all information comes from events
-}
+export type StateEventProcessorContext = {};
 
 /**
  * Initial context factory for StateEventProcessor

package/src/agent/engine/internal/turnTrackerProcessor.ts

@@ -13,17 +13,17 @@
  * - turn_response
  */
 
-import type { Processor, ProcessorDefinition } from "../mealy";
 import type {
-  StreamEvent,
   MessageStartEvent,
   MessageStopEvent,
+  StreamEvent,
+  // Data types
+  TokenUsage,
   // Output: Turn events
   TurnRequestEvent,
   TurnResponseEvent,
-  // Data types
-  TokenUsage,
 } from "../../types";
+import type { Processor, ProcessorDefinition } from "../mealy";
 
 // ===== State Types =====
 

package/src/agent/engine/mealy/Mealy.ts

@@ -31,10 +31,10 @@
  * ```
  */
 
+import { createLogger } from "commonxjs/logger";
 import type { Processor } from "./Processor";
-import type { Store } from "./Store";
 import type { Sink, SinkDefinition } from "./Sink";
-import { createLogger } from "commonxjs/logger";
+import type { Store } from "./Store";
 
 const logger = createLogger("engine/Mealy");
 

package/src/agent/engine/mealy/combinators.ts

@@ -28,13 +28,11 @@ import type { Processor } from "./Processor";
  * });
  * ```
  */
-export function combineProcessors<
-  TState extends Record<string, unknown>,
-  TInput,
-  TOutput,
->(processors: {
-  [K in keyof TState]: Processor<TState[K], TInput, TOutput>;
-}): Processor<TState, TInput, TOutput> {
+export function combineProcessors<TState extends Record<string, unknown>, TInput, TOutput>(
+  processors: {
+    [K in keyof TState]: Processor<TState[K], TInput, TOutput>;
+  }
+): Processor<TState, TInput, TOutput> {
   return (state: Readonly<TState>, event: TInput): [TState, TOutput[]] => {
     const newState = {} as TState;
     const allOutputs: TOutput[] = [];
@@ -55,9 +53,11 @@ export function combineProcessors<
 /**
  * combineInitialStates - Helper to create initial state for combined processors
  */
-export function combineInitialStates<TState extends Record<string, unknown>>(initialStates: {
-  [K in keyof TState]: () => TState[K];
-}): () => TState {
+export function combineInitialStates<TState extends Record<string, unknown>>(
+  initialStates: {
+    [K in keyof TState]: () => TState[K];
+  }
+): () => TState {
   return () => {
     const state = {} as TState;
     for (const key in initialStates) {

package/src/agent/engine/mealy/index.ts

@@ -16,30 +16,28 @@
 
 // ===== Core Components =====
 
-// Source - Input (input adapter)
-export { type Source, type SourceDefinition } from "./Source";
-
 // Processor - Processing (pure Mealy transition function)
-export { type Processor, type ProcessorResult, type ProcessorDefinition } from "./Processor";
-
+export type { Processor, ProcessorDefinition, ProcessorResult } from "./Processor";
 // Sink - Output (output adapter)
-export { type Sink, type SinkDefinition } from "./Sink";
+export type { Sink, SinkDefinition } from "./Sink";
+// Source - Input (input adapter)
+export type { Source, SourceDefinition } from "./Source";
 
 // Store - State storage
-export { type Store, MemoryStore } from "./Store";
+export { MemoryStore, type Store } from "./Store";
 
 // ===== Mealy Runtime =====
 
-export { Mealy, createMealy, type MealyConfig, type ProcessResult } from "./Mealy";
+export { createMealy, Mealy, type MealyConfig, type ProcessResult } from "./Mealy";
 
 // ===== Combinators =====
 
 export {
-  combineProcessors,
-  combineInitialStates,
   chainProcessors,
+  combineInitialStates,
+  combineProcessors,
   filterProcessor,
+  identityProcessor,
   mapOutput,
   withLogging,
-  identityProcessor,
 } from "./combinators";

package/src/agent/index.ts

@@ -30,8 +30,8 @@
 // Core API
 // ============================================================================
 
-export { createAgent } from "./createAgent";
 export { AgentStateMachine } from "./AgentStateMachine";
+export { createAgent } from "./createAgent";
 export type { AgentEngine, CreateAgentOptions } from "./types";
 
 // ============================================================================
@@ -44,63 +44,61 @@ export * from "./types";
 // Engine (Stateless)
 // ============================================================================
 
-// MealyMachine
-export { MealyMachine, createMealyMachine } from "./engine/MealyMachine";
-
 // AgentProcessor (for advanced use cases)
 export {
-  agentProcessor,
-  createInitialAgentEngineState,
   type AgentEngineState,
   type AgentProcessorInput,
   type AgentProcessorOutput,
+  agentProcessor,
+  createInitialAgentEngineState,
 } from "./engine/AgentProcessor";
-
 // Internal Processors (for advanced use cases)
 export {
-  // MessageAssembler
-  messageAssemblerProcessor,
-  messageAssemblerProcessorDef,
+  createInitialMessageAssemblerState,
+  createInitialStateEventProcessorContext,
+  createInitialTurnTrackerState,
   type MessageAssemblerInput,
   type MessageAssemblerOutput,
   type MessageAssemblerState,
+  // MessageAssembler
+  messageAssemblerProcessor,
+  messageAssemblerProcessorDef,
   type PendingContent,
-  createInitialMessageAssemblerState,
+  type PendingTurn,
+  type StateEventProcessorContext,
+  type StateEventProcessorInput,
+  type StateEventProcessorOutput,
   // StateEventProcessor
   stateEventProcessor,
   stateEventProcessorDef,
-  type StateEventProcessorInput,
-  type StateEventProcessorOutput,
-  type StateEventProcessorContext,
-  createInitialStateEventProcessorContext,
-  // TurnTracker
-  turnTrackerProcessor,
-  turnTrackerProcessorDef,
   type TurnTrackerInput,
   type TurnTrackerOutput,
   type TurnTrackerState,
-  type PendingTurn,
-  createInitialTurnTrackerState,
+  // TurnTracker
+  turnTrackerProcessor,
+  turnTrackerProcessorDef,
 } from "./engine/internal";
+// MealyMachine
+export { createMealyMachine, MealyMachine } from "./engine/MealyMachine";
 
 // Mealy Machine Core (for building custom processors)
 export {
-  // Core types
-  type Source,
-  type SourceDefinition,
+  chainProcessors,
+  combineInitialStates,
+  // Combinators
+  combineProcessors,
+  filterProcessor,
+  identityProcessor,
+  MemoryStore,
+  mapOutput,
   type Processor,
-  type ProcessorResult,
   type ProcessorDefinition,
+  type ProcessorResult,
   type Sink,
   type SinkDefinition,
+  // Core types
+  type Source,
+  type SourceDefinition,
   type Store,
-  MemoryStore,
-  // Combinators
-  combineProcessors,
-  combineInitialStates,
-  chainProcessors,
-  filterProcessor,
-  mapOutput,
   withLogging,
-  identityProcessor,
 } from "./engine/mealy";

package/src/agent/types/engine.ts

@@ -13,14 +13,14 @@
  * @packageDocumentation
  */
 
-import type { UserMessage } from "./message";
 import type {
-  AgentState,
   AgentOutput,
+  AgentOutputCallback,
+  AgentState,
   StreamEvent,
   Unsubscribe,
-  AgentOutputCallback,
 } from "./event";
+import type { UserMessage } from "./message";
 
 // =============================================================================
 // Message Queue

package/src/agent/types/event.ts

@@ -13,11 +13,11 @@
  */
 
 import type {
-  UserMessage,
   AssistantMessage,
-  ToolResultMessage,
   ErrorMessage,
   TokenUsage,
+  ToolResultMessage,
+  UserMessage,
 } from "./message";
 
 // =============================================================================
@@ -234,13 +234,9 @@ export interface ConversationStartData {
   messageId: string;
 }
 
-export interface ConversationThinkingData {
-  // Empty
-}
+export type ConversationThinkingData = {};
 
-export interface ConversationRespondingData {
-  // Empty
-}
+export type ConversationRespondingData = {};
 
 export interface ConversationEndData {
   reason: "completed" | "interrupted" | "error";

package/src/agent/types/index.ts

@@ -59,25 +59,25 @@
 // =============================================================================
 
 export type {
+  AssistantMessage,
+  ContentPart,
+  ErrorMessage,
+  FilePart,
+  ImagePart,
+  Message,
+  // Message Types
+  MessageRole,
+  MessageSubtype,
   // Content Parts
   TextPart,
   ThinkingPart,
-  ImagePart,
-  FilePart,
+  TokenUsage,
   ToolCallPart,
+  ToolResultMessage,
   ToolResultOutput,
   ToolResultPart,
-  ContentPart,
   UserContentPart,
-  // Message Types
-  MessageRole,
-  MessageSubtype,
-  TokenUsage,
   UserMessage,
-  AssistantMessage,
-  ToolResultMessage,
-  ErrorMessage,
-  Message,
 } from "./message";
 
 // =============================================================================
@@ -85,111 +85,111 @@ export type {
 // =============================================================================
 
 export type {
-  // Base Types
-  EngineEvent,
+  AgentError,
+  AgentErrorCategory,
+  AgentErrorOccurredEvent,
   AgentEvent,
+  AgentEventHandler,
+  AgentMessageEvent,
+  // Agent Output
+  AgentOutput,
+  AgentOutputCallback,
   // Agent State and Error
   AgentState,
-  AgentErrorCategory,
-  AgentError,
-  // Stream Events
-  StopReason,
-  MessageStartData,
-  MessageDeltaData,
-  MessageStopData,
-  TextDeltaData,
-  ToolUseStartData,
-  InputJsonDeltaData,
-  ToolUseStopData,
-  ToolResultData,
-  ErrorReceivedData,
-  MessageStartEvent,
-  MessageDeltaEvent,
-  MessageStopEvent,
-  TextDeltaEvent,
-  ToolUseStartEvent,
-  InputJsonDeltaEvent,
-  ToolUseStopEvent,
-  ToolResultEvent,
-  ErrorReceivedEvent,
-  StreamEvent,
-  StreamEventType,
-  // State Events
-  ConversationQueuedData,
-  ConversationStartData,
-  ConversationThinkingData,
-  ConversationRespondingData,
+  AgentStateEvent,
+  AgentTurnEvent,
+  AssistantMessageEvent,
   ConversationEndData,
+  ConversationEndEvent,
   ConversationInterruptedData,
-  ToolPlannedData,
-  ToolExecutingData,
-  ToolCompletedData,
-  ToolFailedData,
-  ErrorOccurredData,
-  StateEvent,
+  ConversationInterruptedEvent,
+  // State Events
+  ConversationQueuedData,
   ConversationQueuedEvent,
+  ConversationRespondingData,
+  ConversationRespondingEvent,
+  ConversationStartData,
   ConversationStartEvent,
+  ConversationThinkingData,
   ConversationThinkingEvent,
-  ConversationRespondingEvent,
-  ConversationEndEvent,
-  ConversationInterruptedEvent,
-  ToolPlannedEvent,
-  ToolExecutingEvent,
-  ToolCompletedEvent,
-  ToolFailedEvent,
+  // Base Types
+  EngineEvent,
+  ErrorMessageEvent,
+  ErrorOccurredData,
   ErrorOccurredEvent,
-  AgentErrorOccurredEvent,
-  AgentStateEvent,
+  ErrorReceivedData,
+  ErrorReceivedEvent,
+  InputJsonDeltaData,
+  InputJsonDeltaEvent,
+  MessageDeltaData,
+  MessageDeltaEvent,
   // Message Events
   MessageEvent,
-  UserMessageEvent,
-  AssistantMessageEvent,
+  MessageStartData,
+  MessageStartEvent,
+  MessageStopData,
+  MessageStopEvent,
+  StateEvent,
+  // Stream Events
+  StopReason,
+  StreamEvent,
+  StreamEventType,
+  TextDeltaData,
+  TextDeltaEvent,
+  ToolCompletedData,
+  ToolCompletedEvent,
+  ToolExecutingData,
+  ToolExecutingEvent,
+  ToolFailedData,
+  ToolFailedEvent,
+  ToolPlannedData,
+  ToolPlannedEvent,
+  ToolResultData,
+  ToolResultEvent,
   ToolResultMessageEvent,
-  ErrorMessageEvent,
-  AgentMessageEvent,
+  ToolUseStartData,
+  ToolUseStartEvent,
+  ToolUseStopData,
+  ToolUseStopEvent,
+  TurnEvent,
   // Turn Events
   TurnRequestData,
-  TurnResponseData,
-  TurnEvent,
   TurnRequestEvent,
+  TurnResponseData,
   TurnResponseEvent,
-  AgentTurnEvent,
-  // Agent Output
-  AgentOutput,
   // Event Handling
   Unsubscribe,
-  AgentOutputCallback,
-  AgentEventHandler,
+  UserMessageEvent,
 } from "./event";
 
 // Type guards (functions, not types)
-export { isStateEvent, isMessageEvent, isTurnEvent } from "./event";
+export { isMessageEvent, isStateEvent, isTurnEvent } from "./event";
 
 // =============================================================================
 // Engine Types - Engine, Source, Presenter, Middleware, Interceptor
 // =============================================================================
 
 export type {
-  // Message Queue
-  MessageQueue,
-  // Middleware & Interceptor
-  AgentMiddlewareNext,
-  AgentMiddleware,
-  AgentInterceptorNext,
-  AgentInterceptor,
-  // State Machine
-  StateChange,
-  StateChangeHandler,
-  AgentStateMachineInterface,
-  // Event Handler Maps
-  EventHandlerMap,
-  ReactHandlerMap,
   // Agent Engine
   AgentEngine,
+  AgentEventBus,
+  AgentInterceptor,
+  AgentInterceptorNext,
+  AgentMiddleware,
+  // Middleware & Interceptor
+  AgentMiddlewareNext,
+  AgentPresenter,
   // Source & Presenter (EventBus adapters)
   AgentSource,
-  AgentPresenter,
-  AgentEventBus,
+  AgentStateMachineInterface,
   // Factory Options
   CreateAgentOptions,
+  // Event Handler Maps
+  EventHandlerMap,
+  // Message Queue
+  MessageQueue,
+  ReactHandlerMap,
+  // State Machine
+  StateChange,
+  StateChangeHandler,
 } from "./engine";

package/src/bash/index.ts

@@ -17,5 +17,5 @@
  * ```
  */
 
-export type { BashProvider, BashResult, BashOptions } from "./types";
 export { createBashTool } from "./tool";
+export type { BashOptions, BashProvider, BashResult } from "./types";

package/src/common/logger/ConsoleLogger.ts

@@ -5,7 +5,7 @@
  * Used as fallback when no custom LoggerFactory is provided.
  */
 
-import type { Logger, LogContext, LogLevel } from "./types";
+import type { LogContext, Logger, LogLevel } from "./types";
 
 export interface ConsoleLoggerOptions {
   level?: LogLevel;

package/src/common/logger/LoggerFactoryImpl.ts

@@ -7,8 +7,8 @@
  * - External LoggerFactory can be injected via Runtime
  */
 
-import type { Logger, LoggerFactory, LogContext, LogLevel } from "./types";
 import { ConsoleLogger, type ConsoleLoggerOptions } from "./ConsoleLogger";
+import type { LogContext, Logger, LoggerFactory, LogLevel } from "./types";
 
 // External factory injected via Runtime
 let externalFactory: LoggerFactory | null = null;
@@ -36,22 +36,22 @@ export class LoggerFactoryImpl {
   static getLogger(nameOrClass: string | (new (...args: unknown[]) => unknown)): Logger {
     const name = typeof nameOrClass === "string" ? nameOrClass : nameOrClass.name;
 
-    if (this.loggers.has(name)) {
-      return this.loggers.get(name)!;
+    if (LoggerFactoryImpl.loggers.has(name)) {
+      return LoggerFactoryImpl.loggers.get(name)!;
     }
 
-    const lazyLogger = this.createLazyLogger(name);
-    this.loggers.set(name, lazyLogger);
+    const lazyLogger = LoggerFactoryImpl.createLazyLogger(name);
+    LoggerFactoryImpl.loggers.set(name, lazyLogger);
     return lazyLogger;
   }
 
   static configure(config: LoggerFactoryConfig): void {
-    this.config = { ...this.config, ...config };
+    LoggerFactoryImpl.config = { ...LoggerFactoryImpl.config, ...config };
   }
 
   static reset(): void {
-    this.loggers.clear();
-    this.config = { defaultLevel: "info" };
+    LoggerFactoryImpl.loggers.clear();
+    LoggerFactoryImpl.config = { defaultLevel: "info" };
     externalFactory = null;
     factoryVersion++; // Invalidate all cached real loggers
   }
@@ -63,7 +63,7 @@ export class LoggerFactoryImpl {
     const getRealLogger = (): Logger => {
       // Recreate logger if factory version changed (setLoggerFactory was called)
       if (!realLogger || loggerVersion !== factoryVersion) {
-        realLogger = this.createLogger(name);
+        realLogger = LoggerFactoryImpl.createLogger(name);
         loggerVersion = factoryVersion;
       }
       return realLogger;
@@ -71,7 +71,7 @@ export class LoggerFactoryImpl {
 
     return {
       name,
-      level: this.config.defaultLevel || "info",
+      level: LoggerFactoryImpl.config.defaultLevel || "info",
       debug: (message: string, context?: LogContext) => getRealLogger().debug(message, context),
       info: (message: string, context?: LogContext) => getRealLogger().info(message, context),
       warn: (message: string, context?: LogContext) => getRealLogger().warn(message, context),
@@ -89,13 +89,13 @@ export class LoggerFactoryImpl {
       return externalFactory.getLogger(name);
     }
 
-    if (this.config.defaultImplementation) {
-      return this.config.defaultImplementation(name);
+    if (LoggerFactoryImpl.config.defaultImplementation) {
+      return LoggerFactoryImpl.config.defaultImplementation(name);
     }
 
     return new ConsoleLogger(name, {
-      level: this.config.defaultLevel,
-      ...this.config.consoleOptions,
+      level: LoggerFactoryImpl.config.defaultLevel,
+      ...LoggerFactoryImpl.config.consoleOptions,
     });
   }
 }

package/src/common/logger/index.ts

@@ -16,11 +16,11 @@
  * ```
  */
 
-export type { Logger, LoggerFactory, LogContext, LogLevel } from "./types";
 export { ConsoleLogger, type ConsoleLoggerOptions } from "./ConsoleLogger";
 export {
-  LoggerFactoryImpl,
+  createLogger,
   type LoggerFactoryConfig,
+  LoggerFactoryImpl,
   setLoggerFactory,
-  createLogger,
 } from "./LoggerFactoryImpl";
+export type { LogContext, Logger, LoggerFactory, LogLevel } from "./types";

package/src/container/index.ts

@@ -32,13 +32,12 @@
  * ```
  */
 
+export { ContainerImpl, createContainer, getOrCreateContainer, loadContainer } from "./Container";
 export type {
-  ContainerRecord,
-  ContainerConfig,
-  ContainerRepository,
   Container,
+  ContainerConfig,
   ContainerContext,
   ContainerCreateConfig,
+  ContainerRecord,
+  ContainerRepository,
 } from "./types";
-
-export { ContainerImpl, createContainer, loadContainer, getOrCreateContainer } from "./Container";

package/src/container/types.ts

@@ -16,7 +16,7 @@ import type { SessionRepository } from "../session/types";
 // Re-export from persistence (storage schema)
 // ============================================================================
 
-export type { ContainerRecord, ContainerConfig, ContainerRepository } from "../persistence/types";
+export type { ContainerConfig, ContainerRecord, ContainerRepository } from "../persistence/types";
 
 // ============================================================================
 // Container Interface