@axiom-lattice/gateway 1.0.11

package/src/controllers/run.ts

@@ -0,0 +1,233 @@
+import { FastifyRequest, FastifyReply } from "fastify";
+import * as agentService from "../services/agent_service";
+import { CreateRunRequest } from "../types";
+import { v4 } from "uuid";
+
+// 创建运行
+export const createRun = async (
+  request: FastifyRequest,
+  reply: FastifyReply
+): Promise<void> => {
+  try {
+    const {
+      assistant_id,
+      thread_id,
+      command,
+      streaming,
+      background,
+      ...input
+    } = request.body as CreateRunRequest;
+
+    const tenant_id = request.headers["x-tenant-id"] as string;
+    const x_request_id = (request.headers["x-request-id"] as string) || v4();
+
+    // 验证请求数据
+    if (!assistant_id) {
+      reply.status(400).send({
+        success: false,
+        error: "助手ID是必需的",
+      });
+      return;
+    }
+
+    // 如果请求streaming，则agent_stream
+    if (streaming) {
+      // 开始运行
+      const stream = await agentService.agent_stream({
+        assistant_id: assistant_id,
+        input: input,
+        thread_id: thread_id,
+        command,
+        tenant_id: tenant_id,
+        run_id: x_request_id,
+      });
+
+      // 设置 SSE 响应头
+      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)}\n\n`);
+        }
+      } catch (error) {
+        //console.error("Stream processing error:", error);
+      } finally {
+        reply.raw.end();
+        // 通知 Fastify 我们将手动处理响应
+        return reply.hijack();
+      }
+    } else {
+      // 后台运行的情况
+      const result = await agentService.agent_invoke({
+        assistant_id: assistant_id,
+        input: input,
+        command: command,
+        thread_id: thread_id,
+        tenant_id: tenant_id,
+        run_id: x_request_id,
+      });
+      reply.status(200).send(result);
+    }
+  } catch (error: any) {
+    reply.status(500).send({
+      success: false,
+      error: `创建运行时发生错误: ${error.message}`,
+    });
+  }
+};
+
+// // 获取运行
+// export const getRun = async (
+//   request: FastifyRequest,
+//   reply: FastifyReply
+// ): Promise<void> => {
+//   try {
+//     const { id } = request.params as { id: string };
+
+//     if (!id) {
+//       reply.status(400).send({
+//         success: false,
+//         error: "运行ID是必需的",
+//       });
+//       return;
+//     }
+
+//     const result = await runModel.getRun(id);
+
+//     if (!result.success) {
+//       reply.status(404).send(result);
+//       return;
+//     }
+
+//     reply.send(result);
+//   } catch (error: any) {
+//     reply.status(500).send({
+//       success: false,
+//       error: `获取运行时发生错误: ${error.message}`,
+//     });
+//   }
+// };
+
+// // 获取助手的所有运行
+// export const getRunsByAssistant = async (
+//   request: FastifyRequest,
+//   reply: FastifyReply
+// ): Promise<void> => {
+//   try {
+//     const { assistantId } = request.params as { assistantId: string };
+
+//     if (!assistantId) {
+//       reply.status(400).send({
+//         success: false,
+//         error: "助手ID是必需的",
+//       });
+//       return;
+//     }
+
+//     const result = await runModel.getRunsByAssistant(assistantId);
+
+//     reply.send(result);
+//   } catch (error: any) {
+//     reply.status(500).send({
+//       success: false,
+//       error: `获取助手运行时发生错误: ${error.message}`,
+//     });
+//   }
+// };
+
+// // 取消运行
+// export const cancelRun = async (
+//   request: FastifyRequest,
+//   reply: FastifyReply
+// ): Promise<void> => {
+//   try {
+//     const { id } = request.params as { id: string };
+
+//     if (!id) {
+//       reply.status(400).send({
+//         success: false,
+//         error: "运行ID是必需的",
+//       });
+//       return;
+//     }
+
+//     const result = await runModel.updateRunStatus(id, RunStatus.CANCELLED);
+
+//     if (!result.success) {
+//       reply.status(404).send(result);
+//       return;
+//     }
+
+//     reply.send(result);
+//   } catch (error: any) {
+//     reply.status(500).send({
+//       success: false,
+//       error: `取消运行时发生错误: ${error.message}`,
+//     });
+//   }
+// };
+
+// // 添加消息
+// export const addMessage = async (
+//   request: FastifyRequest,
+//   reply: FastifyReply
+// ): Promise<void> => {
+//   try {
+//     const data = request.body as AddMessageRequest;
+
+//     // 验证请求数据
+//     if (!data.runId || !data.role || !data.content) {
+//       reply.status(400).send({
+//         success: false,
+//         error: "运行ID、角色和内容是必需的",
+//       });
+//       return;
+//     }
+
+//     const result = await messageModel.addMessage(data);
+
+//     if (!result.success) {
+//       reply.status(500).send(result);
+//       return;
+//     }
+
+//     reply.status(201).send(result);
+//   } catch (error: any) {
+//     reply.status(500).send({
+//       success: false,
+//       error: `添加消息时发生错误: ${error.message}`,
+//     });
+//   }
+// };
+
+// // 获取运行的所有消息
+// export const getMessages = async (
+//   request: FastifyRequest,
+//   reply: FastifyReply
+// ): Promise<void> => {
+//   try {
+//     const { runId } = request.params as { runId: string };
+
+//     if (!runId) {
+//       reply.status(400).send({
+//         success: false,
+//         error: "运行ID是必需的",
+//       });
+//       return;
+//     }
+
+//     const result = await messageModel.getMessagesByRun(runId);
+
+//     reply.send(result);
+//   } catch (error: any) {
+//     reply.status(500).send({
+//       success: false,
+//       error: `获取消息时发生错误: ${error.message}`,
+//     });
+//   }
+// };

package/src/index.ts

@@ -0,0 +1,101 @@
+import fastify from "fastify";
+import cors from "@fastify/cors";
+import sensible from "@fastify/sensible";
+import { registerRoutes } from "./routes";
+// 导入自定义 Logger 类
+import { Logger } from "./logger/Logger";
+
+process.on("unhandledRejection", (reason, promise) => {
+  console.error("未处理的Promise拒绝:", reason);
+  // 可以在这里进行日志记录或其他处理
+});
+
+// 创建自定义日志记录器
+const logger = new Logger({
+  serviceName: "lattice-gateway",
+  name: "fastify-server",
+});
+
+// 创建 Fastify 应用
+const 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();
+});
+
+// cors
+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(
+    `请求错误: ${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 || "服务器内部错误",
+  });
+});
+
+// 将日志记录器添加到应用实例中，以便在路由中使用
+app.decorate("logger", logger);
+
+// 注册路由
+registerRoutes(app);
+
+// 启动服务器
+const start = async ({ port }: { port: number }) => {
+  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);
+  }
+};
+
+const LatticeGateway = {
+  startAsHttpEndpoint: start,
+  app,
+};
+
+export { LatticeGateway };

package/src/logger/Logger.ts

@@ -0,0 +1,186 @@
+import pino from "pino";
+import "pino-pretty";
+import "pino-roll";
+import { AsyncLocalStorage } from "async_hooks";
+
+export interface LoggerContext {
+  "x-user-id"?: string;
+  "x-tenant-id"?: string;
+  "x-request-id"?: string;
+  "x-task-id"?: string;
+  "x-thread-id"?: string;
+}
+
+export interface LoggerOptions {
+  name?: string;
+  serviceName?: string;
+  context?: LoggerContext;
+}
+
+/**
+ * 单例的Pino日志工厂类，管理底层pino实例
+ */
+class PinoLoggerFactory {
+  private static instance: PinoLoggerFactory;
+  private pinoLogger: pino.Logger;
+
+  private constructor() {
+    const isProd = process.env.NODE_ENV === "production";
+
+    const loggerConfig: pino.LoggerOptions = {
+      // 自定义时间戳格式
+      timestamp: () => `,"@timestamp":"${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 * 1000,
+          };
+        },
+      },
+    };
+
+    // 生产环境使用文件日志
+    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(
+          "无法初始化 pino-roll 日志记录器，回退到控制台日志",
+          error
+        );
+        // 回退到开发环境的配置
+        this.pinoLogger = pino({
+          ...loggerConfig,
+          transport: {
+            target: "pino-pretty",
+            options: {
+              colorize: true,
+            },
+          },
+        });
+      }
+    } else {
+      // 开发环境使用格式化输出
+      this.pinoLogger = pino({
+        ...loggerConfig,
+        transport: {
+          target: "pino-pretty",
+          options: {
+            colorize: true,
+          },
+        },
+      });
+    }
+  }
+
+  public static getInstance(): PinoLoggerFactory {
+    if (!PinoLoggerFactory.instance) {
+      PinoLoggerFactory.instance = new PinoLoggerFactory();
+    }
+    return PinoLoggerFactory.instance;
+  }
+
+  public getPinoLogger(): pino.Logger {
+    return this.pinoLogger;
+  }
+}
+
+/**
+ * Logger类，可以创建多个实例，每个实例有自己的上下文
+ */
+export class Logger {
+  private context: LoggerContext;
+  private name: string;
+  private serviceName: string;
+
+  constructor(options?: LoggerOptions) {
+    this.context = options?.context || {};
+    this.name = options?.name || "lattice-graph-logger";
+    this.serviceName = options?.serviceName || "lattice/graph-server";
+  }
+
+  /**
+   * 获取合并了上下文的日志对象
+   * @param additionalContext 额外的上下文数据
+   * @returns 带有上下文的pino日志对象
+   */
+  private getContextualLogger(additionalContext?: object): pino.Logger {
+    const pinoLogger = PinoLoggerFactory.getInstance().getPinoLogger();
+
+    // 合并Logger实例的上下文和额外上下文
+    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: string, obj?: object): void {
+    this.getContextualLogger(obj).info(msg);
+  }
+
+  error(msg: string, obj?: object | Error): void {
+    this.getContextualLogger(obj).error(msg);
+  }
+
+  warn(msg: string, obj?: object): void {
+    this.getContextualLogger(obj).warn(msg);
+  }
+
+  debug(msg: string, obj?: object): void {
+    this.getContextualLogger(obj).debug(msg);
+  }
+
+  /**
+   * 更新Logger实例的上下文
+   */
+  updateContext(context: Partial<LoggerContext>): void {
+    this.context = {
+      ...this.context,
+      ...context,
+    };
+  }
+
+  /**
+   * 创建一个新的Logger实例，继承当前Logger的上下文
+   */
+  child(options: Partial<LoggerOptions>): Logger {
+    return new Logger({
+      name: options.name || this.name,
+      serviceName: options.serviceName || this.serviceName,
+      context: {
+        ...this.context,
+        ...options.context,
+      },
+    });
+  }
+}

package/src/routes/index.ts

@@ -0,0 +1,70 @@
+import { FastifyInstance } from "fastify";
+//import * as assistantController from "../controllers/assistant";
+import * as runController from "../controllers/run";
+import * as memoryController from "../controllers/memory";
+import * as graphController from "../controllers/assistant";
+
+export const registerRoutes = (app: FastifyInstance): void => {
+  // 运行路由
+  app.post<{
+    Body: any;
+  }>("/api/runs", runController.createRun);
+
+  // app.get<{
+  //   Params: { id: string };
+  // }>("/api/runs/:id", runController.getRun);
+
+  // app.get<{
+  //   Params: { assistantId: string };
+  // }>("/api/assistants/:assistantId/runs", runController.getRunsByAssistant);
+
+  // app.post<{
+  //   Params: { id: string };
+  // }>("/api/runs/:id/cancel", runController.cancelRun);
+
+  // 内存路由
+  app.get<{
+    Params: { assistantId: string; thread_id: string };
+  }>(
+    "/api/assistants/:assistantId/:thread_id/memory",
+    memoryController.getAllMemoryItems
+  );
+
+  app.get<{
+    Params: { assistantId: string; thread_id: string };
+  }>(
+    "/api/assistants/:assistantId/:thread_id/state",
+    memoryController.getAgentState
+  );
+
+  app.get<{
+    Params: { assistantId: string; key: string };
+  }>(
+    "/api/assistants/:assistantId/memory/:key",
+    memoryController.getMemoryItem
+  );
+
+  app.put<{
+    Params: { assistantId: string; key: string };
+    Body: any;
+  }>(
+    "/api/assistants/:assistantId/memory/:key",
+    memoryController.setMemoryItem
+  );
+
+  app.delete<{
+    Params: { assistantId: string; key: string };
+  }>(
+    "/api/assistants/:assistantId/memory/:key",
+    memoryController.deleteMemoryItem
+  );
+
+  app.delete<{
+    Params: { assistantId: string };
+  }>("/api/assistants/:assistantId/memory", memoryController.clearMemory);
+
+  // 图表路由
+  app.get<{
+    Params: { assistantId: string };
+  }>("/api/assistants/:assistantId/graph", graphController.getAgentGraph);
+};

package/src/services/AgentManager.ts

@@ -0,0 +1,42 @@
+import { AGENT_TASK_EVENT } from "./agent_task_types";
+import eventBus from "./event_bus";
+
+export class AgentManager {
+  private static instance: AgentManager;
+  private constructor() {}
+  private agents: { name: string; agent: any }[] = [];
+  public static getInstance(): AgentManager {
+    if (!AgentManager.instance) {
+      AgentManager.instance = new AgentManager();
+    }
+    return AgentManager.instance;
+  }
+  callAgentInQueue(queue: {
+    assistant_id: string;
+    input: any;
+    thread_id: string;
+    "x-tenant-id": number;
+  }) {
+    return new Promise((resolve, reject) => {
+      const callback_event = `${queue.assistant_id}::${queue.thread_id}`;
+      eventBus.subscribeOnce(callback_event, (data) => {
+        if (data.success) {
+          console.log("AgentManager callAgentInQueue success", data);
+          resolve(data.result);
+        } else {
+          console.log("AgentManager callAgentInQueue error", data);
+          reject(data.error);
+        }
+      });
+      eventBus.publish(
+        AGENT_TASK_EVENT,
+        {
+          ...queue,
+          thread_id: callback_event,
+          callback_event,
+        },
+        true
+      );
+    });
+  }
+}