@axiom-lattice/gateway 3.0.2 → 3.0.4

package/src/controllers/tasks.ts

@@ -1,213 +0,0 @@
-import { FastifyRequest, FastifyReply } from "fastify";
-import { getStoreLattice } from "@axiom-lattice/core";
-import type { TaskStore, TaskItem, CreateTaskRequest, UpdateTaskRequest, TaskWorkItemStore } from "@axiom-lattice/protocols";
-
-function getTenantId(request: FastifyRequest): string {
-  const userTenantId = (request as any).user?.tenantId;
-  if (userTenantId) return userTenantId;
-  return (request.headers["x-tenant-id"] as string) || "default";
-}
-
-function getUserId(request: FastifyRequest): string {
-  const userId = (request as any).user?.id
-    || (request.headers["x-user-id"] as string);
-  if (!userId) throw new Error("User ID is required");
-  return userId;
-}
-
-function getStore(): TaskStore {
-  return getStoreLattice("default", "task").store as TaskStore;
-}
-
-export async function listTasks(
-  request: FastifyRequest,
-  reply: FastifyReply
-): Promise<{ success: boolean; data?: TaskItem[]; count?: number; error?: string }> {
-  try {
-    const tenantId = getTenantId(request);
-    const query = request.query as Record<string, string>;
-
-    const store = getStore();
-    const tasks = await store.list({
-      tenantId,
-      status: query.status,
-      priority: query.priority,
-      ...(query.ownerId && { ownerId: query.ownerId }),
-      ...(query.ownerType && { ownerType: query.ownerType as 'user' | 'agent' }),
-      metadata: query.metadata ? JSON.parse(query.metadata) : undefined,
-      projectId: query.projectId,
-      limit: query.limit ? parseInt(query.limit) : undefined,
-      offset: query.offset ? parseInt(query.offset) : undefined,
-    });
-
-    return { success: true, data: tasks, count: tasks.length };
-  } catch (error: any) {
-    return { success: false, error: error.message };
-  }
-}
-
-export async function getTask(
-  request: FastifyRequest<{ Params: { id: string } }>,
-  reply: FastifyReply
-): Promise<{ success: boolean; data?: TaskItem; error?: string }> {
-  try {
-    const tenantId = getTenantId(request);
-    const userId = getUserId(request);
-    const { id } = request.params;
-
-    const store = getStore();
-    const task = await store.getById(tenantId, id);
-    if (!task) {
-      return reply.status(404).send({ success: false, error: "Task not found" });
-    }
-
-    if (task.ownerType === 'user' && task.ownerId !== userId) {
-      return reply.status(403).send({ success: false, error: "Access denied" });
-    }
-
-    return { success: true, data: task };
-  } catch (error: any) {
-    return { success: false, error: error.message };
-  }
-}
-
-export async function createTask(
-  request: FastifyRequest<{ Body: CreateTaskRequest }>,
-  reply: FastifyReply
-): Promise<{ success: boolean; data?: TaskItem; error?: string }> {
-  try {
-    const tenantId = getTenantId(request);
-    const userId = getUserId(request);
-    const body = request.body;
-
-    if (!body.title) {
-      return reply.status(400).send({ success: false, error: "title is required" });
-    }
-
-    const store = getStore();
-    const task = await store.create({
-      ...body,
-      tenantId,
-      ownerType: (body.ownerType || "user") as 'user' | 'agent',
-      ownerId: body.ownerId || userId,
-    });
-
-    return reply.status(201).send({ success: true, data: task });
-  } catch (error: any) {
-    return reply.status(500).send({ success: false, error: error.message });
-  }
-}
-
-export async function updateTask(
-  request: FastifyRequest<{ Params: { id: string }; Body: UpdateTaskRequest }>,
-  reply: FastifyReply
-): Promise<{ success: boolean; data?: TaskItem; error?: string }> {
-  try {
-    const tenantId = getTenantId(request);
-    const userId = getUserId(request);
-    const { id } = request.params;
-
-    const store = getStore();
-    const existing = await store.getById(tenantId, id);
-    if (!existing) {
-      return reply.status(404).send({ success: false, error: "Task not found" });
-    }
-
-    if (existing.ownerType === 'user' && existing.ownerId !== userId) {
-      return reply.status(403).send({ success: false, error: "Access denied" });
-    }
-
-    const task = await store.update(tenantId, id, request.body);
-    if (!task) {
-      return reply.status(404).send({ success: false, error: "Task not found" });
-    }
-    return { success: true, data: task };
-  } catch (error: any) {
-    return reply.status(500).send({ success: false, error: error.message });
-  }
-}
-
-export async function deleteTask(
-  request: FastifyRequest<{ Params: { id: string } }>,
-  reply: FastifyReply
-): Promise<{ success: boolean; message?: string; error?: string }> {
-  try {
-    const tenantId = getTenantId(request);
-    const userId = getUserId(request);
-    const { id } = request.params;
-
-    const store = getStore();
-    const existing = await store.getById(tenantId, id);
-    if (!existing) {
-      return reply.status(404).send({ success: false, error: "Task not found" });
-    }
-
-    if (existing.ownerType === 'user' && existing.ownerId !== userId) {
-      return reply.status(403).send({ success: false, error: "Access denied" });
-    }
-
-    const deleted = await store.delete(tenantId, id);
-    if (!deleted) {
-      return reply.status(404).send({ success: false, error: "Task not found" });
-    }
-
-    return { success: true, message: "Task deleted" };
-  } catch (error: any) {
-    return reply.status(500).send({ success: false, error: error.message });
-  }
-}
-
-export async function completeTask(
-  request: FastifyRequest<{ Params: { id: string } }>,
-  reply: FastifyReply
-): Promise<{ success: boolean; data?: TaskItem; error?: string }> {
-  try {
-    const tenantId = getTenantId(request);
-    const userId = getUserId(request);
-    const { id } = request.params;
-
-    const store = getStore();
-    const existing = await store.getById(tenantId, id);
-    if (!existing) {
-      return reply.status(404).send({ success: false, error: "Task not found" });
-    }
-
-    if (existing.ownerType === 'user' && existing.ownerId !== userId) {
-      return reply.status(403).send({ success: false, error: "Access denied" });
-    }
-
-    const task = await store.update(tenantId, id, { status: "completed" });
-    if (!task) {
-      return reply.status(404).send({ success: false, error: "Task not found" });
-    }
-    return { success: true, data: task };
-  } catch (error: any) {
-    return reply.status(500).send({ success: false, error: error.message });
-  }
-}
-
-function getTaskWorkItemStore(): TaskWorkItemStore {
-  return getStoreLattice("default", "taskWorkItem").store as TaskWorkItemStore;
-}
-
-export async function listTaskWorkItems(
-  request: FastifyRequest<{ 
-    Params: { id: string }; 
-    Querystring: { action?: string; limit?: number; offset?: number } 
-  }>,
-  reply: FastifyReply
-) {
-  const tenantId = getTenantId(request);
-  const { id } = request.params;
-  const { action, limit, offset } = request.query;
-
-  const store = getTaskWorkItemStore();
-  const items = await store.list({ 
-    tenantId, 
-    taskId: id, 
-    action, 
-    limit: limit ? Number(limit) : undefined, 
-    offset: offset ? Number(offset) : undefined 
-  });
-  return reply.send({ success: true, data: items });
-}

package/src/controllers/tenants.ts

@@ -1,121 +0,0 @@
-/**
- * TenantsController
- *
- * Controller for tenant management
- * Handles CRUD operations for tenants (top-level entities)
- */
-
-import { FastifyInstance, FastifyRequest, FastifyReply } from "fastify";
-import { getStoreLattice } from "@axiom-lattice/core";
-import type {
-  CreateTenantRequest,
-  UpdateTenantRequest,
-} from "@axiom-lattice/protocols";
-import { v4 as uuidv4 } from "uuid";
-
-interface TenantParams {
-  tenantId: string;
-}
-
-export class TenantsController {
-  private tenantStore;
-
-  constructor() {
-    this.tenantStore = getStoreLattice("default", "tenant").store;
-  }
-
-  // ==================== Tenant CRUD ====================
-
-  async listTenants(request: FastifyRequest, reply: FastifyReply) {
-    const tenants = await this.tenantStore.getAllTenants();
-    return { success: true, data: tenants };
-  }
-
-  async createTenant(
-    request: FastifyRequest<{ Body: CreateTenantRequest }>,
-    reply: FastifyReply
-  ) {
-    const data = request.body;
-    const id = uuidv4();
-
-    const tenant = await this.tenantStore.createTenant(id, data);
-    return reply.status(201).send({ success: true, data: tenant });
-  }
-
-  async getTenant(
-    request: FastifyRequest<{ Params: TenantParams }>,
-    reply: FastifyReply
-  ) {
-    const { tenantId } = request.params;
-
-    const tenant = await this.tenantStore.getTenantById(tenantId);
-
-    if (!tenant) {
-      return reply.status(404).send({
-        success: false,
-        error: "Tenant not found",
-      });
-    }
-
-    return { success: true, data: tenant };
-  }
-
-  async updateTenant(
-    request: FastifyRequest<{
-      Params: TenantParams;
-      Body: UpdateTenantRequest;
-    }>,
-    reply: FastifyReply
-  ) {
-    const { tenantId } = request.params;
-    const updates = request.body;
-
-    const tenant = await this.tenantStore.updateTenant(tenantId, updates);
-
-    if (!tenant) {
-      return reply.status(404).send({
-        success: false,
-        error: "Tenant not found",
-      });
-    }
-
-    return { success: true, data: tenant };
-  }
-
-  async deleteTenant(
-    request: FastifyRequest<{ Params: TenantParams }>,
-    reply: FastifyReply
-  ) {
-    const { tenantId } = request.params;
-
-    // Prevent deletion of the default tenant
-    if (tenantId === "default") {
-      return reply.status(403).send({
-        success: false,
-        error: "Cannot delete the default tenant",
-      });
-    }
-
-    const deleted = await this.tenantStore.deleteTenant(tenantId);
-
-    if (!deleted) {
-      return reply.status(404).send({
-        success: false,
-        error: "Tenant not found",
-      });
-    }
-
-    return { success: true };
-  }
-}
-
-export function registerTenantRoutes(app: FastifyInstance) {
-  const controller = new TenantsController();
-
-  // Tenant routes
-  app.get("/api/tenants", controller.listTenants.bind(controller));
-  app.post("/api/tenants", controller.createTenant.bind(controller));
-  app.get("/api/tenants/:tenantId", controller.getTenant.bind(controller));
-  app.patch("/api/tenants/:tenantId", controller.updateTenant.bind(controller));
-  app.delete("/api/tenants/:tenantId", controller.deleteTenant.bind(controller));
-}

package/src/controllers/thread_status.ts

@@ -1,66 +0,0 @@
-import { FastifyRequest, FastifyReply } from "fastify";
-import { agentInstanceManager } from "@axiom-lattice/core";
-
-/**
- * DELETE /api/assistants/:assistant_id/threads/:thread_id/pending-messages/:message_id
- * Remove pending message from queue
- */
-export async function removePendingMessageHandler(
-  request: FastifyRequest,
-  reply: FastifyReply
-) {
-  try {
-    const { assistant_id, thread_id, message_id } = request.params as {
-      assistant_id: string;
-      thread_id: string;
-      message_id: string;
-    };
-    const tenant_id = request.headers["x-tenant-id"] as string;
-    const workspace_id = request.headers["x-workspace-id"] as string;
-    const project_id = request.headers["x-project-id"] as string;
-
-    if (!tenant_id) {
-      return reply.code(400).send({ error: "Missing x-tenant-id header" });
-    }
-
-    if (!assistant_id) {
-      return reply.code(400).send({ error: "Missing assistant_id parameter" });
-    }
-
-    // Get agent instance
-    const agent = agentInstanceManager.getAgent({
-      assistant_id,
-      thread_id,
-      tenant_id,
-      workspace_id,
-      project_id,
-    });
-
-    if (!agent) {
-      return reply.code(404).send({
-        error: "Thread not found",
-        threadId: thread_id,
-      });
-    }
-
-    const success = await agent.removePendingMessage(message_id);
-
-    if (!success) {
-      return reply.code(404).send({
-        error: "Message not found",
-        messageId: message_id,
-      });
-    }
-
-    return reply.send({
-      success: true,
-      messageId: message_id,
-    });
-  } catch (error) {
-    console.error("Error removing pending message:", error);
-    return reply.code(500).send({
-      error: "Internal server error",
-      message: error instanceof Error ? error.message : String(error),
-    });
-  }
-}

package/src/controllers/threads.ts

@@ -1,260 +0,0 @@
-import { FastifyRequest, FastifyReply } from "fastify";
-import { getStoreLattice } from "@axiom-lattice/core";
-import { Thread, CreateThreadRequest } from "../types";
-import { randomUUID } from "crypto";
-
-/**
- * Thread Controller
- * Handles thread-related CRUD operations for a specific assistant
- * 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
- */
-interface ThreadListResponse {
-  success: boolean;
-  message: string;
-  data: {
-    records: Thread[];
-    total: number;
-  };
-}
-
-/**
- * Thread response interface
- */
-interface ThreadResponse {
-  success: boolean;
-  message: string;
-  data?: Thread;
-}
-
-/**
- * Thread update request body interface
- */
-interface ThreadUpdateBody {
-  metadata?: Record<string, any>;
-}
-
-/**
- * Get list of all threads for a specific assistant
- */
-export async function getThreadList(
-  request: FastifyRequest<{
-    Params: { assistantId: string };
-  }>,
-  reply: FastifyReply
-): Promise<ThreadListResponse> {
-  const tenantId = getTenantId(request);
-  const { assistantId } = request.params;
-
-  // Build metadata filter from headers (workspace/project isolation)
-  const metadataFilter: Record<string, string> = {};
-  const workspaceId = request.headers["x-workspace-id"] as string | undefined;
-  const projectId = request.headers["x-project-id"] as string | undefined;
-  
-  if (workspaceId) {
-    metadataFilter.workspaceId = workspaceId;
-  }
-  if (projectId) {
-    metadataFilter.projectId = projectId;
-  }
-
-  const storeLattice = getStoreLattice("default", "thread");
-  const threadStore = storeLattice.store;
-  const threads = await threadStore.getThreadsByAssistantId(
-    tenantId,
-    assistantId,
-    Object.keys(metadataFilter).length > 0 ? metadataFilter : undefined
-  );
-
-  return {
-    success: true,
-    message: "Successfully retrieved thread list",
-    data: {
-      records: threads,
-      total: threads.length,
-    },
-  };
-}
-
-/**
- * Get a single thread by ID for a specific tenant
- */
-export async function getThread(
-  request: FastifyRequest<{
-    Params: { assistantId: string; threadId: string };
-  }>,
-  reply: FastifyReply
-): Promise<ThreadResponse> {
-  const tenantId = getTenantId(request);
-  const { threadId } = request.params;
-
-  const storeLattice = getStoreLattice("default", "thread");
-  const threadStore = storeLattice.store;
-  const thread = await threadStore.getThreadById(tenantId, threadId);
-
-  if (!thread) {
-    return reply.status(404).send({
-      success: false,
-      message: "Thread not found",
-    });
-  }
-
-  return {
-    success: true,
-    message: "Successfully retrieved thread",
-    data: thread,
-  };
-}
-
-/**
- * Create a new thread for an assistant
- */
-export async function createThread(
-  request: FastifyRequest<{
-    Params: { assistantId: string };
-    Body: CreateThreadRequest;
-  }>,
-  reply: FastifyReply
-): Promise<ThreadResponse> {
-  const tenantId = getTenantId(request);
-  const { assistantId } = request.params;
-  const data = request.body;
-
-  // Generate thread ID if not provided
-  const threadId = randomUUID();
-
-  // Extract workspace and project from headers
-  const workspaceId = request.headers["x-workspace-id"] as string | undefined;
-  const projectId = request.headers["x-project-id"] as string | undefined;
-
-  // Enrich metadata with tenant/workspace/project
-  const enrichedMetadata: Record<string, any> = {
-    ...data.metadata,
-    tenantId,
-  };
-
-  if (workspaceId) {
-    enrichedMetadata.workspaceId = workspaceId;
-  }
-  if (projectId) {
-    enrichedMetadata.projectId = projectId;
-  }
-
-  // Create thread with enriched metadata
-  const storeLattice = getStoreLattice("default", "thread");
-  const threadStore = storeLattice.store;
-  const newThread = await threadStore.createThread(tenantId, assistantId, threadId, {
-    metadata: enrichedMetadata,
-  });
-
-  return reply.status(201).send({
-    success: true,
-    message: "Successfully created thread",
-    data: newThread,
-  });
-}
-
-/**
- * Update an existing thread by ID
- */
-export async function updateThread(
-  request: FastifyRequest<{
-    Params: { assistantId: string; threadId: string };
-    Body: ThreadUpdateBody;
-  }>,
-  reply: FastifyReply
-): Promise<ThreadResponse> {
-  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(tenantId, threadId);
-  if (!exists) {
-    return reply.status(404).send({
-      success: false,
-      message: "Thread not found",
-    });
-  }
-
-  // Update thread
-  const updatedThread = await threadStore.updateThread(
-    tenantId,
-    threadId,
-    updates
-  );
-
-  if (!updatedThread) {
-    return reply.status(500).send({
-      success: false,
-      message: "Failed to update thread",
-    });
-  }
-
-  return {
-    success: true,
-    message: "Successfully updated thread",
-    data: updatedThread,
-  };
-}
-
-/**
- * Delete a thread by ID
- */
-export async function deleteThread(
-  request: FastifyRequest<{
-    Params: { assistantId: string; threadId: string };
-  }>,
-  reply: FastifyReply
-): Promise<{ success: boolean; message: string }> {
-  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(tenantId, threadId);
-  if (!exists) {
-    return reply.status(404).send({
-      success: false,
-      message: "Thread not found",
-    });
-  }
-
-  // Delete the thread
-  const deleted = await threadStore.deleteThread(tenantId, threadId);
-
-  if (!deleted) {
-    return reply.status(500).send({
-      success: false,
-      message: "Failed to delete thread",
-    });
-  }
-
-  return {
-    success: true,
-    message: "Successfully deleted thread",
-  };
-}