@axiom-lattice/gateway 3.0.2 → 3.0.3

package/src/controllers/run.ts

@@ -1,338 +0,0 @@
-import { FastifyRequest, FastifyReply } from "fastify";
-import { CreateRunRequest } from "../types";
-import { v4 } from "uuid";
-import {
-  Agent,
-  ThreadStatus,
-  agentLatticeManager,
-  agentInstanceManager,
-  QueueMode,
-} from "@axiom-lattice/core";
-import { MessageChunkTypes } from "@axiom-lattice/protocols";
-
-function getUserId(request: FastifyRequest): string | undefined {
-  const authUser = (request as any).user;
-  if (authUser?.id) return authUser.id;
-  return (request.headers["x-user-id"] as string) || undefined;
-}
-
-interface ResumeStreamRequest {
-  thread_id: string;
-  assistant_id: string
-  message_id: string;
-  known_content: string;
-  poll_interval?: number;
-}
-
-// Create run
-export const createRun = async (
-  request: FastifyRequest,
-  reply: FastifyReply
-): Promise<void> => {
-  try {
-    const {
-      assistant_id,
-      thread_id,
-      message_id,
-      command,
-      streaming,
-      background,
-      custom_run_config,
-      mode,
-      ...input
-    } = request.body as CreateRunRequest;
-
-    const tenant_id = request.headers["x-tenant-id"] as string;
-    const workspace_id = request.headers["x-workspace-id"] as string;
-    const project_id = request.headers["x-project-id"] as string;
-    const x_request_id = (request.headers["x-request-id"] as string) || v4();
-    const user_id = getUserId(request);
-
-    // Merge user_id, project_id, workspace_id into custom_run_config for downstream propagation
-    const mergedConfig = {
-      ...custom_run_config,
-      ...(user_id && { user_id }),
-    };
-
-    // Validate request
-    if (!assistant_id) {
-      reply.status(400).send({
-        success: false,
-        error: "助手ID是必需的",
-      });
-      return;
-    }
-
-    // Get or create Agent instance (ensures single instance per thread)
-    const agent = agentInstanceManager.getAgent({
-      assistant_id,
-      thread_id,
-      tenant_id,
-      workspace_id,
-      project_id,
-      custom_run_config: mergedConfig,
-    });
-
-
-    // ADR-026: background mode — enqueue only, returns 202.
-    // Chunk delivery is handled by the thread-level resume_stream SSE.
-    if (background) {
-      const messageInput = message_id
-        ? { ...input, id: message_id }
-        : input;
-
-      const result = await agent.addMessage({
-        input: messageInput,
-        command,
-        custom_run_config: mergedConfig,
-      }, mode as QueueMode);
-
-      reply.status(202).send({
-        success: true,
-        messageId: result.messageId,
-        queued: true,
-      });
-      return;
-    }
-
-    // Handle streaming requests
-    if (streaming) {
-      // Setup SSE
-      reply.hijack();
-      reply.raw.writeHead(200, {
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache",
-        Connection: "keep-alive",
-        "Access-Control-Allow-Origin": "*",
-      });
-
-      try {
-
-        // Execute agent with streaming
-        // Only pass id if message_id is provided (for backward compatibility)
-        const messageInput = message_id 
-          ? { ...input, id: message_id }
-          : input;
-        
-        const result = await agent.addMessage({
-          input: messageInput,
-          command,
-          custom_run_config: mergedConfig,
-        }, mode as QueueMode);
-
-        // const agentStatus = await agent.getRunStatus()
-        // console.log(agentStatus)
-        // if (agentStatus === "busy") {
-        //   reply.status(200).send({
-        //     success: true,
-
-        //   });
-        //   return
-        // }
-
-        const stream = agent.chunkStream((result).messageId, [MessageChunkTypes.MESSAGE_COMPLETED, MessageChunkTypes.INTERRUPT, MessageChunkTypes.MESSAGE_FAILED])
-
-        // Forward all chunks to SSE
-        for await (const chunk of stream) {
-          const success = reply.raw.write(`data: ${JSON.stringify(chunk)}\n\n`);
-          if (!success) {
-            await new Promise(resolve => reply.raw.once('drain', resolve));
-          }
-        }
-      } catch (error: any) {
-        // Send error as SSE event
-        const errorEvent = {
-          type: 'error',
-          data: {
-            id: v4(),
-            content: error.message || 'Stream processing error',
-          },
-        };
-        reply.raw.write(`data: ${JSON.stringify(errorEvent)}\n\n`);
-      } finally {
-        reply.raw.end();
-      }
-    } else {
-      // Non-streaming: use agentExecutor
-      const { message: msg, ...restInputNonStream } = input;
-      const result = await agent.invoke({
-        input: { message: msg, ...restInputNonStream },
-        command,
-        custom_run_config: mergedConfig,
-      });
-      reply.status(200).send({
-        success: true,
-        ...result,
-      });
-    }
-  } catch (error: any) {
-    reply.status(500).send({
-      success: false,
-      error: `创建运行时发生错误: ${error.message}`,
-    });
-  }
-};
-
-// Resume stream from known position
-export const resumeStream = async (
-  request: FastifyRequest,
-  reply: FastifyReply
-): Promise<void> => {
-  try {
-
-
-
-
-    const { thread_id, message_id, assistant_id, known_content, poll_interval } =
-      request.body as ResumeStreamRequest;
-    const tenant_id = request.headers["x-tenant-id"] as string;
-    const workspace_id = request.headers["x-workspace-id"] as string;
-    const project_id = request.headers["x-project-id"] as string;
-
-    // Validate request data
-    if (!thread_id || !message_id || !assistant_id || known_content === undefined) {
-      reply.status(400).send({
-        success: false,
-        error: "thread_id, message_id, assistant_id, and known_content are required",
-      });
-      return;
-    }
-
-    // Notify Fastify that we will manually handle the response
-    reply.hijack();
-
-    // Set SSE response headers
-    reply.raw.writeHead(200, {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      Connection: "keep-alive",
-      "Access-Control-Allow-Origin": "*",
-    });
-
-    try {
-      // Create Agent instance for accessing chunk buffer
-      // Get or create Agent instance (ensures single instance per thread)
-      const agent = agentInstanceManager.getAgent({
-        assistant_id,
-        thread_id,
-        tenant_id,
-        workspace_id,
-        project_id,
-      });
-
-      // ADR-026: Thread-level SSE, lives until client disconnect.
-      // Empty stopTypes means the iterator never stops on its own —
-      // MESSAGE_COMPLETED, THREAD_IDLE etc. pass through as data.
-      // Client disconnect (close event) or client abort (reply.raw.destroyed)
-      // terminate the loop.
-      const stream = agent.chunkStream(message_id, []);
-      let closed = false;
-      request.raw.on('close', () => { closed = true; });
-
-      for await (const chunk of stream) {
-        if (closed || reply.raw.destroyed) break;
-        reply.raw.write(`data: ${JSON.stringify(chunk)}\n\n`);
-      }
-    } catch (error: any) {
-      // Send error as SSE event before closing (following MessageChunk format)
-      const errorEvent = {
-        type: 'error',
-        data: {
-          id: v4(),
-          content: error.message || 'Resume stream processing error'
-        }
-      };
-      reply.raw.write(`data: ${JSON.stringify(errorEvent)}\n\n`);
-    } finally {
-      reply.raw.end();
-    }
-  } catch (error: any) {
-    reply.status(500).send({
-      success: false,
-      error: `Error resuming stream: ${error.message}`,
-    });
-  }
-};
-
-// Abort agent execution for a thread
-export const abortRun = async (
-  request: FastifyRequest,
-  reply: FastifyReply
-): Promise<void> => {
-  try {
-    const { assistantId, threadId } = request.params as {
-      assistantId: string;
-      threadId: string;
-    };
-    const tenant_id = request.headers["x-tenant-id"] as string;
-    const workspace_id = (request.headers["x-workspace-id"] as string) || "default";
-    const project_id = (request.headers["x-project-id"] as string) || "default";
-
-    const agent = agentInstanceManager.getAgent({
-      assistant_id: assistantId,
-      thread_id: threadId,
-      tenant_id,
-      workspace_id,
-      project_id,
-    });
-
-    await agent.abort();
-
-    reply.status(200).send({
-      success: true,
-      message: "Agent aborted",
-    });
-  } catch (error: any) {
-    reply.status(500).send({
-      success: false,
-      error: `Abort failed: ${error.message}`,
-    });
-  }
-};
-
-/**
- * Recover agent execution after a crash or manual abort.
- *
- * Resumes the LangGraph from its last checkpoint if the graph was
- * mid-execution (BUSY).  Otherwise cleans up stuck queue messages
- * and restarts the queue processor.
- *
- * Pairs with {@link abortRun} — use abort to stop, recover to continue.
- */
-export const recoverRun = async (
-  request: FastifyRequest,
-  reply: FastifyReply
-): Promise<void> => {
-  try {
-    const { assistantId, threadId } = request.params as {
-      assistantId: string;
-      threadId: string;
-    };
-    const tenant_id = request.headers["x-tenant-id"] as string;
-    const workspace_id = (request.headers["x-workspace-id"] as string) || "default";
-    const project_id = (request.headers["x-project-id"] as string) || "default";
-
-    const agent = agentInstanceManager.getAgent({
-      assistant_id: assistantId,
-      thread_id: threadId,
-      tenant_id,
-      workspace_id,
-      project_id,
-    });
-
-    await agent.resumeTask();
-
-    const status = await agent.getRunStatus();
-
-    reply.status(200).send({
-      success: true,
-      threadId,
-      status,
-    });
-  } catch (error: any) {
-    reply.status(500).send({
-      success: false,
-      error: `Recover failed: ${error.message}`,
-    });
-  }
-};

package/src/controllers/sandbox.ts

@@ -1,255 +0,0 @@
-import { FastifyInstance } from "fastify";
-import { sandboxService } from "../services/sandbox_service";
-import { getSandBoxManager } from "@axiom-lattice/core";
-import { getContentTypeFromFilename, getFilenameFromPath } from "../utils/mime";
-
-interface SandboxParams {
-  assistantId: string;
-  threadId: string;
-}
-
-export function registerSandboxProxyRoutes(app: FastifyInstance): void {
-  // Register uploadfile route FIRST before wildcard routes to ensure it matches
-  app.post<{ Params: SandboxParams }>(
-    "/api/assistants/:assistantId/threads/:threadId/sandbox/uploadfile",
-    async (request, reply) => {
-      console.log("[Sandbox Upload] Route matched:", request.url);
-      const { assistantId, threadId } = request.params;
-      const tenantId = (request.headers["x-tenant-id"] as string) || "default";
-
-      const vmIsolation = sandboxService.getFilesystemVmIsolation(tenantId, assistantId);
-      if (!vmIsolation) {
-        return reply.status(500).send({ error: "Assistant sandbox config not found" });
-      }
-
-      const workspaceId = request.headers["x-workspace-id"] as string;
-      const projectId = request.headers["x-project-id"] as string;
-
-      const sandboxManager = getSandBoxManager();
-      const sandbox = await sandboxManager.getSandboxFromConfig({
-        assistant_id: assistantId,
-        thread_id: threadId,
-        tenantId,
-        workspaceId,
-        projectId,
-        vmIsolation,
-      });
-
-      try {
-        const data = await request.file();
-        if (!data) {
-          return reply.status(400).send({ error: "No file in request" });
-        }
-
-        const buffer = await data.toBuffer();
-        const pathEntry = data.fields?.path;
-        const pathValue =
-          pathEntry && typeof pathEntry === "object" && "value" in pathEntry
-            ? String((pathEntry as { value: unknown }).value)
-            : typeof pathEntry === "string"
-              ? pathEntry
-              : undefined;
-
-        const filePath = `/uploads/${pathValue ? pathValue : ""}${data.filename}`;
-        try {
-          await sandbox.file.uploadFile({ file: filePath, data: buffer });
-        } catch (err) {
-          reply.status(500).send({ error: String(err) });
-          return;
-        }
-
-        const relativePath = filePath.replace(`~/`, "");
-        const result = { id: relativePath, name: data.filename, size: buffer.length };
-
-        return reply.status(200).send({ message: "File uploaded successfully", ...result });
-      } catch (error: unknown) {
-        const message = error instanceof Error ? error.message : String(error);
-        return reply.status(502).send({ error: `Upload proxy error: ${message}` });
-      }
-    }
-  );
-
-  // Download file from sandbox: GET with query param path (file path in sandbox, e.g. /home/gem/uploads/foo.txt)
-  app.get<{
-    Params: SandboxParams;
-    Querystring: { path: string };
-  }>(
-    "/api/assistants/:assistantId/threads/:threadId/sandbox/downloadfile",
-    async (request, reply) => {
-      const { assistantId, threadId } = request.params;
-      const { path: filePath } = request.query;
-      const tenantId = (request.headers["x-tenant-id"] as string) || "default";
-
-      if (!filePath || typeof filePath !== "string") {
-        return reply.status(400).send({ error: "Query parameter 'path' is required" });
-      }
-
-      const vmIsolation = sandboxService.getFilesystemVmIsolation(tenantId, assistantId);
-      if (!vmIsolation) {
-        return reply.status(500).send({ error: "Assistant filesystem vmIsolation not found" });
-      }
-
-      const workspaceId = request.headers["x-workspace-id"] as string;
-      const projectId = request.headers["x-project-id"] as string;
-
-      const sandboxManager = getSandBoxManager();
-      const sandbox = await sandboxManager.getSandboxFromConfig({
-        assistant_id: assistantId,
-        thread_id: threadId,
-        tenantId,
-        workspaceId,
-        projectId,
-        vmIsolation,
-      });
-
-      try {
-        // Normalize path to /-prefixed absolute path
-        const resolvedPath = filePath.startsWith("/") ? filePath : `/${filePath}`;
-        const filename = getFilenameFromPath(resolvedPath);
-        const inferredContentType = getContentTypeFromFilename(filename);
-
-        try {
-          const buf = await sandbox.file.downloadFile({ file: resolvedPath });
-          const contentDisposition = `inline; filename="${filename.replace(/"/g, '\\"')}"; filename*=UTF-8''${encodeURIComponent(filename)}`;
-          reply = reply.status(200).type(inferredContentType).header("Content-Disposition", contentDisposition).send(buf);
-          return reply;
-        } catch (err) {
-          reply.status(500).send({ error: String(err) });
-          return;
-        }
-      } catch (error: unknown) {
-        const message = error instanceof Error ? error.message : String(error);
-        return reply.status(502).send({ error: `Download proxy error: ${message}` });
-      }
-    }
-  );
-
-  // app.get<{ Params: SandboxParams }>(
-  //   "/api/assistants/:assistantId/threads/:threadId/sandbox/browser",
-  //   async (request, reply) => {
-  //     const { assistantId, threadId } = request.params;
-
-  //     const sandboxConfig = sandboxService.getSandboxConfig(assistantId);
-  //     if (!sandboxConfig) {
-  //       const errorHtml = sandboxService.generateErrorHtml(
-  //         assistantId,
-  //         threadId,
-  //         "unknown",
-  //         `Assistant ${assistantId} not found`
-  //       );
-  //       return reply.status(404).type("text/html").send(errorHtml);
-  //     }
-
-  //     const { vmIsolation } = sandboxConfig;
-  //     const sandboxName = sandboxService.computeSandboxName(
-  //       assistantId,
-  //       threadId,
-  //       vmIsolation
-  //     );
-
-  //     try {
-  //       const html = await sandboxService.getVncHtml(sandboxName);
-  //       const rewrittenHtml = sandboxService.rewriteHtml(html, assistantId, threadId);
-  //       return reply.type("text/html").send(rewrittenHtml);
-  //     } catch (error: any) {
-  //       const errorHtml = sandboxService.generateErrorHtml(
-  //         assistantId,
-  //         threadId,
-  //         vmIsolation,
-  //         error.message || "Failed to connect to sandbox"
-  //       );
-  //       return reply.status(502).type("text/html").send(errorHtml);
-  //     }
-  //   }
-  // );
-
-
-  // app.get<{ Params: SandboxParams }>(
-  //   "/api/assistants/:assistantId/threads/:threadId/sandbox/websockify",
-  //   { websocket: true },
-
-  //   (connection, request) => {
-
-  //     const url = (connection?.url) as string;
-  //     console.log(`[WebSocket] Received connection from URL: ${url}`);
-
-  //     const urlMatch = url.match(/\/api\/assistants\/([^/]+)\/threads\/([^/]+)\/sandbox\/websockify/);
-  //     if (!urlMatch) {
-  //       console.error(`[WebSocket] Failed to parse params from URL: ${url}`);
-  //       connection.close(1008, "Invalid URL format");
-  //       return;
-  //     }
-
-  //     const assistantId = urlMatch[1];
-  //     const threadId = urlMatch[2];
-  //     console.log(`[WebSocket] Parsed params - assistantId: ${assistantId}, threadId: ${threadId}`);
-
-  //     const sandboxConfig = sandboxService.getSandboxConfig(assistantId);
-  //     if (!sandboxConfig) {
-  //       console.error(`[WebSocket] Assistant ${assistantId} not found`);
-  //       connection.close(1008, "Assistant not found");
-  //       return;
-  //     }
-
-  //     const { vmIsolation } = sandboxConfig;
-  //     const sandboxName = sandboxService.computeSandboxName(
-  //       assistantId,
-  //       threadId,
-  //       vmIsolation
-  //     );
-
-  //     const targetUrl = sandboxService.getTargetUrl(sandboxName);
-  //     const targetWsUrl = targetUrl.replace(/^http/, "ws").replace(/^https/, "wss") + "/websockify";
-
-  //     console.log(`[WebSocket] Connecting to target: ${targetWsUrl}`);
-
-  //     const targetSocket = new WebSocket(targetWsUrl);
-  //     const clientStream = createWebSocketStream(connection, { encoding: "utf8" });
-
-  //     const targetStream = createWebSocketStream(targetSocket, { encoding: "utf8" });
-
-  //     const forward = pipeline(clientStream, targetStream);
-  //     const backward = pipeline(targetStream, clientStream);
-
-  //     Promise.all([forward, backward]).catch((err) => {
-  //       console.error(`[WebSocket] Proxy pipeline failed:`, err.message);
-  //       targetSocket.terminate();
-  //       connection.terminate();
-  //     });
-  //   }
-  // );
-
-  // app.get<{ Params: ProxyParams }>(
-  //   "/api/assistants/:assistantId/threads/:threadId/sandbox/browser/vnc/*",
-  //   async (request, reply) => {
-  //     const { assistantId, threadId, "*": restPath } = request.params;
-
-  //     const sandboxConfig = sandboxService.getSandboxConfig(assistantId);
-  //     if (!sandboxConfig) {
-  //       return reply.status(404).send("Assistant not found");
-  //     }
-
-  //     const { vmIsolation } = sandboxConfig;
-  //     const sandboxName = sandboxService.computeSandboxName(
-  //       assistantId,
-  //       threadId,
-  //       vmIsolation
-  //     );
-
-  //     const targetPath = restPath ? `/vnc/${restPath}` : "/vnc/";
-  //     const targetUrl = `${sandboxService.getTargetUrl(sandboxName)}${targetPath}`;
-
-  //     try {
-  //       const response = await fetch(targetUrl);
-  //       const contentType = response.headers.get("content-type") || "application/octet-stream";
-
-  //       const body = await response.arrayBuffer();
-  //       reply.status(response.status).type(contentType).send(Buffer.from(body));
-  //     } catch (error: any) {
-  //       reply.status(502).send(`Proxy error: ${error.message}`);
-  //     }
-  //   }
-  // );
-
-
-}