agentxjs 2.6.1 → 2.8.0

package/dist/server-MVOHQ5ZM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/server.ts"],"sourcesContent":["/**\n * AgentX Server Implementation (JSON-RPC 2.0)\n *\n * Creates a WebSocket server that:\n * 1. Accepts client connections\n * 2. Handles JSON-RPC requests directly via CommandHandler\n * 3. Broadcasts stream events as JSON-RPC notifications\n *\n * Message Types:\n * - RPC Request (has id): Client → Server → Client (direct response)\n * - RPC Notification (no id): Server → Client (stream events)\n */\n\nimport type { CreateDriver } from \"@agentxjs/core/driver\";\nimport type { BusEvent, SystemEvent } from \"@agentxjs/core/event\";\nimport type { ChannelConnection } from \"@agentxjs/core/network\";\nimport {\n  createErrorResponse,\n  createStreamEvent,\n  createSuccessResponse,\n  isNotification,\n  isRequest,\n  parseMessage,\n  RpcErrorCodes,\n  type RpcMethod,\n} from \"@agentxjs/core/network\";\nimport type { AgentXPlatform } from \"@agentxjs/core/runtime\";\nimport { createAgentXRuntime } from \"@agentxjs/core/runtime\";\nimport { createLogger } from \"@deepracticex/logger\";\nimport { CommandHandler } from \"./CommandHandler\";\nimport type { AgentXServer } from \"./types\";\n\nconst logger = createLogger(\"server/Server\");\n\n/**\n * Connection state\n */\ninterface ConnectionState {\n  connection: ChannelConnection;\n  subscribedTopics: Set<string>;\n}\n\n/**\n * Server configuration (supports both immediate and deferred platforms)\n */\nexport interface ServerConfig {\n  /**\n   * AgentX Platform — must provide `channelServer` for accepting WebSocket connections.\n   */\n  platform: AgentXPlatform;\n\n  /**\n   * LLM Driver factory function - creates Driver per Agent\n   */\n  createDriver: CreateDriver;\n\n  /**\n   * Port to listen on (standalone mode)\n   */\n  port?: number;\n\n  /**\n   * Host to bind to (default: \"0.0.0.0\")\n   */\n  host?: string;\n\n  /**\n   * Existing HTTP server to attach to (attached mode)\n   */\n  server?: import(\"@agentxjs/core/network\").MinimalHTTPServer;\n\n  /**\n   * WebSocket path when attached (default: \"/ws\")\n   */\n  wsPath?: string;\n\n  /**\n   * Enable debug logging\n   */\n  debug?: boolean;\n}\n\n/**\n * Create an AgentX server\n */\nexport async function createServer(config: ServerConfig): Promise<AgentXServer> {\n  const { wsPath = \"/ws\" } = config;\n  const platform = config.platform;\n\n  // Create runtime from platform + driver\n  const runtime = createAgentXRuntime(platform, config.createDriver);\n\n  // Get channel server from platform\n  const wsServer = platform.channelServer;\n  if (!wsServer) {\n    throw new Error(\"Platform must provide channelServer for server mode\");\n  }\n\n  // Create command handler (no longer needs eventBus)\n  const commandHandler = new CommandHandler(runtime);\n\n  // Track connections\n  const connections = new Map<string, ConnectionState>();\n\n  /**\n   * Subscribe connection to a topic\n   */\n  function subscribeToTopic(connectionId: string, topic: string): void {\n    const state = connections.get(connectionId);\n    if (!state || state.subscribedTopics.has(topic)) return;\n\n    state.subscribedTopics.add(topic);\n    logger.debug(\"Connection subscribed to topic\", { connectionId, topic });\n  }\n\n  /**\n   * Check if event should be sent to connection based on subscriptions\n   */\n  function shouldSendToConnection(state: ConnectionState, event: BusEvent): boolean {\n    // Skip internal driver events\n    if (event.source === \"driver\" && event.intent !== \"notification\") {\n      return false;\n    }\n\n    // Skip command events (they are handled via RPC, not broadcast)\n    if (event.source === \"command\") {\n      return false;\n    }\n\n    // Check if subscribed to event's session\n    const eventWithContext = event as BusEvent & { context?: { sessionId?: string } };\n    const sessionId = eventWithContext.context?.sessionId;\n    if (sessionId && state.subscribedTopics.has(sessionId)) {\n      return true;\n    }\n\n    // Send to global subscribers\n    return state.subscribedTopics.has(\"global\");\n  }\n\n  /**\n   * Send JSON-RPC response to a specific connection\n   */\n  function sendResponse(connection: ChannelConnection, id: string | number, result: unknown): void {\n    const response = createSuccessResponse(id, result);\n    connection.send(JSON.stringify(response));\n  }\n\n  /**\n   * Send JSON-RPC error to a specific connection\n   */\n  function sendError(\n    connection: ChannelConnection,\n    id: string | number | null,\n    code: number,\n    message: string\n  ): void {\n    const response = createErrorResponse(id, code, message);\n    connection.send(JSON.stringify(response));\n  }\n\n  // Handle new connections\n  wsServer.onConnection((connection) => {\n    const state: ConnectionState = {\n      connection,\n      subscribedTopics: new Set([\"global\"]),\n    };\n    connections.set(connection.id, state);\n\n    logger.info(\"Client connected\", {\n      connectionId: connection.id,\n      totalConnections: connections.size,\n    });\n\n    // Handle messages from client\n    connection.onMessage(async (message) => {\n      try {\n        const parsed = parseMessage(message);\n\n        // Handle single message (not batch)\n        if (!Array.isArray(parsed)) {\n          await handleParsedMessage(connection, state, parsed);\n        } else {\n          // Handle batch (not common, but supported by JSON-RPC 2.0)\n          for (const item of parsed) {\n            await handleParsedMessage(connection, state, item);\n          }\n        }\n      } catch (err) {\n        logger.error(\"Failed to parse message\", { error: (err as Error).message });\n        sendError(connection, null, RpcErrorCodes.PARSE_ERROR, \"Parse error\");\n      }\n    });\n\n    // Cleanup on disconnect\n    connection.onClose(() => {\n      connections.delete(connection.id);\n      logger.info(\"Client disconnected\", {\n        connectionId: connection.id,\n        totalConnections: connections.size,\n      });\n    });\n  });\n\n  /**\n   * Handle a parsed JSON-RPC message\n   */\n  async function handleParsedMessage(\n    connection: ChannelConnection,\n    state: ConnectionState,\n    parsed: import(\"jsonrpc-lite\").IParsedObject\n  ): Promise<void> {\n    if (isRequest(parsed)) {\n      // JSON-RPC Request - handle and respond directly\n      const payload = parsed.payload as {\n        id: string | number;\n        method: string;\n        params: unknown;\n      };\n      const { id, method, params } = payload;\n\n      logger.debug(\"Received RPC request\", { id, method });\n\n      // Call command handler\n      const result = await commandHandler.handle(method as RpcMethod, params);\n\n      if (result.success) {\n        sendResponse(connection, id, result.data);\n      } else {\n        sendError(connection, id, result.code, result.message);\n      }\n    } else if (isNotification(parsed)) {\n      // JSON-RPC Notification - control messages\n      const payload = parsed.payload as {\n        method: string;\n        params: unknown;\n      };\n      const { method, params } = payload;\n\n      logger.debug(\"Received notification\", { method });\n\n      if (method === \"subscribe\") {\n        const { topic } = params as { topic: string };\n        subscribeToTopic(connection.id, topic);\n      } else if (method === \"unsubscribe\") {\n        const { topic } = params as { topic: string };\n        state.subscribedTopics.delete(topic);\n        logger.debug(\"Connection unsubscribed from topic\", { connectionId: connection.id, topic });\n      } else if (method === \"control.ack\") {\n        // ACK for reliable delivery - handled by network layer\n        logger.debug(\"Received ACK notification\");\n      }\n    } else {\n      // Invalid message\n      logger.warn(\"Received invalid JSON-RPC message\");\n    }\n  }\n\n  // Route internal events to connected clients as JSON-RPC notifications\n  platform.eventBus.onAny((event) => {\n    // Only broadcast broadcastable events\n    if (!shouldBroadcastEvent(event)) {\n      return;\n    }\n\n    // Get topic from event context\n    const eventWithContext = event as BusEvent & { context?: { sessionId?: string } };\n    const topic = eventWithContext.context?.sessionId || \"global\";\n\n    // Wrap as JSON-RPC notification\n    const notification = createStreamEvent(topic, event as SystemEvent);\n    const message = JSON.stringify(notification);\n\n    for (const [connectionId, state] of connections) {\n      if (shouldSendToConnection(state, event)) {\n        state.connection.sendReliable(message, {\n          timeout: 10000,\n          onTimeout: () => {\n            logger.warn(\"Event ACK timeout\", {\n              connectionId,\n              eventType: event.type,\n            });\n          },\n        });\n      }\n    }\n  });\n\n  /**\n   * Check if event should be broadcast\n   */\n  function shouldBroadcastEvent(event: BusEvent): boolean {\n    // Skip internal driver events\n    if (event.source === \"driver\" && event.intent !== \"notification\") {\n      return false;\n    }\n\n    // Skip command events (handled via RPC)\n    if (event.source === \"command\") {\n      return false;\n    }\n\n    // Check broadcastable flag\n    const systemEvent = event as SystemEvent;\n    if (systemEvent.broadcastable === false) {\n      return false;\n    }\n\n    return true;\n  }\n\n  // Attach to existing server if provided\n  if (config.server) {\n    wsServer.attach(config.server, wsPath);\n    logger.info(\"WebSocket attached to existing server\", { path: wsPath });\n  }\n\n  return {\n    async listen(port?: number, host?: string) {\n      if (config.server) {\n        throw new Error(\n          \"Cannot listen when attached to existing server. The server should call listen() instead.\"\n        );\n      }\n\n      const listenPort = port ?? config.port ?? 5200;\n      const listenHost = host ?? config.host ?? \"0.0.0.0\";\n\n      await wsServer.listen(listenPort, listenHost);\n      logger.info(\"Server listening\", { port: listenPort, host: listenHost });\n    },\n\n    async close() {\n      await wsServer.close();\n      logger.info(\"Server closed\");\n    },\n\n    async dispose() {\n      // Cleanup in order\n      await wsServer.dispose();\n      commandHandler.dispose();\n      await runtime.shutdown();\n      logger.info(\"Server disposed\");\n    },\n  };\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentxjs",
-  "version": "2.6.1",
+  "version": "2.8.0",
   "description": "AgentX Client SDK - Local and remote AI agent management",
   "license": "MIT",
   "type": "module",
@@ -23,12 +23,12 @@
     "test": "bun test bdd/"
   },
   "dependencies": {
-    "@agentxjs/core": "^2.6.1",
+    "@agentxjs/core": "^2.8.0",
     "@deepracticex/id": "^0.2.0",
     "@deepracticex/logger": "^1.2.0"
   },
   "devDependencies": {
-    "@agentxjs/devtools": "^2.6.1",
+    "@agentxjs/devtools": "^2.8.0",
     "@deepracticex/bdd": "^0.3.0",
     "tsx": "^4.19.0",
     "typescript": "^5.3.3"

package/src/AgentHandle.ts

@@ -7,15 +7,15 @@
 import type { Message } from "@agentxjs/core/agent";
 import type { Presentation, PresentationOptions } from "./presentation";
 import type {
+  AgentConfig,
   AgentHandle,
   BaseResponse,
-  Embodiment,
   MessageSendResponse,
   RuntimeNamespace,
 } from "./types";
 
 export class AgentHandleImpl implements AgentHandle {
-  readonly agentId: string;
+  readonly instanceId: string;
   readonly imageId: string;
   readonly containerId: string;
   readonly sessionId: string;
@@ -23,10 +23,10 @@ export class AgentHandleImpl implements AgentHandle {
   private readonly ns: RuntimeNamespace;
 
   constructor(
-    ids: { agentId: string; imageId: string; containerId: string; sessionId: string },
+    ids: { instanceId: string; imageId: string; containerId: string; sessionId: string },
     ns: RuntimeNamespace
   ) {
-    this.agentId = ids.agentId;
+    this.instanceId = ids.instanceId;
     this.imageId = ids.imageId;
     this.containerId = ids.containerId;
     this.sessionId = ids.sessionId;
@@ -34,11 +34,11 @@ export class AgentHandleImpl implements AgentHandle {
   }
 
   async send(content: string | unknown[]): Promise<MessageSendResponse> {
-    return this.ns.session.send(this.agentId, content);
+    return this.ns.session.send(this.instanceId, content);
   }
 
   async interrupt(): Promise<BaseResponse> {
-    return this.ns.session.interrupt(this.agentId);
+    return this.ns.session.interrupt(this.instanceId);
   }
 
   async history(): Promise<Message[]> {
@@ -46,20 +46,22 @@ export class AgentHandleImpl implements AgentHandle {
   }
 
   async present(options?: PresentationOptions): Promise<Presentation> {
-    return this.ns.present.create(this.agentId, options);
+    return this.ns.present.create(this.instanceId, options);
   }
 
-  async update(updates: {
-    name?: string;
-    description?: string;
-    embody?: Embodiment;
-    customData?: Record<string, unknown>;
-  }): Promise<void> {
+  async update(
+    updates: Partial<
+      Pick<
+        AgentConfig,
+        "name" | "description" | "model" | "systemPrompt" | "mcpServers" | "customData"
+      >
+    >
+  ): Promise<void> {
     await this.ns.image.update(this.imageId, updates);
   }
 
   async delete(): Promise<void> {
-    await this.ns.agent.destroy(this.agentId);
+    await this.ns.instance.destroy(this.instanceId);
     await this.ns.image.delete(this.imageId);
   }
 }

package/src/CommandHandler.ts

@@ -8,6 +8,7 @@
  */
 
 import type { UserContentPart } from "@agentxjs/core/agent";
+import { DEFAULT_CONTAINER_ID } from "@agentxjs/core/container";
 import type { RpcMethod } from "@agentxjs/core/network";
 import type { AgentXRuntime } from "@agentxjs/core/runtime";
 import { createLogger } from "@deepracticex/logger";
@@ -63,14 +64,6 @@ export class CommandHandler {
 
     try {
       switch (method) {
-        // Container
-        case "container.create":
-          return await this.handleContainerCreate(params);
-        case "container.get":
-          return await this.handleContainerGet(params);
-        case "container.list":
-          return await this.handleContainerList(params);
-
         // Image
         case "image.create":
           return await this.handleImageCreate(params);
@@ -89,34 +82,22 @@ export class CommandHandler {
         case "image.messages":
           return await this.handleImageMessages(params);
 
-        // Agent
-        case "agent.get":
+        // Instance
+        case "instance.get":
           return await this.handleAgentGet(params);
-        case "agent.list":
+        case "instance.list":
           return await this.handleAgentList(params);
-        case "agent.destroy":
+        case "instance.destroy":
           return await this.handleAgentDestroy(params);
-        case "agent.destroyAll":
+        case "instance.destroyAll":
           return await this.handleAgentDestroyAll(params);
-        case "agent.interrupt":
+        case "instance.interrupt":
           return await this.handleAgentInterrupt(params);
 
         // Message
         case "message.send":
           return await this.handleMessageSend(params);
 
-        // Prototype
-        case "prototype.create":
-          return await this.handlePrototypeCreate(params);
-        case "prototype.get":
-          return await this.handlePrototypeGet(params);
-        case "prototype.list":
-          return await this.handlePrototypeList(params);
-        case "prototype.update":
-          return await this.handlePrototypeUpdate(params);
-        case "prototype.delete":
-          return await this.handlePrototypeDelete(params);
-
         // LLM Provider
         case "llm.create":
           return await this.handleLLMCreate(params);
@@ -140,50 +121,39 @@ export class CommandHandler {
     }
   }
 
-  // ==================== Container Commands ====================
-
-  private async handleContainerCreate(params: unknown): Promise<RpcResponse> {
-    const { containerId } = params as { containerId: string };
-    const { getOrCreateContainer } = await import("@agentxjs/core/container");
-    const { containerRepository, imageRepository, sessionRepository } = this.runtime.platform;
-
-    const container = await getOrCreateContainer(containerId, {
-      containerRepository,
-      imageRepository,
-      sessionRepository,
-    });
-
-    return ok({ containerId: container.containerId });
-  }
-
-  private async handleContainerGet(params: unknown): Promise<RpcResponse> {
-    const { containerId } = params as { containerId: string };
-    const exists = await this.runtime.platform.containerRepository.containerExists(containerId);
-    return ok({ containerId, exists });
-  }
-
-  private async handleContainerList(_params: unknown): Promise<RpcResponse> {
-    const containers = await this.runtime.platform.containerRepository.findAllContainers();
-    return ok({ containerIds: containers.map((c) => c.containerId) });
-  }
-
   // ==================== Image Commands ====================
 
   private async handleImageCreate(params: unknown): Promise<RpcResponse> {
-    const { containerId, name, description, contextId, embody, customData } = params as {
-      containerId: string;
+    const {
+      containerId: _cid,
+      name,
+      description,
+      contextId,
+      model,
+      systemPrompt,
+      mcpServers,
+      customData,
+    } = params as {
+      containerId?: string;
       name?: string;
       description?: string;
       contextId?: string;
-      embody?: import("@agentxjs/core/persistence").Embodiment;
+      model?: string;
+      systemPrompt?: string;
+      mcpServers?: Record<string, unknown>;
       customData?: Record<string, unknown>;
     };
 
     const { imageRepository, sessionRepository } = this.runtime.platform;
     const { createImage } = await import("@agentxjs/core/image");
 
+    const embody =
+      model || systemPrompt || mcpServers
+        ? ({ model, systemPrompt, mcpServers } as import("@agentxjs/core/persistence").Embodiment)
+        : undefined;
+
     const image = await createImage(
-      { containerId, name, description, contextId, embody, customData },
+      { containerId: DEFAULT_CONTAINER_ID, name, description, contextId, embody, customData },
       { imageRepository, sessionRepository }
     );
 
@@ -228,9 +198,9 @@ export class CommandHandler {
   }
 
   private async handleImageRun(params: unknown): Promise<RpcResponse> {
-    const { imageId, agentId: requestedAgentId } = params as {
+    const { imageId, instanceId: requestedInstanceId } = params as {
       imageId: string;
-      agentId?: string;
+      instanceId?: string;
     };
 
     // Check if already have a running agent for this image
@@ -241,30 +211,30 @@ export class CommandHandler {
     if (existingAgent) {
       logger.debug("Reusing existing agent for image", {
         imageId,
-        agentId: existingAgent.agentId,
+        instanceId: existingAgent.instanceId,
       });
       return ok({
         imageId,
-        agentId: existingAgent.agentId,
+        instanceId: existingAgent.instanceId,
         sessionId: existingAgent.sessionId,
         containerId: existingAgent.containerId,
         reused: true,
       });
     }
 
-    // Create new agent (with optional custom agentId)
+    // Create new agent (with optional custom instanceId)
     const agent = await this.runtime.createAgent({
       imageId,
-      agentId: requestedAgentId,
+      instanceId: requestedInstanceId,
     });
     logger.info("Created new agent for image", {
       imageId,
-      agentId: agent.agentId,
+      instanceId: agent.instanceId,
     });
 
     return ok({
       imageId,
-      agentId: agent.agentId,
+      instanceId: agent.instanceId,
       sessionId: agent.sessionId,
       containerId: agent.containerId,
       reused: false,
@@ -280,8 +250,8 @@ export class CommandHandler {
       .find((a) => a.imageId === imageId && a.lifecycle === "running");
 
     if (agent) {
-      await this.runtime.stopAgent(agent.agentId);
-      logger.info("Stopped agent for image", { imageId, agentId: agent.agentId });
+      await this.runtime.stopAgent(agent.instanceId);
+      logger.info("Stopped agent for image", { imageId, instanceId: agent.instanceId });
     } else {
       logger.debug("No running agent found for image", { imageId });
     }
@@ -295,7 +265,9 @@ export class CommandHandler {
       updates: {
         name?: string;
         description?: string;
-        embody?: import("@agentxjs/core/persistence").Embodiment;
+        model?: string;
+        systemPrompt?: string;
+        mcpServers?: Record<string, unknown>;
         customData?: Record<string, unknown>;
       };
     };
@@ -306,12 +278,22 @@ export class CommandHandler {
       return err(404, `Image not found: ${imageId}`);
     }
 
-    // Update image record (embody is merged, not replaced)
-    const { embody: embodyUpdates, ...otherUpdates } = updates;
+    // Extract embody fields from flat updates
+    const { model, systemPrompt, mcpServers, ...otherUpdates } = updates;
+    const embodyUpdates =
+      model !== undefined || systemPrompt !== undefined || mcpServers !== undefined
+        ? ({
+            ...imageRecord.embody,
+            model,
+            systemPrompt,
+            mcpServers,
+          } as import("@agentxjs/core/persistence").Embodiment)
+        : imageRecord.embody;
+
     const updatedRecord = {
       ...imageRecord,
       ...otherUpdates,
-      embody: embodyUpdates ? { ...imageRecord.embody, ...embodyUpdates } : imageRecord.embody,
+      embody: embodyUpdates,
       updatedAt: Date.now(),
     };
 
@@ -344,13 +326,13 @@ export class CommandHandler {
   // ==================== Agent Commands ====================
 
   private async handleAgentGet(params: unknown): Promise<RpcResponse> {
-    const { agentId } = params as { agentId: string };
-    const agent = this.runtime.getAgent(agentId);
+    const { instanceId } = params as { instanceId: string };
+    const agent = this.runtime.getAgent(instanceId);
 
     return ok({
       agent: agent
         ? {
-            agentId: agent.agentId,
+            instanceId: agent.instanceId,
             imageId: agent.imageId,
             containerId: agent.containerId,
             sessionId: agent.sessionId,
@@ -369,7 +351,7 @@ export class CommandHandler {
 
     return ok({
       agents: agents.map((a) => ({
-        agentId: a.agentId,
+        instanceId: a.instanceId,
         imageId: a.imageId,
         containerId: a.containerId,
         sessionId: a.sessionId,
@@ -379,47 +361,47 @@ export class CommandHandler {
   }
 
   private async handleAgentDestroy(params: unknown): Promise<RpcResponse> {
-    const { agentId } = params as { agentId: string };
+    const { instanceId } = params as { instanceId: string };
 
     // Check if agent exists first
-    const agent = this.runtime.getAgent(agentId);
+    const agent = this.runtime.getAgent(instanceId);
     if (!agent) {
-      return ok({ agentId, success: false });
+      return ok({ instanceId, success: false });
     }
 
-    await this.runtime.destroyAgent(agentId);
-    return ok({ agentId, success: true });
+    await this.runtime.destroyAgent(instanceId);
+    return ok({ instanceId, success: true });
   }
 
   private async handleAgentDestroyAll(params: unknown): Promise<RpcResponse> {
     const { containerId } = params as { containerId: string };
     const agents = this.runtime.getAgentsByContainer(containerId);
     for (const agent of agents) {
-      await this.runtime.destroyAgent(agent.agentId);
+      await this.runtime.destroyAgent(agent.instanceId);
     }
     return ok({ containerId });
   }
 
   private async handleAgentInterrupt(params: unknown): Promise<RpcResponse> {
-    const { agentId } = params as { agentId: string };
-    this.runtime.interrupt(agentId);
-    return ok({ agentId });
+    const { instanceId } = params as { instanceId: string };
+    this.runtime.interrupt(instanceId);
+    return ok({ instanceId });
   }
 
   // ==================== Message Commands ====================
 
   private async handleMessageSend(params: unknown): Promise<RpcResponse> {
-    const { agentId, imageId, content } = params as {
-      agentId?: string;
+    const { instanceId, imageId, content } = params as {
+      instanceId?: string;
       imageId?: string;
       content: string | UserContentPart[];
     };
 
-    let targetAgentId: string;
+    let targetInstanceId: string;
 
-    if (agentId) {
+    if (instanceId) {
       // Direct agent reference
-      targetAgentId = agentId;
+      targetInstanceId = instanceId;
     } else if (imageId) {
       // Auto-activate image: find or create agent
       const existingAgent = this.runtime
@@ -427,138 +409,41 @@ export class CommandHandler {
         .find((a) => a.imageId === imageId && a.lifecycle === "running");
 
       if (existingAgent) {
-        targetAgentId = existingAgent.agentId;
+        targetInstanceId = existingAgent.instanceId;
         logger.debug("Using existing agent for message", {
           imageId,
-          agentId: targetAgentId,
+          instanceId: targetInstanceId,
         });
       } else {
         // Create new agent for this image
         const agent = await this.runtime.createAgent({ imageId });
-        targetAgentId = agent.agentId;
+        targetInstanceId = agent.instanceId;
         logger.info("Auto-created agent for message", {
           imageId,
-          agentId: targetAgentId,
+          instanceId: targetInstanceId,
         });
       }
     } else {
-      return err(-32602, "Either agentId or imageId is required");
-    }
-
-    await this.runtime.receive(targetAgentId, content);
-    return ok({ agentId: targetAgentId, imageId });
-  }
-
-  // ==================== Prototype Commands ====================
-
-  private async handlePrototypeCreate(params: unknown): Promise<RpcResponse> {
-    const { containerId, name, description, contextId, embody, customData } = params as {
-      containerId: string;
-      name: string;
-      description?: string;
-      contextId?: string;
-      embody?: import("@agentxjs/core/persistence").Embodiment;
-      customData?: Record<string, unknown>;
-    };
-
-    const repo = this.runtime.platform.prototypeRepository;
-    if (!repo) {
-      return err(-32000, "Prototype repository not available");
-    }
-
-    const now = Date.now();
-    const random = Math.random().toString(36).slice(2, 8);
-    const record = {
-      prototypeId: `proto_${now}_${random}`,
-      containerId,
-      name,
-      description,
-      contextId,
-      embody,
-      customData,
-      createdAt: now,
-      updatedAt: now,
-    };
-
-    await repo.savePrototype(record);
-    return ok({ record });
-  }
-
-  private async handlePrototypeGet(params: unknown): Promise<RpcResponse> {
-    const { prototypeId } = params as { prototypeId: string };
-    const repo = this.runtime.platform.prototypeRepository;
-    if (!repo) {
-      return err(-32000, "Prototype repository not available");
-    }
-
-    const record = await repo.findPrototypeById(prototypeId);
-    return ok({ record });
-  }
-
-  private async handlePrototypeList(params: unknown): Promise<RpcResponse> {
-    const { containerId } = params as { containerId?: string };
-    const repo = this.runtime.platform.prototypeRepository;
-    if (!repo) {
-      return err(-32000, "Prototype repository not available");
-    }
-
-    const records = containerId
-      ? await repo.findPrototypesByContainerId(containerId)
-      : await repo.findAllPrototypes();
-
-    return ok({ records });
-  }
-
-  private async handlePrototypeUpdate(params: unknown): Promise<RpcResponse> {
-    const { prototypeId, updates } = params as {
-      prototypeId: string;
-      updates: {
-        name?: string;
-        description?: string;
-        contextId?: string;
-        embody?: import("@agentxjs/core/persistence").Embodiment;
-        customData?: Record<string, unknown>;
-      };
-    };
-
-    const repo = this.runtime.platform.prototypeRepository;
-    if (!repo) {
-      return err(-32000, "Prototype repository not available");
-    }
-
-    const existing = await repo.findPrototypeById(prototypeId);
-    if (!existing) {
-      return err(404, `Prototype not found: ${prototypeId}`);
+      return err(-32602, "Either instanceId or imageId is required");
     }
 
-    const { embody: embodyUpdates, ...otherUpdates } = updates;
-    const updated = {
-      ...existing,
-      ...otherUpdates,
-      embody: embodyUpdates ? { ...existing.embody, ...embodyUpdates } : existing.embody,
-      updatedAt: Date.now(),
-    };
-
-    await repo.savePrototype(updated);
-    return ok({ record: updated });
-  }
-
-  private async handlePrototypeDelete(params: unknown): Promise<RpcResponse> {
-    const { prototypeId } = params as { prototypeId: string };
-    const repo = this.runtime.platform.prototypeRepository;
-    if (!repo) {
-      return err(-32000, "Prototype repository not available");
-    }
-
-    await repo.deletePrototype(prototypeId);
-    return ok({ prototypeId });
+    await this.runtime.receive(targetInstanceId, content);
+    return ok({ instanceId: targetInstanceId, imageId });
   }
 
   // ==================== LLM Provider Commands ====================
 
   private async handleLLMCreate(params: unknown): Promise<RpcResponse> {
-    const { containerId, name, vendor, protocol, apiKey, baseUrl, model } = params as {
-      containerId: string;
+    const {
+      containerId: _cid,
+      name,
+      vendor,
+      protocol,
+      apiKey,
+      baseUrl,
+      model,
+    } = params as {
+      containerId?: string;
       name: string;
       vendor: string;
       protocol: string;
@@ -576,7 +461,7 @@ export class CommandHandler {
     const now = Date.now();
     const record = {
       id: generateId("llm"),
-      containerId,
+      containerId: DEFAULT_CONTAINER_ID,
       name,
       vendor,
       protocol: protocol as "anthropic" | "openai",