agentxjs 2.4.0 → 2.6.0

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   CommandHandler,
   createServer
-} from "./chunk-X44CQZPK.js";
+} from "./chunk-JTHR3AK6.js";
 
 // src/index.ts
 import { createAgentXRuntime } from "@agentxjs/core/runtime";
@@ -9,6 +9,41 @@ import { createAgentXRuntime } from "@agentxjs/core/runtime";
 // src/LocalClient.ts
 import { createLogger } from "commonxjs/logger";
 
+// src/AgentHandle.ts
+var AgentHandleImpl = class {
+  agentId;
+  imageId;
+  containerId;
+  sessionId;
+  ns;
+  constructor(ids, ns) {
+    this.agentId = ids.agentId;
+    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);
+  }
+  async interrupt() {
+    return this.ns.session.interrupt(this.agentId);
+  }
+  async history() {
+    return this.ns.image.getMessages(this.imageId);
+  }
+  async present(options) {
+    return this.ns.present.create(this.agentId, options);
+  }
+  async update(updates) {
+    await this.ns.image.update(this.imageId, updates);
+  }
+  async delete() {
+    await this.ns.agent.destroy(this.agentId);
+    await this.ns.image.delete(this.imageId);
+  }
+};
+
 // src/namespaces/agents.ts
 function createLocalAgents(runtime) {
   return {
@@ -705,7 +740,7 @@ var Presentation = class {
     this.state = addUserConversation(this.state, content);
     this.notify();
     try {
-      await this.agentx.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)));
     }
@@ -715,7 +750,7 @@ var Presentation = class {
    */
   async interrupt() {
     try {
-      await this.agentx.session.interrupt(this.agentId);
+      await this.agentx.runtime.session.interrupt(this.agentId);
     } catch (error) {
       this.notifyError(error instanceof Error ? error : new Error(String(error)));
     }
@@ -774,16 +809,113 @@ var Presentation = class {
 };
 
 // src/namespaces/presentations.ts
-function createPresentations(agentx) {
+function createPresentations(agentx, imageNs) {
   return {
     async create(agentId, options) {
-      const messages = await agentx.session.getMessages(agentId);
+      const messages = await imageNs.getMessages(agentId);
       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: "" };
+    }
+  };
+}
+
 // src/namespaces/sessions.ts
 function createLocalSessions(runtime) {
   return {
@@ -829,24 +961,27 @@ function createRemoteSessions(rpcClient) {
 // src/LocalClient.ts
 var logger = createLogger("agentx/LocalClient");
 var LocalClient = class {
-  runtime;
+  _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);
+  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 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 };
+    this.provider = llm;
+    this.prototype = prototype;
+    this.chat = this.createChatNamespace();
     logger.info("LocalClient initialized");
   }
   // ==================== Properties ====================
@@ -854,27 +989,27 @@ var LocalClient = class {
     return !this.isDisposed;
   }
   get events() {
-    return this.runtime.platform.eventBus;
+    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) {
@@ -882,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");
   }
@@ -902,12 +1091,10 @@ var RemoteClient = class {
   config;
   eventBus;
   rpcClient;
-  container;
-  image;
-  agent;
-  session;
-  presentation;
-  llm;
+  chat;
+  runtime;
+  provider;
+  prototype;
   constructor(config) {
     this.config = config;
     this.eventBus = new EventBusImpl();
@@ -923,12 +1110,17 @@ var RemoteClient = class {
       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);
+    const container = createRemoteContainers(this.rpcClient);
+    const image = createRemoteImages(this.rpcClient, (sessionId) => this.subscribe(sessionId));
+    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.runtime = { container, image, agent, session, present, llm, prototype };
+    this.provider = llm;
+    this.prototype = prototype;
+    this.chat = this.createChatNamespace();
   }
   // ==================== Properties ====================
   get connected() {
@@ -972,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
@@ -999,23 +1245,17 @@ function createAgentX(config) {
     get events() {
       return getLocalClient().events;
     },
-    get container() {
-      return getLocalClient().container;
-    },
-    get image() {
-      return getLocalClient().image;
-    },
-    get agent() {
-      return getLocalClient().agent;
+    get runtime() {
+      return getLocalClient().runtime;
     },
-    get session() {
-      return getLocalClient().session;
+    get provider() {
+      return getLocalClient().provider;
     },
-    get presentation() {
-      return getLocalClient().presentation;
+    get chat() {
+      return getLocalClient().chat;
     },
-    get llm() {
-      return getLocalClient().llm;
+    get prototype() {
+      return getLocalClient().prototype;
     },
     on(type, handler) {
       return getLocalClient().on(type, handler);
@@ -1057,7 +1297,7 @@ function createAgentX(config) {
           "serve() requires platform.channelServer. Ensure your platform supports server mode."
         );
       }
-      const { createServer: createServer2 } = await import("./server-BWI5JE4B.js");
+      const { createServer: createServer2 } = await import("./server-UCQISBKH.js");
       return createServer2({
         platform: config.platform,
         createDriver: config.createDriver,