@axiom-lattice/gateway 2.1.11 → 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/assistant.ts

@@ -1,6 +1,277 @@
 import { FastifyRequest, FastifyReply } from "fastify";
 import { draw_graph } from "../services/agent_service";
+import { assistantStore } from "../stores/assistant_store";
+import { Assistant, CreateAssistantRequest } from "../types";
+import { randomUUID } from "crypto";
+import { AgentConfig, getAllAgentConfigs } from "@axiom-lattice/core";
 
+/**
+ * Assistant Controller
+ * Handles assistant-related CRUD operations
+ * Merges code-configured agents (from @axiom-lattice/core) with in-memory stored assistants
+ * GET operations return both code-configured and stored assistants
+ * CUD operations only work on stored assistants
+ */
+
+/**
+ * Convert AgentConfig to Assistant format
+ */
+function convertAgentConfigToAssistant(config: AgentConfig): Assistant {
+  return {
+    id: config.key,
+    name: config.name,
+    description: config.description,
+    graphDefinition: config, // Store the full config as graphDefinition
+    createdAt: new Date(0), // Code-configured agents have no creation date
+    updatedAt: new Date(0), // Code-configured agents have no update date
+  };
+}
+
+/**
+ * Assistant list response interface
+ */
+interface AssistantListResponse {
+  success: boolean;
+  message: string;
+  data: {
+    records: Assistant[];
+    total: number;
+  };
+}
+
+/**
+ * Assistant response interface
+ */
+interface AssistantResponse {
+  success: boolean;
+  message: string;
+  data?: Assistant;
+}
+
+/**
+ * Assistant update request body interface
+ */
+interface AssistantUpdateBody {
+  name?: string;
+  description?: string;
+  graphDefinition?: any;
+}
+
+/**
+ * Get list of all assistants
+ * Merges code-configured agents with stored assistants
+ */
+export async function getAssistantList(
+  request: FastifyRequest,
+  reply: FastifyReply
+): Promise<AssistantListResponse> {
+  // Get code-configured agents
+  const agentConfigs = await getAllAgentConfigs();
+  const codeConfiguredAssistants = agentConfigs.map(
+    convertAgentConfigToAssistant
+  );
+
+  // Get stored assistants
+  const storedAssistants = assistantStore.getAllAssistants();
+
+  // Merge both sources, stored assistants take precedence if ID conflicts
+  const assistantMap = new Map<string, Assistant>();
+
+  // First add code-configured agents
+  codeConfiguredAssistants.forEach((assistant) => {
+    assistantMap.set(assistant.id, assistant);
+  });
+
+  // Then add stored assistants (overwrite if ID exists)
+  storedAssistants.forEach((assistant) => {
+    assistantMap.set(assistant.id, assistant);
+  });
+
+  const allAssistants = Array.from(assistantMap.values());
+
+  return {
+    success: true,
+    message: "Successfully retrieved assistant list",
+    data: {
+      records: allAssistants,
+      total: allAssistants.length,
+    },
+  };
+}
+
+/**
+ * Get a single assistant by ID
+ * Checks both code-configured agents and stored assistants
+ */
+export async function getAssistant(
+  request: FastifyRequest<{ Params: { id: string } }>,
+  reply: FastifyReply
+): Promise<AssistantResponse> {
+  const { id } = request.params;
+
+  // First check stored assistants
+  let assistant = assistantStore.getAssistantById(id);
+
+  // If not found in store, check code-configured agents
+  if (!assistant) {
+    const agentConfigs = await getAllAgentConfigs();
+    const agentConfig = agentConfigs.find((config) => config.key === id);
+    if (agentConfig) {
+      assistant = convertAgentConfigToAssistant(agentConfig);
+    }
+  }
+
+  if (!assistant) {
+    return reply.status(404).send({
+      success: false,
+      message: "Assistant not found",
+    });
+  }
+
+  return {
+    success: true,
+    message: "Successfully retrieved assistant",
+    data: assistant,
+  };
+}
+
+/**
+ * Create a new assistant
+ */
+export async function createAssistant(
+  request: FastifyRequest<{ Body: CreateAssistantRequest }>,
+  reply: FastifyReply
+): Promise<AssistantResponse> {
+  const data = request.body;
+
+  // Validate required fields
+  if (!data.name) {
+    return reply.status(400).send({
+      success: false,
+      message: "name is required",
+    });
+  }
+
+  if (!data.graphDefinition) {
+    return reply.status(400).send({
+      success: false,
+      message: "graphDefinition is required",
+    });
+  }
+
+  // Generate ID if not provided
+  const id = randomUUID();
+
+  // Create assistant
+  const newAssistant = assistantStore.createAssistant(id, data);
+
+  return reply.status(201).send({
+    success: true,
+    message: "Successfully created assistant",
+    data: newAssistant,
+  });
+}
+
+/**
+ * Update an existing assistant by ID
+ * Only works on stored assistants, not code-configured ones
+ */
+export async function updateAssistant(
+  request: FastifyRequest<{
+    Params: { id: string };
+    Body: AssistantUpdateBody;
+  }>,
+  reply: FastifyReply
+): Promise<AssistantResponse> {
+  const { id } = request.params;
+  const updates = request.body;
+
+  // Check if it's a code-configured agent
+  const agentConfigs = await getAllAgentConfigs();
+  const isCodeConfigured = agentConfigs.some((config) => config.key === id);
+
+  if (isCodeConfigured) {
+    return reply.status(403).send({
+      success: false,
+      message:
+        "Cannot update code-configured assistant. Only stored assistants can be updated.",
+    });
+  }
+
+  // Check if assistant exists in store
+  if (!assistantStore.hasAssistant(id)) {
+    return reply.status(404).send({
+      success: false,
+      message: "Assistant not found",
+    });
+  }
+
+  // Update assistant
+  const updatedAssistant = assistantStore.updateAssistant(id, updates);
+
+  if (!updatedAssistant) {
+    return reply.status(500).send({
+      success: false,
+      message: "Failed to update assistant",
+    });
+  }
+
+  return {
+    success: true,
+    message: "Successfully updated assistant",
+    data: updatedAssistant,
+  };
+}
+
+/**
+ * Delete an assistant by ID
+ * Only works on stored assistants, not code-configured ones
+ */
+export async function deleteAssistant(
+  request: FastifyRequest<{ Params: { id: string } }>,
+  reply: FastifyReply
+): Promise<{ success: boolean; message: string }> {
+  const { id } = request.params;
+
+  // Check if it's a code-configured agent
+  const agentConfigs = await getAllAgentConfigs();
+  const isCodeConfigured = agentConfigs.some((config) => config.key === id);
+
+  if (isCodeConfigured) {
+    return reply.status(403).send({
+      success: false,
+      message:
+        "Cannot delete code-configured assistant. Only stored assistants can be deleted.",
+    });
+  }
+
+  // Check if assistant exists in store
+  if (!assistantStore.hasAssistant(id)) {
+    return reply.status(404).send({
+      success: false,
+      message: "Assistant not found",
+    });
+  }
+
+  // Delete the assistant
+  const deleted = assistantStore.deleteAssistant(id);
+
+  if (!deleted) {
+    return reply.status(500).send({
+      success: false,
+      message: "Failed to delete assistant",
+    });
+  }
+
+  return {
+    success: true,
+    message: "Successfully deleted assistant",
+  };
+}
+
+/**
+ * Get agent graph visualization
+ */
 export const getAgentGraph = async (
   request: FastifyRequest<{
     Params: { assistantId: string };
@@ -10,17 +281,17 @@ export const getAgentGraph = async (
   try {
     const { assistantId } = request.params;
 
-    // 调用绘图服务获取图片数据
+    // Call drawing service to get image data
     const imageData = await draw_graph(assistantId);
 
-    // 设置响应头并返回图片数据
+    // Set response header and return image data
     reply.header("Content-Type", "application/json").send({
       image: imageData,
     });
   } catch (error: any) {
     reply.status(500).send({
       success: false,
-      error: error.message || "获取代理图表失败",
+      error: error.message || "Failed to get agent graph",
     });
   }
 };

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",
+    });
+  }
+}