@axiom-lattice/gateway 2.1.28 → 2.1.29

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,6 +2433,670 @@ function registerSandboxProxyRoutes(app2) {
   );
 }
 
+// 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/workspaces/:workspaceId",
+    controller.getWorkspace.bind(controller)
+  );
+  app2.patch(
+    "/api/workspaces/:workspaceId",
+    controller.updateWorkspace.bind(controller)
+  );
+  app2.delete(
+    "/api/workspaces/:workspaceId",
+    controller.deleteWorkspace.bind(controller)
+  );
+  app2.get(
+    "/api/workspaces/:workspaceId/projects",
+    controller.listProjects.bind(controller)
+  );
+  app2.post(
+    "/api/workspaces/:workspaceId/projects",
+    controller.createProject.bind(controller)
+  );
+  app2.get(
+    "/api/workspaces/:workspaceId/projects/:projectId",
+    controller.getProject.bind(controller)
+  );
+  app2.patch(
+    "/api/workspaces/:workspaceId/projects/:projectId",
+    controller.updateProject.bind(controller)
+  );
+  app2.delete(
+    "/api/workspaces/:workspaceId/projects/:projectId",
+    controller.deleteProject.bind(controller)
+  );
+  app2.get(
+    "/api/workspaces/:workspaceId/projects/:projectId/listpath",
+    controller.listPath.bind(controller)
+  );
+  app2.get(
+    "/api/workspaces/:workspaceId/projects/:projectId/readfile",
+    controller.readFile.bind(controller)
+  );
+  app2.post(
+    "/api/workspaces/:workspaceId/projects/:projectId/uploadfile",
+    controller.uploadFile.bind(controller)
+  );
+  app2.get(
+    "/api/workspaces/:workspaceId/projects/:projectId/downloadfile",
+    controller.downloadFile.bind(controller)
+  );
+}
+
+// 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/routes/index.ts
 var registerLatticeRoutes = (app2) => {
   app2.post("/api/runs", createRun);
@@ -2462,6 +3216,8 @@ var registerLatticeRoutes = (app2) => {
     filterSkillsByLicense
   );
   registerSandboxProxyRoutes(app2);
+  registerWorkspaceRoutes(app2);
+  registerDatabaseConfigRoutes(app2);
 };
 
 // src/swagger.ts
@@ -2527,7 +3283,7 @@ var configureSwagger = async (app2, customSwaggerConfig, customSwaggerUiConfig)
 };
 
 // src/services/agent_task_consumer.ts
-var import_core14 = require("@axiom-lattice/core");
+var import_core18 = require("@axiom-lattice/core");
 var handleAgentTask = async (taskRequest, retryCount = 0) => {
   const {
     assistant_id,
@@ -2591,7 +3347,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_core18.eventBus.publish(callback_event, {
           success: true,
           state,
           config: { assistant_id, thread_id, tenant_id }
@@ -2605,7 +3361,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_core18.eventBus.publish(callback_event, {
           success: true,
           state,
           config: { assistant_id, thread_id, tenant_id }
@@ -2632,7 +3388,7 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
       return handleAgentTask(taskRequest, nextRetryCount);
     }
     if (callback_event) {
-      import_core14.eventBus.publish(callback_event, {
+      import_core18.eventBus.publish(callback_event, {
         success: false,
         error: error instanceof Error ? error.message : String(error),
         config: { assistant_id, thread_id, tenant_id }
@@ -2670,7 +3426,7 @@ var _AgentTaskConsumer = class _AgentTaskConsumer {
    * 初始化事件监听和队列轮询
    */
   initialize() {
-    import_core14.eventBus.subscribe(import_core14.AGENT_TASK_EVENT, this.trigger_agent_task.bind(this));
+    import_core18.eventBus.subscribe(import_core18.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 +3545,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_core18.eventBus.publish(taskRequest.callback_event, {
           success: false,
           error: error instanceof Error ? error.message : String(error),
           config: {
@@ -2809,7 +3565,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_core19 = 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 +3579,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_core19.loggerLatticeManager.hasLattice("default")) {
+    import_core19.loggerLatticeManager.removeLattice("default");
   }
-  (0, import_core15.registerLoggerLattice)("default", config);
-  return (0, import_core15.getLoggerLattice)("default");
+  (0, import_core19.registerLoggerLattice)("default", config2);
+  return (0, import_core19.getLoggerLattice)("default");
 }
 var app = (0, import_fastify.default)({
   logger: false,
@@ -2868,16 +3624,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 +3661,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) {