agentxjs 0.0.0-dev-20260312143810

package/dist/index.js

@@ -0,0 +1,1088 @@
+import {
+  CommandHandler,
+  createServer
+} from "./chunk-X44CQZPK.js";
+
+// src/index.ts
+import { createAgentXRuntime } from "@agentxjs/core/runtime";
+
+// src/LocalClient.ts
+import { createLogger } from "commonxjs/logger";
+
+// 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: "" };
+    }
+  };
+}
+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: "" };
+    }
+  };
+}
+
+// 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: "" };
+    }
+  };
+}
+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: "" };
+    }
+  };
+}
+
+// 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: "" };
+    },
+    async getMessages(imageId) {
+      const imageRecord = await platform.imageRepository.findImageById(imageId);
+      if (!imageRecord) return [];
+      return platform.sessionRepository.getMessages(imageRecord.sessionId);
+    }
+  };
+}
+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: "" };
+    },
+    async getMessages(imageId) {
+      const result = await rpcClient.call("image.messages", { imageId });
+      return result.messages ?? [];
+    }
+  };
+}
+
+// src/namespaces/llm.ts
+import { generateId } from "@deepracticex/id";
+function createLocalLLM(platform) {
+  const repo = platform.llmProviderRepository;
+  if (!repo) {
+    throw new Error("LLM provider repository not available on this platform");
+  }
+  return {
+    async create(params) {
+      const now = Date.now();
+      const record = {
+        id: generateId("llm"),
+        containerId: params.containerId,
+        name: params.name,
+        vendor: params.vendor,
+        protocol: params.protocol,
+        apiKey: params.apiKey,
+        baseUrl: params.baseUrl,
+        model: params.model,
+        isDefault: false,
+        createdAt: now,
+        updatedAt: now
+      };
+      await repo.saveLLMProvider(record);
+      return { record, requestId: "" };
+    },
+    async get(id) {
+      const record = await repo.findLLMProviderById(id);
+      return { record, requestId: "" };
+    },
+    async list(containerId) {
+      const records = await repo.findLLMProvidersByContainerId(containerId);
+      return { records, requestId: "" };
+    },
+    async update(id, updates) {
+      const existing = await repo.findLLMProviderById(id);
+      if (!existing) {
+        throw new Error(`LLM provider not found: ${id}`);
+      }
+      const updated = {
+        ...existing,
+        ...updates,
+        id: existing.id,
+        containerId: existing.containerId,
+        createdAt: existing.createdAt,
+        updatedAt: Date.now()
+      };
+      await repo.saveLLMProvider(updated);
+      return { record: updated, requestId: "" };
+    },
+    async delete(id) {
+      await repo.deleteLLMProvider(id);
+      return { requestId: "" };
+    },
+    async setDefault(id) {
+      await repo.setDefaultLLMProvider(id);
+      return { requestId: "" };
+    },
+    async getDefault(containerId) {
+      const record = await repo.findDefaultLLMProvider(containerId);
+      return { record, requestId: "" };
+    }
+  };
+}
+function createRemoteLLM(rpcClient) {
+  return {
+    async create(params) {
+      const result = await rpcClient.call("llm.create", params);
+      return { ...result, requestId: "" };
+    },
+    async get(id) {
+      const result = await rpcClient.call("llm.get", { id });
+      return { ...result, requestId: "" };
+    },
+    async list(containerId) {
+      const result = await rpcClient.call("llm.list", { containerId });
+      return { ...result, requestId: "" };
+    },
+    async update(id, updates) {
+      const result = await rpcClient.call("llm.update", {
+        id,
+        updates
+      });
+      return { ...result, requestId: "" };
+    },
+    async delete(id) {
+      const result = await rpcClient.call("llm.delete", { id });
+      return { ...result, requestId: "" };
+    },
+    async setDefault(id) {
+      const result = await rpcClient.call("llm.default", { id });
+      return { ...result, requestId: "" };
+    },
+    async getDefault(containerId) {
+      const result = await rpcClient.call("llm.default", {
+        containerId
+      });
+      return { ...result, requestId: "" };
+    }
+  };
+}
+
+// src/presentation/types.ts
+var initialPresentationState = {
+  conversations: [],
+  streaming: null,
+  status: "idle"
+};
+
+// 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 "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:
+      return state;
+  }
+}
+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: [],
+    isStreaming: true
+  };
+  return {
+    ...state,
+    conversations,
+    streaming,
+    status: "thinking"
+  };
+}
+function handleTextDelta(state, data) {
+  if (!state.streaming) {
+    return state;
+  }
+  const blocks = [...state.streaming.blocks];
+  const lastBlock = blocks[blocks.length - 1];
+  if (lastBlock && lastBlock.type === "text") {
+    blocks[blocks.length - 1] = {
+      ...lastBlock,
+      content: lastBlock.content + data.text
+    };
+  } else {
+    blocks.push({
+      type: "text",
+      content: data.text
+    });
+  }
+  return {
+    ...state,
+    streaming: {
+      ...state.streaming,
+      blocks
+    },
+    status: "responding"
+  };
+}
+function handleToolUseStart(state, data) {
+  if (!state.streaming) {
+    return state;
+  }
+  const toolBlock = {
+    type: "tool",
+    toolUseId: data.toolCallId,
+    toolName: data.toolName,
+    toolInput: {},
+    status: "pending"
+  };
+  return {
+    ...state,
+    streaming: {
+      ...state.streaming,
+      blocks: [...state.streaming.blocks, toolBlock]
+    },
+    status: "executing"
+  };
+}
+function handleToolUseStop(state, data) {
+  if (!state.streaming) {
+    return state;
+  }
+  const blocks = state.streaming.blocks.map((block) => {
+    if (block.type === "tool" && block.toolUseId === data.toolCallId) {
+      return {
+        ...block,
+        toolInput: data.input,
+        status: "running"
+      };
+    }
+    return block;
+  });
+  return {
+    ...state,
+    streaming: {
+      ...state.streaming,
+      blocks
+    }
+  };
+}
+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) {
+  if (!state.streaming) {
+    return state;
+  }
+  if (data.stopReason === "tool_use") {
+    return {
+      ...state,
+      status: "executing"
+    };
+  }
+  const completedConversation = {
+    ...state.streaming,
+    isStreaming: false
+  };
+  return {
+    ...state,
+    conversations: [...state.conversations, completedConversation],
+    streaming: null,
+    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,
+    conversations: [
+      ...state.conversations,
+      {
+        role: "error",
+        message: data.message
+      }
+    ],
+    streaming: null,
+    status: "idle"
+  };
+}
+function addUserConversation(state, content) {
+  return {
+    ...state,
+    conversations: [
+      ...state.conversations,
+      {
+        role: "user",
+        blocks: [{ type: "text", 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 {
+  agentx;
+  agentId;
+  state;
+  updateHandlers = /* @__PURE__ */ new Set();
+  errorHandlers = /* @__PURE__ */ new Set();
+  eventUnsubscribe = null;
+  constructor(agentx, agentId, options, initialConversations) {
+    this.agentx = agentx;
+    this.agentId = agentId;
+    this.state = initialConversations?.length ? { ...initialPresentationState, conversations: initialConversations } : createInitialState();
+    if (options?.onUpdate) {
+      this.updateHandlers.add(options.onUpdate);
+    }
+    if (options?.onError) {
+      this.errorHandlers.add(options.onError);
+    }
+    this.subscribeToEvents();
+  }
+  /**
+   * Get current state
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Subscribe to state updates
+   */
+  onUpdate(handler) {
+    this.updateHandlers.add(handler);
+    handler(this.state);
+    return () => {
+      this.updateHandlers.delete(handler);
+    };
+  }
+  /**
+   * Subscribe to errors
+   */
+  onError(handler) {
+    this.errorHandlers.add(handler);
+    return () => {
+      this.errorHandlers.delete(handler);
+    };
+  }
+  /**
+   * Send a message
+   */
+  async send(content) {
+    this.state = addUserConversation(this.state, content);
+    this.notify();
+    try {
+      await this.agentx.session.send(this.agentId, content);
+    } catch (error) {
+      this.notifyError(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  /**
+   * Interrupt current response
+   */
+  async interrupt() {
+    try {
+      await this.agentx.session.interrupt(this.agentId);
+    } catch (error) {
+      this.notifyError(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  /**
+   * Reset state
+   */
+  reset() {
+    this.state = createInitialState();
+    this.notify();
+  }
+  /**
+   * Dispose and cleanup
+   */
+  dispose() {
+    if (this.eventUnsubscribe) {
+      this.eventUnsubscribe();
+      this.eventUnsubscribe = null;
+    }
+    this.updateHandlers.clear();
+    this.errorHandlers.clear();
+  }
+  // ==================== Private ====================
+  subscribeToEvents() {
+    this.eventUnsubscribe = this.agentx.onAny((event) => {
+      const eventWithContext = event;
+      const eventAgentId = eventWithContext.context?.agentId;
+      if (eventAgentId && eventAgentId !== this.agentId) {
+        return;
+      }
+      const newState = presentationReducer(this.state, event);
+      if (newState !== this.state) {
+        this.state = newState;
+        this.notify();
+      }
+    });
+  }
+  notify() {
+    for (const handler of this.updateHandlers) {
+      try {
+        handler(this.state);
+      } catch (error) {
+        console.error("Presentation update handler error:", error);
+      }
+    }
+  }
+  notifyError(error) {
+    for (const handler of this.errorHandlers) {
+      try {
+        handler(error);
+      } catch (e) {
+        console.error("Presentation error handler error:", e);
+      }
+    }
+  }
+};
+
+// src/namespaces/presentations.ts
+function createPresentations(agentx) {
+  return {
+    async create(agentId, options) {
+      const messages = await agentx.session.getMessages(agentId);
+      const conversations = messagesToConversations(messages);
+      return new Presentation(agentx, agentId, options, conversations);
+    }
+  };
+}
+
+// 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);
+    }
+  };
+}
+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 ?? [];
+    }
+  };
+}
+
+// src/LocalClient.ts
+var logger = createLogger("agentx/LocalClient");
+var LocalClient = class {
+  runtime;
+  commandHandler = null;
+  isDisposed = false;
+  container;
+  image;
+  agent;
+  session;
+  presentation;
+  llm;
+  constructor(runtime) {
+    this.runtime = runtime;
+    const platform = runtime.platform;
+    this.container = createLocalContainers(platform);
+    this.image = createLocalImages(platform);
+    this.agent = createLocalAgents(runtime);
+    this.session = createLocalSessions(runtime);
+    this.presentation = createPresentations(this);
+    this.llm = createLocalLLM(platform);
+    logger.info("LocalClient initialized");
+  }
+  // ==================== Properties ====================
+  get connected() {
+    return !this.isDisposed;
+  }
+  get events() {
+    return this.runtime.platform.eventBus;
+  }
+  // ==================== Event Subscription ====================
+  on(type, handler) {
+    return this.runtime.platform.eventBus.on(type, handler);
+  }
+  onAny(handler) {
+    return this.runtime.platform.eventBus.onAny(handler);
+  }
+  subscribe(_sessionId) {
+  }
+  // ==================== Error Handling ====================
+  onError(handler) {
+    return this.runtime.platform.eventBus.on("agentx_error", (event) => {
+      handler(event.data);
+    });
+  }
+  // ==================== RPC ====================
+  async rpc(method, params) {
+    if (!this.commandHandler) {
+      this.commandHandler = new CommandHandler(this.runtime);
+    }
+    const result = await this.commandHandler.handle(method, params);
+    if (result.success) {
+      return result.data;
+    }
+    throw new Error(result.message);
+  }
+  // ==================== Lifecycle ====================
+  async disconnect() {
+  }
+  async dispose() {
+    if (this.isDisposed) return;
+    await this.runtime.shutdown();
+    this.isDisposed = true;
+    logger.info("LocalClient disposed");
+  }
+};
+
+// src/RemoteClient.ts
+import { EventBusImpl } from "@agentxjs/core/event";
+import { RpcClient } from "@agentxjs/core/network";
+import { createLogger as createLogger2 } from "commonxjs/logger";
+var logger2 = createLogger2("agentx/RemoteClient");
+var RemoteClient = class {
+  config;
+  eventBus;
+  rpcClient;
+  container;
+  image;
+  agent;
+  session;
+  presentation;
+  llm;
+  constructor(config) {
+    this.config = config;
+    this.eventBus = new EventBusImpl();
+    this.rpcClient = new RpcClient({
+      url: config.serverUrl,
+      createWebSocket: config.customPlatform?.channelClient,
+      timeout: config.timeout ?? 3e4,
+      autoReconnect: config.autoReconnect ?? true,
+      headers: config.headers,
+      debug: false
+    });
+    this.rpcClient.onStreamEvent((topic, event) => {
+      logger2.debug("Received stream event", { topic, type: event.type });
+      this.eventBus.emit(event);
+    });
+    this.container = createRemoteContainers(this.rpcClient);
+    this.image = createRemoteImages(this.rpcClient, (sessionId) => this.subscribe(sessionId));
+    this.agent = createRemoteAgents(this.rpcClient);
+    this.session = createRemoteSessions(this.rpcClient);
+    this.presentation = createPresentations(this);
+    this.llm = createRemoteLLM(this.rpcClient);
+  }
+  // ==================== Properties ====================
+  get connected() {
+    return this.rpcClient.connected;
+  }
+  get events() {
+    return this.eventBus;
+  }
+  // ==================== Connection ====================
+  async connect() {
+    await this.rpcClient.connect();
+    logger2.info("Connected to server", { url: this.config.serverUrl });
+  }
+  async disconnect() {
+    this.rpcClient.disconnect();
+    logger2.info("Disconnected from server");
+  }
+  async dispose() {
+    this.rpcClient.dispose();
+    this.eventBus.destroy();
+    logger2.info("RemoteClient disposed");
+  }
+  // ==================== Event Subscription ====================
+  on(type, handler) {
+    return this.eventBus.on(type, handler);
+  }
+  onAny(handler) {
+    return this.eventBus.onAny(handler);
+  }
+  subscribe(sessionId) {
+    this.rpcClient.subscribe(sessionId);
+    logger2.debug("Subscribed to session", { sessionId });
+  }
+  // ==================== Error Handling ====================
+  onError(handler) {
+    return this.eventBus.on("agentx_error", (event) => {
+      handler(event.data);
+    });
+  }
+  // ==================== RPC ====================
+  async rpc(method, params) {
+    return this.rpcClient.call(method, params);
+  }
+};
+
+// src/index.ts
+import { AgentXError, AgentXErrorCode } from "@agentxjs/core/error";
+function createAgentX(config) {
+  let localClient = null;
+  function getLocalClient() {
+    if (localClient) return localClient;
+    if (!config) {
+      throw new Error(
+        "Local mode requires a platform. Pass a PlatformConfig to createAgentX(), or use connect() for remote mode."
+      );
+    }
+    const runtime = createAgentXRuntime(config.platform, config.createDriver);
+    localClient = new LocalClient(runtime);
+    return localClient;
+  }
+  if (config) {
+    getLocalClient();
+  }
+  return {
+    get connected() {
+      return localClient?.connected ?? false;
+    },
+    get events() {
+      return getLocalClient().events;
+    },
+    get container() {
+      return getLocalClient().container;
+    },
+    get image() {
+      return getLocalClient().image;
+    },
+    get agent() {
+      return getLocalClient().agent;
+    },
+    get session() {
+      return getLocalClient().session;
+    },
+    get presentation() {
+      return getLocalClient().presentation;
+    },
+    get llm() {
+      return getLocalClient().llm;
+    },
+    on(type, handler) {
+      return getLocalClient().on(type, handler);
+    },
+    onAny(handler) {
+      return getLocalClient().onAny(handler);
+    },
+    subscribe(sessionId) {
+      getLocalClient().subscribe(sessionId);
+    },
+    onError(handler) {
+      return getLocalClient().onError(handler);
+    },
+    async disconnect() {
+      await localClient?.disconnect();
+    },
+    async dispose() {
+      await localClient?.dispose();
+      localClient = null;
+    },
+    async connect(serverUrl, options) {
+      const remoteClient = new RemoteClient({
+        serverUrl,
+        headers: options?.headers,
+        context: options?.context,
+        timeout: options?.timeout,
+        autoReconnect: options?.autoReconnect,
+        customPlatform: config?.platform
+      });
+      await remoteClient.connect();
+      return remoteClient;
+    },
+    async serve(serveConfig) {
+      if (!config) {
+        throw new Error("serve() requires a platform. Pass a PlatformConfig to createAgentX().");
+      }
+      if (!config.platform.channelServer) {
+        throw new Error(
+          "serve() requires platform.channelServer. Ensure your platform supports server mode."
+        );
+      }
+      const { createServer: createServer2 } = await import("./server-BWI5JE4B.js");
+      return createServer2({
+        platform: config.platform,
+        createDriver: config.createDriver,
+        port: serveConfig?.port,
+        host: serveConfig?.host,
+        server: serveConfig?.server,
+        wsPath: serveConfig?.wsPath
+      });
+    },
+    async rpc(method, params) {
+      return getLocalClient().rpc(method, params);
+    }
+  };
+}
+export {
+  AgentXError,
+  AgentXErrorCode,
+  CommandHandler,
+  Presentation,
+  addUserConversation,
+  createAgentX,
+  createInitialState,
+  createServer,
+  initialPresentationState,
+  messagesToConversations,
+  presentationReducer
+};
+//# sourceMappingURL=index.js.map