@axiom-lattice/gateway 2.1.20 → 2.1.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiom-lattice/gateway",
-  "version": "2.1.20",
+  "version": "2.1.21",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -32,9 +32,9 @@
     "pino-roll": "^3.1.0",
     "redis": "^5.0.1",
     "uuid": "^9.0.1",
-    "@axiom-lattice/core": "2.1.15",
-    "@axiom-lattice/protocols": "2.1.9",
-    "@axiom-lattice/queue-redis": "1.0.8"
+    "@axiom-lattice/core": "2.1.16",
+    "@axiom-lattice/protocols": "2.1.10",
+    "@axiom-lattice/queue-redis": "1.0.9"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",

package/src/controllers/skills.ts

@@ -0,0 +1,474 @@
+import { FastifyRequest, FastifyReply } from "fastify";
+import { getStoreLattice } from "@axiom-lattice/core";
+import { validateSkillName } from "@axiom-lattice/core";
+import type {
+  Skill,
+  CreateSkillRequest,
+} from "@axiom-lattice/protocols";
+
+/**
+ * Skills Controller
+ * Handles skill-related CRUD operations
+ */
+
+/**
+ * Skill list response interface
+ */
+interface SkillListResponse {
+  success: boolean;
+  message: string;
+  data: {
+    records: Skill[];
+    total: number;
+  };
+}
+
+/**
+ * Skill response interface
+ */
+interface SkillResponse {
+  success: boolean;
+  message: string;
+  data?: Skill;
+}
+
+/**
+ * Skill update request body interface
+ */
+interface SkillUpdateBody {
+  name?: string;
+  description?: string;
+  license?: string;
+  compatibility?: string;
+  metadata?: Record<string, string>;
+  content?: string;
+  subSkills?: string[];
+}
+
+/**
+ * Serialize Skill object for JSON response
+ * Converts Date objects to ISO strings
+ * Explicitly creates a plain object to ensure all fields are serializable
+ */
+function serializeSkill(skill: Skill): any {
+  // Explicitly create a plain object with all fields
+  // This ensures Fastify can properly serialize the response
+  const serialized: any = {
+    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() : new Date().toISOString()),
+    updatedAt: skill.updatedAt instanceof Date ? skill.updatedAt.toISOString() : (skill.updatedAt ? new Date(skill.updatedAt).toISOString() : new Date().toISOString()),
+  };
+
+  // Remove undefined fields to avoid serialization issues
+  Object.keys(serialized).forEach((key) => {
+    if (serialized[key] === undefined) {
+      delete serialized[key];
+    }
+  });
+
+  return serialized;
+}
+
+/**
+ * Get list of all skills
+ */
+export async function getSkillList(
+  request: FastifyRequest,
+  reply: FastifyReply
+): Promise<SkillListResponse> {
+  try {
+    const storeLattice = getStoreLattice("default", "skill");
+    const skillStore = storeLattice.store;
+    const skills = await skillStore.getAllSkills();
+
+    // Serialize skills to convert Date objects to ISO strings
+    const serializedSkills = skills.map(serializeSkill);
+
+    return {
+      success: true,
+      message: "Successfully retrieved skill list",
+      data: {
+        records: serializedSkills,
+        total: serializedSkills.length,
+      },
+    };
+  } catch (error: any) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to retrieve skills: ${error.message}`,
+      data: {
+        records: [],
+        total: 0,
+      },
+    });
+  }
+}
+
+/**
+ * Get a single skill by ID
+ */
+export async function getSkill(
+  request: FastifyRequest<{ Params: { id: string } }>,
+  reply: FastifyReply
+): Promise<SkillResponse> {
+  try {
+    const { id } = request.params;
+
+    const storeLattice = getStoreLattice("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: any) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to retrieve skill: ${error.message}`,
+    });
+  }
+}
+
+/**
+ * Create a new skill
+ */
+export async function createSkill(
+  request: FastifyRequest<{ Body: CreateSkillRequest }>,
+  reply: FastifyReply
+): Promise<SkillResponse> {
+  try {
+    const data = request.body;
+
+    // Validate required fields
+    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",
+      });
+    }
+
+    // Validate name format
+    try {
+      validateSkillName(data.name);
+    } catch (error: any) {
+      return reply.status(400).send({
+        success: false,
+        message: error.message || "Invalid skill name format",
+      });
+    }
+
+    // ID must equal name (name is used for path addressing)
+    const id = (request.body as any).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 = getStoreLattice("default", "skill");
+    const skillStore = storeLattice.store;
+
+    // Check if skill already exists
+    const exists = await skillStore.hasSkill(id);
+    if (exists) {
+      return reply.status(409).send({
+        success: false,
+        message: `Skill with id "${id}" already exists`,
+      });
+    }
+
+    // Create skill
+    const newSkill = await skillStore.createSkill(id, data);
+
+    return reply.status(201).send({
+      success: true,
+      message: "Successfully created skill",
+      data: serializeSkill(newSkill),
+    });
+  } catch (error: any) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to create skill: ${error.message}`,
+    });
+  }
+}
+
+/**
+ * Update an existing skill by ID
+ */
+export async function updateSkill(
+  request: FastifyRequest<{
+    Params: { id: string };
+    Body: SkillUpdateBody;
+  }>,
+  reply: FastifyReply
+): Promise<SkillResponse> {
+  try {
+    const { id } = request.params;
+    const updates = request.body;
+
+    // Validate name format if name is being updated
+    if (updates.name !== undefined) {
+      try {
+        validateSkillName(updates.name);
+      } catch (error: any) {
+        return reply.status(400).send({
+          success: false,
+          message: error.message || "Invalid skill name format",
+        });
+      }
+    }
+
+    const storeLattice = getStoreLattice("default", "skill");
+    const skillStore = storeLattice.store;
+
+    // Check if skill exists
+    const exists = await skillStore.hasSkill(id);
+    if (!exists) {
+      return reply.status(404).send({
+        success: false,
+        message: "Skill not found",
+      });
+    }
+
+    // Update skill
+    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: any) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to update skill: ${error.message}`,
+    });
+  }
+}
+
+/**
+ * Delete a skill by ID
+ */
+export async function deleteSkill(
+  request: FastifyRequest<{ Params: { id: string } }>,
+  reply: FastifyReply
+): Promise<{ success: boolean; message: string }> {
+  try {
+    const { id } = request.params;
+
+    const storeLattice = getStoreLattice("default", "skill");
+    const skillStore = storeLattice.store;
+
+    // Check if skill exists
+    const exists = await skillStore.hasSkill(id);
+    if (!exists) {
+      return reply.status(404).send({
+        success: false,
+        message: "Skill not found",
+      });
+    }
+
+    // Delete the skill
+    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: any) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to delete skill: ${error.message}`,
+    });
+  }
+}
+
+/**
+ * Search skills by metadata
+ */
+export async function searchSkillsByMetadata(
+  request: FastifyRequest<{
+    Querystring: { key: string; value: string };
+  }>,
+  reply: FastifyReply
+): Promise<SkillListResponse> {
+  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 = getStoreLattice("default", "skill");
+    const skillStore = storeLattice.store;
+    const skills = await skillStore.searchByMetadata(key, value);
+
+    // Serialize skills to convert Date objects to ISO strings
+    const serializedSkills = skills.map(serializeSkill);
+
+    return {
+      success: true,
+      message: "Successfully searched skills",
+      data: {
+        records: serializedSkills,
+        total: serializedSkills.length,
+      },
+    };
+  } catch (error: any) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to search skills: ${error.message}`,
+      data: {
+        records: [],
+        total: 0,
+      },
+    });
+  }
+}
+
+/**
+ * Filter skills by compatibility
+ */
+export async function filterSkillsByCompatibility(
+  request: FastifyRequest<{
+    Querystring: { compatibility: string };
+  }>,
+  reply: FastifyReply
+): Promise<SkillListResponse> {
+  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 = getStoreLattice("default", "skill");
+    const skillStore = storeLattice.store;
+    const skills = await skillStore.filterByCompatibility(compatibility);
+
+    // Serialize skills to convert Date objects to ISO strings
+    const serializedSkills = skills.map(serializeSkill);
+
+    return {
+      success: true,
+      message: "Successfully filtered skills",
+      data: {
+        records: serializedSkills,
+        total: serializedSkills.length,
+      },
+    };
+  } catch (error: any) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to filter skills: ${error.message}`,
+      data: {
+        records: [],
+        total: 0,
+      },
+    });
+  }
+}
+
+/**
+ * Filter skills by license
+ */
+export async function filterSkillsByLicense(
+  request: FastifyRequest<{
+    Querystring: { license: string };
+  }>,
+  reply: FastifyReply
+): Promise<SkillListResponse> {
+  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 = getStoreLattice("default", "skill");
+    const skillStore = storeLattice.store;
+    const skills = await skillStore.filterByLicense(license);
+
+    // Serialize skills to convert Date objects to ISO strings
+    const serializedSkills = skills.map(serializeSkill);
+
+    return {
+      success: true,
+      message: "Successfully filtered skills",
+      data: {
+        records: serializedSkills,
+        total: serializedSkills.length,
+      },
+    };
+  } catch (error: any) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to filter skills: ${error.message}`,
+      data: {
+        records: [],
+        total: 0,
+      },
+    });
+  }
+}

package/src/routes/index.ts

@@ -1,4 +1,5 @@
 import { FastifyInstance } from "fastify";
+import { ScheduledTaskStatus } from "@axiom-lattice/protocols";
 import * as assistantController from "../controllers/assistant";
 import * as runController from "../controllers/run";
 import * as memoryController from "../controllers/memory";
@@ -9,6 +10,7 @@ import * as schedulesController from "../controllers/schedules";
 import * as configController from "../controllers/config";
 import * as modelsController from "../controllers/models";
 import * as healthController from "../controllers/health";
+import * as skillsController from "../controllers/skills";
 import {
   createRunSchema,
   getAllMemoryItemsSchema,
@@ -200,7 +202,11 @@ export const registerLatticeRoutes = (app: FastifyInstance): void => {
   // Schedule routes for viewing scheduled tasks by thread
   app.get<{
     Params: { assistantId: string; threadId: string };
-    Querystring: { status?: string; limit?: string; offset?: string };
+    Querystring: {
+      status?: ScheduledTaskStatus;
+      limit?: string;
+      offset?: string;
+    };
   }>(
     "/api/assistants/:assistantId/threads/:threadId/schedules",
     schedulesController.getThreadSchedules
@@ -225,4 +231,58 @@ export const registerLatticeRoutes = (app: FastifyInstance): void => {
   app.post<{
     Params: { taskId: string };
   }>("/api/schedules/:taskId/resume", schedulesController.resumeScheduledTask);
+
+  // Skills CRUD routes
+  app.get("/api/skills", skillsController.getSkillList);
+
+  app.get<{
+    Params: { id: string };
+  }>(
+    "/api/skills/:id",
+    skillsController.getSkill
+  );
+
+  app.post<{
+    Body: any;
+  }>(
+    "/api/skills",
+    skillsController.createSkill
+  );
+
+  app.put<{
+    Params: { id: string };
+    Body: any;
+  }>(
+    "/api/skills/:id",
+    skillsController.updateSkill
+  );
+
+  app.delete<{
+    Params: { id: string };
+  }>(
+    "/api/skills/:id",
+    skillsController.deleteSkill
+  );
+
+  // Skills search and filter routes
+  app.get<{
+    Querystring: { key: string; value: string };
+  }>(
+    "/api/skills/search/metadata",
+    skillsController.searchSkillsByMetadata
+  );
+
+  app.get<{
+    Querystring: { compatibility: string };
+  }>(
+    "/api/skills/filter/compatibility",
+    skillsController.filterSkillsByCompatibility
+  );
+
+  app.get<{
+    Querystring: { license: string };
+  }>(
+    "/api/skills/filter/license",
+    skillsController.filterSkillsByLicense
+  );
 };