@axiom-lattice/gateway 2.1.11 → 2.1.13

package/dist/index.mjs

@@ -223,6 +223,226 @@ async function resume_stream({
   };
 }
 
+// src/stores/assistant_store.ts
+var AssistantStore = class {
+  constructor() {
+    this.assistants = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Get all assistants
+   */
+  getAllAssistants() {
+    return Array.from(this.assistants.values());
+  }
+  /**
+   * Get assistant by ID
+   */
+  getAssistantById(id) {
+    return this.assistants.get(id);
+  }
+  /**
+   * Create a new assistant
+   */
+  createAssistant(id, data) {
+    const now = /* @__PURE__ */ new Date();
+    const assistant = {
+      id,
+      name: data.name,
+      description: data.description,
+      graphDefinition: data.graphDefinition,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.assistants.set(id, assistant);
+    return assistant;
+  }
+  /**
+   * Update an existing assistant
+   */
+  updateAssistant(id, updates) {
+    const existing = this.assistants.get(id);
+    if (!existing) {
+      return null;
+    }
+    const updated = {
+      ...existing,
+      ...updates,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.assistants.set(id, updated);
+    return updated;
+  }
+  /**
+   * Delete an assistant by ID
+   */
+  deleteAssistant(id) {
+    return this.assistants.delete(id);
+  }
+  /**
+   * Check if assistant exists
+   */
+  hasAssistant(id) {
+    return this.assistants.has(id);
+  }
+};
+var assistantStore = new AssistantStore();
+
+// src/controllers/assistant.ts
+import { randomUUID } from "crypto";
+import { getAllAgentConfigs } from "@axiom-lattice/core";
+function convertAgentConfigToAssistant(config) {
+  return {
+    id: config.key,
+    name: config.name,
+    description: config.description,
+    graphDefinition: config,
+    // Store the full config as graphDefinition
+    createdAt: /* @__PURE__ */ new Date(0),
+    // Code-configured agents have no creation date
+    updatedAt: /* @__PURE__ */ new Date(0)
+    // Code-configured agents have no update date
+  };
+}
+async function getAssistantList(request, reply) {
+  const agentConfigs = await getAllAgentConfigs();
+  const codeConfiguredAssistants = agentConfigs.map(
+    convertAgentConfigToAssistant
+  );
+  const storedAssistants = assistantStore.getAllAssistants();
+  const assistantMap = /* @__PURE__ */ new Map();
+  codeConfiguredAssistants.forEach((assistant) => {
+    assistantMap.set(assistant.id, assistant);
+  });
+  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
+    }
+  };
+}
+async function getAssistant(request, reply) {
+  const { id } = request.params;
+  let assistant = assistantStore.getAssistantById(id);
+  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
+  };
+}
+async function createAssistant(request, reply) {
+  const data = request.body;
+  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"
+    });
+  }
+  const id = randomUUID();
+  const newAssistant = assistantStore.createAssistant(id, data);
+  return reply.status(201).send({
+    success: true,
+    message: "Successfully created assistant",
+    data: newAssistant
+  });
+}
+async function updateAssistant(request, reply) {
+  const { id } = request.params;
+  const updates = request.body;
+  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."
+    });
+  }
+  if (!assistantStore.hasAssistant(id)) {
+    return reply.status(404).send({
+      success: false,
+      message: "Assistant not found"
+    });
+  }
+  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
+  };
+}
+async function deleteAssistant(request, reply) {
+  const { id } = request.params;
+  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."
+    });
+  }
+  if (!assistantStore.hasAssistant(id)) {
+    return reply.status(404).send({
+      success: false,
+      message: "Assistant not found"
+    });
+  }
+  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"
+  };
+}
+var getAgentGraph = async (request, reply) => {
+  try {
+    const { assistantId } = request.params;
+    const imageData = await draw_graph(assistantId);
+    reply.header("Content-Type", "application/json").send({
+      image: imageData
+    });
+  } catch (error) {
+    reply.status(500).send({
+      success: false,
+      error: error.message || "Failed to get agent graph"
+    });
+  }
+};
+
 // src/controllers/run.ts
 import { v4 as v42 } from "uuid";
 var createRun = async (request, reply) => {
@@ -490,22 +710,6 @@ var clearMemory = async (request, reply) => {
   }
 };
 
-// src/controllers/assistant.ts
-var getAgentGraph = async (request, reply) => {
-  try {
-    const { assistantId } = request.params;
-    const imageData = await draw_graph(assistantId);
-    reply.header("Content-Type", "application/json").send({
-      image: imageData
-    });
-  } catch (error) {
-    reply.status(500).send({
-      success: false,
-      error: error.message || "\u83B7\u53D6\u4EE3\u7406\u56FE\u8868\u5931\u8D25"
-    });
-  }
-};
-
 // src/controllers/agent_task.ts
 import { AgentManager } from "@axiom-lattice/core";
 var triggerAgentTask = async (request, reply) => {
@@ -545,6 +749,478 @@ var triggerAgentTask = async (request, reply) => {
   }
 };
 
+// src/stores/thread_store.ts
+var ThreadStore = class {
+  constructor() {
+    // Map<assistantId, Map<threadId, Thread>>
+    this.threads = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Get all threads for a specific assistant
+   */
+  getThreadsByAssistantId(assistantId) {
+    const assistantThreads = this.threads.get(assistantId);
+    if (!assistantThreads) {
+      return [];
+    }
+    return Array.from(assistantThreads.values());
+  }
+  /**
+   * Get a thread by ID for a specific assistant
+   */
+  getThreadById(assistantId, threadId) {
+    const assistantThreads = this.threads.get(assistantId);
+    if (!assistantThreads) {
+      return void 0;
+    }
+    return assistantThreads.get(threadId);
+  }
+  /**
+   * Create a new thread for an assistant
+   */
+  createThread(assistantId, threadId, data) {
+    const now = /* @__PURE__ */ new Date();
+    const thread = {
+      id: threadId,
+      assistantId,
+      metadata: data.metadata || {},
+      createdAt: now,
+      updatedAt: now
+    };
+    if (!this.threads.has(assistantId)) {
+      this.threads.set(assistantId, /* @__PURE__ */ new Map());
+    }
+    const assistantThreads = this.threads.get(assistantId);
+    assistantThreads.set(threadId, thread);
+    return thread;
+  }
+  /**
+   * Update an existing thread
+   */
+  updateThread(assistantId, threadId, updates) {
+    const assistantThreads = this.threads.get(assistantId);
+    if (!assistantThreads) {
+      return null;
+    }
+    const existing = assistantThreads.get(threadId);
+    if (!existing) {
+      return null;
+    }
+    const updated = {
+      ...existing,
+      metadata: {
+        ...existing.metadata,
+        ...updates.metadata || {}
+      },
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    assistantThreads.set(threadId, updated);
+    return updated;
+  }
+  /**
+   * Delete a thread by ID
+   */
+  deleteThread(assistantId, threadId) {
+    const assistantThreads = this.threads.get(assistantId);
+    if (!assistantThreads) {
+      return false;
+    }
+    return assistantThreads.delete(threadId);
+  }
+  /**
+   * Check if thread exists
+   */
+  hasThread(assistantId, threadId) {
+    const assistantThreads = this.threads.get(assistantId);
+    if (!assistantThreads) {
+      return false;
+    }
+    return assistantThreads.has(threadId);
+  }
+};
+var threadStore = new ThreadStore();
+
+// src/controllers/threads.ts
+import { randomUUID as randomUUID2 } from "crypto";
+async function getThreadList(request, reply) {
+  const { assistantId } = request.params;
+  const threads = threadStore.getThreadsByAssistantId(assistantId);
+  return {
+    success: true,
+    message: "Successfully retrieved thread list",
+    data: {
+      records: threads,
+      total: threads.length
+    }
+  };
+}
+async function getThread(request, reply) {
+  const { assistantId, threadId } = request.params;
+  const thread = threadStore.getThreadById(assistantId, threadId);
+  if (!thread) {
+    return reply.status(404).send({
+      success: false,
+      message: "Thread not found"
+    });
+  }
+  return {
+    success: true,
+    message: "Successfully retrieved thread",
+    data: thread
+  };
+}
+async function createThread(request, reply) {
+  const { assistantId } = request.params;
+  const data = request.body;
+  const threadId = randomUUID2();
+  const newThread = threadStore.createThread(assistantId, threadId, data);
+  return reply.status(201).send({
+    success: true,
+    message: "Successfully created thread",
+    data: newThread
+  });
+}
+async function updateThread(request, reply) {
+  const { assistantId, threadId } = request.params;
+  const updates = request.body;
+  if (!threadStore.hasThread(assistantId, threadId)) {
+    return reply.status(404).send({
+      success: false,
+      message: "Thread not found"
+    });
+  }
+  const updatedThread = threadStore.updateThread(
+    assistantId,
+    threadId,
+    updates
+  );
+  if (!updatedThread) {
+    return reply.status(500).send({
+      success: false,
+      message: "Failed to update thread"
+    });
+  }
+  return {
+    success: true,
+    message: "Successfully updated thread",
+    data: updatedThread
+  };
+}
+async function deleteThread(request, reply) {
+  const { assistantId, threadId } = request.params;
+  if (!threadStore.hasThread(assistantId, threadId)) {
+    return reply.status(404).send({
+      success: false,
+      message: "Thread not found"
+    });
+  }
+  const deleted = threadStore.deleteThread(assistantId, threadId);
+  if (!deleted) {
+    return reply.status(500).send({
+      success: false,
+      message: "Failed to delete thread"
+    });
+  }
+  return {
+    success: true,
+    message: "Successfully deleted thread"
+  };
+}
+
+// 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",
@@ -713,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) => {
@@ -748,6 +1495,11 @@ var registerLatticeRoutes = (app2) => {
     { schema: clearMemorySchema },
     clearMemory
   );
+  app2.get("/api/assistants", getAssistantList);
+  app2.get("/api/assistants/:id", getAssistant);
+  app2.post("/api/assistants", createAssistant);
+  app2.put("/api/assistants/:id", updateAssistant);
+  app2.delete("/api/assistants/:id", deleteAssistant);
   app2.get(
     "/api/assistants/:assistantId/graph",
     { schema: getAgentGraphSchema },
@@ -758,6 +1510,32 @@ var registerLatticeRoutes = (app2) => {
     { schema: triggerAgentTaskSchema },
     triggerAgentTask
   );
+  app2.get("/api/assistants/:assistantId/threads", getThreadList);
+  app2.get(
+    "/api/assistants/:assistantId/threads/:threadId",
+    getThread
+  );
+  app2.post("/api/assistants/:assistantId/threads", createThread);
+  app2.put(
+    "/api/assistants/:assistantId/threads/:threadId",
+    updateThread
+  );
+  app2.delete(
+    "/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
@@ -960,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) => {