agentxjs 2.6.0 → 2.7.0

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   CommandHandler,
   createServer
-} from "./chunk-JTHR3AK6.js";
+} from "./chunk-NPRCFKO5.js";
 
 // src/index.ts
 import { createAgentXRuntime } from "@agentxjs/core/runtime";
@@ -11,47 +11,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 +60,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,
@@ -88,7 +88,7 @@ function createLocalAgents(runtime) {
       const agents = containerId ? runtime.getAgentsByContainer(containerId) : runtime.getAgents();
       return {
         agents: agents.map((a) => ({
-          agentId: a.agentId,
+          instanceId: a.instanceId,
           imageId: a.imageId,
           containerId: a.containerId,
           sessionId: a.sessionId,
@@ -97,34 +97,34 @@ 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 });
+    async get(instanceId) {
+      const result = await rpcClient.call("instance.get", { instanceId });
       return { ...result, requestId: "" };
     },
     async list(containerId) {
-      const result = await rpcClient.call("agent.list", { containerId });
+      const result = await rpcClient.call("instance.list", { containerId });
       return { ...result, requestId: "" };
     },
-    async destroy(agentId) {
-      const result = await rpcClient.call("agent.destroy", { agentId });
+    async destroy(instanceId) {
+      const result = await rpcClient.call("instance.destroy", { instanceId });
       return { ...result, requestId: "" };
     }
   };
@@ -691,14 +691,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 +740,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 +750,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 +777,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,12 +809,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);
+      return new Presentation(agentx, instanceId, options, conversations);
     }
   };
 }
@@ -919,16 +919,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 +936,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
@@ -973,12 +975,12 @@ var LocalClient = class {
     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 = { container, image, instance, session, present, llm, prototype };
     this.provider = llm;
     this.prototype = prototype;
     this.chat = this.createChatNamespace();
@@ -1019,13 +1021,13 @@ 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);
+          const protoRes = await rt.prototype.get(params.prototypeId);
           if (protoRes.record) {
             const proto = protoRes.record;
             mergedParams = {
@@ -1040,33 +1042,34 @@ var LocalClient = class {
           }
         }
         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({ containerId, ...imageParams });
+        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 instRes = await rt.instance.create({ imageId: r.imageId });
         return new AgentHandleImpl(
           {
-            agentId: r.imageId,
-            imageId: r.imageId,
-            containerId: r.containerId,
-            sessionId: r.sessionId
+            instanceId: instRes.instanceId,
+            imageId: instRes.imageId,
+            containerId: instRes.containerId,
+            sessionId: instRes.sessionId
           },
-          instance
+          rt
         );
       }
     };
@@ -1112,12 +1115,12 @@ var RemoteClient = class {
     });
     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 = { container, image, instance, session, present, llm, prototype };
     this.provider = llm;
     this.prototype = prototype;
     this.chat = this.createChatNamespace();
@@ -1166,13 +1169,13 @@ 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);
+          const protoRes = await rt.prototype.get(params.prototypeId);
           if (protoRes.record) {
             const proto = protoRes.record;
             mergedParams = {
@@ -1187,33 +1190,34 @@ var RemoteClient = class {
           }
         }
         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({ containerId, ...imageParams });
+        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 instRes = await rt.instance.create({ imageId: r.imageId });
         return new AgentHandleImpl(
           {
-            agentId: r.imageId,
-            imageId: r.imageId,
-            containerId: r.containerId,
-            sessionId: r.sessionId
+            instanceId: instRes.instanceId,
+            imageId: instRes.imageId,
+            containerId: instRes.containerId,
+            sessionId: instRes.sessionId
           },
-          instance
+          rt
         );
       }
     };
@@ -1297,7 +1301,7 @@ function createAgentX(config) {
           "serve() requires platform.channelServer. Ensure your platform supports server mode."
         );
       }
-      const { createServer: createServer2 } = await import("./server-UCQISBKH.js");
+      const { createServer: createServer2 } = await import("./server-3BCYHXYA.js");
       return createServer2({
         platform: config.platform,
         createDriver: config.createDriver,