@axiom-lattice/gateway 2.1.12 → 2.1.13

package/dist/index.mjs

@@ -927,6 +927,300 @@ async function deleteThread(request, reply) {
   };
 }
 
+// src/config.ts
+var ConfigService = class {
+  constructor() {
+    this.config = this.loadFromEnv();
+  }
+  /**
+   * Load configuration from environment variables
+   */
+  loadFromEnv() {
+    return {
+      port: process.env.PORT ? Number(process.env.PORT) : void 0,
+      queueServiceType: process.env.QUEUE_SERVICE_TYPE,
+      redisUrl: process.env.REDIS_URL,
+      redisPassword: process.env.REDIS_PASSWORD,
+      queueName: process.env.QUEUE_NAME
+    };
+  }
+  /**
+   * Update configuration from JSON object
+   * This will update both the internal config and process.env
+   */
+  updateConfig(jsonConfig) {
+    for (const [key, value] of Object.entries(jsonConfig)) {
+      if (value !== null && value !== void 0) {
+        if (typeof value === "object" && !Array.isArray(value)) {
+          for (const [nestedKey, nestedValue] of Object.entries(value)) {
+            const envKey = `${key.toUpperCase()}_${nestedKey.toUpperCase()}`;
+            process.env[envKey] = String(nestedValue);
+          }
+        } else {
+          process.env[key.toUpperCase()] = String(value);
+        }
+      }
+    }
+    this.config = this.loadFromEnv();
+    this.config = this.deepMerge(this.config, jsonConfig);
+  }
+  /**
+   * Deep merge two objects
+   */
+  deepMerge(target, source) {
+    const output = { ...target };
+    if (this.isObject(target) && this.isObject(source)) {
+      Object.keys(source).forEach((key) => {
+        if (this.isObject(source[key])) {
+          if (!(key in target)) {
+            Object.assign(output, { [key]: source[key] });
+          } else {
+            output[key] = this.deepMerge(target[key], source[key]);
+          }
+        } else {
+          Object.assign(output, { [key]: source[key] });
+        }
+      });
+    }
+    return output;
+  }
+  /**
+   * Check if value is a plain object
+   */
+  isObject(item) {
+    return item && typeof item === "object" && !Array.isArray(item);
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+};
+var configService = new ConfigService();
+
+// src/services/queue_service.ts
+import {
+  queueLatticeManager,
+  registerQueueLattice,
+  getQueueLattice
+} from "@axiom-lattice/core";
+import { QueueType } from "@axiom-lattice/protocols";
+import { RedisQueueClient } from "@axiom-lattice/queue-redis";
+var DEFAULT_QUEUE_KEY = "default";
+var queueServiceType = process.env.QUEUE_SERVICE_TYPE || "memory";
+var setQueueServiceType = (type) => {
+  queueServiceType = type;
+  console.log(`Queue service type set to: ${type}`);
+  const queueName = process.env.QUEUE_NAME || "tasks";
+  const config = {
+    name: "Default Queue Service",
+    description: `Default ${type} queue service`,
+    type: type === "redis" ? QueueType.REDIS : QueueType.MEMORY,
+    queueName,
+    options: type === "redis" ? {
+      redisUrl: process.env.REDIS_URL,
+      redisPassword: process.env.REDIS_PASSWORD
+    } : void 0
+  };
+  if (queueLatticeManager.hasLattice(DEFAULT_QUEUE_KEY)) {
+    queueLatticeManager.removeLattice(DEFAULT_QUEUE_KEY);
+  }
+  let client;
+  if (type === "redis") {
+    client = new RedisQueueClient(queueName, {
+      redisUrl: process.env.REDIS_URL,
+      redisPassword: process.env.REDIS_PASSWORD
+    });
+  }
+  registerQueueLattice(DEFAULT_QUEUE_KEY, config, client);
+};
+var getQueueService = () => {
+  if (!queueLatticeManager.hasLattice(DEFAULT_QUEUE_KEY)) {
+    setQueueServiceType(queueServiceType);
+  }
+  return getQueueLattice(DEFAULT_QUEUE_KEY);
+};
+var popAgentTaskFromQueue = async () => {
+  const queue = getQueueService();
+  const result = await queue.pop();
+  return result;
+};
+
+// src/controllers/config.ts
+async function updateConfig(request, reply) {
+  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"
+      });
+    }
+    configService.updateConfig(jsonConfig);
+    const warnings = [];
+    const requiresRestart = [];
+    if (jsonConfig.port !== void 0) {
+      requiresRestart.push("PORT");
+      warnings.push("Port change requires server restart to take effect");
+    }
+    if (jsonConfig.queueServiceType) {
+      setQueueServiceType(jsonConfig.queueServiceType);
+    }
+    if ((jsonConfig.redisUrl || jsonConfig.redisPassword) && (process.env.QUEUE_SERVICE_TYPE === "redis" || jsonConfig.queueServiceType === "redis")) {
+      const currentType = jsonConfig.queueServiceType || process.env.QUEUE_SERVICE_TYPE || "memory";
+      if (currentType === "redis") {
+        setQueueServiceType("redis");
+      }
+    }
+    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 : void 0,
+      requiresRestart: requiresRestart.length > 0 ? requiresRestart : void 0
+    });
+  } catch (error) {
+    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"
+    });
+  }
+}
+async function getConfig(request, reply) {
+  try {
+    const currentConfig = configService.getConfig();
+    const safeConfig = {
+      ...currentConfig,
+      redisPassword: currentConfig.redisPassword ? "***" : currentConfig.redisPassword
+    };
+    return reply.send({
+      success: true,
+      data: safeConfig
+    });
+  } catch (error) {
+    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"
+    });
+  }
+}
+
+// src/controllers/models.ts
+import { registerModelLattice, modelLatticeManager } from "@axiom-lattice/core";
+async function getModels(request, reply) {
+  try {
+    const allLattices = modelLatticeManager.getAllLattices();
+    const models = allLattices.map((lattice) => {
+      const config = lattice.client.config || {};
+      return {
+        key: lattice.key,
+        model: config.model || "",
+        provider: config.provider || "openai",
+        streaming: config.streaming || false,
+        apiKey: config.apiKey || "",
+        baseURL: config.baseURL || "",
+        maxTokens: config.maxTokens,
+        temperature: config.temperature,
+        timeout: config.timeout,
+        maxRetries: config.maxRetries
+      };
+    });
+    return reply.send({
+      success: true,
+      data: models
+    });
+  } catch (error) {
+    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"
+    });
+  }
+}
+async function updateModels(request, reply) {
+  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 = [];
+    const errors = [];
+    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 {
+        if (modelLatticeManager.hasLattice(modelConfig.key)) {
+          modelLatticeManager.removeLattice(modelConfig.key);
+        }
+        const 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
+        };
+        registerModelLattice(modelConfig.key, llmConfig);
+        registeredModels.push(modelConfig.key);
+      } catch (error) {
+        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 : void 0
+      }
+    });
+  } catch (error) {
+    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"
+    });
+  }
+}
+
 // src/schemas/index.ts
 var getAllMemoryItemsSchema = {
   description: "Get all memory items for an assistant thread",
@@ -1095,6 +1389,77 @@ var triggerAgentTaskSchema = {
     }
   }
 };
+var updateConfigSchema = {
+  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" }
+      }
+    }
+  }
+};
+var getConfigSchema = {
+  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" }
+      }
+    }
+  }
+};
 
 // src/routes/index.ts
 var registerLatticeRoutes = (app2) => {
@@ -1159,6 +1524,18 @@ var registerLatticeRoutes = (app2) => {
     "/api/assistants/:assistantId/threads/:threadId",
     deleteThread
   );
+  app2.get(
+    "/api/config",
+    { schema: getConfigSchema },
+    getConfig
+  );
+  app2.put(
+    "/api/config",
+    { schema: updateConfigSchema },
+    updateConfig
+  );
+  app2.get("/api/models", getModels);
+  app2.put("/api/models", updateModels);
 };
 
 // src/logger/Logger.ts
@@ -1361,54 +1738,6 @@ var configureSwagger = async (app2, customSwaggerConfig, customSwaggerUiConfig)
   await app2.register(swaggerUi, swaggerUiConfig);
 };
 
-// src/services/queue_service.ts
-import {
-  queueLatticeManager,
-  registerQueueLattice,
-  getQueueLattice
-} from "@axiom-lattice/core";
-import { QueueType } from "@axiom-lattice/protocols";
-import { RedisQueueClient } from "@axiom-lattice/queue-redis";
-var DEFAULT_QUEUE_KEY = "default";
-var queueServiceType = process.env.QUEUE_SERVICE_TYPE || "memory";
-var setQueueServiceType = (type) => {
-  queueServiceType = type;
-  console.log(`Queue service type set to: ${type}`);
-  const queueName = process.env.QUEUE_NAME || "tasks";
-  const config = {
-    name: "Default Queue Service",
-    description: `Default ${type} queue service`,
-    type: type === "redis" ? QueueType.REDIS : QueueType.MEMORY,
-    queueName,
-    options: type === "redis" ? {
-      redisUrl: process.env.REDIS_URL,
-      redisPassword: process.env.REDIS_PASSWORD
-    } : void 0
-  };
-  if (queueLatticeManager.hasLattice(DEFAULT_QUEUE_KEY)) {
-    queueLatticeManager.removeLattice(DEFAULT_QUEUE_KEY);
-  }
-  let client;
-  if (type === "redis") {
-    client = new RedisQueueClient(queueName, {
-      redisUrl: process.env.REDIS_URL,
-      redisPassword: process.env.REDIS_PASSWORD
-    });
-  }
-  registerQueueLattice(DEFAULT_QUEUE_KEY, config, client);
-};
-var getQueueService = () => {
-  if (!queueLatticeManager.hasLattice(DEFAULT_QUEUE_KEY)) {
-    setQueueServiceType(queueServiceType);
-  }
-  return getQueueLattice(DEFAULT_QUEUE_KEY);
-};
-var popAgentTaskFromQueue = async () => {
-  const queue = getQueueService();
-  const result = await queue.pop();
-  return result;
-};
-
 // src/services/agent_task_consumer.ts
 import { eventBus, AGENT_TASK_EVENT } from "@axiom-lattice/core";
 var handleAgentTask = async (taskRequest, retryCount = 0) => {