@axiom-lattice/gateway 2.1.11 → 2.1.12

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @axiom-lattice/gateway@2.1.11 build /home/runner/work/agentic/agentic/packages/gateway
+> @axiom-lattice/gateway@2.1.12 build /home/runner/work/agentic/agentic/packages/gateway
 > tsup src/index.ts --format cjs,esm --dts --clean --sourcemap
 
 CLI Building entry: src/index.ts
@@ -9,13 +9,13 @@
 CLI Cleaning output folder
 CJS Build start
 ESM Build start
-CJS dist/index.js     38.70 KB
-CJS dist/index.js.map 76.28 KB
-CJS ⚡️ Build success in 134ms
-ESM dist/index.mjs     36.46 KB
-ESM dist/index.mjs.map 76.20 KB
-ESM ⚡️ Build success in 134ms
+ESM dist/index.mjs     46.92 KB
+ESM dist/index.mjs.map 100.58 KB
+ESM ⚡️ Build success in 131ms
+CJS dist/index.js     49.24 KB
+CJS dist/index.js.map 100.67 KB
+CJS ⚡️ Build success in 131ms
 DTS Build start
-DTS ⚡️ Build success in 6556ms
+DTS ⚡️ Build success in 7072ms
 DTS dist/index.d.ts  3.32 KB
 DTS dist/index.d.mts 3.32 KB

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @axiom-lattice/gateway
 
+## 2.1.12
+
+### Patch Changes
+
+- 2d9f075: lattice app
+
 ## 2.1.11
 
 ### Patch Changes

package/dist/index.js

@@ -248,6 +248,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
+var import_crypto = require("crypto");
+var import_core2 = require("@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 (0, import_core2.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 (0, import_core2.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 = (0, import_crypto.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 (0, import_core2.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 (0, import_core2.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
 var import_uuid2 = require("uuid");
 var createRun = async (request, reply) => {
@@ -515,24 +735,8 @@ 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
-var import_core2 = require("@axiom-lattice/core");
+var import_core3 = require("@axiom-lattice/core");
 var triggerAgentTask = async (request, reply) => {
   try {
     const { assistant_id, thread_id, input, command } = request.body;
@@ -551,7 +755,7 @@ var triggerAgentTask = async (request, reply) => {
       });
       return;
     }
-    const agentManager = import_core2.AgentManager.getInstance();
+    const agentManager = import_core3.AgentManager.getInstance();
     const result = await agentManager.callAgentInQueue({
       assistant_id,
       thread_id,
@@ -570,6 +774,184 @@ 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
+var import_crypto2 = require("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 = (0, import_crypto2.randomUUID)();
+  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/schemas/index.ts
 var getAllMemoryItemsSchema = {
   description: "Get all memory items for an assistant thread",
@@ -773,6 +1155,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 },
@@ -783,6 +1170,20 @@ 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
+  );
 };
 
 // src/logger/Logger.ts
@@ -986,7 +1387,7 @@ var configureSwagger = async (app2, customSwaggerConfig, customSwaggerUiConfig)
 };
 
 // src/services/queue_service.ts
-var import_core3 = require("@axiom-lattice/core");
+var import_core4 = require("@axiom-lattice/core");
 var import_protocols = require("@axiom-lattice/protocols");
 var import_queue_redis = require("@axiom-lattice/queue-redis");
 var DEFAULT_QUEUE_KEY = "default";
@@ -1005,8 +1406,8 @@ var setQueueServiceType = (type) => {
       redisPassword: process.env.REDIS_PASSWORD
     } : void 0
   };
-  if (import_core3.queueLatticeManager.hasLattice(DEFAULT_QUEUE_KEY)) {
-    import_core3.queueLatticeManager.removeLattice(DEFAULT_QUEUE_KEY);
+  if (import_core4.queueLatticeManager.hasLattice(DEFAULT_QUEUE_KEY)) {
+    import_core4.queueLatticeManager.removeLattice(DEFAULT_QUEUE_KEY);
   }
   let client;
   if (type === "redis") {
@@ -1015,13 +1416,13 @@ var setQueueServiceType = (type) => {
       redisPassword: process.env.REDIS_PASSWORD
     });
   }
-  (0, import_core3.registerQueueLattice)(DEFAULT_QUEUE_KEY, config, client);
+  (0, import_core4.registerQueueLattice)(DEFAULT_QUEUE_KEY, config, client);
 };
 var getQueueService = () => {
-  if (!import_core3.queueLatticeManager.hasLattice(DEFAULT_QUEUE_KEY)) {
+  if (!import_core4.queueLatticeManager.hasLattice(DEFAULT_QUEUE_KEY)) {
     setQueueServiceType(queueServiceType);
   }
-  return (0, import_core3.getQueueLattice)(DEFAULT_QUEUE_KEY);
+  return (0, import_core4.getQueueLattice)(DEFAULT_QUEUE_KEY);
 };
 var popAgentTaskFromQueue = async () => {
   const queue = getQueueService();
@@ -1030,7 +1431,7 @@ var popAgentTaskFromQueue = async () => {
 };
 
 // src/services/agent_task_consumer.ts
-var import_core4 = require("@axiom-lattice/core");
+var import_core5 = require("@axiom-lattice/core");
 var handleAgentTask = async (taskRequest, retryCount = 0) => {
   const {
     assistant_id,
@@ -1094,7 +1495,7 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
       }
       if (callback_event) {
         const state = await agent_state({ assistant_id, thread_id });
-        import_core4.eventBus.publish(callback_event, {
+        import_core5.eventBus.publish(callback_event, {
           success: true,
           state,
           config: { assistant_id, thread_id, tenant_id }
@@ -1108,7 +1509,7 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
       await response.text();
       if (callback_event) {
         const state = await agent_state({ assistant_id, thread_id });
-        import_core4.eventBus.publish(callback_event, {
+        import_core5.eventBus.publish(callback_event, {
           success: true,
           state,
           config: { assistant_id, thread_id, tenant_id }
@@ -1135,7 +1536,7 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
       return handleAgentTask(taskRequest, nextRetryCount);
     }
     if (callback_event) {
-      import_core4.eventBus.publish(callback_event, {
+      import_core5.eventBus.publish(callback_event, {
         success: false,
         error: error instanceof Error ? error.message : String(error),
         config: { assistant_id, thread_id, tenant_id }
@@ -1173,7 +1574,7 @@ var _AgentTaskConsumer = class _AgentTaskConsumer {
    * 初始化事件监听和队列轮询
    */
   initialize() {
-    import_core4.eventBus.subscribe(import_core4.AGENT_TASK_EVENT, this.trigger_agent_task.bind(this));
+    import_core5.eventBus.subscribe(import_core5.AGENT_TASK_EVENT, this.trigger_agent_task.bind(this));
     this.startPollingQueue();
     console.log("Agent\u4EFB\u52A1\u6D88\u8D39\u8005\u5DF2\u542F\u52A8\u5E76\u76D1\u542C\u4EFB\u52A1\u4E8B\u4EF6\u548C\u961F\u5217");
   }
@@ -1292,7 +1693,7 @@ var _AgentTaskConsumer = class _AgentTaskConsumer {
     handleAgentTask(taskRequest).catch((error) => {
       console.error("\u5904\u7406Agent\u4EFB\u52A1\u65F6\u53D1\u751F\u672A\u6355\u83B7\u7684\u9519\u8BEF:", error);
       if (taskRequest.callback_event) {
-        import_core4.eventBus.publish(taskRequest.callback_event, {
+        import_core5.eventBus.publish(taskRequest.callback_event, {
           success: false,
           error: error instanceof Error ? error.message : String(error),
           config: {