@agentxjs/runtime 1.0.2 → 1.1.0

package/dist/index.cjs

@@ -37,178 +37,8 @@ module.exports = __toCommonJS(index_exports);
 
 // src/internal/SystemBusImpl.ts
 var import_rxjs = require("rxjs");
-
-// ../common/dist/index.js
-var __defProp2 = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp2(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 import_common = require("@agentxjs/common");
+var logger = (0, import_common.createLogger)("runtime/SystemBusImpl");
 var SystemBusImpl = class {
   subject = new import_rxjs.Subject();
   subscriptions = [];
@@ -366,7 +196,8 @@ var SystemBusImpl = class {
 };
 
 // src/internal/BusDriver.ts
-var logger2 = createLogger("runtime/BusDriver");
+var import_common2 = require("@agentxjs/common");
+var logger2 = (0, import_common2.createLogger)("runtime/BusDriver");
 var BusDriver = class {
   name = "BusDriver";
   description = "Driver that listens to SystemBus for DriveableEvents";
@@ -551,7 +382,8 @@ var BusDriver = class {
 };
 
 // src/internal/AgentInteractor.ts
-var logger3 = createLogger("runtime/AgentInteractor");
+var import_common3 = require("@agentxjs/common");
+var logger3 = (0, import_common3.createLogger)("runtime/AgentInteractor");
 var AgentInteractor = class {
   producer;
   session;
@@ -642,1006 +474,13 @@ var AgentInteractor = class {
   }
 };
 
-// ../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/internal/RuntimeAgent.ts
+var import_agent = require("@agentxjs/agent");
+var import_common7 = require("@agentxjs/common");
 
 // src/environment/ClaudeReceptor.ts
-var logger6 = createLogger("ecosystem/ClaudeReceptor");
+var import_common4 = require("@agentxjs/common");
+var logger4 = (0, import_common4.createLogger)("ecosystem/ClaudeReceptor");
 var ClaudeReceptor = class {
   producer = null;
   currentMeta = null;
@@ -1659,7 +498,7 @@ var ClaudeReceptor = class {
    */
   connect(producer) {
     this.producer = producer;
-    logger6.debug("ClaudeReceptor connected to SystemBusProducer");
+    logger4.debug("ClaudeReceptor connected to SystemBusProducer");
   }
   /**
    * Feed SDK message to receptor with correlation metadata
@@ -1777,7 +616,7 @@ var ClaudeReceptor = class {
       case "content_block_start": {
         const contentBlock = event.content_block;
         this.blockContext.currentBlockIndex = event.index;
-        logger6.debug("content_block_start received", { contentBlock, index: event.index });
+        logger4.debug("content_block_start received", { contentBlock, index: event.index });
         if (contentBlock.type === "text") {
           this.blockContext.currentBlockType = "text";
           this.emitToBus({
@@ -1914,9 +753,11 @@ var ClaudeReceptor = class {
 // src/environment/ClaudeEffector.ts
 var import_claude_agent_sdk = require("@anthropic-ai/claude-agent-sdk");
 var import_rxjs2 = require("rxjs");
+var import_common6 = require("@agentxjs/common");
 
 // src/environment/buildOptions.ts
-var logger7 = createLogger("environment/buildOptions");
+var import_common5 = require("@agentxjs/common");
+var logger5 = (0, import_common5.createLogger)("environment/buildOptions");
 function buildOptions(context, abortController) {
   const options = {
     abortController,
@@ -1941,7 +782,7 @@ function buildOptions(context, abortController) {
     env.ANTHROPIC_API_KEY = context.apiKey;
   }
   options.env = env;
-  logger7.info("buildOptions called", {
+  logger5.info("buildOptions called", {
     hasPath: !!env.PATH,
     pathLength: env.PATH?.length,
     hasApiKey: !!env.ANTHROPIC_API_KEY,
@@ -1952,7 +793,7 @@ function buildOptions(context, abortController) {
     cwd: context.cwd
   });
   options.stderr = (data) => {
-    logger7.info("SDK stderr", { data: data.trim() });
+    logger5.info("SDK stderr", { data: data.trim() });
   };
   if (context.model) options.model = context.model;
   if (context.systemPrompt) options.systemPrompt = context.systemPrompt;
@@ -2055,7 +896,7 @@ async function* observableToAsyncIterable(observable) {
 }
 
 // src/environment/ClaudeEffector.ts
-var logger8 = createLogger("ecosystem/ClaudeEffector");
+var logger6 = (0, import_common6.createLogger)("ecosystem/ClaudeEffector");
 var DEFAULT_TIMEOUT = 3e4;
 var ClaudeEffector = class {
   config;
@@ -2074,12 +915,12 @@ var ClaudeEffector = class {
    * Connect to SystemBus consumer to subscribe to events
    */
   connect(consumer) {
-    logger8.debug("ClaudeEffector connected to SystemBusConsumer", {
+    logger6.debug("ClaudeEffector connected to SystemBusConsumer", {
       agentId: this.config.agentId
     });
     consumer.on("user_message", async (event) => {
       const typedEvent = event;
-      logger8.debug("user_message event received", {
+      logger6.debug("user_message event received", {
         eventAgentId: typedEvent.context?.agentId,
         myAgentId: this.config.agentId,
         matches: typedEvent.context?.agentId === this.config.agentId
@@ -2115,14 +956,14 @@ var ClaudeEffector = class {
     this.currentMeta = meta;
     const timeout = this.config.timeout ?? DEFAULT_TIMEOUT;
     const timeoutId = setTimeout(() => {
-      logger8.warn("Request timeout", { timeout });
+      logger6.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);
-      logger8.debug("Sending message to Claude", {
+      logger6.debug("Sending message to Claude", {
         content: typeof message.content === "string" ? message.content.substring(0, 80) : "[structured]",
         timeout,
         requestId: meta.requestId
@@ -2139,13 +980,13 @@ var ClaudeEffector = class {
    */
   interrupt(meta) {
     if (this.claudeQuery) {
-      logger8.debug("Interrupting Claude query", { requestId: meta?.requestId });
+      logger6.debug("Interrupting Claude query", { requestId: meta?.requestId });
       this.wasInterrupted = true;
       if (meta) {
         this.currentMeta = meta;
       }
       this.claudeQuery.interrupt().catch((err) => {
-        logger8.debug("SDK interrupt() error (may be expected)", { error: err });
+        logger6.debug("SDK interrupt() error (may be expected)", { error: err });
       });
     }
   }
@@ -2154,7 +995,7 @@ var ClaudeEffector = class {
    */
   async initialize(abortController) {
     if (this.isInitialized) return;
-    logger8.info("Initializing ClaudeEffector");
+    logger6.info("Initializing ClaudeEffector");
     const context = {
       apiKey: this.config.apiKey,
       baseUrl: this.config.baseUrl,
@@ -2171,7 +1012,7 @@ var ClaudeEffector = class {
     });
     this.isInitialized = true;
     this.startBackgroundListener();
-    logger8.info("ClaudeEffector initialized");
+    logger6.info("ClaudeEffector initialized");
   }
   /**
    * Start background listener for SDK responses
@@ -2180,7 +1021,7 @@ var ClaudeEffector = class {
     (async () => {
       try {
         for await (const sdkMsg of this.claudeQuery) {
-          logger8.debug("SDK message received", {
+          logger6.debug("SDK message received", {
             type: sdkMsg.type,
             subtype: sdkMsg.subtype,
             sessionId: sdkMsg.session_id,
@@ -2197,10 +1038,10 @@ var ClaudeEffector = class {
           }
           if (sdkMsg.type === "result") {
             const resultMsg = sdkMsg;
-            logger8.info("SDK result received (full)", {
+            logger6.info("SDK result received (full)", {
               fullResult: JSON.stringify(sdkMsg, null, 2)
             });
-            logger8.info("SDK result received", {
+            logger6.info("SDK result received", {
               subtype: resultMsg.subtype,
               isError: resultMsg.is_error,
               errors: resultMsg.errors,
@@ -2218,10 +1059,10 @@ var ClaudeEffector = class {
         }
       } catch (error) {
         if (this.isAbortError(error)) {
-          logger8.debug("Background listener aborted (expected during interrupt)");
+          logger6.debug("Background listener aborted (expected during interrupt)");
           this.resetState();
         } else {
-          logger8.error("Background listener error", { error });
+          logger6.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);
@@ -2253,7 +1094,7 @@ var ClaudeEffector = class {
    * Dispose and cleanup resources
    */
   dispose() {
-    logger8.debug("Disposing ClaudeEffector");
+    logger6.debug("Disposing ClaudeEffector");
     if (this.currentAbortController) {
       this.currentAbortController.abort();
     }
@@ -2284,7 +1125,7 @@ var ClaudeEnvironment = class {
 };
 
 // src/internal/RuntimeAgent.ts
-var logger9 = createLogger("runtime/RuntimeAgent");
+var logger7 = (0, import_common7.createLogger)("runtime/RuntimeAgent");
 var BusPresenter = class {
   constructor(producer, session, agentId, imageId, containerId) {
     this.producer = producer;
@@ -2321,67 +1162,18 @@ var BusPresenter = class {
     this.producer.emit(systemEvent);
     if (category === "message") {
       this.session.addMessage(data).catch((err) => {
-        logger9.error("Failed to persist message", { error: err, messageType: output.type });
+        logger7.error("Failed to persist message", { error: err, messageType: output.type });
       });
     }
   }
   /**
    * Convert AgentOutput to proper Message type for persistence
+   *
+   * Since messageAssemblerProcessor now emits complete Message objects,
+   * we can directly use the data field without transformation.
    */
   convertToMessage(output) {
-    const eventData = output.data;
-    const messageId = eventData.messageId ?? eventData.id;
-    const timestamp = eventData.timestamp || output.timestamp;
-    switch (output.type) {
-      case "assistant_message": {
-        const content = eventData.content;
-        return {
-          id: messageId,
-          role: "assistant",
-          subtype: "assistant",
-          content,
-          timestamp
-        };
-      }
-      case "tool_call_message": {
-        const toolCalls = eventData.toolCalls;
-        const toolCall = toolCalls[0];
-        return {
-          id: messageId,
-          role: "assistant",
-          subtype: "tool-call",
-          toolCall,
-          timestamp
-        };
-      }
-      case "tool_result_message": {
-        const results = eventData.results;
-        const toolResult = results[0];
-        return {
-          id: messageId,
-          role: "tool",
-          subtype: "tool-result",
-          toolCallId: toolResult.id,
-          toolResult,
-          timestamp
-        };
-      }
-      case "error_message": {
-        const content = eventData.content;
-        const errorCode = eventData.errorCode;
-        return {
-          id: messageId,
-          role: "error",
-          subtype: "error",
-          content,
-          errorCode,
-          timestamp
-        };
-      }
-      default:
-        logger9.warn("Unknown message type, passing through", { type: output.type });
-        return eventData;
-    }
+    return output.data;
   }
   /**
    * Determine event category from output type
@@ -2440,7 +1232,7 @@ var RuntimeAgent = class {
     });
     this.environment.receptor.connect(config.bus.asProducer());
     this.environment.effector.connect(config.bus.asConsumer());
-    logger9.info("ClaudeEnvironment created for agent", {
+    logger7.info("ClaudeEnvironment created for agent", {
       agentId: this.agentId,
       imageId: this.imageId,
       cwd: config.sandbox.workdir.path,
@@ -2455,7 +1247,7 @@ var RuntimeAgent = class {
       this.imageId,
       this.containerId
     );
-    this.engine = createAgent({
+    this.engine = (0, import_agent.createAgent)({
       driver: {
         name: "DummyDriver",
         description: "Placeholder driver for push-based event handling",
@@ -2475,14 +1267,14 @@ var RuntimeAgent = class {
     this.driver = new BusDriver(config.bus.asConsumer(), {
       agentId: this.agentId,
       onStreamEvent: (event) => {
-        logger9.debug("BusDriver \u2192 Engine.handleStreamEvent", { type: event.type });
+        logger7.debug("BusDriver \u2192 Engine.handleStreamEvent", { type: event.type });
         this.engine.handleStreamEvent(event);
       },
       onStreamComplete: (reason) => {
-        logger9.debug("Stream completed", { reason, agentId: this.agentId });
+        logger7.debug("Stream completed", { reason, agentId: this.agentId });
       }
     });
-    logger9.debug("RuntimeAgent created", {
+    logger7.debug("RuntimeAgent created", {
       agentId: this.agentId,
       imageId: this.imageId
     });
@@ -2491,13 +1283,13 @@ var RuntimeAgent = class {
    * Save SDK session ID to image metadata for future resume
    */
   saveSessionId(sdkSessionId) {
-    logger9.info("Saving SDK session ID to image metadata", {
+    logger7.info("Saving SDK session ID to image metadata", {
       agentId: this.agentId,
       imageId: this.imageId,
       sdkSessionId
     });
     this.imageRepository.updateMetadata(this.imageId, { claudeSdkSessionId: sdkSessionId }).catch((err) => {
-      logger9.error("Failed to save SDK session ID", { error: err, imageId: this.imageId });
+      logger7.error("Failed to save SDK session ID", { error: err, imageId: this.imageId });
     });
   }
   get lifecycle() {
@@ -2510,7 +1302,7 @@ var RuntimeAgent = class {
    * @param requestId - Request ID for correlation
    */
   async receive(content, requestId) {
-    logger9.debug("RuntimeAgent.receive called", {
+    logger7.debug("RuntimeAgent.receive called", {
       agentId: this.agentId,
       contentPreview: content.substring(0, 50),
       requestId
@@ -2519,13 +1311,13 @@ var RuntimeAgent = class {
       throw new Error(`Cannot send message to ${this._lifecycle} agent`);
     }
     await this.interactor.receive(content, requestId || `req_${Date.now()}`);
-    logger9.debug("RuntimeAgent.receive completed", { agentId: this.agentId });
+    logger7.debug("RuntimeAgent.receive completed", { agentId: this.agentId });
   }
   /**
    * Interrupt current operation
    */
   interrupt(requestId) {
-    logger9.debug("RuntimeAgent.interrupt called", { agentId: this.agentId, requestId });
+    logger7.debug("RuntimeAgent.interrupt called", { agentId: this.agentId, requestId });
     this.interactor.interrupt(requestId);
     this.producer.emit({
       type: "interrupted",
@@ -2700,7 +1492,7 @@ var RuntimeSandbox = class {
       "containers",
       config.containerId,
       "workdirs",
-      config.agentId
+      config.imageId
     );
     this.workdir = new RuntimeWorkdir(config.agentId, workdirPath);
   }
@@ -2720,7 +1512,8 @@ var RuntimeSandbox = class {
 };
 
 // src/internal/RuntimeImage.ts
-var logger10 = createLogger("runtime/RuntimeImage");
+var import_common8 = require("@agentxjs/common");
+var logger8 = (0, import_common8.createLogger)("runtime/RuntimeImage");
 var RuntimeImage = class _RuntimeImage {
   constructor(record, context) {
     this.record = record;
@@ -2777,7 +1570,7 @@ var RuntimeImage = class _RuntimeImage {
       createdAt: now,
       updatedAt: now
     });
-    logger10.info("Image created", {
+    logger8.info("Image created", {
       imageId,
       sessionId,
       containerId: config.containerId,
@@ -2791,10 +1584,10 @@ var RuntimeImage = class _RuntimeImage {
   static async load(imageId, context) {
     const record = await context.imageRepository.findImageById(imageId);
     if (!record) {
-      logger10.debug("Image not found", { imageId });
+      logger8.debug("Image not found", { imageId });
       return null;
     }
-    logger10.debug("Image loaded", { imageId, name: record.name });
+    logger8.debug("Image loaded", { imageId, name: record.name });
     return new _RuntimeImage(record, context);
   }
   /**
@@ -2828,7 +1621,7 @@ var RuntimeImage = class _RuntimeImage {
       updatedAt: now
     };
     await this.context.imageRepository.saveImage(updatedRecord);
-    logger10.info("Image updated", { imageId: this.imageId, updates });
+    logger8.info("Image updated", { imageId: this.imageId, updates });
     return new _RuntimeImage(updatedRecord, this.context);
   }
   /**
@@ -2837,7 +1630,7 @@ var RuntimeImage = class _RuntimeImage {
   async delete() {
     await this.context.sessionRepository.deleteSession(this.sessionId);
     await this.context.imageRepository.deleteImage(this.imageId);
-    logger10.info("Image deleted", { imageId: this.imageId, sessionId: this.sessionId });
+    logger8.info("Image deleted", { imageId: this.imageId, sessionId: this.sessionId });
   }
   /**
    * Get the underlying record
@@ -2859,7 +1652,8 @@ var RuntimeImage = class _RuntimeImage {
 };
 
 // src/internal/RuntimeContainer.ts
-var logger11 = createLogger("runtime/RuntimeContainer");
+var import_common9 = require("@agentxjs/common");
+var logger9 = (0, import_common9.createLogger)("runtime/RuntimeContainer");
 var RuntimeContainer = class _RuntimeContainer {
   containerId;
   createdAt;
@@ -2899,7 +1693,7 @@ var RuntimeContainer = class _RuntimeContainer {
         containerId
       }
     });
-    logger11.info("Container created", { containerId });
+    logger9.info("Container created", { containerId });
     return container;
   }
   /**
@@ -2908,7 +1702,7 @@ var RuntimeContainer = class _RuntimeContainer {
   static async load(containerId, context) {
     const record = await context.persistence.containers.findContainerById(containerId);
     if (!record) return null;
-    logger11.info("Container loaded", { containerId });
+    logger9.info("Container loaded", { containerId });
     return new _RuntimeContainer(containerId, record.createdAt, context);
   }
   // ==================== Image → Agent Lifecycle ====================
@@ -2921,7 +1715,7 @@ var RuntimeContainer = class _RuntimeContainer {
     if (existingAgentId) {
       const existingAgent = this.agents.get(existingAgentId);
       if (existingAgent) {
-        logger11.info("Reusing existing agent for image", {
+        logger9.info("Reusing existing agent for image", {
           containerId: this.containerId,
           imageId: image.imageId,
           agentId: existingAgentId
@@ -2933,6 +1727,7 @@ var RuntimeContainer = class _RuntimeContainer {
     const agentId = this.generateAgentId();
     const sandbox = new RuntimeSandbox({
       agentId,
+      imageId: image.imageId,
       containerId: this.containerId,
       basePath: this.context.basePath
     });
@@ -2980,7 +1775,7 @@ var RuntimeContainer = class _RuntimeContainer {
         agentId
       }
     });
-    logger11.info("Agent created for image", {
+    logger9.info("Agent created for image", {
       containerId: this.containerId,
       imageId: image.imageId,
       agentId
@@ -2993,17 +1788,17 @@ var RuntimeContainer = class _RuntimeContainer {
   async stopImage(imageId) {
     const agentId = this.imageToAgent.get(imageId);
     if (!agentId) {
-      logger11.debug("Image not running, nothing to stop", {
+      logger9.debug("Image not running, nothing to stop", {
         imageId,
         containerId: this.containerId
       });
       return false;
     }
-    logger11.info("Stopping image", { imageId, agentId, containerId: this.containerId });
+    logger9.info("Stopping image", { imageId, agentId, containerId: this.containerId });
     const success = await this.destroyAgent(agentId);
     if (success) {
       this.imageToAgent.delete(imageId);
-      logger11.info("Image stopped", { imageId, agentId, containerId: this.containerId });
+      logger9.info("Image stopped", { imageId, agentId, containerId: this.containerId });
     }
     return success;
   }
@@ -3060,7 +1855,7 @@ var RuntimeContainer = class _RuntimeContainer {
         agentId
       }
     });
-    logger11.info("Agent destroyed", { containerId: this.containerId, agentId });
+    logger9.info("Agent destroyed", { containerId: this.containerId, agentId });
     return true;
   }
   async destroyAllAgents() {
@@ -3088,7 +1883,7 @@ var RuntimeContainer = class _RuntimeContainer {
       }
     });
     this.context.onDisposed?.(this.containerId);
-    logger11.info("Container disposed", { containerId: this.containerId, agentCount });
+    logger9.info("Container disposed", { containerId: this.containerId, agentCount });
   }
   // ==================== Private Helpers ====================
   generateAgentId() {
@@ -3099,7 +1894,8 @@ var RuntimeContainer = class _RuntimeContainer {
 };
 
 // src/internal/BaseEventHandler.ts
-var logger12 = createLogger("runtime/BaseEventHandler");
+var import_common10 = require("@agentxjs/common");
+var logger10 = (0, import_common10.createLogger)("runtime/BaseEventHandler");
 var BaseEventHandler = class {
   bus;
   unsubscribes = [];
@@ -3138,7 +1934,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;
-    logger12.error(`Error in ${context.operation || "handler"}`, {
+    logger10.error(`Error in ${context.operation || "handler"}`, {
       message,
       requestId: context.requestId,
       details: context.details
@@ -3165,7 +1961,7 @@ var BaseEventHandler = class {
       try {
         context.onError(err);
       } catch (callbackErr) {
-        logger12.error("Error in onError callback", { error: callbackErr });
+        logger10.error("Error in onError callback", { error: callbackErr });
       }
     }
   }
@@ -3183,12 +1979,13 @@ var BaseEventHandler = class {
       unsubscribe();
     }
     this.unsubscribes = [];
-    logger12.debug(`${this.constructor.name} disposed`);
+    logger10.debug(`${this.constructor.name} disposed`);
   }
 };
 
 // src/internal/CommandHandler.ts
-var logger13 = createLogger("runtime/CommandHandler");
+var import_common11 = require("@agentxjs/common");
+var logger11 = (0, import_common11.createLogger)("runtime/CommandHandler");
 function createResponse(type, data) {
   return {
     type,
@@ -3221,7 +2018,7 @@ var CommandHandler = class extends BaseEventHandler {
     super(bus);
     this.ops = operations;
     this.bindHandlers();
-    logger13.debug("CommandHandler created");
+    logger11.debug("CommandHandler created");
   }
   /**
    * Log error and emit system_error event
@@ -3229,7 +2026,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;
-    logger13.error(operation, {
+    logger11.error(operation, {
       requestId,
       ...context,
       error: errorMessage,
@@ -3286,12 +2083,12 @@ var CommandHandler = class extends BaseEventHandler {
     this.subscribe(
       this.bus.onCommand("image_messages_request", (event) => this.handleImageMessages(event))
     );
-    logger13.debug("Command handlers bound");
+    logger11.debug("Command handlers bound");
   }
   // ==================== Container Handlers ====================
   async handleContainerCreate(event) {
     const { requestId, containerId } = event.data;
-    logger13.debug("Handling container_create_request", { requestId, containerId });
+    logger11.debug("Handling container_create_request", { requestId, containerId });
     try {
       await this.ops.createContainer(containerId);
       this.bus.emit(
@@ -3313,7 +2110,7 @@ var CommandHandler = class extends BaseEventHandler {
   }
   handleContainerGet(event) {
     const { requestId, containerId } = event.data;
-    logger13.debug("Handling container_get_request", { requestId, containerId });
+    logger11.debug("Handling container_get_request", { requestId, containerId });
     const container = this.ops.getContainer(containerId);
     this.bus.emit(
       createResponse("container_get_response", {
@@ -3325,7 +2122,7 @@ var CommandHandler = class extends BaseEventHandler {
   }
   handleContainerList(event) {
     const { requestId } = event.data;
-    logger13.debug("Handling container_list_request", { requestId });
+    logger11.debug("Handling container_list_request", { requestId });
     const containers = this.ops.listContainers();
     this.bus.emit(
       createResponse("container_list_response", {
@@ -3337,7 +2134,7 @@ var CommandHandler = class extends BaseEventHandler {
   // ==================== Agent Handlers ====================
   handleAgentGet(event) {
     const { requestId, agentId } = event.data;
-    logger13.debug("Handling agent_get_request", { requestId, agentId });
+    logger11.debug("Handling agent_get_request", { requestId, agentId });
     const agent = this.ops.getAgent(agentId);
     this.bus.emit(
       createResponse("agent_get_response", {
@@ -3350,7 +2147,7 @@ var CommandHandler = class extends BaseEventHandler {
   }
   handleAgentList(event) {
     const { requestId, containerId } = event.data;
-    logger13.debug("Handling agent_list_request", { requestId, containerId });
+    logger11.debug("Handling agent_list_request", { requestId, containerId });
     const agents = this.ops.listAgents(containerId);
     this.bus.emit(
       createResponse("agent_list_response", {
@@ -3365,7 +2162,7 @@ var CommandHandler = class extends BaseEventHandler {
   }
   async handleAgentDestroy(event) {
     const { requestId, agentId } = event.data;
-    logger13.debug("Handling agent_destroy_request", { requestId, agentId });
+    logger11.debug("Handling agent_destroy_request", { requestId, agentId });
     try {
       const success = await this.ops.destroyAgent(agentId);
       this.bus.emit(
@@ -3389,7 +2186,7 @@ var CommandHandler = class extends BaseEventHandler {
   }
   async handleAgentDestroyAll(event) {
     const { requestId, containerId } = event.data;
-    logger13.debug("Handling agent_destroy_all_request", { requestId, containerId });
+    logger11.debug("Handling agent_destroy_all_request", { requestId, containerId });
     try {
       await this.ops.destroyAllAgents(containerId);
       this.bus.emit(
@@ -3411,7 +2208,7 @@ var CommandHandler = class extends BaseEventHandler {
   }
   async handleMessageSend(event) {
     const { requestId, imageId, agentId, content } = event.data;
-    logger13.debug("Handling message_send_request", { requestId, imageId, agentId });
+    logger11.debug("Handling message_send_request", { requestId, imageId, agentId });
     try {
       const result = await this.ops.receiveMessage(imageId, agentId, content, requestId);
       this.bus.emit(
@@ -3435,7 +2232,7 @@ var CommandHandler = class extends BaseEventHandler {
   }
   handleAgentInterrupt(event) {
     const { requestId, imageId, agentId } = event.data;
-    logger13.debug("Handling agent_interrupt_request", { requestId, imageId, agentId });
+    logger11.debug("Handling agent_interrupt_request", { requestId, imageId, agentId });
     try {
       const result = this.ops.interruptAgent(imageId, agentId, requestId);
       this.bus.emit(
@@ -3460,7 +2257,7 @@ var CommandHandler = class extends BaseEventHandler {
   // ==================== Image Handlers ====================
   async handleImageCreate(event) {
     const { requestId, containerId, config } = event.data;
-    logger13.debug("Handling image_create_request", { requestId, containerId });
+    logger11.debug("Handling image_create_request", { requestId, containerId });
     try {
       const record = await this.ops.createImage(containerId, config);
       this.bus.emit(
@@ -3482,7 +2279,7 @@ var CommandHandler = class extends BaseEventHandler {
   }
   async handleImageRun(event) {
     const { requestId, imageId } = event.data;
-    logger13.debug("Handling image_run_request", { requestId, imageId });
+    logger11.debug("Handling image_run_request", { requestId, imageId });
     try {
       const result = await this.ops.runImage(imageId);
       this.bus.emit(
@@ -3508,7 +2305,7 @@ var CommandHandler = class extends BaseEventHandler {
   }
   async handleImageStop(event) {
     const { requestId, imageId } = event.data;
-    logger13.debug("Handling image_stop_request", { requestId, imageId });
+    logger11.debug("Handling image_stop_request", { requestId, imageId });
     try {
       await this.ops.stopImage(imageId);
       this.bus.emit(
@@ -3530,7 +2327,7 @@ var CommandHandler = class extends BaseEventHandler {
   }
   async handleImageUpdate(event) {
     const { requestId, imageId, updates } = event.data;
-    logger13.debug("Handling image_update_request", { requestId, imageId });
+    logger11.debug("Handling image_update_request", { requestId, imageId });
     try {
       const record = await this.ops.updateImage(imageId, updates);
       this.bus.emit(
@@ -3552,7 +2349,7 @@ var CommandHandler = class extends BaseEventHandler {
   }
   async handleImageList(event) {
     const { requestId, containerId } = event.data;
-    logger13.debug("Handling image_list_request", { requestId, containerId });
+    logger11.debug("Handling image_list_request", { requestId, containerId });
     try {
       const images = await this.ops.listImages(containerId);
       this.bus.emit(
@@ -3574,7 +2371,7 @@ var CommandHandler = class extends BaseEventHandler {
   }
   async handleImageGet(event) {
     const { requestId, imageId } = event.data;
-    logger13.debug("Handling image_get_request", { requestId, imageId });
+    logger11.debug("Handling image_get_request", { requestId, imageId });
     try {
       const image = await this.ops.getImage(imageId);
       this.bus.emit(
@@ -3595,7 +2392,7 @@ var CommandHandler = class extends BaseEventHandler {
   }
   async handleImageDelete(event) {
     const { requestId, imageId } = event.data;
-    logger13.debug("Handling image_delete_request", { requestId, imageId });
+    logger11.debug("Handling image_delete_request", { requestId, imageId });
     try {
       await this.ops.deleteImage(imageId);
       this.bus.emit(
@@ -3617,10 +2414,10 @@ var CommandHandler = class extends BaseEventHandler {
   }
   async handleImageMessages(event) {
     const { requestId, imageId } = event.data;
-    logger13.info("Handling image_messages_request", { requestId, imageId });
+    logger11.info("Handling image_messages_request", { requestId, imageId });
     try {
       const messages = await this.ops.getImageMessages(imageId);
-      logger13.info("Got messages for image", { imageId, count: messages.length });
+      logger11.info("Got messages for image", { imageId, count: messages.length });
       this.bus.emit(
         createResponse("image_messages_response", {
           requestId,
@@ -3628,7 +2425,7 @@ var CommandHandler = class extends BaseEventHandler {
           messages
         })
       );
-      logger13.info("Emitted image_messages_response", { requestId, imageId });
+      logger11.info("Emitted image_messages_response", { requestId, imageId });
     } catch (err) {
       this.emitError("Failed to get image messages", err, requestId, { imageId });
       this.bus.emit(
@@ -3645,9 +2442,8 @@ var CommandHandler = class extends BaseEventHandler {
 };
 
 // src/RuntimeImpl.ts
-var import_node_os = require("os");
-var import_node_path2 = require("path");
-var logger14 = createLogger("runtime/RuntimeImpl");
+var import_common12 = require("@agentxjs/common");
+var logger12 = (0, import_common12.createLogger)("runtime/RuntimeImpl");
 var RuntimeImpl = class {
   persistence;
   llmProvider;
@@ -3658,20 +2454,20 @@ var RuntimeImpl = class {
   /** Container registry: containerId -> RuntimeContainer */
   containerRegistry = /* @__PURE__ */ new Map();
   constructor(config) {
-    logger14.info("RuntimeImpl constructor start");
+    logger12.info("RuntimeImpl constructor start");
     this.persistence = config.persistence;
     this.llmProvider = config.llmProvider;
-    this.basePath = (0, import_node_path2.join)((0, import_node_os.homedir)(), ".agentx");
-    logger14.info("Creating SystemBus");
+    this.basePath = config.basePath;
+    logger12.info("Creating SystemBus");
     this.bus = new SystemBusImpl();
     this.llmConfig = this.llmProvider.provide();
-    logger14.info("LLM config loaded", {
+    logger12.info("LLM config loaded", {
       hasApiKey: !!this.llmConfig.apiKey,
       model: this.llmConfig.model
     });
-    logger14.info("Creating CommandHandler");
+    logger12.info("Creating CommandHandler");
     this.commandHandler = new CommandHandler(this.bus, this.createRuntimeOperations());
-    logger14.info("RuntimeImpl constructor done");
+    logger12.info("RuntimeImpl constructor done");
   }
   // ==================== SystemBus delegation ====================
   emit(event) {
@@ -3754,7 +2550,7 @@ var RuntimeImpl = class {
       // Agent operations (by imageId - with auto-activation)
       receiveMessage: async (imageId, agentId, content, requestId) => {
         if (imageId) {
-          logger14.debug("Receiving message by imageId", {
+          logger12.debug("Receiving message by imageId", {
             imageId,
             contentLength: content.length,
             requestId
@@ -3763,7 +2559,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);
-          logger14.info("Message routed to agent", {
+          logger12.info("Message routed to agent", {
             imageId,
             agentId: agent.agentId,
             reused,
@@ -3773,7 +2569,7 @@ var RuntimeImpl = class {
           return { agentId: agent.agentId, imageId };
         }
         if (agentId) {
-          logger14.debug("Receiving message by agentId (legacy)", {
+          logger12.debug("Receiving message by agentId (legacy)", {
             agentId,
             contentLength: content.length,
             requestId
@@ -3790,12 +2586,12 @@ var RuntimeImpl = class {
         if (imageId) {
           const foundAgentId = this.findAgentIdForImage(imageId);
           if (!foundAgentId) {
-            logger14.debug("Image is offline, nothing to interrupt", { imageId });
+            logger12.debug("Image is offline, nothing to interrupt", { imageId });
             return { imageId, agentId: void 0 };
           }
           const agent = this.findAgent(foundAgentId);
           if (agent) {
-            logger14.info("Interrupting agent by imageId", {
+            logger12.info("Interrupting agent by imageId", {
               imageId,
               agentId: foundAgentId,
               requestId
@@ -3807,7 +2603,7 @@ var RuntimeImpl = class {
         if (agentId) {
           const agent = this.findAgent(agentId);
           if (!agent) throw new Error(`Agent not found: ${agentId}`);
-          logger14.info("Interrupting agent by agentId (legacy)", { agentId, requestId });
+          logger12.info("Interrupting agent by agentId (legacy)", { agentId, requestId });
           agent.interrupt(requestId);
           const foundImageId = this.findImageIdForAgent(agentId);
           return { agentId, imageId: foundImageId };
@@ -3816,32 +2612,32 @@ var RuntimeImpl = class {
       },
       // Image operations (new model)
       createImage: async (containerId, config) => {
-        logger14.debug("Creating image", { containerId, name: config.name });
+        logger12.debug("Creating image", { containerId, name: config.name });
         await this.getOrCreateContainer(containerId);
         const image = await RuntimeImage.create(
           { containerId, ...config },
           this.createImageContext()
         );
-        logger14.info("Image created via RuntimeOps", { imageId: image.imageId, containerId });
+        logger12.info("Image created via RuntimeOps", { imageId: image.imageId, containerId });
         return this.toImageListItemResult(image.toRecord(), false);
       },
       runImage: async (imageId) => {
-        logger14.debug("Running image", { imageId });
+        logger12.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);
-        logger14.info("Image running", { imageId, agentId: agent.agentId, reused });
+        logger12.info("Image running", { imageId, agentId: agent.agentId, reused });
         return { imageId, agentId: agent.agentId, reused };
       },
       stopImage: async (imageId) => {
-        logger14.debug("Stopping image", { imageId });
+        logger12.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);
-          logger14.info("Image stopped via RuntimeOps", { imageId });
+          logger12.info("Image stopped via RuntimeOps", { imageId });
         }
       },
       updateImage: async (imageId, updates) => {
@@ -3865,10 +2661,10 @@ var RuntimeImpl = class {
         return this.toImageListItemResult(record, online);
       },
       deleteImage: async (imageId) => {
-        logger14.debug("Deleting image", { imageId });
+        logger12.debug("Deleting image", { imageId });
         const agentId = this.findAgentIdForImage(imageId);
         if (agentId) {
-          logger14.debug("Stopping running agent before delete", { imageId, agentId });
+          logger12.debug("Stopping running agent before delete", { imageId, agentId });
           for (const container of this.containerRegistry.values()) {
             if (container.getAgent(agentId)) {
               await container.destroyAgent(agentId);
@@ -3879,42 +2675,18 @@ var RuntimeImpl = class {
         const image = await RuntimeImage.load(imageId, this.createImageContext());
         if (image) {
           await image.delete();
-          logger14.info("Image deleted via RuntimeOps", { imageId });
+          logger12.info("Image deleted via RuntimeOps", { imageId });
         }
       },
       getImageMessages: async (imageId) => {
-        logger14.debug("Getting messages for image", { imageId });
+        logger12.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();
-        logger14.debug("Got messages from storage", { imageId, count: messages.length });
-        return messages.map((m) => {
-          let content;
-          let role = m.role;
-          let errorCode;
-          if (m.subtype === "user" || m.subtype === "assistant") {
-            content = m.content;
-          } else if (m.subtype === "tool-call") {
-            content = m.toolCall;
-            role = "tool_call";
-          } else if (m.subtype === "tool-result") {
-            content = m.toolResult;
-            role = "tool_result";
-          } else if (m.subtype === "error") {
-            content = m.content;
-            role = "error";
-            errorCode = m.errorCode;
-          }
-          return {
-            id: m.id,
-            role,
-            content,
-            timestamp: m.timestamp,
-            errorCode
-          };
-        });
+        logger12.debug("Got messages from storage", { imageId, count: messages.length });
+        return messages;
       }
     };
   }
@@ -4006,14 +2778,14 @@ var RuntimeImpl = class {
   }
   // ==================== Lifecycle ====================
   async dispose() {
-    logger14.info("Disposing RuntimeImpl");
+    logger12.info("Disposing RuntimeImpl");
     this.commandHandler.dispose();
     for (const container of this.containerRegistry.values()) {
       await container.dispose();
     }
     this.bus.destroy();
     this.containerRegistry.clear();
-    logger14.info("RuntimeImpl disposed");
+    logger12.info("RuntimeImpl disposed");
   }
 };
 
@@ -4024,9 +2796,11 @@ function createRuntime(config) {
 
 // src/internal/persistence/PersistenceImpl.ts
 var import_unstorage = require("unstorage");
+var import_common16 = require("@agentxjs/common");
 
 // src/internal/persistence/repository/StorageImageRepository.ts
-var logger15 = createLogger("persistence/ImageRepository");
+var import_common13 = require("@agentxjs/common");
+var logger13 = (0, import_common13.createLogger)("persistence/ImageRepository");
 var PREFIX = "images";
 var INDEX_BY_NAME = "idx:images:name";
 var INDEX_BY_CONTAINER = "idx:images:container";
@@ -4050,7 +2824,7 @@ var StorageImageRepository = class {
       this.containerIndexKey(record.containerId, record.imageId),
       record.imageId
     );
-    logger15.debug("Image saved", { imageId: record.imageId });
+    logger13.debug("Image saved", { imageId: record.imageId });
   }
   async findImageById(imageId) {
     const record = await this.storage.getItem(this.key(imageId));
@@ -4105,7 +2879,7 @@ var StorageImageRepository = class {
       await this.storage.removeItem(this.nameIndexKey(record.name, imageId));
       await this.storage.removeItem(this.containerIndexKey(record.containerId, imageId));
     }
-    logger15.debug("Image deleted", { imageId });
+    logger13.debug("Image deleted", { imageId });
   }
   async imageExists(imageId) {
     return await this.storage.hasItem(this.key(imageId));
@@ -4124,12 +2898,13 @@ var StorageImageRepository = class {
       updatedAt: Date.now()
     };
     await this.storage.setItem(this.key(imageId), updatedRecord);
-    logger15.debug("Image metadata updated", { imageId, metadata });
+    logger13.debug("Image metadata updated", { imageId, metadata });
   }
 };
 
 // src/internal/persistence/repository/StorageContainerRepository.ts
-var logger16 = createLogger("persistence/ContainerRepository");
+var import_common14 = require("@agentxjs/common");
+var logger14 = (0, import_common14.createLogger)("persistence/ContainerRepository");
 var PREFIX2 = "containers";
 var StorageContainerRepository = class {
   constructor(storage) {
@@ -4140,7 +2915,7 @@ var StorageContainerRepository = class {
   }
   async saveContainer(record) {
     await this.storage.setItem(this.key(record.containerId), record);
-    logger16.debug("Container saved", { containerId: record.containerId });
+    logger14.debug("Container saved", { containerId: record.containerId });
   }
   async findContainerById(containerId) {
     const record = await this.storage.getItem(this.key(containerId));
@@ -4159,7 +2934,7 @@ var StorageContainerRepository = class {
   }
   async deleteContainer(containerId) {
     await this.storage.removeItem(this.key(containerId));
-    logger16.debug("Container deleted", { containerId });
+    logger14.debug("Container deleted", { containerId });
   }
   async containerExists(containerId) {
     return await this.storage.hasItem(this.key(containerId));
@@ -4167,7 +2942,8 @@ var StorageContainerRepository = class {
 };
 
 // src/internal/persistence/repository/StorageSessionRepository.ts
-var logger17 = createLogger("persistence/SessionRepository");
+var import_common15 = require("@agentxjs/common");
+var logger15 = (0, import_common15.createLogger)("persistence/SessionRepository");
 var PREFIX3 = "sessions";
 var MESSAGES_PREFIX = "messages";
 var INDEX_BY_IMAGE = "idx:sessions:image";
@@ -4198,7 +2974,7 @@ var StorageSessionRepository = class {
       this.containerIndexKey(record.containerId, record.sessionId),
       record.sessionId
     );
-    logger17.debug("Session saved", { sessionId: record.sessionId });
+    logger15.debug("Session saved", { sessionId: record.sessionId });
   }
   async findSessionById(sessionId) {
     const record = await this.storage.getItem(this.key(sessionId));
@@ -4247,7 +3023,7 @@ var StorageSessionRepository = class {
       await this.storage.removeItem(this.imageIndexKey(record.imageId, sessionId));
       await this.storage.removeItem(this.containerIndexKey(record.containerId, sessionId));
     }
-    logger17.debug("Session deleted", { sessionId });
+    logger15.debug("Session deleted", { sessionId });
   }
   async sessionExists(sessionId) {
     return await this.storage.hasItem(this.key(sessionId));
@@ -4257,13 +3033,13 @@ var StorageSessionRepository = class {
     const messages = await this.getMessages(sessionId);
     messages.push(message);
     await this.storage.setItem(this.messagesKey(sessionId), messages);
-    logger17.debug("Message added to session", { sessionId, subtype: message.subtype });
+    logger15.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) {
-        logger17.warn("Messages data is not an array, resetting", {
+        logger15.warn("Messages data is not an array, resetting", {
           sessionId,
           type: typeof messages
         });
@@ -4274,12 +3050,12 @@ var StorageSessionRepository = class {
   }
   async clearMessages(sessionId) {
     await this.storage.removeItem(this.messagesKey(sessionId));
-    logger17.debug("Messages cleared for session", { sessionId });
+    logger15.debug("Messages cleared for session", { sessionId });
   }
 };
 
 // src/internal/persistence/PersistenceImpl.ts
-var logger18 = createLogger("persistence/Persistence");
+var logger16 = (0, import_common16.createLogger)("persistence/Persistence");
 var PersistenceImpl = class _PersistenceImpl {
   images;
   containers;
@@ -4293,7 +3069,7 @@ var PersistenceImpl = class _PersistenceImpl {
     this.images = new StorageImageRepository(this.storage);
     this.containers = new StorageContainerRepository(this.storage);
     this.sessions = new StorageSessionRepository(this.storage);
-    logger18.info("Persistence created", { driver: driverName });
+    logger16.info("Persistence created", { driver: driverName });
   }
   /**
    * Create a PersistenceImpl instance (async factory)
@@ -4314,7 +3090,7 @@ var PersistenceImpl = class _PersistenceImpl {
    */
   async dispose() {
     await this.storage.dispose();
-    logger18.info("Persistence disposed");
+    logger16.info("Persistence disposed");
   }
 };
 async function createStorageFromConfig(config) {