agentxjs 2.5.0 → 2.6.0

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   CommandHandler,
   createServer
-} from "./chunk-7GW66EMD.js";
+} from "./chunk-JTHR3AK6.js";
 
 // src/index.ts
 import { createAgentXRuntime } from "@agentxjs/core/runtime";
@@ -740,7 +740,7 @@ var Presentation = class {
     this.state = addUserConversation(this.state, content);
     this.notify();
     try {
-      await this.agentx.instance.session.send(this.agentId, content);
+      await this.agentx.runtime.session.send(this.agentId, content);
     } catch (error) {
       this.notifyError(error instanceof Error ? error : new Error(String(error)));
     }
@@ -750,7 +750,7 @@ var Presentation = class {
    */
   async interrupt() {
     try {
-      await this.agentx.instance.session.interrupt(this.agentId);
+      await this.agentx.runtime.session.interrupt(this.agentId);
     } catch (error) {
       this.notifyError(error instanceof Error ? error : new Error(String(error)));
     }
@@ -819,6 +819,103 @@ function createPresentations(agentx, imageNs) {
   };
 }
 
+// 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: "" };
+    }
+  };
+}
+
 // src/namespaces/sessions.ts
 function createLocalSessions(runtime) {
   return {
@@ -864,22 +961,27 @@ function createRemoteSessions(rpcClient) {
 // src/LocalClient.ts
 var logger = createLogger("agentx/LocalClient");
 var LocalClient = class {
-  runtime;
+  _runtime;
   commandHandler = null;
   isDisposed = false;
-  instance;
+  chat;
+  runtime;
   provider;
-  constructor(runtime) {
-    this.runtime = runtime;
-    const platform = runtime.platform;
+  prototype;
+  constructor(agentxRuntime) {
+    this._runtime = agentxRuntime;
+    const platform = agentxRuntime.platform;
     const container = createLocalContainers(platform);
     const image = createLocalImages(platform);
-    const agent = createLocalAgents(runtime);
-    const session = createLocalSessions(runtime);
+    const agent = createLocalAgents(agentxRuntime);
+    const session = createLocalSessions(agentxRuntime);
     const llm = createLocalLLM(platform);
+    const prototype = createLocalPrototypes(platform);
     const present = createPresentations(this, image);
-    this.instance = { container, image, agent, session, present, llm };
+    this.runtime = { container, image, agent, session, present, llm, prototype };
     this.provider = llm;
+    this.prototype = prototype;
+    this.chat = this.createChatNamespace();
     logger.info("LocalClient initialized");
   }
   // ==================== Properties ====================
@@ -887,59 +989,27 @@ var LocalClient = class {
     return !this.isDisposed;
   }
   get events() {
-    return this.runtime.platform.eventBus;
-  }
-  // ==================== Top-level Agent API ====================
-  async create(params) {
-    const containerId = "default";
-    const imgRes = await this.instance.image.create({ containerId, ...params });
-    const agentRes = await this.instance.agent.create({ imageId: imgRes.record.imageId });
-    return new AgentHandleImpl(
-      {
-        agentId: agentRes.agentId,
-        imageId: agentRes.imageId,
-        containerId: agentRes.containerId,
-        sessionId: agentRes.sessionId
-      },
-      this.instance
-    );
-  }
-  async list() {
-    return this.instance.image.list();
-  }
-  async get(agentId) {
-    const res = await this.instance.image.get(agentId);
-    if (!res.record) return null;
-    const r = res.record;
-    return new AgentHandleImpl(
-      {
-        agentId: r.imageId,
-        imageId: r.imageId,
-        containerId: r.containerId,
-        sessionId: r.sessionId
-      },
-      this.instance
-    );
+    return this._runtime.platform.eventBus;
   }
   // ==================== Event Subscription ====================
   on(type, handler) {
-    return this.runtime.platform.eventBus.on(type, handler);
+    return this._runtime.platform.eventBus.on(type, handler);
   }
   onAny(handler) {
-    return this.runtime.platform.eventBus.onAny(handler);
+    return this._runtime.platform.eventBus.onAny(handler);
   }
   subscribe(_sessionId) {
   }
   // ==================== Error Handling ====================
   onError(handler) {
-    return this.runtime.platform.eventBus.on("agentx_error", (event) => {
+    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);
+      this.commandHandler = new CommandHandler(this._runtime);
     }
     const result = await this.commandHandler.handle(method, params);
     if (result.success) {
@@ -947,12 +1017,66 @@ var LocalClient = class {
     }
     throw new Error(result.message);
   }
+  // ==================== Private ====================
+  createChatNamespace() {
+    const instance = 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 });
+        return new AgentHandleImpl(
+          {
+            agentId: agentRes.agentId,
+            imageId: agentRes.imageId,
+            containerId: agentRes.containerId,
+            sessionId: agentRes.sessionId
+          },
+          instance
+        );
+      },
+      async list() {
+        return instance.image.list();
+      },
+      async get(id) {
+        const res = await instance.image.get(id);
+        if (!res.record) return null;
+        const r = res.record;
+        return new AgentHandleImpl(
+          {
+            agentId: r.imageId,
+            imageId: r.imageId,
+            containerId: r.containerId,
+            sessionId: r.sessionId
+          },
+          instance
+        );
+      }
+    };
+  }
   // ==================== Lifecycle ====================
   async disconnect() {
   }
   async dispose() {
     if (this.isDisposed) return;
-    await this.runtime.shutdown();
+    await this._runtime.shutdown();
     this.isDisposed = true;
     logger.info("LocalClient disposed");
   }
@@ -967,8 +1091,10 @@ var RemoteClient = class {
   config;
   eventBus;
   rpcClient;
-  instance;
+  chat;
+  runtime;
   provider;
+  prototype;
   constructor(config) {
     this.config = config;
     this.eventBus = new EventBusImpl();
@@ -989,9 +1115,12 @@ var RemoteClient = class {
     const agent = createRemoteAgents(this.rpcClient);
     const session = createRemoteSessions(this.rpcClient);
     const llm = createRemoteLLM(this.rpcClient);
+    const prototype = createRemotePrototypes(this.rpcClient);
     const present = createPresentations(this, image);
-    this.instance = { container, image, agent, session, present, llm };
+    this.runtime = { container, image, agent, session, present, llm, prototype };
     this.provider = llm;
+    this.prototype = prototype;
+    this.chat = this.createChatNamespace();
   }
   // ==================== Properties ====================
   get connected() {
@@ -1000,38 +1129,6 @@ var RemoteClient = class {
   get events() {
     return this.eventBus;
   }
-  // ==================== Top-level Agent API ====================
-  async create(params) {
-    const containerId = "default";
-    const imgRes = await this.instance.image.create({ containerId, ...params });
-    const agentRes = await this.instance.agent.create({ imageId: imgRes.record.imageId });
-    return new AgentHandleImpl(
-      {
-        agentId: agentRes.agentId,
-        imageId: agentRes.imageId,
-        containerId: agentRes.containerId,
-        sessionId: agentRes.sessionId
-      },
-      this.instance
-    );
-  }
-  async list() {
-    return this.instance.image.list();
-  }
-  async get(agentId) {
-    const res = await this.instance.image.get(agentId);
-    if (!res.record) return null;
-    const r = res.record;
-    return new AgentHandleImpl(
-      {
-        agentId: r.imageId,
-        imageId: r.imageId,
-        containerId: r.containerId,
-        sessionId: r.sessionId
-      },
-      this.instance
-    );
-  }
   // ==================== Connection ====================
   async connect() {
     await this.rpcClient.connect();
@@ -1067,6 +1164,60 @@ var RemoteClient = class {
   async rpc(method, params) {
     return this.rpcClient.call(method, params);
   }
+  // ==================== Private ====================
+  createChatNamespace() {
+    const instance = 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 });
+        return new AgentHandleImpl(
+          {
+            agentId: agentRes.agentId,
+            imageId: agentRes.imageId,
+            containerId: agentRes.containerId,
+            sessionId: agentRes.sessionId
+          },
+          instance
+        );
+      },
+      async list() {
+        return instance.image.list();
+      },
+      async get(id) {
+        const res = await instance.image.get(id);
+        if (!res.record) return null;
+        const r = res.record;
+        return new AgentHandleImpl(
+          {
+            agentId: r.imageId,
+            imageId: r.imageId,
+            containerId: r.containerId,
+            sessionId: r.sessionId
+          },
+          instance
+        );
+      }
+    };
+  }
 };
 
 // src/index.ts
@@ -1094,16 +1245,18 @@ function createAgentX(config) {
     get events() {
       return getLocalClient().events;
     },
-    get instance() {
-      return getLocalClient().instance;
+    get runtime() {
+      return getLocalClient().runtime;
     },
     get provider() {
       return getLocalClient().provider;
     },
-    // Top-level Agent API
-    create: (params) => getLocalClient().create(params),
-    list: () => getLocalClient().list(),
-    get: (agentId) => getLocalClient().get(agentId),
+    get chat() {
+      return getLocalClient().chat;
+    },
+    get prototype() {
+      return getLocalClient().prototype;
+    },
     on(type, handler) {
       return getLocalClient().on(type, handler);
     },
@@ -1144,7 +1297,7 @@ function createAgentX(config) {
           "serve() requires platform.channelServer. Ensure your platform supports server mode."
         );
       }
-      const { createServer: createServer2 } = await import("./server-55XTEGMF.js");
+      const { createServer: createServer2 } = await import("./server-UCQISBKH.js");
       return createServer2({
         platform: config.platform,
         createDriver: config.createDriver,