agentxjs 2.6.1 → 2.8.0

package/dist/index.js

@@ -1,7 +1,6 @@
 import {
-  CommandHandler,
-  createServer
-} from "./chunk-JTHR3AK6.js";
+  CommandHandler
+} from "./chunk-JUZULVWQ.js";
 
 // src/index.ts
 import { createAgentXRuntime } from "@agentxjs/core/runtime";
@@ -11,47 +10,47 @@ import { createLogger } from "commonxjs/logger";
 
 // src/AgentHandle.ts
 var AgentHandleImpl = class {
-  agentId;
+  instanceId;
   imageId;
   containerId;
   sessionId;
   ns;
   constructor(ids, ns) {
-    this.agentId = ids.agentId;
+    this.instanceId = ids.instanceId;
     this.imageId = ids.imageId;
     this.containerId = ids.containerId;
     this.sessionId = ids.sessionId;
     this.ns = ns;
   }
   async send(content) {
-    return this.ns.session.send(this.agentId, content);
+    return this.ns.session.send(this.instanceId, content);
   }
   async interrupt() {
-    return this.ns.session.interrupt(this.agentId);
+    return this.ns.session.interrupt(this.instanceId);
   }
   async history() {
     return this.ns.image.getMessages(this.imageId);
   }
   async present(options) {
-    return this.ns.present.create(this.agentId, options);
+    return this.ns.present.create(this.instanceId, options);
   }
   async update(updates) {
     await this.ns.image.update(this.imageId, updates);
   }
   async delete() {
-    await this.ns.agent.destroy(this.agentId);
+    await this.ns.instance.destroy(this.instanceId);
     await this.ns.image.delete(this.imageId);
   }
 };
 
 // src/namespaces/agents.ts
-function createLocalAgents(runtime) {
+function createLocalInstances(runtime) {
   return {
     async create(params) {
       const existingAgent = runtime.getAgents().find((a) => a.imageId === params.imageId && a.lifecycle === "running");
       if (existingAgent) {
         return {
-          agentId: existingAgent.agentId,
+          instanceId: existingAgent.instanceId,
           imageId: existingAgent.imageId,
           containerId: existingAgent.containerId,
           sessionId: existingAgent.sessionId,
@@ -60,21 +59,21 @@ function createLocalAgents(runtime) {
       }
       const agent = await runtime.createAgent({
         imageId: params.imageId,
-        agentId: params.agentId
+        instanceId: params.instanceId
       });
       return {
-        agentId: agent.agentId,
+        instanceId: agent.instanceId,
         imageId: agent.imageId,
         containerId: agent.containerId,
         sessionId: agent.sessionId,
         requestId: ""
       };
     },
-    async get(agentId) {
-      const agent = runtime.getAgent(agentId);
+    async get(instanceId) {
+      const agent = runtime.getAgent(instanceId);
       return {
         agent: agent ? {
-          agentId: agent.agentId,
+          instanceId: agent.instanceId,
           imageId: agent.imageId,
           containerId: agent.containerId,
           sessionId: agent.sessionId,
@@ -84,11 +83,11 @@ function createLocalAgents(runtime) {
         requestId: ""
       };
     },
-    async list(containerId) {
-      const agents = containerId ? runtime.getAgentsByContainer(containerId) : runtime.getAgents();
+    async list() {
+      const agents = runtime.getAgents();
       return {
         agents: agents.map((a) => ({
-          agentId: a.agentId,
+          instanceId: a.instanceId,
           imageId: a.imageId,
           containerId: a.containerId,
           sessionId: a.sessionId,
@@ -97,97 +96,53 @@ function createLocalAgents(runtime) {
         requestId: ""
       };
     },
-    async destroy(agentId) {
-      const agent = runtime.getAgent(agentId);
+    async destroy(instanceId) {
+      const agent = runtime.getAgent(instanceId);
       if (agent) {
-        await runtime.destroyAgent(agentId);
+        await runtime.destroyAgent(instanceId);
       }
       return { requestId: "" };
     }
   };
 }
-function createRemoteAgents(rpcClient) {
+function createRemoteInstances(rpcClient) {
   return {
     async create(params) {
       const result = await rpcClient.call("image.run", {
         imageId: params.imageId,
-        agentId: params.agentId
+        instanceId: params.instanceId
       });
       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 });
+    async get(instanceId) {
+      const result = await rpcClient.call("instance.get", { instanceId });
       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
-      });
+      const result = await rpcClient.call("instance.list", {});
       return { ...result, requestId: "" };
     },
-    async list() {
-      const result = await rpcClient.call("container.list", {});
+    async destroy(instanceId) {
+      const result = await rpcClient.call("instance.destroy", { instanceId });
       return { ...result, requestId: "" };
     }
   };
 }
 
 // src/namespaces/images.ts
+import { DEFAULT_CONTAINER_ID } from "@agentxjs/core/container";
 function createLocalImages(platform) {
   return {
     async create(params) {
       const { imageRepository, sessionRepository } = platform;
       const { createImage } = await import("@agentxjs/core/image");
+      const { model, systemPrompt, mcpServers, ...rest } = params;
+      const embody = model || systemPrompt || mcpServers ? { model, systemPrompt, mcpServers } : void 0;
       const image = await createImage(
         {
-          containerId: params.containerId,
-          name: params.name,
-          description: params.description,
-          systemPrompt: params.systemPrompt,
-          mcpServers: params.mcpServers,
-          customData: params.customData
+          containerId: DEFAULT_CONTAINER_ID,
+          ...rest,
+          embody
         },
         { imageRepository, sessionRepository }
       );
@@ -205,8 +160,8 @@ function createLocalImages(platform) {
         requestId: ""
       };
     },
-    async list(containerId) {
-      const records = containerId ? await platform.imageRepository.findImagesByContainerId(containerId) : await platform.imageRepository.findAllImages();
+    async list() {
+      const records = await platform.imageRepository.findAllImages();
       return {
         records,
         __subscriptions: records.map((r) => r.sessionId),
@@ -242,7 +197,10 @@ function createLocalImages(platform) {
 function createRemoteImages(rpcClient, subscribeFn) {
   return {
     async create(params) {
-      const result = await rpcClient.call("image.create", params);
+      const result = await rpcClient.call("image.create", {
+        ...params,
+        containerId: DEFAULT_CONTAINER_ID
+      });
       if (result.__subscriptions) {
         for (const sessionId of result.__subscriptions) {
           subscribeFn(sessionId);
@@ -259,8 +217,8 @@ function createRemoteImages(rpcClient, subscribeFn) {
       }
       return { ...result, requestId: "" };
     },
-    async list(containerId) {
-      const result = await rpcClient.call("image.list", { containerId });
+    async list() {
+      const result = await rpcClient.call("image.list", {});
       if (result.__subscriptions) {
         for (const sessionId of result.__subscriptions) {
           subscribeFn(sessionId);
@@ -287,6 +245,7 @@ function createRemoteImages(rpcClient, subscribeFn) {
 }
 
 // src/namespaces/llm.ts
+import { DEFAULT_CONTAINER_ID as DEFAULT_CONTAINER_ID2 } from "@agentxjs/core/container";
 import { generateId } from "@deepracticex/id";
 function createLocalLLM(platform) {
   const repo = platform.llmProviderRepository;
@@ -298,7 +257,7 @@ function createLocalLLM(platform) {
       const now = Date.now();
       const record = {
         id: generateId("llm"),
-        containerId: params.containerId,
+        containerId: DEFAULT_CONTAINER_ID2,
         name: params.name,
         vendor: params.vendor,
         protocol: params.protocol,
@@ -316,8 +275,8 @@ function createLocalLLM(platform) {
       const record = await repo.findLLMProviderById(id);
       return { record, requestId: "" };
     },
-    async list(containerId) {
-      const records = await repo.findLLMProvidersByContainerId(containerId);
+    async list() {
+      const records = await repo.findLLMProvidersByContainerId(DEFAULT_CONTAINER_ID2);
       return { records, requestId: "" };
     },
     async update(id, updates) {
@@ -344,8 +303,8 @@ function createLocalLLM(platform) {
       await repo.setDefaultLLMProvider(id);
       return { requestId: "" };
     },
-    async getDefault(containerId) {
-      const record = await repo.findDefaultLLMProvider(containerId);
+    async getDefault() {
+      const record = await repo.findDefaultLLMProvider(DEFAULT_CONTAINER_ID2);
       return { record, requestId: "" };
     }
   };
@@ -353,15 +312,20 @@ function createLocalLLM(platform) {
 function createRemoteLLM(rpcClient) {
   return {
     async create(params) {
-      const result = await rpcClient.call("llm.create", params);
+      const result = await rpcClient.call("llm.create", {
+        ...params,
+        containerId: DEFAULT_CONTAINER_ID2
+      });
       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 });
+    async list() {
+      const result = await rpcClient.call("llm.list", {
+        containerId: DEFAULT_CONTAINER_ID2
+      });
       return { ...result, requestId: "" };
     },
     async update(id, updates) {
@@ -379,9 +343,9 @@ function createRemoteLLM(rpcClient) {
       const result = await rpcClient.call("llm.default", { id });
       return { ...result, requestId: "" };
     },
-    async getDefault(containerId) {
+    async getDefault() {
       const result = await rpcClient.call("llm.default", {
-        containerId
+        containerId: DEFAULT_CONTAINER_ID2
       });
       return { ...result, requestId: "" };
     }
@@ -691,14 +655,14 @@ function messagesToConversations(messages) {
 // src/presentation/Presentation.ts
 var Presentation = class {
   agentx;
-  agentId;
+  instanceId;
   state;
   updateHandlers = /* @__PURE__ */ new Set();
   errorHandlers = /* @__PURE__ */ new Set();
   eventUnsubscribe = null;
-  constructor(agentx, agentId, options, initialConversations) {
+  constructor(agentx, instanceId, options, initialConversations) {
     this.agentx = agentx;
-    this.agentId = agentId;
+    this.instanceId = instanceId;
     this.state = initialConversations?.length ? { ...initialPresentationState, conversations: initialConversations } : createInitialState();
     if (options?.onUpdate) {
       this.updateHandlers.add(options.onUpdate);
@@ -740,7 +704,7 @@ var Presentation = class {
     this.state = addUserConversation(this.state, content);
     this.notify();
     try {
-      await this.agentx.runtime.session.send(this.agentId, content);
+      await this.agentx.runtime.session.send(this.instanceId, content);
     } catch (error) {
       this.notifyError(error instanceof Error ? error : new Error(String(error)));
     }
@@ -750,7 +714,7 @@ var Presentation = class {
    */
   async interrupt() {
     try {
-      await this.agentx.runtime.session.interrupt(this.agentId);
+      await this.agentx.runtime.session.interrupt(this.instanceId);
     } catch (error) {
       this.notifyError(error instanceof Error ? error : new Error(String(error)));
     }
@@ -777,8 +741,8 @@ var Presentation = class {
   subscribeToEvents() {
     this.eventUnsubscribe = this.agentx.onAny((event) => {
       const eventWithContext = event;
-      const eventAgentId = eventWithContext.context?.agentId;
-      if (eventAgentId && eventAgentId !== this.agentId) {
+      const eventAgentId = eventWithContext.context?.instanceId;
+      if (eventAgentId && eventAgentId !== this.instanceId) {
         return;
       }
       const newState = presentationReducer(this.state, event);
@@ -809,109 +773,12 @@ var Presentation = class {
 };
 
 // src/namespaces/presentations.ts
-function createPresentations(agentx, imageNs) {
+function createPresentations(agentx, sessionNs) {
   return {
-    async create(agentId, options) {
-      const messages = await imageNs.getMessages(agentId);
+    async create(instanceId, options) {
+      const messages = await sessionNs.getMessages(instanceId);
       const conversations = messagesToConversations(messages);
-      return new Presentation(agentx, agentId, options, conversations);
-    }
-  };
-}
-
-// src/namespaces/prototypes.ts
-function createLocalPrototypes(platform) {
-  return {
-    async create(params) {
-      const repo = platform.prototypeRepository;
-      if (!repo) {
-        throw new Error("Prototype repository not available");
-      }
-      const now = Date.now();
-      const random = Math.random().toString(36).slice(2, 8);
-      const record = {
-        prototypeId: `proto_${now}_${random}`,
-        containerId: params.containerId,
-        name: params.name,
-        description: params.description,
-        contextId: params.contextId,
-        embody: params.embody,
-        customData: params.customData,
-        createdAt: now,
-        updatedAt: now
-      };
-      await repo.savePrototype(record);
-      return { record, requestId: "" };
-    },
-    async get(prototypeId) {
-      const repo = platform.prototypeRepository;
-      if (!repo) {
-        throw new Error("Prototype repository not available");
-      }
-      const record = await repo.findPrototypeById(prototypeId);
-      return { record, requestId: "" };
-    },
-    async list(containerId) {
-      const repo = platform.prototypeRepository;
-      if (!repo) {
-        throw new Error("Prototype repository not available");
-      }
-      const records = containerId ? await repo.findPrototypesByContainerId(containerId) : await repo.findAllPrototypes();
-      return { records, requestId: "" };
-    },
-    async update(prototypeId, updates) {
-      const repo = platform.prototypeRepository;
-      if (!repo) {
-        throw new Error("Prototype repository not available");
-      }
-      const existing = await repo.findPrototypeById(prototypeId);
-      if (!existing) {
-        throw new Error(`Prototype not found: ${prototypeId}`);
-      }
-      const { embody: embodyUpdates, ...otherUpdates } = updates;
-      const updatedRecord = {
-        ...existing,
-        ...otherUpdates,
-        embody: embodyUpdates ? { ...existing.embody, ...embodyUpdates } : existing.embody,
-        updatedAt: Date.now()
-      };
-      await repo.savePrototype(updatedRecord);
-      return { record: updatedRecord, requestId: "" };
-    },
-    async delete(prototypeId) {
-      const repo = platform.prototypeRepository;
-      if (!repo) {
-        throw new Error("Prototype repository not available");
-      }
-      await repo.deletePrototype(prototypeId);
-      return { requestId: "" };
-    }
-  };
-}
-function createRemotePrototypes(rpcClient) {
-  return {
-    async create(params) {
-      const result = await rpcClient.call("prototype.create", params);
-      return { ...result, requestId: "" };
-    },
-    async get(prototypeId) {
-      const result = await rpcClient.call("prototype.get", { prototypeId });
-      return { ...result, requestId: "" };
-    },
-    async list(containerId) {
-      const result = await rpcClient.call("prototype.list", { containerId });
-      return { ...result, requestId: "" };
-    },
-    async update(prototypeId, updates) {
-      const result = await rpcClient.call("prototype.update", {
-        prototypeId,
-        updates
-      });
-      return { ...result, requestId: "" };
-    },
-    async delete(prototypeId) {
-      const result = await rpcClient.call("prototype.delete", { prototypeId });
-      return { ...result, requestId: "" };
+      return new Presentation(agentx, instanceId, options, conversations);
     }
   };
 }
@@ -919,16 +786,16 @@ function createRemotePrototypes(rpcClient) {
 // src/namespaces/sessions.ts
 function createLocalSessions(runtime) {
   return {
-    async send(agentId, content) {
-      await runtime.receive(agentId, content);
-      return { agentId, requestId: "" };
+    async send(instanceId, content) {
+      await runtime.receive(instanceId, content);
+      return { instanceId, requestId: "" };
     },
-    async interrupt(agentId) {
-      runtime.interrupt(agentId);
+    async interrupt(instanceId) {
+      runtime.interrupt(instanceId);
       return { requestId: "" };
     },
-    async getMessages(agentId) {
-      const agent = runtime.getAgent(agentId);
+    async getMessages(instanceId) {
+      const agent = runtime.getAgent(instanceId);
       if (!agent) return [];
       return runtime.platform.sessionRepository.getMessages(agent.sessionId);
     }
@@ -936,19 +803,21 @@ function createLocalSessions(runtime) {
 }
 function createRemoteSessions(rpcClient) {
   return {
-    async send(agentId, content) {
+    async send(instanceId, content) {
       const result = await rpcClient.call("message.send", {
-        agentId,
+        instanceId,
         content
       });
       return { ...result, requestId: "" };
     },
-    async interrupt(agentId) {
-      const result = await rpcClient.call("agent.interrupt", { agentId });
+    async interrupt(instanceId) {
+      const result = await rpcClient.call("instance.interrupt", { instanceId });
       return { ...result, requestId: "" };
     },
-    async getMessages(agentId) {
-      const agentRes = await rpcClient.call("agent.get", { agentId });
+    async getMessages(instanceId) {
+      const agentRes = await rpcClient.call("instance.get", {
+        instanceId
+      });
       if (!agentRes.agent) return [];
       const msgRes = await rpcClient.call("image.messages", {
         imageId: agentRes.agent.imageId
@@ -967,20 +836,16 @@ var LocalClient = class {
   chat;
   runtime;
   provider;
-  prototype;
   constructor(agentxRuntime) {
     this._runtime = agentxRuntime;
     const platform = agentxRuntime.platform;
-    const container = createLocalContainers(platform);
     const image = createLocalImages(platform);
-    const agent = createLocalAgents(agentxRuntime);
+    const instance = createLocalInstances(agentxRuntime);
     const session = createLocalSessions(agentxRuntime);
     const llm = createLocalLLM(platform);
-    const prototype = createLocalPrototypes(platform);
-    const present = createPresentations(this, image);
-    this.runtime = { container, image, agent, session, present, llm, prototype };
+    const present = createPresentations(this, session);
+    this.runtime = { image, instance, session, present, llm };
     this.provider = llm;
-    this.prototype = prototype;
     this.chat = this.createChatNamespace();
     logger.info("LocalClient initialized");
   }
@@ -1019,55 +884,37 @@ var LocalClient = class {
   }
   // ==================== Private ====================
   createChatNamespace() {
-    const instance = this.runtime;
+    const rt = this.runtime;
     return {
       async create(params) {
-        const containerId = "default";
-        let mergedParams = { ...params };
-        if (params.prototypeId) {
-          const protoRes = await instance.prototype.get(params.prototypeId);
-          if (protoRes.record) {
-            const proto = protoRes.record;
-            mergedParams = {
-              name: proto.name,
-              description: proto.description,
-              contextId: proto.contextId,
-              embody: proto.embody,
-              customData: proto.customData,
-              ...params
-              // inline params override prototype
-            };
-          }
-        }
-        const { prototypeId: _pid, ...imageParams } = mergedParams;
-        const imgRes = await instance.image.create({ containerId, ...imageParams });
-        const agentRes = await instance.agent.create({ imageId: imgRes.record.imageId });
+        const imgRes = await rt.image.create(params);
+        const instRes = await rt.instance.create({ imageId: imgRes.record.imageId });
         return new AgentHandleImpl(
           {
-            agentId: agentRes.agentId,
-            imageId: agentRes.imageId,
-            containerId: agentRes.containerId,
-            sessionId: agentRes.sessionId
+            instanceId: instRes.instanceId,
+            imageId: instRes.imageId,
+            containerId: instRes.containerId,
+            sessionId: instRes.sessionId
           },
-          instance
+          rt
         );
       },
       async list() {
-        return instance.image.list();
+        return rt.image.list();
       },
       async get(id) {
-        const res = await instance.image.get(id);
+        const res = await rt.image.get(id);
         if (!res.record) return null;
         const r = res.record;
-        const agentRes = await instance.agent.create({ imageId: r.imageId });
+        const instRes = await rt.instance.create({ imageId: r.imageId });
         return new AgentHandleImpl(
           {
-            agentId: agentRes.agentId,
-            imageId: agentRes.imageId,
-            containerId: agentRes.containerId,
-            sessionId: agentRes.sessionId
+            instanceId: instRes.instanceId,
+            imageId: instRes.imageId,
+            containerId: instRes.containerId,
+            sessionId: instRes.sessionId
           },
-          instance
+          rt
         );
       }
     };
@@ -1095,7 +942,6 @@ var RemoteClient = class {
   chat;
   runtime;
   provider;
-  prototype;
   constructor(config) {
     this.config = config;
     this.eventBus = new EventBusImpl();
@@ -1111,16 +957,13 @@ var RemoteClient = class {
       logger2.debug("Received stream event", { topic, type: event.type });
       this.eventBus.emit(event);
     });
-    const container = createRemoteContainers(this.rpcClient);
     const image = createRemoteImages(this.rpcClient, (sessionId) => this.subscribe(sessionId));
-    const agent = createRemoteAgents(this.rpcClient);
+    const instance = createRemoteInstances(this.rpcClient);
     const session = createRemoteSessions(this.rpcClient);
     const llm = createRemoteLLM(this.rpcClient);
-    const prototype = createRemotePrototypes(this.rpcClient);
-    const present = createPresentations(this, image);
-    this.runtime = { container, image, agent, session, present, llm, prototype };
+    const present = createPresentations(this, session);
+    this.runtime = { image, instance, session, present, llm };
     this.provider = llm;
-    this.prototype = prototype;
     this.chat = this.createChatNamespace();
   }
   // ==================== Properties ====================
@@ -1167,55 +1010,37 @@ var RemoteClient = class {
   }
   // ==================== Private ====================
   createChatNamespace() {
-    const instance = this.runtime;
+    const rt = this.runtime;
     return {
       async create(params) {
-        const containerId = "default";
-        let mergedParams = { ...params };
-        if (params.prototypeId) {
-          const protoRes = await instance.prototype.get(params.prototypeId);
-          if (protoRes.record) {
-            const proto = protoRes.record;
-            mergedParams = {
-              name: proto.name,
-              description: proto.description,
-              contextId: proto.contextId,
-              embody: proto.embody,
-              customData: proto.customData,
-              ...params
-              // inline params override prototype
-            };
-          }
-        }
-        const { prototypeId: _pid, ...imageParams } = mergedParams;
-        const imgRes = await instance.image.create({ containerId, ...imageParams });
-        const agentRes = await instance.agent.create({ imageId: imgRes.record.imageId });
+        const imgRes = await rt.image.create(params);
+        const instRes = await rt.instance.create({ imageId: imgRes.record.imageId });
         return new AgentHandleImpl(
           {
-            agentId: agentRes.agentId,
-            imageId: agentRes.imageId,
-            containerId: agentRes.containerId,
-            sessionId: agentRes.sessionId
+            instanceId: instRes.instanceId,
+            imageId: instRes.imageId,
+            containerId: instRes.containerId,
+            sessionId: instRes.sessionId
           },
-          instance
+          rt
         );
       },
       async list() {
-        return instance.image.list();
+        return rt.image.list();
       },
       async get(id) {
-        const res = await instance.image.get(id);
+        const res = await rt.image.get(id);
         if (!res.record) return null;
         const r = res.record;
-        const agentRes = await instance.agent.create({ imageId: r.imageId });
+        const instRes = await rt.instance.create({ imageId: r.imageId });
         return new AgentHandleImpl(
           {
-            agentId: agentRes.agentId,
-            imageId: agentRes.imageId,
-            containerId: agentRes.containerId,
-            sessionId: agentRes.sessionId
+            instanceId: instRes.instanceId,
+            imageId: instRes.imageId,
+            containerId: instRes.containerId,
+            sessionId: instRes.sessionId
           },
-          instance
+          rt
         );
       }
     };
@@ -1256,9 +1081,6 @@ function createAgentX(config) {
     get chat() {
       return getLocalClient().chat;
     },
-    get prototype() {
-      return getLocalClient().prototype;
-    },
     on(type, handler) {
       return getLocalClient().on(type, handler);
     },
@@ -1299,8 +1121,8 @@ function createAgentX(config) {
           "serve() requires platform.channelServer. Ensure your platform supports server mode."
         );
       }
-      const { createServer: createServer2 } = await import("./server-UCQISBKH.js");
-      return createServer2({
+      const { createServer } = await import("./server-MVOHQ5ZM.js");
+      return createServer({
         platform: config.platform,
         createDriver: config.createDriver,
         port: serveConfig?.port,
@@ -1317,12 +1139,10 @@ function createAgentX(config) {
 export {
   AgentXError,
   AgentXErrorCode,
-  CommandHandler,
   Presentation,
   addUserConversation,
   createAgentX,
   createInitialState,
-  createServer,
   initialPresentationState,
   messagesToConversations,
   presentationReducer