@axiom-lattice/gateway 2.1.37 → 2.1.39

package/src/controllers/workspace.ts

@@ -52,6 +52,19 @@ export class WorkspaceController {
   }
 
   private getTenantId(request: FastifyRequest): string {
+    // First try to get from authenticated user context
+    const userTenantId = (request as any).user?.tenantId;
+    if (userTenantId) {
+      return userTenantId;
+    }
+
+    // Try to get from query parameters (for direct URL access like file downloads)
+    const queryTenantId = (request.query as any)?.tenantId;
+    if (queryTenantId) {
+      return String(queryTenantId);
+    }
+
+    // Fallback to request headers for backward compatibility
     return (request.headers["x-tenant-id"] as string) || "default";
   }
 
@@ -239,8 +252,7 @@ export class WorkspaceController {
 
   // ==================== File Operations ====================
 
-  private async getBackend(workspaceId: string, projectId: string) {
-    const tenantId = "default";
+  private async getBackend(tenantId: string, workspaceId: string, projectId: string) {
     const workspace = await this.workspaceStore.getWorkspaceById(
       tenantId,
       workspaceId
@@ -251,18 +263,22 @@ export class WorkspaceController {
     }
 
     if (workspace.storageType === "sandbox") {
-      const sandboxManager = getSandBoxManager("default");
+      const sandboxManager = getSandBoxManager();
       const sandboxName = "global";
       const sandbox = await sandboxManager.createSandbox(sandboxName);
-      return { backend: new SandboxFilesystem({
-        sandboxInstance: sandbox,
-        workingDirectory: `/workspaces/${workspaceId}/${projectId}`,
-      }), workspace };
+      return {
+        backend: new SandboxFilesystem({
+          sandboxInstance: sandbox,
+          workingDirectory: `/tenants/${tenantId}/workspaces/${workspaceId}/${projectId}`,
+        }), workspace
+      };
     } else {
-      return { backend: new FilesystemBackend({
-        rootDir: `/lattice_store/workspaces/${workspaceId}/${projectId}`,
-        virtualMode: true,
-      }), workspace };
+      return {
+        backend: new FilesystemBackend({
+          rootDir: `/lattice_store/tenants/${tenantId}/workspaces/${workspaceId}/${projectId}`,
+          virtualMode: true,
+        }), workspace
+      };
     }
   }
 
@@ -301,6 +317,7 @@ export class WorkspaceController {
     }>,
     reply: FastifyReply
   ) {
+    const tenantId = this.getTenantId(request);
     const { workspaceId, projectId } = request.params;
     const filePath = request.query.path;
 
@@ -309,13 +326,13 @@ export class WorkspaceController {
     }
 
     try {
-      const { workspace } = await this.getBackend(workspaceId, projectId);
+      const { workspace } = await this.getBackend(tenantId, workspaceId, projectId);
       const resolvedPath = filePath.startsWith("/") ? filePath : `/${filePath}`;
 
       if (workspace.storageType === "sandbox") {
-        const sandboxManager = getSandBoxManager("default");
+        const sandboxManager = getSandBoxManager();
         const sandbox = await sandboxManager.createSandbox("global");
-        const realPath = path.join("/home/gem/workspaces", workspaceId, projectId, resolvedPath);
+        const realPath = path.join("/home/gem/tenants", tenantId, "workspaces", workspaceId, projectId, resolvedPath);
         const filename = this.getFilenameFromPath(resolvedPath);
         const inferredContentType = this.getMimeType(filename);
 
@@ -341,14 +358,14 @@ export class WorkspaceController {
           const nodeStream = Readable.fromWeb(webStream);
           const contentType = body.contentType ?? inferredContentType;
           const contentDisposition =
-            body.contentDisposition ?? `inline; filename*=UTF-8''${encodeURIComponent(filename)}`;
+            body.contentDisposition ?? `attachment; filename*=UTF-8''${encodeURIComponent(filename)}`;
           return reply.status(200).type(contentType).header("Content-Disposition", contentDisposition).send(nodeStream);
         }
 
         const bodyUnknown = downloadResult.body as unknown;
         let buf: Buffer;
         let contentType = inferredContentType;
-        let contentDisposition = `inline; filename*=UTF-8''${encodeURIComponent(filename)}`;
+        let contentDisposition = `attachment; filename*=UTF-8''${encodeURIComponent(filename)}`;
 
         if (bodyUnknown instanceof ArrayBuffer) {
           buf = Buffer.from(bodyUnknown);
@@ -372,7 +389,7 @@ export class WorkspaceController {
         return reply.status(200).type(contentType).header("Content-Disposition", contentDisposition).send(buf);
       }
 
-      const { backend } = await this.getBackend(workspaceId, projectId);
+      const { backend } = await this.getBackend(tenantId, workspaceId, projectId);
       const content = await backend.read(resolvedPath, 0, Infinity);
       const filename = this.getFilenameFromPath(resolvedPath);
       const mimeType = this.getMimeType(filename);
@@ -381,7 +398,7 @@ export class WorkspaceController {
       return reply
         .status(200)
         .type(mimeType)
-        .header("Content-Disposition", `inline; filename*=UTF-8''${encodeURIComponent(filename)}`)
+        .header("Content-Disposition", `attachment; filename*=UTF-8''${encodeURIComponent(filename)}`)
         .send(buffer);
     } catch (error: unknown) {
       const message = error instanceof Error ? error.message : String(error);
@@ -389,16 +406,122 @@ export class WorkspaceController {
     }
   }
 
+  /**
+   * View a file inline in the browser (not download).
+   * Returns file content with inline Content-Disposition for preview.
+   */
+  async viewFile(
+    request: FastifyRequest<{
+      Params: ProjectParams;
+      Querystring: { path: string };
+    }>,
+    reply: FastifyReply
+  ) {
+    const tenantId = this.getTenantId(request);
+    const { workspaceId, projectId } = request.params;
+    const filePath = request.query.path;
+
+    if (!filePath) {
+      return reply.status(400).send({ success: false, error: "Path is required" });
+    }
+
+    try {
+      const { workspace } = await this.getBackend(tenantId, workspaceId, projectId);
+      const resolvedPath = filePath.startsWith("/") ? filePath : `/${filePath}`;
+
+      if (workspace.storageType === "sandbox") {
+        const sandboxManager = getSandBoxManager();
+        const sandbox = await sandboxManager.createSandbox("global");
+        const realPath = path.join("/home/gem/tenants", tenantId, "workspaces", workspaceId, projectId, resolvedPath);
+        const filename = this.getFilenameFromPath(resolvedPath);
+        const inferredContentType = this.getMimeType(filename);
+
+        const downloadResult = await sandbox.file.downloadFile({
+          path: realPath,
+        });
+
+        if (!downloadResult.ok) {
+          return reply.status(502).send({
+            success: false,
+            error: `View error: ${JSON.stringify(downloadResult.error)}`,
+          });
+        }
+
+        const body = downloadResult.body as unknown as {
+          stream?: () => ReadableStream<Uint8Array>;
+          contentType?: string;
+          contentDisposition?: string;
+        };
+
+        if (typeof body?.stream === "function") {
+          const webStream = body.stream();
+          const nodeStream = Readable.fromWeb(webStream);
+          const contentType = body.contentType ?? inferredContentType;
+          // inline for viewing, not attachment for download
+          return reply
+            .status(200)
+            .type(contentType)
+            .header("Content-Disposition", "inline")
+            .send(nodeStream);
+        }
+
+        const bodyUnknown = downloadResult.body as unknown;
+        let buf: Buffer;
+        let contentType = inferredContentType;
+
+        if (bodyUnknown instanceof ArrayBuffer) {
+          buf = Buffer.from(bodyUnknown);
+        } else if (bodyUnknown instanceof Buffer) {
+          buf = bodyUnknown;
+        } else if (
+          bodyUnknown &&
+          typeof (bodyUnknown as { arrayBuffer?: () => Promise<ArrayBuffer> }).arrayBuffer === "function"
+        ) {
+          const res = bodyUnknown as { arrayBuffer: () => Promise<ArrayBuffer>; headers?: Headers };
+          buf = Buffer.from(await res.arrayBuffer());
+          if (res.headers?.get("content-type")) contentType = res.headers.get("content-type")!;
+        } else if (bodyUnknown && typeof (bodyUnknown as { blob?: () => Promise<Blob> }).blob === "function") {
+          const blob = await (bodyUnknown as { blob: () => Promise<Blob> }).blob();
+          buf = Buffer.from(await blob.arrayBuffer());
+        } else {
+          return reply.status(502).send({ success: false, error: "Unexpected view response format" });
+        }
+
+        return reply
+          .status(200)
+          .type(contentType)
+          .header("Content-Disposition", "inline")
+          .send(buf);
+      }
+
+      const { backend } = await this.getBackend(tenantId, workspaceId, projectId);
+      const content = await backend.read(resolvedPath, 0, Infinity);
+      const filename = this.getFilenameFromPath(resolvedPath);
+      const mimeType = this.getMimeType(filename);
+      const buffer = Buffer.from(content, "utf-8");
+
+      return reply
+        .status(200)
+        .type(mimeType)
+        .header("Content-Disposition", "inline")
+        .send(buffer);
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : String(error);
+      return reply.status(502).send({ success: false, error: `View proxy error: ${message}` });
+    }
+  }
+
   async listPath(
     request: FastifyRequest<{
       Params: ProjectParams;
       Querystring: ListPathQuery;
     }>
   ) {
+    const tenantId = this.getTenantId(request);
     const { workspaceId, projectId } = request.params;
     const path = (request.query.path as string) || "/";
 
-    const { backend } = await this.getBackend(workspaceId, projectId);
+    const { backend } = await this.getBackend(tenantId, workspaceId, projectId);
     const files = await backend.lsInfo(path);
 
     return { success: true, data: files };
@@ -410,10 +533,11 @@ export class WorkspaceController {
       Querystring: ReadFileQuery;
     }>
   ) {
+    const tenantId = this.getTenantId(request);
     const { workspaceId, projectId } = request.params;
     const { path, offset = 0, limit = 1000 } = request.query;
 
-    const { backend } = await this.getBackend(workspaceId, projectId);
+    const { backend } = await this.getBackend(tenantId, workspaceId, projectId);
     const content = await backend.read(path, Number(offset), Number(limit));
 
     return { success: true, data: { content, offset, limit } };
@@ -475,11 +599,11 @@ export class WorkspaceController {
       }
 
       if (workspace.storageType === "sandbox") {
-        const sandboxManager = getSandBoxManager("default");
+        const sandboxManager = getSandBoxManager();
         const sandboxName = "global";
         const sandbox = await sandboxManager.createSandbox(sandboxName);
 
-        const baseDir = path.join("/home/gem/workspaces", workspaceId, projectId);
+        const baseDir = path.join("/home/gem/tenants", tenantId, "workspaces", workspaceId, projectId);
         const realPath = pathValue
           ? path.join(baseDir, pathValue, filename)
           : path.join(baseDir, filename);
@@ -497,7 +621,7 @@ export class WorkspaceController {
         }
 
         const relativePath =
-          uploadResult.body?.data?.file_path?.replace(path.join("/home/gem/workspaces", workspaceId, projectId), "") ||
+          uploadResult.body?.data?.file_path?.replace(path.join("/home/gem/tenants", tenantId, "workspaces", workspaceId, projectId), "") ||
           (pathValue ? `/${pathValue}/${filename}` : `/${filename}`);
 
         const result = {
@@ -511,8 +635,8 @@ export class WorkspaceController {
         return reply.status(200).send({ success: true, data: result });
       }
 
-      // Filesystem storage: write under /lattice_store/workspaces/{workspaceId}/{projectId} and expose as virtual path "/<filename>"
-      const rootDir = `/lattice_store/workspaces/${workspaceId}/${projectId}`;
+      // Filesystem storage: write under /lattice_store/tenants/{tenantId}/workspaces/{workspaceId}/{projectId} and expose as virtual path "/<filename>"
+      const rootDir = `/lattice_store/tenants/${tenantId}/workspaces/${workspaceId}/${projectId}`;
       const targetDir = pathValue ? path.join(rootDir, pathValue) : rootDir;
       const targetPath = path.join(targetDir, filename);
       await fs.mkdir(path.dirname(targetPath), { recursive: true });
@@ -595,4 +719,8 @@ export function registerWorkspaceRoutes(app: FastifyInstance) {
     "/api/workspaces/:workspaceId/projects/:projectId/downloadfile",
     controller.downloadFile.bind(controller)
   );
+  app.get(
+    "/api/workspaces/:workspaceId/projects/:projectId/viewfile",
+    controller.viewFile.bind(controller)
+  );
 }

package/src/index.ts

@@ -14,6 +14,7 @@ import {
   registerLoggerLattice,
   getLoggerLattice,
   loggerLatticeManager,
+  sandboxLatticeManager,
 } from "@axiom-lattice/core";
 import {
   LoggerType,
@@ -196,6 +197,15 @@ const start = async (config?: LatticeGatewayConfig) => {
     // Access via: request.server.loggerLattice or app.loggerLattice
     app.decorate("loggerLattice", loggerLattice);
 
+    // Register sandbox manager if not already registered
+    if (!sandboxLatticeManager.hasLattice("default")) {
+      const sandboxBaseURL = process.env.SANDBOX_BASE_URL || "http://localhost:8080";
+      sandboxLatticeManager.registerLattice("default", {
+        baseURL: sandboxBaseURL,
+      });
+      logger.info(`Registered sandbox manager with baseURL: ${sandboxBaseURL}`);
+    }
+
     const target_port = config?.port || Number(process.env.PORT) || 4001;
 
     await app.listen({ port: target_port, host: "0.0.0.0" });

package/src/services/agent_service.ts

@@ -11,13 +11,28 @@ import { Command, CommandParams } from "@langchain/langgraph";
 import { v4 } from "uuid";
 import {
   getAgentClient,
-  getAgentLattice,
+  agentLatticeManager,
   InMemoryChunkBuffer,
   registerChunkBuffer,
   getChunkBuffer,
   hasChunkBuffer,
 } from "@axiom-lattice/core";
 
+/**
+ * Check if an agent exists for the given tenant and assistant ID
+ */
+export async function checkAgentExists(
+  tenant_id: string,
+  assistant_id: string
+): Promise<boolean> {
+  try {
+    const agentLattice = agentLatticeManager.getAgentLatticeWithTenant(tenant_id, assistant_id);
+    return agentLattice !== undefined;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Get or create the global ChunkBuffer instance
  */
@@ -53,7 +68,7 @@ export async function agent_invoke({
   command?: CommandParams<any>;
   custom_run_config?: Record<string, any>;
 }) {
-  const agentLattice = getAgentLattice(assistant_id);
+  const agentLattice = agentLatticeManager.getAgentLatticeWithTenant(tenant_id, assistant_id);
   const runnable_agent = agentLattice?.client;
 
   const { message, ...rest } = input;
@@ -66,6 +81,7 @@ export async function agent_invoke({
   // Get runConfig from agent config and merge with custom_run_config
   const runConfig = {
     ...agentLattice?.config?.runConfig || {},
+    tenantId: tenant_id,
     workspaceId: workspace_id,
     projectId: project_id,
     ...custom_run_config || {},
@@ -124,8 +140,8 @@ export async function agent_stream({
   run_id?: string;
   custom_run_config?: Record<string, any>;
 }) {
-  const runnable_agent = getAgentClient(assistant_id) as any;
-  const agentLattice = getAgentLattice(assistant_id);
+  const runnable_agent = await getAgentClient(tenant_id, assistant_id);
+  const agentLattice = agentLatticeManager.getAgentLatticeWithTenant(tenant_id, assistant_id);
   const { message, ...rest } = input;
   let messages: BaseMessage[] = [];
   if (!command) {
@@ -139,6 +155,7 @@ export async function agent_stream({
   // Get runConfig from agent config and merge with custom_run_config
   const runConfig = {
     ...agentLattice?.config?.runConfig || {},
+    tenantId: tenant_id,
     workspaceId: workspace_id,
     projectId: project_id,
     ...custom_run_config || {},
@@ -150,7 +167,7 @@ export async function agent_stream({
     if (!runnable_agent) {
       throw new Error(`Agent ${assistant_id} not found`);
     }
-    const agentStream = await runnable_agent.stream(
+    const agentStream = await (runnable_agent as any).stream(
       command
         ? new Command(command)
         : {
@@ -235,13 +252,15 @@ export async function agent_stream({
 }
 
 export async function agent_state({
-  thread_id,
   assistant_id,
+  thread_id,
+  tenant_id,
 }: {
   assistant_id: string;
   thread_id: string;
+  tenant_id: string;
 }) {
-  const runnable_agent = getAgentClient(assistant_id);
+  const runnable_agent = await getAgentClient(tenant_id, assistant_id);
   if (!runnable_agent) {
     throw new Error(`Agent ${assistant_id} not found`);
   }
@@ -260,7 +279,7 @@ export async function agent_messages({
   thread_id: string;
   tenant_id: string;
 }) {
-  const runnable_agent = getAgentClient(assistant_id);
+  const runnable_agent = await getAgentClient(tenant_id, assistant_id);
   if (!runnable_agent) {
     throw new Error(`Agent ${assistant_id} not found`);
   }
@@ -298,8 +317,8 @@ export async function agent_messages({
   return new_messages;
 }
 
-export async function draw_graph(assistant_id: string) {
-  const runnable_agent = getAgentClient(assistant_id);
+export async function draw_graph(assistant_id: string, tenant_id: string) {
+  const runnable_agent = await getAgentClient(tenant_id, assistant_id);
   if (!runnable_agent) {
     throw new Error(`Agent ${assistant_id} not found`);
   }

package/src/services/agent_task_consumer.ts

@@ -120,7 +120,7 @@ const handleAgentTask = async (
 
       // Stream has ended successfully
       if (callback_event) {
-        const state = await agent_state({ assistant_id, thread_id });
+        const state = await agent_state({ assistant_id, thread_id, tenant_id });
         eventBus.publish(callback_event, {
           success: true,
           state: state,
@@ -137,7 +137,7 @@ const handleAgentTask = async (
       await response.text(); // Consume the response
 
       if (callback_event) {
-        const state = await agent_state({ assistant_id, thread_id });
+        const state = await agent_state({ assistant_id, thread_id, tenant_id });
         eventBus.publish(callback_event, {
           success: true,
           state,

package/src/services/sandbox_service.ts

@@ -1,5 +1,5 @@
-import { getAgentConfig, getAgentLattice, getSandBoxManager, normalizeSandboxName, sandboxLatticeManager } from "@axiom-lattice/core";
-import { ConnectedSandboxConfig, SandboxMiddlewareConfig } from "@axiom-lattice/protocols";
+import { agentLatticeManager, getSandBoxManager, normalizeSandboxName, sandboxLatticeManager } from "@axiom-lattice/core";
+import { SandboxMiddlewareConfig } from "@axiom-lattice/protocols";
 
 
 const ERROR_HTML = `<!DOCTYPE html>
@@ -114,19 +114,20 @@ const ERROR_HTML = `<!DOCTYPE html>
 
 export class SandboxService {
 
-  getFilesystemIsolatedLevel(assistantId: string): "agent" | "thread" | "global" | null {
-    const agentConfig = getAgentConfig(assistantId);
-    if (!agentConfig) {
+  getFilesystemIsolatedLevel(tenantId: string, assistantId: string): "agent" | "thread" | "global" | null {
+    const agentLattice = agentLatticeManager.getAgentLatticeWithTenant(tenantId, assistantId);
+    if (!agentLattice) {
       return null;
     }
 
-    const agentLattice = getAgentLattice(assistantId);
-    const filesystemConfig = agentLattice?.config?.middleware?.find(m => m.type === "filesystem");
+    const filesystemConfig = agentLattice?.config?.middleware?.find((m: any) => m.type === "filesystem");
     if (!filesystemConfig) {
       return null;
     }
 
-    return filesystemConfig.config?.isolatedLevel || null;
+    // Type guard for SandboxMiddlewareConfig which has isolatedLevel
+    const config = filesystemConfig.config as SandboxMiddlewareConfig;
+    return config?.isolatedLevel || null;
   }
 
   computeSandboxName(
@@ -153,7 +154,7 @@ export class SandboxService {
   }
 
   getTargetUrl(sandboxName: string): string {
-    const sandboxManager = getSandBoxManager("default")
+    const sandboxManager = getSandBoxManager()
     return `${sandboxManager.getBaseURL()}/sandbox/${sandboxName}`;
   }