@axiom-lattice/gateway 2.1.19 → 2.1.21

package/dist/index.mjs

@@ -1319,6 +1319,311 @@ async function getHealth(request, reply) {
   }
 }
 
+// src/controllers/skills.ts
+import { getStoreLattice as getStoreLattice3 } from "@axiom-lattice/core";
+import { validateSkillName } from "@axiom-lattice/core";
+function serializeSkill(skill) {
+  const serialized = {
+    id: skill.id,
+    name: skill.name,
+    description: skill.description,
+    license: skill.license,
+    compatibility: skill.compatibility,
+    metadata: skill.metadata || {},
+    content: skill.content,
+    subSkills: skill.subSkills,
+    createdAt: skill.createdAt instanceof Date ? skill.createdAt.toISOString() : skill.createdAt ? new Date(skill.createdAt).toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: skill.updatedAt instanceof Date ? skill.updatedAt.toISOString() : skill.updatedAt ? new Date(skill.updatedAt).toISOString() : (/* @__PURE__ */ new Date()).toISOString()
+  };
+  Object.keys(serialized).forEach((key) => {
+    if (serialized[key] === void 0) {
+      delete serialized[key];
+    }
+  });
+  return serialized;
+}
+async function getSkillList(request, reply) {
+  try {
+    const storeLattice = getStoreLattice3("default", "skill");
+    const skillStore = storeLattice.store;
+    const skills = await skillStore.getAllSkills();
+    const serializedSkills = skills.map(serializeSkill);
+    return {
+      success: true,
+      message: "Successfully retrieved skill list",
+      data: {
+        records: serializedSkills,
+        total: serializedSkills.length
+      }
+    };
+  } catch (error) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to retrieve skills: ${error.message}`,
+      data: {
+        records: [],
+        total: 0
+      }
+    });
+  }
+}
+async function getSkill(request, reply) {
+  try {
+    const { id } = request.params;
+    const storeLattice = getStoreLattice3("default", "skill");
+    const skillStore = storeLattice.store;
+    const skill = await skillStore.getSkillById(id);
+    if (!skill) {
+      return reply.status(404).send({
+        success: false,
+        message: "Skill not found"
+      });
+    }
+    return {
+      success: true,
+      message: "Successfully retrieved skill",
+      data: serializeSkill(skill)
+    };
+  } catch (error) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to retrieve skill: ${error.message}`
+    });
+  }
+}
+async function createSkill(request, reply) {
+  try {
+    const data = request.body;
+    if (!data.name) {
+      return reply.status(400).send({
+        success: false,
+        message: "name is required"
+      });
+    }
+    if (!data.description) {
+      return reply.status(400).send({
+        success: false,
+        message: "description is required"
+      });
+    }
+    try {
+      validateSkillName(data.name);
+    } catch (error) {
+      return reply.status(400).send({
+        success: false,
+        message: error.message || "Invalid skill name format"
+      });
+    }
+    const id = request.body.id || data.name;
+    if (id !== data.name) {
+      return reply.status(400).send({
+        success: false,
+        message: `id "${id}" must equal name "${data.name}" (name is used for path addressing)`
+      });
+    }
+    const storeLattice = getStoreLattice3("default", "skill");
+    const skillStore = storeLattice.store;
+    const exists = await skillStore.hasSkill(id);
+    if (exists) {
+      return reply.status(409).send({
+        success: false,
+        message: `Skill with id "${id}" already exists`
+      });
+    }
+    const newSkill = await skillStore.createSkill(id, data);
+    return reply.status(201).send({
+      success: true,
+      message: "Successfully created skill",
+      data: serializeSkill(newSkill)
+    });
+  } catch (error) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to create skill: ${error.message}`
+    });
+  }
+}
+async function updateSkill(request, reply) {
+  try {
+    const { id } = request.params;
+    const updates = request.body;
+    if (updates.name !== void 0) {
+      try {
+        validateSkillName(updates.name);
+      } catch (error) {
+        return reply.status(400).send({
+          success: false,
+          message: error.message || "Invalid skill name format"
+        });
+      }
+    }
+    const storeLattice = getStoreLattice3("default", "skill");
+    const skillStore = storeLattice.store;
+    const exists = await skillStore.hasSkill(id);
+    if (!exists) {
+      return reply.status(404).send({
+        success: false,
+        message: "Skill not found"
+      });
+    }
+    const updatedSkill = await skillStore.updateSkill(id, updates);
+    if (!updatedSkill) {
+      return reply.status(500).send({
+        success: false,
+        message: "Failed to update skill"
+      });
+    }
+    return {
+      success: true,
+      message: "Successfully updated skill",
+      data: serializeSkill(updatedSkill)
+    };
+  } catch (error) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to update skill: ${error.message}`
+    });
+  }
+}
+async function deleteSkill(request, reply) {
+  try {
+    const { id } = request.params;
+    const storeLattice = getStoreLattice3("default", "skill");
+    const skillStore = storeLattice.store;
+    const exists = await skillStore.hasSkill(id);
+    if (!exists) {
+      return reply.status(404).send({
+        success: false,
+        message: "Skill not found"
+      });
+    }
+    const deleted = await skillStore.deleteSkill(id);
+    if (!deleted) {
+      return reply.status(500).send({
+        success: false,
+        message: "Failed to delete skill"
+      });
+    }
+    return {
+      success: true,
+      message: "Successfully deleted skill"
+    };
+  } catch (error) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to delete skill: ${error.message}`
+    });
+  }
+}
+async function searchSkillsByMetadata(request, reply) {
+  try {
+    const { key, value } = request.query;
+    if (!key || !value) {
+      return reply.status(400).send({
+        success: false,
+        message: "key and value query parameters are required",
+        data: {
+          records: [],
+          total: 0
+        }
+      });
+    }
+    const storeLattice = getStoreLattice3("default", "skill");
+    const skillStore = storeLattice.store;
+    const skills = await skillStore.searchByMetadata(key, value);
+    const serializedSkills = skills.map(serializeSkill);
+    return {
+      success: true,
+      message: "Successfully searched skills",
+      data: {
+        records: serializedSkills,
+        total: serializedSkills.length
+      }
+    };
+  } catch (error) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to search skills: ${error.message}`,
+      data: {
+        records: [],
+        total: 0
+      }
+    });
+  }
+}
+async function filterSkillsByCompatibility(request, reply) {
+  try {
+    const { compatibility } = request.query;
+    if (!compatibility) {
+      return reply.status(400).send({
+        success: false,
+        message: "compatibility query parameter is required",
+        data: {
+          records: [],
+          total: 0
+        }
+      });
+    }
+    const storeLattice = getStoreLattice3("default", "skill");
+    const skillStore = storeLattice.store;
+    const skills = await skillStore.filterByCompatibility(compatibility);
+    const serializedSkills = skills.map(serializeSkill);
+    return {
+      success: true,
+      message: "Successfully filtered skills",
+      data: {
+        records: serializedSkills,
+        total: serializedSkills.length
+      }
+    };
+  } catch (error) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to filter skills: ${error.message}`,
+      data: {
+        records: [],
+        total: 0
+      }
+    });
+  }
+}
+async function filterSkillsByLicense(request, reply) {
+  try {
+    const { license } = request.query;
+    if (!license) {
+      return reply.status(400).send({
+        success: false,
+        message: "license query parameter is required",
+        data: {
+          records: [],
+          total: 0
+        }
+      });
+    }
+    const storeLattice = getStoreLattice3("default", "skill");
+    const skillStore = storeLattice.store;
+    const skills = await skillStore.filterByLicense(license);
+    const serializedSkills = skills.map(serializeSkill);
+    return {
+      success: true,
+      message: "Successfully filtered skills",
+      data: {
+        records: serializedSkills,
+        total: serializedSkills.length
+      }
+    };
+  } catch (error) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to filter skills: ${error.message}`,
+      data: {
+        records: [],
+        total: 0
+      }
+    });
+  }
+}
+
 // src/schemas/index.ts
 var getAllMemoryItemsSchema = {
   description: "Get all memory items for an assistant thread",
@@ -1678,144 +1983,35 @@ var registerLatticeRoutes = (app2) => {
   app2.post("/api/schedules/:taskId/cancel", cancelScheduledTask);
   app2.post("/api/schedules/:taskId/pause", pauseScheduledTask);
   app2.post("/api/schedules/:taskId/resume", resumeScheduledTask);
-};
-
-// 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
-      }
-    });
-  }
+  app2.get("/api/skills", getSkillList);
+  app2.get(
+    "/api/skills/:id",
+    getSkill
+  );
+  app2.post(
+    "/api/skills",
+    createSkill
+  );
+  app2.put(
+    "/api/skills/:id",
+    updateSkill
+  );
+  app2.delete(
+    "/api/skills/:id",
+    deleteSkill
+  );
+  app2.get(
+    "/api/skills/search/metadata",
+    searchSkillsByMetadata
+  );
+  app2.get(
+    "/api/skills/filter/compatibility",
+    filterSkillsByCompatibility
+  );
+  app2.get(
+    "/api/skills/filter/license",
+    filterSkillsByLicense
+  );
 };
 
 // src/swagger.ts
@@ -2163,13 +2359,33 @@ _AgentTaskConsumer.agent_run_endpoint = "http://localhost:4001/api/runs";
 var AgentTaskConsumer = _AgentTaskConsumer;
 
 // src/index.ts
+import {
+  registerLoggerLattice,
+  getLoggerLattice,
+  loggerLatticeManager
+} from "@axiom-lattice/core";
+import {
+  LoggerType
+} from "@axiom-lattice/protocols";
 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 DEFAULT_LOGGER_CONFIG = {
+  name: "default",
+  description: "Default logger for lattice-gateway service",
+  type: LoggerType.PINO,
+  serviceName: "lattice/gateway",
+  loggerName: "lattice/gateway"
+};
+var loggerLattice = initializeLogger(DEFAULT_LOGGER_CONFIG);
+var logger = loggerLattice.client;
+function initializeLogger(config) {
+  if (loggerLatticeManager.hasLattice("default")) {
+    loggerLatticeManager.removeLattice("default");
+  }
+  registerLoggerLattice("default", config);
+  return getLoggerLattice("default");
+}
 var app = fastify({
   logger: false,
   // 禁用内置日志记录器
@@ -2177,17 +2393,33 @@ var app = fastify({
   // Default 50MB, configurable via BODY_LIMIT env var
 });
 app.addHook("onRequest", (request, reply, done) => {
+  const getHeaderValue = (header) => {
+    if (Array.isArray(header)) {
+      return header[0];
+    }
+    return header;
+  };
   const context = {
-    "x-tenant-id": request.headers["x-tenant-id"],
-    "x-request-id": request.headers["x-request-id"]
+    "x-tenant-id": getHeaderValue(request.headers["x-tenant-id"]),
+    "x-request-id": getHeaderValue(request.headers["x-request-id"])
   };
+  if (loggerLattice.updateContext) {
+    loggerLattice.updateContext(context);
+  }
   done();
 });
 app.addHook("onResponse", (request, reply, done) => {
+  const getHeaderValue = (header) => {
+    if (Array.isArray(header)) {
+      return header[0];
+    }
+    return header;
+  };
   const context = {
-    "x-tenant-id": request.headers["x-tenant-id"],
-    "x-request-id": request.headers["x-request-id"]
+    "x-tenant-id": getHeaderValue(request.headers["x-tenant-id"]),
+    "x-request-id": getHeaderValue(request.headers["x-request-id"])
   };
+  loggerLattice.info(`${request.method} ${request.url} - ${reply.statusCode}`);
   done();
 });
 app.register(cors, {
@@ -2205,9 +2437,15 @@ app.register(cors, {
 });
 app.register(sensible);
 app.setErrorHandler((error, request, reply) => {
+  const getHeaderValue = (header) => {
+    if (Array.isArray(header)) {
+      return header[0];
+    }
+    return header;
+  };
   const context = {
-    "x-tenant-id": request.headers["x-tenant-id"],
-    "x-request-id": request.headers["x-request-id"]
+    "x-tenant-id": getHeaderValue(request.headers["x-tenant-id"]),
+    "x-request-id": getHeaderValue(request.headers["x-request-id"])
   };
   logger.error(
     `\u8BF7\u6C42\u9519\u8BEF: ${request.method} ${request.url} error:${error.message}`,
@@ -2223,9 +2461,19 @@ app.setErrorHandler((error, request, reply) => {
     error: error.message || "\u670D\u52A1\u5668\u5185\u90E8\u9519\u8BEF"
   });
 });
-app.decorate("logger", logger);
 var start = async (config) => {
   try {
+    if (config?.loggerConfig) {
+      const loggerConfig = {
+        ...DEFAULT_LOGGER_CONFIG,
+        ...config.loggerConfig,
+        // Merge file config if provided
+        file: config.loggerConfig.file || DEFAULT_LOGGER_CONFIG.file
+      };
+      loggerLattice = initializeLogger(loggerConfig);
+      logger = loggerLattice.client;
+    }
+    app.decorate("loggerLattice", loggerLattice);
     const target_port = config?.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: ${target_port}`);