@agentxjs/runtime 0.1.1 → 0.1.4

package/dist/index.js

@@ -1,6 +1,176 @@
 // src/internal/SystemBusImpl.ts
 import { Subject } from "rxjs";
-import { createLogger } from "@agentxjs/common";
+
+// ../common/dist/index.js
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var _ConsoleLogger = class _ConsoleLogger2 {
+  constructor(name, options = {}) {
+    __publicField(this, "name");
+    __publicField(this, "level");
+    __publicField(this, "colors");
+    __publicField(this, "timestamps");
+    this.name = name;
+    this.level = options.level ?? "info";
+    this.colors = options.colors ?? this.isNodeEnvironment();
+    this.timestamps = options.timestamps ?? true;
+  }
+  debug(message, context) {
+    if (this.isDebugEnabled()) {
+      this.log("DEBUG", message, context);
+    }
+  }
+  info(message, context) {
+    if (this.isInfoEnabled()) {
+      this.log("INFO", message, context);
+    }
+  }
+  warn(message, context) {
+    if (this.isWarnEnabled()) {
+      this.log("WARN", message, context);
+    }
+  }
+  error(message, context) {
+    if (this.isErrorEnabled()) {
+      if (message instanceof Error) {
+        this.log("ERROR", message.message, { ...context, stack: message.stack });
+      } else {
+        this.log("ERROR", message, context);
+      }
+    }
+  }
+  isDebugEnabled() {
+    return this.getLevelValue(this.level) <= this.getLevelValue("debug");
+  }
+  isInfoEnabled() {
+    return this.getLevelValue(this.level) <= this.getLevelValue("info");
+  }
+  isWarnEnabled() {
+    return this.getLevelValue(this.level) <= this.getLevelValue("warn");
+  }
+  isErrorEnabled() {
+    return this.getLevelValue(this.level) <= this.getLevelValue("error");
+  }
+  getLevelValue(level) {
+    const levels = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3,
+      silent: 4
+    };
+    return levels[level];
+  }
+  log(level, message, context) {
+    const parts = [];
+    if (this.timestamps) {
+      parts.push((/* @__PURE__ */ new Date()).toISOString());
+    }
+    if (this.colors) {
+      const color = _ConsoleLogger2.COLORS[level];
+      parts.push(`${color}${level.padEnd(5)}${_ConsoleLogger2.COLORS.RESET}`);
+    } else {
+      parts.push(level.padEnd(5));
+    }
+    parts.push(`[${this.name}]`);
+    parts.push(message);
+    const logLine = parts.join(" ");
+    const consoleMethod = this.getConsoleMethod(level);
+    if (context && Object.keys(context).length > 0) {
+      consoleMethod(logLine, context);
+    } else {
+      consoleMethod(logLine);
+    }
+  }
+  getConsoleMethod(level) {
+    switch (level) {
+      case "DEBUG":
+        return console.debug.bind(console);
+      case "INFO":
+        return console.info.bind(console);
+      case "WARN":
+        return console.warn.bind(console);
+      case "ERROR":
+        return console.error.bind(console);
+      default:
+        return console.log.bind(console);
+    }
+  }
+  isNodeEnvironment() {
+    return typeof process !== "undefined" && process.versions?.node !== void 0;
+  }
+};
+__publicField(_ConsoleLogger, "COLORS", {
+  DEBUG: "\x1B[36m",
+  INFO: "\x1B[32m",
+  WARN: "\x1B[33m",
+  ERROR: "\x1B[31m",
+  RESET: "\x1B[0m"
+});
+var ConsoleLogger = _ConsoleLogger;
+var externalFactory = null;
+var LoggerFactoryImpl = class {
+  static getLogger(nameOrClass) {
+    const name = typeof nameOrClass === "string" ? nameOrClass : nameOrClass.name;
+    if (this.loggers.has(name)) {
+      return this.loggers.get(name);
+    }
+    const lazyLogger = this.createLazyLogger(name);
+    this.loggers.set(name, lazyLogger);
+    return lazyLogger;
+  }
+  static configure(config) {
+    this.config = { ...this.config, ...config };
+  }
+  static reset() {
+    this.loggers.clear();
+    this.config = { defaultLevel: "info" };
+    externalFactory = null;
+  }
+  static createLazyLogger(name) {
+    let realLogger = null;
+    const getRealLogger = () => {
+      if (!realLogger) {
+        realLogger = this.createLogger(name);
+      }
+      return realLogger;
+    };
+    return {
+      name,
+      level: this.config.defaultLevel || "info",
+      debug: (message, context) => getRealLogger().debug(message, context),
+      info: (message, context) => getRealLogger().info(message, context),
+      warn: (message, context) => getRealLogger().warn(message, context),
+      error: (message, context) => getRealLogger().error(message, context),
+      isDebugEnabled: () => getRealLogger().isDebugEnabled(),
+      isInfoEnabled: () => getRealLogger().isInfoEnabled(),
+      isWarnEnabled: () => getRealLogger().isWarnEnabled(),
+      isErrorEnabled: () => getRealLogger().isErrorEnabled()
+    };
+  }
+  static createLogger(name) {
+    if (externalFactory) {
+      return externalFactory.getLogger(name);
+    }
+    if (this.config.defaultImplementation) {
+      return this.config.defaultImplementation(name);
+    }
+    return new ConsoleLogger(name, {
+      level: this.config.defaultLevel,
+      ...this.config.consoleOptions
+    });
+  }
+};
+__publicField(LoggerFactoryImpl, "loggers", /* @__PURE__ */ new Map());
+__publicField(LoggerFactoryImpl, "config", {
+  defaultLevel: "info"
+});
+function createLogger(name) {
+  return LoggerFactoryImpl.getLogger(name);
+}
+
+// src/internal/SystemBusImpl.ts
 var logger = createLogger("runtime/SystemBusImpl");
 var SystemBusImpl = class {
   subject = new Subject();
@@ -159,8 +329,7 @@ var SystemBusImpl = class {
 };
 
 // src/internal/BusDriver.ts
-import { createLogger as createLogger2 } from "@agentxjs/common";
-var logger2 = createLogger2("runtime/BusDriver");
+var logger2 = createLogger("runtime/BusDriver");
 var BusDriver = class {
   name = "BusDriver";
   description = "Driver that listens to SystemBus for DriveableEvents";
@@ -345,8 +514,7 @@ var BusDriver = class {
 };
 
 // src/internal/AgentInteractor.ts
-import { createLogger as createLogger3 } from "@agentxjs/common";
-var logger3 = createLogger3("runtime/AgentInteractor");
+var logger3 = createLogger("runtime/AgentInteractor");
 var AgentInteractor = class {
   producer;
   session;
@@ -437,13 +605,1006 @@ var AgentInteractor = class {
   }
 };
 
-// src/internal/RuntimeAgent.ts
-import { createAgent } from "@agentxjs/agent";
-import { createLogger as createLogger6 } from "@agentxjs/common";
+// ../types/dist/agent.js
+function isStateEvent(event) {
+  const stateTypes = [
+    "conversation_queued",
+    "conversation_start",
+    "conversation_thinking",
+    "conversation_responding",
+    "conversation_end",
+    "conversation_interrupted",
+    "tool_planned",
+    "tool_executing",
+    "tool_completed",
+    "tool_failed",
+    "error_occurred"
+  ];
+  return stateTypes.includes(event.type);
+}
+
+// ../agent/dist/index.js
+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();
+  }
+};
+createLogger("engine/Mealy");
+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 createInitialMessageAssemblerState() {
+  return {
+    currentMessageId: null,
+    messageStartTime: null,
+    pendingContents: {},
+    pendingToolCalls: {}
+  };
+}
+function generateId() {
+  return `msg_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+var messageAssemblerProcessor = (state, input) => {
+  switch (input.type) {
+    case "message_start":
+      return handleMessageStart(state, input);
+    case "text_delta":
+      return handleTextDelta(state, input);
+    case "tool_use_start":
+      return handleToolUseStart(state, input);
+    case "input_json_delta":
+      return handleInputJsonDelta(state, input);
+    case "tool_use_stop":
+      return handleToolUseStop(state);
+    case "tool_result":
+      return handleToolResult(state, input);
+    case "message_stop":
+      return handleMessageStop(state, input);
+    case "error_received":
+      return handleErrorReceived(state, input);
+    default:
+      return [state, []];
+  }
+};
+function handleMessageStart(state, event) {
+  const data = event.data;
+  return [
+    {
+      ...state,
+      currentMessageId: data.messageId,
+      messageStartTime: event.timestamp,
+      pendingContents: {}
+    },
+    []
+  ];
+}
+function handleTextDelta(state, event) {
+  const data = event.data;
+  const index = 0;
+  const existingContent = state.pendingContents[index];
+  const pendingContent = existingContent?.type === "text" ? {
+    ...existingContent,
+    textDeltas: [...existingContent.textDeltas || [], data.text]
+  } : {
+    type: "text",
+    index,
+    textDeltas: [data.text]
+  };
+  return [
+    {
+      ...state,
+      pendingContents: {
+        ...state.pendingContents,
+        [index]: pendingContent
+      }
+    },
+    []
+  ];
+}
+function handleToolUseStart(state, event) {
+  const data = event.data;
+  const index = 1;
+  const pendingContent = {
+    type: "tool_use",
+    index,
+    toolId: data.toolCallId,
+    toolName: data.toolName,
+    toolInputJson: ""
+  };
+  return [
+    {
+      ...state,
+      pendingContents: {
+        ...state.pendingContents,
+        [index]: pendingContent
+      }
+    },
+    []
+  ];
+}
+function handleInputJsonDelta(state, event) {
+  const data = event.data;
+  const index = 1;
+  const existingContent = state.pendingContents[index];
+  if (!existingContent || existingContent.type !== "tool_use") {
+    return [state, []];
+  }
+  const pendingContent = {
+    ...existingContent,
+    toolInputJson: (existingContent.toolInputJson || "") + data.partialJson
+  };
+  return [
+    {
+      ...state,
+      pendingContents: {
+        ...state.pendingContents,
+        [index]: pendingContent
+      }
+    },
+    []
+  ];
+}
+function handleToolUseStop(state, _event) {
+  const index = 1;
+  const pendingContent = state.pendingContents[index];
+  if (!pendingContent || pendingContent.type !== "tool_use") {
+    return [state, []];
+  }
+  const toolId = pendingContent.toolId || "";
+  const toolName = pendingContent.toolName || "";
+  let toolInput = {};
+  try {
+    toolInput = pendingContent.toolInputJson ? JSON.parse(pendingContent.toolInputJson) : {};
+  } catch {
+    toolInput = {};
+  }
+  const toolCall = {
+    type: "tool-call",
+    id: toolId,
+    name: toolName,
+    input: toolInput
+  };
+  const toolCallMessageEvent = {
+    type: "tool_call_message",
+    timestamp: Date.now(),
+    data: {
+      messageId: generateId(),
+      toolCalls: [toolCall],
+      timestamp: Date.now()
+    }
+  };
+  const { [index]: _, ...remainingContents } = state.pendingContents;
+  return [
+    {
+      ...state,
+      pendingContents: remainingContents,
+      pendingToolCalls: {
+        ...state.pendingToolCalls,
+        [toolId]: { id: toolId, name: toolName }
+      }
+    },
+    [toolCallMessageEvent]
+  ];
+}
+function handleToolResult(state, event) {
+  const data = event.data;
+  const { toolCallId, result, isError } = data;
+  const pendingToolCall = state.pendingToolCalls[toolCallId];
+  const toolName = pendingToolCall?.name || "unknown";
+  const toolResult = {
+    type: "tool-result",
+    id: toolCallId,
+    name: toolName,
+    output: {
+      type: isError ? "error-text" : "text",
+      value: typeof result === "string" ? result : JSON.stringify(result)
+    }
+  };
+  const toolResultMessageEvent = {
+    type: "tool_result_message",
+    timestamp: Date.now(),
+    data: {
+      messageId: generateId(),
+      results: [toolResult],
+      timestamp: Date.now()
+    }
+  };
+  const { [toolCallId]: _, ...remainingToolCalls } = state.pendingToolCalls;
+  return [
+    {
+      ...state,
+      pendingToolCalls: remainingToolCalls
+    },
+    [toolResultMessageEvent]
+  ];
+}
+function handleMessageStop(state, event) {
+  const data = event.data;
+  if (!state.currentMessageId) {
+    return [state, []];
+  }
+  const textParts = [];
+  const sortedContents = Object.values(state.pendingContents).sort((a, b) => a.index - b.index);
+  for (const pending of sortedContents) {
+    if (pending.type === "text" && pending.textDeltas) {
+      textParts.push(pending.textDeltas.join(""));
+    }
+  }
+  const textContent = textParts.join("");
+  const stopReason = data.stopReason;
+  if (!textContent || textContent.trim().length === 0) {
+    const shouldPreserveToolCalls2 = stopReason === "tool_use";
+    return [
+      {
+        ...createInitialMessageAssemblerState(),
+        pendingToolCalls: shouldPreserveToolCalls2 ? state.pendingToolCalls : {}
+      },
+      []
+    ];
+  }
+  const contentParts = [
+    {
+      type: "text",
+      text: textContent
+    }
+  ];
+  const assistantEvent = {
+    type: "assistant_message",
+    timestamp: Date.now(),
+    data: {
+      messageId: state.currentMessageId,
+      content: contentParts,
+      stopReason,
+      timestamp: state.messageStartTime || Date.now()
+    }
+  };
+  const shouldPreserveToolCalls = stopReason === "tool_use";
+  return [
+    {
+      ...createInitialMessageAssemblerState(),
+      pendingToolCalls: shouldPreserveToolCalls ? state.pendingToolCalls : {}
+    },
+    [assistantEvent]
+  ];
+}
+function handleErrorReceived(_state, event) {
+  const data = event.data;
+  const errorMessageEvent = {
+    type: "error_message",
+    timestamp: Date.now(),
+    data: {
+      messageId: generateId(),
+      content: data.message,
+      errorCode: data.errorCode,
+      timestamp: Date.now()
+    }
+  };
+  return [createInitialMessageAssemblerState(), [errorMessageEvent]];
+}
+var logger22 = createLogger("engine/stateEventProcessor");
+function createInitialStateEventProcessorContext() {
+  return {};
+}
+var stateEventProcessor = (context, input) => {
+  logger22.debug(`[Stream Event] ${input.type}`, {
+    context,
+    eventData: "data" in input ? input.data : void 0
+  });
+  switch (input.type) {
+    case "message_start":
+      return handleMessageStart2(context, input);
+    case "message_delta":
+      return handleMessageDelta(context);
+    case "message_stop":
+      return handleMessageStop2(context, input);
+    case "text_delta":
+      return handleTextDelta2(context);
+    case "tool_use_start":
+      return handleToolUseStart2(context, input);
+    case "tool_use_stop":
+      return handleToolUseStop2(context);
+    case "error_received":
+      return handleErrorReceived2(context, input);
+    default:
+      logger22.debug(`[Stream Event] ${input.type} (unhandled)`);
+      return [context, []];
+  }
+};
+function handleMessageStart2(context, event) {
+  const data = event.data;
+  const conversationStartEvent = {
+    type: "conversation_start",
+    timestamp: Date.now(),
+    data: {
+      messageId: data.messageId
+    }
+  };
+  return [context, [conversationStartEvent]];
+}
+function handleMessageDelta(context) {
+  return [context, []];
+}
+function handleMessageStop2(context, event) {
+  const data = event.data;
+  const stopReason = data.stopReason;
+  logger22.debug("message_stop received", { stopReason });
+  if (stopReason === "tool_use") {
+    logger22.debug("Skipping conversation_end (tool_use in progress)");
+    return [context, []];
+  }
+  const conversationEndEvent = {
+    type: "conversation_end",
+    timestamp: Date.now(),
+    data: {
+      reason: "completed"
+    }
+  };
+  return [context, [conversationEndEvent]];
+}
+function handleTextDelta2(context) {
+  const respondingEvent = {
+    type: "conversation_responding",
+    timestamp: Date.now(),
+    data: {}
+  };
+  return [context, [respondingEvent]];
+}
+function handleToolUseStart2(context, event) {
+  const data = event.data;
+  const outputs = [];
+  const toolPlannedEvent = {
+    type: "tool_planned",
+    timestamp: Date.now(),
+    data: {
+      toolId: data.toolCallId,
+      toolName: data.toolName
+    }
+  };
+  outputs.push(toolPlannedEvent);
+  const toolExecutingEvent = {
+    type: "tool_executing",
+    timestamp: Date.now(),
+    data: {
+      toolId: data.toolCallId,
+      toolName: data.toolName,
+      input: {}
+    }
+  };
+  outputs.push(toolExecutingEvent);
+  return [context, outputs];
+}
+function handleToolUseStop2(context) {
+  return [context, []];
+}
+function handleErrorReceived2(context, event) {
+  const data = event.data;
+  const errorOccurredEvent = {
+    type: "error_occurred",
+    timestamp: Date.now(),
+    data: {
+      code: data.errorCode || "unknown_error",
+      message: data.message,
+      recoverable: true
+    }
+  };
+  return [context, [errorOccurredEvent]];
+}
+function createInitialTurnTrackerState() {
+  return {
+    pendingTurn: null,
+    costPerInputToken: 3e-6,
+    // $3 per 1M tokens
+    costPerOutputToken: 15e-6
+    // $15 per 1M tokens
+  };
+}
+function generateId2() {
+  return `turn_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+var turnTrackerProcessor = (state, input) => {
+  switch (input.type) {
+    case "user_message":
+      return handleUserMessage(state, input);
+    case "message_stop":
+      return handleMessageStop3(state, input);
+    case "assistant_message":
+      return [state, []];
+    default:
+      return [state, []];
+  }
+};
+function handleUserMessage(state, event) {
+  const data = event.data;
+  const turnId = generateId2();
+  const pendingTurn = {
+    turnId,
+    messageId: data.messageId,
+    content: data.content,
+    requestedAt: event.timestamp
+  };
+  const turnRequestEvent = {
+    type: "turn_request",
+    timestamp: Date.now(),
+    data: {
+      turnId,
+      messageId: data.messageId,
+      content: data.content,
+      timestamp: event.timestamp
+    }
+  };
+  return [
+    {
+      ...state,
+      pendingTurn
+    },
+    [turnRequestEvent]
+  ];
+}
+function handleMessageStop3(state, event) {
+  if (!state.pendingTurn) {
+    return [state, []];
+  }
+  const data = event.data;
+  const stopReason = data.stopReason;
+  if (stopReason === "end_turn" || stopReason === "max_tokens" || stopReason === "stop_sequence") {
+    return completeTurn(state, event.timestamp);
+  }
+  return [state, []];
+}
+function completeTurn(state, completedAt) {
+  if (!state.pendingTurn) {
+    return [state, []];
+  }
+  const { turnId, messageId, requestedAt } = state.pendingTurn;
+  const duration = completedAt - requestedAt;
+  const usage = { inputTokens: 0, outputTokens: 0 };
+  const turnResponseEvent = {
+    type: "turn_response",
+    timestamp: Date.now(),
+    data: {
+      turnId,
+      messageId,
+      duration,
+      usage,
+      timestamp: completedAt
+    }
+  };
+  return [
+    {
+      ...state,
+      pendingTurn: null
+    },
+    [turnResponseEvent]
+  ];
+}
+var agentProcessor = combineProcessors({
+  messageAssembler: messageAssemblerProcessor,
+  stateEventProcessor,
+  turnTracker: turnTrackerProcessor
+});
+var createInitialAgentEngineState = combineInitialStates({
+  messageAssembler: createInitialMessageAssemblerState,
+  stateEventProcessor: createInitialStateEventProcessorContext,
+  turnTracker: createInitialTurnTrackerState
+});
+var logger32 = createLogger("engine/MealyMachine");
+var MealyMachine = class {
+  store;
+  constructor() {
+    this.store = new MemoryStore();
+    logger32.debug("MealyMachine initialized");
+  }
+  /**
+   * Process a single driveable event and return output events
+   *
+   * This is the core Mealy Machine operation:
+   * process(agentId, event) → outputs[]
+   *
+   * @param agentId - The agent identifier (for state isolation)
+   * @param event - StreamEvent to process
+   * @returns Array of output events (state, message, turn events)
+   */
+  process(agentId, event) {
+    const eventType = event.type || "unknown";
+    logger32.debug("Processing event", { agentId, eventType });
+    const isNewState = !this.store.has(agentId);
+    let state = this.store.get(agentId) ?? createInitialAgentEngineState();
+    if (isNewState) {
+      logger32.debug("Created initial state for agent", { agentId });
+    }
+    const allOutputs = [];
+    allOutputs.push(event);
+    const [newState, outputs] = agentProcessor(state, event);
+    state = newState;
+    for (const output of outputs) {
+      allOutputs.push(output);
+      const [chainedState, chainedOutputs] = this.processChained(state, output);
+      state = chainedState;
+      allOutputs.push(...chainedOutputs);
+    }
+    this.store.set(agentId, state);
+    if (outputs.length > 0) {
+      logger32.debug("Produced outputs", {
+        agentId,
+        inputEvent: eventType,
+        outputCount: allOutputs.length,
+        processorOutputs: outputs.length
+      });
+    }
+    return allOutputs;
+  }
+  /**
+   * Process chained events recursively
+   *
+   * Some processors produce events that trigger other processors:
+   * - MessageAssembler produces MessageEvents
+   * - TurnTracker consumes MessageEvents to produce TurnEvents
+   */
+  processChained(state, event) {
+    const [newState, outputs] = agentProcessor(state, event);
+    if (outputs.length === 0) {
+      return [newState, []];
+    }
+    const allOutputs = [...outputs];
+    let currentState = newState;
+    for (const output of outputs) {
+      const [chainedState, chainedOutputs] = this.processChained(currentState, output);
+      currentState = chainedState;
+      allOutputs.push(...chainedOutputs);
+    }
+    return [currentState, allOutputs];
+  }
+  /**
+   * Clear state for an agent
+   *
+   * Call this when an agent is destroyed to free memory.
+   */
+  clearState(agentId) {
+    logger32.debug("Clearing state", { agentId });
+    this.store.delete(agentId);
+  }
+  /**
+   * Check if state exists for an agent
+   */
+  hasState(agentId) {
+    return this.store.has(agentId);
+  }
+};
+var logger4 = createLogger("agent/AgentStateMachine");
+var AgentStateMachine = class {
+  _state = "idle";
+  handlers = /* @__PURE__ */ new Set();
+  /**
+   * Current agent state
+   */
+  get state() {
+    return this._state;
+  }
+  /**
+   * Process an event and update internal state if it's a StateEvent
+   *
+   * @param event - Event from MealyMachine (could be any AgentOutput)
+   */
+  process(event) {
+    if (!isStateEvent(event)) {
+      return;
+    }
+    const prev = this._state;
+    const next = this.mapEventToState(event);
+    if (next !== null && prev !== next) {
+      this._state = next;
+      logger4.debug("State transition", {
+        eventType: event.type,
+        from: prev,
+        to: next
+      });
+      this.notifyHandlers({ prev, current: next });
+    }
+  }
+  /**
+   * Subscribe to state changes
+   *
+   * @param handler - Callback receiving { prev, current } state change
+   * @returns Unsubscribe function
+   */
+  onStateChange(handler) {
+    this.handlers.add(handler);
+    return () => {
+      this.handlers.delete(handler);
+    };
+  }
+  /**
+   * Reset state machine (used on destroy)
+   */
+  reset() {
+    const prev = this._state;
+    this._state = "idle";
+    if (prev !== "idle") {
+      this.notifyHandlers({ prev, current: "idle" });
+    }
+    this.handlers.clear();
+  }
+  /**
+   * Map StateEvent type to AgentState
+   *
+   * @param event - StateEvent from MealyMachine
+   * @returns New AgentState or null if no transition needed
+   */
+  mapEventToState(event) {
+    switch (event.type) {
+      // Conversation lifecycle
+      case "conversation_start":
+        return "thinking";
+      case "conversation_thinking":
+        return "thinking";
+      case "conversation_responding":
+        return "responding";
+      case "conversation_end":
+        return "idle";
+      case "conversation_interrupted":
+        return "idle";
+      // Tool lifecycle
+      case "tool_planned":
+        return "planning_tool";
+      case "tool_executing":
+        return "awaiting_tool_result";
+      case "tool_completed":
+        return "responding";
+      case "tool_failed":
+        return "responding";
+      // Error
+      case "error_occurred":
+        return "error";
+      default:
+        return null;
+    }
+  }
+  /**
+   * Notify all registered handlers of state change
+   */
+  notifyHandlers(change) {
+    for (const handler of this.handlers) {
+      try {
+        handler(change);
+      } catch (error) {
+        logger4.error("State change handler error", {
+          from: change.prev,
+          to: change.current,
+          error
+        });
+      }
+    }
+  }
+};
+var logger5 = createLogger("agent/SimpleAgent");
+function generateAgentId() {
+  return `agent_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+var SimpleMessageQueue = class {
+  queue = [];
+  get length() {
+    return this.queue.length;
+  }
+  get isEmpty() {
+    return this.queue.length === 0;
+  }
+  enqueue(message) {
+    this.queue.push(message);
+  }
+  dequeue() {
+    return this.queue.shift();
+  }
+  clear() {
+    this.queue = [];
+  }
+};
+var SimpleAgent = class {
+  agentId;
+  createdAt;
+  messageQueue;
+  _messageQueue = new SimpleMessageQueue();
+  driver;
+  presenter;
+  machine;
+  stateMachine;
+  handlers = /* @__PURE__ */ new Set();
+  typeHandlers = /* @__PURE__ */ new Map();
+  readyHandlers = /* @__PURE__ */ new Set();
+  destroyHandlers = /* @__PURE__ */ new Set();
+  middlewares = [];
+  interceptors = [];
+  isProcessing = false;
+  constructor(options) {
+    this.agentId = generateAgentId();
+    this.createdAt = Date.now();
+    this.messageQueue = this._messageQueue;
+    this.driver = options.driver;
+    this.presenter = options.presenter;
+    this.machine = new MealyMachine();
+    this.stateMachine = new AgentStateMachine();
+  }
+  get state() {
+    return this.stateMachine.state;
+  }
+  async receive(message) {
+    console.log(
+      "[SimpleAgent.receive] CALLED with message:",
+      typeof message === "string" ? message : message.content
+    );
+    const userMessage = typeof message === "string" ? {
+      id: `msg_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
+      role: "user",
+      subtype: "user",
+      content: message,
+      timestamp: Date.now()
+    } : message;
+    this._messageQueue.enqueue(userMessage);
+    console.log("[SimpleAgent.receive] Message queued, isProcessing:", this.isProcessing);
+    if (this.isProcessing) {
+      return new Promise((resolve, reject) => {
+        userMessage._resolve = resolve;
+        userMessage._reject = reject;
+      });
+    }
+    console.log("[SimpleAgent.receive] Starting processQueue");
+    await this.processQueue();
+  }
+  async processQueue() {
+    if (this.isProcessing) return;
+    this.isProcessing = true;
+    console.log("[SimpleAgent.processQueue] Starting, queue size:", this._messageQueue.length);
+    while (!this._messageQueue.isEmpty) {
+      const message = this._messageQueue.dequeue();
+      if (!message) break;
+      console.log("[SimpleAgent.processQueue] Processing message:", message.id);
+      try {
+        await this.processMessage(message);
+        if (message._resolve) {
+          message._resolve();
+        }
+      } catch (error) {
+        if (message._reject) {
+          message._reject(error);
+        }
+        throw error;
+      }
+    }
+    this.isProcessing = false;
+    console.log("[SimpleAgent.processQueue] Finished");
+  }
+  async processMessage(message) {
+    console.log("[SimpleAgent.processMessage] START, message:", message.id);
+    let processedMessage = message;
+    for (const middleware of this.middlewares) {
+      let nextCalled = false;
+      await middleware(processedMessage, async (msg) => {
+        nextCalled = true;
+        processedMessage = msg;
+      });
+      if (!nextCalled) {
+        console.log("[SimpleAgent.processMessage] Middleware blocked message");
+        return;
+      }
+    }
+    console.log("[SimpleAgent.processMessage] Getting driver stream...");
+    const driverStream = this.driver.receive(processedMessage);
+    console.log("[SimpleAgent.processMessage] Driver stream:", driverStream);
+    try {
+      console.log("[SimpleAgent.processMessage] Starting for-await loop...");
+      for await (const streamEvent of driverStream) {
+        this.handleStreamEvent(streamEvent);
+      }
+      console.log("[SimpleAgent.processMessage] For-await loop completed");
+    } catch (error) {
+      console.log("[SimpleAgent.processMessage] ERROR:", error);
+      throw error;
+    }
+    console.log("[SimpleAgent.processMessage] END");
+  }
+  /**
+   * Handle a stream event from the driver (push-based API)
+   *
+   * This method processes a single StreamEvent through the MealyMachine
+   * and emits all resulting outputs to presenter and handlers.
+   */
+  handleStreamEvent(event) {
+    logger5.info("handleStreamEvent", { type: event.type });
+    const outputs = this.machine.process(this.agentId, event);
+    logger5.info("MealyMachine outputs", {
+      count: outputs.length,
+      types: outputs.map((o) => o.type)
+    });
+    for (const output of outputs) {
+      this.stateMachine.process(output);
+      this.emitOutput(output);
+    }
+  }
+  emitOutput(output) {
+    let currentOutput = output;
+    const runInterceptor = (index, out) => {
+      if (index >= this.interceptors.length) {
+        currentOutput = out;
+        return;
+      }
+      this.interceptors[index](out, (nextOut) => {
+        runInterceptor(index + 1, nextOut);
+      });
+    };
+    runInterceptor(0, output);
+    if (!currentOutput) return;
+    this.presenter.present(this.agentId, currentOutput);
+    for (const handler of this.handlers) {
+      try {
+        handler(currentOutput);
+      } catch (e) {
+        console.error("Event handler error:", e);
+      }
+    }
+    const typeSet = this.typeHandlers.get(currentOutput.type);
+    if (typeSet) {
+      for (const handler of typeSet) {
+        try {
+          handler(currentOutput);
+        } catch (e) {
+          console.error("Event handler error:", e);
+        }
+      }
+    }
+  }
+  on(typeOrHandler, handler) {
+    if (typeof typeOrHandler === "function") {
+      this.handlers.add(typeOrHandler);
+      return () => this.handlers.delete(typeOrHandler);
+    }
+    if (typeof typeOrHandler === "object" && !Array.isArray(typeOrHandler)) {
+      const unsubscribes = [];
+      for (const [type, h2] of Object.entries(typeOrHandler)) {
+        if (h2) {
+          unsubscribes.push(this.on(type, h2));
+        }
+      }
+      return () => unsubscribes.forEach((u) => u());
+    }
+    const types = Array.isArray(typeOrHandler) ? typeOrHandler : [typeOrHandler];
+    const h = handler;
+    for (const type of types) {
+      if (!this.typeHandlers.has(type)) {
+        this.typeHandlers.set(type, /* @__PURE__ */ new Set());
+      }
+      this.typeHandlers.get(type).add(h);
+    }
+    return () => {
+      for (const type of types) {
+        this.typeHandlers.get(type)?.delete(h);
+      }
+    };
+  }
+  onStateChange(handler) {
+    return this.stateMachine.onStateChange(handler);
+  }
+  react(handlers) {
+    const eventHandlerMap = {};
+    for (const [key, handler] of Object.entries(handlers)) {
+      if (handler && key.startsWith("on")) {
+        const eventType = key.slice(2).replace(/([A-Z])/g, "_$1").toLowerCase().slice(1);
+        eventHandlerMap[eventType] = handler;
+      }
+    }
+    return this.on(eventHandlerMap);
+  }
+  onReady(handler) {
+    try {
+      handler();
+    } catch (e) {
+      console.error("onReady handler error:", e);
+    }
+    this.readyHandlers.add(handler);
+    return () => this.readyHandlers.delete(handler);
+  }
+  onDestroy(handler) {
+    this.destroyHandlers.add(handler);
+    return () => this.destroyHandlers.delete(handler);
+  }
+  use(middleware) {
+    this.middlewares.push(middleware);
+    return () => {
+      const index = this.middlewares.indexOf(middleware);
+      if (index >= 0) {
+        this.middlewares.splice(index, 1);
+      }
+    };
+  }
+  intercept(interceptor) {
+    this.interceptors.push(interceptor);
+    return () => {
+      const index = this.interceptors.indexOf(interceptor);
+      if (index >= 0) {
+        this.interceptors.splice(index, 1);
+      }
+    };
+  }
+  interrupt() {
+    if (this.state === "idle") {
+      return;
+    }
+    this.driver.interrupt();
+  }
+  async destroy() {
+    if (this.state !== "idle") {
+      this.interrupt();
+    }
+    for (const handler of this.destroyHandlers) {
+      try {
+        handler();
+      } catch (e) {
+        console.error("onDestroy handler error:", e);
+      }
+    }
+    this.machine.clearState(this.agentId);
+    this.stateMachine.reset();
+    this._messageQueue.clear();
+    this.handlers.clear();
+    this.typeHandlers.clear();
+    this.readyHandlers.clear();
+    this.destroyHandlers.clear();
+    this.middlewares.length = 0;
+    this.interceptors.length = 0;
+  }
+};
+function createAgent(options) {
+  return new SimpleAgent(options);
+}
 
 // src/environment/ClaudeReceptor.ts
-import { createLogger as createLogger4 } from "@agentxjs/common";
-var logger4 = createLogger4("ecosystem/ClaudeReceptor");
+var logger6 = createLogger("ecosystem/ClaudeReceptor");
 var ClaudeReceptor = class {
   producer = null;
   currentMeta = null;
@@ -461,7 +1622,7 @@ var ClaudeReceptor = class {
    */
   connect(producer) {
     this.producer = producer;
-    logger4.debug("ClaudeReceptor connected to SystemBusProducer");
+    logger6.debug("ClaudeReceptor connected to SystemBusProducer");
   }
   /**
    * Feed SDK message to receptor with correlation metadata
@@ -579,7 +1740,7 @@ var ClaudeReceptor = class {
       case "content_block_start": {
         const contentBlock = event.content_block;
         this.blockContext.currentBlockIndex = event.index;
-        logger4.debug("content_block_start received", { contentBlock, index: event.index });
+        logger6.debug("content_block_start received", { contentBlock, index: event.index });
         if (contentBlock.type === "text") {
           this.blockContext.currentBlockType = "text";
           this.emitToBus({
@@ -716,7 +1877,6 @@ var ClaudeReceptor = class {
 // src/environment/ClaudeEffector.ts
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import { Subject as Subject2 } from "rxjs";
-import { createLogger as createLogger5 } from "@agentxjs/common";
 
 // src/environment/buildOptions.ts
 function buildOptions(context, abortController) {
@@ -835,7 +1995,7 @@ async function* observableToAsyncIterable(observable) {
 }
 
 // src/environment/ClaudeEffector.ts
-var logger5 = createLogger5("ecosystem/ClaudeEffector");
+var logger7 = createLogger("ecosystem/ClaudeEffector");
 var DEFAULT_TIMEOUT = 3e4;
 var ClaudeEffector = class {
   config;
@@ -854,12 +2014,12 @@ var ClaudeEffector = class {
    * Connect to SystemBus consumer to subscribe to events
    */
   connect(consumer) {
-    logger5.debug("ClaudeEffector connected to SystemBusConsumer", {
+    logger7.debug("ClaudeEffector connected to SystemBusConsumer", {
       agentId: this.config.agentId
     });
     consumer.on("user_message", async (event) => {
       const typedEvent = event;
-      logger5.debug("user_message event received", {
+      logger7.debug("user_message event received", {
         eventAgentId: typedEvent.context?.agentId,
         myAgentId: this.config.agentId,
         matches: typedEvent.context?.agentId === this.config.agentId
@@ -895,14 +2055,14 @@ var ClaudeEffector = class {
     this.currentMeta = meta;
     const timeout = this.config.timeout ?? DEFAULT_TIMEOUT;
     const timeoutId = setTimeout(() => {
-      logger5.warn("Request timeout", { timeout });
+      logger7.warn("Request timeout", { timeout });
       this.currentAbortController?.abort(new Error(`Request timeout after ${timeout}ms`));
     }, timeout);
     try {
       await this.initialize(this.currentAbortController);
       const sessionId = this.config.sessionId || "default";
       const sdkUserMessage = buildSDKUserMessage(message, sessionId);
-      logger5.debug("Sending message to Claude", {
+      logger7.debug("Sending message to Claude", {
         content: typeof message.content === "string" ? message.content.substring(0, 80) : "[structured]",
         timeout,
         requestId: meta.requestId
@@ -919,13 +2079,13 @@ var ClaudeEffector = class {
    */
   interrupt(meta) {
     if (this.claudeQuery) {
-      logger5.debug("Interrupting Claude query", { requestId: meta?.requestId });
+      logger7.debug("Interrupting Claude query", { requestId: meta?.requestId });
       this.wasInterrupted = true;
       if (meta) {
         this.currentMeta = meta;
       }
       this.claudeQuery.interrupt().catch((err) => {
-        logger5.debug("SDK interrupt() error (may be expected)", { error: err });
+        logger7.debug("SDK interrupt() error (may be expected)", { error: err });
       });
     }
   }
@@ -934,7 +2094,7 @@ var ClaudeEffector = class {
    */
   async initialize(abortController) {
     if (this.isInitialized) return;
-    logger5.info("Initializing ClaudeEffector");
+    logger7.info("Initializing ClaudeEffector");
     const context = {
       apiKey: this.config.apiKey,
       baseUrl: this.config.baseUrl,
@@ -951,7 +2111,7 @@ var ClaudeEffector = class {
     });
     this.isInitialized = true;
     this.startBackgroundListener();
-    logger5.info("ClaudeEffector initialized");
+    logger7.info("ClaudeEffector initialized");
   }
   /**
    * Start background listener for SDK responses
@@ -960,7 +2120,7 @@ var ClaudeEffector = class {
     (async () => {
       try {
         for await (const sdkMsg of this.claudeQuery) {
-          logger5.debug("SDK message received", {
+          logger7.debug("SDK message received", {
             type: sdkMsg.type,
             subtype: sdkMsg.subtype,
             sessionId: sdkMsg.session_id,
@@ -977,10 +2137,10 @@ var ClaudeEffector = class {
           }
           if (sdkMsg.type === "result") {
             const resultMsg = sdkMsg;
-            logger5.info("SDK result received (full)", {
+            logger7.info("SDK result received (full)", {
               fullResult: JSON.stringify(sdkMsg, null, 2)
             });
-            logger5.info("SDK result received", {
+            logger7.info("SDK result received", {
               subtype: resultMsg.subtype,
               isError: resultMsg.is_error,
               errors: resultMsg.errors,
@@ -998,10 +2158,10 @@ var ClaudeEffector = class {
         }
       } catch (error) {
         if (this.isAbortError(error)) {
-          logger5.debug("Background listener aborted (expected during interrupt)");
+          logger7.debug("Background listener aborted (expected during interrupt)");
           this.resetState();
         } else {
-          logger5.error("Background listener error", { error });
+          logger7.error("Background listener error", { error });
           if (this.currentMeta) {
             const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
             this.receptor.emitError(errorMessage, "runtime_error", this.currentMeta);
@@ -1033,7 +2193,7 @@ var ClaudeEffector = class {
    * Dispose and cleanup resources
    */
   dispose() {
-    logger5.debug("Disposing ClaudeEffector");
+    logger7.debug("Disposing ClaudeEffector");
     if (this.currentAbortController) {
       this.currentAbortController.abort();
     }
@@ -1064,7 +2224,7 @@ var ClaudeEnvironment = class {
 };
 
 // src/internal/RuntimeAgent.ts
-var logger6 = createLogger6("runtime/RuntimeAgent");
+var logger8 = createLogger("runtime/RuntimeAgent");
 var BusPresenter = class {
   constructor(producer, session, agentId, imageId, containerId) {
     this.producer = producer;
@@ -1101,7 +2261,7 @@ var BusPresenter = class {
     this.producer.emit(systemEvent);
     if (category === "message") {
       this.session.addMessage(data).catch((err) => {
-        logger6.error("Failed to persist message", { error: err, messageType: output.type });
+        logger8.error("Failed to persist message", { error: err, messageType: output.type });
       });
     }
   }
@@ -1159,7 +2319,7 @@ var BusPresenter = class {
         };
       }
       default:
-        logger6.warn("Unknown message type, passing through", { type: output.type });
+        logger8.warn("Unknown message type, passing through", { type: output.type });
         return eventData;
     }
   }
@@ -1219,7 +2379,7 @@ var RuntimeAgent = class {
     });
     this.environment.receptor.connect(config.bus.asProducer());
     this.environment.effector.connect(config.bus.asConsumer());
-    logger6.info("ClaudeEnvironment created for agent", {
+    logger8.info("ClaudeEnvironment created for agent", {
       agentId: this.agentId,
       imageId: this.imageId,
       resumeSessionId: resumeSessionId ?? "none",
@@ -1253,14 +2413,14 @@ var RuntimeAgent = class {
     this.driver = new BusDriver(config.bus.asConsumer(), {
       agentId: this.agentId,
       onStreamEvent: (event) => {
-        logger6.debug("BusDriver \u2192 Engine.handleStreamEvent", { type: event.type });
+        logger8.debug("BusDriver \u2192 Engine.handleStreamEvent", { type: event.type });
         this.engine.handleStreamEvent(event);
       },
       onStreamComplete: (reason) => {
-        logger6.debug("Stream completed", { reason, agentId: this.agentId });
+        logger8.debug("Stream completed", { reason, agentId: this.agentId });
       }
     });
-    logger6.debug("RuntimeAgent created", {
+    logger8.debug("RuntimeAgent created", {
       agentId: this.agentId,
       imageId: this.imageId
     });
@@ -1269,13 +2429,13 @@ var RuntimeAgent = class {
    * Save SDK session ID to image metadata for future resume
    */
   saveSessionId(sdkSessionId) {
-    logger6.info("Saving SDK session ID to image metadata", {
+    logger8.info("Saving SDK session ID to image metadata", {
       agentId: this.agentId,
       imageId: this.imageId,
       sdkSessionId
     });
     this.imageRepository.updateMetadata(this.imageId, { claudeSdkSessionId: sdkSessionId }).catch((err) => {
-      logger6.error("Failed to save SDK session ID", { error: err, imageId: this.imageId });
+      logger8.error("Failed to save SDK session ID", { error: err, imageId: this.imageId });
     });
   }
   get lifecycle() {
@@ -1288,7 +2448,7 @@ var RuntimeAgent = class {
    * @param requestId - Request ID for correlation
    */
   async receive(content, requestId) {
-    logger6.debug("RuntimeAgent.receive called", {
+    logger8.debug("RuntimeAgent.receive called", {
       agentId: this.agentId,
       contentPreview: content.substring(0, 50),
       requestId
@@ -1297,13 +2457,13 @@ var RuntimeAgent = class {
       throw new Error(`Cannot send message to ${this._lifecycle} agent`);
     }
     await this.interactor.receive(content, requestId || `req_${Date.now()}`);
-    logger6.debug("RuntimeAgent.receive completed", { agentId: this.agentId });
+    logger8.debug("RuntimeAgent.receive completed", { agentId: this.agentId });
   }
   /**
    * Interrupt current operation
    */
   interrupt(requestId) {
-    logger6.debug("RuntimeAgent.interrupt called", { agentId: this.agentId, requestId });
+    logger8.debug("RuntimeAgent.interrupt called", { agentId: this.agentId, requestId });
     this.interactor.interrupt(requestId);
     this.producer.emit({
       type: "interrupted",
@@ -1498,8 +2658,7 @@ var RuntimeSandbox = class {
 };
 
 // src/internal/RuntimeImage.ts
-import { createLogger as createLogger7 } from "@agentxjs/common";
-var logger7 = createLogger7("runtime/RuntimeImage");
+var logger9 = createLogger("runtime/RuntimeImage");
 var RuntimeImage = class _RuntimeImage {
   constructor(record, context) {
     this.record = record;
@@ -1556,7 +2715,7 @@ var RuntimeImage = class _RuntimeImage {
       createdAt: now,
       updatedAt: now
     });
-    logger7.info("Image created", {
+    logger9.info("Image created", {
       imageId,
       sessionId,
       containerId: config.containerId,
@@ -1570,10 +2729,10 @@ var RuntimeImage = class _RuntimeImage {
   static async load(imageId, context) {
     const record = await context.imageRepository.findImageById(imageId);
     if (!record) {
-      logger7.debug("Image not found", { imageId });
+      logger9.debug("Image not found", { imageId });
       return null;
     }
-    logger7.debug("Image loaded", { imageId, name: record.name });
+    logger9.debug("Image loaded", { imageId, name: record.name });
     return new _RuntimeImage(record, context);
   }
   /**
@@ -1607,7 +2766,7 @@ var RuntimeImage = class _RuntimeImage {
       updatedAt: now
     };
     await this.context.imageRepository.saveImage(updatedRecord);
-    logger7.info("Image updated", { imageId: this.imageId, updates });
+    logger9.info("Image updated", { imageId: this.imageId, updates });
     return new _RuntimeImage(updatedRecord, this.context);
   }
   /**
@@ -1616,7 +2775,7 @@ var RuntimeImage = class _RuntimeImage {
   async delete() {
     await this.context.sessionRepository.deleteSession(this.sessionId);
     await this.context.imageRepository.deleteImage(this.imageId);
-    logger7.info("Image deleted", { imageId: this.imageId, sessionId: this.sessionId });
+    logger9.info("Image deleted", { imageId: this.imageId, sessionId: this.sessionId });
   }
   /**
    * Get the underlying record
@@ -1638,8 +2797,7 @@ var RuntimeImage = class _RuntimeImage {
 };
 
 // src/internal/RuntimeContainer.ts
-import { createLogger as createLogger8 } from "@agentxjs/common";
-var logger8 = createLogger8("runtime/RuntimeContainer");
+var logger10 = createLogger("runtime/RuntimeContainer");
 var RuntimeContainer = class _RuntimeContainer {
   containerId;
   createdAt;
@@ -1679,7 +2837,7 @@ var RuntimeContainer = class _RuntimeContainer {
         containerId
       }
     });
-    logger8.info("Container created", { containerId });
+    logger10.info("Container created", { containerId });
     return container;
   }
   /**
@@ -1688,7 +2846,7 @@ var RuntimeContainer = class _RuntimeContainer {
   static async load(containerId, context) {
     const record = await context.persistence.containers.findContainerById(containerId);
     if (!record) return null;
-    logger8.info("Container loaded", { containerId });
+    logger10.info("Container loaded", { containerId });
     return new _RuntimeContainer(containerId, record.createdAt, context);
   }
   // ==================== Image → Agent Lifecycle ====================
@@ -1701,7 +2859,7 @@ var RuntimeContainer = class _RuntimeContainer {
     if (existingAgentId) {
       const existingAgent = this.agents.get(existingAgentId);
       if (existingAgent) {
-        logger8.info("Reusing existing agent for image", {
+        logger10.info("Reusing existing agent for image", {
           containerId: this.containerId,
           imageId: image.imageId,
           agentId: existingAgentId
@@ -1760,7 +2918,7 @@ var RuntimeContainer = class _RuntimeContainer {
         agentId
       }
     });
-    logger8.info("Agent created for image", {
+    logger10.info("Agent created for image", {
       containerId: this.containerId,
       imageId: image.imageId,
       agentId
@@ -1773,17 +2931,17 @@ var RuntimeContainer = class _RuntimeContainer {
   async stopImage(imageId) {
     const agentId = this.imageToAgent.get(imageId);
     if (!agentId) {
-      logger8.debug("Image not running, nothing to stop", {
+      logger10.debug("Image not running, nothing to stop", {
         imageId,
         containerId: this.containerId
       });
       return false;
     }
-    logger8.info("Stopping image", { imageId, agentId, containerId: this.containerId });
+    logger10.info("Stopping image", { imageId, agentId, containerId: this.containerId });
     const success = await this.destroyAgent(agentId);
     if (success) {
       this.imageToAgent.delete(imageId);
-      logger8.info("Image stopped", { imageId, agentId, containerId: this.containerId });
+      logger10.info("Image stopped", { imageId, agentId, containerId: this.containerId });
     }
     return success;
   }
@@ -1840,7 +2998,7 @@ var RuntimeContainer = class _RuntimeContainer {
         agentId
       }
     });
-    logger8.info("Agent destroyed", { containerId: this.containerId, agentId });
+    logger10.info("Agent destroyed", { containerId: this.containerId, agentId });
     return true;
   }
   async destroyAllAgents() {
@@ -1868,7 +3026,7 @@ var RuntimeContainer = class _RuntimeContainer {
       }
     });
     this.context.onDisposed?.(this.containerId);
-    logger8.info("Container disposed", { containerId: this.containerId, agentCount });
+    logger10.info("Container disposed", { containerId: this.containerId, agentCount });
   }
   // ==================== Private Helpers ====================
   generateAgentId() {
@@ -1879,8 +3037,7 @@ var RuntimeContainer = class _RuntimeContainer {
 };
 
 // src/internal/BaseEventHandler.ts
-import { createLogger as createLogger9 } from "@agentxjs/common";
-var logger9 = createLogger9("runtime/BaseEventHandler");
+var logger11 = createLogger("runtime/BaseEventHandler");
 var BaseEventHandler = class {
   bus;
   unsubscribes = [];
@@ -1919,7 +3076,7 @@ var BaseEventHandler = class {
   handleError(err, context) {
     const message = err instanceof Error ? err.message : String(err);
     const stack = err instanceof Error ? err.stack : void 0;
-    logger9.error(`Error in ${context.operation || "handler"}`, {
+    logger11.error(`Error in ${context.operation || "handler"}`, {
       message,
       requestId: context.requestId,
       details: context.details
@@ -1946,7 +3103,7 @@ var BaseEventHandler = class {
       try {
         context.onError(err);
       } catch (callbackErr) {
-        logger9.error("Error in onError callback", { error: callbackErr });
+        logger11.error("Error in onError callback", { error: callbackErr });
       }
     }
   }
@@ -1964,13 +3121,12 @@ var BaseEventHandler = class {
       unsubscribe();
     }
     this.unsubscribes = [];
-    logger9.debug(`${this.constructor.name} disposed`);
+    logger11.debug(`${this.constructor.name} disposed`);
   }
 };
 
 // src/internal/CommandHandler.ts
-import { createLogger as createLogger10 } from "@agentxjs/common";
-var logger10 = createLogger10("runtime/CommandHandler");
+var logger12 = createLogger("runtime/CommandHandler");
 function createResponse(type, data) {
   return {
     type,
@@ -2003,7 +3159,7 @@ var CommandHandler = class extends BaseEventHandler {
     super(bus);
     this.ops = operations;
     this.bindHandlers();
-    logger10.debug("CommandHandler created");
+    logger12.debug("CommandHandler created");
   }
   /**
    * Log error and emit system_error event
@@ -2011,7 +3167,7 @@ var CommandHandler = class extends BaseEventHandler {
   emitError(operation, err, requestId, context) {
     const errorMessage = err instanceof Error ? err.message : String(err);
     const stack = err instanceof Error ? err.stack : void 0;
-    logger10.error(operation, {
+    logger12.error(operation, {
       requestId,
       ...context,
       error: errorMessage,
@@ -2068,12 +3224,12 @@ var CommandHandler = class extends BaseEventHandler {
     this.subscribe(
       this.bus.onCommand("image_messages_request", (event) => this.handleImageMessages(event))
     );
-    logger10.debug("Command handlers bound");
+    logger12.debug("Command handlers bound");
   }
   // ==================== Container Handlers ====================
   async handleContainerCreate(event) {
     const { requestId, containerId } = event.data;
-    logger10.debug("Handling container_create_request", { requestId, containerId });
+    logger12.debug("Handling container_create_request", { requestId, containerId });
     try {
       await this.ops.createContainer(containerId);
       this.bus.emit(
@@ -2095,7 +3251,7 @@ var CommandHandler = class extends BaseEventHandler {
   }
   handleContainerGet(event) {
     const { requestId, containerId } = event.data;
-    logger10.debug("Handling container_get_request", { requestId, containerId });
+    logger12.debug("Handling container_get_request", { requestId, containerId });
     const container = this.ops.getContainer(containerId);
     this.bus.emit(
       createResponse("container_get_response", {
@@ -2107,7 +3263,7 @@ var CommandHandler = class extends BaseEventHandler {
   }
   handleContainerList(event) {
     const { requestId } = event.data;
-    logger10.debug("Handling container_list_request", { requestId });
+    logger12.debug("Handling container_list_request", { requestId });
     const containers = this.ops.listContainers();
     this.bus.emit(
       createResponse("container_list_response", {
@@ -2119,7 +3275,7 @@ var CommandHandler = class extends BaseEventHandler {
   // ==================== Agent Handlers ====================
   handleAgentGet(event) {
     const { requestId, agentId } = event.data;
-    logger10.debug("Handling agent_get_request", { requestId, agentId });
+    logger12.debug("Handling agent_get_request", { requestId, agentId });
     const agent = this.ops.getAgent(agentId);
     this.bus.emit(
       createResponse("agent_get_response", {
@@ -2132,7 +3288,7 @@ var CommandHandler = class extends BaseEventHandler {
   }
   handleAgentList(event) {
     const { requestId, containerId } = event.data;
-    logger10.debug("Handling agent_list_request", { requestId, containerId });
+    logger12.debug("Handling agent_list_request", { requestId, containerId });
     const agents = this.ops.listAgents(containerId);
     this.bus.emit(
       createResponse("agent_list_response", {
@@ -2147,7 +3303,7 @@ var CommandHandler = class extends BaseEventHandler {
   }
   async handleAgentDestroy(event) {
     const { requestId, agentId } = event.data;
-    logger10.debug("Handling agent_destroy_request", { requestId, agentId });
+    logger12.debug("Handling agent_destroy_request", { requestId, agentId });
     try {
       const success = await this.ops.destroyAgent(agentId);
       this.bus.emit(
@@ -2171,7 +3327,7 @@ var CommandHandler = class extends BaseEventHandler {
   }
   async handleAgentDestroyAll(event) {
     const { requestId, containerId } = event.data;
-    logger10.debug("Handling agent_destroy_all_request", { requestId, containerId });
+    logger12.debug("Handling agent_destroy_all_request", { requestId, containerId });
     try {
       await this.ops.destroyAllAgents(containerId);
       this.bus.emit(
@@ -2193,7 +3349,7 @@ var CommandHandler = class extends BaseEventHandler {
   }
   async handleMessageSend(event) {
     const { requestId, imageId, agentId, content } = event.data;
-    logger10.debug("Handling message_send_request", { requestId, imageId, agentId });
+    logger12.debug("Handling message_send_request", { requestId, imageId, agentId });
     try {
       const result = await this.ops.receiveMessage(imageId, agentId, content, requestId);
       this.bus.emit(
@@ -2217,7 +3373,7 @@ var CommandHandler = class extends BaseEventHandler {
   }
   handleAgentInterrupt(event) {
     const { requestId, imageId, agentId } = event.data;
-    logger10.debug("Handling agent_interrupt_request", { requestId, imageId, agentId });
+    logger12.debug("Handling agent_interrupt_request", { requestId, imageId, agentId });
     try {
       const result = this.ops.interruptAgent(imageId, agentId, requestId);
       this.bus.emit(
@@ -2242,7 +3398,7 @@ var CommandHandler = class extends BaseEventHandler {
   // ==================== Image Handlers ====================
   async handleImageCreate(event) {
     const { requestId, containerId, config } = event.data;
-    logger10.debug("Handling image_create_request", { requestId, containerId });
+    logger12.debug("Handling image_create_request", { requestId, containerId });
     try {
       const record = await this.ops.createImage(containerId, config);
       this.bus.emit(
@@ -2264,7 +3420,7 @@ var CommandHandler = class extends BaseEventHandler {
   }
   async handleImageRun(event) {
     const { requestId, imageId } = event.data;
-    logger10.debug("Handling image_run_request", { requestId, imageId });
+    logger12.debug("Handling image_run_request", { requestId, imageId });
     try {
       const result = await this.ops.runImage(imageId);
       this.bus.emit(
@@ -2290,7 +3446,7 @@ var CommandHandler = class extends BaseEventHandler {
   }
   async handleImageStop(event) {
     const { requestId, imageId } = event.data;
-    logger10.debug("Handling image_stop_request", { requestId, imageId });
+    logger12.debug("Handling image_stop_request", { requestId, imageId });
     try {
       await this.ops.stopImage(imageId);
       this.bus.emit(
@@ -2312,7 +3468,7 @@ var CommandHandler = class extends BaseEventHandler {
   }
   async handleImageUpdate(event) {
     const { requestId, imageId, updates } = event.data;
-    logger10.debug("Handling image_update_request", { requestId, imageId });
+    logger12.debug("Handling image_update_request", { requestId, imageId });
     try {
       const record = await this.ops.updateImage(imageId, updates);
       this.bus.emit(
@@ -2334,7 +3490,7 @@ var CommandHandler = class extends BaseEventHandler {
   }
   async handleImageList(event) {
     const { requestId, containerId } = event.data;
-    logger10.debug("Handling image_list_request", { requestId, containerId });
+    logger12.debug("Handling image_list_request", { requestId, containerId });
     try {
       const images = await this.ops.listImages(containerId);
       this.bus.emit(
@@ -2356,7 +3512,7 @@ var CommandHandler = class extends BaseEventHandler {
   }
   async handleImageGet(event) {
     const { requestId, imageId } = event.data;
-    logger10.debug("Handling image_get_request", { requestId, imageId });
+    logger12.debug("Handling image_get_request", { requestId, imageId });
     try {
       const image = await this.ops.getImage(imageId);
       this.bus.emit(
@@ -2377,7 +3533,7 @@ var CommandHandler = class extends BaseEventHandler {
   }
   async handleImageDelete(event) {
     const { requestId, imageId } = event.data;
-    logger10.debug("Handling image_delete_request", { requestId, imageId });
+    logger12.debug("Handling image_delete_request", { requestId, imageId });
     try {
       await this.ops.deleteImage(imageId);
       this.bus.emit(
@@ -2399,10 +3555,10 @@ var CommandHandler = class extends BaseEventHandler {
   }
   async handleImageMessages(event) {
     const { requestId, imageId } = event.data;
-    logger10.info("Handling image_messages_request", { requestId, imageId });
+    logger12.info("Handling image_messages_request", { requestId, imageId });
     try {
       const messages = await this.ops.getImageMessages(imageId);
-      logger10.info("Got messages for image", { imageId, count: messages.length });
+      logger12.info("Got messages for image", { imageId, count: messages.length });
       this.bus.emit(
         createResponse("image_messages_response", {
           requestId,
@@ -2410,7 +3566,7 @@ var CommandHandler = class extends BaseEventHandler {
           messages
         })
       );
-      logger10.info("Emitted image_messages_response", { requestId, imageId });
+      logger12.info("Emitted image_messages_response", { requestId, imageId });
     } catch (err) {
       this.emitError("Failed to get image messages", err, requestId, { imageId });
       this.bus.emit(
@@ -2427,10 +3583,9 @@ var CommandHandler = class extends BaseEventHandler {
 };
 
 // src/RuntimeImpl.ts
-import { createLogger as createLogger11 } from "@agentxjs/common";
 import { homedir } from "os";
 import { join as join2 } from "path";
-var logger11 = createLogger11("runtime/RuntimeImpl");
+var logger13 = createLogger("runtime/RuntimeImpl");
 var RuntimeImpl = class {
   persistence;
   llmProvider;
@@ -2441,20 +3596,20 @@ var RuntimeImpl = class {
   /** Container registry: containerId -> RuntimeContainer */
   containerRegistry = /* @__PURE__ */ new Map();
   constructor(config) {
-    logger11.info("RuntimeImpl constructor start");
+    logger13.info("RuntimeImpl constructor start");
     this.persistence = config.persistence;
     this.llmProvider = config.llmProvider;
     this.basePath = join2(homedir(), ".agentx");
-    logger11.info("Creating SystemBus");
+    logger13.info("Creating SystemBus");
     this.bus = new SystemBusImpl();
     this.llmConfig = this.llmProvider.provide();
-    logger11.info("LLM config loaded", {
+    logger13.info("LLM config loaded", {
       hasApiKey: !!this.llmConfig.apiKey,
       model: this.llmConfig.model
     });
-    logger11.info("Creating CommandHandler");
+    logger13.info("Creating CommandHandler");
     this.commandHandler = new CommandHandler(this.bus, this.createRuntimeOperations());
-    logger11.info("RuntimeImpl constructor done");
+    logger13.info("RuntimeImpl constructor done");
   }
   // ==================== SystemBus delegation ====================
   emit(event) {
@@ -2537,7 +3692,7 @@ var RuntimeImpl = class {
       // Agent operations (by imageId - with auto-activation)
       receiveMessage: async (imageId, agentId, content, requestId) => {
         if (imageId) {
-          logger11.debug("Receiving message by imageId", {
+          logger13.debug("Receiving message by imageId", {
             imageId,
             contentLength: content.length,
             requestId
@@ -2546,7 +3701,7 @@ var RuntimeImpl = class {
           if (!record) throw new Error(`Image not found: ${imageId}`);
           const container = await this.getOrCreateContainer(record.containerId);
           const { agent, reused } = await container.runImage(record);
-          logger11.info("Message routed to agent", {
+          logger13.info("Message routed to agent", {
             imageId,
             agentId: agent.agentId,
             reused,
@@ -2556,7 +3711,7 @@ var RuntimeImpl = class {
           return { agentId: agent.agentId, imageId };
         }
         if (agentId) {
-          logger11.debug("Receiving message by agentId (legacy)", {
+          logger13.debug("Receiving message by agentId (legacy)", {
             agentId,
             contentLength: content.length,
             requestId
@@ -2573,12 +3728,12 @@ var RuntimeImpl = class {
         if (imageId) {
           const foundAgentId = this.findAgentIdForImage(imageId);
           if (!foundAgentId) {
-            logger11.debug("Image is offline, nothing to interrupt", { imageId });
+            logger13.debug("Image is offline, nothing to interrupt", { imageId });
             return { imageId, agentId: void 0 };
           }
           const agent = this.findAgent(foundAgentId);
           if (agent) {
-            logger11.info("Interrupting agent by imageId", {
+            logger13.info("Interrupting agent by imageId", {
               imageId,
               agentId: foundAgentId,
               requestId
@@ -2590,7 +3745,7 @@ var RuntimeImpl = class {
         if (agentId) {
           const agent = this.findAgent(agentId);
           if (!agent) throw new Error(`Agent not found: ${agentId}`);
-          logger11.info("Interrupting agent by agentId (legacy)", { agentId, requestId });
+          logger13.info("Interrupting agent by agentId (legacy)", { agentId, requestId });
           agent.interrupt(requestId);
           const foundImageId = this.findImageIdForAgent(agentId);
           return { agentId, imageId: foundImageId };
@@ -2599,32 +3754,32 @@ var RuntimeImpl = class {
       },
       // Image operations (new model)
       createImage: async (containerId, config) => {
-        logger11.debug("Creating image", { containerId, name: config.name });
+        logger13.debug("Creating image", { containerId, name: config.name });
         await this.getOrCreateContainer(containerId);
         const image = await RuntimeImage.create(
           { containerId, ...config },
           this.createImageContext()
         );
-        logger11.info("Image created via RuntimeOps", { imageId: image.imageId, containerId });
+        logger13.info("Image created via RuntimeOps", { imageId: image.imageId, containerId });
         return this.toImageListItemResult(image.toRecord(), false);
       },
       runImage: async (imageId) => {
-        logger11.debug("Running image", { imageId });
+        logger13.debug("Running image", { imageId });
         const record = await this.persistence.images.findImageById(imageId);
         if (!record) throw new Error(`Image not found: ${imageId}`);
         const container = await this.getOrCreateContainer(record.containerId);
         const { agent, reused } = await container.runImage(record);
-        logger11.info("Image running", { imageId, agentId: agent.agentId, reused });
+        logger13.info("Image running", { imageId, agentId: agent.agentId, reused });
         return { imageId, agentId: agent.agentId, reused };
       },
       stopImage: async (imageId) => {
-        logger11.debug("Stopping image", { imageId });
+        logger13.debug("Stopping image", { imageId });
         const record = await this.persistence.images.findImageById(imageId);
         if (!record) throw new Error(`Image not found: ${imageId}`);
         const container = this.containerRegistry.get(record.containerId);
         if (container) {
           await container.stopImage(imageId);
-          logger11.info("Image stopped via RuntimeOps", { imageId });
+          logger13.info("Image stopped via RuntimeOps", { imageId });
         }
       },
       updateImage: async (imageId, updates) => {
@@ -2648,10 +3803,10 @@ var RuntimeImpl = class {
         return this.toImageListItemResult(record, online);
       },
       deleteImage: async (imageId) => {
-        logger11.debug("Deleting image", { imageId });
+        logger13.debug("Deleting image", { imageId });
         const agentId = this.findAgentIdForImage(imageId);
         if (agentId) {
-          logger11.debug("Stopping running agent before delete", { imageId, agentId });
+          logger13.debug("Stopping running agent before delete", { imageId, agentId });
           for (const container of this.containerRegistry.values()) {
             if (container.getAgent(agentId)) {
               await container.destroyAgent(agentId);
@@ -2662,17 +3817,17 @@ var RuntimeImpl = class {
         const image = await RuntimeImage.load(imageId, this.createImageContext());
         if (image) {
           await image.delete();
-          logger11.info("Image deleted via RuntimeOps", { imageId });
+          logger13.info("Image deleted via RuntimeOps", { imageId });
         }
       },
       getImageMessages: async (imageId) => {
-        logger11.debug("Getting messages for image", { imageId });
+        logger13.debug("Getting messages for image", { imageId });
         const image = await RuntimeImage.load(imageId, this.createImageContext());
         if (!image) {
           throw new Error(`Image not found: ${imageId}`);
         }
         const messages = await image.getMessages();
-        logger11.debug("Got messages from storage", { imageId, count: messages.length });
+        logger13.debug("Got messages from storage", { imageId, count: messages.length });
         return messages.map((m) => {
           let content;
           let role = m.role;
@@ -2789,14 +3944,14 @@ var RuntimeImpl = class {
   }
   // ==================== Lifecycle ====================
   async dispose() {
-    logger11.info("Disposing RuntimeImpl");
+    logger13.info("Disposing RuntimeImpl");
     this.commandHandler.dispose();
     for (const container of this.containerRegistry.values()) {
       await container.dispose();
     }
     this.bus.destroy();
     this.containerRegistry.clear();
-    logger11.info("RuntimeImpl disposed");
+    logger13.info("RuntimeImpl disposed");
   }
 };
 
@@ -2807,11 +3962,9 @@ function createRuntime(config) {
 
 // src/internal/persistence/PersistenceImpl.ts
 import { createStorage } from "unstorage";
-import { createLogger as createLogger15 } from "@agentxjs/common";
 
 // src/internal/persistence/repository/StorageImageRepository.ts
-import { createLogger as createLogger12 } from "@agentxjs/common";
-var logger12 = createLogger12("persistence/ImageRepository");
+var logger14 = createLogger("persistence/ImageRepository");
 var PREFIX = "images";
 var INDEX_BY_NAME = "idx:images:name";
 var INDEX_BY_CONTAINER = "idx:images:container";
@@ -2835,7 +3988,7 @@ var StorageImageRepository = class {
       this.containerIndexKey(record.containerId, record.imageId),
       record.imageId
     );
-    logger12.debug("Image saved", { imageId: record.imageId });
+    logger14.debug("Image saved", { imageId: record.imageId });
   }
   async findImageById(imageId) {
     const record = await this.storage.getItem(this.key(imageId));
@@ -2890,7 +4043,7 @@ var StorageImageRepository = class {
       await this.storage.removeItem(this.nameIndexKey(record.name, imageId));
       await this.storage.removeItem(this.containerIndexKey(record.containerId, imageId));
     }
-    logger12.debug("Image deleted", { imageId });
+    logger14.debug("Image deleted", { imageId });
   }
   async imageExists(imageId) {
     return await this.storage.hasItem(this.key(imageId));
@@ -2909,13 +4062,12 @@ var StorageImageRepository = class {
       updatedAt: Date.now()
     };
     await this.storage.setItem(this.key(imageId), updatedRecord);
-    logger12.debug("Image metadata updated", { imageId, metadata });
+    logger14.debug("Image metadata updated", { imageId, metadata });
   }
 };
 
 // src/internal/persistence/repository/StorageContainerRepository.ts
-import { createLogger as createLogger13 } from "@agentxjs/common";
-var logger13 = createLogger13("persistence/ContainerRepository");
+var logger15 = createLogger("persistence/ContainerRepository");
 var PREFIX2 = "containers";
 var StorageContainerRepository = class {
   constructor(storage) {
@@ -2926,7 +4078,7 @@ var StorageContainerRepository = class {
   }
   async saveContainer(record) {
     await this.storage.setItem(this.key(record.containerId), record);
-    logger13.debug("Container saved", { containerId: record.containerId });
+    logger15.debug("Container saved", { containerId: record.containerId });
   }
   async findContainerById(containerId) {
     const record = await this.storage.getItem(this.key(containerId));
@@ -2945,7 +4097,7 @@ var StorageContainerRepository = class {
   }
   async deleteContainer(containerId) {
     await this.storage.removeItem(this.key(containerId));
-    logger13.debug("Container deleted", { containerId });
+    logger15.debug("Container deleted", { containerId });
   }
   async containerExists(containerId) {
     return await this.storage.hasItem(this.key(containerId));
@@ -2953,8 +4105,7 @@ var StorageContainerRepository = class {
 };
 
 // src/internal/persistence/repository/StorageSessionRepository.ts
-import { createLogger as createLogger14 } from "@agentxjs/common";
-var logger14 = createLogger14("persistence/SessionRepository");
+var logger16 = createLogger("persistence/SessionRepository");
 var PREFIX3 = "sessions";
 var MESSAGES_PREFIX = "messages";
 var INDEX_BY_IMAGE = "idx:sessions:image";
@@ -2985,7 +4136,7 @@ var StorageSessionRepository = class {
       this.containerIndexKey(record.containerId, record.sessionId),
       record.sessionId
     );
-    logger14.debug("Session saved", { sessionId: record.sessionId });
+    logger16.debug("Session saved", { sessionId: record.sessionId });
   }
   async findSessionById(sessionId) {
     const record = await this.storage.getItem(this.key(sessionId));
@@ -3034,7 +4185,7 @@ var StorageSessionRepository = class {
       await this.storage.removeItem(this.imageIndexKey(record.imageId, sessionId));
       await this.storage.removeItem(this.containerIndexKey(record.containerId, sessionId));
     }
-    logger14.debug("Session deleted", { sessionId });
+    logger16.debug("Session deleted", { sessionId });
   }
   async sessionExists(sessionId) {
     return await this.storage.hasItem(this.key(sessionId));
@@ -3044,13 +4195,13 @@ var StorageSessionRepository = class {
     const messages = await this.getMessages(sessionId);
     messages.push(message);
     await this.storage.setItem(this.messagesKey(sessionId), messages);
-    logger14.debug("Message added to session", { sessionId, subtype: message.subtype });
+    logger16.debug("Message added to session", { sessionId, subtype: message.subtype });
   }
   async getMessages(sessionId) {
     const messages = await this.storage.getItem(this.messagesKey(sessionId));
     if (!messages || !Array.isArray(messages)) {
       if (messages) {
-        logger14.warn("Messages data is not an array, resetting", {
+        logger16.warn("Messages data is not an array, resetting", {
           sessionId,
           type: typeof messages
         });
@@ -3061,12 +4212,12 @@ var StorageSessionRepository = class {
   }
   async clearMessages(sessionId) {
     await this.storage.removeItem(this.messagesKey(sessionId));
-    logger14.debug("Messages cleared for session", { sessionId });
+    logger16.debug("Messages cleared for session", { sessionId });
   }
 };
 
 // src/internal/persistence/PersistenceImpl.ts
-var logger15 = createLogger15("persistence/Persistence");
+var logger17 = createLogger("persistence/Persistence");
 var PersistenceImpl = class _PersistenceImpl {
   images;
   containers;
@@ -3080,7 +4231,7 @@ var PersistenceImpl = class _PersistenceImpl {
     this.images = new StorageImageRepository(this.storage);
     this.containers = new StorageContainerRepository(this.storage);
     this.sessions = new StorageSessionRepository(this.storage);
-    logger15.info("Persistence created", { driver: driverName });
+    logger17.info("Persistence created", { driver: driverName });
   }
   /**
    * Create a PersistenceImpl instance (async factory)
@@ -3101,7 +4252,7 @@ var PersistenceImpl = class _PersistenceImpl {
    */
   async dispose() {
     await this.storage.dispose();
-    logger15.info("Persistence disposed");
+    logger17.info("Persistence disposed");
   }
 };
 async function createStorageFromConfig(config) {