agentxjs 2.6.1 → 2.8.0

package/dist/chunk-JTHR3AK6.js

@@ -1,652 +0,0 @@
-// src/server.ts
-import {
-  createErrorResponse,
-  createStreamEvent,
-  createSuccessResponse,
-  isNotification,
-  isRequest,
-  parseMessage,
-  RpcErrorCodes
-} from "@agentxjs/core/network";
-import { createAgentXRuntime } from "@agentxjs/core/runtime";
-import { createLogger as createLogger2 } from "@deepracticex/logger";
-
-// src/CommandHandler.ts
-import { createLogger } from "@deepracticex/logger";
-var logger = createLogger("server/CommandHandler");
-function ok(data) {
-  return { success: true, data };
-}
-function err(code, message) {
-  return { success: false, code, message };
-}
-var CommandHandler = class {
-  runtime;
-  constructor(runtime) {
-    this.runtime = runtime;
-    logger.debug("CommandHandler created");
-  }
-  /**
-   * Handle an RPC request and return response
-   */
-  async handle(method, params) {
-    logger.debug("Handling RPC request", { method });
-    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);
-        case "image.get":
-          return await this.handleImageGet(params);
-        case "image.list":
-          return await this.handleImageList(params);
-        case "image.delete":
-          return await this.handleImageDelete(params);
-        case "image.run":
-          return await this.handleImageRun(params);
-        case "image.stop":
-          return await this.handleImageStop(params);
-        case "image.update":
-          return await this.handleImageUpdate(params);
-        case "image.messages":
-          return await this.handleImageMessages(params);
-        // Agent
-        case "agent.get":
-          return await this.handleAgentGet(params);
-        case "agent.list":
-          return await this.handleAgentList(params);
-        case "agent.destroy":
-          return await this.handleAgentDestroy(params);
-        case "agent.destroyAll":
-          return await this.handleAgentDestroyAll(params);
-        case "agent.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);
-        case "llm.get":
-          return await this.handleLLMGet(params);
-        case "llm.list":
-          return await this.handleLLMList(params);
-        case "llm.update":
-          return await this.handleLLMUpdate(params);
-        case "llm.delete":
-          return await this.handleLLMDelete(params);
-        case "llm.default":
-          return await this.handleLLMDefault(params);
-        default:
-          return err(-32601, `Method not found: ${method}`);
-      }
-    } catch (error) {
-      logger.error("RPC handler error", { method, error });
-      return err(-32e3, error instanceof Error ? error.message : String(error));
-    }
-  }
-  // ==================== Container Commands ====================
-  async handleContainerCreate(params) {
-    const { containerId } = params;
-    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 });
-  }
-  async handleContainerGet(params) {
-    const { containerId } = params;
-    const exists = await this.runtime.platform.containerRepository.containerExists(containerId);
-    return ok({ containerId, exists });
-  }
-  async handleContainerList(_params) {
-    const containers = await this.runtime.platform.containerRepository.findAllContainers();
-    return ok({ containerIds: containers.map((c) => c.containerId) });
-  }
-  // ==================== Image Commands ====================
-  async handleImageCreate(params) {
-    const { containerId, name, description, contextId, embody, customData } = params;
-    const { imageRepository, sessionRepository } = this.runtime.platform;
-    const { createImage } = await import("@agentxjs/core/image");
-    const image = await createImage(
-      { containerId, name, description, contextId, embody, customData },
-      { imageRepository, sessionRepository }
-    );
-    return ok({
-      record: image.toRecord(),
-      __subscriptions: [image.sessionId]
-    });
-  }
-  async handleImageGet(params) {
-    const { imageId } = params;
-    const record = await this.runtime.platform.imageRepository.findImageById(imageId);
-    return ok({
-      record,
-      __subscriptions: record?.sessionId ? [record.sessionId] : void 0
-    });
-  }
-  async handleImageList(params) {
-    const { containerId } = params;
-    const records = containerId ? await this.runtime.platform.imageRepository.findImagesByContainerId(containerId) : await this.runtime.platform.imageRepository.findAllImages();
-    return ok({
-      records,
-      __subscriptions: records.map((r) => r.sessionId)
-    });
-  }
-  async handleImageDelete(params) {
-    const { imageId } = params;
-    const { loadImage } = await import("@agentxjs/core/image");
-    const { imageRepository, sessionRepository } = this.runtime.platform;
-    const image = await loadImage(imageId, { imageRepository, sessionRepository });
-    if (image) {
-      await image.delete();
-    }
-    return ok({ imageId });
-  }
-  async handleImageRun(params) {
-    const { imageId, agentId: requestedAgentId } = params;
-    const existingAgent = this.runtime.getAgents().find((a) => a.imageId === imageId && a.lifecycle === "running");
-    if (existingAgent) {
-      logger.debug("Reusing existing agent for image", {
-        imageId,
-        agentId: existingAgent.agentId
-      });
-      return ok({
-        imageId,
-        agentId: existingAgent.agentId,
-        sessionId: existingAgent.sessionId,
-        containerId: existingAgent.containerId,
-        reused: true
-      });
-    }
-    const agent = await this.runtime.createAgent({
-      imageId,
-      agentId: requestedAgentId
-    });
-    logger.info("Created new agent for image", {
-      imageId,
-      agentId: agent.agentId
-    });
-    return ok({
-      imageId,
-      agentId: agent.agentId,
-      sessionId: agent.sessionId,
-      containerId: agent.containerId,
-      reused: false
-    });
-  }
-  async handleImageStop(params) {
-    const { imageId } = params;
-    const agent = this.runtime.getAgents().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 });
-    } else {
-      logger.debug("No running agent found for image", { imageId });
-    }
-    return ok({ imageId });
-  }
-  async handleImageUpdate(params) {
-    const { imageId, updates } = params;
-    const imageRecord = await this.runtime.platform.imageRepository.findImageById(imageId);
-    if (!imageRecord) {
-      return err(404, `Image not found: ${imageId}`);
-    }
-    const { embody: embodyUpdates, ...otherUpdates } = updates;
-    const updatedRecord = {
-      ...imageRecord,
-      ...otherUpdates,
-      embody: embodyUpdates ? { ...imageRecord.embody, ...embodyUpdates } : imageRecord.embody,
-      updatedAt: Date.now()
-    };
-    await this.runtime.platform.imageRepository.saveImage(updatedRecord);
-    logger.info("Updated image", { imageId, updates });
-    return ok({ record: updatedRecord });
-  }
-  async handleImageMessages(params) {
-    const { imageId } = params;
-    const imageRecord = await this.runtime.platform.imageRepository.findImageById(imageId);
-    if (!imageRecord) {
-      return err(404, `Image not found: ${imageId}`);
-    }
-    const messages = await this.runtime.platform.sessionRepository.getMessages(
-      imageRecord.sessionId
-    );
-    logger.debug("Got messages for image", { imageId, count: messages.length });
-    return ok({ imageId, messages });
-  }
-  // ==================== Agent Commands ====================
-  async handleAgentGet(params) {
-    const { agentId } = params;
-    const agent = this.runtime.getAgent(agentId);
-    return ok({
-      agent: agent ? {
-        agentId: agent.agentId,
-        imageId: agent.imageId,
-        containerId: agent.containerId,
-        sessionId: agent.sessionId,
-        lifecycle: agent.lifecycle
-      } : null,
-      exists: !!agent
-    });
-  }
-  async handleAgentList(params) {
-    const { containerId } = params;
-    const agents = containerId ? this.runtime.getAgentsByContainer(containerId) : this.runtime.getAgents();
-    return ok({
-      agents: agents.map((a) => ({
-        agentId: a.agentId,
-        imageId: a.imageId,
-        containerId: a.containerId,
-        sessionId: a.sessionId,
-        lifecycle: a.lifecycle
-      }))
-    });
-  }
-  async handleAgentDestroy(params) {
-    const { agentId } = params;
-    const agent = this.runtime.getAgent(agentId);
-    if (!agent) {
-      return ok({ agentId, success: false });
-    }
-    await this.runtime.destroyAgent(agentId);
-    return ok({ agentId, success: true });
-  }
-  async handleAgentDestroyAll(params) {
-    const { containerId } = params;
-    const agents = this.runtime.getAgentsByContainer(containerId);
-    for (const agent of agents) {
-      await this.runtime.destroyAgent(agent.agentId);
-    }
-    return ok({ containerId });
-  }
-  async handleAgentInterrupt(params) {
-    const { agentId } = params;
-    this.runtime.interrupt(agentId);
-    return ok({ agentId });
-  }
-  // ==================== Message Commands ====================
-  async handleMessageSend(params) {
-    const { agentId, imageId, content } = params;
-    let targetAgentId;
-    if (agentId) {
-      targetAgentId = agentId;
-    } else if (imageId) {
-      const existingAgent = this.runtime.getAgents().find((a) => a.imageId === imageId && a.lifecycle === "running");
-      if (existingAgent) {
-        targetAgentId = existingAgent.agentId;
-        logger.debug("Using existing agent for message", {
-          imageId,
-          agentId: targetAgentId
-        });
-      } else {
-        const agent = await this.runtime.createAgent({ imageId });
-        targetAgentId = agent.agentId;
-        logger.info("Auto-created agent for message", {
-          imageId,
-          agentId: targetAgentId
-        });
-      }
-    } else {
-      return err(-32602, "Either agentId or imageId is required");
-    }
-    await this.runtime.receive(targetAgentId, content);
-    return ok({ agentId: targetAgentId, imageId });
-  }
-  // ==================== Prototype Commands ====================
-  async handlePrototypeCreate(params) {
-    const { containerId, name, description, contextId, embody, customData } = params;
-    const repo = this.runtime.platform.prototypeRepository;
-    if (!repo) {
-      return err(-32e3, "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 });
-  }
-  async handlePrototypeGet(params) {
-    const { prototypeId } = params;
-    const repo = this.runtime.platform.prototypeRepository;
-    if (!repo) {
-      return err(-32e3, "Prototype repository not available");
-    }
-    const record = await repo.findPrototypeById(prototypeId);
-    return ok({ record });
-  }
-  async handlePrototypeList(params) {
-    const { containerId } = params;
-    const repo = this.runtime.platform.prototypeRepository;
-    if (!repo) {
-      return err(-32e3, "Prototype repository not available");
-    }
-    const records = containerId ? await repo.findPrototypesByContainerId(containerId) : await repo.findAllPrototypes();
-    return ok({ records });
-  }
-  async handlePrototypeUpdate(params) {
-    const { prototypeId, updates } = params;
-    const repo = this.runtime.platform.prototypeRepository;
-    if (!repo) {
-      return err(-32e3, "Prototype repository not available");
-    }
-    const existing = await repo.findPrototypeById(prototypeId);
-    if (!existing) {
-      return err(404, `Prototype not found: ${prototypeId}`);
-    }
-    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 });
-  }
-  async handlePrototypeDelete(params) {
-    const { prototypeId } = params;
-    const repo = this.runtime.platform.prototypeRepository;
-    if (!repo) {
-      return err(-32e3, "Prototype repository not available");
-    }
-    await repo.deletePrototype(prototypeId);
-    return ok({ prototypeId });
-  }
-  // ==================== LLM Provider Commands ====================
-  async handleLLMCreate(params) {
-    const { containerId, name, vendor, protocol, apiKey, baseUrl, model } = params;
-    const repo = this.runtime.platform.llmProviderRepository;
-    if (!repo) {
-      return err(-32e3, "LLM provider repository not available");
-    }
-    const { generateId } = await import("@deepracticex/id");
-    const now = Date.now();
-    const record = {
-      id: generateId("llm"),
-      containerId,
-      name,
-      vendor,
-      protocol,
-      apiKey,
-      baseUrl,
-      model,
-      isDefault: false,
-      createdAt: now,
-      updatedAt: now
-    };
-    await repo.saveLLMProvider(record);
-    return ok({ record });
-  }
-  async handleLLMGet(params) {
-    const { id } = params;
-    const repo = this.runtime.platform.llmProviderRepository;
-    if (!repo) {
-      return err(-32e3, "LLM provider repository not available");
-    }
-    const record = await repo.findLLMProviderById(id);
-    return ok({ record });
-  }
-  async handleLLMList(params) {
-    const { containerId } = params;
-    const repo = this.runtime.platform.llmProviderRepository;
-    if (!repo) {
-      return err(-32e3, "LLM provider repository not available");
-    }
-    const records = await repo.findLLMProvidersByContainerId(containerId);
-    return ok({ records });
-  }
-  async handleLLMUpdate(params) {
-    const { id, updates } = params;
-    const repo = this.runtime.platform.llmProviderRepository;
-    if (!repo) {
-      return err(-32e3, "LLM provider repository not available");
-    }
-    const existing = await repo.findLLMProviderById(id);
-    if (!existing) {
-      return err(404, `LLM provider not found: ${id}`);
-    }
-    const updated = {
-      ...existing,
-      ...updates,
-      id: existing.id,
-      containerId: existing.containerId,
-      createdAt: existing.createdAt,
-      updatedAt: Date.now()
-    };
-    await repo.saveLLMProvider(updated);
-    return ok({ record: updated });
-  }
-  async handleLLMDelete(params) {
-    const { id } = params;
-    const repo = this.runtime.platform.llmProviderRepository;
-    if (!repo) {
-      return err(-32e3, "LLM provider repository not available");
-    }
-    await repo.deleteLLMProvider(id);
-    return ok({ id });
-  }
-  async handleLLMDefault(params) {
-    const { id, containerId } = params;
-    const repo = this.runtime.platform.llmProviderRepository;
-    if (!repo) {
-      return err(-32e3, "LLM provider repository not available");
-    }
-    if (id) {
-      await repo.setDefaultLLMProvider(id);
-      return ok({ id });
-    }
-    if (containerId) {
-      const record = await repo.findDefaultLLMProvider(containerId);
-      return ok({ record });
-    }
-    return err(-32602, "Either id or containerId is required");
-  }
-  // ==================== Lifecycle ====================
-  dispose() {
-    logger.debug("CommandHandler disposed");
-  }
-};
-
-// src/server.ts
-var logger2 = createLogger2("server/Server");
-async function createServer(config) {
-  const { wsPath = "/ws" } = config;
-  const platform = config.platform;
-  const runtime = createAgentXRuntime(platform, config.createDriver);
-  const wsServer = platform.channelServer;
-  if (!wsServer) {
-    throw new Error("Platform must provide channelServer for server mode");
-  }
-  const commandHandler = new CommandHandler(runtime);
-  const connections = /* @__PURE__ */ new Map();
-  function subscribeToTopic(connectionId, topic) {
-    const state = connections.get(connectionId);
-    if (!state || state.subscribedTopics.has(topic)) return;
-    state.subscribedTopics.add(topic);
-    logger2.debug("Connection subscribed to topic", { connectionId, topic });
-  }
-  function shouldSendToConnection(state, event) {
-    if (event.source === "driver" && event.intent !== "notification") {
-      return false;
-    }
-    if (event.source === "command") {
-      return false;
-    }
-    const eventWithContext = event;
-    const sessionId = eventWithContext.context?.sessionId;
-    if (sessionId && state.subscribedTopics.has(sessionId)) {
-      return true;
-    }
-    return state.subscribedTopics.has("global");
-  }
-  function sendResponse(connection, id, result) {
-    const response = createSuccessResponse(id, result);
-    connection.send(JSON.stringify(response));
-  }
-  function sendError(connection, id, code, message) {
-    const response = createErrorResponse(id, code, message);
-    connection.send(JSON.stringify(response));
-  }
-  wsServer.onConnection((connection) => {
-    const state = {
-      connection,
-      subscribedTopics: /* @__PURE__ */ new Set(["global"])
-    };
-    connections.set(connection.id, state);
-    logger2.info("Client connected", {
-      connectionId: connection.id,
-      totalConnections: connections.size
-    });
-    connection.onMessage(async (message) => {
-      try {
-        const parsed = parseMessage(message);
-        if (!Array.isArray(parsed)) {
-          await handleParsedMessage(connection, state, parsed);
-        } else {
-          for (const item of parsed) {
-            await handleParsedMessage(connection, state, item);
-          }
-        }
-      } catch (err2) {
-        logger2.error("Failed to parse message", { error: err2.message });
-        sendError(connection, null, RpcErrorCodes.PARSE_ERROR, "Parse error");
-      }
-    });
-    connection.onClose(() => {
-      connections.delete(connection.id);
-      logger2.info("Client disconnected", {
-        connectionId: connection.id,
-        totalConnections: connections.size
-      });
-    });
-  });
-  async function handleParsedMessage(connection, state, parsed) {
-    if (isRequest(parsed)) {
-      const payload = parsed.payload;
-      const { id, method, params } = payload;
-      logger2.debug("Received RPC request", { id, method });
-      const result = await commandHandler.handle(method, params);
-      if (result.success) {
-        sendResponse(connection, id, result.data);
-      } else {
-        sendError(connection, id, result.code, result.message);
-      }
-    } else if (isNotification(parsed)) {
-      const payload = parsed.payload;
-      const { method, params } = payload;
-      logger2.debug("Received notification", { method });
-      if (method === "subscribe") {
-        const { topic } = params;
-        subscribeToTopic(connection.id, topic);
-      } else if (method === "unsubscribe") {
-        const { topic } = params;
-        state.subscribedTopics.delete(topic);
-        logger2.debug("Connection unsubscribed from topic", { connectionId: connection.id, topic });
-      } else if (method === "control.ack") {
-        logger2.debug("Received ACK notification");
-      }
-    } else {
-      logger2.warn("Received invalid JSON-RPC message");
-    }
-  }
-  platform.eventBus.onAny((event) => {
-    if (!shouldBroadcastEvent(event)) {
-      return;
-    }
-    const eventWithContext = event;
-    const topic = eventWithContext.context?.sessionId || "global";
-    const notification = createStreamEvent(topic, event);
-    const message = JSON.stringify(notification);
-    for (const [connectionId, state] of connections) {
-      if (shouldSendToConnection(state, event)) {
-        state.connection.sendReliable(message, {
-          timeout: 1e4,
-          onTimeout: () => {
-            logger2.warn("Event ACK timeout", {
-              connectionId,
-              eventType: event.type
-            });
-          }
-        });
-      }
-    }
-  });
-  function shouldBroadcastEvent(event) {
-    if (event.source === "driver" && event.intent !== "notification") {
-      return false;
-    }
-    if (event.source === "command") {
-      return false;
-    }
-    const systemEvent = event;
-    if (systemEvent.broadcastable === false) {
-      return false;
-    }
-    return true;
-  }
-  if (config.server) {
-    wsServer.attach(config.server, wsPath);
-    logger2.info("WebSocket attached to existing server", { path: wsPath });
-  }
-  return {
-    async listen(port, host) {
-      if (config.server) {
-        throw new Error(
-          "Cannot listen when attached to existing server. The server should call listen() instead."
-        );
-      }
-      const listenPort = port ?? config.port ?? 5200;
-      const listenHost = host ?? config.host ?? "0.0.0.0";
-      await wsServer.listen(listenPort, listenHost);
-      logger2.info("Server listening", { port: listenPort, host: listenHost });
-    },
-    async close() {
-      await wsServer.close();
-      logger2.info("Server closed");
-    },
-    async dispose() {
-      await wsServer.dispose();
-      commandHandler.dispose();
-      await runtime.shutdown();
-      logger2.info("Server disposed");
-    }
-  };
-}
-
-export {
-  CommandHandler,
-  createServer
-};
-//# sourceMappingURL=chunk-JTHR3AK6.js.map