agentxjs 2.6.1 → 2.8.0

package/src/LocalClient.ts

@@ -12,20 +12,12 @@ import type { AgentXRuntime } from "@agentxjs/core/runtime";
 import { createLogger } from "commonxjs/logger";
 import { AgentHandleImpl } from "./AgentHandle";
 import { CommandHandler } from "./CommandHandler";
-import { createLocalAgents } from "./namespaces/agents";
-import { createLocalContainers } from "./namespaces/containers";
+import { createLocalInstances } from "./namespaces/agents";
 import { createLocalImages } from "./namespaces/images";
 import { createLocalLLM } from "./namespaces/llm";
 import { createPresentations } from "./namespaces/presentations";
-import { createLocalPrototypes } from "./namespaces/prototypes";
 import { createLocalSessions } from "./namespaces/sessions";
-import type {
-  AgentX,
-  ChatNamespace,
-  LLMNamespace,
-  PrototypeNamespace,
-  RuntimeNamespace,
-} from "./types";
+import type { AgentX, ChatNamespace, LLMNamespace, RuntimeNamespace } from "./types";
 
 const logger = createLogger("agentx/LocalClient");
 
@@ -40,23 +32,19 @@ export class LocalClient implements AgentX {
   readonly chat: ChatNamespace;
   readonly runtime: RuntimeNamespace;
   readonly provider: LLMNamespace;
-  readonly prototype: PrototypeNamespace;
 
   constructor(agentxRuntime: 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);
+    const present = createPresentations(this, session);
 
-    this.runtime = { container, image, agent, session, present, llm, prototype };
+    this.runtime = { image, instance, session, present, llm };
     this.provider = llm;
-    this.prototype = prototype;
     this.chat = this.createChatNamespace();
 
     logger.info("LocalClient initialized");
@@ -110,55 +98,37 @@ export class LocalClient implements AgentX {
   // ==================== Private ====================
 
   private createChatNamespace(): ChatNamespace {
-    const instance = this.runtime;
+    const rt = this.runtime;
     return {
       async create(params) {
-        const containerId = "default";
-        // If prototypeId is provided, merge prototype config into params
-        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
         );
       },
     };

package/src/RemoteClient.ts

@@ -11,18 +11,15 @@ import { EventBusImpl } from "@agentxjs/core/event";
 import { RpcClient, type RpcMethod } from "@agentxjs/core/network";
 import { createLogger } from "commonxjs/logger";
 import { AgentHandleImpl } from "./AgentHandle";
-import { createRemoteAgents } from "./namespaces/agents";
-import { createRemoteContainers } from "./namespaces/containers";
+import { createRemoteInstances } from "./namespaces/agents";
 import { createRemoteImages } from "./namespaces/images";
 import { createRemoteLLM } from "./namespaces/llm";
 import { createPresentations } from "./namespaces/presentations";
-import { createRemotePrototypes } from "./namespaces/prototypes";
 import { createRemoteSessions } from "./namespaces/sessions";
 import type {
   AgentX,
   ChatNamespace,
   LLMNamespace,
-  PrototypeNamespace,
   RemoteClientConfig,
   RuntimeNamespace,
 } from "./types";
@@ -40,7 +37,6 @@ export class RemoteClient implements AgentX {
   readonly chat: ChatNamespace;
   readonly runtime: RuntimeNamespace;
   readonly provider: LLMNamespace;
-  readonly prototype: PrototypeNamespace;
 
   constructor(config: RemoteClientConfig) {
     this.config = config;
@@ -63,17 +59,14 @@ export class RemoteClient implements AgentX {
     });
 
     // Assemble namespaces
-    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);
+    const present = createPresentations(this, session);
 
-    this.runtime = { container, image, agent, session, present, llm, prototype };
+    this.runtime = { image, instance, session, present, llm };
     this.provider = llm;
-    this.prototype = prototype;
     this.chat = this.createChatNamespace();
   }
 
@@ -137,55 +130,37 @@ export class RemoteClient implements AgentX {
   // ==================== Private ====================
 
   private createChatNamespace(): ChatNamespace {
-    const instance = this.runtime;
+    const rt = this.runtime;
     return {
       async create(params) {
-        const containerId = "default";
-        // If prototypeId is provided, merge prototype config into params
-        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
         );
       },
     };

package/src/index.ts

@@ -9,7 +9,7 @@
  * import { nodePlatform } from "@agentxjs/node-platform";
  *
  * const ax = createAgentX(nodePlatform({ createDriver }));
- * const agent = await ax.chat.create({ name: "Aristotle", embody: { model: "claude-sonnet-4-6" } });
+ * const agent = await ax.chat.create({ name: "Aristotle", model: "claude-sonnet-4-6" });
  * await agent.send("Hello!");
  * ```
  *
@@ -87,10 +87,6 @@ export function createAgentX(config?: PlatformConfig): AgentXBuilder {
       return getLocalClient().chat;
     },
 
-    get prototype() {
-      return getLocalClient().prototype;
-    },
-
     on(type, handler) {
       return getLocalClient().on(type, handler);
     },
@@ -156,12 +152,12 @@ export function createAgentX(config?: PlatformConfig): AgentXBuilder {
   };
 }
 
-export type { AgentXErrorCategory, AgentXErrorContext } from "@agentxjs/core/error";
+// Re-export context interfaces
+export type { Capability, Context, ContextProvider } from "@agentxjs/core/context";
 // Re-export error types
+export type { AgentXErrorCategory, AgentXErrorContext } from "@agentxjs/core/error";
 export { AgentXError, AgentXErrorCode } from "@agentxjs/core/error";
-// Re-export server
-export { CommandHandler } from "./CommandHandler";
-// Re-export Presentation types and classes
+// Re-export Presentation
 export type {
   AssistantConversation,
   Block,
@@ -184,32 +180,27 @@ export {
   Presentation,
   presentationReducer,
 } from "./presentation";
-export { createServer, type ServerConfig } from "./server";
 // Re-export types
 export type {
-  AgentCreateResponse,
-  AgentGetResponse,
+  AgentConfig,
   AgentHandle,
-  AgentInfo,
-  AgentListResponse,
-  AgentNamespace,
   AgentX,
   AgentXBuilder,
   AgentXServer,
   BaseResponse,
   ChatNamespace,
   ConnectOptions,
-  ContainerCreateResponse,
-  ContainerGetResponse,
-  ContainerInfo,
-  ContainerListResponse,
-  ContainerNamespace,
-  Embodiment,
   ImageCreateResponse,
   ImageGetResponse,
   ImageListResponse,
   ImageNamespace,
   ImageRecord,
+  ImageUpdateResponse,
+  InstanceCreateResponse,
+  InstanceGetResponse,
+  InstanceInfo,
+  InstanceListResponse,
+  InstanceNamespace,
   LLMNamespace,
   LLMProviderCreateResponse,
   LLMProviderDefaultResponse,
@@ -219,11 +210,6 @@ export type {
   MaybeAsync,
   MessageSendResponse,
   PresentationNamespace,
-  PrototypeCreateResponse,
-  PrototypeGetResponse,
-  PrototypeListResponse,
-  PrototypeNamespace,
-  PrototypeUpdateResponse,
   RuntimeNamespace,
   ServeConfig,
   SessionNamespace,

package/src/namespaces/agents.ts

@@ -5,19 +5,22 @@
 import type { RpcClient, RpcMethod } from "@agentxjs/core/network";
 import type { AgentXRuntime } from "@agentxjs/core/runtime";
 import type {
-  AgentCreateResponse,
-  AgentGetResponse,
-  AgentListResponse,
-  AgentNamespace,
   BaseResponse,
+  InstanceCreateResponse,
+  InstanceGetResponse,
+  InstanceListResponse,
+  InstanceNamespace,
 } from "../types";
 
 /**
  * Create local agent namespace backed by embedded runtime
  */
-export function createLocalAgents(runtime: AgentXRuntime): AgentNamespace {
+export function createLocalInstances(runtime: AgentXRuntime): InstanceNamespace {
   return {
-    async create(params: { imageId: string; agentId?: string }): Promise<AgentCreateResponse> {
+    async create(params: {
+      imageId: string;
+      instanceId?: string;
+    }): Promise<InstanceCreateResponse> {
       // Reuse existing running agent for this image
       const existingAgent = runtime
         .getAgents()
@@ -25,7 +28,7 @@ export function createLocalAgents(runtime: AgentXRuntime): AgentNamespace {
 
       if (existingAgent) {
         return {
-          agentId: existingAgent.agentId,
+          instanceId: existingAgent.instanceId,
           imageId: existingAgent.imageId,
           containerId: existingAgent.containerId,
           sessionId: existingAgent.sessionId,
@@ -35,11 +38,11 @@ export function createLocalAgents(runtime: AgentXRuntime): AgentNamespace {
 
       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,
@@ -47,12 +50,12 @@ export function createLocalAgents(runtime: AgentXRuntime): AgentNamespace {
       };
     },
 
-    async get(agentId: string): Promise<AgentGetResponse> {
-      const agent = runtime.getAgent(agentId);
+    async get(instanceId: string): Promise<InstanceGetResponse> {
+      const agent = runtime.getAgent(instanceId);
       return {
         agent: agent
           ? {
-              agentId: agent.agentId,
+              instanceId: agent.instanceId,
               imageId: agent.imageId,
               containerId: agent.containerId,
               sessionId: agent.sessionId,
@@ -64,12 +67,12 @@ export function createLocalAgents(runtime: AgentXRuntime): AgentNamespace {
       };
     },
 
-    async list(containerId?: string): Promise<AgentListResponse> {
-      const agents = containerId ? runtime.getAgentsByContainer(containerId) : runtime.getAgents();
+    async list(): Promise<InstanceListResponse> {
+      const agents = runtime.getAgents();
 
       return {
         agents: agents.map((a) => ({
-          agentId: a.agentId,
+          instanceId: a.instanceId,
           imageId: a.imageId,
           containerId: a.containerId,
           sessionId: a.sessionId,
@@ -79,10 +82,10 @@ export function createLocalAgents(runtime: AgentXRuntime): AgentNamespace {
       };
     },
 
-    async destroy(agentId: string): Promise<BaseResponse> {
-      const agent = runtime.getAgent(agentId);
+    async destroy(instanceId: string): Promise<BaseResponse> {
+      const agent = runtime.getAgent(instanceId);
       if (agent) {
-        await runtime.destroyAgent(agentId);
+        await runtime.destroyAgent(instanceId);
       }
       return { requestId: "" };
     },
@@ -92,29 +95,32 @@ export function createLocalAgents(runtime: AgentXRuntime): AgentNamespace {
 /**
  * Create remote agent namespace backed by RPC client
  */
-export function createRemoteAgents(rpcClient: RpcClient): AgentNamespace {
+export function createRemoteInstances(rpcClient: RpcClient): InstanceNamespace {
   return {
-    async create(params: { imageId: string; agentId?: string }): Promise<AgentCreateResponse> {
+    async create(params: {
+      imageId: string;
+      instanceId?: string;
+    }): Promise<InstanceCreateResponse> {
       // Agent creation via image.run RPC
-      const result = await rpcClient.call<AgentCreateResponse>("image.run" as RpcMethod, {
+      const result = await rpcClient.call<InstanceCreateResponse>("image.run" as RpcMethod, {
         imageId: params.imageId,
-        agentId: params.agentId,
+        instanceId: params.instanceId,
       });
       return { ...result, requestId: "" };
     },
 
-    async get(agentId: string): Promise<AgentGetResponse> {
-      const result = await rpcClient.call<AgentGetResponse>("agent.get", { agentId });
+    async get(instanceId: string): Promise<InstanceGetResponse> {
+      const result = await rpcClient.call<InstanceGetResponse>("instance.get", { instanceId });
       return { ...result, requestId: "" };
     },
 
-    async list(containerId?: string): Promise<AgentListResponse> {
-      const result = await rpcClient.call<AgentListResponse>("agent.list", { containerId });
+    async list(): Promise<InstanceListResponse> {
+      const result = await rpcClient.call<InstanceListResponse>("instance.list", {});
       return { ...result, requestId: "" };
     },
 
-    async destroy(agentId: string): Promise<BaseResponse> {
-      const result = await rpcClient.call<BaseResponse>("agent.destroy", { agentId });
+    async destroy(instanceId: string): Promise<BaseResponse> {
+      const result = await rpcClient.call<BaseResponse>("instance.destroy", { instanceId });
       return { ...result, requestId: "" };
     },
   };

package/src/namespaces/images.ts

@@ -3,9 +3,11 @@
  */
 
 import type { Message } from "@agentxjs/core/agent";
+import { DEFAULT_CONTAINER_ID } from "@agentxjs/core/container";
 import type { RpcClient } from "@agentxjs/core/network";
 import type { AgentXPlatform } from "@agentxjs/core/runtime";
 import type {
+  AgentConfig,
   BaseResponse,
   ImageCreateResponse,
   ImageGetResponse,
@@ -19,25 +21,21 @@ import type {
  */
 export function createLocalImages(platform: AgentXPlatform): ImageNamespace {
   return {
-    async create(params: {
-      containerId: string;
-      name?: string;
-      description?: string;
-      systemPrompt?: string;
-      mcpServers?: Record<string, unknown>;
-      customData?: Record<string, unknown>;
-    }): Promise<ImageCreateResponse> {
+    async create(params: AgentConfig): Promise<ImageCreateResponse> {
       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: mcpServers as any }
+          : undefined;
+
       const image = await createImage(
         {
-          containerId: params.containerId,
-          name: params.name,
-          description: params.description,
-          systemPrompt: params.systemPrompt,
-          mcpServers: params.mcpServers as any,
-          customData: params.customData,
+          containerId: DEFAULT_CONTAINER_ID,
+          ...rest,
+          embody,
         },
         { imageRepository, sessionRepository }
       );
@@ -58,10 +56,8 @@ export function createLocalImages(platform: AgentXPlatform): ImageNamespace {
       };
     },
 
-    async list(containerId?: string): Promise<ImageListResponse> {
-      const records = containerId
-        ? await platform.imageRepository.findImagesByContainerId(containerId)
-        : await platform.imageRepository.findAllImages();
+    async list(): Promise<ImageListResponse> {
+      const records = await platform.imageRepository.findAllImages();
 
       return {
         records,
@@ -118,15 +114,11 @@ export function createRemoteImages(
   subscribeFn: (sessionId: string) => void
 ): ImageNamespace {
   return {
-    async create(params: {
-      containerId: string;
-      name?: string;
-      description?: string;
-      systemPrompt?: string;
-      mcpServers?: Record<string, unknown>;
-      customData?: Record<string, unknown>;
-    }): Promise<ImageCreateResponse> {
-      const result = await rpcClient.call<ImageCreateResponse>("image.create", params);
+    async create(params: AgentConfig): Promise<ImageCreateResponse> {
+      const result = await rpcClient.call<ImageCreateResponse>("image.create", {
+        ...params,
+        containerId: DEFAULT_CONTAINER_ID,
+      });
 
       // Auto subscribe to session events
       if (result.__subscriptions) {
@@ -151,8 +143,8 @@ export function createRemoteImages(
       return { ...result, requestId: "" };
     },
 
-    async list(containerId?: string): Promise<ImageListResponse> {
-      const result = await rpcClient.call<ImageListResponse>("image.list", { containerId });
+    async list(): Promise<ImageListResponse> {
+      const result = await rpcClient.call<ImageListResponse>("image.list", {});
 
       // Auto subscribe
       if (result.__subscriptions) {

package/src/namespaces/llm.ts

@@ -2,6 +2,7 @@
  * LLM Provider namespace factories
  */
 
+import { DEFAULT_CONTAINER_ID } from "@agentxjs/core/container";
 import type { RpcClient } from "@agentxjs/core/network";
 import type { LLMProviderRecord } from "@agentxjs/core/persistence";
 import type { AgentXPlatform } from "@agentxjs/core/runtime";
@@ -30,7 +31,7 @@ export function createLocalLLM(platform: AgentXPlatform): LLMNamespace {
       const now = Date.now();
       const record: LLMProviderRecord = {
         id: generateId("llm"),
-        containerId: params.containerId,
+        containerId: DEFAULT_CONTAINER_ID,
         name: params.name,
         vendor: params.vendor,
         protocol: params.protocol,
@@ -51,8 +52,8 @@ export function createLocalLLM(platform: AgentXPlatform): LLMNamespace {
       return { record, requestId: "" };
     },
 
-    async list(containerId: string): Promise<LLMProviderListResponse> {
-      const records = await repo.findLLMProvidersByContainerId(containerId);
+    async list(): Promise<LLMProviderListResponse> {
+      const records = await repo.findLLMProvidersByContainerId(DEFAULT_CONTAINER_ID);
       return { records, requestId: "" };
     },
 
@@ -85,8 +86,8 @@ export function createLocalLLM(platform: AgentXPlatform): LLMNamespace {
       return { requestId: "" };
     },
 
-    async getDefault(containerId: string): Promise<LLMProviderDefaultResponse> {
-      const record = await repo.findDefaultLLMProvider(containerId);
+    async getDefault(): Promise<LLMProviderDefaultResponse> {
+      const record = await repo.findDefaultLLMProvider(DEFAULT_CONTAINER_ID);
       return { record, requestId: "" };
     },
   };
@@ -98,7 +99,10 @@ export function createLocalLLM(platform: AgentXPlatform): LLMNamespace {
 export function createRemoteLLM(rpcClient: RpcClient): LLMNamespace {
   return {
     async create(params): Promise<LLMProviderCreateResponse> {
-      const result = await rpcClient.call<LLMProviderCreateResponse>("llm.create", params);
+      const result = await rpcClient.call<LLMProviderCreateResponse>("llm.create", {
+        ...params,
+        containerId: DEFAULT_CONTAINER_ID,
+      });
       return { ...result, requestId: "" };
     },
 
@@ -107,8 +111,10 @@ export function createRemoteLLM(rpcClient: RpcClient): LLMNamespace {
       return { ...result, requestId: "" };
     },
 
-    async list(containerId: string): Promise<LLMProviderListResponse> {
-      const result = await rpcClient.call<LLMProviderListResponse>("llm.list", { containerId });
+    async list(): Promise<LLMProviderListResponse> {
+      const result = await rpcClient.call<LLMProviderListResponse>("llm.list", {
+        containerId: DEFAULT_CONTAINER_ID,
+      });
       return { ...result, requestId: "" };
     },
 
@@ -130,9 +136,9 @@ export function createRemoteLLM(rpcClient: RpcClient): LLMNamespace {
       return { ...result, requestId: "" };
     },
 
-    async getDefault(containerId: string): Promise<LLMProviderDefaultResponse> {
+    async getDefault(): Promise<LLMProviderDefaultResponse> {
       const result = await rpcClient.call<LLMProviderDefaultResponse>("llm.default", {
-        containerId,
+        containerId: DEFAULT_CONTAINER_ID,
       });
       return { ...result, requestId: "" };
     },

package/src/namespaces/presentations.ts

@@ -5,23 +5,23 @@
  */
 
 import { messagesToConversations, Presentation, type PresentationOptions } from "../presentation";
-import type { AgentX, ImageNamespace, PresentationNamespace } from "../types";
+import type { AgentX, PresentationNamespace, SessionNamespace } from "../types";
 
 /**
  * Create presentation namespace.
  *
- * Takes the full AgentX (for Presentation event wiring) and the ImageNamespace
- * (for message history), avoiding circular access to `instance` during construction.
+ * Takes the full AgentX (for Presentation event wiring) and the SessionNamespace
+ * (for message history via instanceId).
  */
 export function createPresentations(
   agentx: AgentX,
-  imageNs: ImageNamespace
+  sessionNs: SessionNamespace
 ): PresentationNamespace {
   return {
-    async create(agentId: string, options?: PresentationOptions): Promise<Presentation> {
-      const messages = await imageNs.getMessages(agentId);
+    async create(instanceId: string, options?: PresentationOptions): Promise<Presentation> {
+      const messages = await sessionNs.getMessages(instanceId);
       const conversations = messagesToConversations(messages);
-      return new Presentation(agentx, agentId, options, conversations);
+      return new Presentation(agentx, instanceId, options, conversations);
     },
   };
 }