@agentxjs/core 2.0.0 → 3.0.0

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

@@ -4,13 +4,13 @@
  * Tests the stateless event transformer: Stream Events -> State Events
  */
 
-import { describe, it, expect, beforeEach } from "bun:test";
+import { beforeEach, describe, expect, it } from "bun:test";
 import {
-  stateEventProcessor,
   createInitialStateEventProcessorContext,
   type StateEventProcessorContext,
   type StateEventProcessorInput,
   type StateEventProcessorOutput,
+  stateEventProcessor,
 } from "../../../engine/internal/stateEventProcessor";
 
 // Helper to create test events
@@ -67,7 +67,7 @@ describe("stateEventProcessor", () => {
     it("should emit conversation_end for end_turn stop reason", () => {
       const event = createStreamEvent("message_stop", { stopReason: "end_turn" });
 
-      const [newContext, outputs] = stateEventProcessor(context, event);
+      const [_newContext, outputs] = stateEventProcessor(context, event);
 
       expect(outputs).toHaveLength(1);
       expect(outputs[0].type).toBe("conversation_end");
@@ -106,7 +106,7 @@ describe("stateEventProcessor", () => {
     it("should emit conversation_responding event", () => {
       const event = createStreamEvent("text_delta", { text: "Hello" });
 
-      const [newContext, outputs] = stateEventProcessor(context, event);
+      const [_newContext, outputs] = stateEventProcessor(context, event);
 
       expect(outputs).toHaveLength(1);
       expect(outputs[0].type).toBe("conversation_responding");
@@ -122,7 +122,7 @@ describe("stateEventProcessor", () => {
         toolName: "search",
       });
 
-      const [newContext, outputs] = stateEventProcessor(context, event);
+      const [_newContext, outputs] = stateEventProcessor(context, event);
 
       expect(outputs).toHaveLength(2);
 
@@ -157,7 +157,7 @@ describe("stateEventProcessor", () => {
         errorCode: "rate_limit",
       });
 
-      const [newContext, outputs] = stateEventProcessor(context, event);
+      const [_newContext, outputs] = stateEventProcessor(context, event);
 
       expect(outputs).toHaveLength(1);
       expect(outputs[0].type).toBe("error_occurred");

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

@@ -7,13 +7,13 @@
  * - message_stop  → turn_response
  */
 
-import { describe, it, expect, beforeEach } from "bun:test";
+import { beforeEach, describe, expect, it } from "bun:test";
 import {
-  turnTrackerProcessor,
   createInitialTurnTrackerState,
-  type TurnTrackerState,
   type TurnTrackerInput,
   type TurnTrackerOutput,
+  type TurnTrackerState,
+  turnTrackerProcessor,
 } from "../../../engine/internal/turnTrackerProcessor";
 
 // Helper to create test events
@@ -77,7 +77,7 @@ describe("turnTrackerProcessor", () => {
       const [state2] = turnTrackerProcessor(state1, createMessageStopEvent("end_turn"));
 
       // Start new turn
-      const [state3, outputs3] = turnTrackerProcessor(state2, createMessageStartEvent("msg_2"));
+      const [_state3, outputs3] = turnTrackerProcessor(state2, createMessageStartEvent("msg_2"));
 
       expect(outputs1[0].data.turnId).not.toBe(outputs3[0].data.turnId);
     });

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

@@ -2,11 +2,11 @@
  * Mealy.test.ts - Unit tests for Mealy Machine runtime
  */
 
-import { describe, it, expect, beforeEach, mock } from "bun:test";
-import { Mealy, createMealy, type MealyConfig } from "../../../engine/mealy/Mealy";
-import { MemoryStore } from "../../../engine/mealy/Store";
+import { beforeEach, describe, expect, it } from "bun:test";
+import { createMealy, Mealy, type MealyConfig } from "../../../engine/mealy/Mealy";
 import type { Processor } from "../../../engine/mealy/Processor";
 import type { Sink, SinkDefinition } from "../../../engine/mealy/Sink";
+import { MemoryStore } from "../../../engine/mealy/Store";
 
 // Test types
 interface TestState {

package/src/agent/__tests__/engine/mealy/Store.test.ts

@@ -2,7 +2,7 @@
  * Store.test.ts - Unit tests for MemoryStore
  */
 
-import { describe, it, expect, beforeEach } from "bun:test";
+import { beforeEach, describe, expect, it } from "bun:test";
 import { MemoryStore, type Store } from "../../../engine/mealy/Store";
 
 describe("MemoryStore", () => {

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

@@ -2,15 +2,15 @@
  * combinators.test.ts - Unit tests for Mealy processor combinators
  */
 
-import { describe, it, expect } from "bun:test";
+import { describe, expect, it } from "bun:test";
 import {
-  combineProcessors,
-  combineInitialStates,
   chainProcessors,
+  combineInitialStates,
+  combineProcessors,
   filterProcessor,
+  identityProcessor,
   mapOutput,
   withLogging,
-  identityProcessor,
 } from "../../../engine/mealy/combinators";
 import type { Processor } from "../../../engine/mealy/Processor";
 

package/src/agent/createAgent.ts

@@ -21,29 +21,29 @@
  * ```
  */
 
+import { createLogger } from "commonxjs/logger";
+import { isDriveableEvent } from "../event";
+import { AgentStateMachine } from "./AgentStateMachine";
+import { MealyMachine } from "./engine/MealyMachine";
 import type {
   AgentEngine,
-  AgentState,
+  AgentEventBus,
+  AgentInterceptor,
+  AgentMiddleware,
+  AgentOutput,
   AgentOutputCallback,
-  UserMessage,
-  MessageQueue,
-  StateChangeHandler,
+  AgentPresenter,
+  AgentSource,
+  AgentState,
+  CreateAgentOptions,
   EventHandlerMap,
+  MessageQueue,
   ReactHandlerMap,
-  AgentOutput,
-  CreateAgentOptions,
-  AgentSource,
-  AgentPresenter,
-  AgentEventBus,
+  StateChangeHandler,
   StreamEvent,
   Unsubscribe,
-  AgentMiddleware,
-  AgentInterceptor,
+  UserMessage,
 } from "./types";
-import { MealyMachine } from "./engine/MealyMachine";
-import { AgentStateMachine } from "./AgentStateMachine";
-import { createLogger } from "commonxjs/logger";
-import { isDriveableEvent } from "../event";
 
 const logger = createLogger("agent/AgentEngine");
 

package/src/agent/engine/AgentProcessor.ts

@@ -5,24 +5,24 @@
  * Composes MessageAssembler, StateMachine, and TurnTracker processors.
  */
 
-import { combineProcessors, combineInitialStates, type Processor } from "./mealy";
+import type { AgentOutput } from "../types";
 // Note: StreamEventType and MessageEventType are part of AgentOutput (from Presenter)
 // They flow through the system but AgentProcessor doesn't need to import them directly
 import {
-  messageAssemblerProcessor,
-  stateEventProcessor,
-  turnTrackerProcessor,
   createInitialMessageAssemblerState,
   createInitialStateEventProcessorContext,
   createInitialTurnTrackerState,
+  type MessageAssemblerOutput,
   type MessageAssemblerState,
+  messageAssemblerProcessor,
   type StateEventProcessorContext,
-  type TurnTrackerState,
-  type MessageAssemblerOutput,
   type StateEventProcessorOutput,
+  stateEventProcessor,
   type TurnTrackerOutput,
+  type TurnTrackerState,
+  turnTrackerProcessor,
 } from "./internal";
-import type { AgentOutput } from "../types";
+import { combineInitialStates, combineProcessors, type Processor } from "./mealy";
 
 /**
  * Combined state type for the full agent engine

package/src/agent/engine/MealyMachine.ts

@@ -45,14 +45,14 @@
  * ```
  */
 
+import { createLogger } from "commonxjs/logger";
+import type { AgentOutput, StreamEvent } from "../types";
 import {
+  type AgentEngineState,
   agentProcessor,
   createInitialAgentEngineState,
-  type AgentEngineState,
 } from "./AgentProcessor";
 import { MemoryStore } from "./mealy";
-import type { AgentOutput, StreamEvent } from "../types";
-import { createLogger } from "commonxjs/logger";
 
 const logger = createLogger("engine/MealyMachine");
 

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

@@ -6,30 +6,30 @@
  */
 
 export {
-  messageAssemblerProcessor,
-  messageAssemblerProcessorDef,
+  createInitialMessageAssemblerState,
   type MessageAssemblerInput,
   type MessageAssemblerOutput,
   type MessageAssemblerState,
+  messageAssemblerProcessor,
+  messageAssemblerProcessorDef,
   type PendingContent,
-  createInitialMessageAssemblerState,
 } from "./messageAssemblerProcessor";
 
 export {
-  stateEventProcessor,
-  stateEventProcessorDef,
+  createInitialStateEventProcessorContext,
+  type StateEventProcessorContext,
   type StateEventProcessorInput,
   type StateEventProcessorOutput,
-  type StateEventProcessorContext,
-  createInitialStateEventProcessorContext,
+  stateEventProcessor,
+  stateEventProcessorDef,
 } from "./stateEventProcessor";
 
 export {
-  turnTrackerProcessor,
-  turnTrackerProcessorDef,
+  createInitialTurnTrackerState,
+  type PendingTurn,
   type TurnTrackerInput,
   type TurnTrackerOutput,
   type TurnTrackerState,
-  type PendingTurn,
-  createInitialTurnTrackerState,
+  turnTrackerProcessor,
+  turnTrackerProcessorDef,
 } from "./turnTrackerProcessor";

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

@@ -18,29 +18,29 @@
  * - tool_result_message (Message - tool execution result)
  */
 
-import type { Processor, ProcessorDefinition } from "../mealy";
 import type {
-  // Input: StreamEvent (from agent layer)
-  StreamEvent,
-  MessageStartEvent,
-  TextDeltaEvent,
-  ToolUseStartEvent,
-  InputJsonDeltaEvent,
-  ToolResultEvent,
-  MessageStopEvent,
-  // Output: Message events
-  AssistantMessageEvent,
-  ToolResultMessageEvent,
-  ErrorMessageEvent,
   // Message types
   AssistantMessage,
-  ToolResultMessage,
+  // Output: Message events
+  AssistantMessageEvent,
   ErrorMessage,
+  ErrorMessageEvent,
+  InputJsonDeltaEvent,
+  MessageStartEvent,
+  MessageStopEvent,
+  // Input: StreamEvent (from agent layer)
+  StreamEvent,
+  TextDeltaEvent,
   // Content parts
   TextPart,
   ToolCallPart,
+  ToolResultEvent,
+  ToolResultMessage,
+  ToolResultMessageEvent,
   ToolResultPart,
+  ToolUseStartEvent,
 } from "../../types";
+import type { Processor, ProcessorDefinition } from "../mealy";
 
 // ===== State Types =====
 

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";