@axiom-lattice/gateway 1.0.11

package/dist/index.mjs

@@ -0,0 +1,659 @@
+// src/index.ts
+import fastify from "fastify";
+import cors from "@fastify/cors";
+import sensible from "@fastify/sensible";
+
+// src/services/agent_service.ts
+import {
+  filterMessages,
+  HumanMessage
+} from "@langchain/core/messages";
+import { Command } from "@langchain/langgraph";
+import { v4 } from "uuid";
+import { getAgentClient, getAgentLattice } from "@axiom-lattice/core";
+async function agent_invoke({
+  input,
+  thread_id,
+  assistant_id,
+  tenant_id,
+  command,
+  run_id
+}) {
+  const runnable_agent = getAgentLattice(assistant_id)?.client;
+  const { files, message, ...rest } = input;
+  const humanMessage = new HumanMessage(message || "");
+  humanMessage.additional_kwargs = { files };
+  const messages = [humanMessage];
+  if (!runnable_agent) {
+    throw new Error(`Agent ${assistant_id} not found`);
+  }
+  const result = await runnable_agent.invoke(
+    command ? new Command(command) : { ...rest, messages, "x-tenant-id": tenant_id },
+    {
+      configurable: {
+        thread_id,
+        run_id: run_id || v4(),
+        recursionLimit: 200,
+        "x-tenant-id": tenant_id,
+        "x-request-id": run_id,
+        "x-thread-id": thread_id
+      }
+    }
+  );
+  return result;
+}
+async function agent_stream({
+  input,
+  thread_id,
+  command,
+  tenant_id,
+  assistant_id,
+  run_id
+}) {
+  const runnable_agent = getAgentClient(assistant_id);
+  const { files, message, ...rest } = input;
+  let messages = [];
+  if (!command) {
+    const humanMessage = new HumanMessage(message);
+    humanMessage.additional_kwargs = { files };
+    messages = [humanMessage];
+  }
+  try {
+    if (!runnable_agent) {
+      throw new Error(`Agent ${assistant_id} not found`);
+    }
+    const agentStream = await runnable_agent.stream(
+      command ? new Command(command) : {
+        ...rest,
+        messages,
+        "x-tenant-id": tenant_id
+      },
+      {
+        configurable: {
+          thread_id,
+          run_id: run_id || v4(),
+          "x-tenant-id": tenant_id,
+          "x-request-id": run_id,
+          "x-thread-id": thread_id
+        },
+        streamMode: ["updates", "messages"],
+        subgraphs: false
+      }
+    );
+    return {
+      [Symbol.asyncIterator]: async function* () {
+        try {
+          for await (const chunk of agentStream) {
+            let data;
+            if (chunk[0] === "updates") {
+              const update = chunk[1];
+              const values = Object.values(update);
+              const messages2 = values[0].messages;
+              if (messages2?.[0]?.tool_call_id) {
+                data = messages2[0].toDict();
+              }
+            } else if (chunk[0] === "messages") {
+              const messages2 = chunk[1];
+              data = messages2?.[0]?.toDict();
+            }
+            if (chunk?.[1]?.__interrupt__) {
+              data = chunk?.[1]?.[0]?.toDict();
+            }
+            if (data) {
+              yield data;
+            }
+          }
+        } catch (error) {
+          console.error("Stream error:", error);
+          throw error;
+        }
+      }
+    };
+  } catch (error) {
+    throw error;
+  }
+}
+async function agent_state({
+  thread_id,
+  assistant_id
+}) {
+  const runnable_agent = getAgentClient(assistant_id);
+  if (!runnable_agent) {
+    throw new Error(`Agent ${assistant_id} not found`);
+  }
+  const state = await runnable_agent.getState({
+    configurable: { thread_id, subgraphs: false }
+  });
+  return state;
+}
+async function agent_messages({
+  thread_id,
+  tenant_id,
+  assistant_id
+}) {
+  const runnable_agent = getAgentClient(assistant_id);
+  if (!runnable_agent) {
+    throw new Error(`Agent ${assistant_id} not found`);
+  }
+  const state = await runnable_agent.getState({
+    configurable: { thread_id, subgraphs: false }
+  });
+  const messages = state.values.messages || [];
+  const filteredMessages = filterMessages(messages, {
+    includeTypes: ["ai", "human", "tool"]
+    //["human", "ai", "tool"],
+  });
+  let messagesArray = filteredMessages.map((message) => ({
+    id: message.id,
+    role: message.getType(),
+    content: message.content,
+    files: message.additional_kwargs.files,
+    ...message.lc_kwargs
+  }));
+  const action_messages = state.tasks.flatMap((task) => {
+    return task.interrupts.map((interrupt) => {
+      return {
+        role: "ai",
+        content: interrupt.value,
+        type: "action"
+      };
+    });
+  });
+  const new_messages = [...messagesArray, ...action_messages];
+  return new_messages;
+}
+async function draw_graph(assistant_id) {
+  const runnable_agent = getAgentClient(assistant_id);
+  if (!runnable_agent) {
+    throw new Error(`Agent ${assistant_id} not found`);
+  }
+  const drawableGraph = await runnable_agent.getGraphAsync();
+  const image = await drawableGraph.drawMermaid();
+  return image;
+}
+
+// src/controllers/run.ts
+import { v4 as v42 } from "uuid";
+var createRun = async (request, reply) => {
+  try {
+    const {
+      assistant_id,
+      thread_id,
+      command,
+      streaming,
+      background,
+      ...input
+    } = request.body;
+    const tenant_id = request.headers["x-tenant-id"];
+    const x_request_id = request.headers["x-request-id"] || v42();
+    if (!assistant_id) {
+      reply.status(400).send({
+        success: false,
+        error: "\u52A9\u624BID\u662F\u5FC5\u9700\u7684"
+      });
+      return;
+    }
+    if (streaming) {
+      const stream = await agent_stream({
+        assistant_id,
+        input,
+        thread_id,
+        command,
+        tenant_id,
+        run_id: x_request_id
+      });
+      reply.raw.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+        "Access-Control-Allow-Origin": "*"
+      });
+      try {
+        for await (const chunk of stream) {
+          reply.raw.write(`data: ${JSON.stringify(chunk)}
+
+`);
+        }
+      } catch (error) {
+      } finally {
+        reply.raw.end();
+        return reply.hijack();
+      }
+    } else {
+      const result = await agent_invoke({
+        assistant_id,
+        input,
+        command,
+        thread_id,
+        tenant_id,
+        run_id: x_request_id
+      });
+      reply.status(200).send(result);
+    }
+  } catch (error) {
+    reply.status(500).send({
+      success: false,
+      error: `\u521B\u5EFA\u8FD0\u884C\u65F6\u53D1\u751F\u9519\u8BEF: ${error.message}`
+    });
+  }
+};
+
+// src/controllers/memory.ts
+var setMemoryItem = async (request, reply) => {
+  try {
+    const { assistantId, key } = request.params;
+    const value = request.body;
+    if (!assistantId || !key) {
+      reply.status(400).send({
+        success: false,
+        error: "\u52A9\u624BID\u548C\u952E\u662F\u5FC5\u9700\u7684"
+      });
+      return;
+    }
+    if (value === void 0) {
+      reply.status(400).send({
+        success: false,
+        error: "\u503C\u662F\u5FC5\u9700\u7684"
+      });
+      return;
+    }
+    reply.status(500).send();
+    return;
+  } catch (error) {
+    reply.status(500).send({
+      success: false,
+      error: `\u8BBE\u7F6E\u5185\u5B58\u9879\u65F6\u53D1\u751F\u9519\u8BEF: ${error.message}`
+    });
+  }
+};
+var getMemoryItem = async (request, reply) => {
+  try {
+    const { assistantId, key } = request.params;
+    if (!assistantId || !key) {
+      reply.status(400).send({
+        success: false,
+        error: "\u52A9\u624BID\u548C\u952E\u662F\u5FC5\u9700\u7684"
+      });
+      return;
+    }
+    reply.status(404).send();
+    return;
+  } catch (error) {
+    reply.status(500).send({
+      success: false,
+      error: `\u83B7\u53D6\u5185\u5B58\u9879\u65F6\u53D1\u751F\u9519\u8BEF: ${error.message}`
+    });
+  }
+};
+var getAllMemoryItems = async (request, reply) => {
+  try {
+    const { assistantId, thread_id } = request.params;
+    const tenant_id = request.headers["x-tenant-id"];
+    if (!thread_id) {
+      reply.status(400).send({
+        success: false,
+        error: "\u7EBF\u7A0BID\u662F\u5FC5\u9700\u7684"
+      });
+      return;
+    }
+    if (!assistantId) {
+      reply.status(400).send({
+        success: false,
+        error: "\u52A9\u624BID\u662F\u5FC5\u9700\u7684"
+      });
+      return;
+    }
+    const result = await agent_messages({
+      assistant_id: assistantId,
+      thread_id,
+      tenant_id
+    });
+    if (!result) {
+      reply.status(500).send(result);
+      return;
+    }
+    reply.send(result);
+  } catch (error) {
+    reply.status(500).send({
+      success: false,
+      error: `\u83B7\u53D6\u6240\u6709\u5185\u5B58\u9879\u65F6\u53D1\u751F\u9519\u8BEF: ${error.message}`
+    });
+  }
+};
+var getAgentState = async (request, reply) => {
+  try {
+    const { assistantId, thread_id } = request.params;
+    if (!thread_id) {
+      reply.status(400).send({
+        success: false,
+        error: "\u7EBF\u7A0BID\u662F\u5FC5\u9700\u7684"
+      });
+      return;
+    }
+    if (!assistantId) {
+      reply.status(400).send({
+        success: false,
+        error: "\u52A9\u624BID\u662F\u5FC5\u9700\u7684"
+      });
+      return;
+    }
+    const result = await agent_state({
+      assistant_id: assistantId,
+      thread_id
+    });
+    if (!result) {
+      reply.status(500).send(result);
+      return;
+    }
+    reply.send(result);
+  } catch (error) {
+    reply.status(500).send({
+      success: false,
+      error: `\u83B7\u53D6\u52A9\u624B\u72B6\u6001\u65F6\u53D1\u751F\u9519\u8BEF: ${error.message}`
+    });
+  }
+};
+var deleteMemoryItem = async (request, reply) => {
+  try {
+    const { assistantId, key } = request.params;
+    if (!assistantId || !key) {
+      reply.status(400).send({
+        success: false,
+        error: "\u52A9\u624BID\u548C\u952E\u662F\u5FC5\u9700\u7684"
+      });
+      return;
+    }
+    reply.status(500).send();
+    return;
+    reply.status(204).send();
+  } catch (error) {
+    reply.status(500).send({
+      success: false,
+      error: `\u5220\u9664\u5185\u5B58\u9879\u65F6\u53D1\u751F\u9519\u8BEF: ${error.message}`
+    });
+  }
+};
+var clearMemory = async (request, reply) => {
+  try {
+    const { assistantId } = request.params;
+    if (!assistantId) {
+      reply.status(400).send({
+        success: false,
+        error: "\u52A9\u624BID\u662F\u5FC5\u9700\u7684"
+      });
+      return;
+    }
+    let result;
+    if (!result.success) {
+      reply.status(500).send(result);
+      return;
+    }
+    reply.status(204).send();
+  } catch (error) {
+    reply.status(500).send({
+      success: false,
+      error: `\u6E05\u9664\u5185\u5B58\u65F6\u53D1\u751F\u9519\u8BEF: ${error.message}`
+    });
+  }
+};
+
+// 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/routes/index.ts
+var registerRoutes = (app2) => {
+  app2.post("/api/runs", createRun);
+  app2.get(
+    "/api/assistants/:assistantId/:thread_id/memory",
+    getAllMemoryItems
+  );
+  app2.get(
+    "/api/assistants/:assistantId/:thread_id/state",
+    getAgentState
+  );
+  app2.get(
+    "/api/assistants/:assistantId/memory/:key",
+    getMemoryItem
+  );
+  app2.put(
+    "/api/assistants/:assistantId/memory/:key",
+    setMemoryItem
+  );
+  app2.delete(
+    "/api/assistants/:assistantId/memory/:key",
+    deleteMemoryItem
+  );
+  app2.delete("/api/assistants/:assistantId/memory", clearMemory);
+  app2.get("/api/assistants/:assistantId/graph", getAgentGraph);
+};
+
+// src/logger/Logger.ts
+import pino from "pino";
+import "pino-pretty";
+import "pino-roll";
+var PinoLoggerFactory = class _PinoLoggerFactory {
+  constructor() {
+    const isProd = process.env.NODE_ENV === "production";
+    const loggerConfig = {
+      // 自定义时间戳格式
+      timestamp: () => `,"@timestamp":"${(/* @__PURE__ */ new Date()).toISOString()}"`,
+      // 关闭默认的时间戳键
+      base: {
+        "@version": "1",
+        app_name: "lattice",
+        service_name: "lattice/graph-server",
+        thread_name: "main",
+        logger_name: "lattice-graph-logger"
+      },
+      formatters: {
+        level: (label, number) => {
+          return {
+            level: label.toUpperCase(),
+            level_value: number * 1e3
+          };
+        }
+      }
+    };
+    if (isProd) {
+      try {
+        this.pinoLogger = pino(
+          loggerConfig,
+          pino.transport({
+            target: "pino-roll",
+            options: {
+              file: "./logs/fin_ai_graph_server",
+              frequency: "daily",
+              mkdir: true
+            }
+          })
+        );
+      } catch (error) {
+        console.error(
+          "\u65E0\u6CD5\u521D\u59CB\u5316 pino-roll \u65E5\u5FD7\u8BB0\u5F55\u5668\uFF0C\u56DE\u9000\u5230\u63A7\u5236\u53F0\u65E5\u5FD7",
+          error
+        );
+        this.pinoLogger = pino({
+          ...loggerConfig,
+          transport: {
+            target: "pino-pretty",
+            options: {
+              colorize: true
+            }
+          }
+        });
+      }
+    } else {
+      this.pinoLogger = pino({
+        ...loggerConfig,
+        transport: {
+          target: "pino-pretty",
+          options: {
+            colorize: true
+          }
+        }
+      });
+    }
+  }
+  static getInstance() {
+    if (!_PinoLoggerFactory.instance) {
+      _PinoLoggerFactory.instance = new _PinoLoggerFactory();
+    }
+    return _PinoLoggerFactory.instance;
+  }
+  getPinoLogger() {
+    return this.pinoLogger;
+  }
+};
+var Logger = class _Logger {
+  constructor(options) {
+    this.context = options?.context || {};
+    this.name = options?.name || "lattice-graph-logger";
+    this.serviceName = options?.serviceName || "lattice/graph-server";
+  }
+  /**
+   * 获取合并了上下文的日志对象
+   * @param additionalContext 额外的上下文数据
+   * @returns 带有上下文的pino日志对象
+   */
+  getContextualLogger(additionalContext) {
+    const pinoLogger = PinoLoggerFactory.getInstance().getPinoLogger();
+    const contextObj = {
+      "x-user-id": this.context["x-user-id"] || "",
+      "x-tenant-id": this.context["x-tenant-id"] || "",
+      "x-request-id": this.context["x-request-id"] || "",
+      "x-task-id": this.context["x-task-id"] || "",
+      "x-thread-id": this.context["x-thread-id"] || "",
+      service_name: this.serviceName,
+      logger_name: this.name,
+      ...additionalContext
+    };
+    return pinoLogger.child(contextObj);
+  }
+  info(msg, obj) {
+    this.getContextualLogger(obj).info(msg);
+  }
+  error(msg, obj) {
+    this.getContextualLogger(obj).error(msg);
+  }
+  warn(msg, obj) {
+    this.getContextualLogger(obj).warn(msg);
+  }
+  debug(msg, obj) {
+    this.getContextualLogger(obj).debug(msg);
+  }
+  /**
+   * 更新Logger实例的上下文
+   */
+  updateContext(context) {
+    this.context = {
+      ...this.context,
+      ...context
+    };
+  }
+  /**
+   * 创建一个新的Logger实例，继承当前Logger的上下文
+   */
+  child(options) {
+    return new _Logger({
+      name: options.name || this.name,
+      serviceName: options.serviceName || this.serviceName,
+      context: {
+        ...this.context,
+        ...options.context
+      }
+    });
+  }
+};
+
+// src/index.ts
+process.on("unhandledRejection", (reason, promise) => {
+  console.error("\u672A\u5904\u7406\u7684Promise\u62D2\u7EDD:", reason);
+});
+var logger = new Logger({
+  serviceName: "lattice-gateway",
+  name: "fastify-server"
+});
+var app = fastify({
+  logger: false
+  // 禁用内置日志记录器
+});
+app.addHook("onRequest", (request, reply, done) => {
+  const context = {
+    "x-tenant-id": request.headers["x-tenant-id"],
+    "x-request-id": request.headers["x-request-id"]
+  };
+  done();
+});
+app.addHook("onResponse", (request, reply, done) => {
+  const context = {
+    "x-tenant-id": request.headers["x-tenant-id"],
+    "x-request-id": request.headers["x-request-id"]
+  };
+  done();
+});
+app.register(cors, {
+  origin: true,
+  methods: ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+  allowedHeaders: [
+    "Content-Type",
+    "Authorization",
+    "X-Requested-With",
+    "x-tenant-id",
+    "x-request-id"
+  ],
+  exposedHeaders: ["Content-Type"],
+  credentials: true
+});
+app.register(sensible);
+app.setErrorHandler((error, request, reply) => {
+  const context = {
+    "x-tenant-id": request.headers["x-tenant-id"],
+    "x-request-id": request.headers["x-request-id"]
+  };
+  logger.error(
+    `\u8BF7\u6C42\u9519\u8BEF: ${request.method} ${request.url} error:${error.message}`,
+    {
+      ...context,
+      error: error.message,
+      stack: error.stack,
+      statusCode: error.statusCode || 500
+    }
+  );
+  reply.status(error.statusCode || 500).send({
+    success: false,
+    error: error.message || "\u670D\u52A1\u5668\u5185\u90E8\u9519\u8BEF"
+  });
+});
+app.decorate("logger", logger);
+registerRoutes(app);
+var start = async ({ port }) => {
+  try {
+    const target_port = port || Number(process.env.PORT) || 4001;
+    await app.listen({ port: target_port, host: "0.0.0.0" });
+    logger.info(`Lattice Gateway is running on port: ${port}`);
+  } catch (err) {
+    logger.error("Server start failed", { error: err });
+    process.exit(1);
+  }
+};
+var LatticeGateway = {
+  startAsHttpEndpoint: start,
+  app
+};
+export {
+  LatticeGateway
+};
+//# sourceMappingURL=index.mjs.map