agentxjs 1.9.9-dev → 2.0.0

package/dist/index.js

@@ -1,174 +1,281 @@
 // src/RemoteClient.ts
 import { EventBusImpl } from "@agentxjs/core/event";
 import { RpcClient } from "@agentxjs/core/network";
+import { createLogger } from "commonxjs/logger";
 
-// ../../node_modules/commonxjs/dist/logger/index.js
-var ConsoleLogger = class _ConsoleLogger {
-  name;
-  level;
-  colors;
-  timestamps;
-  static COLORS = {
-    DEBUG: "\x1B[36m",
-    INFO: "\x1B[32m",
-    WARN: "\x1B[33m",
-    ERROR: "\x1B[31m",
-    RESET: "\x1B[0m"
-  };
-  constructor(name, options = {}) {
-    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);
+// src/namespaces/containers.ts
+function createLocalContainers(platform) {
+  return {
+    async create(containerId) {
+      const { getOrCreateContainer } = await import("@agentxjs/core/container");
+      const { containerRepository, imageRepository, sessionRepository } = platform;
+      const container = await getOrCreateContainer(containerId, {
+        containerRepository,
+        imageRepository,
+        sessionRepository
+      });
+      return { containerId: container.containerId, requestId: "" };
+    },
+    async get(containerId) {
+      const exists = await platform.containerRepository.containerExists(containerId);
+      return { containerId, exists, requestId: "" };
+    },
+    async list() {
+      const containers = await platform.containerRepository.findAllContainers();
+      return { containerIds: containers.map((c) => c.containerId), requestId: "" };
     }
-  }
-  warn(message, context) {
-    if (this.isWarnEnabled()) {
-      this.log("WARN", message, context);
+  };
+}
+function createRemoteContainers(rpcClient) {
+  return {
+    async create(containerId) {
+      const result = await rpcClient.call("container.create", {
+        containerId
+      });
+      return { ...result, requestId: "" };
+    },
+    async get(containerId) {
+      const result = await rpcClient.call("container.get", {
+        containerId
+      });
+      return { ...result, requestId: "" };
+    },
+    async list() {
+      const result = await rpcClient.call("container.list", {});
+      return { ...result, requestId: "" };
     }
-  }
-  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);
+  };
+}
+
+// src/namespaces/images.ts
+function createLocalImages(platform) {
+  return {
+    async create(params) {
+      const { imageRepository, sessionRepository } = platform;
+      const { createImage } = await import("@agentxjs/core/image");
+      const image = await createImage(
+        {
+          containerId: params.containerId,
+          name: params.name,
+          description: params.description,
+          systemPrompt: params.systemPrompt,
+          mcpServers: params.mcpServers,
+          customData: params.customData
+        },
+        { imageRepository, sessionRepository }
+      );
+      return {
+        record: image.toRecord(),
+        __subscriptions: [image.sessionId],
+        requestId: ""
+      };
+    },
+    async get(imageId) {
+      const record = await platform.imageRepository.findImageById(imageId);
+      return {
+        record,
+        __subscriptions: record?.sessionId ? [record.sessionId] : void 0,
+        requestId: ""
+      };
+    },
+    async list(containerId) {
+      const records = containerId ? await platform.imageRepository.findImagesByContainerId(containerId) : await platform.imageRepository.findAllImages();
+      return {
+        records,
+        __subscriptions: records.map((r) => r.sessionId),
+        requestId: ""
+      };
+    },
+    async update(imageId, updates) {
+      const { loadImage } = await import("@agentxjs/core/image");
+      const { imageRepository, sessionRepository } = platform;
+      const image = await loadImage(imageId, { imageRepository, sessionRepository });
+      if (!image) {
+        throw new Error(`Image not found: ${imageId}`);
       }
+      const updated = await image.update(updates);
+      return { record: updated.toRecord(), requestId: "" };
+    },
+    async delete(imageId) {
+      const { loadImage } = await import("@agentxjs/core/image");
+      const { imageRepository, sessionRepository } = platform;
+      const image = await loadImage(imageId, { imageRepository, sessionRepository });
+      if (image) {
+        await image.delete();
+      }
+      return { requestId: "" };
     }
-  }
-  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 = _ConsoleLogger.COLORS[level];
-      parts.push(`${color}${level.padEnd(5)}${_ConsoleLogger.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);
+  };
+}
+function createRemoteImages(rpcClient, subscribeFn) {
+  return {
+    async create(params) {
+      const result = await rpcClient.call("image.create", params);
+      if (result.__subscriptions) {
+        for (const sessionId of result.__subscriptions) {
+          subscribeFn(sessionId);
+        }
+      }
+      return { ...result, requestId: "" };
+    },
+    async get(imageId) {
+      const result = await rpcClient.call("image.get", { imageId });
+      if (result.__subscriptions) {
+        for (const sessionId of result.__subscriptions) {
+          subscribeFn(sessionId);
+        }
+      }
+      return { ...result, requestId: "" };
+    },
+    async list(containerId) {
+      const result = await rpcClient.call("image.list", { containerId });
+      if (result.__subscriptions) {
+        for (const sessionId of result.__subscriptions) {
+          subscribeFn(sessionId);
+        }
+      }
+      return { ...result, requestId: "" };
+    },
+    async update(imageId, updates) {
+      const result = await rpcClient.call("image.update", {
+        imageId,
+        updates
+      });
+      return { ...result, requestId: "" };
+    },
+    async delete(imageId) {
+      const result = await rpcClient.call("image.delete", { imageId });
+      return { ...result, requestId: "" };
     }
-  }
-  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);
+  };
+}
+
+// src/namespaces/agents.ts
+function createLocalAgents(runtime) {
+  return {
+    async create(params) {
+      const existingAgent = runtime.getAgents().find((a) => a.imageId === params.imageId && a.lifecycle === "running");
+      if (existingAgent) {
+        return {
+          agentId: existingAgent.agentId,
+          imageId: existingAgent.imageId,
+          containerId: existingAgent.containerId,
+          sessionId: existingAgent.sessionId,
+          requestId: ""
+        };
+      }
+      const agent = await runtime.createAgent({
+        imageId: params.imageId,
+        agentId: params.agentId
+      });
+      return {
+        agentId: agent.agentId,
+        imageId: agent.imageId,
+        containerId: agent.containerId,
+        sessionId: agent.sessionId,
+        requestId: ""
+      };
+    },
+    async get(agentId) {
+      const agent = runtime.getAgent(agentId);
+      return {
+        agent: agent ? {
+          agentId: agent.agentId,
+          imageId: agent.imageId,
+          containerId: agent.containerId,
+          sessionId: agent.sessionId,
+          lifecycle: agent.lifecycle
+        } : null,
+        exists: !!agent,
+        requestId: ""
+      };
+    },
+    async list(containerId) {
+      const agents = containerId ? runtime.getAgentsByContainer(containerId) : runtime.getAgents();
+      return {
+        agents: agents.map((a) => ({
+          agentId: a.agentId,
+          imageId: a.imageId,
+          containerId: a.containerId,
+          sessionId: a.sessionId,
+          lifecycle: a.lifecycle
+        })),
+        requestId: ""
+      };
+    },
+    async destroy(agentId) {
+      const agent = runtime.getAgent(agentId);
+      if (agent) {
+        await runtime.destroyAgent(agentId);
+      }
+      return { requestId: "" };
     }
-  }
-  isNodeEnvironment() {
-    return typeof process !== "undefined" && process.versions?.node !== void 0;
-  }
-};
-var externalFactory = null;
-var factoryVersion = 0;
-var LoggerFactoryImpl = class {
-  static loggers = /* @__PURE__ */ new Map();
-  static config = {
-    defaultLevel: "info"
   };
-  static getLogger(nameOrClass) {
-    const name = typeof nameOrClass === "string" ? nameOrClass : nameOrClass.name;
-    if (this.loggers.has(name)) {
-      return this.loggers.get(name);
+}
+function createRemoteAgents(rpcClient) {
+  return {
+    async create(params) {
+      const result = await rpcClient.call("image.run", {
+        imageId: params.imageId,
+        agentId: params.agentId
+      });
+      return { ...result, requestId: "" };
+    },
+    async get(agentId) {
+      const result = await rpcClient.call("agent.get", { agentId });
+      return { ...result, requestId: "" };
+    },
+    async list(containerId) {
+      const result = await rpcClient.call("agent.list", { containerId });
+      return { ...result, requestId: "" };
+    },
+    async destroy(agentId) {
+      const result = await rpcClient.call("agent.destroy", { agentId });
+      return { ...result, requestId: "" };
     }
-    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;
-    factoryVersion++;
-  }
-  static createLazyLogger(name) {
-    let realLogger = null;
-    let loggerVersion = -1;
-    const getRealLogger = () => {
-      if (!realLogger || loggerVersion !== factoryVersion) {
-        realLogger = this.createLogger(name);
-        loggerVersion = factoryVersion;
-      }
-      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);
+  };
+}
+
+// src/namespaces/sessions.ts
+function createLocalSessions(runtime) {
+  return {
+    async send(agentId, content) {
+      await runtime.receive(agentId, content);
+      return { agentId, requestId: "" };
+    },
+    async interrupt(agentId) {
+      runtime.interrupt(agentId);
+      return { requestId: "" };
+    },
+    async getMessages(agentId) {
+      const agent = runtime.getAgent(agentId);
+      if (!agent) return [];
+      return runtime.platform.sessionRepository.getMessages(agent.sessionId);
     }
-    if (this.config.defaultImplementation) {
-      return this.config.defaultImplementation(name);
+  };
+}
+function createRemoteSessions(rpcClient) {
+  return {
+    async send(agentId, content) {
+      const result = await rpcClient.call("message.send", {
+        agentId,
+        content
+      });
+      return { ...result, requestId: "" };
+    },
+    async interrupt(agentId) {
+      const result = await rpcClient.call("agent.interrupt", { agentId });
+      return { ...result, requestId: "" };
+    },
+    async getMessages(agentId) {
+      const agentRes = await rpcClient.call("agent.get", { agentId });
+      if (!agentRes.agent) return [];
+      const msgRes = await rpcClient.call("image.messages", {
+        imageId: agentRes.agent.imageId
+      });
+      return msgRes.messages ?? [];
     }
-    return new ConsoleLogger(name, {
-      level: this.config.defaultLevel,
-      ...this.config.consoleOptions
-    });
-  }
-};
-function createLogger(name) {
-  return LoggerFactoryImpl.getLogger(name);
+  };
 }
 
 // src/presentation/types.ts
@@ -181,18 +288,22 @@ var initialPresentationState = {
 // src/presentation/reducer.ts
 function presentationReducer(state, event) {
   switch (event.type) {
+    // Stream layer — real-time display
     case "message_start":
       return handleMessageStart(state, event.data);
     case "text_delta":
       return handleTextDelta(state, event.data);
     case "tool_use_start":
       return handleToolUseStart(state, event.data);
-    case "input_json_delta":
-      return handleInputJsonDelta(state, event.data);
-    case "tool_result":
-      return handleToolResult(state, event.data);
+    case "tool_use_stop":
+      return handleToolUseStop(state, event.data);
+    case "message_delta":
+      return handleMessageDelta(state, event.data);
     case "message_stop":
       return handleMessageStop(state, event.data);
+    // Message layer — tool results from Engine
+    case "tool_result_message":
+      return handleToolResultMessage(state, event.data);
     case "error":
       return handleError(state, event.data);
     default:
@@ -200,6 +311,10 @@ function presentationReducer(state, event) {
   }
 }
 function handleMessageStart(state, _data) {
+  let conversations = state.conversations;
+  if (state.streaming && state.streaming.blocks.length > 0) {
+    conversations = [...conversations, { ...state.streaming, isStreaming: false }];
+  }
   const streaming = {
     role: "assistant",
     blocks: [],
@@ -207,6 +322,7 @@ function handleMessageStart(state, _data) {
   };
   return {
     ...state,
+    conversations,
     streaming,
     status: "thinking"
   };
@@ -243,7 +359,7 @@ function handleToolUseStart(state, data) {
   }
   const toolBlock = {
     type: "tool",
-    toolUseId: data.toolUseId,
+    toolUseId: data.toolCallId,
     toolName: data.toolName,
     toolInput: {},
     status: "pending"
@@ -257,46 +373,16 @@ function handleToolUseStart(state, data) {
     status: "executing"
   };
 }
-function handleInputJsonDelta(state, data) {
-  if (!state.streaming) {
-    return state;
-  }
-  const blocks = [...state.streaming.blocks];
-  const lastBlock = blocks[blocks.length - 1];
-  if (lastBlock && lastBlock.type === "tool") {
-    const currentInput = lastBlock._rawInput || "";
-    const newInput = currentInput + data.delta;
-    let toolInput = lastBlock.toolInput;
-    try {
-      toolInput = JSON.parse(newInput);
-    } catch {
-    }
-    blocks[blocks.length - 1] = {
-      ...lastBlock,
-      toolInput,
-      _rawInput: newInput,
-      status: "running"
-    };
-    return {
-      ...state,
-      streaming: {
-        ...state.streaming,
-        blocks
-      }
-    };
-  }
-  return state;
-}
-function handleToolResult(state, data) {
+function handleToolUseStop(state, data) {
   if (!state.streaming) {
     return state;
   }
   const blocks = state.streaming.blocks.map((block) => {
-    if (block.type === "tool" && block.toolUseId === data.toolUseId) {
+    if (block.type === "tool" && block.toolUseId === data.toolCallId) {
       return {
         ...block,
-        toolResult: data.result,
-        status: data.isError ? "error" : "completed"
+        toolInput: data.input,
+        status: "running"
       };
     }
     return block;
@@ -306,14 +392,36 @@ function handleToolResult(state, data) {
     streaming: {
       ...state.streaming,
       blocks
-    },
-    status: "responding"
+    }
+  };
+}
+function handleMessageDelta(state, data) {
+  if (!state.streaming || !data.usage) {
+    return state;
+  }
+  const prev = state.streaming.usage;
+  const usage = {
+    inputTokens: (prev?.inputTokens ?? 0) + data.usage.inputTokens,
+    outputTokens: (prev?.outputTokens ?? 0) + data.usage.outputTokens
+  };
+  return {
+    ...state,
+    streaming: {
+      ...state.streaming,
+      usage
+    }
   };
 }
-function handleMessageStop(state, _data) {
+function handleMessageStop(state, data) {
   if (!state.streaming) {
     return state;
   }
+  if (data.stopReason === "tool_use") {
+    return {
+      ...state,
+      status: "executing"
+    };
+  }
   const completedConversation = {
     ...state.streaming,
     isStreaming: false
@@ -325,6 +433,30 @@ function handleMessageStop(state, _data) {
     status: "idle"
   };
 }
+function handleToolResultMessage(state, data) {
+  if (!state.streaming) {
+    return state;
+  }
+  const toolCallId = data.toolCallId;
+  const blocks = state.streaming.blocks.map((block) => {
+    if (block.type === "tool" && block.toolUseId === toolCallId) {
+      return {
+        ...block,
+        toolResult: formatToolResultOutput(data.toolResult.output),
+        status: data.toolResult.output.type === "error-text" || data.toolResult.output.type === "error-json" || data.toolResult.output.type === "execution-denied" ? "error" : "completed"
+      };
+    }
+    return block;
+  });
+  return {
+    ...state,
+    streaming: {
+      ...state.streaming,
+      blocks
+    },
+    status: "responding"
+  };
+}
 function handleError(state, data) {
   return {
     ...state,
@@ -354,6 +486,97 @@ function addUserConversation(state, content) {
 function createInitialState() {
   return { ...initialPresentationState };
 }
+function formatToolResultOutput(output) {
+  switch (output.type) {
+    case "text":
+    case "error-text":
+      return output.value;
+    case "json":
+    case "error-json":
+      return JSON.stringify(output.value);
+    case "execution-denied":
+      return output.reason ?? "Execution denied";
+    case "content":
+      return output.value.filter((p) => p.type === "text").map((p) => p.text).join("");
+  }
+}
+function messagesToConversations(messages) {
+  const conversations = [];
+  let currentAssistant = null;
+  function flushAssistant() {
+    if (currentAssistant && currentAssistant.blocks.length > 0) {
+      conversations.push(currentAssistant);
+    }
+    currentAssistant = null;
+  }
+  for (const msg of messages) {
+    switch (msg.subtype) {
+      case "user": {
+        flushAssistant();
+        const m = msg;
+        const text = typeof m.content === "string" ? m.content : m.content.filter((p) => p.type === "text").map((p) => p.text).join("");
+        conversations.push({
+          role: "user",
+          blocks: [{ type: "text", content: text }]
+        });
+        break;
+      }
+      case "assistant": {
+        if (!currentAssistant) {
+          currentAssistant = { role: "assistant", blocks: [], isStreaming: false };
+        }
+        const m = msg;
+        if (typeof m.content === "string") {
+          if (m.content) {
+            currentAssistant.blocks.push({ type: "text", content: m.content });
+          }
+        } else {
+          for (const part of m.content) {
+            if (part.type === "text") {
+              if (part.text) {
+                currentAssistant.blocks.push({ type: "text", content: part.text });
+              }
+            } else if (part.type === "tool-call") {
+              const tc = part;
+              currentAssistant.blocks.push({
+                type: "tool",
+                toolUseId: tc.id,
+                toolName: tc.name,
+                toolInput: tc.input,
+                status: "completed"
+              });
+            }
+          }
+        }
+        break;
+      }
+      case "tool-result": {
+        const m = msg;
+        if (currentAssistant) {
+          for (const block of currentAssistant.blocks) {
+            if (block.type === "tool" && block.toolUseId === m.toolResult.id) {
+              block.toolResult = formatToolResultOutput(m.toolResult.output);
+              block.status = m.toolResult.output.type === "error-text" || m.toolResult.output.type === "error-json" || m.toolResult.output.type === "execution-denied" ? "error" : "completed";
+              break;
+            }
+          }
+        }
+        break;
+      }
+      case "error": {
+        flushAssistant();
+        const m = msg;
+        conversations.push({
+          role: "error",
+          message: m.content
+        });
+        break;
+      }
+    }
+  }
+  flushAssistant();
+  return conversations;
+}
 
 // src/presentation/Presentation.ts
 var Presentation = class {
@@ -363,10 +586,10 @@ var Presentation = class {
   updateHandlers = /* @__PURE__ */ new Set();
   errorHandlers = /* @__PURE__ */ new Set();
   eventUnsubscribe = null;
-  constructor(agentx, agentId, options) {
+  constructor(agentx, agentId, options, initialConversations) {
     this.agentx = agentx;
     this.agentId = agentId;
-    this.state = createInitialState();
+    this.state = initialConversations?.length ? { ...initialPresentationState, conversations: initialConversations } : createInitialState();
     if (options?.onUpdate) {
       this.updateHandlers.add(options.onUpdate);
     }
@@ -407,7 +630,7 @@ var Presentation = class {
     this.state = addUserConversation(this.state, content);
     this.notify();
     try {
-      await this.agentx.sendMessage(this.agentId, content);
+      await this.agentx.sessions.send(this.agentId, content);
     } catch (error) {
       this.notifyError(error instanceof Error ? error : new Error(String(error)));
     }
@@ -417,7 +640,7 @@ var Presentation = class {
    */
   async interrupt() {
     try {
-      await this.agentx.interrupt(this.agentId);
+      await this.agentx.sessions.interrupt(this.agentId);
     } catch (error) {
       this.notifyError(error instanceof Error ? error : new Error(String(error)));
     }
@@ -475,17 +698,34 @@ var Presentation = class {
   }
 };
 
+// src/namespaces/presentations.ts
+function createPresentations(agentx) {
+  return {
+    async create(agentId, options) {
+      const messages = await agentx.sessions.getMessages(agentId);
+      const conversations = messagesToConversations(messages);
+      return new Presentation(agentx, agentId, options, conversations);
+    }
+  };
+}
+
 // src/RemoteClient.ts
 var logger = createLogger("agentx/RemoteClient");
 var RemoteClient = class {
   config;
   eventBus;
   rpcClient;
+  containers;
+  images;
+  agents;
+  sessions;
+  presentations;
   constructor(config) {
     this.config = config;
     this.eventBus = new EventBusImpl();
     this.rpcClient = new RpcClient({
       url: config.serverUrl,
+      createWebSocket: config.customPlatform?.webSocketFactory,
       timeout: config.timeout ?? 3e4,
       autoReconnect: config.autoReconnect ?? true,
       headers: config.headers,
@@ -495,6 +735,11 @@ var RemoteClient = class {
       logger.debug("Received stream event", { topic, type: event.type });
       this.eventBus.emit(event);
     });
+    this.containers = createRemoteContainers(this.rpcClient);
+    this.images = createRemoteImages(this.rpcClient, (sessionId) => this.subscribe(sessionId));
+    this.agents = createRemoteAgents(this.rpcClient);
+    this.sessions = createRemoteSessions(this.rpcClient);
+    this.presentations = createPresentations(this);
   }
   // ==================== Properties ====================
   get connected() {
@@ -517,109 +762,133 @@ var RemoteClient = class {
     this.eventBus.destroy();
     logger.info("RemoteClient disposed");
   }
-  // ==================== Container Operations ====================
-  async createContainer(containerId) {
-    const result = await this.rpcClient.call("container.create", {
-      containerId
-    });
-    return { ...result, requestId: "" };
-  }
-  async getContainer(containerId) {
-    const result = await this.rpcClient.call("container.get", {
-      containerId
-    });
-    return { ...result, requestId: "" };
-  }
-  async listContainers() {
-    const result = await this.rpcClient.call("container.list", {});
-    return { ...result, requestId: "" };
-  }
-  // ==================== Image Operations ====================
-  async createImage(params) {
-    const result = await this.rpcClient.call("image.create", params);
-    if (result.__subscriptions) {
-      for (const sessionId of result.__subscriptions) {
-        this.subscribe(sessionId);
-      }
-    }
-    return { ...result, requestId: "" };
-  }
-  async getImage(imageId) {
-    const result = await this.rpcClient.call("image.get", { imageId });
-    if (result.__subscriptions) {
-      for (const sessionId of result.__subscriptions) {
-        this.subscribe(sessionId);
-      }
-    }
-    return { ...result, requestId: "" };
-  }
-  async listImages(containerId) {
-    const result = await this.rpcClient.call("image.list", { containerId });
-    if (result.__subscriptions) {
-      for (const sessionId of result.__subscriptions) {
-        this.subscribe(sessionId);
-      }
-    }
-    return { ...result, requestId: "" };
-  }
-  async deleteImage(imageId) {
-    const result = await this.rpcClient.call("image.delete", { imageId });
-    return { ...result, requestId: "" };
-  }
-  // ==================== Agent Operations ====================
-  async createAgent(params) {
-    const result = await this.rpcClient.call("image.run", {
-      imageId: params.imageId,
-      agentId: params.agentId
-    });
-    return { ...result, requestId: "" };
+  // ==================== Event Subscription ====================
+  on(type, handler) {
+    return this.eventBus.on(type, handler);
   }
-  async getAgent(agentId) {
-    const result = await this.rpcClient.call("agent.get", { agentId });
-    return { ...result, requestId: "" };
+  onAny(handler) {
+    return this.eventBus.onAny(handler);
   }
-  async listAgents(containerId) {
-    const result = await this.rpcClient.call("agent.list", { containerId });
-    return { ...result, requestId: "" };
+  subscribe(sessionId) {
+    this.rpcClient.subscribe(sessionId);
+    logger.debug("Subscribed to session", { sessionId });
   }
-  async destroyAgent(agentId) {
-    const result = await this.rpcClient.call("agent.destroy", { agentId });
-    return { ...result, requestId: "" };
+};
+
+// src/LocalClient.ts
+import { createLogger as createLogger2 } from "commonxjs/logger";
+var logger2 = createLogger2("agentx/LocalClient");
+var LocalClient = class {
+  runtime;
+  isDisposed = false;
+  containers;
+  images;
+  agents;
+  sessions;
+  presentations;
+  constructor(runtime) {
+    this.runtime = runtime;
+    const platform = runtime.platform;
+    this.containers = createLocalContainers(platform);
+    this.images = createLocalImages(platform);
+    this.agents = createLocalAgents(runtime);
+    this.sessions = createLocalSessions(runtime);
+    this.presentations = createPresentations(this);
+    logger2.info("LocalClient initialized");
   }
-  // ==================== Message Operations ====================
-  async sendMessage(agentId, content) {
-    const result = await this.rpcClient.call("message.send", {
-      agentId,
-      content
-    });
-    return { ...result, requestId: "" };
+  // ==================== Properties ====================
+  get connected() {
+    return !this.isDisposed;
   }
-  async interrupt(agentId) {
-    const result = await this.rpcClient.call("agent.interrupt", { agentId });
-    return { ...result, requestId: "" };
+  get events() {
+    return this.runtime.platform.eventBus;
   }
   // ==================== Event Subscription ====================
   on(type, handler) {
-    return this.eventBus.on(type, handler);
+    return this.runtime.platform.eventBus.on(type, handler);
   }
   onAny(handler) {
-    return this.eventBus.onAny(handler);
+    return this.runtime.platform.eventBus.onAny(handler);
   }
-  subscribe(sessionId) {
-    this.rpcClient.subscribe(sessionId);
-    logger.debug("Subscribed to session", { sessionId });
+  subscribe(_sessionId) {
   }
-  // ==================== Presentation ====================
-  presentation(agentId, options) {
-    return new Presentation(this, agentId, options);
+  // ==================== Lifecycle ====================
+  async disconnect() {
+  }
+  async dispose() {
+    if (this.isDisposed) return;
+    await this.runtime.shutdown();
+    this.isDisposed = true;
+    logger2.info("LocalClient disposed");
   }
 };
 
 // src/index.ts
 async function createAgentX(config) {
-  const client = new RemoteClient(config);
-  await client.connect();
-  return client;
+  if (config.serverUrl) {
+    const resolvedConfig = await resolvePlatformForRemote(config);
+    const client = new RemoteClient(resolvedConfig);
+    await client.connect();
+    return client;
+  }
+  if (config.apiKey || config.createDriver || config.customPlatform) {
+    return createLocalClient(config);
+  }
+  throw new Error(
+    "Invalid AgentX config: provide either 'serverUrl' (remote mode) or 'apiKey' (local mode)"
+  );
+}
+async function resolvePlatformForRemote(config) {
+  if (config.customPlatform?.webSocketFactory) {
+    return config;
+  }
+  if (typeof globalThis !== "undefined" && globalThis.window?.document !== void 0) {
+    return config;
+  }
+  try {
+    const { createNodeWebSocket } = await import("@agentxjs/node-platform/network");
+    return {
+      ...config,
+      customPlatform: {
+        ...config.customPlatform,
+        webSocketFactory: createNodeWebSocket
+      }
+    };
+  } catch {
+    return config;
+  }
+}
+async function createLocalClient(config) {
+  const { createAgentXRuntime } = await import("@agentxjs/core/runtime");
+  let platform;
+  if (config.customPlatform) {
+    platform = config.customPlatform;
+  } else {
+    const { createNodePlatform } = await import("@agentxjs/node-platform");
+    platform = await createNodePlatform({
+      dataPath: config.dataPath ?? ":memory:",
+      logLevel: config.logLevel ?? (config.debug ? "debug" : void 0)
+    });
+  }
+  let createDriver = config.createDriver;
+  if (!createDriver) {
+    const { createMonoDriver } = await import("@agentxjs/mono-driver");
+    createDriver = (driverConfig) => {
+      const existingOptions = driverConfig.options ?? {};
+      return createMonoDriver({
+        ...driverConfig,
+        apiKey: config.apiKey ?? driverConfig.apiKey,
+        baseUrl: config.baseUrl ?? driverConfig.baseUrl,
+        model: config.model ?? driverConfig.model,
+        options: {
+          ...existingOptions,
+          provider: config.provider ?? existingOptions.provider ?? "anthropic"
+        }
+      });
+    };
+  }
+  const runtime = createAgentXRuntime(platform, createDriver);
+  return new LocalClient(runtime);
 }
 export {
   Presentation,
@@ -627,6 +896,7 @@ export {
   createAgentX,
   createInitialState,
   initialPresentationState,
+  messagesToConversations,
   presentationReducer
 };
 //# sourceMappingURL=index.js.map