agentxjs 0.0.1

package/dist/server/index.cjs

@@ -0,0 +1,1093 @@
+'use strict';
+
+var types = require('@agentxjs/types');
+var common = require('@agentxjs/common');
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var logger = common.createLogger("agentx/SSEServerTransport");
+var SSEConnection = class {
+  constructor(connectionId, agentId) {
+    __publicField(this, "connectionId");
+    __publicField(this, "agentId");
+    __publicField(this, "_state", "connecting");
+    __publicField(this, "_controller", null);
+    __publicField(this, "_encoder", new TextEncoder());
+    __publicField(this, "_closeHandlers", []);
+    __publicField(this, "_unsubscribe", null);
+    __publicField(this, "_heartbeatInterval", null);
+    this.connectionId = connectionId;
+    this.agentId = agentId;
+    logger.debug("SSE connection created", {
+      connectionId,
+      agentId
+    });
+  }
+  get state() {
+    return this._state;
+  }
+  /**
+   * Create SSE Response stream
+   */
+  createResponse(agent) {
+    const stream = new ReadableStream({
+      start: (controller) => {
+        this._controller = controller;
+        this._state = "open";
+        this._unsubscribe = agent.on((event) => {
+          if (types.isStreamEvent(event)) {
+            this.send(event);
+          } else if (types.isErrorEvent(event)) {
+            this.sendError(event);
+          }
+        });
+        this._heartbeatInterval = setInterval(() => {
+          this.sendHeartbeat();
+        }, 3e4);
+      },
+      cancel: () => {
+        this.close();
+      }
+    });
+    return new Response(stream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+        "X-Accel-Buffering": "no"
+        // Disable nginx buffering
+      }
+    });
+  }
+  /**
+   * Send a Stream event to the client
+   */
+  send(event) {
+    if (this._state !== "open" || !this._controller) {
+      return;
+    }
+    try {
+      const eventType = event.type;
+      const data = JSON.stringify(event);
+      const message = `event: ${eventType}
+data: ${data}
+
+`;
+      this._controller.enqueue(this._encoder.encode(message));
+    } catch {
+      this.close();
+    }
+  }
+  /**
+   * Send an Error event to the client
+   *
+   * ErrorEvent is independent from Stream events but also transported via SSE.
+   */
+  sendError(event) {
+    if (this._state !== "open" || !this._controller) {
+      return;
+    }
+    try {
+      const eventType = event.type;
+      const data = JSON.stringify(event);
+      const message = `event: ${eventType}
+data: ${data}
+
+`;
+      this._controller.enqueue(this._encoder.encode(message));
+    } catch {
+      this.close();
+    }
+  }
+  /**
+   * Send heartbeat to keep connection alive
+   */
+  sendHeartbeat() {
+    if (this._state !== "open" || !this._controller) {
+      return;
+    }
+    try {
+      const message = `: heartbeat ${Date.now()}
+
+`;
+      this._controller.enqueue(this._encoder.encode(message));
+    } catch {
+      this.close();
+    }
+  }
+  /**
+   * Close the connection
+   */
+  close() {
+    if (this._state === "closed" || this._state === "closing") {
+      return;
+    }
+    logger.debug("Closing SSE connection", {
+      connectionId: this.connectionId,
+      agentId: this.agentId
+    });
+    this._state = "closing";
+    if (this._heartbeatInterval) {
+      clearInterval(this._heartbeatInterval);
+      this._heartbeatInterval = null;
+    }
+    if (this._unsubscribe) {
+      this._unsubscribe();
+      this._unsubscribe = null;
+    }
+    if (this._controller) {
+      try {
+        this._controller.close();
+      } catch {
+      }
+      this._controller = null;
+    }
+    this._state = "closed";
+    for (const handler of this._closeHandlers) {
+      try {
+        handler();
+      } catch {
+      }
+    }
+    this._closeHandlers = [];
+  }
+  /**
+   * Register close handler
+   */
+  onClose(handler) {
+    if (this._state === "closed") {
+      handler();
+    } else {
+      this._closeHandlers.push(handler);
+    }
+  }
+};
+var SSEConnectionManager = class {
+  constructor() {
+    __publicField(this, "_connections", /* @__PURE__ */ new Map());
+    __publicField(this, "_idCounter", 0);
+  }
+  /**
+   * Create a new SSE connection for an agent
+   */
+  createConnection(agent) {
+    const connectionId = `conn_${++this._idCounter}_${Date.now()}`;
+    const connection = new SSEConnection(connectionId, agent.agentId);
+    const response = connection.createResponse(agent);
+    this._connections.set(connectionId, connection);
+    connection.onClose(() => {
+      this._connections.delete(connectionId);
+    });
+    return { connection, response };
+  }
+  /**
+   * Get connection by ID
+   */
+  getConnection(connectionId) {
+    return this._connections.get(connectionId);
+  }
+  /**
+   * Get all connections for an agent
+   */
+  getConnectionsForAgent(agentId) {
+    return Array.from(this._connections.values()).filter((conn) => conn.agentId === agentId);
+  }
+  /**
+   * Close all connections for an agent
+   */
+  closeConnectionsForAgent(agentId) {
+    for (const conn of this.getConnectionsForAgent(agentId)) {
+      conn.close();
+    }
+  }
+  /**
+   * Close all connections
+   */
+  closeAll() {
+    for (const conn of this._connections.values()) {
+      conn.close();
+    }
+    this._connections.clear();
+  }
+  /**
+   * Get active connection count
+   */
+  get connectionCount() {
+    return this._connections.size;
+  }
+};
+var logger2 = common.createLogger("agentx/AgentXHandler");
+var VERSION = "0.1.0";
+function createAgentXHandler(agentx, options = {}) {
+  const {
+    basePath = "",
+    allowDynamicCreation = false,
+    allowedDefinitions = [],
+    repository,
+    hooks = {}
+  } = options;
+  const sseManager = new SSEConnectionManager();
+  const definitions = /* @__PURE__ */ new Map();
+  function registerDefinition(name, definition, defaultConfig) {
+    definitions.set(name, { definition, defaultConfig });
+  }
+  function parseRequest(request) {
+    const url = new URL(request.url);
+    const method = request.method;
+    let path = url.pathname;
+    if (basePath && path.startsWith(basePath)) {
+      path = path.slice(basePath.length);
+    }
+    path = "/" + path.replace(/^\/+|\/+$/g, "");
+    if (method === "GET" && path === "/info") {
+      return { type: "platform_info" };
+    }
+    if (method === "GET" && path === "/health") {
+      return { type: "platform_health" };
+    }
+    if (method === "GET" && path === "/agents") {
+      return { type: "list_agents" };
+    }
+    if (method === "POST" && path === "/agents") {
+      return { type: "create_agent" };
+    }
+    const agentMatch = path.match(/^\/agents\/([^/]+)(\/.*)?$/);
+    if (agentMatch) {
+      const agentId = agentMatch[1];
+      const subPath = agentMatch[2] || "";
+      if (method === "GET" && subPath === "") {
+        return { type: "get_agent", agentId };
+      }
+      if (method === "DELETE" && subPath === "") {
+        return { type: "delete_agent", agentId };
+      }
+      if (method === "GET" && subPath === "/sse") {
+        return { type: "connect_sse", agentId };
+      }
+      if (method === "POST" && subPath === "/messages") {
+        return { type: "send_message", agentId };
+      }
+      if (method === "POST" && subPath === "/interrupt") {
+        return { type: "interrupt", agentId };
+      }
+    }
+    if (method === "GET" && path === "/definitions") {
+      return { type: "list_definitions" };
+    }
+    const definitionMatch = path.match(/^\/definitions\/([^/]+)$/);
+    if (definitionMatch) {
+      const definitionName = definitionMatch[1];
+      if (method === "GET") {
+        return { type: "get_definition", definitionName };
+      }
+      if (method === "PUT") {
+        return { type: "save_definition", definitionName };
+      }
+      if (method === "DELETE") {
+        return { type: "delete_definition", definitionName };
+      }
+      if (method === "HEAD") {
+        return { type: "head_definition", definitionName };
+      }
+    }
+    if (method === "GET" && path === "/images") {
+      return { type: "list_images" };
+    }
+    const imageMatch = path.match(/^\/images\/([^/]+)(\/.*)?$/);
+    if (imageMatch) {
+      const imageId = imageMatch[1];
+      const subPath = imageMatch[2] || "";
+      if (method === "GET" && subPath === "") {
+        return { type: "get_image", imageId };
+      }
+      if (method === "PUT" && subPath === "") {
+        return { type: "save_image", imageId };
+      }
+      if (method === "DELETE" && subPath === "") {
+        return { type: "delete_image", imageId };
+      }
+      if (method === "HEAD" && subPath === "") {
+        return { type: "head_image", imageId };
+      }
+      if (method === "GET" && subPath === "/sessions") {
+        return { type: "list_image_sessions", imageId };
+      }
+      if (method === "DELETE" && subPath === "/sessions") {
+        return { type: "delete_image_sessions", imageId };
+      }
+      if (method === "POST" && subPath === "/run") {
+        return { type: "run_image", imageId };
+      }
+    }
+    if (method === "GET" && path === "/sessions") {
+      return { type: "list_sessions" };
+    }
+    const sessionMatch = path.match(/^\/sessions\/([^/]+)(\/.*)?$/);
+    if (sessionMatch) {
+      const sessionId = sessionMatch[1];
+      const subPath = sessionMatch[2] || "";
+      if (method === "GET" && subPath === "") {
+        return { type: "get_session", sessionId };
+      }
+      if (method === "PUT" && subPath === "") {
+        return { type: "save_session", sessionId };
+      }
+      if (method === "DELETE" && subPath === "") {
+        return { type: "delete_session", sessionId };
+      }
+      if (method === "HEAD" && subPath === "") {
+        return { type: "head_session", sessionId };
+      }
+      if (method === "GET" && subPath === "/messages") {
+        return { type: "list_session_messages", sessionId };
+      }
+      if (method === "DELETE" && subPath === "/messages") {
+        return { type: "delete_session_messages", sessionId };
+      }
+      if (method === "GET" && subPath === "/messages/count") {
+        return { type: "count_session_messages", sessionId };
+      }
+      if (method === "POST" && subPath === "/resume") {
+        return { type: "resume_session", sessionId };
+      }
+    }
+    const userMatch = path.match(/^\/users\/([^/]+)\/sessions$/);
+    if (userMatch && method === "GET") {
+      return { type: "list_user_sessions", userId: userMatch[1] };
+    }
+    const messageMatch = path.match(/^\/messages\/([^/]+)$/);
+    if (messageMatch) {
+      const messageId = messageMatch[1];
+      if (method === "GET") {
+        return { type: "get_message", messageId };
+      }
+      if (method === "PUT") {
+        return { type: "save_message", messageId };
+      }
+      if (method === "DELETE") {
+        return { type: "delete_message", messageId };
+      }
+    }
+    if (method === "GET" && path === "/containers") {
+      return { type: "list_containers" };
+    }
+    if (method === "POST" && path === "/containers") {
+      return { type: "create_container" };
+    }
+    const containerMatch = path.match(/^\/containers\/([^/]+)$/);
+    if (containerMatch) {
+      const containerId = containerMatch[1];
+      if (method === "GET") {
+        return { type: "get_container", containerId };
+      }
+      if (method === "PUT") {
+        return { type: "save_container", containerId };
+      }
+      if (method === "DELETE") {
+        return { type: "delete_container", containerId };
+      }
+      if (method === "HEAD") {
+        return { type: "head_container", containerId };
+      }
+    }
+    return { type: "not_found" };
+  }
+  function jsonResponse(data, status = 200) {
+    return new Response(JSON.stringify(data), {
+      status,
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  }
+  function errorResponse(code, message, status) {
+    const body = {
+      error: { code, message }
+    };
+    return jsonResponse(body, status);
+  }
+  function getAgentOrError(agentId) {
+    const agent = agentx.agents.get(agentId);
+    if (!agent) {
+      return errorResponse("AGENT_NOT_FOUND", `Agent ${agentId} not found`, 404);
+    }
+    if (agent.lifecycle === "destroyed") {
+      return errorResponse("AGENT_DESTROYED", `Agent ${agentId} has been destroyed`, 410);
+    }
+    return agent;
+  }
+  function buildAgentInfo(agent) {
+    return {
+      agentId: agent.agentId,
+      name: agent.definition.name,
+      description: agent.definition.description,
+      lifecycle: agent.lifecycle,
+      state: agent.state,
+      createdAt: agent.createdAt
+    };
+  }
+  async function handlePlatformInfo() {
+    const response = {
+      platform: "AgentX",
+      version: VERSION,
+      agentCount: agentx.agents.list().length
+    };
+    return jsonResponse(response);
+  }
+  async function handleHealth() {
+    const response = {
+      status: "healthy",
+      timestamp: Date.now(),
+      agentCount: agentx.agents.list().length
+    };
+    return jsonResponse(response);
+  }
+  async function handleListAgents() {
+    const allAgents = agentx.agents.list();
+    const agents = allAgents.map((agent) => buildAgentInfo(agent));
+    const response = { agents };
+    return jsonResponse(response);
+  }
+  async function handleCreateAgent(request) {
+    if (!allowDynamicCreation) {
+      return errorResponse("DYNAMIC_CREATION_DISABLED", "Dynamic agent creation is disabled", 403);
+    }
+    let body;
+    try {
+      body = await request.json();
+    } catch {
+      return errorResponse("INVALID_REQUEST", "Invalid JSON body", 400);
+    }
+    if (!body.definition) {
+      return errorResponse("INVALID_REQUEST", "Missing 'definition' field", 400);
+    }
+    if (allowedDefinitions.length > 0 && !allowedDefinitions.includes(body.definition)) {
+      return errorResponse(
+        "DEFINITION_NOT_FOUND",
+        `Definition '${body.definition}' is not allowed`,
+        403
+      );
+    }
+    const registered = definitions.get(body.definition);
+    if (!registered) {
+      return errorResponse(
+        "DEFINITION_NOT_FOUND",
+        `Definition '${body.definition}' not found`,
+        404
+      );
+    }
+    const metaImage = await agentx.images.getMetaImage(body.definition);
+    if (!metaImage) {
+      return errorResponse(
+        "IMAGE_NOT_FOUND",
+        `MetaImage for definition '${body.definition}' not found`,
+        404
+      );
+    }
+    const agent = await agentx.images.run(metaImage.imageId);
+    const response = {
+      agentId: agent.agentId,
+      name: agent.definition.name,
+      lifecycle: agent.lifecycle,
+      state: agent.state,
+      createdAt: agent.createdAt,
+      endpoints: {
+        sse: `${basePath}/agents/${agent.agentId}/sse`,
+        messages: `${basePath}/agents/${agent.agentId}/messages`,
+        interrupt: `${basePath}/agents/${agent.agentId}/interrupt`
+      }
+    };
+    return jsonResponse(response, 201);
+  }
+  async function handleGetAgent(agentId) {
+    const result = getAgentOrError(agentId);
+    if (result instanceof Response) return result;
+    return jsonResponse(buildAgentInfo(result));
+  }
+  async function handleDeleteAgent(agentId) {
+    const result = getAgentOrError(agentId);
+    if (result instanceof Response) return result;
+    sseManager.closeConnectionsForAgent(agentId);
+    await agentx.agents.destroy(agentId);
+    return new Response(null, { status: 204 });
+  }
+  async function handleConnectSSE(agentId) {
+    const result = getAgentOrError(agentId);
+    if (result instanceof Response) return result;
+    const agent = result;
+    const { connection, response } = sseManager.createConnection(agent);
+    if (hooks.onConnect) {
+      try {
+        await hooks.onConnect(agentId, connection.connectionId);
+      } catch {
+      }
+    }
+    connection.onClose(() => {
+      if (hooks.onDisconnect) {
+        const result2 = hooks.onDisconnect(agentId, connection.connectionId);
+        if (result2 instanceof Promise) {
+          result2.catch(() => {
+          });
+        }
+      }
+    });
+    return response;
+  }
+  async function handleSendMessage(agentId, request) {
+    const result = getAgentOrError(agentId);
+    if (result instanceof Response) return result;
+    const agent = result;
+    if (agent.state !== "idle") {
+      return errorResponse("AGENT_BUSY", `Agent is currently ${agent.state}`, 409);
+    }
+    let body;
+    try {
+      body = await request.json();
+    } catch {
+      return errorResponse("INVALID_REQUEST", "Invalid JSON body", 400);
+    }
+    if (!body.content) {
+      return errorResponse("INVALID_REQUEST", "Missing 'content' field", 400);
+    }
+    const message = {
+      id: `msg_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,
+      role: "user",
+      subtype: "user",
+      content: typeof body.content === "string" ? body.content : body.content,
+      timestamp: Date.now()
+    };
+    if (hooks.onMessage) {
+      try {
+        await hooks.onMessage(agentId, message);
+      } catch {
+      }
+    }
+    agent.receive(message).catch((error) => {
+      if (hooks.onError) {
+        const result2 = hooks.onError(agentId, error);
+        if (result2 instanceof Promise) {
+          result2.catch(() => {
+          });
+        }
+      }
+    });
+    const response = {
+      status: "processing"
+    };
+    return jsonResponse(response, 202);
+  }
+  async function handleInterrupt(agentId) {
+    const result = getAgentOrError(agentId);
+    if (result instanceof Response) return result;
+    const agent = result;
+    agent.interrupt();
+    const response = {
+      interrupted: true
+    };
+    return jsonResponse(response);
+  }
+  function getRepository() {
+    if (!repository) {
+      throw new Error(
+        "Repository not configured. Pass 'repository' option to createAgentXHandler."
+      );
+    }
+    return repository;
+  }
+  async function handleListDefinitions() {
+    const repo = getRepository();
+    const definitions2 = await repo.findAllDefinitions();
+    return jsonResponse(definitions2);
+  }
+  async function handleGetDefinition(name) {
+    const repo = getRepository();
+    const definition = await repo.findDefinitionByName(name);
+    if (!definition) {
+      return errorResponse("INVALID_REQUEST", `Definition ${name} not found`, 404);
+    }
+    return jsonResponse(definition);
+  }
+  async function handleSaveDefinition(name, request) {
+    const repo = getRepository();
+    let body;
+    try {
+      body = await request.json();
+    } catch {
+      return errorResponse("INVALID_REQUEST", "Invalid JSON body", 400);
+    }
+    await repo.saveDefinition({ ...body, name });
+    return new Response(null, { status: 204 });
+  }
+  async function handleDeleteDefinition(name) {
+    const repo = getRepository();
+    await repo.deleteDefinition(name);
+    return new Response(null, { status: 204 });
+  }
+  async function handleHeadDefinition(name) {
+    const repo = getRepository();
+    const exists = await repo.definitionExists(name);
+    return new Response(null, { status: exists ? 200 : 404 });
+  }
+  async function handleListImages() {
+    const repo = getRepository();
+    const images = await repo.findAllImages();
+    return jsonResponse(images);
+  }
+  async function handleGetImage(imageId) {
+    const repo = getRepository();
+    const image = await repo.findImageById(imageId);
+    if (!image) {
+      return errorResponse("INVALID_REQUEST", `Image ${imageId} not found`, 404);
+    }
+    return jsonResponse(image);
+  }
+  async function handleSaveImage(imageId, request) {
+    const repo = getRepository();
+    let body;
+    try {
+      body = await request.json();
+    } catch {
+      return errorResponse("INVALID_REQUEST", "Invalid JSON body", 400);
+    }
+    await repo.saveImage({ ...body, imageId });
+    return new Response(null, { status: 204 });
+  }
+  async function handleDeleteImage(imageId) {
+    const repo = getRepository();
+    await repo.deleteImage(imageId);
+    return new Response(null, { status: 204 });
+  }
+  async function handleHeadImage(imageId) {
+    const repo = getRepository();
+    const exists = await repo.imageExists(imageId);
+    return new Response(null, { status: exists ? 200 : 404 });
+  }
+  async function handleListImageSessions(imageId) {
+    const repo = getRepository();
+    const sessions = await repo.findSessionsByImageId(imageId);
+    return jsonResponse(sessions);
+  }
+  async function handleDeleteImageSessions(imageId) {
+    const repo = getRepository();
+    await repo.deleteSessionsByImageId(imageId);
+    return new Response(null, { status: 204 });
+  }
+  async function handleRunImage(imageId, request) {
+    let containerId;
+    try {
+      const body = await request.json();
+      containerId = body.containerId;
+    } catch {
+    }
+    const agent = await agentx.images.run(imageId, { containerId });
+    const response = {
+      agentId: agent.agentId,
+      name: agent.definition.name,
+      lifecycle: agent.lifecycle,
+      state: agent.state,
+      createdAt: agent.createdAt,
+      endpoints: {
+        sse: `${basePath}/agents/${agent.agentId}/sse`,
+        messages: `${basePath}/agents/${agent.agentId}/messages`,
+        interrupt: `${basePath}/agents/${agent.agentId}/interrupt`
+      }
+    };
+    return jsonResponse(response, 201);
+  }
+  async function handleListSessions() {
+    const repo = getRepository();
+    const sessions = await repo.findAllSessions();
+    return jsonResponse(sessions);
+  }
+  async function handleGetSession(sessionId) {
+    const repo = getRepository();
+    const session = await repo.findSessionById(sessionId);
+    if (!session) {
+      return errorResponse("INVALID_REQUEST", `Session ${sessionId} not found`, 404);
+    }
+    return jsonResponse(session);
+  }
+  async function handleSaveSession(sessionId, request) {
+    const repo = getRepository();
+    let body;
+    try {
+      body = await request.json();
+    } catch {
+      return errorResponse("INVALID_REQUEST", "Invalid JSON body", 400);
+    }
+    await repo.saveSession({ ...body, sessionId });
+    return new Response(null, { status: 204 });
+  }
+  async function handleDeleteSession(sessionId) {
+    const repo = getRepository();
+    await repo.deleteSession(sessionId);
+    return new Response(null, { status: 204 });
+  }
+  async function handleHeadSession(sessionId) {
+    const repo = getRepository();
+    const exists = await repo.sessionExists(sessionId);
+    return new Response(null, { status: exists ? 200 : 404 });
+  }
+  async function handleListSessionMessages(sessionId) {
+    const repo = getRepository();
+    const messages = await repo.findMessagesBySessionId(sessionId);
+    return jsonResponse(messages);
+  }
+  async function handleDeleteSessionMessages(sessionId) {
+    const repo = getRepository();
+    await repo.deleteMessagesBySessionId(sessionId);
+    return new Response(null, { status: 204 });
+  }
+  async function handleCountSessionMessages(sessionId) {
+    const repo = getRepository();
+    const count = await repo.countMessagesBySessionId(sessionId);
+    return jsonResponse({ count });
+  }
+  async function handleResumeSession(sessionId, request) {
+    const session = await agentx.sessions.get(sessionId);
+    if (!session) {
+      return errorResponse("INVALID_REQUEST", `Session ${sessionId} not found`, 404);
+    }
+    let containerId;
+    try {
+      const body = await request.json();
+      containerId = body.containerId;
+    } catch {
+    }
+    const agent = await session.resume({ containerId });
+    const response = {
+      agentId: agent.agentId,
+      name: agent.definition.name,
+      lifecycle: agent.lifecycle,
+      state: agent.state,
+      createdAt: agent.createdAt,
+      endpoints: {
+        sse: `${basePath}/agents/${agent.agentId}/sse`,
+        messages: `${basePath}/agents/${agent.agentId}/messages`,
+        interrupt: `${basePath}/agents/${agent.agentId}/interrupt`
+      }
+    };
+    return jsonResponse(response, 201);
+  }
+  async function handleListUserSessions(userId) {
+    const repo = getRepository();
+    const sessions = await repo.findSessionsByUserId(userId);
+    return jsonResponse(sessions);
+  }
+  async function handleGetMessage(messageId) {
+    const repo = getRepository();
+    const message = await repo.findMessageById(messageId);
+    if (!message) {
+      return errorResponse("INVALID_REQUEST", `Message ${messageId} not found`, 404);
+    }
+    return jsonResponse(message);
+  }
+  async function handleSaveMessage(messageId, request) {
+    const repo = getRepository();
+    let body;
+    try {
+      body = await request.json();
+    } catch {
+      return errorResponse("INVALID_REQUEST", "Invalid JSON body", 400);
+    }
+    await repo.saveMessage({ ...body, messageId });
+    return new Response(null, { status: 204 });
+  }
+  async function handleDeleteMessage(messageId) {
+    const repo = getRepository();
+    await repo.deleteMessage(messageId);
+    return new Response(null, { status: 204 });
+  }
+  async function handleListContainers() {
+    const repo = getRepository();
+    const containers = await repo.findAllContainers();
+    return jsonResponse(containers);
+  }
+  async function handleCreateContainer(request) {
+    let config;
+    try {
+      const body = await request.json();
+      config = body.config;
+    } catch {
+    }
+    const container = await agentx.containers.create(config);
+    return jsonResponse(container, 201);
+  }
+  async function handleGetContainer(containerId) {
+    const container = await agentx.containers.get(containerId);
+    if (!container) {
+      return errorResponse("INVALID_REQUEST", `Container ${containerId} not found`, 404);
+    }
+    return jsonResponse(container);
+  }
+  async function handleDeleteContainer(containerId) {
+    const deleted = await agentx.containers.delete(containerId);
+    if (!deleted) {
+      return errorResponse("INVALID_REQUEST", `Container ${containerId} not found`, 404);
+    }
+    return new Response(null, { status: 204 });
+  }
+  async function handleHeadContainer(containerId) {
+    const exists = await agentx.containers.exists(containerId);
+    return new Response(null, { status: exists ? 200 : 404 });
+  }
+  async function handleSaveContainer(containerId, request) {
+    const repo = getRepository();
+    let body;
+    try {
+      body = await request.json();
+    } catch {
+      return errorResponse("INVALID_REQUEST", "Invalid JSON body", 400);
+    }
+    await repo.saveContainer({ ...body, containerId });
+    return new Response(null, { status: 204 });
+  }
+  const handler = async (request) => {
+    try {
+      const parsed = parseRequest(request);
+      switch (parsed.type) {
+        // Platform
+        case "platform_info":
+          return handlePlatformInfo();
+        case "platform_health":
+          return handleHealth();
+        // Agents
+        case "list_agents":
+          return handleListAgents();
+        case "create_agent":
+          return handleCreateAgent(request);
+        case "get_agent":
+          return handleGetAgent(parsed.agentId);
+        case "delete_agent":
+          return handleDeleteAgent(parsed.agentId);
+        case "connect_sse":
+          return handleConnectSSE(parsed.agentId);
+        case "send_message":
+          return handleSendMessage(parsed.agentId, request);
+        case "interrupt":
+          return handleInterrupt(parsed.agentId);
+        // Definitions
+        case "list_definitions":
+          return handleListDefinitions();
+        case "get_definition":
+          return handleGetDefinition(parsed.definitionName);
+        case "save_definition":
+          return handleSaveDefinition(parsed.definitionName, request);
+        case "delete_definition":
+          return handleDeleteDefinition(parsed.definitionName);
+        case "head_definition":
+          return handleHeadDefinition(parsed.definitionName);
+        // Images
+        case "list_images":
+          return handleListImages();
+        case "get_image":
+          return handleGetImage(parsed.imageId);
+        case "save_image":
+          return handleSaveImage(parsed.imageId, request);
+        case "delete_image":
+          return handleDeleteImage(parsed.imageId);
+        case "head_image":
+          return handleHeadImage(parsed.imageId);
+        case "list_image_sessions":
+          return handleListImageSessions(parsed.imageId);
+        case "delete_image_sessions":
+          return handleDeleteImageSessions(parsed.imageId);
+        case "run_image":
+          return handleRunImage(parsed.imageId, request);
+        // Sessions
+        case "list_sessions":
+          return handleListSessions();
+        case "get_session":
+          return handleGetSession(parsed.sessionId);
+        case "save_session":
+          return handleSaveSession(parsed.sessionId, request);
+        case "delete_session":
+          return handleDeleteSession(parsed.sessionId);
+        case "head_session":
+          return handleHeadSession(parsed.sessionId);
+        case "list_session_messages":
+          return handleListSessionMessages(parsed.sessionId);
+        case "delete_session_messages":
+          return handleDeleteSessionMessages(parsed.sessionId);
+        case "count_session_messages":
+          return handleCountSessionMessages(parsed.sessionId);
+        case "resume_session":
+          return handleResumeSession(parsed.sessionId, request);
+        // Users
+        case "list_user_sessions":
+          return handleListUserSessions(parsed.userId);
+        // Messages
+        case "get_message":
+          return handleGetMessage(parsed.messageId);
+        case "save_message":
+          return handleSaveMessage(parsed.messageId, request);
+        case "delete_message":
+          return handleDeleteMessage(parsed.messageId);
+        // Containers
+        case "list_containers":
+          return handleListContainers();
+        case "create_container":
+          return handleCreateContainer(request);
+        case "get_container":
+          return handleGetContainer(parsed.containerId);
+        case "save_container":
+          return handleSaveContainer(parsed.containerId, request);
+        case "delete_container":
+          return handleDeleteContainer(parsed.containerId);
+        case "head_container":
+          return handleHeadContainer(parsed.containerId);
+        case "not_found":
+        default:
+          return errorResponse("INVALID_REQUEST", "Not found", 404);
+      }
+    } catch (error) {
+      logger2.error("Unhandled error in request handler", { error });
+      return errorResponse(
+        "INTERNAL_ERROR",
+        error instanceof Error ? error.message : "Internal server error",
+        500
+      );
+    }
+  };
+  handler.registerDefinition = registerDefinition;
+  handler.sseManager = sseManager;
+  return handler;
+}
+
+// src/server/adapters/express.ts
+function toWebRequest(req) {
+  const protocol = req.protocol || "http";
+  const host = req.hostname || req.headers.host || "localhost";
+  const url = `${protocol}://${host}${req.originalUrl || req.url}`;
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (value !== void 0) {
+      if (Array.isArray(value)) {
+        value.forEach((v) => headers.append(key, v));
+      } else {
+        headers.set(key, value);
+      }
+    }
+  }
+  const init = {
+    method: req.method,
+    headers
+  };
+  if (req.method !== "GET" && req.method !== "HEAD") {
+    if (req.body !== void 0) {
+      init.body = JSON.stringify(req.body);
+    }
+  }
+  return new Request(url, init);
+}
+async function sendWebResponse(res, webResponse) {
+  res.status(webResponse.status);
+  webResponse.headers.forEach((value, key) => {
+    if (key.toLowerCase() !== "content-encoding") {
+      res.setHeader(key, value);
+    }
+  });
+  const contentType = webResponse.headers.get("content-type");
+  if (contentType?.includes("text/event-stream")) {
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    if (res.flushHeaders) {
+      res.flushHeaders();
+    }
+    const reader = webResponse.body?.getReader();
+    if (reader) {
+      const decoder = new TextDecoder();
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          res.write(decoder.decode(value, { stream: true }));
+        }
+      } catch {
+      } finally {
+        reader.releaseLock();
+      }
+    }
+    res.end();
+  } else {
+    const body = await webResponse.text();
+    res.end(body);
+  }
+}
+function toExpressHandler(handler) {
+  return async (req, res, next) => {
+    try {
+      const webRequest = toWebRequest(req);
+      const webResponse = await handler(webRequest);
+      await sendWebResponse(res, webResponse);
+    } catch (error) {
+      next(error);
+    }
+  };
+}
+function createExpressAdapter(handler) {
+  return toExpressHandler(handler);
+}
+
+// src/server/adapters/hono.ts
+function toHonoHandler(handler) {
+  return async (c) => {
+    return handler(c.req.raw);
+  };
+}
+function createHonoRoutes(handler, HonoClass) {
+  const app = new HonoClass();
+  const honoHandler = toHonoHandler(handler);
+  app.get("/info", honoHandler);
+  app.get("/health", honoHandler);
+  app.get("/agents", honoHandler);
+  app.post("/agents", honoHandler);
+  app.get("/agents/:agentId", honoHandler);
+  app.delete("/agents/:agentId", honoHandler);
+  app.get("/agents/:agentId/sse", honoHandler);
+  app.post("/agents/:agentId/messages", honoHandler);
+  app.post("/agents/:agentId/interrupt", honoHandler);
+  app.all("/*", honoHandler);
+  return app;
+}
+function createHonoAdapter(handler) {
+  return toHonoHandler(handler);
+}
+
+// src/server/adapters/next.ts
+function createNextHandler(handler) {
+  const routeHandler = async (request) => {
+    return handler(request);
+  };
+  return {
+    GET: routeHandler,
+    POST: routeHandler,
+    DELETE: routeHandler,
+    PUT: routeHandler,
+    PATCH: routeHandler,
+    HEAD: routeHandler,
+    OPTIONS: routeHandler
+  };
+}
+function toNextHandler(handler) {
+  return async (request) => handler(request);
+}
+function createNextEdgeHandler(handler) {
+  return createNextHandler(handler);
+}
+
+exports.SSEConnection = SSEConnection;
+exports.SSEConnectionManager = SSEConnectionManager;
+exports.createAgentXHandler = createAgentXHandler;
+exports.createAgentXRoutes = createNextHandler;
+exports.createExpressAdapter = createExpressAdapter;
+exports.createHonoAdapter = createHonoAdapter;
+exports.createHonoRoutes = createHonoRoutes;
+exports.createNextEdgeHandler = createNextEdgeHandler;
+exports.createNextHandler = createNextHandler;
+exports.toExpressHandler = toExpressHandler;
+exports.toHonoHandler = toHonoHandler;
+exports.toNextHandler = toNextHandler;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map