@axiom-lattice/gateway 2.1.28 → 2.1.30

package/dist/index.js

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,6 +30,106 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/config.ts
+var config_exports = {};
+__export(config_exports, {
+  config: () => config,
+  configService: () => configService
+});
+var ConfigService, configService, config;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    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 };
+      }
+    };
+    configService = new ConfigService();
+    config = {
+      get port() {
+        return configService.getConfig().port;
+      },
+      get queueServiceType() {
+        return configService.getConfig().queueServiceType;
+      },
+      get redisUrl() {
+        return configService.getConfig().redisUrl;
+      },
+      get redisPassword() {
+        return configService.getConfig().redisPassword;
+      },
+      get queueName() {
+        return configService.getConfig().queueName;
+      }
+    };
+  }
+});
+
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
@@ -44,6 +147,31 @@ var import_messages = require("@langchain/core/messages");
 var import_langgraph = require("@langchain/langgraph");
 var import_uuid = require("uuid");
 var import_core = require("@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 (!(0, import_core.hasChunkBuffer)("default")) {
     const buffer = new import_core.InMemoryChunkBuffer({
@@ -61,6 +189,8 @@ async function agent_invoke({
   thread_id,
   assistant_id,
   tenant_id,
+  workspace_id,
+  project_id,
   command,
   run_id
 }) {
@@ -72,10 +202,19 @@ async function agent_invoke({
   if (!runnable_agent) {
     throw new Error(`Agent ${assistant_id} not found`);
   }
+  const { configService: configService2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+  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 import_langgraph.Command(command) : { ...rest, messages, "x-tenant-id": tenant_id },
@@ -84,11 +223,12 @@ async function agent_invoke({
         thread_id,
         run_id: run_id || (0, import_uuid.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
     }
@@ -107,6 +247,8 @@ async function agent_stream({
   thread_id,
   command,
   tenant_id,
+  workspace_id,
+  project_id,
   assistant_id,
   run_id
 }) {
@@ -119,10 +261,19 @@ async function agent_stream({
     messages = [humanMessage];
   }
   const chunkBuffer = getOrCreateChunkBuffer();
+  const { configService: configService2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+  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) {
@@ -139,6 +290,8 @@ async function agent_stream({
           thread_id,
           run_id: run_id || (0, import_uuid.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,
@@ -272,12 +425,12 @@ async function resume_stream({
 var import_core2 = require("@axiom-lattice/core");
 var import_crypto = require("crypto");
 var import_core3 = require("@axiom-lattice/core");
-function convertAgentConfigToAssistant(config) {
+function convertAgentConfigToAssistant(config2) {
   return {
-    id: config.key,
-    name: config.name,
-    description: config.description,
-    graphDefinition: config,
+    id: config2.key,
+    name: config2.name,
+    description: config2.description,
+    graphDefinition: config2,
     // Store the full config as graphDefinition
     createdAt: /* @__PURE__ */ new Date(0),
     // Code-configured agents have no creation date
@@ -317,7 +470,7 @@ async function getAssistant(request, reply) {
   let assistant = await assistantStore.getAssistantById(id);
   if (!assistant) {
     const agentConfigs = await (0, import_core3.getAllAgentConfigs)();
-    const agentConfig = agentConfigs.find((config) => config.key === id);
+    const agentConfig = agentConfigs.find((config2) => config2.key === id);
     if (agentConfig) {
       assistant = convertAgentConfigToAssistant(agentConfig);
     }
@@ -392,7 +545,7 @@ async function deleteAssistant(request, reply) {
   const storeLattice = (0, import_core2.getStoreLattice)("default", "assistant");
   const assistantStore = storeLattice.store;
   const agentConfigs = await (0, import_core3.getAllAgentConfigs)();
-  const isCodeConfigured = agentConfigs.some((config) => config.key === id);
+  const isCodeConfigured = agentConfigs.some((config2) => config2.key === id);
   if (isCodeConfigured) {
     const exists2 = await assistantStore.hasAssistant(id);
     if (!exists2) {
@@ -456,6 +609,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"] || (0, import_uuid2.v4)();
     if (!assistant_id) {
       reply.status(400).send({
@@ -471,6 +626,8 @@ var createRun = async (request, reply) => {
         thread_id,
         command,
         tenant_id,
+        workspace_id,
+        project_id,
         run_id: x_request_id
       });
       reply.hijack();
@@ -498,6 +655,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);
@@ -1044,77 +1203,8 @@ 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/controllers/config.ts
+init_config();
 
 // src/services/queue_service.ts
 var import_core7 = require("@axiom-lattice/core");
@@ -1126,7 +1216,7 @@ var setQueueServiceType = (type) => {
   queueServiceType = type;
   console.log(`Queue service type set to: ${type}`);
   const queueName = process.env.QUEUE_NAME || "tasks";
-  const config = {
+  const config2 = {
     name: "Default Queue Service",
     description: `Default ${type} queue service`,
     type: type === "redis" ? import_protocols.QueueType.REDIS : import_protocols.QueueType.MEMORY,
@@ -1146,7 +1236,7 @@ var setQueueServiceType = (type) => {
       redisPassword: process.env.REDIS_PASSWORD
     });
   }
-  (0, import_core7.registerQueueLattice)(DEFAULT_QUEUE_KEY, config, client);
+  (0, import_core7.registerQueueLattice)(DEFAULT_QUEUE_KEY, config2, client);
 };
 var getQueueService = () => {
   if (!import_core7.queueLatticeManager.hasLattice(DEFAULT_QUEUE_KEY)) {
@@ -1238,18 +1328,18 @@ async function getModels(request, reply) {
   try {
     const allLattices = import_core8.modelLatticeManager.getAllLattices();
     const models = allLattices.map((lattice) => {
-      const config = lattice.client.config || {};
+      const config2 = lattice.client.config || {};
       return {
         key: lattice.key,
-        model: config.model || "",
-        provider: config.provider || "openai",
-        streaming: config.streaming || false,
-        apiKey: config.apiKey || "",
-        baseURL: config.baseURL || "",
-        maxTokens: config.maxTokens,
-        temperature: config.temperature,
-        timeout: config.timeout,
-        maxRetries: config.maxRetries
+        model: config2.model || "",
+        provider: config2.provider || "openai",
+        streaming: config2.streaming || false,
+        apiKey: config2.apiKey || "",
+        baseURL: config2.baseURL || "",
+        maxTokens: config2.maxTokens,
+        temperature: config2.temperature,
+        timeout: config2.timeout,
+        maxRetries: config2.maxRetries
       };
     });
     return reply.send({
@@ -1709,15 +1799,15 @@ async function getToolConfigs(request, reply) {
   try {
     const allLattices = import_core11.toolLatticeManager.getAllLattices();
     const toolConfigs = allLattices.map((lattice) => {
-      const config = { ...lattice.config };
-      const serializedSchema = config.schema ? serializeSchema(config.schema) : void 0;
+      const config2 = { ...lattice.config };
+      const serializedSchema = config2.schema ? serializeSchema(config2.schema) : void 0;
       return {
         id: lattice.key,
-        name: config.name,
-        description: config.description,
+        name: config2.name,
+        description: config2.description,
         schema: serializedSchema,
-        returnDirect: config.returnDirect,
-        needUserApprove: config.needUserApprove
+        returnDirect: config2.returnDirect,
+        needUserApprove: config2.needUserApprove
       };
     });
     return reply.send({
@@ -2205,8 +2295,8 @@ var sandboxService = new SandboxService();
 
 // src/controllers/sandbox.ts
 var import_core13 = require("@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 = {
@@ -2257,10 +2347,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}` });
@@ -2343,105 +2433,1801 @@ 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
+var fs = __toESM(require("fs/promises"));
+var path = __toESM(require("path"));
+var import_stream2 = require("stream");
+var import_core14 = require("@axiom-lattice/core");
+var import_core15 = require("@axiom-lattice/core");
+var import_core16 = require("@axiom-lattice/core");
+var import_uuid3 = require("uuid");
+var WorkspaceController = class {
+  constructor() {
+    this.workspaceStore = (0, import_core14.getStoreLattice)("default", "workspace").store;
+    this.projectStore = (0, import_core14.getStoreLattice)("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 = (0, import_uuid3.v4)();
+    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 = (0, import_uuid3.v4)();
+    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 = (0, import_core16.getSandBoxManager)("default");
+      const sandboxName = "global";
+      const sandbox = await sandboxManager.createSandbox(sandboxName);
+      return { backend: new import_core15.SandboxFilesystem({
+        sandboxInstance: sandbox,
+        workingDirectory: `/workspaces/${workspaceId}/${projectId}`
+      }), workspace };
+    } else {
+      return { backend: new import_core15.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 = (0, import_core16.getSandBoxManager)("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 = import_stream2.Readable.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 = (0, import_core16.getSandBoxManager)("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
+    "/api/workspaces/:workspaceId/projects/:projectId",
+    controller.deleteProject.bind(controller)
   );
   app2.get(
-    "/api/config",
-    { schema: getConfigSchema },
-    getConfig
-  );
-  app2.put(
-    "/api/config",
-    { schema: updateConfigSchema },
-    updateConfig
+    "/api/workspaces/:workspaceId/projects/:projectId/listpath",
+    controller.listPath.bind(controller)
   );
-  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/readfile",
+    controller.readFile.bind(controller)
   );
-  app2.get(
-    "/api/assistants/:assistantId/threads/:threadId/schedules",
-    getThreadSchedules
+  app2.post(
+    "/api/workspaces/:workspaceId/projects/:projectId/uploadfile",
+    controller.uploadFile.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
-  );
-  app2.post(
-    "/api/skills",
-    createSkill
+    "/api/workspaces/:workspaceId/projects/:projectId/downloadfile",
+    controller.downloadFile.bind(controller)
   );
-  app2.put(
+}
+
+// src/controllers/database-configs.ts
+var import_core17 = require("@axiom-lattice/core");
+var import_crypto3 = require("crypto");
+function getTenantId(request) {
+  return request.headers["x-tenant-id"] || "default";
+}
+async function getDatabaseConfigList(request, reply) {
+  const tenantId = getTenantId(request);
+  try {
+    const storeLattice = (0, import_core17.getStoreLattice)("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 = (0, import_core17.getStoreLattice)("default", "database");
+    const store = storeLattice.store;
+    const config2 = await store.getConfigByKey(tenantId, key);
+    if (!config2) {
+      return {
+        success: false,
+        message: "Database configuration not found"
+      };
+    }
+    return {
+      success: true,
+      message: "Database configuration retrieved successfully",
+      data: config2
+    };
+  } 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 = (0, import_core17.getStoreLattice)("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 || (0, import_crypto3.randomUUID)();
+    const config2 = await store.createConfig(tenantId, id, body);
+    try {
+      import_core17.sqlDatabaseManager.registerDatabase(config2.key, config2.config);
+    } catch (error) {
+      console.warn("Failed to auto-register database:", error);
+    }
+    reply.code(201);
+    return {
+      success: true,
+      message: "Database configuration created successfully",
+      data: config2
+    };
+  } 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 = (0, import_core17.getStoreLattice)("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 {
+        import_core17.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 = (0, import_core17.getStoreLattice)("default", "database");
+    const store = storeLattice.store;
+    console.log("Delete request - keyOrId:", keyOrId);
+    let config2 = await store.getConfigByKey(tenantId, keyOrId);
+    let configKey = keyOrId;
+    if (!config2) {
+      config2 = await store.getConfigById(tenantId, keyOrId);
+      if (config2) {
+        configKey = config2.key;
+      }
+    }
+    if (!config2) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "Database configuration not found"
+      };
+    }
+    console.log("Found config to delete:", { id: config2.id, key: config2.key });
+    const deleted = await store.deleteConfig(tenantId, config2.id);
+    if (!deleted) {
+      return {
+        success: false,
+        message: "Failed to delete database configuration"
+      };
+    }
+    try {
+      if (import_core17.sqlDatabaseManager.hasDatabase(configKey)) {
+        await import_core17.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 = (0, import_core17.getStoreLattice)("default", "database");
+    const store = storeLattice.store;
+    const config2 = await store.getConfigByKey(tenantId, key);
+    if (!config2) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "Database configuration not found"
+      };
+    }
+    const testKey = `__test_${key}_${Date.now()}`;
+    import_core17.sqlDatabaseManager.registerDatabase(testKey, config2.config);
+    const startTime = Date.now();
+    const db = import_core17.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 import_core17.sqlDatabaseManager.removeDatabase(testKey);
+      return {
+        success: true,
+        message: "Connection test successful",
+        data: {
+          connected: true,
+          latency
+        }
+      };
+    } catch (error) {
+      try {
+        await db.disconnect();
+        await import_core17.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
+var import_core18 = require("@axiom-lattice/core");
+var import_crypto4 = require("crypto");
+function getTenantId2(request) {
+  return request.headers["x-tenant-id"] || "default";
+}
+async function getMetricsServerConfigList(request, reply) {
+  const tenantId = getTenantId2(request);
+  try {
+    const storeLattice = (0, import_core18.getStoreLattice)("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 = (0, import_core18.getStoreLattice)("default", "metrics");
+    const store = storeLattice.store;
+    const config2 = await store.getConfigByKey(tenantId, key);
+    if (!config2) {
+      return {
+        success: false,
+        message: "Metrics server configuration not found"
+      };
+    }
+    return {
+      success: true,
+      message: "Metrics server configuration retrieved successfully",
+      data: config2
+    };
+  } 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 = (0, import_core18.getStoreLattice)("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 || (0, import_crypto4.randomUUID)();
+    const configData = {
+      key: body.key,
+      name: body.name,
+      description: body.description,
+      config: body.config.type === "semantic" ? {
+        ...body.config,
+        selectedDataSources: body.selectedDataSources || []
+      } : body.config
+    };
+    const config2 = await store.createConfig(tenantId, id, configData);
+    try {
+      import_core18.metricsServerManager.registerServer(config2.key, config2.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: config2
+    };
+  } 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 = (0, import_core18.getStoreLattice)("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 {
+        import_core18.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 = (0, import_core18.getStoreLattice)("default", "metrics");
+    const store = storeLattice.store;
+    let config2 = await store.getConfigByKey(tenantId, keyOrId);
+    let configKey = keyOrId;
+    if (!config2) {
+      config2 = await store.getConfigById(tenantId, keyOrId);
+      if (config2) {
+        configKey = config2.key;
+      }
+    }
+    if (!config2) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "Metrics server configuration not found"
+      };
+    }
+    const deleted = await store.deleteConfig(tenantId, config2.id);
+    if (!deleted) {
+      return {
+        success: false,
+        message: "Failed to delete metrics server configuration"
+      };
+    }
+    try {
+      if (import_core18.metricsServerManager.hasServer(configKey)) {
+        import_core18.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 = (0, import_core18.getStoreLattice)("default", "metrics");
+    const store = storeLattice.store;
+    const config2 = await store.getConfigByKey(tenantId, key);
+    if (!config2) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "Metrics server configuration not found"
+      };
+    }
+    const testKey = `__test_${key}_${Date.now()}`;
+    import_core18.metricsServerManager.registerServer(testKey, config2.config);
+    try {
+      const client = import_core18.metricsServerManager.getClient(testKey);
+      const result = await client.testConnection();
+      import_core18.metricsServerManager.removeServer(testKey);
+      return {
+        success: true,
+        message: result.connected ? "Connection test successful" : "Connection test failed",
+        data: result
+      };
+    } catch (error) {
+      try {
+        import_core18.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 = (0, import_core18.getStoreLattice)("default", "metrics");
+    const store = storeLattice.store;
+    const config2 = await store.getConfigByKey(tenantId, key);
+    if (!config2) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "Metrics server configuration not found"
+      };
+    }
+    if (!import_core18.metricsServerManager.hasServer(key)) {
+      import_core18.metricsServerManager.registerServer(key, config2.config);
+    }
+    const client = import_core18.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 = (0, import_core18.getStoreLattice)("default", "metrics");
+    const store = storeLattice.store;
+    const config2 = await store.getConfigByKey(tenantId, key);
+    if (!config2) {
+      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 (!import_core18.metricsServerManager.hasServer(key)) {
+      import_core18.metricsServerManager.registerServer(key, config2.config);
+    }
+    const client = import_core18.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 = (0, import_core18.getStoreLattice)("default", "metrics");
+    const store = storeLattice.store;
+    const config2 = await store.getConfigByKey(tenantId, key);
+    if (!config2) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "Metrics server configuration not found"
+      };
+    }
+    if (config2.config.type !== "semantic") {
+      reply.code(400);
+      return {
+        success: false,
+        message: "This endpoint is only available for semantic metrics servers"
+      };
+    }
+    const semanticConfig = config2.config;
+    const client = new import_core18.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 = (0, import_core18.getStoreLattice)("default", "metrics");
+    const store = storeLattice.store;
+    const config2 = await store.getConfigByKey(tenantId, key);
+    if (!config2) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "Metrics server configuration not found"
+      };
+    }
+    if (config2.config.type !== "semantic") {
+      reply.code(400);
+      return {
+        success: false,
+        message: "This endpoint is only available for semantic metrics servers"
+      };
+    }
+    const semanticConfig = config2.config;
+    const client = new import_core18.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 = (0, import_core18.getStoreLattice)("default", "metrics");
+    const store = storeLattice.store;
+    const config2 = await store.getConfigByKey(tenantId, key);
+    if (!config2) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "Metrics server configuration not found"
+      };
+    }
+    if (config2.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 = config2.config;
+    const client = new import_core18.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 import_core18.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 import_core18.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
+var import_core19 = require("@axiom-lattice/core");
+var import_uuid4 = require("uuid");
+var UsersController = class {
+  constructor() {
+    this.userStore = (0, import_core19.getStoreLattice)("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 = (0, import_uuid4.v4)();
+    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
+var import_core20 = require("@axiom-lattice/core");
+var import_uuid5 = require("uuid");
+var TenantsController = class {
+  constructor() {
+    this.tenantStore = (0, import_core20.getStoreLattice)("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 = (0, import_uuid5.v4)();
+    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
+var import_core21 = require("@axiom-lattice/core");
+var import_uuid6 = require("uuid");
+var defaultAuthConfig = {
+  autoApproveUsers: true,
+  allowTenantRegistration: true,
+  tokenExpiration: 86400
+};
+var AuthController = class {
+  constructor(config2 = {}) {
+    this.userStore = (0, import_core21.getStoreLattice)("default", "user").store;
+    this.tenantStore = (0, import_core21.getStoreLattice)("default", "tenant").store;
+    this.userTenantLinkStore = (0, import_core21.getStoreLattice)("default", "userTenantLink").store;
+    this.config = { ...defaultAuthConfig, ...config2 };
+  }
+  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 = (0, import_uuid6.v4)();
+      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, config2) {
+  const controller = new AuthController(config2);
+  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
   );
@@ -2462,6 +4248,15 @@ var registerLatticeRoutes = (app2) => {
     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
@@ -2527,7 +4322,7 @@ var configureSwagger = async (app2, customSwaggerConfig, customSwaggerUiConfig)
 };
 
 // src/services/agent_task_consumer.ts
-var import_core14 = require("@axiom-lattice/core");
+var import_core22 = require("@axiom-lattice/core");
 var handleAgentTask = async (taskRequest, retryCount = 0) => {
   const {
     assistant_id,
@@ -2591,7 +4386,7 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
       }
       if (callback_event) {
         const state = await agent_state({ assistant_id, thread_id });
-        import_core14.eventBus.publish(callback_event, {
+        import_core22.eventBus.publish(callback_event, {
           success: true,
           state,
           config: { assistant_id, thread_id, tenant_id }
@@ -2605,7 +4400,7 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
       await response.text();
       if (callback_event) {
         const state = await agent_state({ assistant_id, thread_id });
-        import_core14.eventBus.publish(callback_event, {
+        import_core22.eventBus.publish(callback_event, {
           success: true,
           state,
           config: { assistant_id, thread_id, tenant_id }
@@ -2632,7 +4427,7 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
       return handleAgentTask(taskRequest, nextRetryCount);
     }
     if (callback_event) {
-      import_core14.eventBus.publish(callback_event, {
+      import_core22.eventBus.publish(callback_event, {
         success: false,
         error: error instanceof Error ? error.message : String(error),
         config: { assistant_id, thread_id, tenant_id }
@@ -2670,7 +4465,7 @@ var _AgentTaskConsumer = class _AgentTaskConsumer {
    * 初始化事件监听和队列轮询
    */
   initialize() {
-    import_core14.eventBus.subscribe(import_core14.AGENT_TASK_EVENT, this.trigger_agent_task.bind(this));
+    import_core22.eventBus.subscribe(import_core22.AGENT_TASK_EVENT, this.trigger_agent_task.bind(this));
     this.startPollingQueue();
     console.log("Agent\u4EFB\u52A1\u6D88\u8D39\u8005\u5DF2\u542F\u52A8\u5E76\u76D1\u542C\u4EFB\u52A1\u4E8B\u4EF6\u548C\u961F\u5217");
   }
@@ -2789,7 +4584,7 @@ var _AgentTaskConsumer = class _AgentTaskConsumer {
     handleAgentTask(taskRequest).catch((error) => {
       console.error("\u5904\u7406Agent\u4EFB\u52A1\u65F6\u53D1\u751F\u672A\u6355\u83B7\u7684\u9519\u8BEF:", error);
       if (taskRequest.callback_event) {
-        import_core14.eventBus.publish(taskRequest.callback_event, {
+        import_core22.eventBus.publish(taskRequest.callback_event, {
           success: false,
           error: error instanceof Error ? error.message : String(error),
           config: {
@@ -2809,7 +4604,7 @@ _AgentTaskConsumer.agent_run_endpoint = "http://localhost:4001/api/runs";
 var AgentTaskConsumer = _AgentTaskConsumer;
 
 // src/index.ts
-var import_core15 = require("@axiom-lattice/core");
+var import_core23 = require("@axiom-lattice/core");
 var import_protocols2 = require("@axiom-lattice/protocols");
 process.on("unhandledRejection", (reason, promise) => {
   console.error("\u672A\u5904\u7406\u7684Promise\u62D2\u7EDD:", reason);
@@ -2823,12 +4618,12 @@ var DEFAULT_LOGGER_CONFIG = {
 };
 var loggerLattice = initializeLogger(DEFAULT_LOGGER_CONFIG);
 var logger = loggerLattice.client;
-function initializeLogger(config) {
-  if (import_core15.loggerLatticeManager.hasLattice("default")) {
-    import_core15.loggerLatticeManager.removeLattice("default");
+function initializeLogger(config2) {
+  if (import_core23.loggerLatticeManager.hasLattice("default")) {
+    import_core23.loggerLatticeManager.removeLattice("default");
   }
-  (0, import_core15.registerLoggerLattice)("default", config);
-  return (0, import_core15.getLoggerLattice)("default");
+  (0, import_core23.registerLoggerLattice)("default", config2);
+  return (0, import_core23.getLoggerLattice)("default");
 }
 var app = (0, import_fastify.default)({
   logger: false,
@@ -2868,16 +4663,8 @@ app.addHook("onResponse", (request, reply, done) => {
 });
 app.register(import_cors.default, {
   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
 });
@@ -2913,23 +4700,23 @@ app.setErrorHandler((error, request, reply) => {
     error: error.message || "\u670D\u52A1\u5668\u5185\u90E8\u9519\u8BEF"
   });
 });
-var start = async (config) => {
+var start = async (config2) => {
   try {
-    if (config?.loggerConfig) {
+    if (config2?.loggerConfig) {
       const loggerConfig = {
         ...DEFAULT_LOGGER_CONFIG,
-        ...config.loggerConfig,
+        ...config2.loggerConfig,
         // Merge file config if provided
-        file: config.loggerConfig.file || DEFAULT_LOGGER_CONFIG.file
+        file: config2.loggerConfig.file || DEFAULT_LOGGER_CONFIG.file
       };
       loggerLattice = initializeLogger(loggerConfig);
       logger = loggerLattice.client;
     }
     app.decorate("loggerLattice", loggerLattice);
-    const target_port = config?.port || Number(process.env.PORT) || 4001;
+    const target_port = config2?.port || Number(process.env.PORT) || 4001;
     await app.listen({ port: target_port, host: "0.0.0.0" });
     logger.info(`Lattice Gateway is running on port: ${target_port}`);
-    const queueServiceConfig = config?.queueServiceConfig;
+    const queueServiceConfig = config2?.queueServiceConfig;
     if (queueServiceConfig) {
       setQueueServiceType(queueServiceConfig.type);
       if (queueServiceConfig.defaultStartPollingQueue) {