@axiom-lattice/gateway 2.1.28 → 2.1.30

package/dist/index.mjs

@@ -1,3 +1,7 @@
+import {
+  configService
+} from "./chunk-FSASG3SB.mjs";
+
 // src/index.ts
 import fastify from "fastify";
 import cors from "@fastify/cors";
@@ -20,6 +24,31 @@ import {
   getChunkBuffer,
   hasChunkBuffer
 } from "@axiom-lattice/core";
+async function fetchDatabaseConfigs(baseURL, apiKey, tenantId) {
+  try {
+    const headers = {};
+    if (apiKey) {
+      headers["Authorization"] = `Bearer ${apiKey}`;
+    }
+    if (tenantId) {
+      headers["x-tenant-id"] = tenantId;
+    }
+    const response = await fetch(`${baseURL}/api/database-configs`, { headers });
+    if (response.ok) {
+      const data = await response.json();
+      if (data.success && data.data && Array.isArray(data.data.records)) {
+        return data.data.records.map((record) => ({
+          key: record.key,
+          name: record.name,
+          description: record.description
+        }));
+      }
+    }
+  } catch (error) {
+    console.error("Failed to fetch database configs:", error);
+  }
+  return [];
+}
 function getOrCreateChunkBuffer() {
   if (!hasChunkBuffer("default")) {
     const buffer = new InMemoryChunkBuffer({
@@ -37,6 +66,8 @@ async function agent_invoke({
   thread_id,
   assistant_id,
   tenant_id,
+  workspace_id,
+  project_id,
   command,
   run_id
 }) {
@@ -48,10 +79,19 @@ async function agent_invoke({
   if (!runnable_agent) {
     throw new Error(`Agent ${assistant_id} not found`);
   }
+  const { configService: configService2 } = await import("./config-F3FCBSPH.mjs");
+  const gatewayConfig = configService2.getConfig();
+  const databaseConfigs = await fetchDatabaseConfigs(
+    gatewayConfig.baseURL || "http://localhost:4001",
+    void 0,
+    tenant_id
+  );
+  global.__DATABASE_CONFIGS__ = databaseConfigs;
   const runConfig = {
     ...agentLattice?.config?.runConfig || {},
     assistant_id,
-    sandboxConfig: agentLattice?.config?.connectedSandbox
+    workspaceId: workspace_id,
+    projectId: project_id
   };
   const result = await runnable_agent.invoke(
     command ? new Command(command) : { ...rest, messages, "x-tenant-id": tenant_id },
@@ -60,11 +100,12 @@ async function agent_invoke({
         thread_id,
         run_id: run_id || v4(),
         "x-tenant-id": tenant_id,
+        "x-workspace-id": workspace_id,
+        "x-project-id": project_id,
         "x-request-id": run_id,
         "x-thread-id": thread_id,
         "x-assistant-id": assistant_id,
         runConfig
-        // Inject runConfig for tools to access
       },
       recursionLimit: 200
     }
@@ -83,6 +124,8 @@ async function agent_stream({
   thread_id,
   command,
   tenant_id,
+  workspace_id,
+  project_id,
   assistant_id,
   run_id
 }) {
@@ -95,10 +138,19 @@ async function agent_stream({
     messages = [humanMessage];
   }
   const chunkBuffer = getOrCreateChunkBuffer();
+  const { configService: configService2 } = await import("./config-F3FCBSPH.mjs");
+  const gatewayConfig = configService2.getConfig();
+  const databaseConfigs = await fetchDatabaseConfigs(
+    gatewayConfig.baseURL || "http://localhost:4001",
+    void 0,
+    tenant_id
+  );
+  global.__DATABASE_CONFIGS__ = databaseConfigs;
   const runConfig = {
     ...agentLattice?.config?.runConfig || {},
     assistant_id,
-    sandboxConfig: agentLattice?.config?.connectedSandbox
+    workspaceId: workspace_id,
+    projectId: project_id
   };
   try {
     if (!runnable_agent) {
@@ -115,6 +167,8 @@ async function agent_stream({
           thread_id,
           run_id: run_id || v4(),
           "x-tenant-id": tenant_id,
+          "x-workspace-id": workspace_id,
+          "x-project-id": project_id,
           "x-request-id": run_id,
           "x-thread-id": thread_id,
           "x-assistant-id": assistant_id,
@@ -432,6 +486,8 @@ var createRun = async (request, reply) => {
       ...input
     } = request.body;
     const tenant_id = request.headers["x-tenant-id"];
+    const workspace_id = request.headers["x-workspace-id"];
+    const project_id = request.headers["x-project-id"];
     const x_request_id = request.headers["x-request-id"] || v42();
     if (!assistant_id) {
       reply.status(400).send({
@@ -447,6 +503,8 @@ var createRun = async (request, reply) => {
         thread_id,
         command,
         tenant_id,
+        workspace_id,
+        project_id,
         run_id: x_request_id
       });
       reply.hijack();
@@ -474,6 +532,8 @@ var createRun = async (request, reply) => {
         command,
         thread_id,
         tenant_id,
+        workspace_id,
+        project_id,
         run_id: x_request_id
       });
       reply.status(200).send(result);
@@ -1020,78 +1080,6 @@ async function resumeScheduledTask(request, reply) {
   }
 }
 
-// src/config.ts
-var ConfigService = class {
-  constructor() {
-    this.config = this.loadFromEnv();
-  }
-  /**
-   * Load configuration from environment variables
-   */
-  loadFromEnv() {
-    return {
-      port: process.env.PORT ? Number(process.env.PORT) : void 0,
-      queueServiceType: process.env.QUEUE_SERVICE_TYPE,
-      redisUrl: process.env.REDIS_URL,
-      redisPassword: process.env.REDIS_PASSWORD,
-      queueName: process.env.QUEUE_NAME
-    };
-  }
-  /**
-   * Update configuration from JSON object
-   * This will update both the internal config and process.env
-   */
-  updateConfig(jsonConfig) {
-    for (const [key, value] of Object.entries(jsonConfig)) {
-      if (value !== null && value !== void 0) {
-        if (typeof value === "object" && !Array.isArray(value)) {
-          for (const [nestedKey, nestedValue] of Object.entries(value)) {
-            const envKey = `${key.toUpperCase()}_${nestedKey.toUpperCase()}`;
-            process.env[envKey] = String(nestedValue);
-          }
-        } else {
-          process.env[key.toUpperCase()] = String(value);
-        }
-      }
-    }
-    this.config = this.loadFromEnv();
-    this.config = this.deepMerge(this.config, jsonConfig);
-  }
-  /**
-   * Deep merge two objects
-   */
-  deepMerge(target, source) {
-    const output = { ...target };
-    if (this.isObject(target) && this.isObject(source)) {
-      Object.keys(source).forEach((key) => {
-        if (this.isObject(source[key])) {
-          if (!(key in target)) {
-            Object.assign(output, { [key]: source[key] });
-          } else {
-            output[key] = this.deepMerge(target[key], source[key]);
-          }
-        } else {
-          Object.assign(output, { [key]: source[key] });
-        }
-      });
-    }
-    return output;
-  }
-  /**
-   * Check if value is a plain object
-   */
-  isObject(item) {
-    return item && typeof item === "object" && !Array.isArray(item);
-  }
-  /**
-   * Get current configuration
-   */
-  getConfig() {
-    return { ...this.config };
-  }
-};
-var configService = new ConfigService();
-
 // src/services/queue_service.ts
 import {
   queueLatticeManager,
@@ -2185,8 +2173,8 @@ var sandboxService = new SandboxService();
 
 // src/controllers/sandbox.ts
 import { getSandBoxManager as getSandBoxManager2 } from "@axiom-lattice/core";
-function getFilenameFromPath(path) {
-  const segments = path.replace(/\/+$/, "").split("/");
+function getFilenameFromPath(path2) {
+  const segments = path2.replace(/\/+$/, "").split("/");
   return segments[segments.length - 1] || "download";
 }
 var EXT_TO_MIME = {
@@ -2237,10 +2225,10 @@ function registerSandboxProxyRoutes(app2) {
         const pathValue = pathEntry && typeof pathEntry === "object" && "value" in pathEntry ? String(pathEntry.value) : typeof pathEntry === "string" ? pathEntry : void 0;
         const formData = new FormData();
         formData.append("file", new Blob([buffer]), data.filename ?? "file");
-        const path = `/home/gem/uploads/${pathValue ? pathValue : ""}${data.filename}`;
+        const path2 = `/home/gem/uploads/${pathValue ? pathValue : ""}${data.filename}`;
         const uploadResult = await sandbox.file.uploadFile({
           file: buffer,
-          path
+          path: path2
         });
         if (!uploadResult.ok) {
           return reply.status(502).send({ error: `Upload error: ${uploadResult.error}` });
@@ -2323,125 +2311,1837 @@ function registerSandboxProxyRoutes(app2) {
   );
 }
 
-// src/routes/index.ts
-var registerLatticeRoutes = (app2) => {
-  app2.post("/api/runs", createRun);
-  app2.post("/api/resume_stream", resumeStream);
-  app2.get(
-    "/api/assistants/:assistantId/:thread_id/memory",
-    { schema: getAllMemoryItemsSchema },
-    getAllMemoryItems
-  );
-  app2.get(
-    "/api/assistants/:assistantId/:thread_id/state",
-    { schema: getAgentStateSchema },
-    getAgentState
-  );
+// src/controllers/workspace.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import { Readable as Readable2 } from "stream";
+import { getStoreLattice as getStoreLattice5 } from "@axiom-lattice/core";
+import { SandboxFilesystem, FilesystemBackend } from "@axiom-lattice/core";
+import { getSandBoxManager as getSandBoxManager3 } from "@axiom-lattice/core";
+import { v4 as uuidv4 } from "uuid";
+var WorkspaceController = class {
+  constructor() {
+    this.workspaceStore = getStoreLattice5("default", "workspace").store;
+    this.projectStore = getStoreLattice5("default", "project").store;
+  }
+  getTenantId(request) {
+    return request.headers["x-tenant-id"] || "default";
+  }
+  // ==================== Workspace CRUD ====================
+  async listWorkspaces(request, reply) {
+    const tenantId = this.getTenantId(request);
+    const workspaces = await this.workspaceStore.getAllWorkspaces(tenantId);
+    return { success: true, data: workspaces };
+  }
+  async createWorkspace(request, reply) {
+    const tenantId = this.getTenantId(request);
+    const data = request.body;
+    const id = uuidv4();
+    const workspace = await this.workspaceStore.createWorkspace(
+      tenantId,
+      id,
+      data
+    );
+    return reply.status(201).send({ success: true, data: workspace });
+  }
+  async getWorkspace(request, reply) {
+    const tenantId = this.getTenantId(request);
+    const { workspaceId } = request.params;
+    const workspace = await this.workspaceStore.getWorkspaceById(
+      tenantId,
+      workspaceId
+    );
+    if (!workspace) {
+      return reply.status(404).send({ success: false, error: "Workspace not found" });
+    }
+    return { success: true, data: workspace };
+  }
+  async updateWorkspace(request, reply) {
+    const tenantId = this.getTenantId(request);
+    const { workspaceId } = request.params;
+    const updates = request.body;
+    const workspace = await this.workspaceStore.updateWorkspace(
+      tenantId,
+      workspaceId,
+      updates
+    );
+    if (!workspace) {
+      return reply.status(404).send({ success: false, error: "Workspace not found" });
+    }
+    return { success: true, data: workspace };
+  }
+  async deleteWorkspace(request, reply) {
+    const tenantId = this.getTenantId(request);
+    const { workspaceId } = request.params;
+    const deleted = await this.workspaceStore.deleteWorkspace(
+      tenantId,
+      workspaceId
+    );
+    if (!deleted) {
+      return reply.status(404).send({ success: false, error: "Workspace not found" });
+    }
+    return { success: true };
+  }
+  // ==================== Project CRUD ====================
+  async listProjects(request, reply) {
+    const tenantId = this.getTenantId(request);
+    const { workspaceId } = request.params;
+    const projects = await this.projectStore.getProjectsByWorkspace(
+      tenantId,
+      workspaceId
+    );
+    return { success: true, data: projects };
+  }
+  async createProject(request, reply) {
+    const tenantId = this.getTenantId(request);
+    const { workspaceId } = request.params;
+    const data = request.body;
+    const id = uuidv4();
+    const project = await this.projectStore.createProject(
+      tenantId,
+      workspaceId,
+      id,
+      data
+    );
+    return reply.status(201).send({ success: true, data: project });
+  }
+  async getProject(request, reply) {
+    const tenantId = this.getTenantId(request);
+    const { projectId } = request.params;
+    const project = await this.projectStore.getProjectById(tenantId, projectId);
+    if (!project) {
+      return reply.status(404).send({ success: false, error: "Project not found" });
+    }
+    return { success: true, data: project };
+  }
+  async updateProject(request, reply) {
+    const tenantId = this.getTenantId(request);
+    const { projectId } = request.params;
+    const updates = request.body;
+    const project = await this.projectStore.updateProject(
+      tenantId,
+      projectId,
+      updates
+    );
+    if (!project) {
+      return reply.status(404).send({ success: false, error: "Project not found" });
+    }
+    return { success: true, data: project };
+  }
+  async deleteProject(request, reply) {
+    const tenantId = this.getTenantId(request);
+    const { projectId } = request.params;
+    const deleted = await this.projectStore.deleteProject(tenantId, projectId);
+    if (!deleted) {
+      return reply.status(404).send({ success: false, error: "Project not found" });
+    }
+    return { success: true };
+  }
+  // ==================== File Operations ====================
+  async getBackend(workspaceId, projectId) {
+    const tenantId = "default";
+    const workspace = await this.workspaceStore.getWorkspaceById(
+      tenantId,
+      workspaceId
+    );
+    if (!workspace) {
+      throw new Error("Workspace not found");
+    }
+    if (workspace.storageType === "sandbox") {
+      const sandboxManager = getSandBoxManager3("default");
+      const sandboxName = "global";
+      const sandbox = await sandboxManager.createSandbox(sandboxName);
+      return { backend: new SandboxFilesystem({
+        sandboxInstance: sandbox,
+        workingDirectory: `/workspaces/${workspaceId}/${projectId}`
+      }), workspace };
+    } else {
+      return { backend: new FilesystemBackend({
+        rootDir: `/lattice_store/workspaces/${workspaceId}/${projectId}`,
+        virtualMode: true
+      }), workspace };
+    }
+  }
+  getFilenameFromPath(filePath) {
+    const segments = filePath.split("/");
+    return segments[segments.length - 1] || "download";
+  }
+  getMimeType(filename) {
+    const ext = filename.split(".").pop()?.toLowerCase() || "";
+    const mimeTypes = {
+      pdf: "application/pdf",
+      csv: "text/csv",
+      xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+      xls: "application/vnd.ms-excel",
+      txt: "text/plain",
+      json: "application/json",
+      png: "image/png",
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      gif: "image/gif",
+      svg: "image/svg+xml",
+      html: "text/html",
+      htm: "text/html",
+      mp3: "audio/mpeg",
+      mp4: "video/mp4",
+      webm: "video/webm"
+    };
+    return mimeTypes[ext] || "application/octet-stream";
+  }
+  async downloadFile(request, reply) {
+    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(workspaceId, projectId);
+      const resolvedPath = filePath.startsWith("/") ? filePath : `/${filePath}`;
+      if (workspace.storageType === "sandbox") {
+        const sandboxManager = getSandBoxManager3("default");
+        const sandbox = await sandboxManager.createSandbox("global");
+        const realPath = path.join("/home/gem/workspaces", workspaceId, projectId, resolvedPath);
+        const filename2 = this.getFilenameFromPath(resolvedPath);
+        const inferredContentType = this.getMimeType(filename2);
+        const downloadResult = await sandbox.file.downloadFile({
+          path: realPath
+        });
+        if (!downloadResult.ok) {
+          return reply.status(502).send({
+            success: false,
+            error: `Download error: ${JSON.stringify(downloadResult.error)}`
+          });
+        }
+        const body = downloadResult.body;
+        if (typeof body?.stream === "function") {
+          const webStream = body.stream();
+          const nodeStream = Readable2.fromWeb(webStream);
+          const contentType2 = body.contentType ?? inferredContentType;
+          const contentDisposition2 = body.contentDisposition ?? `inline; filename*=UTF-8''${encodeURIComponent(filename2)}`;
+          return reply.status(200).type(contentType2).header("Content-Disposition", contentDisposition2).send(nodeStream);
+        }
+        const bodyUnknown = downloadResult.body;
+        let buf;
+        let contentType = inferredContentType;
+        let contentDisposition = `inline; filename*=UTF-8''${encodeURIComponent(filename2)}`;
+        if (bodyUnknown instanceof ArrayBuffer) {
+          buf = Buffer.from(bodyUnknown);
+        } else if (bodyUnknown instanceof Buffer) {
+          buf = bodyUnknown;
+        } else if (bodyUnknown && typeof bodyUnknown.arrayBuffer === "function") {
+          const res = bodyUnknown;
+          buf = Buffer.from(await res.arrayBuffer());
+          if (res.headers?.get("content-type")) contentType = res.headers.get("content-type");
+          if (res.headers?.get("content-disposition")) contentDisposition = res.headers.get("content-disposition");
+        } else if (bodyUnknown && typeof bodyUnknown.blob === "function") {
+          const blob = await bodyUnknown.blob();
+          buf = Buffer.from(await blob.arrayBuffer());
+        } else {
+          return reply.status(502).send({ success: false, error: "Unexpected download response format" });
+        }
+        return reply.status(200).type(contentType).header("Content-Disposition", contentDisposition).send(buf);
+      }
+      const { backend } = await this.getBackend(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; filename*=UTF-8''${encodeURIComponent(filename)}`).send(buffer);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return reply.status(502).send({ success: false, error: `Download proxy error: ${message}` });
+    }
+  }
+  async listPath(request) {
+    const { workspaceId, projectId } = request.params;
+    const path2 = request.query.path || "/";
+    const { backend } = await this.getBackend(workspaceId, projectId);
+    const files = await backend.lsInfo(path2);
+    return { success: true, data: files };
+  }
+  async readFile(request) {
+    const { workspaceId, projectId } = request.params;
+    const { path: path2, offset = 0, limit = 1e3 } = request.query;
+    const { backend } = await this.getBackend(workspaceId, projectId);
+    const content = await backend.read(path2, Number(offset), Number(limit));
+    return { success: true, data: { content, offset, limit } };
+  }
+  /**
+   * Upload a file to the workspace project storage.
+   *
+   * Route: POST /api/workspaces/:workspaceId/projects/:projectId/uploadfile
+   * Accepts multipart/form-data with:
+   * - `file`: the file to upload (required)
+   * - `path`: optional directory path relative to project root (e.g., "docs", "src/utils")
+   * For sandbox storage, delegates to the sandbox upload API.
+   * For filesystem storage, writes directly under /lattice_store/workspaces/{workspaceId}/{projectId}.
+   */
+  async uploadFile(request, reply) {
+    const tenantId = this.getTenantId(request);
+    const { workspaceId, projectId } = request.params;
+    const workspace = await this.workspaceStore.getWorkspaceById(
+      tenantId,
+      workspaceId
+    );
+    if (!workspace) {
+      return reply.status(404).send({ success: false, error: "Workspace not found" });
+    }
+    try {
+      const data = await request.file();
+      if (!data) {
+        return reply.status(400).send({ success: false, error: "No file in request" });
+      }
+      const buffer = await data.toBuffer();
+      const filename = data.filename || "file";
+      const pathEntry = data.fields?.path;
+      const pathValue = pathEntry && typeof pathEntry === "object" && "value" in pathEntry ? String(pathEntry.value) : typeof pathEntry === "string" ? pathEntry : void 0;
+      if (pathValue && !/^[a-zA-Z0-9_./-]+$/.test(pathValue)) {
+        return reply.status(400).send({ success: false, error: "Invalid path parameter" });
+      }
+      if (workspace.storageType === "sandbox") {
+        const sandboxManager = getSandBoxManager3("default");
+        const sandboxName = "global";
+        const sandbox = await sandboxManager.createSandbox(sandboxName);
+        const baseDir = path.join("/home/gem/workspaces", workspaceId, projectId);
+        const realPath = pathValue ? path.join(baseDir, pathValue, filename) : path.join(baseDir, filename);
+        const uploadResult = await sandbox.file.uploadFile({
+          file: buffer,
+          path: realPath
+        }, { timeoutInSeconds: 300 });
+        if (!uploadResult.ok) {
+          return reply.status(502).send({
+            success: false,
+            error: `Upload error: ${JSON.stringify(uploadResult.error)}`
+          });
+        }
+        const relativePath = uploadResult.body?.data?.file_path?.replace(path.join("/home/gem/workspaces", workspaceId, projectId), "") || (pathValue ? `/${pathValue}/${filename}` : `/${filename}`);
+        const result2 = {
+          path: relativePath,
+          name: filename,
+          is_dir: false,
+          size: buffer.length,
+          modified_at: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        return reply.status(200).send({ success: true, data: result2 });
+      }
+      const rootDir = `/lattice_store/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 });
+      await fs.writeFile(targetPath, buffer);
+      const stat2 = await fs.stat(targetPath);
+      const result = {
+        path: pathValue ? `/${pathValue}/${filename}` : `/${filename}`,
+        name: filename,
+        is_dir: false,
+        size: stat2.size,
+        modified_at: stat2.mtime.toISOString()
+      };
+      return reply.status(200).send({ success: true, data: result });
+    } catch (error) {
+      return reply.status(500).send({
+        success: false,
+        error: `Upload handler error: ${error?.message || String(error)}`
+      });
+    }
+  }
+};
+function registerWorkspaceRoutes(app2) {
+  const controller = new WorkspaceController();
+  app2.get("/api/workspaces", controller.listWorkspaces.bind(controller));
+  app2.post("/api/workspaces", controller.createWorkspace.bind(controller));
   app2.get(
-    "/api/assistants/:assistantId/memory/:key",
-    { schema: getMemoryItemSchema },
-    getMemoryItem
-  );
-  app2.put(
-    "/api/assistants/:assistantId/memory/:key",
-    { schema: setMemoryItemSchema },
-    setMemoryItem
+    "/api/workspaces/:workspaceId",
+    controller.getWorkspace.bind(controller)
   );
-  app2.delete(
-    "/api/assistants/:assistantId/memory/:key",
-    { schema: deleteMemoryItemSchema },
-    deleteMemoryItem
+  app2.patch(
+    "/api/workspaces/:workspaceId",
+    controller.updateWorkspace.bind(controller)
   );
   app2.delete(
-    "/api/assistants/:assistantId/memory",
-    { schema: clearMemorySchema },
-    clearMemory
+    "/api/workspaces/:workspaceId",
+    controller.deleteWorkspace.bind(controller)
   );
-  app2.get("/api/assistants", getAssistantList);
-  app2.get("/api/assistants/:id", getAssistant);
-  app2.post("/api/assistants", createAssistant);
-  app2.put("/api/assistants/:id", updateAssistant);
-  app2.delete("/api/assistants/:id", deleteAssistant);
   app2.get(
-    "/api/assistants/:assistantId/graph",
-    { schema: getAgentGraphSchema },
-    getAgentGraph
+    "/api/workspaces/:workspaceId/projects",
+    controller.listProjects.bind(controller)
   );
   app2.post(
-    "/api/agent-tasks/trigger",
-    { schema: triggerAgentTaskSchema },
-    triggerAgentTask
+    "/api/workspaces/:workspaceId/projects",
+    controller.createProject.bind(controller)
   );
-  app2.get("/api/assistants/:assistantId/threads", getThreadList);
   app2.get(
-    "/api/assistants/:assistantId/threads/:threadId",
-    getThread
+    "/api/workspaces/:workspaceId/projects/:projectId",
+    controller.getProject.bind(controller)
   );
-  app2.post("/api/assistants/:assistantId/threads", createThread);
-  app2.put(
-    "/api/assistants/:assistantId/threads/:threadId",
-    updateThread
+  app2.patch(
+    "/api/workspaces/:workspaceId/projects/:projectId",
+    controller.updateProject.bind(controller)
   );
   app2.delete(
-    "/api/assistants/:assistantId/threads/:threadId",
-    deleteThread
-  );
-  app2.get(
-    "/api/config",
-    { schema: getConfigSchema },
-    getConfig
-  );
-  app2.put(
-    "/api/config",
-    { schema: updateConfigSchema },
-    updateConfig
-  );
-  app2.get("/api/models", getModels);
-  app2.put("/api/models", updateModels);
-  app2.get("/api/tools", getToolConfigs);
-  app2.get(
-    "/health",
-    { schema: getHealthSchema },
-    getHealth
+    "/api/workspaces/:workspaceId/projects/:projectId",
+    controller.deleteProject.bind(controller)
   );
   app2.get(
-    "/api/assistants/:assistantId/threads/:threadId/schedules",
-    getThreadSchedules
+    "/api/workspaces/:workspaceId/projects/:projectId/listpath",
+    controller.listPath.bind(controller)
   );
-  app2.get("/api/schedules/:taskId", getScheduledTask);
-  app2.post("/api/schedules/:taskId/cancel", cancelScheduledTask);
-  app2.post("/api/schedules/:taskId/pause", pauseScheduledTask);
-  app2.post("/api/schedules/:taskId/resume", resumeScheduledTask);
-  app2.get("/api/skills", getSkillList);
   app2.get(
-    "/api/skills/:id",
-    getSkill
+    "/api/workspaces/:workspaceId/projects/:projectId/readfile",
+    controller.readFile.bind(controller)
   );
   app2.post(
-    "/api/skills",
-    createSkill
-  );
-  app2.put(
-    "/api/skills/:id",
-    updateSkill
-  );
-  app2.delete(
-    "/api/skills/:id",
-    deleteSkill
-  );
-  app2.get(
-    "/api/skills/search/metadata",
-    searchSkillsByMetadata
-  );
-  app2.get(
-    "/api/skills/filter/compatibility",
-    filterSkillsByCompatibility
+    "/api/workspaces/:workspaceId/projects/:projectId/uploadfile",
+    controller.uploadFile.bind(controller)
   );
   app2.get(
-    "/api/skills/filter/license",
-    filterSkillsByLicense
+    "/api/workspaces/:workspaceId/projects/:projectId/downloadfile",
+    controller.downloadFile.bind(controller)
   );
-  registerSandboxProxyRoutes(app2);
+}
+
+// src/controllers/database-configs.ts
+import {
+  getStoreLattice as getStoreLattice6,
+  sqlDatabaseManager
+} from "@axiom-lattice/core";
+import { randomUUID as randomUUID3 } from "crypto";
+function getTenantId(request) {
+  return request.headers["x-tenant-id"] || "default";
+}
+async function getDatabaseConfigList(request, reply) {
+  const tenantId = getTenantId(request);
+  try {
+    const storeLattice = getStoreLattice6("default", "database");
+    const store = storeLattice.store;
+    const configs = await store.getAllConfigs(tenantId);
+    console.log("Backend: getAllConfigs returned:", configs);
+    if (configs.length > 0) {
+      console.log("Backend: First config key:", configs[0].key);
+    }
+    return {
+      success: true,
+      message: "Database configurations retrieved successfully",
+      data: {
+        records: configs,
+        total: configs.length
+      }
+    };
+  } catch (error) {
+    console.error("Failed to get database configs:", error);
+    return {
+      success: false,
+      message: "Failed to retrieve database configurations",
+      data: {
+        records: [],
+        total: 0
+      }
+    };
+  }
+}
+async function getDatabaseConfig(request, reply) {
+  const tenantId = getTenantId(request);
+  const { key } = request.params;
+  try {
+    const storeLattice = getStoreLattice6("default", "database");
+    const store = storeLattice.store;
+    const config = await store.getConfigByKey(tenantId, key);
+    if (!config) {
+      return {
+        success: false,
+        message: "Database configuration not found"
+      };
+    }
+    return {
+      success: true,
+      message: "Database configuration retrieved successfully",
+      data: config
+    };
+  } catch (error) {
+    console.error("Failed to get database config:", error);
+    return {
+      success: false,
+      message: "Failed to retrieve database configuration"
+    };
+  }
+}
+async function createDatabaseConfig(request, reply) {
+  const tenantId = getTenantId(request);
+  const body = request.body;
+  try {
+    const storeLattice = getStoreLattice6("default", "database");
+    const store = storeLattice.store;
+    const existing = await store.getConfigByKey(tenantId, body.key);
+    if (existing) {
+      reply.code(409);
+      return {
+        success: false,
+        message: "Database configuration with this key already exists"
+      };
+    }
+    const id = body.id || randomUUID3();
+    const config = await store.createConfig(tenantId, id, body);
+    try {
+      sqlDatabaseManager.registerDatabase(config.key, config.config);
+    } catch (error) {
+      console.warn("Failed to auto-register database:", error);
+    }
+    reply.code(201);
+    return {
+      success: true,
+      message: "Database configuration created successfully",
+      data: config
+    };
+  } catch (error) {
+    console.error("Failed to create database config:", error);
+    return {
+      success: false,
+      message: "Failed to create database configuration"
+    };
+  }
+}
+async function updateDatabaseConfig(request, reply) {
+  const tenantId = getTenantId(request);
+  const { key } = request.params;
+  const updates = request.body;
+  try {
+    const storeLattice = getStoreLattice6("default", "database");
+    const store = storeLattice.store;
+    const existing = await store.getConfigByKey(tenantId, key);
+    if (!existing) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "Database configuration not found"
+      };
+    }
+    const updated = await store.updateConfig(tenantId, existing.id, updates);
+    if (!updated) {
+      return {
+        success: false,
+        message: "Failed to update database configuration"
+      };
+    }
+    if (updates.config) {
+      try {
+        sqlDatabaseManager.registerDatabase(updated.key, updated.config);
+      } catch (error) {
+        console.warn("Failed to re-register database:", error);
+      }
+    }
+    return {
+      success: true,
+      message: "Database configuration updated successfully",
+      data: updated
+    };
+  } catch (error) {
+    console.error("Failed to update database config:", error);
+    return {
+      success: false,
+      message: "Failed to update database configuration"
+    };
+  }
+}
+async function deleteDatabaseConfig(request, reply) {
+  const tenantId = getTenantId(request);
+  const { keyOrId } = request.params;
+  try {
+    const storeLattice = getStoreLattice6("default", "database");
+    const store = storeLattice.store;
+    console.log("Delete request - keyOrId:", keyOrId);
+    let config = await store.getConfigByKey(tenantId, keyOrId);
+    let configKey = keyOrId;
+    if (!config) {
+      config = await store.getConfigById(tenantId, keyOrId);
+      if (config) {
+        configKey = config.key;
+      }
+    }
+    if (!config) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "Database configuration not found"
+      };
+    }
+    console.log("Found config to delete:", { id: config.id, key: config.key });
+    const deleted = await store.deleteConfig(tenantId, config.id);
+    if (!deleted) {
+      return {
+        success: false,
+        message: "Failed to delete database configuration"
+      };
+    }
+    try {
+      if (sqlDatabaseManager.hasDatabase(configKey)) {
+        await sqlDatabaseManager.removeDatabase(configKey);
+      }
+    } catch (error) {
+      console.warn("Failed to remove from SqlDatabaseManager:", error);
+    }
+    return {
+      success: true,
+      message: "Database configuration deleted successfully"
+    };
+  } catch (error) {
+    console.error("Failed to delete database config:", error);
+    return {
+      success: false,
+      message: "Failed to delete database configuration"
+    };
+  }
+}
+async function testDatabaseConnection(request, reply) {
+  const tenantId = getTenantId(request);
+  const { key } = request.params;
+  try {
+    const storeLattice = getStoreLattice6("default", "database");
+    const store = storeLattice.store;
+    const config = await store.getConfigByKey(tenantId, key);
+    if (!config) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "Database configuration not found"
+      };
+    }
+    const testKey = `__test_${key}_${Date.now()}`;
+    sqlDatabaseManager.registerDatabase(testKey, config.config);
+    const startTime = Date.now();
+    const db = sqlDatabaseManager.getDatabase(testKey);
+    try {
+      await db.connect();
+      await db.listTables();
+      const latency = Date.now() - startTime;
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      await db.disconnect();
+      await sqlDatabaseManager.removeDatabase(testKey);
+      return {
+        success: true,
+        message: "Connection test successful",
+        data: {
+          connected: true,
+          latency
+        }
+      };
+    } catch (error) {
+      try {
+        await db.disconnect();
+        await sqlDatabaseManager.removeDatabase(testKey);
+      } catch {
+      }
+      return {
+        success: true,
+        message: "Connection test failed",
+        data: {
+          connected: false,
+          error: error instanceof Error ? error.message : "Unknown error"
+        }
+      };
+    }
+  } catch (error) {
+    console.error("Failed to test database connection:", error);
+    return {
+      success: false,
+      message: "Failed to test database connection",
+      data: {
+        connected: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      }
+    };
+  }
+}
+function registerDatabaseConfigRoutes(app2) {
+  app2.get(
+    "/api/database-configs",
+    getDatabaseConfigList
+  );
+  app2.get(
+    "/api/database-configs/:key",
+    getDatabaseConfig
+  );
+  app2.post(
+    "/api/database-configs",
+    createDatabaseConfig
+  );
+  app2.put(
+    "/api/database-configs/:key",
+    updateDatabaseConfig
+  );
+  app2.delete(
+    "/api/database-configs/:keyOrId",
+    deleteDatabaseConfig
+  );
+  app2.post(
+    "/api/database-configs/:key/test",
+    testDatabaseConnection
+  );
+}
+
+// src/controllers/metrics-configs.ts
+import {
+  getStoreLattice as getStoreLattice7,
+  metricsServerManager,
+  SemanticMetricsClient
+} from "@axiom-lattice/core";
+import { randomUUID as randomUUID4 } from "crypto";
+function getTenantId2(request) {
+  return request.headers["x-tenant-id"] || "default";
+}
+async function getMetricsServerConfigList(request, reply) {
+  const tenantId = getTenantId2(request);
+  try {
+    const storeLattice = getStoreLattice7("default", "metrics");
+    const store = storeLattice.store;
+    const configs = await store.getAllConfigs(tenantId);
+    return {
+      success: true,
+      message: "Metrics server configurations retrieved successfully",
+      data: {
+        records: configs,
+        total: configs.length
+      }
+    };
+  } catch (error) {
+    console.error("Failed to get metrics server configs:", error);
+    return {
+      success: false,
+      message: "Failed to retrieve metrics server configurations",
+      data: {
+        records: [],
+        total: 0
+      }
+    };
+  }
+}
+async function getMetricsServerConfig(request, reply) {
+  const tenantId = getTenantId2(request);
+  const { key } = request.params;
+  try {
+    const storeLattice = getStoreLattice7("default", "metrics");
+    const store = storeLattice.store;
+    const config = await store.getConfigByKey(tenantId, key);
+    if (!config) {
+      return {
+        success: false,
+        message: "Metrics server configuration not found"
+      };
+    }
+    return {
+      success: true,
+      message: "Metrics server configuration retrieved successfully",
+      data: config
+    };
+  } catch (error) {
+    console.error("Failed to get metrics server config:", error);
+    return {
+      success: false,
+      message: "Failed to retrieve metrics server configuration"
+    };
+  }
+}
+async function createMetricsServerConfig(request, reply) {
+  const tenantId = getTenantId2(request);
+  const body = request.body;
+  try {
+    const storeLattice = getStoreLattice7("default", "metrics");
+    const store = storeLattice.store;
+    const existing = await store.getConfigByKey(tenantId, body.key);
+    if (existing) {
+      reply.code(409);
+      return {
+        success: false,
+        message: "Metrics server configuration with this key already exists"
+      };
+    }
+    if (body.config.type === "semantic" && !body.selectedDataSources) {
+      reply.code(400);
+      return {
+        success: false,
+        message: "selectedDataSources is required for semantic metrics servers"
+      };
+    }
+    const id = body.id || randomUUID4();
+    const configData = {
+      key: body.key,
+      name: body.name,
+      description: body.description,
+      config: body.config.type === "semantic" ? {
+        ...body.config,
+        selectedDataSources: body.selectedDataSources || []
+      } : body.config
+    };
+    const config = await store.createConfig(tenantId, id, configData);
+    try {
+      metricsServerManager.registerServer(config.key, config.config);
+    } catch (error) {
+      console.warn("Failed to auto-register metrics server:", error);
+    }
+    reply.code(201);
+    return {
+      success: true,
+      message: "Metrics server configuration created successfully",
+      data: config
+    };
+  } catch (error) {
+    console.error("Failed to create metrics server config:", error);
+    return {
+      success: false,
+      message: "Failed to create metrics server configuration"
+    };
+  }
+}
+async function updateMetricsServerConfig(request, reply) {
+  const tenantId = getTenantId2(request);
+  const { key } = request.params;
+  const updates = request.body;
+  try {
+    const storeLattice = getStoreLattice7("default", "metrics");
+    const store = storeLattice.store;
+    const existing = await store.getConfigByKey(tenantId, key);
+    if (!existing) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "Metrics server configuration not found"
+      };
+    }
+    const isSemantic = updates.config?.type === "semantic" || existing.config.type === "semantic" && !updates.config?.type;
+    if (isSemantic && updates.selectedDataSources !== void 0) {
+      updates.config = {
+        ...existing.config,
+        ...updates.config,
+        type: "semantic",
+        selectedDataSources: updates.selectedDataSources
+      };
+    }
+    const updated = await store.updateConfig(tenantId, existing.id, updates);
+    if (!updated) {
+      return {
+        success: false,
+        message: "Failed to update metrics server configuration"
+      };
+    }
+    if (updates.config) {
+      try {
+        metricsServerManager.registerServer(updated.key, updated.config);
+      } catch (error) {
+        console.warn("Failed to re-register metrics server:", error);
+      }
+    }
+    return {
+      success: true,
+      message: "Metrics server configuration updated successfully",
+      data: updated
+    };
+  } catch (error) {
+    console.error("Failed to update metrics server config:", error);
+    return {
+      success: false,
+      message: "Failed to update metrics server configuration"
+    };
+  }
+}
+async function deleteMetricsServerConfig(request, reply) {
+  const tenantId = getTenantId2(request);
+  const { keyOrId } = request.params;
+  try {
+    const storeLattice = getStoreLattice7("default", "metrics");
+    const store = storeLattice.store;
+    let config = await store.getConfigByKey(tenantId, keyOrId);
+    let configKey = keyOrId;
+    if (!config) {
+      config = await store.getConfigById(tenantId, keyOrId);
+      if (config) {
+        configKey = config.key;
+      }
+    }
+    if (!config) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "Metrics server configuration not found"
+      };
+    }
+    const deleted = await store.deleteConfig(tenantId, config.id);
+    if (!deleted) {
+      return {
+        success: false,
+        message: "Failed to delete metrics server configuration"
+      };
+    }
+    try {
+      if (metricsServerManager.hasServer(configKey)) {
+        metricsServerManager.removeServer(configKey);
+      }
+    } catch (error) {
+      console.warn("Failed to remove from MetricsServerManager:", error);
+    }
+    return {
+      success: true,
+      message: "Metrics server configuration deleted successfully"
+    };
+  } catch (error) {
+    console.error("Failed to delete metrics server config:", error);
+    return {
+      success: false,
+      message: "Failed to delete metrics server configuration"
+    };
+  }
+}
+async function testMetricsServerConnection(request, reply) {
+  const tenantId = getTenantId2(request);
+  const { key } = request.params;
+  try {
+    const storeLattice = getStoreLattice7("default", "metrics");
+    const store = storeLattice.store;
+    const config = await store.getConfigByKey(tenantId, key);
+    if (!config) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "Metrics server configuration not found"
+      };
+    }
+    const testKey = `__test_${key}_${Date.now()}`;
+    metricsServerManager.registerServer(testKey, config.config);
+    try {
+      const client = metricsServerManager.getClient(testKey);
+      const result = await client.testConnection();
+      metricsServerManager.removeServer(testKey);
+      return {
+        success: true,
+        message: result.connected ? "Connection test successful" : "Connection test failed",
+        data: result
+      };
+    } catch (error) {
+      try {
+        metricsServerManager.removeServer(testKey);
+      } catch {
+      }
+      return {
+        success: true,
+        message: "Connection test failed",
+        data: {
+          connected: false,
+          error: error instanceof Error ? error.message : "Unknown error"
+        }
+      };
+    }
+  } catch (error) {
+    console.error("Failed to test metrics server connection:", error);
+    return {
+      success: false,
+      message: "Failed to test metrics server connection",
+      data: {
+        connected: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      }
+    };
+  }
+}
+async function listAvailableMetrics(request, reply) {
+  const tenantId = getTenantId2(request);
+  const { key } = request.params;
+  try {
+    const storeLattice = getStoreLattice7("default", "metrics");
+    const store = storeLattice.store;
+    const config = await store.getConfigByKey(tenantId, key);
+    if (!config) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "Metrics server configuration not found"
+      };
+    }
+    if (!metricsServerManager.hasServer(key)) {
+      metricsServerManager.registerServer(key, config.config);
+    }
+    const client = metricsServerManager.getClient(key);
+    const metrics = await client.listMetrics();
+    return {
+      success: true,
+      message: "Metrics retrieved successfully",
+      data: {
+        metrics: metrics.map((m) => ({
+          name: m.name,
+          type: m.type,
+          description: m.description
+        }))
+      }
+    };
+  } catch (error) {
+    console.error("Failed to list metrics:", error);
+    return {
+      success: false,
+      message: "Failed to retrieve metrics"
+    };
+  }
+}
+async function queryMetricsData(request, reply) {
+  const tenantId = getTenantId2(request);
+  const { key } = request.params;
+  const { metricName, startTime, endTime, step, labels } = request.body;
+  try {
+    const storeLattice = getStoreLattice7("default", "metrics");
+    const store = storeLattice.store;
+    const config = await store.getConfigByKey(tenantId, key);
+    if (!config) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "Metrics server configuration not found"
+      };
+    }
+    if (!metricName) {
+      reply.code(400);
+      return {
+        success: false,
+        message: "metricName is required"
+      };
+    }
+    if (!metricsServerManager.hasServer(key)) {
+      metricsServerManager.registerServer(key, config.config);
+    }
+    const client = metricsServerManager.getClient(key);
+    const result = await client.queryMetricData(metricName, {
+      startTime,
+      endTime,
+      step,
+      labels
+    });
+    return {
+      success: true,
+      message: "Metric data retrieved successfully",
+      data: {
+        metricName: result.metricName,
+        dataPoints: result.dataPoints
+      }
+    };
+  } catch (error) {
+    console.error("Failed to query metric data:", error);
+    return {
+      success: false,
+      message: "Failed to query metric data"
+    };
+  }
+}
+async function getDataSources(request, reply) {
+  const tenantId = getTenantId2(request);
+  const { key } = request.params;
+  try {
+    const storeLattice = getStoreLattice7("default", "metrics");
+    const store = storeLattice.store;
+    const config = await store.getConfigByKey(tenantId, key);
+    if (!config) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "Metrics server configuration not found"
+      };
+    }
+    if (config.config.type !== "semantic") {
+      reply.code(400);
+      return {
+        success: false,
+        message: "This endpoint is only available for semantic metrics servers"
+      };
+    }
+    const semanticConfig = config.config;
+    const client = new SemanticMetricsClient(semanticConfig);
+    const datasources = await client.getDataSources();
+    return {
+      success: true,
+      message: "Data sources retrieved successfully",
+      data: {
+        datasources
+      }
+    };
+  } catch (error) {
+    console.error("Failed to get data sources:", error);
+    return {
+      success: false,
+      message: "Failed to retrieve data sources"
+    };
+  }
+}
+async function getDatasourceMetrics(request, reply) {
+  const tenantId = getTenantId2(request);
+  const { key, datasourceId } = request.params;
+  try {
+    const storeLattice = getStoreLattice7("default", "metrics");
+    const store = storeLattice.store;
+    const config = await store.getConfigByKey(tenantId, key);
+    if (!config) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "Metrics server configuration not found"
+      };
+    }
+    if (config.config.type !== "semantic") {
+      reply.code(400);
+      return {
+        success: false,
+        message: "This endpoint is only available for semantic metrics servers"
+      };
+    }
+    const semanticConfig = config.config;
+    const client = new SemanticMetricsClient(semanticConfig);
+    const metrics = await client.getDatasourceMetrics(datasourceId);
+    return {
+      success: true,
+      message: "Datasource metrics retrieved successfully",
+      data: metrics
+    };
+  } catch (error) {
+    console.error("Failed to get datasource metrics:", error);
+    return {
+      success: false,
+      message: "Failed to retrieve datasource metrics"
+    };
+  }
+}
+async function querySemanticMetrics(request, reply) {
+  const tenantId = getTenantId2(request);
+  const { key } = request.params;
+  const body = request.body;
+  try {
+    const storeLattice = getStoreLattice7("default", "metrics");
+    const store = storeLattice.store;
+    const config = await store.getConfigByKey(tenantId, key);
+    if (!config) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "Metrics server configuration not found"
+      };
+    }
+    if (config.config.type !== "semantic") {
+      reply.code(400);
+      return {
+        success: false,
+        message: "This endpoint is only available for semantic metrics servers"
+      };
+    }
+    if (!body.datasourceId || !body.metrics || body.metrics.length === 0) {
+      reply.code(400);
+      return {
+        success: false,
+        message: "datasourceId and metrics array are required"
+      };
+    }
+    const semanticConfig = config.config;
+    const client = new SemanticMetricsClient(semanticConfig);
+    const result = await client.semanticQuery(body);
+    return {
+      success: true,
+      message: "Semantic query executed successfully",
+      data: {
+        datasourceId: result.datasourceId,
+        metrics: result.metrics,
+        dataPoints: result.dataPoints,
+        metadata: result.metadata
+      }
+    };
+  } catch (error) {
+    console.error("Failed to query semantic metrics:", error);
+    return {
+      success: false,
+      message: "Failed to query semantic metrics"
+    };
+  }
+}
+async function testSemanticDataSources(request, reply) {
+  const body = request.body;
+  try {
+    if (!body.serverUrl) {
+      reply.code(400);
+      return {
+        success: false,
+        message: "serverUrl is required"
+      };
+    }
+    const testConfig = {
+      type: "semantic",
+      serverUrl: body.serverUrl,
+      apiKey: body.apiKey,
+      username: body.username,
+      password: body.password,
+      headers: body.headers
+    };
+    const client = new SemanticMetricsClient(testConfig);
+    const datasources = await client.getDataSources();
+    return {
+      success: true,
+      message: "Data sources retrieved successfully",
+      data: {
+        datasources
+      }
+    };
+  } catch (error) {
+    console.error("Failed to test datasources:", error);
+    return {
+      success: false,
+      message: `Failed to retrieve data sources: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function testDatasourceMetrics(request, reply) {
+  const { datasourceId } = request.params;
+  const body = request.body;
+  try {
+    if (!body.serverUrl) {
+      reply.code(400);
+      return {
+        success: false,
+        message: "serverUrl is required"
+      };
+    }
+    const testConfig = {
+      type: "semantic",
+      serverUrl: body.serverUrl,
+      apiKey: body.apiKey,
+      username: body.username,
+      password: body.password,
+      headers: body.headers
+    };
+    const client = new SemanticMetricsClient(testConfig);
+    const metrics = await client.getDatasourceMetrics(datasourceId);
+    return {
+      success: true,
+      message: "Datasource metrics retrieved successfully",
+      data: metrics
+    };
+  } catch (error) {
+    console.error("Failed to test datasource metrics:", error);
+    return {
+      success: false,
+      message: `Failed to retrieve datasource metrics: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+function registerMetricsServerConfigRoutes(app2) {
+  app2.get("/api/metrics-configs", getMetricsServerConfigList);
+  app2.get("/api/metrics-configs/:key", getMetricsServerConfig);
+  app2.post("/api/metrics-configs", createMetricsServerConfig);
+  app2.put("/api/metrics-configs/:key", updateMetricsServerConfig);
+  app2.delete("/api/metrics-configs/:keyOrId", deleteMetricsServerConfig);
+  app2.post("/api/metrics-configs/:key/test", testMetricsServerConnection);
+  app2.get("/api/metrics-configs/:key/metrics", listAvailableMetrics);
+  app2.post("/api/metrics-configs/:key/query", queryMetricsData);
+  app2.get("/api/metrics-configs/:key/datasources", getDataSources);
+  app2.get("/api/metrics-configs/:key/datasources/:datasourceId/meta", getDatasourceMetrics);
+  app2.post("/api/metrics-configs/:key/semantic-query", querySemanticMetrics);
+  app2.post("/api/metrics-configs/test-datasources", testSemanticDataSources);
+  app2.post("/api/metrics-configs/test-datasources/:datasourceId/meta", testDatasourceMetrics);
+}
+
+// src/controllers/users.ts
+import { getStoreLattice as getStoreLattice8 } from "@axiom-lattice/core";
+import { v4 as uuidv42 } from "uuid";
+var UsersController = class {
+  constructor() {
+    this.userStore = getStoreLattice8("default", "user").store;
+  }
+  async listUsers(request, reply) {
+    const { email } = request.query;
+    if (email) {
+      const user = await this.userStore.getUserByEmail(email);
+      return { success: true, data: user ? [user] : [] };
+    }
+    const users = await this.userStore.getAllUsers();
+    return { success: true, data: users };
+  }
+  async createUser(request, reply) {
+    const data = request.body;
+    const id = uuidv42();
+    const existingUser = await this.userStore.getUserByEmail(data.email);
+    if (existingUser) {
+      return reply.status(409).send({
+        success: false,
+        error: `User with email ${data.email} already exists`
+      });
+    }
+    const user = await this.userStore.createUser(id, data);
+    return reply.status(201).send({ success: true, data: user });
+  }
+  async getUser(request, reply) {
+    const { userId } = request.params;
+    const user = await this.userStore.getUserById(userId);
+    if (!user) {
+      return reply.status(404).send({
+        success: false,
+        error: "User not found"
+      });
+    }
+    return { success: true, data: user };
+  }
+  async updateUser(request, reply) {
+    const { userId } = request.params;
+    const updates = request.body;
+    if (updates.email) {
+      const existingUser = await this.userStore.getUserByEmail(updates.email);
+      if (existingUser && existingUser.id !== userId) {
+        return reply.status(409).send({
+          success: false,
+          error: `User with email ${updates.email} already exists`
+        });
+      }
+    }
+    const user = await this.userStore.updateUser(userId, updates);
+    if (!user) {
+      return reply.status(404).send({
+        success: false,
+        error: "User not found"
+      });
+    }
+    return { success: true, data: user };
+  }
+  async deleteUser(request, reply) {
+    const { userId } = request.params;
+    const deleted = await this.userStore.deleteUser(userId);
+    if (!deleted) {
+      return reply.status(404).send({
+        success: false,
+        error: "User not found"
+      });
+    }
+    return { success: true };
+  }
+};
+function registerUserRoutes(app2) {
+  const controller = new UsersController();
+  app2.get("/api/users", controller.listUsers.bind(controller));
+  app2.post("/api/users", controller.createUser.bind(controller));
+  app2.get("/api/users/:userId", controller.getUser.bind(controller));
+  app2.patch("/api/users/:userId", controller.updateUser.bind(controller));
+  app2.delete("/api/users/:userId", controller.deleteUser.bind(controller));
+}
+
+// src/controllers/tenants.ts
+import { getStoreLattice as getStoreLattice9 } from "@axiom-lattice/core";
+import { v4 as uuidv43 } from "uuid";
+var TenantsController = class {
+  constructor() {
+    this.tenantStore = getStoreLattice9("default", "tenant").store;
+  }
+  // ==================== Tenant CRUD ====================
+  async listTenants(request, reply) {
+    const tenants = await this.tenantStore.getAllTenants();
+    return { success: true, data: tenants };
+  }
+  async createTenant(request, reply) {
+    const data = request.body;
+    const id = uuidv43();
+    const tenant = await this.tenantStore.createTenant(id, data);
+    return reply.status(201).send({ success: true, data: tenant });
+  }
+  async getTenant(request, reply) {
+    const { tenantId } = request.params;
+    const tenant = await this.tenantStore.getTenantById(tenantId);
+    if (!tenant) {
+      return reply.status(404).send({
+        success: false,
+        error: "Tenant not found"
+      });
+    }
+    return { success: true, data: tenant };
+  }
+  async updateTenant(request, reply) {
+    const { tenantId } = request.params;
+    const updates = request.body;
+    const tenant = await this.tenantStore.updateTenant(tenantId, updates);
+    if (!tenant) {
+      return reply.status(404).send({
+        success: false,
+        error: "Tenant not found"
+      });
+    }
+    return { success: true, data: tenant };
+  }
+  async deleteTenant(request, reply) {
+    const { tenantId } = request.params;
+    if (tenantId === "default") {
+      return reply.status(403).send({
+        success: false,
+        error: "Cannot delete the default tenant"
+      });
+    }
+    const deleted = await this.tenantStore.deleteTenant(tenantId);
+    if (!deleted) {
+      return reply.status(404).send({
+        success: false,
+        error: "Tenant not found"
+      });
+    }
+    return { success: true };
+  }
+};
+function registerTenantRoutes(app2) {
+  const controller = new TenantsController();
+  app2.get("/api/tenants", controller.listTenants.bind(controller));
+  app2.post("/api/tenants", controller.createTenant.bind(controller));
+  app2.get("/api/tenants/:tenantId", controller.getTenant.bind(controller));
+  app2.patch("/api/tenants/:tenantId", controller.updateTenant.bind(controller));
+  app2.delete("/api/tenants/:tenantId", controller.deleteTenant.bind(controller));
+}
+
+// src/controllers/auth.ts
+import { getStoreLattice as getStoreLattice10 } from "@axiom-lattice/core";
+import { v4 as uuidv44 } from "uuid";
+var defaultAuthConfig = {
+  autoApproveUsers: true,
+  allowTenantRegistration: true,
+  tokenExpiration: 86400
+};
+var AuthController = class {
+  constructor(config = {}) {
+    this.userStore = getStoreLattice10("default", "user").store;
+    this.tenantStore = getStoreLattice10("default", "tenant").store;
+    this.userTenantLinkStore = getStoreLattice10("default", "userTenantLink").store;
+    this.config = { ...defaultAuthConfig, ...config };
+  }
+  async register(request, reply) {
+    const { email, password, name } = request.body;
+    try {
+      const existingUser = await this.userStore.getUserByEmail(email);
+      if (existingUser) {
+        return reply.status(409).send({
+          success: false,
+          error: "User with this email already exists"
+        });
+      }
+      const userId = uuidv44();
+      const userStatus = this.config.autoApproveUsers ? "active" : "pending";
+      const userData = {
+        email,
+        name,
+        status: userStatus,
+        metadata: {
+          passwordHash: await this.hashPassword(password)
+        }
+      };
+      const user = await this.userStore.createUser(userId, userData);
+      return reply.status(201).send({
+        success: true,
+        message: this.config.autoApproveUsers ? "Registration successful" : "Registration successful. Please wait for admin approval.",
+        data: {
+          user: {
+            id: user.id,
+            email: user.email,
+            name: user.name,
+            status: user.status
+          }
+        }
+      });
+    } catch (error) {
+      console.error("Registration error:", error);
+      return reply.status(500).send({
+        success: false,
+        error: "Registration failed"
+      });
+    }
+  }
+  async login(request, reply) {
+    const { email, password } = request.body;
+    try {
+      const user = await this.userStore.getUserByEmail(email);
+      if (!user) {
+        return reply.status(401).send({
+          success: false,
+          error: "Invalid credentials"
+        });
+      }
+      if (user.status !== "active") {
+        return reply.status(403).send({
+          success: false,
+          error: `Account is ${user.status}. Please wait for admin approval.`
+        });
+      }
+      const isValidPassword = await this.verifyPassword(
+        password,
+        user.metadata?.passwordHash || ""
+      );
+      if (!isValidPassword) {
+        return reply.status(401).send({
+          success: false,
+          error: "Invalid credentials"
+        });
+      }
+      const tenantLinks = await this.userTenantLinkStore.getTenantsByUser(user.id);
+      const token = await this.generateToken(user.id);
+      return {
+        success: true,
+        data: {
+          user: {
+            id: user.id,
+            email: user.email,
+            name: user.name,
+            status: user.status
+          },
+          tenants: tenantLinks.map((link) => ({
+            id: link.tenantId,
+            role: link.role
+          })),
+          token,
+          requiresTenantSelection: tenantLinks.length > 1,
+          hasTenants: tenantLinks.length > 0
+        }
+      };
+    } catch (error) {
+      console.error("Login error:", error);
+      return reply.status(500).send({
+        success: false,
+        error: "Login failed"
+      });
+    }
+  }
+  async getUserTenants(request, reply) {
+    const userId = request.user?.id;
+    if (!userId) {
+      return reply.status(401).send({
+        success: false,
+        error: "Unauthorized"
+      });
+    }
+    try {
+      const links = await this.userTenantLinkStore.getTenantsByUser(userId);
+      const tenantsWithDetails = await Promise.all(
+        links.map(async (link) => {
+          const tenant = await this.tenantStore.getTenantById(link.tenantId);
+          return {
+            ...link,
+            tenant: tenant || null
+          };
+        })
+      );
+      return {
+        success: true,
+        data: tenantsWithDetails
+      };
+    } catch (error) {
+      console.error("Get user tenants error:", error);
+      return reply.status(500).send({
+        success: false,
+        error: "Failed to get user tenants"
+      });
+    }
+  }
+  async selectTenant(request, reply) {
+    const userId = request.user?.id;
+    const { tenantId } = request.body;
+    if (!userId) {
+      return reply.status(401).send({
+        success: false,
+        error: "Unauthorized"
+      });
+    }
+    try {
+      const hasLink = await this.userTenantLinkStore.hasLink(userId, tenantId);
+      if (!hasLink) {
+        return reply.status(403).send({
+          success: false,
+          error: "You do not have access to this tenant"
+        });
+      }
+      const tenant = await this.tenantStore.getTenantById(tenantId);
+      if (!tenant) {
+        return reply.status(404).send({
+          success: false,
+          error: "Tenant not found"
+        });
+      }
+      const token = await this.generateToken(userId, tenantId);
+      return {
+        success: true,
+        data: {
+          tenant: {
+            id: tenant.id,
+            name: tenant.name,
+            status: tenant.status
+          },
+          token
+        }
+      };
+    } catch (error) {
+      console.error("Select tenant error:", error);
+      return reply.status(500).send({
+        success: false,
+        error: "Failed to select tenant"
+      });
+    }
+  }
+  async approveUser(request, reply) {
+    const { userId, approved } = request.body;
+    try {
+      const user = await this.userStore.getUserById(userId);
+      if (!user) {
+        return reply.status(404).send({
+          success: false,
+          error: "User not found"
+        });
+      }
+      if (user.status !== "pending") {
+        return reply.status(400).send({
+          success: false,
+          error: `User is already ${user.status}`
+        });
+      }
+      const updatedUser = await this.userStore.updateUser(userId, {
+        status: approved ? "active" : "suspended"
+      });
+      return {
+        success: true,
+        data: updatedUser
+      };
+    } catch (error) {
+      console.error("Approval error:", error);
+      return reply.status(500).send({
+        success: false,
+        error: "Approval failed"
+      });
+    }
+  }
+  async listPendingUsers(request, reply) {
+    try {
+      const users = await this.userStore.getAllUsers();
+      const pendingUsers = users.filter((u) => u.status === "pending");
+      return {
+        success: true,
+        data: pendingUsers
+      };
+    } catch (error) {
+      console.error("List pending users error:", error);
+      return reply.status(500).send({
+        success: false,
+        error: "Failed to list pending users"
+      });
+    }
+  }
+  async assignTenant(request, reply) {
+    const { userId, tenantId, role = "member" } = request.body;
+    try {
+      const user = await this.userStore.getUserById(userId);
+      if (!user) {
+        return reply.status(404).send({
+          success: false,
+          error: "User not found"
+        });
+      }
+      const tenant = await this.tenantStore.getTenantById(tenantId);
+      if (!tenant) {
+        return reply.status(404).send({
+          success: false,
+          error: "Tenant not found"
+        });
+      }
+      const link = await this.userTenantLinkStore.createLink({
+        userId,
+        tenantId,
+        role
+      });
+      return {
+        success: true,
+        data: link
+      };
+    } catch (error) {
+      console.error("Assign tenant error:", error);
+      return reply.status(500).send({
+        success: false,
+        error: "Failed to assign tenant"
+      });
+    }
+  }
+  async hashPassword(password) {
+    const encoder = new TextEncoder();
+    const data = encoder.encode(password + "salt");
+    const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  async verifyPassword(password, hash) {
+    const hashedPassword = await this.hashPassword(password);
+    return hashedPassword === hash;
+  }
+  async generateToken(userId, tenantId) {
+    const payload = {
+      userId,
+      exp: Date.now() + this.config.tokenExpiration * 1e3
+    };
+    if (tenantId) {
+      payload.tenantId = tenantId;
+    }
+    return btoa(JSON.stringify(payload));
+  }
+};
+function registerAuthRoutes(app2, config) {
+  const controller = new AuthController(config);
+  const authHook = async (request, reply) => {
+    const authHeader = request.headers.authorization;
+    if (!authHeader || !authHeader.startsWith("Bearer ")) {
+      return reply.status(401).send({
+        success: false,
+        error: "Unauthorized - Missing or invalid token"
+      });
+    }
+    const token = authHeader.substring(7);
+    try {
+      const payload = JSON.parse(atob(token));
+      if (payload.exp && payload.exp < Date.now()) {
+        return reply.status(401).send({
+          success: false,
+          error: "Unauthorized - Token expired"
+        });
+      }
+      request.user = {
+        id: payload.userId,
+        tenantId: payload.tenantId
+      };
+    } catch {
+      return reply.status(401).send({
+        success: false,
+        error: "Unauthorized - Invalid token"
+      });
+    }
+  };
+  app2.post("/api/auth/register", controller.register.bind(controller));
+  app2.post("/api/auth/login", controller.login.bind(controller));
+  app2.get("/api/auth/tenants", { preHandler: authHook }, (req, res) => controller.getUserTenants(req, res));
+  app2.post("/api/auth/select-tenant", { preHandler: authHook }, (req, res) => controller.selectTenant(req, res));
+  app2.post("/api/auth/approve", { preHandler: authHook }, (req, res) => controller.approveUser(req, res));
+  app2.get("/api/auth/pending", { preHandler: authHook }, (req, res) => controller.listPendingUsers(req, res));
+  app2.post("/api/auth/assign-tenant", { preHandler: authHook }, (req, res) => controller.assignTenant(req, res));
+}
+
+// src/routes/index.ts
+var registerLatticeRoutes = (app2) => {
+  app2.post("/api/runs", createRun);
+  app2.post("/api/resume_stream", resumeStream);
+  app2.get(
+    "/api/assistants/:assistantId/:thread_id/memory",
+    { schema: getAllMemoryItemsSchema },
+    getAllMemoryItems
+  );
+  app2.get(
+    "/api/assistants/:assistantId/:thread_id/state",
+    { schema: getAgentStateSchema },
+    getAgentState
+  );
+  app2.get(
+    "/api/assistants/:assistantId/memory/:key",
+    { schema: getMemoryItemSchema },
+    getMemoryItem
+  );
+  app2.put(
+    "/api/assistants/:assistantId/memory/:key",
+    { schema: setMemoryItemSchema },
+    setMemoryItem
+  );
+  app2.delete(
+    "/api/assistants/:assistantId/memory/:key",
+    { schema: deleteMemoryItemSchema },
+    deleteMemoryItem
+  );
+  app2.delete(
+    "/api/assistants/:assistantId/memory",
+    { schema: clearMemorySchema },
+    clearMemory
+  );
+  app2.get("/api/assistants", getAssistantList);
+  app2.get("/api/assistants/:id", getAssistant);
+  app2.post("/api/assistants", createAssistant);
+  app2.put("/api/assistants/:id", updateAssistant);
+  app2.delete("/api/assistants/:id", deleteAssistant);
+  app2.get(
+    "/api/assistants/:assistantId/graph",
+    { schema: getAgentGraphSchema },
+    getAgentGraph
+  );
+  app2.post(
+    "/api/agent-tasks/trigger",
+    { schema: triggerAgentTaskSchema },
+    triggerAgentTask
+  );
+  app2.get("/api/assistants/:assistantId/threads", getThreadList);
+  app2.get(
+    "/api/assistants/:assistantId/threads/:threadId",
+    getThread
+  );
+  app2.post("/api/assistants/:assistantId/threads", createThread);
+  app2.put(
+    "/api/assistants/:assistantId/threads/:threadId",
+    updateThread
+  );
+  app2.delete(
+    "/api/assistants/:assistantId/threads/:threadId",
+    deleteThread
+  );
+  app2.get(
+    "/api/config",
+    { schema: getConfigSchema },
+    getConfig
+  );
+  app2.put(
+    "/api/config",
+    { schema: updateConfigSchema },
+    updateConfig
+  );
+  app2.get("/api/models", getModels);
+  app2.put("/api/models", updateModels);
+  app2.get("/api/tools", getToolConfigs);
+  app2.get(
+    "/health",
+    { schema: getHealthSchema },
+    getHealth
+  );
+  app2.get(
+    "/api/assistants/:assistantId/threads/:threadId/schedules",
+    getThreadSchedules
+  );
+  app2.get("/api/schedules/:taskId", getScheduledTask);
+  app2.post("/api/schedules/:taskId/cancel", cancelScheduledTask);
+  app2.post("/api/schedules/:taskId/pause", pauseScheduledTask);
+  app2.post("/api/schedules/:taskId/resume", resumeScheduledTask);
+  app2.get("/api/skills", getSkillList);
+  app2.get(
+    "/api/skills/:id",
+    getSkill
+  );
+  app2.post(
+    "/api/skills",
+    createSkill
+  );
+  app2.put(
+    "/api/skills/:id",
+    updateSkill
+  );
+  app2.delete(
+    "/api/skills/:id",
+    deleteSkill
+  );
+  app2.get(
+    "/api/skills/search/metadata",
+    searchSkillsByMetadata
+  );
+  app2.get(
+    "/api/skills/filter/compatibility",
+    filterSkillsByCompatibility
+  );
+  app2.get(
+    "/api/skills/filter/license",
+    filterSkillsByLicense
+  );
+  registerSandboxProxyRoutes(app2);
+  registerWorkspaceRoutes(app2);
+  registerDatabaseConfigRoutes(app2);
+  registerMetricsServerConfigRoutes(app2);
+  registerUserRoutes(app2);
+  registerTenantRoutes(app2);
+  registerAuthRoutes(app2, {
+    autoApproveUsers: process.env.AUTO_APPROVE_USERS !== "false",
+    allowTenantRegistration: process.env.ALLOW_TENANT_REGISTRATION !== "false"
+  });
 };
 
 // src/swagger.ts
@@ -2854,16 +4554,8 @@ app.addHook("onResponse", (request, reply, done) => {
 });
 app.register(cors, {
   origin: true,
-  methods: ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
-  allowedHeaders: [
-    "Content-Type",
-    "Authorization",
-    "X-Requested-With",
-    "x-tenant-id",
-    "x-request-id",
-    "x-assistant-id",
-    "x-thread-id"
-  ],
+  methods: ["GET", "POST", "PUT", "DELETE", "OPTIONS", "PATCH"],
+  allowedHeaders: "*",
   exposedHeaders: ["Content-Type"],
   credentials: true
 });