@agentxjs/runtime 1.5.11 → 1.6.0

package/dist/index.js

@@ -410,7 +410,7 @@ class AgentInteractor {
 }
 // src/internal/RuntimeAgent.ts
 import { createAgent } from "@agentxjs/agent";
-import { createLogger as createLogger7 } from "@agentxjs/common";
+import { createLogger as createLogger8 } from "@agentxjs/common";
 
 // src/environment/ClaudeReceptor.ts
 import { createLogger as createLogger4 } from "@agentxjs/common";
@@ -658,7 +658,76 @@ class ClaudeReceptor {
 }
 
 // src/environment/ClaudeEffector.ts
-import { query } from "@anthropic-ai/claude-agent-sdk";
+import { Subject as Subject3, TimeoutError } from "rxjs";
+import { timeout } from "rxjs/operators";
+import { createLogger as createLogger7 } from "@agentxjs/common";
+
+// src/environment/helpers.ts
+function isTextPart(part) {
+  return part.type === "text";
+}
+function isImagePart(part) {
+  return part.type === "image";
+}
+function isFilePart(part) {
+  return part.type === "file";
+}
+function buildSDKContent(message) {
+  if (typeof message.content === "string") {
+    return message.content;
+  }
+  if (!Array.isArray(message.content)) {
+    return "";
+  }
+  const parts = message.content;
+  const hasNonTextParts = parts.some((p) => !isTextPart(p));
+  if (!hasNonTextParts) {
+    return parts.filter(isTextPart).map((p) => p.text).join(`
+`);
+  }
+  return parts.map((part) => {
+    if (isTextPart(part)) {
+      return {
+        type: "text",
+        text: part.text
+      };
+    }
+    if (isImagePart(part)) {
+      return {
+        type: "image",
+        source: {
+          type: "base64",
+          media_type: part.mediaType,
+          data: part.data
+        }
+      };
+    }
+    if (isFilePart(part)) {
+      return {
+        type: "document",
+        source: {
+          type: "base64",
+          media_type: part.mediaType,
+          data: part.data
+        }
+      };
+    }
+    return { type: "text", text: "" };
+  });
+}
+function buildSDKUserMessage(message, sessionId) {
+  return {
+    type: "user",
+    message: { role: "user", content: buildSDKContent(message) },
+    parent_tool_use_id: null,
+    session_id: sessionId
+  };
+}
+
+// src/environment/SDKQueryLifecycle.ts
+import {
+  query
+} from "@anthropic-ai/claude-agent-sdk";
 import { Subject as Subject2 } from "rxjs";
 import { createLogger as createLogger6 } from "@agentxjs/common";
 
@@ -699,6 +768,7 @@ function buildOptions(context, abortController) {
   if (!env.PATH && process.env.PATH) {
     env.PATH = process.env.PATH;
   }
+  env.AGENTX_ENVIRONMENT = "true";
   if (context.baseUrl) {
     env.ANTHROPIC_BASE_URL = context.baseUrl;
   }
@@ -763,68 +833,6 @@ function buildOptions(context, abortController) {
   return options;
 }
 
-// src/environment/helpers.ts
-function isTextPart(part) {
-  return part.type === "text";
-}
-function isImagePart(part) {
-  return part.type === "image";
-}
-function isFilePart(part) {
-  return part.type === "file";
-}
-function buildSDKContent(message) {
-  if (typeof message.content === "string") {
-    return message.content;
-  }
-  if (!Array.isArray(message.content)) {
-    return "";
-  }
-  const parts = message.content;
-  const hasNonTextParts = parts.some((p) => !isTextPart(p));
-  if (!hasNonTextParts) {
-    return parts.filter(isTextPart).map((p) => p.text).join(`
-`);
-  }
-  return parts.map((part) => {
-    if (isTextPart(part)) {
-      return {
-        type: "text",
-        text: part.text
-      };
-    }
-    if (isImagePart(part)) {
-      return {
-        type: "image",
-        source: {
-          type: "base64",
-          media_type: part.mediaType,
-          data: part.data
-        }
-      };
-    }
-    if (isFilePart(part)) {
-      return {
-        type: "document",
-        source: {
-          type: "base64",
-          media_type: part.mediaType,
-          data: part.data
-        }
-      };
-    }
-    return { type: "text", text: "" };
-  });
-}
-function buildSDKUserMessage(message, sessionId) {
-  return {
-    type: "user",
-    message: { role: "user", content: buildSDKContent(message) },
-    parent_tool_use_id: null,
-    session_id: sessionId
-  };
-}
-
 // src/environment/observableToAsyncIterable.ts
 async function* observableToAsyncIterable(observable) {
   const queue = [];
@@ -889,97 +897,28 @@ async function* observableToAsyncIterable(observable) {
   }
 }
 
-// src/environment/ClaudeEffector.ts
-var logger6 = createLogger6("ecosystem/ClaudeEffector");
-var DEFAULT_TIMEOUT = 30000;
+// src/environment/SDKQueryLifecycle.ts
+var logger6 = createLogger6("environment/SDKQueryLifecycle");
 
-class ClaudeEffector {
+class SDKQueryLifecycle {
   config;
-  receptor;
+  callbacks;
   promptSubject = new Subject2;
-  currentAbortController = null;
   claudeQuery = null;
   isInitialized = false;
-  wasInterrupted = false;
-  currentMeta = null;
-  constructor(config, receptor) {
+  abortController = null;
+  constructor(config, callbacks = {}) {
     this.config = config;
-    this.receptor = receptor;
+    this.callbacks = callbacks;
   }
-  connect(consumer) {
-    logger6.debug("ClaudeEffector connected to SystemBusConsumer", {
-      agentId: this.config.agentId
-    });
-    consumer.on("user_message", async (event) => {
-      const typedEvent = event;
-      logger6.debug("user_message event received", {
-        eventAgentId: typedEvent.context?.agentId,
-        myAgentId: this.config.agentId,
-        matches: typedEvent.context?.agentId === this.config.agentId
-      });
-      if (typedEvent.context?.agentId !== this.config.agentId) {
-        return;
-      }
-      const message = typedEvent.data;
-      const meta = {
-        requestId: typedEvent.requestId || "",
-        context: typedEvent.context || {}
-      };
-      await this.send(message, meta);
-    });
-    consumer.on("interrupt", (event) => {
-      const typedEvent = event;
-      if (typedEvent.context?.agentId !== this.config.agentId) {
-        return;
-      }
-      const meta = {
-        requestId: typedEvent.requestId || "",
-        context: typedEvent.context || {}
-      };
-      this.interrupt(meta);
-    });
-  }
-  async send(message, meta) {
-    this.wasInterrupted = false;
-    this.currentAbortController = new AbortController;
-    this.currentMeta = meta;
-    const timeout = this.config.timeout ?? DEFAULT_TIMEOUT;
-    const timeoutId = setTimeout(() => {
-      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);
-      logger6.debug("Sending message to Claude", {
-        content: typeof message.content === "string" ? message.content.substring(0, 80) : "[structured]",
-        timeout,
-        requestId: meta.requestId
-      });
-      this.promptSubject.next(sdkUserMessage);
-    } finally {
-      clearTimeout(timeoutId);
-      this.currentAbortController = null;
-      this.wasInterrupted = false;
-    }
+  get initialized() {
+    return this.isInitialized;
   }
-  interrupt(meta) {
-    if (this.claudeQuery) {
-      logger6.debug("Interrupting Claude query", { requestId: meta?.requestId });
-      this.wasInterrupted = true;
-      if (meta) {
-        this.currentMeta = meta;
-      }
-      this.claudeQuery.interrupt().catch((err) => {
-        logger6.debug("SDK interrupt() error (may be expected)", { error: err });
-      });
-    }
-  }
-  async initialize(abortController) {
+  async initialize() {
     if (this.isInitialized)
       return;
-    logger6.info("Initializing ClaudeEffector");
+    logger6.info("Initializing SDKQueryLifecycle");
+    this.abortController = new AbortController;
     const context = {
       apiKey: this.config.apiKey,
       baseUrl: this.config.baseUrl,
@@ -989,7 +928,7 @@ class ClaudeEffector {
       resume: this.config.resumeSessionId,
       mcpServers: this.config.mcpServers
     };
-    const sdkOptions = buildOptions(context, abortController);
+    const sdkOptions = buildOptions(context, this.abortController);
     const promptStream = observableToAsyncIterable(this.promptSubject);
     this.claudeQuery = query({
       prompt: promptStream,
@@ -997,7 +936,47 @@ class ClaudeEffector {
     });
     this.isInitialized = true;
     this.startBackgroundListener();
-    logger6.info("ClaudeEffector initialized");
+    logger6.info("SDKQueryLifecycle initialized");
+  }
+  send(message) {
+    if (!this.isInitialized) {
+      throw new Error("SDKQueryLifecycle not initialized. Call initialize() first.");
+    }
+    this.promptSubject.next(message);
+  }
+  interrupt() {
+    if (this.claudeQuery) {
+      logger6.debug("Interrupting SDK query");
+      this.claudeQuery.interrupt().catch((err) => {
+        logger6.debug("SDK interrupt() error (may be expected)", { error: err });
+      });
+    }
+  }
+  reset() {
+    logger6.debug("Resetting SDKQueryLifecycle");
+    this.promptSubject.complete();
+    if (this.claudeQuery) {
+      this.claudeQuery.interrupt().catch((err) => {
+        logger6.debug("SDK interrupt() during reset (may be expected)", { error: err });
+      });
+    }
+    this.isInitialized = false;
+    this.claudeQuery = null;
+    this.abortController = null;
+    this.promptSubject = new Subject2;
+  }
+  dispose() {
+    logger6.debug("Disposing SDKQueryLifecycle");
+    if (this.claudeQuery) {
+      this.claudeQuery.interrupt().catch((err) => {
+        logger6.debug("SDK interrupt() during dispose (may be expected)", { error: err });
+      });
+    }
+    if (this.abortController) {
+      this.abortController.abort();
+    }
+    this.reset();
+    logger6.debug("SDKQueryLifecycle disposed");
   }
   startBackgroundListener() {
     (async () => {
@@ -1006,50 +985,36 @@ class ClaudeEffector {
           logger6.debug("SDK message received", {
             type: sdkMsg.type,
             subtype: sdkMsg.subtype,
-            sessionId: sdkMsg.session_id,
-            hasCurrentMeta: !!this.currentMeta
+            sessionId: sdkMsg.session_id
           });
-          if (sdkMsg.type === "stream_event" && this.currentMeta) {
-            this.receptor.feed(sdkMsg, this.currentMeta);
+          if (sdkMsg.session_id && this.callbacks.onSessionIdCaptured) {
+            this.callbacks.onSessionIdCaptured(sdkMsg.session_id);
           }
-          if (sdkMsg.type === "user" && this.currentMeta) {
-            this.receptor.feedUserMessage(sdkMsg, this.currentMeta);
+          if (sdkMsg.type === "stream_event") {
+            this.callbacks.onStreamEvent?.(sdkMsg);
           }
-          if (sdkMsg.session_id && this.config.onSessionIdCaptured) {
-            this.config.onSessionIdCaptured(sdkMsg.session_id);
+          if (sdkMsg.type === "user") {
+            this.callbacks.onUserMessage?.(sdkMsg);
           }
           if (sdkMsg.type === "result") {
-            const resultMsg = sdkMsg;
-            logger6.info("SDK result received (full)", {
-              fullResult: JSON.stringify(sdkMsg, null, 2)
-            });
             logger6.info("SDK result received", {
-              subtype: resultMsg.subtype,
-              isError: resultMsg.is_error,
-              errors: resultMsg.errors,
-              wasInterrupted: this.wasInterrupted
+              subtype: sdkMsg.subtype,
+              is_error: sdkMsg.is_error
             });
-            if (resultMsg.subtype === "error_during_execution" && this.wasInterrupted) {
-              this.receptor.emitInterrupted("user_interrupt", this.currentMeta || undefined);
-            } else if (resultMsg.is_error && this.currentMeta) {
-              const fullResult = sdkMsg;
-              const errorMessage = fullResult.error?.message || fullResult.errors?.join(", ") || (typeof fullResult.result === "string" ? fullResult.result : null) || "An error occurred";
-              const errorCode = fullResult.error?.type || resultMsg.subtype || "api_error";
-              this.receptor.emitError(errorMessage, errorCode, this.currentMeta);
-            }
+            this.callbacks.onResult?.(sdkMsg);
           }
         }
+        this.callbacks.onListenerExit?.("normal");
       } catch (error) {
         if (this.isAbortError(error)) {
           logger6.debug("Background listener aborted (expected during interrupt)");
-          this.resetState();
+          this.callbacks.onListenerExit?.("abort");
         } else {
           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);
-          }
+          this.callbacks.onError?.(error instanceof Error ? error : new Error(String(error)));
+          this.callbacks.onListenerExit?.("error");
         }
+        this.reset();
       }
     })();
   }
@@ -1064,18 +1029,176 @@ class ClaudeEffector {
     }
     return false;
   }
-  resetState() {
-    this.isInitialized = false;
-    this.claudeQuery = null;
-    this.promptSubject = new Subject2;
+}
+
+// src/environment/ClaudeEffector.ts
+var logger7 = createLogger7("environment/ClaudeEffector");
+var DEFAULT_TIMEOUT = 600000;
+
+class ClaudeEffector {
+  config;
+  receptor;
+  queryLifecycle;
+  currentMeta = null;
+  wasInterrupted = false;
+  pendingRequest$ = null;
+  pendingSubscription = null;
+  constructor(config, receptor) {
+    this.config = config;
+    this.receptor = receptor;
+    this.queryLifecycle = new SDKQueryLifecycle({
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl,
+      model: config.model,
+      systemPrompt: config.systemPrompt,
+      cwd: config.cwd,
+      resumeSessionId: config.resumeSessionId,
+      mcpServers: config.mcpServers
+    }, {
+      onStreamEvent: (msg) => this.handleStreamEvent(msg),
+      onUserMessage: (msg) => this.handleUserMessage(msg),
+      onResult: (msg) => this.handleResult(msg),
+      onSessionIdCaptured: config.onSessionIdCaptured,
+      onError: (error) => this.handleError(error),
+      onListenerExit: (reason) => this.handleListenerExit(reason)
+    });
   }
-  dispose() {
-    logger6.debug("Disposing ClaudeEffector");
-    if (this.currentAbortController) {
-      this.currentAbortController.abort();
+  connect(consumer) {
+    logger7.debug("ClaudeEffector connected to SystemBusConsumer", {
+      agentId: this.config.agentId
+    });
+    consumer.on("user_message", async (event) => {
+      const typedEvent = event;
+      if (typedEvent.context?.agentId !== this.config.agentId) {
+        return;
+      }
+      const message = typedEvent.data;
+      const meta = {
+        requestId: typedEvent.requestId || "",
+        context: typedEvent.context || {}
+      };
+      await this.send(message, meta);
+    });
+    consumer.on("interrupt", (event) => {
+      const typedEvent = event;
+      if (typedEvent.context?.agentId !== this.config.agentId) {
+        return;
+      }
+      const meta = {
+        requestId: typedEvent.requestId || "",
+        context: typedEvent.context || {}
+      };
+      this.interrupt(meta);
+    });
+  }
+  async send(message, meta) {
+    this.wasInterrupted = false;
+    this.currentMeta = meta;
+    this.cleanupPendingRequest();
+    const timeoutMs = this.config.timeout ?? DEFAULT_TIMEOUT;
+    try {
+      await this.queryLifecycle.initialize();
+      const sessionId = this.config.sessionId || "default";
+      const sdkUserMessage = buildSDKUserMessage(message, sessionId);
+      logger7.debug("Sending message to Claude", {
+        content: typeof message.content === "string" ? message.content.substring(0, 80) : "[structured]",
+        timeout: timeoutMs,
+        requestId: meta.requestId
+      });
+      this.pendingRequest$ = new Subject3;
+      this.pendingSubscription = this.pendingRequest$.pipe(timeout(timeoutMs)).subscribe({
+        complete: () => {
+          logger7.debug("Request completed within timeout", { requestId: meta.requestId });
+        },
+        error: (err) => {
+          if (err instanceof TimeoutError) {
+            logger7.warn("Request timeout", { timeout: timeoutMs, requestId: meta.requestId });
+            this.handleTimeout(meta);
+          }
+        }
+      });
+      this.queryLifecycle.send(sdkUserMessage);
+    } catch (error) {
+      this.cleanupPendingRequest();
+      throw error;
     }
-    this.promptSubject.complete();
-    this.resetState();
+  }
+  interrupt(meta) {
+    logger7.debug("Interrupting Claude query", { requestId: meta?.requestId });
+    this.wasInterrupted = true;
+    if (meta) {
+      this.currentMeta = meta;
+    }
+    this.queryLifecycle.interrupt();
+  }
+  handleStreamEvent(msg) {
+    if (this.currentMeta) {
+      this.receptor.feed(msg, this.currentMeta);
+    }
+  }
+  handleUserMessage(msg) {
+    if (this.currentMeta) {
+      this.receptor.feedUserMessage(msg, this.currentMeta);
+    }
+  }
+  handleResult(msg) {
+    this.completePendingRequest();
+    const resultMsg = msg;
+    logger7.info("SDK result received", {
+      subtype: resultMsg.subtype,
+      isError: resultMsg.is_error,
+      wasInterrupted: this.wasInterrupted
+    });
+    if (resultMsg.subtype === "error_during_execution" && this.wasInterrupted) {
+      this.receptor.emitInterrupted("user_interrupt", this.currentMeta || undefined);
+      return;
+    }
+    if (resultMsg.is_error && this.currentMeta) {
+      const errorMessage = resultMsg.error?.message || resultMsg.errors?.join(", ") || (typeof resultMsg.result === "string" ? resultMsg.result : null) || "An error occurred";
+      const errorCode = resultMsg.error?.type || resultMsg.subtype || "api_error";
+      this.receptor.emitError(errorMessage, errorCode, this.currentMeta);
+    }
+  }
+  handleError(error) {
+    this.cleanupPendingRequest();
+    if (this.currentMeta) {
+      this.receptor.emitError(error.message, "runtime_error", this.currentMeta);
+    }
+  }
+  handleListenerExit(reason) {
+    logger7.debug("SDK listener exited", { reason });
+    this.cleanupPendingRequest();
+  }
+  handleTimeout(meta) {
+    this.wasInterrupted = true;
+    this.queryLifecycle.interrupt();
+    this.receptor.emitError(`Request timeout after ${this.config.timeout ?? DEFAULT_TIMEOUT}ms`, "timeout", meta);
+  }
+  cleanupPendingRequest() {
+    if (this.pendingSubscription) {
+      this.pendingSubscription.unsubscribe();
+      this.pendingSubscription = null;
+    }
+    if (this.pendingRequest$) {
+      this.pendingRequest$.complete();
+      this.pendingRequest$ = null;
+    }
+  }
+  completePendingRequest() {
+    if (this.pendingRequest$) {
+      this.pendingRequest$.complete();
+      this.pendingRequest$ = null;
+    }
+    if (this.pendingSubscription) {
+      this.pendingSubscription.unsubscribe();
+      this.pendingSubscription = null;
+    }
+  }
+  dispose() {
+    logger7.debug("Disposing ClaudeEffector", { agentId: this.config.agentId });
+    this.cleanupPendingRequest();
+    this.queryLifecycle.dispose();
+    logger7.debug("ClaudeEffector disposed", { agentId: this.config.agentId });
   }
 }
 
@@ -1097,7 +1220,7 @@ class ClaudeEnvironment {
   }
 }
 // src/internal/RuntimeAgent.ts
-var logger7 = createLogger7("runtime/RuntimeAgent");
+var logger8 = createLogger8("runtime/RuntimeAgent");
 
 class BusPresenter {
   producer;
@@ -1140,7 +1263,7 @@ class BusPresenter {
     this.producer.emit(systemEvent);
     if (category === "message") {
       this.session.addMessage(data).catch((err) => {
-        logger7.error("Failed to persist message", { error: err, messageType: output.type });
+        logger8.error("Failed to persist message", { error: err, messageType: output.type });
       });
     }
   }
@@ -1203,7 +1326,7 @@ class RuntimeAgent {
     });
     this.environment.receptor.connect(config.bus.asProducer());
     this.environment.effector.connect(config.bus.asConsumer());
-    logger7.info("ClaudeEnvironment created for agent", {
+    logger8.info("ClaudeEnvironment created for agent", {
       agentId: this.agentId,
       imageId: this.imageId,
       cwd: config.sandbox.workdir.path,
@@ -1230,26 +1353,26 @@ class RuntimeAgent {
     this.driver = new BusDriver(config.bus.asConsumer(), {
       agentId: this.agentId,
       onStreamEvent: (event) => {
-        logger7.debug("BusDriver → Engine.handleStreamEvent", { type: event.type });
+        logger8.debug("BusDriver → Engine.handleStreamEvent", { type: event.type });
         this.engine.handleStreamEvent(event);
       },
       onStreamComplete: (reason) => {
-        logger7.debug("Stream completed", { reason, agentId: this.agentId });
+        logger8.debug("Stream completed", { reason, agentId: this.agentId });
       }
     });
-    logger7.debug("RuntimeAgent created", {
+    logger8.debug("RuntimeAgent created", {
       agentId: this.agentId,
       imageId: this.imageId
     });
   }
   saveSessionId(sdkSessionId) {
-    logger7.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) => {
-      logger7.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() {
@@ -1257,7 +1380,7 @@ class RuntimeAgent {
   }
   async receive(content, requestId) {
     const contentPreview = typeof content === "string" ? content.substring(0, 50) : `[${content.length} parts]`;
-    logger7.debug("RuntimeAgent.receive called", {
+    logger8.debug("RuntimeAgent.receive called", {
       agentId: this.agentId,
       contentPreview,
       requestId
@@ -1266,10 +1389,10 @@ class RuntimeAgent {
       throw new Error(`Cannot send message to ${this._lifecycle} agent`);
     }
     await this.interactor.receive(content, requestId || `req_${Date.now()}`);
-    logger7.debug("RuntimeAgent.receive completed", { agentId: this.agentId });
+    logger8.debug("RuntimeAgent.receive completed", { agentId: this.agentId });
   }
   interrupt(requestId) {
-    logger7.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",
@@ -1448,8 +1571,8 @@ class RuntimeSandbox {
   async cleanup() {}
 }
 // src/internal/RuntimeImage.ts
-import { createLogger as createLogger8 } from "@agentxjs/common";
-var logger8 = createLogger8("runtime/RuntimeImage");
+import { createLogger as createLogger9 } from "@agentxjs/common";
+var logger9 = createLogger9("runtime/RuntimeImage");
 
 class RuntimeImage {
   record;
@@ -1508,7 +1631,7 @@ class RuntimeImage {
       createdAt: now,
       updatedAt: now
     });
-    logger8.info("Image created", {
+    logger9.info("Image created", {
       imageId,
       sessionId,
       containerId: config.containerId,
@@ -1519,10 +1642,10 @@ class RuntimeImage {
   static async load(imageId, context) {
     const record = await context.imageRepository.findImageById(imageId);
     if (!record) {
-      logger8.debug("Image not found", { imageId });
+      logger9.debug("Image not found", { imageId });
       return null;
     }
-    logger8.debug("Image loaded", { imageId, name: record.name });
+    logger9.debug("Image loaded", { imageId, name: record.name });
     return new RuntimeImage(record, context);
   }
   static async listByContainer(containerId, context) {
@@ -1543,13 +1666,13 @@ class RuntimeImage {
       updatedAt: now
     };
     await this.context.imageRepository.saveImage(updatedRecord);
-    logger8.info("Image updated", { imageId: this.imageId, updates });
+    logger9.info("Image updated", { imageId: this.imageId, updates });
     return new RuntimeImage(updatedRecord, this.context);
   }
   async delete() {
     await this.context.sessionRepository.deleteSession(this.sessionId);
     await this.context.imageRepository.deleteImage(this.imageId);
-    logger8.info("Image deleted", { imageId: this.imageId, sessionId: this.sessionId });
+    logger9.info("Image deleted", { imageId: this.imageId, sessionId: this.sessionId });
   }
   toRecord() {
     return { ...this.record };
@@ -1566,8 +1689,8 @@ class RuntimeImage {
   }
 }
 // src/internal/RuntimeContainer.ts
-import { createLogger as createLogger9 } from "@agentxjs/common";
-var logger9 = createLogger9("runtime/RuntimeContainer");
+import { createLogger as createLogger10 } from "@agentxjs/common";
+var logger10 = createLogger10("runtime/RuntimeContainer");
 
 class RuntimeContainer {
   containerId;
@@ -1603,14 +1726,14 @@ class RuntimeContainer {
         containerId
       }
     });
-    logger9.info("Container created", { containerId });
+    logger10.info("Container created", { containerId });
     return container;
   }
   static async load(containerId, context) {
     const record = await context.persistence.containers.findContainerById(containerId);
     if (!record)
       return null;
-    logger9.info("Container loaded", { containerId });
+    logger10.info("Container loaded", { containerId });
     return new RuntimeContainer(containerId, record.createdAt, context);
   }
   async runImage(image) {
@@ -1618,7 +1741,7 @@ class RuntimeContainer {
     if (existingAgentId) {
       const existingAgent = this.agents.get(existingAgentId);
       if (existingAgent) {
-        logger9.info("Reusing existing agent for image", {
+        logger10.info("Reusing existing agent for image", {
           containerId: this.containerId,
           imageId: image.imageId,
           agentId: existingAgentId
@@ -1673,7 +1796,7 @@ class RuntimeContainer {
         agentId
       }
     });
-    logger9.info("Agent created for image", {
+    logger10.info("Agent created for image", {
       containerId: this.containerId,
       imageId: image.imageId,
       agentId
@@ -1683,17 +1806,17 @@ class RuntimeContainer {
   async stopImage(imageId) {
     const agentId = this.imageToAgent.get(imageId);
     if (!agentId) {
-      logger9.debug("Image not running, nothing to stop", {
+      logger10.debug("Image not running, nothing to stop", {
         imageId,
         containerId: this.containerId
       });
       return false;
     }
-    logger9.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);
-      logger9.info("Image stopped", { imageId, agentId, containerId: this.containerId });
+      logger10.info("Image stopped", { imageId, agentId, containerId: this.containerId });
     }
     return success;
   }
@@ -1742,7 +1865,7 @@ class RuntimeContainer {
         agentId
       }
     });
-    logger9.info("Agent destroyed", { containerId: this.containerId, agentId });
+    logger10.info("Agent destroyed", { containerId: this.containerId, agentId });
     return true;
   }
   async destroyAllAgents() {
@@ -1769,7 +1892,7 @@ class RuntimeContainer {
       }
     });
     this.context.onDisposed?.(this.containerId);
-    logger9.info("Container disposed", { containerId: this.containerId, agentCount });
+    logger10.info("Container disposed", { containerId: this.containerId, agentCount });
   }
   generateAgentId() {
     const timestamp = Date.now().toString(36);
@@ -1778,8 +1901,8 @@ class RuntimeContainer {
   }
 }
 // src/internal/BaseEventHandler.ts
-import { createLogger as createLogger10 } from "@agentxjs/common";
-var logger10 = createLogger10("runtime/BaseEventHandler");
+import { createLogger as createLogger11 } from "@agentxjs/common";
+var logger11 = createLogger11("runtime/BaseEventHandler");
 
 class BaseEventHandler {
   bus;
@@ -1806,7 +1929,7 @@ class BaseEventHandler {
   handleError(err, context) {
     const message = err instanceof Error ? err.message : String(err);
     const stack = err instanceof Error ? err.stack : undefined;
-    logger10.error(`Error in ${context.operation || "handler"}`, {
+    logger11.error(`Error in ${context.operation || "handler"}`, {
       message,
       requestId: context.requestId,
       details: context.details
@@ -1833,7 +1956,7 @@ class BaseEventHandler {
       try {
         context.onError(err);
       } catch (callbackErr) {
-        logger10.error("Error in onError callback", { error: callbackErr });
+        logger11.error("Error in onError callback", { error: callbackErr });
       }
     }
   }
@@ -1845,13 +1968,13 @@ class BaseEventHandler {
       unsubscribe();
     }
     this.unsubscribes = [];
-    logger10.debug(`${this.constructor.name} disposed`);
+    logger11.debug(`${this.constructor.name} disposed`);
   }
 }
 
 // src/internal/CommandHandler.ts
-import { createLogger as createLogger11 } from "@agentxjs/common";
-var logger11 = createLogger11("runtime/CommandHandler");
+import { createLogger as createLogger12 } from "@agentxjs/common";
+var logger12 = createLogger12("runtime/CommandHandler");
 function createResponse(type, data) {
   return {
     type,
@@ -1885,12 +2008,12 @@ class CommandHandler extends BaseEventHandler {
     super(bus);
     this.ops = operations;
     this.bindHandlers();
-    logger11.debug("CommandHandler created");
+    logger12.debug("CommandHandler created");
   }
   emitError(operation, err, requestId, context) {
     const errorMessage = err instanceof Error ? err.message : String(err);
     const stack = err instanceof Error ? err.stack : undefined;
-    logger11.error(operation, {
+    logger12.error(operation, {
       requestId,
       ...context,
       error: errorMessage,
@@ -1916,11 +2039,11 @@ class CommandHandler extends BaseEventHandler {
     this.subscribe(this.bus.onCommand("image_get_request", (event) => this.handleImageGet(event)));
     this.subscribe(this.bus.onCommand("image_delete_request", (event) => this.handleImageDelete(event)));
     this.subscribe(this.bus.onCommand("image_messages_request", (event) => this.handleImageMessages(event)));
-    logger11.debug("Command handlers bound");
+    logger12.debug("Command handlers bound");
   }
   async handleContainerCreate(event) {
     const { requestId, containerId } = event.data;
-    logger11.debug("Handling container_create_request", { requestId, containerId });
+    logger12.debug("Handling container_create_request", { requestId, containerId });
     try {
       await this.ops.createContainer(containerId);
       this.bus.emit(createResponse("container_create_response", {
@@ -1938,7 +2061,7 @@ class CommandHandler extends BaseEventHandler {
   }
   handleContainerGet(event) {
     const { requestId, containerId } = event.data;
-    logger11.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", {
       requestId,
@@ -1948,7 +2071,7 @@ class CommandHandler extends BaseEventHandler {
   }
   handleContainerList(event) {
     const { requestId } = event.data;
-    logger11.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", {
       requestId,
@@ -1957,7 +2080,7 @@ class CommandHandler extends BaseEventHandler {
   }
   handleAgentGet(event) {
     const { requestId, agentId } = event.data;
-    logger11.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", {
       requestId,
@@ -1968,7 +2091,7 @@ class CommandHandler extends BaseEventHandler {
   }
   handleAgentList(event) {
     const { requestId, containerId } = event.data;
-    logger11.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", {
       requestId,
@@ -1981,7 +2104,7 @@ class CommandHandler extends BaseEventHandler {
   }
   async handleAgentDestroy(event) {
     const { requestId, agentId } = event.data;
-    logger11.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(createResponse("agent_destroy_response", {
@@ -2001,7 +2124,7 @@ class CommandHandler extends BaseEventHandler {
   }
   async handleAgentDestroyAll(event) {
     const { requestId, containerId } = event.data;
-    logger11.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(createResponse("agent_destroy_all_response", {
@@ -2019,7 +2142,7 @@ class CommandHandler extends BaseEventHandler {
   }
   async handleMessageSend(event) {
     const { requestId, imageId, agentId, content } = event.data;
-    logger11.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(createResponse("message_send_response", {
@@ -2039,7 +2162,7 @@ class CommandHandler extends BaseEventHandler {
   }
   handleAgentInterrupt(event) {
     const { requestId, imageId, agentId } = event.data;
-    logger11.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(createResponse("agent_interrupt_response", {
@@ -2059,7 +2182,7 @@ class CommandHandler extends BaseEventHandler {
   }
   async handleImageCreate(event) {
     const { requestId, containerId, config } = event.data;
-    logger11.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(createResponse("image_create_response", {
@@ -2077,7 +2200,7 @@ class CommandHandler extends BaseEventHandler {
   }
   async handleImageRun(event) {
     const { requestId, imageId } = event.data;
-    logger11.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(createResponse("image_run_response", {
@@ -2099,7 +2222,7 @@ class CommandHandler extends BaseEventHandler {
   }
   async handleImageStop(event) {
     const { requestId, imageId } = event.data;
-    logger11.debug("Handling image_stop_request", { requestId, imageId });
+    logger12.debug("Handling image_stop_request", { requestId, imageId });
     try {
       await this.ops.stopImage(imageId);
       this.bus.emit(createResponse("image_stop_response", {
@@ -2117,7 +2240,7 @@ class CommandHandler extends BaseEventHandler {
   }
   async handleImageUpdate(event) {
     const { requestId, imageId, updates } = event.data;
-    logger11.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(createResponse("image_update_response", {
@@ -2135,7 +2258,7 @@ class CommandHandler extends BaseEventHandler {
   }
   async handleImageList(event) {
     const { requestId, containerId } = event.data;
-    logger11.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(createResponse("image_list_response", {
@@ -2153,7 +2276,7 @@ class CommandHandler extends BaseEventHandler {
   }
   async handleImageGet(event) {
     const { requestId, imageId } = event.data;
-    logger11.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(createResponse("image_get_response", {
@@ -2170,7 +2293,7 @@ class CommandHandler extends BaseEventHandler {
   }
   async handleImageDelete(event) {
     const { requestId, imageId } = event.data;
-    logger11.debug("Handling image_delete_request", { requestId, imageId });
+    logger12.debug("Handling image_delete_request", { requestId, imageId });
     try {
       await this.ops.deleteImage(imageId);
       this.bus.emit(createResponse("image_delete_response", {
@@ -2188,16 +2311,16 @@ class CommandHandler extends BaseEventHandler {
   }
   async handleImageMessages(event) {
     const { requestId, imageId } = event.data;
-    logger11.info("Handling image_messages_request", { requestId, imageId });
+    logger12.info("Handling image_messages_request", { requestId, imageId });
     try {
       const messages = await this.ops.getImageMessages(imageId);
-      logger11.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,
         imageId,
         messages
       }));
-      logger11.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(createResponse("image_messages_response", {
@@ -2210,8 +2333,8 @@ class CommandHandler extends BaseEventHandler {
   }
 }
 // src/RuntimeImpl.ts
-import { createLogger as createLogger12 } from "@agentxjs/common";
-var logger12 = createLogger12("runtime/RuntimeImpl");
+import { createLogger as createLogger13 } from "@agentxjs/common";
+var logger13 = createLogger13("runtime/RuntimeImpl");
 
 class RuntimeImpl {
   persistence;
@@ -2223,21 +2346,21 @@ class RuntimeImpl {
   defaultAgent;
   containerRegistry = new Map;
   constructor(config) {
-    logger12.info("RuntimeImpl constructor start");
+    logger13.info("RuntimeImpl constructor start");
     this.persistence = config.persistence;
     this.llmProvider = config.llmProvider;
     this.basePath = config.basePath;
     this.defaultAgent = config.defaultAgent;
-    logger12.info("Creating SystemBus");
+    logger13.info("Creating SystemBus");
     this.bus = new SystemBusImpl;
     this.llmConfig = this.llmProvider.provide();
-    logger12.info("LLM config loaded", {
+    logger13.info("LLM config loaded", {
       hasApiKey: !!this.llmConfig.apiKey,
       model: this.llmConfig.model
     });
-    logger12.info("Creating CommandHandler");
+    logger13.info("Creating CommandHandler");
     this.commandHandler = new CommandHandler(this.bus, this.createRuntimeOperations());
-    logger12.info("RuntimeImpl constructor done");
+    logger13.info("RuntimeImpl constructor done");
   }
   emit(event) {
     this.bus.emit(event);
@@ -2260,8 +2383,8 @@ class RuntimeImpl {
   emitCommand(type, data) {
     this.bus.emitCommand(type, data);
   }
-  request(type, data, timeout) {
-    return this.bus.request(type, data, timeout);
+  request(type, data, timeout2) {
+    return this.bus.request(type, data, timeout2);
   }
   asConsumer() {
     return this.bus.asConsumer();
@@ -2317,7 +2440,7 @@ class RuntimeImpl {
       },
       receiveMessage: async (imageId, agentId, content, requestId) => {
         if (imageId) {
-          logger12.debug("Receiving message by imageId", {
+          logger13.debug("Receiving message by imageId", {
             imageId,
             contentLength: content.length,
             requestId
@@ -2327,7 +2450,7 @@ class RuntimeImpl {
             throw new Error(`Image not found: ${imageId}`);
           const container = await this.getOrCreateContainer(record.containerId);
           const { agent, reused } = await container.runImage(record);
-          logger12.info("Message routed to agent", {
+          logger13.info("Message routed to agent", {
             imageId,
             agentId: agent.agentId,
             reused,
@@ -2337,7 +2460,7 @@ class RuntimeImpl {
           return { agentId: agent.agentId, imageId };
         }
         if (agentId) {
-          logger12.debug("Receiving message by agentId (legacy)", {
+          logger13.debug("Receiving message by agentId (legacy)", {
             agentId,
             contentLength: content.length,
             requestId
@@ -2355,12 +2478,12 @@ class RuntimeImpl {
         if (imageId) {
           const foundAgentId = this.findAgentIdForImage(imageId);
           if (!foundAgentId) {
-            logger12.debug("Image is offline, nothing to interrupt", { imageId });
+            logger13.debug("Image is offline, nothing to interrupt", { imageId });
             return { imageId, agentId: undefined };
           }
           const agent = this.findAgent(foundAgentId);
           if (agent) {
-            logger12.info("Interrupting agent by imageId", {
+            logger13.info("Interrupting agent by imageId", {
               imageId,
               agentId: foundAgentId,
               requestId
@@ -2373,7 +2496,7 @@ class RuntimeImpl {
           const agent = this.findAgent(agentId);
           if (!agent)
             throw new Error(`Agent not found: ${agentId}`);
-          logger12.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 };
@@ -2381,7 +2504,7 @@ class RuntimeImpl {
         throw new Error("Either imageId or agentId must be provided");
       },
       createImage: async (containerId, config) => {
-        logger12.debug("Creating image", { containerId, name: config.name });
+        logger13.debug("Creating image", { containerId, name: config.name });
         await this.getOrCreateContainer(containerId);
         const mergedConfig = {
           containerId,
@@ -2390,35 +2513,35 @@ class RuntimeImpl {
           systemPrompt: config.systemPrompt ?? this.defaultAgent?.systemPrompt,
           mcpServers: config.mcpServers ?? this.defaultAgent?.mcpServers
         };
-        logger12.debug("Merged config for image creation", {
+        logger13.debug("Merged config for image creation", {
           containerId,
           name: mergedConfig.name,
           hasSystemPrompt: !!mergedConfig.systemPrompt,
           mcpServers: mergedConfig.mcpServers ? Object.keys(mergedConfig.mcpServers) : []
         });
         const image = await RuntimeImage.create(mergedConfig, this.createImageContext());
-        logger12.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) => {
-        logger12.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);
-        logger12.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) => {
-        logger12.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);
-          logger12.info("Image stopped via RuntimeOps", { imageId });
+          logger13.info("Image stopped via RuntimeOps", { imageId });
         }
       },
       updateImage: async (imageId, updates) => {
@@ -2444,10 +2567,10 @@ class RuntimeImpl {
         return this.toImageListItemResult(record, online);
       },
       deleteImage: async (imageId) => {
-        logger12.debug("Deleting image", { imageId });
+        logger13.debug("Deleting image", { imageId });
         const agentId = this.findAgentIdForImage(imageId);
         if (agentId) {
-          logger12.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);
@@ -2458,17 +2581,17 @@ class RuntimeImpl {
         const image = await RuntimeImage.load(imageId, this.createImageContext());
         if (image) {
           await image.delete();
-          logger12.info("Image deleted via RuntimeOps", { imageId });
+          logger13.info("Image deleted via RuntimeOps", { imageId });
         }
       },
       getImageMessages: async (imageId) => {
-        logger12.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();
-        logger12.debug("Got messages from storage", { imageId, count: messages.length });
+        logger13.debug("Got messages from storage", { imageId, count: messages.length });
         return messages;
       }
     };
@@ -2551,14 +2674,14 @@ class RuntimeImpl {
     };
   }
   async dispose() {
-    logger12.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();
-    logger12.info("RuntimeImpl disposed");
+    logger13.info("RuntimeImpl disposed");
   }
 }
 
@@ -2576,4 +2699,4 @@ export {
   RuntimeEnvironment
 };
 
-//# debugId=EF327BE366CB379364756E2164756E21
+//# debugId=C63126293F6B51AD64756E2164756E21