@agentxjs/core 2.0.0 → 3.0.0

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

package/src/driver/index.ts

@@ -16,28 +16,26 @@
  */
 
 export type {
-  // Configuration
-  McpServerConfig,
-  ToolDefinition,
-  DriverConfig,
-  DriverState,
-
+  CreateDriver,
   // Core Interface
   Driver,
-  CreateDriver,
-
-  // Stream Events
-  StreamEvent,
-  StopReason,
+  DriverConfig,
+  DriverState,
+  DriverStreamEvent,
+  DriverStreamEventType,
+  ErrorEvent,
+  InputJsonDeltaEvent,
+  InterruptedEvent,
+  // Configuration
+  McpServerConfig,
   MessageStartEvent,
   MessageStopEvent,
+  StopReason,
+  // Stream Events
+  StreamEvent,
   TextDeltaEvent,
+  ToolDefinition,
+  ToolResultEvent,
   ToolUseStartEvent,
-  InputJsonDeltaEvent,
   ToolUseStopEvent,
-  ToolResultEvent,
-  ErrorEvent,
-  InterruptedEvent,
-  DriverStreamEvent,
-  DriverStreamEventType,
 } from "./types";

package/src/driver/types.ts

@@ -170,85 +170,95 @@ export interface StreamEvent<T extends string = string, D = unknown> {
 }
 
 // Stream Event Types
-export interface MessageStartEvent extends StreamEvent<
-  "message_start",
-  {
-    messageId: string;
-    model: string;
-  }
-> {}
-
-export interface MessageStopEvent extends StreamEvent<
-  "message_stop",
-  {
-    stopReason: StopReason;
-  }
-> {}
-
-export interface TextDeltaEvent extends StreamEvent<
-  "text_delta",
-  {
-    text: string;
-  }
-> {}
-
-export interface ToolUseStartEvent extends StreamEvent<
-  "tool_use_start",
-  {
-    toolCallId: string;
-    toolName: string;
-  }
-> {}
-
-export interface InputJsonDeltaEvent extends StreamEvent<
-  "input_json_delta",
-  {
-    partialJson: string;
-  }
-> {}
-
-export interface ToolUseStopEvent extends StreamEvent<
-  "tool_use_stop",
-  {
-    toolCallId: string;
-    toolName: string;
-    input: Record<string, unknown>;
-  }
-> {}
-
-export interface ToolResultEvent extends StreamEvent<
-  "tool_result",
-  {
-    toolCallId: string;
-    result: unknown;
-    isError?: boolean;
-  }
-> {}
-
-export interface ErrorEvent extends StreamEvent<
-  "error",
-  {
-    message: string;
-    errorCode?: string;
-  }
-> {}
-
-export interface MessageDeltaEvent extends StreamEvent<
-  "message_delta",
-  {
-    usage?: {
-      inputTokens: number;
-      outputTokens: number;
-    };
-  }
-> {}
-
-export interface InterruptedEvent extends StreamEvent<
-  "interrupted",
-  {
-    reason: "user" | "timeout" | "error";
-  }
-> {}
+export interface MessageStartEvent
+  extends StreamEvent<
+    "message_start",
+    {
+      messageId: string;
+      model: string;
+    }
+  > {}
+
+export interface MessageStopEvent
+  extends StreamEvent<
+    "message_stop",
+    {
+      stopReason: StopReason;
+    }
+  > {}
+
+export interface TextDeltaEvent
+  extends StreamEvent<
+    "text_delta",
+    {
+      text: string;
+    }
+  > {}
+
+export interface ToolUseStartEvent
+  extends StreamEvent<
+    "tool_use_start",
+    {
+      toolCallId: string;
+      toolName: string;
+    }
+  > {}
+
+export interface InputJsonDeltaEvent
+  extends StreamEvent<
+    "input_json_delta",
+    {
+      partialJson: string;
+    }
+  > {}
+
+export interface ToolUseStopEvent
+  extends StreamEvent<
+    "tool_use_stop",
+    {
+      toolCallId: string;
+      toolName: string;
+      input: Record<string, unknown>;
+    }
+  > {}
+
+export interface ToolResultEvent
+  extends StreamEvent<
+    "tool_result",
+    {
+      toolCallId: string;
+      result: unknown;
+      isError?: boolean;
+    }
+  > {}
+
+export interface ErrorEvent
+  extends StreamEvent<
+    "error",
+    {
+      message: string;
+      errorCode?: string;
+    }
+  > {}
+
+export interface MessageDeltaEvent
+  extends StreamEvent<
+    "message_delta",
+    {
+      usage?: {
+        inputTokens: number;
+        outputTokens: number;
+      };
+    }
+  > {}
+
+export interface InterruptedEvent
+  extends StreamEvent<
+    "interrupted",
+    {
+      reason: "user" | "timeout" | "error";
+    }
+  > {}
 
 /**
  * DriverStreamEvent - Union of all stream events from Driver

package/src/event/EventBus.ts

@@ -5,22 +5,22 @@
  * Uses RxJS Subject for reactive event distribution.
  */
 
+import { createLogger } from "commonxjs/logger";
+import { Subject } from "rxjs";
 import type {
-  EventBus,
-  EventProducer,
-  EventConsumer,
-  Unsubscribe,
-  BusEventHandler,
-  SubscribeOptions,
   BusEvent,
+  BusEventHandler,
   CommandEventMap,
+  CommandRequestResponseMap,
   CommandRequestType,
-  ResponseEventFor,
+  EventBus,
+  EventConsumer,
+  EventProducer,
   RequestDataFor,
-  CommandRequestResponseMap,
+  ResponseEventFor,
+  SubscribeOptions,
+  Unsubscribe,
 } from "./types";
-import { Subject } from "rxjs";
-import { createLogger } from "commonxjs/logger";
 
 const logger = createLogger("event/EventBus");
 

package/src/event/__tests__/EventBus.test.ts

@@ -2,7 +2,7 @@
  * EventBus.test.ts - Unit tests for EventBus implementation
  */
 
-import { describe, it, expect, beforeEach } from "bun:test";
+import { beforeEach, describe, expect, it } from "bun:test";
 import { EventBusImpl as EventBus } from "../EventBus";
 import type { BusEvent } from "../types";
 

package/src/event/index.ts

@@ -39,8 +39,7 @@
  * ```
  */
 
-// Type definitions from types directory
-export * from "./types";
-
 // Implementation
 export { EventBusImpl } from "./EventBus";
+// Type definitions from types directory
+export * from "./types";