@axiom-lattice/gateway 2.1.11 → 2.1.13

package/src/controllers/threads.ts

@@ -0,0 +1,189 @@
+import { FastifyRequest, FastifyReply } from "fastify";
+import { threadStore } from "../stores/thread_store";
+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 an assistant ID
+ */
+
+/**
+ * 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 { assistantId } = request.params;
+
+  const threads = threadStore.getThreadsByAssistantId(assistantId);
+
+  return {
+    success: true,
+    message: "Successfully retrieved thread list",
+    data: {
+      records: threads,
+      total: threads.length,
+    },
+  };
+}
+
+/**
+ * Get a single thread by ID for a specific assistant
+ */
+export async function getThread(
+  request: FastifyRequest<{
+    Params: { assistantId: string; threadId: string };
+  }>,
+  reply: FastifyReply
+): Promise<ThreadResponse> {
+  const { assistantId, threadId } = request.params;
+
+  const thread = threadStore.getThreadById(assistantId, 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 { assistantId } = request.params;
+  const data = request.body;
+
+  // Generate thread ID if not provided
+  const threadId = randomUUID();
+
+  // Create thread
+  const newThread = threadStore.createThread(assistantId, threadId, data);
+
+  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 { assistantId, threadId } = request.params;
+  const updates = request.body;
+
+  // Check if thread exists
+  if (!threadStore.hasThread(assistantId, threadId)) {
+    return reply.status(404).send({
+      success: false,
+      message: "Thread not found",
+    });
+  }
+
+  // Update thread
+  const updatedThread = threadStore.updateThread(
+    assistantId,
+    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 { assistantId, threadId } = request.params;
+
+  // Check if thread exists
+  if (!threadStore.hasThread(assistantId, threadId)) {
+    return reply.status(404).send({
+      success: false,
+      message: "Thread not found",
+    });
+  }
+
+  // Delete the thread
+  const deleted = threadStore.deleteThread(assistantId, threadId);
+
+  if (!deleted) {
+    return reply.status(500).send({
+      success: false,
+      message: "Failed to delete thread",
+    });
+  }
+
+  return {
+    success: true,
+    message: "Successfully deleted thread",
+  };
+}

package/src/routes/index.ts

@@ -1,9 +1,12 @@
 import { FastifyInstance } from "fastify";
-//import * as assistantController from "../controllers/assistant";
+import * as assistantController from "../controllers/assistant";
 import * as runController from "../controllers/run";
 import * as memoryController from "../controllers/memory";
 import * as graphController from "../controllers/assistant";
 import * as agentTaskController from "../controllers/agent_task";
+import * as threadsController from "../controllers/threads";
+import * as configController from "../controllers/config";
+import * as modelsController from "../controllers/models";
 import {
   createRunSchema,
   getAllMemoryItemsSchema,
@@ -15,6 +18,8 @@ import {
   getAgentGraphSchema,
   resumeStreamSchema,
   triggerAgentTaskSchema,
+  updateConfigSchema,
+  getConfigSchema,
 } from "../schemas";
 
 export const registerLatticeRoutes = (app: FastifyInstance): void => {
@@ -90,6 +95,26 @@ export const registerLatticeRoutes = (app: FastifyInstance): void => {
     memoryController.clearMemory
   );
 
+  // Assistant CRUD routes
+  app.get("/api/assistants", assistantController.getAssistantList);
+
+  app.get<{
+    Params: { id: string };
+  }>("/api/assistants/:id", assistantController.getAssistant);
+
+  app.post<{
+    Body: any;
+  }>("/api/assistants", assistantController.createAssistant);
+
+  app.put<{
+    Params: { id: string };
+    Body: any;
+  }>("/api/assistants/:id", assistantController.updateAssistant);
+
+  app.delete<{
+    Params: { id: string };
+  }>("/api/assistants/:id", assistantController.deleteAssistant);
+
   // 图表路由
   app.get<{
     Params: { assistantId: string };
@@ -107,4 +132,58 @@ export const registerLatticeRoutes = (app: FastifyInstance): void => {
     { schema: triggerAgentTaskSchema },
     agentTaskController.triggerAgentTask
   );
+
+  // Thread CRUD routes for a specific assistant
+  app.get<{
+    Params: { assistantId: string };
+  }>("/api/assistants/:assistantId/threads", threadsController.getThreadList);
+
+  app.get<{
+    Params: { assistantId: string; threadId: string };
+  }>(
+    "/api/assistants/:assistantId/threads/:threadId",
+    threadsController.getThread
+  );
+
+  app.post<{
+    Params: { assistantId: string };
+    Body: any;
+  }>("/api/assistants/:assistantId/threads", threadsController.createThread);
+
+  app.put<{
+    Params: { assistantId: string; threadId: string };
+    Body: any;
+  }>(
+    "/api/assistants/:assistantId/threads/:threadId",
+    threadsController.updateThread
+  );
+
+  app.delete<{
+    Params: { assistantId: string; threadId: string };
+  }>(
+    "/api/assistants/:assistantId/threads/:threadId",
+    threadsController.deleteThread
+  );
+
+  // Configuration routes
+  app.get(
+    "/api/config",
+    { schema: getConfigSchema },
+    configController.getConfig
+  );
+
+  app.put<{
+    Body: { config: Record<string, any> };
+  }>(
+    "/api/config",
+    { schema: updateConfigSchema },
+    configController.updateConfig
+  );
+
+  // Models routes
+  app.get("/api/models", modelsController.getModels);
+
+  app.put<{
+    Body: { models: any[] };
+  }>("/api/models", modelsController.updateModels);
 };

package/src/schemas/index.ts

@@ -245,3 +245,77 @@ export const triggerAgentTaskSchema: FastifySchema = {
     },
   },
 };
+
+// Configuration Schemas
+export const updateConfigSchema: FastifySchema = {
+  description: "Update gateway configuration",
+  tags: ["Configuration"],
+  summary: "Update Configuration",
+  body: {
+    type: "object",
+    properties: {
+      config: {
+        type: "object",
+        description: "Configuration object to update",
+        properties: {
+          port: { type: "number", description: "Server port" },
+          queueServiceType: {
+            type: "string",
+            enum: ["memory", "redis"],
+            description: "Queue service type",
+          },
+          redisUrl: { type: "string", description: "Redis URL" },
+          redisPassword: { type: "string", description: "Redis password" },
+          queueName: { type: "string", description: "Queue name" },
+        },
+      },
+    },
+    required: ["config"],
+  },
+  response: {
+    200: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        message: { type: "string" },
+        data: { type: "object" },
+      },
+    },
+    400: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        error: { type: "string" },
+      },
+    },
+    500: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        error: { type: "string" },
+      },
+    },
+  },
+};
+
+export const getConfigSchema: FastifySchema = {
+  description: "Get current gateway configuration",
+  tags: ["Configuration"],
+  summary: "Get Configuration",
+  response: {
+    200: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        data: { type: "object" },
+      },
+    },
+    500: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        error: { type: "string" },
+      },
+    },
+  },
+};

package/src/services/supabase.ts

@@ -1,15 +1,36 @@
-import { createClient } from "@supabase/supabase-js";
-import { config } from "../config";
+import { createClient, SupabaseClient } from "@supabase/supabase-js";
 // import { Database } from "@/types/database.types";
 // import { Database as PgmqPublic } from "@/types/pgmq_public.types";
-// 创建Supabase客户端
-const supabaseClient = createClient(config.supabase.url, config.supabase.key);
 
-export default supabaseClient;
+/**
+ * Get Supabase client
+ * This function reads from environment variables directly
+ */
+const getSupabaseClient = (): SupabaseClient => {
+  const url = process.env.SUPABASE_URL;
+  const key = process.env.SUPABASE_KEY;
+  if (!url || !key) {
+    throw new Error("Supabase URL and Key must be configured");
+  }
+  return createClient(url, key);
+};
+
+// Default export - creates client using current config
+// Note: Since config uses getters, this will read the latest config values
+export default getSupabaseClient();
 
+/**
+ * Create a Supabase client with tenant headers
+ * This function reads from environment variables directly
+ */
 export const createSupabaseClient = (headers: Record<string, string>) => {
   const currentTenantId = headers["x-tenant-id"];
-  return createClient(config.supabase.url, config.supabase.key, {
+  const url = process.env.SUPABASE_URL;
+  const key = process.env.SUPABASE_KEY;
+  if (!url || !key) {
+    throw new Error("Supabase URL and Key must be configured");
+  }
+  return createClient(url, key, {
     global: {
       fetch: async (input, init) => {
         const headers = new Headers(init?.headers);
@@ -20,7 +41,20 @@ export const createSupabaseClient = (headers: Record<string, string>) => {
   });
 };
 
-export const supabaseQueueClient = createClient(
-  config.supabase.url,
-  config.supabase.key
-);
+/**
+ * Get Supabase queue client
+ * This function reads from environment variables directly
+ */
+export const getSupabaseQueueClient = (): SupabaseClient => {
+  const url = process.env.SUPABASE_URL;
+  const key = process.env.SUPABASE_KEY;
+  if (!url || !key) {
+    throw new Error("Supabase URL and Key must be configured");
+  }
+  return createClient(url, key);
+};
+
+// For backward compatibility, export a client that reads config dynamically
+// Note: This creates a new client each time, but Supabase clients are lightweight
+// and this ensures we always use the latest config
+export const supabaseQueueClient = getSupabaseQueueClient();

package/src/stores/assistant_store.ts

@@ -0,0 +1,82 @@
+import { Assistant, CreateAssistantRequest } from "../types";
+
+/**
+ * In-memory store for assistants
+ * Provides CRUD operations for assistant data
+ */
+class AssistantStore {
+  private assistants: Map<string, Assistant> = new Map();
+
+  /**
+   * Get all assistants
+   */
+  getAllAssistants(): Assistant[] {
+    return Array.from(this.assistants.values());
+  }
+
+  /**
+   * Get assistant by ID
+   */
+  getAssistantById(id: string): Assistant | undefined {
+    return this.assistants.get(id);
+  }
+
+  /**
+   * Create a new assistant
+   */
+  createAssistant(
+    id: string,
+    data: CreateAssistantRequest
+  ): Assistant {
+    const now = new Date();
+    const assistant: Assistant = {
+      id,
+      name: data.name,
+      description: data.description,
+      graphDefinition: data.graphDefinition,
+      createdAt: now,
+      updatedAt: now,
+    };
+    this.assistants.set(id, assistant);
+    return assistant;
+  }
+
+  /**
+   * Update an existing assistant
+   */
+  updateAssistant(
+    id: string,
+    updates: Partial<CreateAssistantRequest>
+  ): Assistant | null {
+    const existing = this.assistants.get(id);
+    if (!existing) {
+      return null;
+    }
+
+    const updated: Assistant = {
+      ...existing,
+      ...updates,
+      updatedAt: new Date(),
+    };
+    this.assistants.set(id, updated);
+    return updated;
+  }
+
+  /**
+   * Delete an assistant by ID
+   */
+  deleteAssistant(id: string): boolean {
+    return this.assistants.delete(id);
+  }
+
+  /**
+   * Check if assistant exists
+   */
+  hasAssistant(id: string): boolean {
+    return this.assistants.has(id);
+  }
+}
+
+// Export singleton instance
+export const assistantStore = new AssistantStore();
+

package/src/stores/thread_store.ts

@@ -0,0 +1,115 @@
+import { Thread, CreateThreadRequest } from "../types";
+
+/**
+ * In-memory store for threads
+ * Provides CRUD operations for thread data
+ * Threads are organized by assistant ID
+ */
+class ThreadStore {
+  // Map<assistantId, Map<threadId, Thread>>
+  private threads: Map<string, Map<string, Thread>> = new Map();
+
+  /**
+   * Get all threads for a specific assistant
+   */
+  getThreadsByAssistantId(assistantId: string): Thread[] {
+    const assistantThreads = this.threads.get(assistantId);
+    if (!assistantThreads) {
+      return [];
+    }
+    return Array.from(assistantThreads.values());
+  }
+
+  /**
+   * Get a thread by ID for a specific assistant
+   */
+  getThreadById(assistantId: string, threadId: string): Thread | undefined {
+    const assistantThreads = this.threads.get(assistantId);
+    if (!assistantThreads) {
+      return undefined;
+    }
+    return assistantThreads.get(threadId);
+  }
+
+  /**
+   * Create a new thread for an assistant
+   */
+  createThread(
+    assistantId: string,
+    threadId: string,
+    data: CreateThreadRequest
+  ): Thread {
+    const now = new Date();
+    const thread: Thread = {
+      id: threadId,
+      assistantId,
+      metadata: data.metadata || {},
+      createdAt: now,
+      updatedAt: now,
+    };
+
+    // Initialize assistant's thread map if it doesn't exist
+    if (!this.threads.has(assistantId)) {
+      this.threads.set(assistantId, new Map());
+    }
+
+    const assistantThreads = this.threads.get(assistantId)!;
+    assistantThreads.set(threadId, thread);
+    return thread;
+  }
+
+  /**
+   * Update an existing thread
+   */
+  updateThread(
+    assistantId: string,
+    threadId: string,
+    updates: Partial<CreateThreadRequest>
+  ): Thread | null {
+    const assistantThreads = this.threads.get(assistantId);
+    if (!assistantThreads) {
+      return null;
+    }
+
+    const existing = assistantThreads.get(threadId);
+    if (!existing) {
+      return null;
+    }
+
+    const updated: Thread = {
+      ...existing,
+      metadata: {
+        ...existing.metadata,
+        ...(updates.metadata || {}),
+      },
+      updatedAt: new Date(),
+    };
+    assistantThreads.set(threadId, updated);
+    return updated;
+  }
+
+  /**
+   * Delete a thread by ID
+   */
+  deleteThread(assistantId: string, threadId: string): boolean {
+    const assistantThreads = this.threads.get(assistantId);
+    if (!assistantThreads) {
+      return false;
+    }
+    return assistantThreads.delete(threadId);
+  }
+
+  /**
+   * Check if thread exists
+   */
+  hasThread(assistantId: string, threadId: string): boolean {
+    const assistantThreads = this.threads.get(assistantId);
+    if (!assistantThreads) {
+      return false;
+    }
+    return assistantThreads.has(threadId);
+  }
+}
+
+// Export singleton instance
+export const threadStore = new ThreadStore();

package/src/types/index.ts

@@ -121,3 +121,17 @@ export interface ServiceResponse<T = any> {
   data?: T;
   error?: string;
 }
+
+// Thread type
+export interface Thread {
+  id: string;
+  assistantId: string;
+  metadata?: Record<string, any>;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+// Create thread request type
+export interface CreateThreadRequest {
+  metadata?: Record<string, any>;
+}