@axiom-lattice/gateway 2.1.40 → 2.1.42

package/dist/index.js

@@ -38,6 +38,8 @@ var import_cors = __toESM(require("@fastify/cors"));
 var import_multipart = __toESM(require("@fastify/multipart"));
 var import_sensible = __toESM(require("@fastify/sensible"));
 var import_websocket = __toESM(require("@fastify/websocket"));
+var import_static = __toESM(require("@fastify/static"));
+var import_path = __toESM(require("path"));
 
 // src/services/agent_service.ts
 var import_messages = require("@langchain/core/messages");
@@ -1861,6 +1863,212 @@ async function getToolConfigs(request, reply) {
   }
 }
 
+// src/controllers/data-query.ts
+var import_core12 = require("@axiom-lattice/core");
+function getTenantId5(request) {
+  return request.headers["x-tenant-id"] || "default";
+}
+async function executeDataQuery(request, reply) {
+  const tenantId = getTenantId5(request);
+  const body = request.body;
+  try {
+    if (!body.serverKey && !body.datasourceId) {
+      reply.code(400);
+      return {
+        success: false,
+        message: "Either serverKey or datasourceId must be provided"
+      };
+    }
+    const isSemanticQuery = body.metrics && body.metrics.length > 0;
+    const isSqlQuery = body.customSql && body.customSql.trim().length > 0;
+    if (!isSemanticQuery && !isSqlQuery) {
+      reply.code(400);
+      return {
+        success: false,
+        message: "Either metrics (for semantic query) or customSql (for SQL query) must be provided"
+      };
+    }
+    if (isSemanticQuery && isSqlQuery) {
+      reply.code(400);
+      return {
+        success: false,
+        message: "Cannot provide both metrics and customSql. Use one query type only."
+      };
+    }
+    const storeLattice = (0, import_core12.getStoreLattice)("default", "metrics");
+    const store = storeLattice.store;
+    if (!body.serverKey) {
+      reply.code(400);
+      return {
+        success: false,
+        message: "serverKey is required"
+      };
+    }
+    const config = await store.getConfigByKey(tenantId, body.serverKey);
+    if (!config) {
+      reply.code(404);
+      return {
+        success: false,
+        message: `Metrics server configuration not found: ${body.serverKey}`
+      };
+    }
+    if (config.config.type !== "semantic") {
+      reply.code(400);
+      return {
+        success: false,
+        message: "This endpoint only supports semantic metrics servers"
+      };
+    }
+    if (!body.datasourceId) {
+      reply.code(400);
+      return {
+        success: false,
+        message: "datasourceId is required"
+      };
+    }
+    if (!import_core12.metricsServerManager.hasServer(tenantId, body.serverKey)) {
+      reply.code(400);
+      return {
+        success: false,
+        message: `Metrics server not registered: ${body.serverKey}. Please register the server first.`
+      };
+    }
+    const client = import_core12.metricsServerManager.getClient(tenantId, body.serverKey);
+    if (isSemanticQuery) {
+      return await executeSemanticQuery(client, body, reply);
+    } else {
+      return await executeSqlQuery(client, body, reply);
+    }
+  } catch (error) {
+    console.error("Failed to execute data query:", error);
+    reply.code(500);
+    return {
+      success: false,
+      message: `Failed to execute data query: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function executeSemanticQuery(client, body, reply) {
+  const semanticFilters = (body.filters || []).map((f) => ({
+    dimension: f.dimension,
+    operator: f.operator,
+    values: f.values
+  }));
+  const result = await client.semanticQuery({
+    datasourceId: body.datasourceId,
+    metrics: body.metrics,
+    groupBy: body.groupBy,
+    filters: semanticFilters,
+    limit: body.limit || 1e3
+  });
+  return {
+    success: true,
+    message: "Semantic query executed successfully",
+    data: {
+      semanticModel: result.semanticModel,
+      columns: result.columns,
+      rows: result.rows,
+      rowsObject: result.rowsObject,
+      metadata: {
+        rowCount: result.rowCount,
+        executionTimeMs: result.executionTimeMs
+      }
+    }
+  };
+}
+async function executeSqlQuery(client, body, reply) {
+  const result = await client.executeSqlQuery({
+    datasourceId: body.datasourceId,
+    customSql: body.customSql,
+    params: body.params,
+    limit: body.limit || 100
+  });
+  return {
+    success: true,
+    message: "SQL query executed successfully",
+    data: {
+      tableName: result.tableName,
+      columns: result.columns.map((name) => ({ name, type: "unknown" })),
+      rows: result.rows,
+      rowsObject: result.rowsObject,
+      executedSql: result.executedSql,
+      metadata: {
+        rowCount: result.rowCount,
+        executionTimeMs: result.executionTimeMs
+      }
+    }
+  };
+}
+
+// src/schemas/data-query.ts
+var dataQuerySchema = {
+  description: "Execute data query (semantic or SQL)",
+  tags: ["Data Query"],
+  summary: "Query Data",
+  body: {
+    type: "object",
+    properties: {
+      serverKey: {
+        type: "string",
+        description: "Target semantic metrics server key (optional if configured in runConfig)"
+      },
+      datasourceId: {
+        type: "string",
+        description: "Data source ID (optional if configured in runConfig)"
+      },
+      // Semantic query parameters
+      metrics: {
+        type: "array",
+        items: { type: "string" },
+        description: "Array of metric names for semantic query"
+      },
+      groupBy: {
+        type: "array",
+        items: { type: "string" },
+        description: "Optional array of dimensions to group by"
+      },
+      filters: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            dimension: { type: "string" },
+            operator: { type: "string" },
+            values: {
+              type: "array",
+              items: { type: ["string", "number", "boolean"] }
+            }
+          },
+          required: ["dimension", "operator", "values"]
+        },
+        description: "Optional array of filters"
+      },
+      // SQL query parameters
+      customSql: {
+        type: "string",
+        description: "Custom SQL query string with named parameters"
+      },
+      params: {
+        type: "object",
+        additionalProperties: { type: ["string", "number", "boolean"] },
+        description: "Optional parameters for SQL query"
+      },
+      // Common parameters
+      limit: {
+        type: "number",
+        description: "Maximum number of results (default: 1000)"
+      },
+      format: {
+        type: "string",
+        enum: ["echarts", "raw"],
+        description: "Response format (default: echarts)"
+      }
+    }
+  }
+  // Response schema temporarily removed - format not yet finalized
+  // TODO: Add proper response schema once data format is confirmed
+};
+
 // src/schemas/index.ts
 var getAllMemoryItemsSchema = {
   description: "Get all memory items for an assistant thread",
@@ -2136,7 +2344,7 @@ var getHealthSchema = {
 var import_stream = require("stream");
 
 // src/services/sandbox_service.ts
-var import_core12 = require("@axiom-lattice/core");
+var import_core13 = require("@axiom-lattice/core");
 var ERROR_HTML = `<!DOCTYPE html>
 <html lang="zh-CN">
 <head>
@@ -2248,7 +2456,7 @@ var ERROR_HTML = `<!DOCTYPE html>
 </html>`;
 var SandboxService = class {
   getFilesystemIsolatedLevel(tenantId, assistantId) {
-    const agentLattice = import_core12.agentLatticeManager.getAgentLatticeWithTenant(tenantId, assistantId);
+    const agentLattice = import_core13.agentLatticeManager.getAgentLatticeWithTenant(tenantId, assistantId);
     if (!agentLattice) {
       return null;
     }
@@ -2273,10 +2481,10 @@ var SandboxService = class {
         sandboxName = "global";
         break;
     }
-    return (0, import_core12.normalizeSandboxName)(sandboxName);
+    return (0, import_core13.normalizeSandboxName)(sandboxName);
   }
   getTargetUrl(sandboxName) {
-    const sandboxManager = (0, import_core12.getSandBoxManager)();
+    const sandboxManager = (0, import_core13.getSandBoxManager)();
     return `${sandboxManager.getBaseURL()}/sandbox/${sandboxName}`;
   }
   async getVncHtml(sandboxName) {
@@ -2321,9 +2529,9 @@ var SandboxService = class {
 var sandboxService = new SandboxService();
 
 // src/controllers/sandbox.ts
-var import_core13 = require("@axiom-lattice/core");
-function getFilenameFromPath(path2) {
-  const segments = path2.replace(/\/+$/, "").split("/");
+var import_core14 = require("@axiom-lattice/core");
+function getFilenameFromPath(path3) {
+  const segments = path3.replace(/\/+$/, "").split("/");
   return segments[segments.length - 1] || "download";
 }
 var EXT_TO_MIME = {
@@ -2363,7 +2571,7 @@ function registerSandboxProxyRoutes(app2) {
         threadId,
         isolatedLevel
       );
-      const sandboxManager = (0, import_core13.getSandBoxManager)();
+      const sandboxManager = (0, import_core14.getSandBoxManager)();
       const sandbox = await sandboxManager.createSandbox(sandboxName);
       try {
         const data = await request.file();
@@ -2375,10 +2583,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 path2 = `/home/gem/uploads/${pathValue ? pathValue : ""}${data.filename}`;
+        const path3 = `/home/gem/uploads/${pathValue ? pathValue : ""}${data.filename}`;
         const uploadResult = await sandbox.file.uploadFile({
           file: buffer,
-          path: path2
+          path: path3
         });
         if (!uploadResult.ok) {
           return reply.status(502).send({ error: `Upload error: ${uploadResult.error}` });
@@ -2410,7 +2618,7 @@ function registerSandboxProxyRoutes(app2) {
         threadId,
         isolatedLevel
       );
-      const sandboxManager = (0, import_core13.getSandBoxManager)();
+      const sandboxManager = (0, import_core14.getSandBoxManager)();
       const sandbox = await sandboxManager.createSandbox(sandboxName);
       try {
         const resolvedPath = filePath.startsWith("/home/gem") ? filePath : `/home/gem/${filePath.replace(/^\//, "")}`;
@@ -2466,14 +2674,14 @@ function registerSandboxProxyRoutes(app2) {
 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_core17 = 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;
+    this.workspaceStore = (0, import_core15.getStoreLattice)("default", "workspace").store;
+    this.projectStore = (0, import_core15.getStoreLattice)("default", "project").store;
   }
   getTenantId(request) {
     const userTenantId = request.user?.tenantId;
@@ -2606,11 +2814,11 @@ var WorkspaceController = class {
       throw new Error("Workspace not found");
     }
     if (workspace.storageType === "sandbox") {
-      const sandboxManager = (0, import_core16.getSandBoxManager)();
+      const sandboxManager = (0, import_core17.getSandBoxManager)();
       const sandboxName = "global";
       const sandbox = await sandboxManager.createSandbox(sandboxName);
       return {
-        backend: new import_core15.SandboxFilesystem({
+        backend: new import_core16.SandboxFilesystem({
           sandboxInstance: sandbox,
           workingDirectory: `/tenants/${tenantId}/workspaces/${workspaceId}/${projectId}`
         }),
@@ -2618,7 +2826,7 @@ var WorkspaceController = class {
       };
     } else {
       return {
-        backend: new import_core15.FilesystemBackend({
+        backend: new import_core16.FilesystemBackend({
           rootDir: `/lattice_store/tenants/${tenantId}/workspaces/${workspaceId}/${projectId}`,
           virtualMode: true
         }),
@@ -2663,7 +2871,7 @@ var WorkspaceController = class {
       const { workspace } = await this.getBackend(tenantId, workspaceId, projectId);
       const resolvedPath = filePath.startsWith("/") ? filePath : `/${filePath}`;
       if (workspace.storageType === "sandbox") {
-        const sandboxManager = (0, import_core16.getSandBoxManager)();
+        const sandboxManager = (0, import_core17.getSandBoxManager)();
         const sandbox = await sandboxManager.createSandbox("global");
         const realPath = path.join("/home/gem/tenants", tenantId, "workspaces", workspaceId, projectId, resolvedPath);
         const filename2 = this.getFilenameFromPath(resolvedPath);
@@ -2732,7 +2940,7 @@ var WorkspaceController = class {
       const { workspace } = await this.getBackend(tenantId, workspaceId, projectId);
       const resolvedPath = filePath.startsWith("/") ? filePath : `/${filePath}`;
       if (workspace.storageType === "sandbox") {
-        const sandboxManager = (0, import_core16.getSandBoxManager)();
+        const sandboxManager = (0, import_core17.getSandBoxManager)();
         const sandbox = await sandboxManager.createSandbox("global");
         const realPath = path.join("/home/gem/tenants", tenantId, "workspaces", workspaceId, projectId, resolvedPath);
         const filename2 = this.getFilenameFromPath(resolvedPath);
@@ -2751,6 +2959,33 @@ var WorkspaceController = class {
           const webStream = body.stream();
           const nodeStream = import_stream2.Readable.fromWeb(webStream);
           const contentType2 = body.contentType ?? inferredContentType;
+          console.log(`[viewFile] Sandbox returned stream, contentType: ${contentType2}, filename: ${filename2}`);
+          const isHtml2 = contentType2?.toLowerCase().includes("text/html") || filename2.toLowerCase().endsWith(".html") || filename2.toLowerCase().endsWith(".htm");
+          if (isHtml2) {
+            console.log(`[viewFile] HTML stream detected, collecting for context injection`);
+            const chunks = [];
+            for await (const chunk of nodeStream) {
+              chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            }
+            let content2 = Buffer.concat(chunks).toString("utf-8");
+            const contextScript = `<script>window.__AI2APP_CONTEXT__=${JSON.stringify({
+              tenantId,
+              workspaceId,
+              projectId,
+              timestamp: Date.now()
+            })};</script>`;
+            if (content2.toLowerCase().includes("</head>")) {
+              content2 = content2.replace(/<\/head>/i, `${contextScript}</head>`);
+              console.log(`[viewFile] Context script injected before </head> (stream)`);
+            } else if (content2.toLowerCase().includes("<html>")) {
+              content2 = content2.replace(/<html>/i, `<html>${contextScript}`);
+              console.log(`[viewFile] Context script injected after <html> (stream)`);
+            } else {
+              content2 = contextScript + content2;
+              console.log(`[viewFile] Context script prepended to content (stream)`);
+            }
+            return reply.status(200).type(contentType2).header("Content-Disposition", "inline").send(Buffer.from(content2, "utf-8"));
+          }
           return reply.status(200).type(contentType2).header("Content-Disposition", "inline").send(nodeStream);
         }
         const bodyUnknown = downloadResult.body;
@@ -2770,13 +3005,56 @@ var WorkspaceController = class {
         } else {
           return reply.status(502).send({ success: false, error: "Unexpected view response format" });
         }
+        const isHtml = contentType?.toLowerCase().includes("text/html") || filename2.toLowerCase().endsWith(".html") || filename2.toLowerCase().endsWith(".htm");
+        if (isHtml) {
+          console.log(`[viewFile] Injecting AI2APP context for sandbox HTML file: ${filename2}, tenantId: ${tenantId}, contentType: ${contentType}`);
+          let content2 = buf.toString("utf-8");
+          const contextScript = `<script>window.__AI2APP_CONTEXT__=${JSON.stringify({
+            tenantId,
+            workspaceId,
+            projectId,
+            timestamp: Date.now()
+          })};</script>`;
+          if (content2.toLowerCase().includes("</head>")) {
+            content2 = content2.replace(/<\/head>/i, `${contextScript}</head>`);
+            console.log(`[viewFile] Context script injected before </head>`);
+          } else if (content2.toLowerCase().includes("<html>")) {
+            content2 = content2.replace(/<html>/i, `<html>${contextScript}`);
+            console.log(`[viewFile] Context script injected after <html>`);
+          } else {
+            content2 = contextScript + content2;
+            console.log(`[viewFile] Context script prepended to content`);
+          }
+          buf = Buffer.from(content2, "utf-8");
+        }
         return reply.status(200).type(contentType).header("Content-Disposition", "inline").send(buf);
       }
       const { backend } = await this.getBackend(tenantId, workspaceId, projectId);
       const content = await backend.read(resolvedPath, 0, Infinity);
       const filename = this.getFilenameFromPath(resolvedPath);
       const mimeType = this.getMimeType(filename);
-      const buffer = Buffer.from(content, "utf-8");
+      let finalContent = content;
+      const isHtmlFs = mimeType?.toLowerCase().includes("text/html") || filename.toLowerCase().endsWith(".html") || filename.toLowerCase().endsWith(".htm");
+      if (isHtmlFs) {
+        console.log(`[viewFile] Injecting AI2APP context for filesystem HTML file: ${filename}, tenantId: ${tenantId}, mimeType: ${mimeType}`);
+        const contextScript = `<script>window.__AI2APP_CONTEXT__=${JSON.stringify({
+          tenantId,
+          workspaceId,
+          projectId,
+          timestamp: Date.now()
+        })};</script>`;
+        if (content.toLowerCase().includes("</head>")) {
+          finalContent = content.replace(/<\/head>/i, `${contextScript}</head>`);
+          console.log(`[viewFile] Context script injected before </head>`);
+        } else if (content.toLowerCase().includes("</html>")) {
+          finalContent = content.replace(/<\/html>/i, `${contextScript}</html>`);
+          console.log(`[viewFile] Context script injected before </html>`);
+        } else {
+          finalContent = content + contextScript;
+          console.log(`[viewFile] Context script appended to content`);
+        }
+      }
+      const buffer = Buffer.from(finalContent, "utf-8");
       return reply.status(200).type(mimeType).header("Content-Disposition", "inline").send(buffer);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
@@ -2786,17 +3064,17 @@ var WorkspaceController = class {
   async listPath(request) {
     const tenantId = this.getTenantId(request);
     const { workspaceId, projectId } = request.params;
-    const path2 = request.query.path || "/";
+    const path3 = request.query.path || "/";
     const { backend } = await this.getBackend(tenantId, workspaceId, projectId);
-    const files = await backend.lsInfo(path2);
+    const files = await backend.lsInfo(path3);
     return { success: true, data: files };
   }
   async readFile(request) {
     const tenantId = this.getTenantId(request);
     const { workspaceId, projectId } = request.params;
-    const { path: path2, offset = 0, limit = 1e3 } = request.query;
+    const { path: path3, offset = 0, limit = 1e3 } = request.query;
     const { backend } = await this.getBackend(tenantId, workspaceId, projectId);
-    const content = await backend.read(path2, Number(offset), Number(limit));
+    const content = await backend.read(path3, Number(offset), Number(limit));
     return { success: true, data: { content, offset, limit } };
   }
   /**
@@ -2832,7 +3110,7 @@ var WorkspaceController = class {
         return reply.status(400).send({ success: false, error: "Invalid path parameter" });
       }
       if (workspace.storageType === "sandbox") {
-        const sandboxManager = (0, import_core16.getSandBoxManager)();
+        const sandboxManager = (0, import_core17.getSandBoxManager)();
         const sandboxName = "global";
         const sandbox = await sandboxManager.createSandbox(sandboxName);
         const baseDir = path.join("/home/gem/tenants", tenantId, "workspaces", workspaceId, projectId);
@@ -2938,9 +3216,9 @@ function registerWorkspaceRoutes(app2) {
 }
 
 // src/controllers/database-configs.ts
-var import_core17 = require("@axiom-lattice/core");
+var import_core18 = require("@axiom-lattice/core");
 var import_crypto3 = require("crypto");
-function getTenantId5(request) {
+function getTenantId6(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
     return userTenantId;
@@ -2948,9 +3226,9 @@ function getTenantId5(request) {
   return request.headers["x-tenant-id"] || "default";
 }
 async function getDatabaseConfigList(request, reply) {
-  const tenantId = getTenantId5(request);
+  const tenantId = getTenantId6(request);
   try {
-    const storeLattice = (0, import_core17.getStoreLattice)("default", "database");
+    const storeLattice = (0, import_core18.getStoreLattice)("default", "database");
     const store = storeLattice.store;
     const configs = await store.getAllConfigs(tenantId);
     console.log("Backend: getAllConfigs returned:", configs);
@@ -2978,10 +3256,10 @@ async function getDatabaseConfigList(request, reply) {
   }
 }
 async function getDatabaseConfig(request, reply) {
-  const tenantId = getTenantId5(request);
+  const tenantId = getTenantId6(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core17.getStoreLattice)("default", "database");
+    const storeLattice = (0, import_core18.getStoreLattice)("default", "database");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -3004,10 +3282,10 @@ async function getDatabaseConfig(request, reply) {
   }
 }
 async function createDatabaseConfig(request, reply) {
-  const tenantId = getTenantId5(request);
+  const tenantId = getTenantId6(request);
   const body = request.body;
   try {
-    const storeLattice = (0, import_core17.getStoreLattice)("default", "database");
+    const storeLattice = (0, import_core18.getStoreLattice)("default", "database");
     const store = storeLattice.store;
     const existing = await store.getConfigByKey(tenantId, body.key);
     if (existing) {
@@ -3020,7 +3298,7 @@ async function createDatabaseConfig(request, reply) {
     const id = body.id || (0, import_crypto3.randomUUID)();
     const config = await store.createConfig(tenantId, id, body);
     try {
-      import_core17.sqlDatabaseManager.registerDatabase(tenantId, config.key, config.config);
+      import_core18.sqlDatabaseManager.registerDatabase(tenantId, config.key, config.config);
     } catch (error) {
       console.warn("Failed to auto-register database:", error);
     }
@@ -3039,11 +3317,11 @@ async function createDatabaseConfig(request, reply) {
   }
 }
 async function updateDatabaseConfig(request, reply) {
-  const tenantId = getTenantId5(request);
+  const tenantId = getTenantId6(request);
   const { key } = request.params;
   const updates = request.body;
   try {
-    const storeLattice = (0, import_core17.getStoreLattice)("default", "database");
+    const storeLattice = (0, import_core18.getStoreLattice)("default", "database");
     const store = storeLattice.store;
     const existing = await store.getConfigByKey(tenantId, key);
     if (!existing) {
@@ -3062,7 +3340,7 @@ async function updateDatabaseConfig(request, reply) {
     }
     if (updates.config) {
       try {
-        import_core17.sqlDatabaseManager.registerDatabase(tenantId, updated.key, updated.config);
+        import_core18.sqlDatabaseManager.registerDatabase(tenantId, updated.key, updated.config);
       } catch (error) {
         console.warn("Failed to re-register database:", error);
       }
@@ -3081,10 +3359,10 @@ async function updateDatabaseConfig(request, reply) {
   }
 }
 async function deleteDatabaseConfig(request, reply) {
-  const tenantId = getTenantId5(request);
+  const tenantId = getTenantId6(request);
   const { keyOrId } = request.params;
   try {
-    const storeLattice = (0, import_core17.getStoreLattice)("default", "database");
+    const storeLattice = (0, import_core18.getStoreLattice)("default", "database");
     const store = storeLattice.store;
     console.log("Delete request - keyOrId:", keyOrId);
     let config = await store.getConfigByKey(tenantId, keyOrId);
@@ -3111,8 +3389,8 @@ async function deleteDatabaseConfig(request, reply) {
       };
     }
     try {
-      if (import_core17.sqlDatabaseManager.hasDatabase(tenantId, configKey)) {
-        await import_core17.sqlDatabaseManager.removeDatabase(tenantId, configKey);
+      if (import_core18.sqlDatabaseManager.hasDatabase(tenantId, configKey)) {
+        await import_core18.sqlDatabaseManager.removeDatabase(tenantId, configKey);
       }
     } catch (error) {
       console.warn("Failed to remove from SqlDatabaseManager:", error);
@@ -3130,10 +3408,10 @@ async function deleteDatabaseConfig(request, reply) {
   }
 }
 async function testDatabaseConnection(request, reply) {
-  const tenantId = getTenantId5(request);
+  const tenantId = getTenantId6(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core17.getStoreLattice)("default", "database");
+    const storeLattice = (0, import_core18.getStoreLattice)("default", "database");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -3144,16 +3422,16 @@ async function testDatabaseConnection(request, reply) {
       };
     }
     const testKey = `__test_${key}_${Date.now()}`;
-    import_core17.sqlDatabaseManager.registerDatabase(tenantId, testKey, config.config);
+    import_core18.sqlDatabaseManager.registerDatabase(tenantId, testKey, config.config);
     const startTime = Date.now();
-    const db = import_core17.sqlDatabaseManager.getDatabase(tenantId, testKey);
+    const db = import_core18.sqlDatabaseManager.getDatabase(tenantId, 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(tenantId, testKey);
+      await import_core18.sqlDatabaseManager.removeDatabase(tenantId, testKey);
       return {
         success: true,
         message: "Connection test successful",
@@ -3165,7 +3443,7 @@ async function testDatabaseConnection(request, reply) {
     } catch (error) {
       try {
         await db.disconnect();
-        await import_core17.sqlDatabaseManager.removeDatabase(tenantId, testKey);
+        await import_core18.sqlDatabaseManager.removeDatabase(tenantId, testKey);
       } catch {
       }
       return {
@@ -3217,9 +3495,9 @@ function registerDatabaseConfigRoutes(app2) {
 }
 
 // src/controllers/metrics-configs.ts
-var import_core18 = require("@axiom-lattice/core");
+var import_core19 = require("@axiom-lattice/core");
 var import_crypto4 = require("crypto");
-function getTenantId6(request) {
+function getTenantId7(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
     return userTenantId;
@@ -3227,9 +3505,9 @@ function getTenantId6(request) {
   return request.headers["x-tenant-id"] || "default";
 }
 async function getMetricsServerConfigList(request, reply) {
-  const tenantId = getTenantId6(request);
+  const tenantId = getTenantId7(request);
   try {
-    const storeLattice = (0, import_core18.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core19.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
     const configs = await store.getAllConfigs(tenantId);
     return {
@@ -3253,10 +3531,10 @@ async function getMetricsServerConfigList(request, reply) {
   }
 }
 async function getMetricsServerConfig(request, reply) {
-  const tenantId = getTenantId6(request);
+  const tenantId = getTenantId7(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core18.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core19.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -3279,10 +3557,10 @@ async function getMetricsServerConfig(request, reply) {
   }
 }
 async function createMetricsServerConfig(request, reply) {
-  const tenantId = getTenantId6(request);
+  const tenantId = getTenantId7(request);
   const body = request.body;
   try {
-    const storeLattice = (0, import_core18.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core19.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
     const existing = await store.getConfigByKey(tenantId, body.key);
     if (existing) {
@@ -3311,7 +3589,7 @@ async function createMetricsServerConfig(request, reply) {
     };
     const config = await store.createConfig(tenantId, id, configData);
     try {
-      import_core18.metricsServerManager.registerServer(tenantId, config.key, config.config);
+      import_core19.metricsServerManager.registerServer(tenantId, config.key, config.config);
     } catch (error) {
       console.warn("Failed to auto-register metrics server:", error);
     }
@@ -3330,11 +3608,11 @@ async function createMetricsServerConfig(request, reply) {
   }
 }
 async function updateMetricsServerConfig(request, reply) {
-  const tenantId = getTenantId6(request);
+  const tenantId = getTenantId7(request);
   const { key } = request.params;
   const updates = request.body;
   try {
-    const storeLattice = (0, import_core18.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core19.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
     const existing = await store.getConfigByKey(tenantId, key);
     if (!existing) {
@@ -3362,7 +3640,7 @@ async function updateMetricsServerConfig(request, reply) {
     }
     if (updates.config) {
       try {
-        import_core18.metricsServerManager.registerServer(tenantId, updated.key, updated.config);
+        import_core19.metricsServerManager.registerServer(tenantId, updated.key, updated.config);
       } catch (error) {
         console.warn("Failed to re-register metrics server:", error);
       }
@@ -3381,10 +3659,10 @@ async function updateMetricsServerConfig(request, reply) {
   }
 }
 async function deleteMetricsServerConfig(request, reply) {
-  const tenantId = getTenantId6(request);
+  const tenantId = getTenantId7(request);
   const { keyOrId } = request.params;
   try {
-    const storeLattice = (0, import_core18.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core19.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
     let config = await store.getConfigByKey(tenantId, keyOrId);
     let configKey = keyOrId;
@@ -3409,8 +3687,8 @@ async function deleteMetricsServerConfig(request, reply) {
       };
     }
     try {
-      if (import_core18.metricsServerManager.hasServer(tenantId, configKey)) {
-        import_core18.metricsServerManager.removeServer(tenantId, configKey);
+      if (import_core19.metricsServerManager.hasServer(tenantId, configKey)) {
+        import_core19.metricsServerManager.removeServer(tenantId, configKey);
       }
     } catch (error) {
       console.warn("Failed to remove from MetricsServerManager:", error);
@@ -3428,10 +3706,10 @@ async function deleteMetricsServerConfig(request, reply) {
   }
 }
 async function testMetricsServerConnection(request, reply) {
-  const tenantId = getTenantId6(request);
+  const tenantId = getTenantId7(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core18.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core19.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -3442,11 +3720,11 @@ async function testMetricsServerConnection(request, reply) {
       };
     }
     const testKey = `__test_${key}_${Date.now()}`;
-    import_core18.metricsServerManager.registerServer(tenantId, testKey, config.config);
+    import_core19.metricsServerManager.registerServer(tenantId, testKey, config.config);
     try {
-      const client = import_core18.metricsServerManager.getClient(tenantId, testKey);
+      const client = import_core19.metricsServerManager.getClient(tenantId, testKey);
       const result = await client.testConnection();
-      import_core18.metricsServerManager.removeServer(tenantId, testKey);
+      import_core19.metricsServerManager.removeServer(tenantId, testKey);
       return {
         success: true,
         message: result.connected ? "Connection test successful" : "Connection test failed",
@@ -3454,7 +3732,7 @@ async function testMetricsServerConnection(request, reply) {
       };
     } catch (error) {
       try {
-        import_core18.metricsServerManager.removeServer(tenantId, testKey);
+        import_core19.metricsServerManager.removeServer(tenantId, testKey);
       } catch {
       }
       return {
@@ -3479,10 +3757,10 @@ async function testMetricsServerConnection(request, reply) {
   }
 }
 async function listAvailableMetrics(request, reply) {
-  const tenantId = getTenantId6(request);
+  const tenantId = getTenantId7(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core18.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core19.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -3492,10 +3770,10 @@ async function listAvailableMetrics(request, reply) {
         message: "Metrics server configuration not found"
       };
     }
-    if (!import_core18.metricsServerManager.hasServer(tenantId, key)) {
-      import_core18.metricsServerManager.registerServer(tenantId, key, config.config);
+    if (!import_core19.metricsServerManager.hasServer(tenantId, key)) {
+      import_core19.metricsServerManager.registerServer(tenantId, key, config.config);
     }
-    const client = import_core18.metricsServerManager.getClient(tenantId, key);
+    const client = import_core19.metricsServerManager.getClient(tenantId, key);
     const metrics = await client.listMetrics();
     return {
       success: true,
@@ -3517,11 +3795,11 @@ async function listAvailableMetrics(request, reply) {
   }
 }
 async function queryMetricsData(request, reply) {
-  const tenantId = getTenantId6(request);
+  const tenantId = getTenantId7(request);
   const { key } = request.params;
   const { metricName, startTime, endTime, step, labels } = request.body;
   try {
-    const storeLattice = (0, import_core18.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core19.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -3538,10 +3816,10 @@ async function queryMetricsData(request, reply) {
         message: "metricName is required"
       };
     }
-    if (!import_core18.metricsServerManager.hasServer(tenantId, key)) {
-      import_core18.metricsServerManager.registerServer(tenantId, key, config.config);
+    if (!import_core19.metricsServerManager.hasServer(tenantId, key)) {
+      import_core19.metricsServerManager.registerServer(tenantId, key, config.config);
     }
-    const client = import_core18.metricsServerManager.getClient(tenantId, key);
+    const client = import_core19.metricsServerManager.getClient(tenantId, key);
     const result = await client.queryMetricData(metricName, {
       startTime,
       endTime,
@@ -3565,10 +3843,10 @@ async function queryMetricsData(request, reply) {
   }
 }
 async function getDataSources(request, reply) {
-  const tenantId = getTenantId6(request);
+  const tenantId = getTenantId7(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core18.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core19.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -3586,7 +3864,7 @@ async function getDataSources(request, reply) {
       };
     }
     const semanticConfig = config.config;
-    const client = new import_core18.SemanticMetricsClient(semanticConfig);
+    const client = new import_core19.SemanticMetricsClient(semanticConfig);
     const allDatasources = await client.getDataSources();
     const selectedIds = semanticConfig.selectedDataSources || [];
     const filteredDatasources = selectedIds.length > 0 ? allDatasources.filter((ds) => selectedIds.includes(String(ds.id))) : allDatasources;
@@ -3606,10 +3884,10 @@ async function getDataSources(request, reply) {
   }
 }
 async function getDatasourceMetrics(request, reply) {
-  const tenantId = getTenantId6(request);
+  const tenantId = getTenantId7(request);
   const { key, datasourceId } = request.params;
   try {
-    const storeLattice = (0, import_core18.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core19.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -3627,7 +3905,7 @@ async function getDatasourceMetrics(request, reply) {
       };
     }
     const semanticConfig = config.config;
-    const client = new import_core18.SemanticMetricsClient(semanticConfig);
+    const client = new import_core19.SemanticMetricsClient(semanticConfig);
     const metrics = await client.getDatasourceMetrics(datasourceId);
     return {
       success: true,
@@ -3643,11 +3921,11 @@ async function getDatasourceMetrics(request, reply) {
   }
 }
 async function querySemanticMetrics(request, reply) {
-  const tenantId = getTenantId6(request);
+  const tenantId = getTenantId7(request);
   const { key } = request.params;
   const body = request.body;
   try {
-    const storeLattice = (0, import_core18.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core19.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -3672,33 +3950,37 @@ async function querySemanticMetrics(request, reply) {
       };
     }
     const semanticConfig = config.config;
-    const client = new import_core18.SemanticMetricsClient(semanticConfig);
+    const client = new import_core19.SemanticMetricsClient(semanticConfig);
     const result = await client.semanticQuery(body);
+    const columnNames = result.columns.map((col) => col.name);
     const allDataPoints = [];
-    const metricNames = [];
-    for (const metricResult of result.results) {
-      metricNames.push(metricResult.metricName);
-      for (const row of metricResult.rows) {
-        allDataPoints.push({
-          timestamp: row.timestamp ? new Date(row.timestamp).getTime() : void 0,
-          value: typeof row.value === "number" ? row.value : 0,
-          metricName: metricResult.metricName,
-          labels: Object.fromEntries(
-            Object.entries(row).filter(([k]) => k !== "value" && k !== "timestamp").map(([k, v]) => [k, String(v)])
-          )
-        });
-      }
+    const timestampColIdx = columnNames.findIndex(
+      (col) => col.toLowerCase().includes("date") || col.toLowerCase().includes("time")
+    );
+    const valueColIdx = columnNames.findIndex(
+      (col) => col.toLowerCase().includes("value") || col.toLowerCase().includes("rate") || col.toLowerCase().includes("amt")
+    );
+    for (const row of result.rows) {
+      const timestamp = timestampColIdx >= 0 ? row[timestampColIdx] : void 0;
+      const value = valueColIdx >= 0 ? row[valueColIdx] : row[row.length - 1];
+      allDataPoints.push({
+        timestamp: timestamp ? new Date(String(timestamp)).getTime() : void 0,
+        value: typeof value === "number" ? value : Number(value) || 0,
+        labels: Object.fromEntries(
+          columnNames.map((col, idx) => [col, String(row[idx] ?? "")])
+        )
+      });
     }
     return {
       success: true,
       message: "Semantic query executed successfully",
       data: {
-        datasourceId: result.datasourceId,
-        metrics: metricNames,
+        semanticModel: result.semanticModel,
+        columns: columnNames,
         dataPoints: allDataPoints,
         metadata: {
-          rowCount: allDataPoints.length,
-          queryTimeMs: result.totalExecutionTimeMs
+          rowCount: result.rows.length,
+          columnCount: result.columns.length
         }
       }
     };
@@ -3728,7 +4010,7 @@ async function testSemanticDataSources(request, reply) {
       password: body.password,
       headers: body.headers
     };
-    const client = new import_core18.SemanticMetricsClient(testConfig);
+    const client = new import_core19.SemanticMetricsClient(testConfig);
     const datasources = await client.getDataSources();
     return {
       success: true,
@@ -3764,7 +4046,7 @@ async function testDatasourceMetrics(request, reply) {
       password: body.password,
       headers: body.headers
     };
-    const client = new import_core18.SemanticMetricsClient(testConfig);
+    const client = new import_core19.SemanticMetricsClient(testConfig);
     const metrics = await client.getDatasourceMetrics(datasourceId);
     return {
       success: true,
@@ -3796,9 +4078,9 @@ function registerMetricsServerConfigRoutes(app2) {
 }
 
 // src/controllers/mcp-configs.ts
-var import_core19 = require("@axiom-lattice/core");
+var import_core20 = require("@axiom-lattice/core");
 var import_crypto5 = require("crypto");
-function getTenantId7(request) {
+function getTenantId8(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
     return userTenantId;
@@ -3806,9 +4088,9 @@ function getTenantId7(request) {
   return request.headers["x-tenant-id"] || "default";
 }
 async function getMcpServerConfigList(request, reply) {
-  const tenantId = getTenantId7(request);
+  const tenantId = getTenantId8(request);
   try {
-    const storeLattice = (0, import_core19.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core20.getStoreLattice)("default", "mcp");
     const store = storeLattice.store;
     const configs = await store.getAllConfigs(tenantId);
     return {
@@ -3832,10 +4114,10 @@ async function getMcpServerConfigList(request, reply) {
   }
 }
 async function getMcpServerConfig(request, reply) {
-  const tenantId = getTenantId7(request);
+  const tenantId = getTenantId8(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core19.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core20.getStoreLattice)("default", "mcp");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -3858,10 +4140,10 @@ async function getMcpServerConfig(request, reply) {
   }
 }
 async function createMcpServerConfig(request, reply) {
-  const tenantId = getTenantId7(request);
+  const tenantId = getTenantId8(request);
   const body = request.body;
   try {
-    const storeLattice = (0, import_core19.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core20.getStoreLattice)("default", "mcp");
     const store = storeLattice.store;
     const existing = await store.getConfigByKey(tenantId, body.key);
     if (existing) {
@@ -3897,11 +4179,11 @@ async function createMcpServerConfig(request, reply) {
   }
 }
 async function updateMcpServerConfig(request, reply) {
-  const tenantId = getTenantId7(request);
+  const tenantId = getTenantId8(request);
   const { key } = request.params;
   const updates = request.body;
   try {
-    const storeLattice = (0, import_core19.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core20.getStoreLattice)("default", "mcp");
     const store = storeLattice.store;
     const existing = await store.getConfigByKey(tenantId, key);
     if (!existing) {
@@ -3921,8 +4203,8 @@ async function updateMcpServerConfig(request, reply) {
     }
     if (shouldReconnect) {
       try {
-        if (import_core19.mcpManager.hasServer(key)) {
-          await import_core19.mcpManager.removeServer(key);
+        if (import_core20.mcpManager.hasServer(key)) {
+          await import_core20.mcpManager.removeServer(key);
         }
         await connectAndRegisterTools(updated);
         await store.updateConfig(tenantId, existing.id, { status: "connected" });
@@ -3947,10 +4229,10 @@ async function updateMcpServerConfig(request, reply) {
   }
 }
 async function deleteMcpServerConfig(request, reply) {
-  const tenantId = getTenantId7(request);
+  const tenantId = getTenantId8(request);
   const { keyOrId } = request.params;
   try {
-    const storeLattice = (0, import_core19.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core20.getStoreLattice)("default", "mcp");
     const store = storeLattice.store;
     let config = await store.getConfigByKey(tenantId, keyOrId);
     let configKey = keyOrId;
@@ -3968,8 +4250,8 @@ async function deleteMcpServerConfig(request, reply) {
       };
     }
     try {
-      if (import_core19.mcpManager.hasServer(configKey)) {
-        await import_core19.mcpManager.removeServer(configKey);
+      if (import_core20.mcpManager.hasServer(configKey)) {
+        await import_core20.mcpManager.removeServer(configKey);
       }
     } catch (error) {
       console.warn("Failed to remove from MCP manager:", error);
@@ -3994,10 +4276,10 @@ async function deleteMcpServerConfig(request, reply) {
   }
 }
 async function testMcpServerConnection(request, reply) {
-  const tenantId = getTenantId7(request);
+  const tenantId = getTenantId8(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core19.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core20.getStoreLattice)("default", "mcp");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -4011,11 +4293,11 @@ async function testMcpServerConnection(request, reply) {
     try {
       const testKey = `__test_${key}_${Date.now()}`;
       const connection = convertToConnection(config.config);
-      import_core19.mcpManager.addServer(testKey, connection);
-      await import_core19.mcpManager.connect();
-      const tools = await import_core19.mcpManager.getAllTools();
+      import_core20.mcpManager.addServer(testKey, connection);
+      await import_core20.mcpManager.connect();
+      const tools = await import_core20.mcpManager.getAllTools();
       const latency = Date.now() - startTime;
-      await import_core19.mcpManager.removeServer(testKey);
+      await import_core20.mcpManager.removeServer(testKey);
       return {
         success: true,
         message: "Connection test successful",
@@ -4047,10 +4329,10 @@ async function testMcpServerConnection(request, reply) {
   }
 }
 async function listMcpServerTools(request, reply) {
-  const tenantId = getTenantId7(request);
+  const tenantId = getTenantId8(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core19.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core20.getStoreLattice)("default", "mcp");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -4060,10 +4342,10 @@ async function listMcpServerTools(request, reply) {
         message: "MCP server configuration not found"
       };
     }
-    if (!import_core19.mcpManager.hasServer(key)) {
+    if (!import_core20.mcpManager.hasServer(key)) {
       await connectAndRegisterTools(config);
     }
-    const tools = await import_core19.mcpManager.getAllTools();
+    const tools = await import_core20.mcpManager.getAllTools();
     return {
       success: true,
       message: "Tools retrieved successfully",
@@ -4080,10 +4362,10 @@ async function listMcpServerTools(request, reply) {
   }
 }
 async function connectMcpServer(request, reply) {
-  const tenantId = getTenantId7(request);
+  const tenantId = getTenantId8(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core19.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core20.getStoreLattice)("default", "mcp");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -4104,7 +4386,7 @@ async function connectMcpServer(request, reply) {
     };
   } catch (error) {
     console.error("Failed to connect MCP server:", error);
-    const storeLattice = (0, import_core19.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core20.getStoreLattice)("default", "mcp");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (config) {
@@ -4117,10 +4399,10 @@ async function connectMcpServer(request, reply) {
   }
 }
 async function disconnectMcpServer(request, reply) {
-  const tenantId = getTenantId7(request);
+  const tenantId = getTenantId8(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core19.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core20.getStoreLattice)("default", "mcp");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -4130,8 +4412,8 @@ async function disconnectMcpServer(request, reply) {
         message: "MCP server configuration not found"
       };
     }
-    if (import_core19.mcpManager.hasServer(key)) {
-      await import_core19.mcpManager.removeServer(key);
+    if (import_core20.mcpManager.hasServer(key)) {
+      await import_core20.mcpManager.removeServer(key);
     }
     const updated = await store.updateConfig(tenantId, config.id, {
       status: "disconnected"
@@ -4161,10 +4443,10 @@ async function testMcpServerTools(request, reply) {
     }
     const testKey = `__test_${Date.now()}`;
     const connection = convertToConnection(body.config);
-    import_core19.mcpManager.addServer(testKey, connection);
-    await import_core19.mcpManager.connect();
-    const tools = await import_core19.mcpManager.getAllTools();
-    await import_core19.mcpManager.removeServer(testKey);
+    import_core20.mcpManager.addServer(testKey, connection);
+    await import_core20.mcpManager.connect();
+    const tools = await import_core20.mcpManager.getAllTools();
+    await import_core20.mcpManager.removeServer(testKey);
     return {
       success: true,
       message: "Tools retrieved successfully",
@@ -4201,14 +4483,14 @@ function convertToConnection(config) {
 }
 async function connectAndRegisterTools(config) {
   const connection = convertToConnection(config.config);
-  import_core19.mcpManager.addServer(config.key, connection);
-  await import_core19.mcpManager.connect();
-  const allTools = await import_core19.mcpManager.getAllTools();
+  import_core20.mcpManager.addServer(config.key, connection);
+  await import_core20.mcpManager.connect();
+  const allTools = await import_core20.mcpManager.getAllTools();
   const selectedTools = allTools.filter(
     (tool) => config.selectedTools.includes(tool.name)
   );
   for (const tool of selectedTools) {
-    import_core19.toolLatticeManager.registerExistingTool(tool.name, tool);
+    import_core20.toolLatticeManager.registerExistingTool(tool.name, tool);
   }
 }
 function registerMcpServerConfigRoutes(app2) {
@@ -4225,11 +4507,11 @@ function registerMcpServerConfigRoutes(app2) {
 }
 
 // src/controllers/users.ts
-var import_core20 = require("@axiom-lattice/core");
+var import_core21 = require("@axiom-lattice/core");
 var import_uuid4 = require("uuid");
 var UsersController = class {
   constructor() {
-    this.userStore = (0, import_core20.getStoreLattice)("default", "user").store;
+    this.userStore = (0, import_core21.getStoreLattice)("default", "user").store;
   }
   async listUsers(request, reply) {
     const { email } = request.query;
@@ -4307,11 +4589,11 @@ function registerUserRoutes(app2) {
 }
 
 // src/controllers/tenants.ts
-var import_core21 = require("@axiom-lattice/core");
+var import_core22 = require("@axiom-lattice/core");
 var import_uuid5 = require("uuid");
 var TenantsController = class {
   constructor() {
-    this.tenantStore = (0, import_core21.getStoreLattice)("default", "tenant").store;
+    this.tenantStore = (0, import_core22.getStoreLattice)("default", "tenant").store;
   }
   // ==================== Tenant CRUD ====================
   async listTenants(request, reply) {
@@ -4375,7 +4657,7 @@ function registerTenantRoutes(app2) {
 }
 
 // src/controllers/auth.ts
-var import_core22 = require("@axiom-lattice/core");
+var import_core23 = require("@axiom-lattice/core");
 var import_uuid6 = require("uuid");
 var defaultAuthConfig = {
   autoApproveUsers: true,
@@ -4384,9 +4666,9 @@ var defaultAuthConfig = {
 };
 var AuthController = class {
   constructor(config = {}) {
-    this.userStore = (0, import_core22.getStoreLattice)("default", "user").store;
-    this.tenantStore = (0, import_core22.getStoreLattice)("default", "tenant").store;
-    this.userTenantLinkStore = (0, import_core22.getStoreLattice)("default", "userTenantLink").store;
+    this.userStore = (0, import_core23.getStoreLattice)("default", "user").store;
+    this.tenantStore = (0, import_core23.getStoreLattice)("default", "tenant").store;
+    this.userTenantLinkStore = (0, import_core23.getStoreLattice)("default", "userTenantLink").store;
     this.config = { ...defaultAuthConfig, ...config };
   }
   async register(request, reply) {
@@ -4823,6 +5105,11 @@ var registerLatticeRoutes = (app2) => {
   registerWorkspaceRoutes(app2);
   registerDatabaseConfigRoutes(app2);
   registerMetricsServerConfigRoutes(app2);
+  app2.post(
+    "/api/data/query",
+    { schema: dataQuerySchema },
+    executeDataQuery
+  );
   registerMcpServerConfigRoutes(app2);
   registerUserRoutes(app2);
   registerTenantRoutes(app2);
@@ -4895,7 +5182,7 @@ var configureSwagger = async (app2, customSwaggerConfig, customSwaggerUiConfig)
 };
 
 // src/services/agent_task_consumer.ts
-var import_core23 = require("@axiom-lattice/core");
+var import_core24 = require("@axiom-lattice/core");
 var handleAgentTask = async (taskRequest, retryCount = 0) => {
   const {
     assistant_id,
@@ -4924,7 +5211,9 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
       }),
       headers: {
         "Content-Type": "application/json",
-        "x-tenant-id": tenant_id
+        "x-tenant-id": tenant_id,
+        "x-workspace-id": runConfig?.workspaceId,
+        "x-project-id": runConfig?.projectId
       }
     }).catch((err) => {
       console.error(`fetch\u8BF7\u6C42\u5931\u8D25: ${err.message || String(err)}`);
@@ -4961,7 +5250,7 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
       }
       if (callback_event) {
         const state = await agent_state({ assistant_id, thread_id, tenant_id });
-        import_core23.eventBus.publish(callback_event, {
+        import_core24.eventBus.publish(callback_event, {
           success: true,
           state,
           config: { assistant_id, thread_id, tenant_id }
@@ -4975,7 +5264,7 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
       await response.text();
       if (callback_event) {
         const state = await agent_state({ assistant_id, thread_id, tenant_id });
-        import_core23.eventBus.publish(callback_event, {
+        import_core24.eventBus.publish(callback_event, {
           success: true,
           state,
           config: { assistant_id, thread_id, tenant_id }
@@ -5002,7 +5291,7 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
       return handleAgentTask(taskRequest, nextRetryCount);
     }
     if (callback_event) {
-      import_core23.eventBus.publish(callback_event, {
+      import_core24.eventBus.publish(callback_event, {
         success: false,
         error: error instanceof Error ? error.message : String(error),
         config: { assistant_id, thread_id, tenant_id }
@@ -5040,7 +5329,7 @@ var _AgentTaskConsumer = class _AgentTaskConsumer {
    * 初始化事件监听和队列轮询
    */
   initialize() {
-    import_core23.eventBus.subscribe(import_core23.AGENT_TASK_EVENT, this.trigger_agent_task.bind(this));
+    import_core24.eventBus.subscribe(import_core24.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");
   }
@@ -5159,7 +5448,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_core23.eventBus.publish(taskRequest.callback_event, {
+        import_core24.eventBus.publish(taskRequest.callback_event, {
           success: false,
           error: error instanceof Error ? error.message : String(error),
           config: {
@@ -5179,7 +5468,7 @@ _AgentTaskConsumer.agent_run_endpoint = "http://localhost:4001/api/runs";
 var AgentTaskConsumer = _AgentTaskConsumer;
 
 // src/index.ts
-var import_core24 = require("@axiom-lattice/core");
+var import_core25 = 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);
@@ -5194,11 +5483,11 @@ var DEFAULT_LOGGER_CONFIG = {
 var loggerLattice = initializeLogger(DEFAULT_LOGGER_CONFIG);
 var logger = loggerLattice.client;
 function initializeLogger(config) {
-  if (import_core24.loggerLatticeManager.hasLattice("default")) {
-    import_core24.loggerLatticeManager.removeLattice("default");
+  if (import_core25.loggerLatticeManager.hasLattice("default")) {
+    import_core25.loggerLatticeManager.removeLattice("default");
   }
-  (0, import_core24.registerLoggerLattice)("default", config);
-  return (0, import_core24.getLoggerLattice)("default");
+  (0, import_core25.registerLoggerLattice)("default", config);
+  return (0, import_core25.getLoggerLattice)("default");
 }
 var app = (0, import_fastify.default)({
   logger: false,
@@ -5250,6 +5539,10 @@ app.register(import_multipart.default, {
   }
 });
 app.register(import_websocket.default);
+app.register(import_static.default, {
+  root: import_path.default.join(__dirname, "../public"),
+  prefix: "/"
+});
 app.setErrorHandler((error, request, reply) => {
   const getHeaderValue = (header) => {
     if (Array.isArray(header)) {
@@ -5288,9 +5581,10 @@ var start = async (config) => {
       logger = loggerLattice.client;
     }
     app.decorate("loggerLattice", loggerLattice);
-    if (!import_core24.sandboxLatticeManager.hasLattice("default")) {
+    registerLatticeRoutes(app);
+    if (!import_core25.sandboxLatticeManager.hasLattice("default")) {
       const sandboxBaseURL = process.env.SANDBOX_BASE_URL || "http://localhost:8080";
-      import_core24.sandboxLatticeManager.registerLattice("default", {
+      import_core25.sandboxLatticeManager.registerLattice("default", {
         baseURL: sandboxBaseURL
       });
       logger.info(`Registered sandbox manager with baseURL: ${sandboxBaseURL}`);