@axiom-lattice/gateway 2.1.38 → 2.1.39

package/src/controllers/schedules.ts

@@ -8,8 +8,23 @@ import {
 /**
  * Schedule Controller
  * Handles schedule-related operations for viewing and managing scheduled tasks
+ * All operations are scoped to a tenant ID
  */
 
+/**
+ * Get tenant ID from request headers or user context
+ */
+function getTenantId(request: FastifyRequest): string {
+  // First try to get from authenticated user context
+  const userTenantId = (request as any).user?.tenantId;
+  if (userTenantId) {
+    return userTenantId;
+  }
+
+  // Fallback to request headers for backward compatibility
+  return (request.headers["x-tenant-id"] as string) || "default";
+}
+
 /**
  * Scheduled tasks list response interface
  */
@@ -93,13 +108,17 @@ export async function getThreadSchedules(
       };
     }
 
+    const tenantId = getTenantId(request);
+
     const filters: {
+      tenantId: string;
       threadId: string;
       assistantId?: string;
       status?: ScheduledTaskStatus;
       limit?: number;
       offset?: number;
     } = {
+      tenantId,
       threadId,
       assistantId,
     };
@@ -116,6 +135,7 @@ export async function getThreadSchedules(
 
     const tasks = await storage.getAllTasks(filters);
     const total = await storage.countTasks({
+      tenantId,
       threadId,
       assistantId,
       status,

package/src/controllers/skills.ts

@@ -6,6 +6,21 @@ import type {
   CreateSkillRequest,
 } from "@axiom-lattice/protocols";
 
+/**
+ * Get tenant ID from authenticated user context
+ * Falls back to request headers for backward compatibility
+ */
+function getTenantId(request: FastifyRequest): string {
+  // First try to get from authenticated user context
+  const userTenantId = (request as any).user?.tenantId;
+  if (userTenantId) {
+    return userTenantId;
+  }
+
+  // Fallback to request headers for backward compatibility
+  return (request.headers["x-tenant-id"] as string) || "default";
+}
+
 /**
  * Skills Controller
  * Handles skill-related CRUD operations
@@ -84,9 +99,10 @@ export async function getSkillList(
   reply: FastifyReply
 ): Promise<SkillListResponse> {
   try {
+    const tenantId = getTenantId(request);
     const storeLattice = getStoreLattice("default", "skill");
     const skillStore = storeLattice.store;
-    const skills = await skillStore.getAllSkills();
+    const skills = await skillStore.getAllSkills(tenantId);
 
     // Serialize skills to convert Date objects to ISO strings
     const serializedSkills = skills.map(serializeSkill);
@@ -119,11 +135,12 @@ export async function getSkill(
   reply: FastifyReply
 ): Promise<SkillResponse> {
   try {
+    const tenantId = getTenantId(request);
     const { id } = request.params;
 
     const storeLattice = getStoreLattice("default", "skill");
     const skillStore = storeLattice.store;
-    const skill = await skillStore.getSkillById(id);
+    const skill = await skillStore.getSkillById(tenantId, id);
 
     if (!skill) {
       return reply.status(404).send({
@@ -190,11 +207,12 @@ export async function createSkill(
       });
     }
 
+    const tenantId = getTenantId(request);
     const storeLattice = getStoreLattice("default", "skill");
     const skillStore = storeLattice.store;
 
     // Check if skill already exists
-    const exists = await skillStore.hasSkill(id);
+    const exists = await skillStore.hasSkill(tenantId, id);
     if (exists) {
       return reply.status(409).send({
         success: false,
@@ -203,7 +221,7 @@ export async function createSkill(
     }
 
     // Create skill
-    const newSkill = await skillStore.createSkill(id, data);
+    const newSkill = await skillStore.createSkill(tenantId, id, data);
 
     return reply.status(201).send({
       success: true,
@@ -244,11 +262,12 @@ export async function updateSkill(
       }
     }
 
+    const tenantId = getTenantId(request);
     const storeLattice = getStoreLattice("default", "skill");
     const skillStore = storeLattice.store;
 
     // Check if skill exists
-    const exists = await skillStore.hasSkill(id);
+    const exists = await skillStore.hasSkill(tenantId, id);
     if (!exists) {
       return reply.status(404).send({
         success: false,
@@ -257,7 +276,7 @@ export async function updateSkill(
     }
 
     // Update skill
-    const updatedSkill = await skillStore.updateSkill(id, updates);
+    const updatedSkill = await skillStore.updateSkill(tenantId, id, updates);
 
     if (!updatedSkill) {
       return reply.status(500).send({
@@ -289,11 +308,12 @@ export async function deleteSkill(
   try {
     const { id } = request.params;
 
+    const tenantId = getTenantId(request);
     const storeLattice = getStoreLattice("default", "skill");
     const skillStore = storeLattice.store;
 
     // Check if skill exists
-    const exists = await skillStore.hasSkill(id);
+    const exists = await skillStore.hasSkill(tenantId, id);
     if (!exists) {
       return reply.status(404).send({
         success: false,
@@ -302,7 +322,7 @@ export async function deleteSkill(
     }
 
     // Delete the skill
-    const deleted = await skillStore.deleteSkill(id);
+    const deleted = await skillStore.deleteSkill(tenantId, id);
 
     if (!deleted) {
       return reply.status(500).send({
@@ -346,9 +366,10 @@ export async function searchSkillsByMetadata(
       });
     }
 
+    const tenantId = getTenantId(request);
     const storeLattice = getStoreLattice("default", "skill");
     const skillStore = storeLattice.store;
-    const skills = await skillStore.searchByMetadata(key, value);
+    const skills = await skillStore.searchByMetadata(tenantId, key, value);
 
     // Serialize skills to convert Date objects to ISO strings
     const serializedSkills = skills.map(serializeSkill);
@@ -396,9 +417,10 @@ export async function filterSkillsByCompatibility(
       });
     }
 
+    const tenantId = getTenantId(request);
     const storeLattice = getStoreLattice("default", "skill");
     const skillStore = storeLattice.store;
-    const skills = await skillStore.filterByCompatibility(compatibility);
+    const skills = await skillStore.filterByCompatibility(tenantId, compatibility);
 
     // Serialize skills to convert Date objects to ISO strings
     const serializedSkills = skills.map(serializeSkill);
@@ -446,9 +468,10 @@ export async function filterSkillsByLicense(
       });
     }
 
+    const tenantId = getTenantId(request);
     const storeLattice = getStoreLattice("default", "skill");
     const skillStore = storeLattice.store;
-    const skills = await skillStore.filterByLicense(license);
+    const skills = await skillStore.filterByLicense(tenantId, license);
 
     // Serialize skills to convert Date objects to ISO strings
     const serializedSkills = skills.map(serializeSkill);

package/src/controllers/threads.ts

@@ -6,9 +6,24 @@ import { randomUUID } from "crypto";
 /**
  * Thread Controller
  * Handles thread-related CRUD operations for a specific assistant
- * All operations are scoped to an assistant ID
+ * All operations are scoped to a tenant ID and assistant ID
  */
 
+/**
+ * Get tenant ID from authenticated user context
+ * Falls back to request headers for backward compatibility
+ */
+function getTenantId(request: FastifyRequest): string {
+  // First try to get from authenticated user context
+  const userTenantId = (request as any).user?.tenantId;
+  if (userTenantId) {
+    return userTenantId;
+  }
+
+  // Fallback to request headers for backward compatibility
+  return (request.headers["x-tenant-id"] as string) || "default";
+}
+
 /**
  * Thread list response interface
  */
@@ -44,11 +59,12 @@ export async function getThreadList(
   request: FastifyRequest<{ Params: { assistantId: string } }>,
   reply: FastifyReply
 ): Promise<ThreadListResponse> {
+  const tenantId = getTenantId(request);
   const { assistantId } = request.params;
 
   const storeLattice = getStoreLattice("default", "thread");
   const threadStore = storeLattice.store;
-  const threads = await threadStore.getThreadsByAssistantId(assistantId);
+  const threads = await threadStore.getThreadsByAssistantId(tenantId, assistantId);
 
   return {
     success: true,
@@ -61,7 +77,7 @@ export async function getThreadList(
 }
 
 /**
- * Get a single thread by ID for a specific assistant
+ * Get a single thread by ID for a specific tenant
  */
 export async function getThread(
   request: FastifyRequest<{
@@ -69,11 +85,12 @@ export async function getThread(
   }>,
   reply: FastifyReply
 ): Promise<ThreadResponse> {
-  const { assistantId, threadId } = request.params;
+  const tenantId = getTenantId(request);
+  const { threadId } = request.params;
 
   const storeLattice = getStoreLattice("default", "thread");
   const threadStore = storeLattice.store;
-  const thread = await threadStore.getThreadById(assistantId, threadId);
+  const thread = await threadStore.getThreadById(tenantId, threadId);
 
   if (!thread) {
     return reply.status(404).send({
@@ -99,6 +116,7 @@ export async function createThread(
   }>,
   reply: FastifyReply
 ): Promise<ThreadResponse> {
+  const tenantId = getTenantId(request);
   const { assistantId } = request.params;
   const data = request.body;
 
@@ -108,7 +126,7 @@ export async function createThread(
   // Create thread
   const storeLattice = getStoreLattice("default", "thread");
   const threadStore = storeLattice.store;
-  const newThread = await threadStore.createThread(assistantId, threadId, data);
+  const newThread = await threadStore.createThread(tenantId, assistantId, threadId, data);
 
   return reply.status(201).send({
     success: true,
@@ -127,14 +145,15 @@ export async function updateThread(
   }>,
   reply: FastifyReply
 ): Promise<ThreadResponse> {
-  const { assistantId, threadId } = request.params;
+  const tenantId = getTenantId(request);
+  const { threadId } = request.params;
   const updates = request.body;
 
   const storeLattice = getStoreLattice("default", "thread");
   const threadStore = storeLattice.store;
 
   // Check if thread exists
-  const exists = await threadStore.hasThread(assistantId, threadId);
+  const exists = await threadStore.hasThread(tenantId, threadId);
   if (!exists) {
     return reply.status(404).send({
       success: false,
@@ -144,7 +163,7 @@ export async function updateThread(
 
   // Update thread
   const updatedThread = await threadStore.updateThread(
-    assistantId,
+    tenantId,
     threadId,
     updates
   );
@@ -172,13 +191,14 @@ export async function deleteThread(
   }>,
   reply: FastifyReply
 ): Promise<{ success: boolean; message: string }> {
-  const { assistantId, threadId } = request.params;
+  const tenantId = getTenantId(request);
+  const { threadId } = request.params;
 
   const storeLattice = getStoreLattice("default", "thread");
   const threadStore = storeLattice.store;
 
   // Check if thread exists
-  const exists = await threadStore.hasThread(assistantId, threadId);
+  const exists = await threadStore.hasThread(tenantId, threadId);
   if (!exists) {
     return reply.status(404).send({
       success: false,
@@ -187,7 +207,7 @@ export async function deleteThread(
   }
 
   // Delete the thread
-  const deleted = await threadStore.deleteThread(assistantId, threadId);
+  const deleted = await threadStore.deleteThread(tenantId, threadId);
 
   if (!deleted) {
     return reply.status(500).send({

package/src/controllers/tools.ts

@@ -1,285 +1,14 @@
 import { FastifyRequest, FastifyReply } from "fastify";
-import { getStoreLattice, toolLatticeManager } from "@axiom-lattice/core";
+import { toolLatticeManager } from "@axiom-lattice/core";
 import type {
-  Tool,
   ToolConfig,
 } from "@axiom-lattice/protocols";
 
 /**
  * Tools Controller
- * Handles tool-related CRUD operations
+ * Handles tool-related operations
  */
 
-/**
- * Tool list response interface
- */
-interface ToolListResponse {
-  success: boolean;
-  message: string;
-  data: {
-    records: Tool[];
-    total: number;
-  };
-}
-
-/**
- * Tool response interface
- */
-interface ToolResponse {
-  success: boolean;
-  message: string;
-  data?: Tool;
-}
-
-/**
- * Serialize Tool object for JSON response
- * Converts Date objects to ISO strings
- * Explicitly creates a plain object to ensure all fields are serializable
- */
-function serializeTool(tool: Tool): any {
-  // Explicitly create a plain object with all fields
-  // This ensures Fastify can properly serialize the response
-  const serialized: any = {
-    id: tool.id,
-    name: tool.name,
-    description: tool.description,
-    license: tool.license,
-    compatibility: tool.compatibility,
-    metadata: tool.metadata || {},
-    config: tool.config,
-    createdAt: tool.createdAt instanceof Date ? tool.createdAt.toISOString() : (tool.createdAt ? new Date(tool.createdAt).toISOString() : new Date().toISOString()),
-    updatedAt: tool.updatedAt instanceof Date ? tool.updatedAt.toISOString() : (tool.updatedAt ? new Date(tool.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 tools
- */
-export async function getToolList(
-  request: FastifyRequest,
-  reply: FastifyReply
-): Promise<ToolListResponse> {
-  try {
-    const storeLattice = getStoreLattice("default", "tool");
-    const toolStore = storeLattice.store;
-    const tools = await toolStore.getAllTools();
-
-    // Serialize tools to convert Date objects to ISO strings
-    const serializedTools = tools.map(serializeTool);
-
-    return {
-      success: true,
-      message: "Successfully retrieved tool list",
-      data: {
-        records: serializedTools,
-        total: serializedTools.length,
-      },
-    };
-  } catch (error: any) {
-    return reply.status(500).send({
-      success: false,
-      message: `Failed to retrieve tools: ${error.message}`,
-      data: {
-        records: [],
-        total: 0,
-      },
-    });
-  }
-}
-
-/**
- * Get a single tool by ID
- */
-export async function getTool(
-  request: FastifyRequest<{ Params: { id: string } }>,
-  reply: FastifyReply
-): Promise<ToolResponse> {
-  try {
-    const { id } = request.params;
-
-    const storeLattice = getStoreLattice("default", "tool");
-    const toolStore = storeLattice.store;
-    const tool = await toolStore.getToolById(id);
-
-    if (!tool) {
-      return reply.status(404).send({
-        success: false,
-        message: "Tool not found",
-      });
-    }
-
-    return {
-      success: true,
-      message: "Successfully retrieved tool",
-      data: serializeTool(tool),
-    };
-  } catch (error: any) {
-    return reply.status(500).send({
-      success: false,
-      message: `Failed to retrieve tool: ${error.message}`,
-    });
-  }
-}
-
-/**
- * Search tools by metadata
- */
-export async function searchToolsByMetadata(
-  request: FastifyRequest<{
-    Querystring: { key: string; value: string };
-  }>,
-  reply: FastifyReply
-): Promise<ToolListResponse> {
-  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", "tool");
-    const toolStore = storeLattice.store;
-    const tools = await toolStore.searchByMetadata(key, value);
-
-    // Serialize tools to convert Date objects to ISO strings
-    const serializedTools = tools.map(serializeTool);
-
-    return {
-      success: true,
-      message: "Successfully searched tools",
-      data: {
-        records: serializedTools,
-        total: serializedTools.length,
-      },
-    };
-  } catch (error: any) {
-    return reply.status(500).send({
-      success: false,
-      message: `Failed to search tools: ${error.message}`,
-      data: {
-        records: [],
-        total: 0,
-      },
-    });
-  }
-}
-
-/**
- * Filter tools by compatibility
- */
-export async function filterToolsByCompatibility(
-  request: FastifyRequest<{
-    Querystring: { compatibility: string };
-  }>,
-  reply: FastifyReply
-): Promise<ToolListResponse> {
-  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", "tool");
-    const toolStore = storeLattice.store;
-    const tools = await toolStore.filterByCompatibility(compatibility);
-
-    // Serialize tools to convert Date objects to ISO strings
-    const serializedTools = tools.map(serializeTool);
-
-    return {
-      success: true,
-      message: "Successfully filtered tools",
-      data: {
-        records: serializedTools,
-        total: serializedTools.length,
-      },
-    };
-  } catch (error: any) {
-    return reply.status(500).send({
-      success: false,
-      message: `Failed to filter tools: ${error.message}`,
-      data: {
-        records: [],
-        total: 0,
-      },
-    });
-  }
-}
-
-/**
- * Filter tools by license
- */
-export async function filterToolsByLicense(
-  request: FastifyRequest<{
-    Querystring: { license: string };
-  }>,
-  reply: FastifyReply
-): Promise<ToolListResponse> {
-  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", "tool");
-    const toolStore = storeLattice.store;
-    const tools = await toolStore.filterByLicense(license);
-
-    // Serialize tools to convert Date objects to ISO strings
-    const serializedTools = tools.map(serializeTool);
-
-    return {
-      success: true,
-      message: "Successfully filtered tools",
-      data: {
-        records: serializedTools,
-        total: serializedTools.length,
-      },
-    };
-  } catch (error: any) {
-    return reply.status(500).send({
-      success: false,
-      message: `Failed to filter tools: ${error.message}`,
-      data: {
-        records: [],
-        total: 0,
-      },
-    });
-  }
-}
-
 /**
  * Tool config meta response interface
  */