@axiom-lattice/gateway 2.1.38 → 2.1.39

package/src/controllers/assistant.ts

@@ -6,7 +6,7 @@ import type {
   CreateAssistantRequest,
 } from "@axiom-lattice/protocols";
 import { randomUUID } from "crypto";
-import { AgentConfig, getAllAgentConfigs, eventBus } from "@axiom-lattice/core";
+import { AgentConfig, agentLatticeManager, eventBus } from "@axiom-lattice/core";
 
 /**
  * Assistant Controller
@@ -16,12 +16,28 @@ import { AgentConfig, getAllAgentConfigs, eventBus } from "@axiom-lattice/core";
  * CUD operations only work on stored assistants
  */
 
+/**
+ * Get tenant ID from authenticated user context
+ * Falls back to request headers for backward compatibility
+ */
+function getTenantId(request: FastifyRequest): string {
+  // First try to get from authenticated user context
+  const userTenantId = (request as any).user?.tenantId;
+  if (userTenantId) {
+    return userTenantId;
+  }
+  
+  // Fallback to request headers for backward compatibility
+  return (request.headers["x-tenant-id"] as string) || "default";
+}
+
 /**
  * Convert AgentConfig to Assistant format
  */
 function convertAgentConfigToAssistant(config: AgentConfig): Assistant {
   return {
     id: config.key,
+    tenantId: "default", // Code-configured agents belong to default tenant
     name: config.name,
     description: config.description,
     graphDefinition: config, // Store the full config as graphDefinition
@@ -68,16 +84,18 @@ export async function getAssistantList(
   request: FastifyRequest,
   reply: FastifyReply
 ): Promise<AssistantListResponse> {
-  // Get code-configured agents
-  const agentConfigs = await getAllAgentConfigs();
+  const tenantId = getTenantId(request);
+
+  // Get code-configured agents for the tenant
+  const agentConfigs = await agentLatticeManager.getAllAgentConfigsByTenant(tenantId);
   const codeConfiguredAssistants = agentConfigs.map(
     convertAgentConfigToAssistant
   );
 
-  // Get stored assistants
+  // Get stored assistants for the tenant
   const storeLattice = getStoreLattice("default", "assistant");
   const assistantStore = storeLattice.store;
-  const storedAssistants = await assistantStore.getAllAssistants();
+  const storedAssistants = await assistantStore.getAllAssistants(tenantId);
 
   // Merge both sources, stored assistants take precedence if ID conflicts
   const assistantMap = new Map<string, Assistant>();
@@ -113,16 +131,16 @@ export async function getAssistant(
   reply: FastifyReply
 ): Promise<AssistantResponse> {
   const { id } = request.params;
+  const tenantId = getTenantId(request);
 
   // First check stored assistants
   const storeLattice = getStoreLattice("default", "assistant");
   const assistantStore = storeLattice.store;
-  let assistant = await assistantStore.getAssistantById(id);
+  let assistant = await assistantStore.getAssistantById(tenantId, id);
 
-  // If not found in store, check code-configured agents
+  // If not found in store, check code-configured agents for the tenant
   if (!assistant) {
-    const agentConfigs = await getAllAgentConfigs();
-    const agentConfig = agentConfigs.find((config) => config.key === id);
+    const agentConfig = await agentLatticeManager.getAgentConfigWithTenant(tenantId, id);
     if (agentConfig) {
       assistant = convertAgentConfigToAssistant(agentConfig);
     }
@@ -146,6 +164,7 @@ export async function getAssistant(
  * Upsert assistant - create if not exists in store, update if exists
  */
 async function upsertAssistant(
+  tenantId: string,
   id: string,
   data: CreateAssistantRequest | AssistantUpdateBody,
   reply: FastifyReply,
@@ -154,18 +173,18 @@ async function upsertAssistant(
   const storeLattice = getStoreLattice("default", "assistant");
   const assistantStore = storeLattice.store;
 
-  const exists = await assistantStore.hasAssistant(id);
+  const exists = await assistantStore.hasAssistant(tenantId, id);
 
   let assistant: Assistant | null;
   if (exists) {
-    assistant = await assistantStore.updateAssistant(id, data);
+    assistant = await assistantStore.updateAssistant(tenantId, id, data);
     if (!assistant) {
       return reply.status(500).send({
         success: false,
         message: "Failed to update assistant",
       });
     }
-    eventBus.publish("assistant:updated", { id: assistant.id, name: assistant.name });
+    eventBus.publish("assistant:updated", { id: assistant.id, name: assistant.name, tenantId });
     return {
       success: true,
       message: "Updated assistant",
@@ -183,8 +202,8 @@ async function upsertAssistant(
     }
   }
 
-  assistant = await assistantStore.createAssistant(id, data as CreateAssistantRequest);
-  eventBus.publish("assistant:created", { id: assistant.id, name: assistant.name });
+  assistant = await assistantStore.createAssistant(tenantId, id, data as CreateAssistantRequest);
+  eventBus.publish("assistant:created", { id: assistant.id, name: assistant.name, tenantId });
   return reply.status(201).send({
     success: true,
     message: "Created assistant",
@@ -199,6 +218,7 @@ export async function createAssistant(
   request: FastifyRequest<{ Body: CreateAssistantRequest & { id?: string } }>,
   reply: FastifyReply
 ): Promise<AssistantResponse> {
+  const tenantId = getTenantId(request);
   const data = request.body;
 
   if (!data.name || !data.graphDefinition) {
@@ -209,7 +229,7 @@ export async function createAssistant(
   }
 
   const id = data.id ?? randomUUID();
-  return upsertAssistant(id, data, reply, true);
+  return upsertAssistant(tenantId, id, data, reply, true);
 }
 
 /**
@@ -222,10 +242,11 @@ export async function updateAssistant(
   }>,
   reply: FastifyReply
 ): Promise<AssistantResponse> {
+  const tenantId = getTenantId(request);
   const { id } = request.params;
   const updates = request.body;
 
-  return upsertAssistant(id, updates, reply, false);
+  return upsertAssistant(tenantId, id, updates, reply, false);
 }
 
 /**
@@ -237,31 +258,32 @@ export async function deleteAssistant(
   request: FastifyRequest<{ Params: { id: string } }>,
   reply: FastifyReply
 ): Promise<{ success: boolean; message: string }> {
+  const tenantId = getTenantId(request);
   const { id } = request.params;
 
   const storeLattice = getStoreLattice("default", "assistant");
   const assistantStore = storeLattice.store;
 
-  const agentConfigs = await getAllAgentConfigs();
-  const isCodeConfigured = agentConfigs.some((config) => config.key === id);
+  const agentConfig = await agentLatticeManager.getAgentConfigWithTenant(tenantId, id);
+  const isCodeConfigured = !!agentConfig;
 
   if (isCodeConfigured) {
-    const exists = await assistantStore.hasAssistant(id);
+    const exists = await assistantStore.hasAssistant(tenantId, id);
     if (!exists) {
       return reply.status(404).send({
         success: false,
         message: "Assistant not found (code-configured assistants cannot be deleted from code, only from store)",
       });
     }
-    await assistantStore.deleteAssistant(id);
-    eventBus.publish("assistant:deleted", { id });
+    await assistantStore.deleteAssistant(tenantId, id);
+    eventBus.publish("assistant:deleted", { id, tenantId });
     return {
       success: true,
       message: "Deleted assistant from store (code-configured registration remains)",
     };
   }
 
-  const exists = await assistantStore.hasAssistant(id);
+  const exists = await assistantStore.hasAssistant(tenantId, id);
   if (!exists) {
     return reply.status(404).send({
       success: false,
@@ -269,7 +291,7 @@ export async function deleteAssistant(
     });
   }
 
-  const deleted = await assistantStore.deleteAssistant(id);
+  const deleted = await assistantStore.deleteAssistant(tenantId, id);
 
   if (!deleted) {
     return reply.status(500).send({
@@ -278,7 +300,7 @@ export async function deleteAssistant(
     });
   }
 
-  eventBus.publish("assistant:deleted", { id });
+  eventBus.publish("assistant:deleted", { id, tenantId });
 
   return {
     success: true,
@@ -297,9 +319,10 @@ export const getAgentGraph = async (
 ) => {
   try {
     const { assistantId } = request.params;
+    const tenant_id = getTenantId(request);
 
     // Call drawing service to get image data
-    const imageData = await draw_graph(assistantId);
+    const imageData = await draw_graph(assistantId, tenant_id);
 
     // Set response header and return image data
     reply.header("Content-Type", "application/json").send({

package/src/controllers/database-configs.ts

@@ -18,9 +18,17 @@ import { randomUUID } from "crypto";
  */
 
 /**
- * Get tenant ID from request headers
+ * Get tenant ID from authenticated user context
+ * Falls back to request headers for backward compatibility
  */
 function getTenantId(request: FastifyRequest): string {
+  // First try to get from authenticated user context
+  const userTenantId = (request as any).user?.tenantId;
+  if (userTenantId) {
+    return userTenantId;
+  }
+
+  // Fallback to request headers for backward compatibility
   return (request.headers["x-tenant-id"] as string) || "default";
 }
 
@@ -165,7 +173,7 @@ export async function createDatabaseConfig(
 
     // Auto-register to SqlDatabaseManager
     try {
-      sqlDatabaseManager.registerDatabase(config.key, config.config);
+      sqlDatabaseManager.registerDatabase(tenantId, config.key, config.config);
     } catch (error) {
       console.warn("Failed to auto-register database:", error);
     }
@@ -221,7 +229,7 @@ export async function updateDatabaseConfig(
     // Re-register to SqlDatabaseManager if config changed
     if (updates.config) {
       try {
-        sqlDatabaseManager.registerDatabase(updated.key, updated.config);
+        sqlDatabaseManager.registerDatabase(tenantId, updated.key, updated.config);
       } catch (error) {
         console.warn("Failed to re-register database:", error);
       }
@@ -290,8 +298,8 @@ export async function deleteDatabaseConfig(
 
     // Remove from SqlDatabaseManager
     try {
-      if (sqlDatabaseManager.hasDatabase(configKey)) {
-        await sqlDatabaseManager.removeDatabase(configKey);
+      if (sqlDatabaseManager.hasDatabase(tenantId, configKey)) {
+        await sqlDatabaseManager.removeDatabase(tenantId, configKey);
       }
     } catch (error) {
       console.warn("Failed to remove from SqlDatabaseManager:", error);
@@ -335,10 +343,10 @@ export async function testDatabaseConnection(
 
     // Register temporarily for testing
     const testKey = `__test_${key}_${Date.now()}`;
-    sqlDatabaseManager.registerDatabase(testKey, config.config);
+    sqlDatabaseManager.registerDatabase(tenantId, testKey, config.config);
 
     const startTime = Date.now();
-    const db = sqlDatabaseManager.getDatabase(testKey);
+    const db = sqlDatabaseManager.getDatabase(tenantId, testKey);
 
     try {
       // Try to connect and list tables
@@ -351,7 +359,7 @@ export async function testDatabaseConnection(
       await db.disconnect();
       
       // Cleanup
-      await sqlDatabaseManager.removeDatabase(testKey);
+      await sqlDatabaseManager.removeDatabase(tenantId, testKey);
 
       return {
         success: true,
@@ -365,7 +373,7 @@ export async function testDatabaseConnection(
       // Cleanup on error
       try {
         await db.disconnect();
-        await sqlDatabaseManager.removeDatabase(testKey);
+        await sqlDatabaseManager.removeDatabase(tenantId, testKey);
       } catch {}
 
       return {

package/src/controllers/mcp-configs.ts

@@ -20,9 +20,17 @@ import type {
 import { randomUUID } from "crypto";
 
 /**
- * Get tenant ID from request headers
+ * Get tenant ID from authenticated user context
+ * Falls back to request headers for backward compatibility
  */
 function getTenantId(request: FastifyRequest): string {
+  // First try to get from authenticated user context
+  const userTenantId = (request as any).user?.tenantId;
+  if (userTenantId) {
+    return userTenantId;
+  }
+
+  // Fallback to request headers for backward compatibility
   return (request.headers["x-tenant-id"] as string) || "default";
 }
 

package/src/controllers/memory.ts

@@ -155,9 +155,12 @@ export const getAgentState = async (
       return;
     }
 
+    const tenant_id = request.headers["x-tenant-id"] as string;
+    
     const result = await agent_state({
       assistant_id: assistantId,
       thread_id: thread_id,
+      tenant_id: tenant_id,
     });
 
     if (!result) {

package/src/controllers/metrics-configs.ts

@@ -22,9 +22,17 @@ import { randomUUID } from "crypto";
  */
 
 /**
- * Get tenant ID from request headers
+ * Get tenant ID from authenticated user context
+ * Falls back to request headers for backward compatibility
  */
 function getTenantId(request: FastifyRequest): string {
+  // First try to get from authenticated user context
+  const userTenantId = (request as any).user?.tenantId;
+  if (userTenantId) {
+    return userTenantId;
+  }
+
+  // Fallback to request headers for backward compatibility
   return (request.headers["x-tenant-id"] as string) || "default";
 }
 
@@ -124,8 +132,18 @@ interface DatasourceMetricsResponse {
         searchKeywords: string[];
         registered: boolean;
       }>;
+      tables?: Array<{
+        tableName: string;
+        displayName: string;
+        docType: string;
+        docTypeEn: string;
+        mainTable?: string;
+        lineTable?: string;
+        columnCount: number;
+        shortDesc: string;
+      }>;
     };
-    details: Array<{
+    metricsDetails: Array<{
       datasourceId: number;
       metricName: string;
       displayName: string;
@@ -176,6 +194,22 @@ interface DatasourceMetricsResponse {
         humanReadableExplanation: string;
       };
     }>;
+    tablesDetails?: Array<{
+      tableName: string;
+      docType: string;
+      docTypeEn: string;
+      objTypeCode?: number;
+      mainTable?: string;
+      lineTable?: string;
+      selectSql: string;
+      columns: Array<{
+        name: string;
+        label: string;
+        description?: string;
+        type?: string;
+        example?: string;
+      } | null>;
+    }>;
   };
 }
 
@@ -326,7 +360,7 @@ export async function createMetricsServerConfig(
 
     // Auto-register to MetricsServerManager
     try {
-      metricsServerManager.registerServer(config.key, config.config);
+      metricsServerManager.registerServer(tenantId, config.key, config.config);
     } catch (error) {
       console.warn("Failed to auto-register metrics server:", error);
     }
@@ -395,7 +429,7 @@ export async function updateMetricsServerConfig(
 
     if (updates.config) {
       try {
-        metricsServerManager.registerServer(updated.key, updated.config);
+        metricsServerManager.registerServer(tenantId, updated.key, updated.config);
       } catch (error) {
         console.warn("Failed to re-register metrics server:", error);
       }
@@ -460,8 +494,8 @@ export async function deleteMetricsServerConfig(
 
     // Remove from MetricsServerManager
     try {
-      if (metricsServerManager.hasServer(configKey)) {
-        metricsServerManager.removeServer(configKey);
+      if (metricsServerManager.hasServer(tenantId, configKey)) {
+        metricsServerManager.removeServer(tenantId, configKey);
       }
     } catch (error) {
       console.warn("Failed to remove from MetricsServerManager:", error);
@@ -505,14 +539,14 @@ export async function testMetricsServerConnection(
 
     // Register temporarily for testing
     const testKey = `__test_${key}_${Date.now()}`;
-    metricsServerManager.registerServer(testKey, config.config);
+    metricsServerManager.registerServer(tenantId, testKey, config.config);
 
     try {
-      const client = metricsServerManager.getClient(testKey);
+      const client = metricsServerManager.getClient(tenantId, testKey);
       const result = await client.testConnection();
 
       // Cleanup
-      metricsServerManager.removeServer(testKey);
+      metricsServerManager.removeServer(tenantId, testKey);
 
       return {
         success: true,
@@ -522,7 +556,7 @@ export async function testMetricsServerConnection(
     } catch (error) {
       // Cleanup on error
       try {
-        metricsServerManager.removeServer(testKey);
+        metricsServerManager.removeServer(tenantId, testKey);
       } catch {}
 
       return {
@@ -571,11 +605,11 @@ export async function listAvailableMetrics(
     }
 
     // Ensure server is registered
-    if (!metricsServerManager.hasServer(key)) {
-      metricsServerManager.registerServer(key, config.config);
+    if (!metricsServerManager.hasServer(tenantId, key)) {
+      metricsServerManager.registerServer(tenantId, key, config.config);
     }
 
-    const client = metricsServerManager.getClient(key);
+    const client = metricsServerManager.getClient(tenantId, key);
     const metrics = await client.listMetrics();
 
     return {
@@ -637,11 +671,11 @@ export async function queryMetricsData(
     }
 
     // Ensure server is registered
-    if (!metricsServerManager.hasServer(key)) {
-      metricsServerManager.registerServer(key, config.config);
+    if (!metricsServerManager.hasServer(tenantId, key)) {
+      metricsServerManager.registerServer(tenantId, key, config.config);
     }
 
-    const client = metricsServerManager.getClient(key);
+    const client = metricsServerManager.getClient(tenantId, key);
     const result = await client.queryMetricData(metricName, {
       startTime,
       endTime,
@@ -822,14 +856,42 @@ export async function querySemanticMetrics(
     const client = new SemanticMetricsClient(semanticConfig);
     const result = await client.semanticQuery(body);
 
+    // Transform SemanticMetricsQueryResponse to response format
+    // The response contains results array with metric data
+    const allDataPoints: Array<{
+      timestamp?: number;
+      value: number;
+      metricName?: string;
+      labels?: Record<string, string>;
+    }> = [];
+    const metricNames: string[] = [];
+
+    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 as string).getTime() : undefined,
+          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)])
+          ),
+        });
+      }
+    }
+
     return {
       success: true,
       message: "Semantic query executed successfully",
       data: {
         datasourceId: result.datasourceId,
-        metrics: result.metrics,
-        dataPoints: result.dataPoints,
-        metadata: result.metadata,
+        metrics: metricNames,
+        dataPoints: allDataPoints,
+        metadata: {
+          rowCount: allDataPoints.length,
+          queryTimeMs: result.totalExecutionTimeMs,
+        },
       },
     };
   } catch (error) {

package/src/controllers/models.ts

@@ -5,8 +5,41 @@ import type { LLMConfig } from "@axiom-lattice/protocols";
 /**
  * Models Controller
  * Handles model lattice registration and management
+ * Models are tenant-isolated using key prefix: {tenantId}:{modelKey}
  */
 
+/**
+ * Get tenant ID from request headers or user context
+ */
+function getTenantId(request: FastifyRequest): string {
+  // First try to get from authenticated user context
+  const userTenantId = (request as any).user?.tenantId;
+  if (userTenantId) {
+    return userTenantId;
+  }
+
+  // Fallback to request headers for backward compatibility
+  return (request.headers["x-tenant-id"] as string) || "default";
+}
+
+/**
+ * Get tenant-scoped model key
+ */
+function getTenantModelKey(tenantId: string, modelKey: string): string {
+  return `${tenantId}:${modelKey}`;
+}
+
+/**
+ * Extract model key from tenant-scoped key
+ */
+function extractModelKey(tenantId: string, tenantModelKey: string): string {
+  const prefix = `${tenantId}:`;
+  if (tenantModelKey.startsWith(prefix)) {
+    return tenantModelKey.substring(prefix.length);
+  }
+  return tenantModelKey;
+}
+
 interface ModelConfig {
   key: string;
   model: string;
@@ -26,6 +59,12 @@ interface UpdateModelsRequest {
   };
 }
 
+interface UpdateModelsRequest {
+  Body: {
+    models: ModelConfig[];
+  };
+}
+
 /**
  * Get all registered models
  */

package/src/controllers/run.ts

@@ -42,6 +42,16 @@ export const createRun = async (
 
     // 如果请求streaming，则agent_stream
     if (streaming) {
+      // 先检查agent是否存在（在hijack之前）
+      const agentExists = await agentService.checkAgentExists(tenant_id, assistant_id);
+      if (!agentExists) {
+        reply.status(404).send({
+          success: false,
+          error: `Agent ${assistant_id} not found for tenant ${tenant_id}`,
+        });
+        return;
+      }
+      
       // 开始运行
       const stream = await agentService.agent_stream({
         assistant_id: assistant_id,
@@ -67,11 +77,24 @@ export const createRun = async (
       });
 
       try {
+        let chunkCount = 0;
         for await (const chunk of stream) {
-          reply.raw.write(`data: ${JSON.stringify(chunk)}\n\n`);
+          chunkCount++;
+          const success = reply.raw.write(`data: ${JSON.stringify(chunk)}\n\n`);
+          if (!success) {
+            await new Promise(resolve => reply.raw.once('drain', resolve));
+          }
         }
-      } catch (error) {
-        console.error("Stream processing error:", error);
+      } catch (error: any) {
+        // Send error as SSE event before closing (following MessageChunk format)
+        const errorEvent = {
+          type: 'error',
+          data: {
+            id: v4(),
+            content: error.message || 'Stream processing error'
+          }
+        };
+        reply.raw.write(`data: ${JSON.stringify(errorEvent)}\n\n`);
       } finally {
         reply.raw.end();
       }
@@ -138,11 +161,18 @@ export const resumeStream = async (
 
       // Stream the chunks to the client
       for await (const chunk of stream) {
-        // console.log("resume stream raw.write", chunk);
         reply.raw.write(`data: ${JSON.stringify(chunk)}\n\n`);
       }
-    } catch (error) {
-      console.error("Resume stream processing error:", error);
+    } catch (error: any) {
+      // Send error as SSE event before closing (following MessageChunk format)
+      const errorEvent = {
+        type: 'error',
+        data: {
+          id: v4(),
+          content: error.message || 'Resume stream processing error'
+        }
+      };
+      reply.raw.write(`data: ${JSON.stringify(errorEvent)}\n\n`);
     } finally {
       reply.raw.end();
     }

package/src/controllers/sandbox.ts

@@ -53,8 +53,9 @@ export function registerSandboxProxyRoutes(app: FastifyInstance): void {
     async (request, reply) => {
       console.log("[Sandbox Upload] Route matched:", request.url);
       const { assistantId, threadId } = request.params;
+      const tenantId = (request.headers["x-tenant-id"] as string) || "default";
 
-      const isolatedLevel = sandboxService.getFilesystemIsolatedLevel(assistantId);
+      const isolatedLevel = sandboxService.getFilesystemIsolatedLevel(tenantId, assistantId);
       if (!isolatedLevel) {
         return reply.status(500).send({ error: "Assistant sandbox config not found" });
       }
@@ -65,7 +66,7 @@ export function registerSandboxProxyRoutes(app: FastifyInstance): void {
         isolatedLevel
       );
 
-      const sandboxManager = getSandBoxManager("default")
+      const sandboxManager = getSandBoxManager()
       const sandbox = await sandboxManager.createSandbox(sandboxName)
 
       try {
@@ -116,12 +117,13 @@ export function registerSandboxProxyRoutes(app: FastifyInstance): void {
     async (request, reply) => {
       const { assistantId, threadId } = request.params;
       const { path: filePath } = request.query;
+      const tenantId = (request.headers["x-tenant-id"] as string) || "default";
 
       if (!filePath || typeof filePath !== "string") {
         return reply.status(400).send({ error: "Query parameter 'path' is required" });
       }
 
-      const isolatedLevel = sandboxService.getFilesystemIsolatedLevel(assistantId);
+      const isolatedLevel = sandboxService.getFilesystemIsolatedLevel(tenantId, assistantId);
       if (!isolatedLevel) {
         return reply.status(500).send({ error: "Assistant filesystem isolated level not found" });
       }
@@ -132,7 +134,7 @@ export function registerSandboxProxyRoutes(app: FastifyInstance): void {
         isolatedLevel
       );
 
-      const sandboxManager = getSandBoxManager("default");
+      const sandboxManager = getSandBoxManager();
       const sandbox = await sandboxManager.createSandbox(sandboxName);
 
       try {