@axiom-lattice/gateway 3.0.2 → 3.0.3

package/src/services/agent_task_consumer.ts

@@ -1,348 +0,0 @@
-import { eventBus, AGENT_TASK_EVENT, agentInstanceManager, QueueMode } from "@axiom-lattice/core";
-import { popAgentTaskFromQueue } from "./queue_service";
-
-// 任务请求结构
-export interface AgentTaskRequest {
-  assistant_id: string;
-  input: any;
-  thread_id: string;
-  "x-tenant-id": string;
-  command?: any;
-  callback_event?: string;
-  runConfig?: Record<string, any>;
-  main_thread_id?: string;
-  main_tenant_id?: string;
-  main_assistant_id?: string;
-}
-
-/**
- * 处理Agent任务事件
- * @param taskRequest 任务请求
- * @param retryCount 重试次数
- */
-const handleAgentTask = async (
-  taskRequest: AgentTaskRequest,
-  retryCount: number = 0
-): Promise<boolean> => {
-  const {
-    assistant_id,
-    input = {},
-    thread_id,
-    "x-tenant-id": tenant_id,
-    command,
-    callback_event,
-    runConfig,
-    main_thread_id,
-    main_tenant_id,
-    main_assistant_id,
-  } = taskRequest;
-
-
-  try {
-    console.log(
-      `开始处理任务 [assistant_id: ${assistant_id}, thread_id: ${thread_id}]`
-    );
-
-    // 检查API服务器是否可用
-    //    const apiUrl = AgentTaskConsumer.agent_run_endpoint;
-
-    //   console.log(`apiUrl: ${apiUrl}`);
-    const agent = agentInstanceManager.getAgent({ assistant_id, thread_id, tenant_id, workspace_id: runConfig?.workspaceId, project_id: runConfig?.projectId, custom_run_config: runConfig })
-    await agent.addMessage({ input, command, custom_run_config: runConfig }, QueueMode.STEER);
-    if (callback_event) {
-      agent.subscribeOnce("message:completed", (evt) => {
-        eventBus.publish(callback_event, {
-          success: true,
-          state: evt.state,
-        });
-
-        if (main_thread_id && main_tenant_id) {
-          try {
-            const mainAgent = agentInstanceManager.getAgent({
-              assistant_id: main_assistant_id ?? assistant_id,
-              thread_id: main_thread_id,
-              tenant_id: main_tenant_id,
-              workspace_id: runConfig?.workspaceId,
-              project_id: runConfig?.projectId,
-            });
-            if (mainAgent) {
-              const messages = evt.state?.values?.messages;
-              const lastAIMessage = messages
-                ?.filter((m: any) => m.type === 'ai' || m.getType?.() === 'ai')
-                .pop();
-              const summary = lastAIMessage?.content
-                ?.substring(0, 500) ?? '(no output)';
-
-              mainAgent.addMessage(
-                {
-                  input: {
-                    message: `[Async task completed]\ntask_id: ${thread_id}\n${summary}`,
-                  },
-                },
-              ).catch((err: Error) => {
-                console.error('Failed to notify main thread:', err);
-              });
-
-              mainAgent.updateAsyncTaskStatus(thread_id, 'completed');
-            }
-          } catch (err) {
-            console.error('Failed to notify main thread:', err);
-          }
-        }
-      })
-      agent.subscribeOnce("message:interrupted", (evt) => {
-        eventBus.publish(callback_event, {
-          success: true,
-          state: evt.state,
-        });
-      })
-    }
-
-    return true;
-
-
-
-  } catch (error) {
-    console.error(
-      `Agent任务执行失败: ${assistant_id}, 线程: ${thread_id}`,
-      error
-    );
-
-    // 重试逻辑，暂不用重试
-    const maxRetries = 0;
-    if (retryCount < maxRetries) {
-      const nextRetryCount = retryCount + 1;
-      const delayMs = Math.pow(2, nextRetryCount) * 1000; // 指数退避策略
-
-      console.log(
-        `将在 ${delayMs}ms 后重试任务 (${nextRetryCount}/${maxRetries})`
-      );
-
-      // 延迟后重试
-      await new Promise((resolve) => setTimeout(resolve, delayMs));
-      return handleAgentTask(taskRequest, nextRetryCount);
-    }
-
-    if (callback_event) {
-      eventBus.publish(callback_event, {
-        success: false,
-        error: error instanceof Error ? error.message : String(error),
-      });
-    }
-
-    console.error(
-      `任务处理失败，已达到最大重试次数 [assistant_id: ${assistant_id}, thread_id: ${thread_id}]`
-    );
-    return false;
-  }
-};
-
-/**
- * Agent任务消费者
- * 负责监听和执行Agent任务事件，同时从队列中消费任务
- */
-export class AgentTaskConsumer {
-  private isPolling: boolean = false;
-  private pollingInterval: NodeJS.Timeout | null = null;
-  private pollingIntervalMs: number = 5000; // 默认5秒轮询一次
-  private maxConcurrentTasks: number = 15; // 最大并发任务数
-  private activeTasks: number = 0; // 当前活跃的任务数
-  private processing: boolean = false; // 是否正在处理任务批次
-  private immediateProcessingEnabled: boolean = true; // 是否启用即时处理模式
-  public gatewayPort: number = 4001;
-  public static agent_run_endpoint: string = "http://localhost:4001/api/runs";
-
-  constructor(gatewayPort: number, pollingIntervalMs?: number) {
-    this.gatewayPort = gatewayPort;
-    AgentTaskConsumer.agent_run_endpoint = `http://localhost:${this.gatewayPort}/api/runs`;
-    if (pollingIntervalMs) {
-      this.pollingIntervalMs = pollingIntervalMs;
-    }
-    this.initialize();
-  }
-
-  /**
-   * 初始化事件监听和队列轮询
-   */
-  private initialize(): void {
-    // 监听事件总线上的任务
-    eventBus.subscribe(AGENT_TASK_EVENT, this.trigger_agent_task.bind(this));
-
-    // 启动队列轮询
-    this.startPollingQueue();
-
-    console.log("Agent任务消费者已启动并监听任务事件和队列");
-  }
-
-  /**
-   * 启动队列轮询
-   */
-  startPollingQueue(): void {
-    if (this.isPolling) {
-      return;
-    }
-
-    this.isPolling = true;
-
-    this.pollingInterval = setInterval(async () => {
-      try {
-        // 如果上一批次任务还在处理中，跳过本次轮询
-        if (this.processing) {
-          console.log("队列处理中，跳过本次轮询");
-          return;
-        }
-
-        await this.consumeFromQueue();
-      } catch (error) {
-        console.error("队列轮询出错:", error);
-      }
-    }, this.pollingIntervalMs);
-
-    console.log(
-      `开始轮询队列，间隔: ${this.pollingIntervalMs}ms，最大并发任务数: ${this.maxConcurrentTasks}`
-    );
-  }
-
-  /**
-   * 停止队列轮询
-   */
-  stopPollingQueue(): void {
-    if (this.pollingInterval) {
-      clearInterval(this.pollingInterval);
-      this.pollingInterval = null;
-      this.isPolling = false;
-      console.log("已停止队列轮询");
-    }
-  }
-
-  /**
-   * 处理单个任务并在完成后立即尝试处理下一个
-   */
-  async processNextTask(): Promise<boolean> {
-    try {
-      // 从队列中获取任务
-      const queueResult = await popAgentTaskFromQueue();
-
-      // 检查队列结果
-      if (queueResult && queueResult.data) {
-        const taskItem = queueResult.data;
-
-        if (taskItem && typeof taskItem === "object") {
-          const taskRequest = taskItem as AgentTaskRequest;
-
-          console.log(
-            `从队列中获取到任务 [assistant: ${taskRequest.assistant_id}, thread: ${taskRequest.thread_id}]`
-          );
-
-          // 增加活跃任务计数
-          this.activeTasks++;
-
-          // 处理任务（不使用await，允许并发执行）
-          handleAgentTask(taskRequest)
-            .then((success) => {
-              if (!success) {
-                console.error(`任务 处理失败`);
-                // 可以在这里记录失败任务或执行补偿逻辑
-              } else {
-                console.log(`任务 处理成功`);
-              }
-            })
-            .catch((error) => {
-              console.error(`任务 处理时出错:`, error);
-            })
-            .finally(() => {
-              // 减少活跃任务计数
-              this.activeTasks--;
-
-              // 如果启用了即时处理模式，尝试处理更多任务
-              if (this.immediateProcessingEnabled && !this.processing) {
-                this.checkQueueForTasks();
-              }
-            });
-
-          // 任务已派发，返回true表示有任务被处理
-          return true;
-        } else {
-          console.log("队列任务格式无效:", taskItem);
-          return false;
-        }
-      } else {
-        // 队列为空
-        return false;
-      }
-    } catch (error) {
-      console.error("处理任务失败:", error);
-      return false;
-    }
-  }
-
-  /**
-   * 检查队列中是否有任务并处理
-   */
-  async checkQueueForTasks(): Promise<void> {
-    // 如果已经在处理中或者并发任务已达上限，则不处理
-    if (this.processing || this.activeTasks >= this.maxConcurrentTasks) {
-      return;
-    }
-
-    this.processing = true;
-
-    try {
-      // 尝试获取并处理任务，直到达到并发上限
-      while (this.activeTasks < this.maxConcurrentTasks) {
-        const taskProcessed = await this.processNextTask();
-        if (!taskProcessed) {
-          // 没有更多任务，退出循环
-          break;
-        }
-      }
-    } catch (error) {
-      console.error("检查队列任务失败:", error);
-    } finally {
-      this.processing = false;
-    }
-  }
-
-  /**
-   * 从队列中消费任务
-   */
-  async consumeFromQueue(): Promise<void> {
-    // 如果已经在处理中，跳过
-    if (this.processing) {
-      return;
-    }
-
-    // 调用任务检查方法
-    await this.checkQueueForTasks();
-  }
-
-  /**
-   * 处理通过事件触发的任务
-   */
-  trigger_agent_task(taskRequest: AgentTaskRequest): void {
-    console.log(
-      `通过事件触发任务: [assistant: ${taskRequest.assistant_id}, thread: ${taskRequest.thread_id}]`
-    );
-
-    // 处理任务，不阻塞事件处理流程
-    handleAgentTask(taskRequest).catch((error) => {
-      console.error("处理Agent任务时发生未捕获的错误:", error);
-
-      // 如果有回调事件，确保即使发生错误也能通知
-      if (taskRequest.callback_event) {
-        eventBus.publish(taskRequest.callback_event, {
-          success: false,
-          error: error instanceof Error ? error.message : String(error),
-        });
-      }
-    });
-
-    // 如果启用了即时处理且当前活跃任务数低于阈值，检查队列
-    if (
-      this.immediateProcessingEnabled &&
-      this.activeTasks < this.maxConcurrentTasks
-    ) {
-      setImmediate(() => this.checkQueueForTasks());
-    }
-  }
-}

package/src/services/collection_service.ts

@@ -1,258 +0,0 @@
-/**
- * CollectionService
- *
- * Business logic layer for collection management and entry operations.
- * Uses CollectionLatticeManager for registration, VectorStoreLatticeManager for storage,
- * and EmbeddingsLatticeManager for vector embedding.
- * All vector store operations are tenant-isolated.
- */
-
-import { v4 as uuidv4 } from "uuid";
-import { Document } from "@langchain/core/documents";
-import {
-  collectionLatticeManager,
-  embeddingsLatticeManager,
-  getOrCreateCollectionVectorStore,
-  getCollectionEntryCount,
-  listCollectionEntries,
-  removeCollectionVectorStore,
-} from "@axiom-lattice/core";
-import type {
-  Collection,
-  CreateCollectionRequest,
-  UpdateCollectionRequest,
-} from "@axiom-lattice/protocols";
-import { FastifyRequest } from "fastify";
-
-function getTenantId(request: FastifyRequest): string {
-  return (
-    (request as any).user?.tenantId ||
-    (request.headers["x-tenant-id"] as string) ||
-    "default"
-  );
-}
-
-export interface EntryResponse {
-  id: string;
-  content: string;
-  metadata: Record<string, unknown>;
-  score?: number;
-}
-
-export class CollectionService {
-  // ─── Collection CRUD ──────────────────────────────────────────
-
-  async getAllCollections(request: FastifyRequest): Promise<Collection[]> {
-    const tenantId = getTenantId(request);
-    const collections = await collectionLatticeManager.getAllCollections(tenantId);
-
-    for (const c of collections) {
-      try {
-        (c as any)._entryCount = await getCollectionEntryCount(c.name, c.embeddingKey, c.tenantId);
-      } catch {
-        (c as any)._entryCount = 0;
-      }
-    }
-
-    return collections;
-  }
-
-  async getCollectionByName(
-    request: FastifyRequest,
-    name: string
-  ): Promise<Collection | null> {
-    const tenantId = getTenantId(request);
-    return collectionLatticeManager.getCollection(tenantId, name);
-  }
-
-  async createCollection(
-    request: FastifyRequest,
-    data: CreateCollectionRequest
-  ): Promise<Collection> {
-    const tenantId = getTenantId(request);
-    const collection = await collectionLatticeManager.registerCollection(tenantId, data);
-
-    try {
-      await getOrCreateCollectionVectorStore(data.name, data.embeddingKey, tenantId);
-    } catch (err) {
-      console.warn(`[CollectionService] Failed to init vector store for ${data.name}:`, err);
-    }
-
-    return collection;
-  }
-
-  async updateCollection(
-    request: FastifyRequest,
-    name: string,
-    updates: UpdateCollectionRequest
-  ): Promise<Collection | null> {
-    const tenantId = getTenantId(request);
-    return collectionLatticeManager.updateCollection(tenantId, name, updates);
-  }
-
-  async deleteCollection(
-    request: FastifyRequest,
-    name: string
-  ): Promise<boolean> {
-    const tenantId = getTenantId(request);
-    await removeCollectionVectorStore(name, tenantId);
-    return collectionLatticeManager.removeCollection(tenantId, name);
-  }
-
-  // ─── Entry CRUD ───────────────────────────────────────────────
-
-  async getEntries(
-    request: FastifyRequest,
-    collectionName: string
-  ): Promise<EntryResponse[]> {
-    const collection = await this.getCollectionByName(request, collectionName);
-    if (!collection) throw new Error(`Collection "${collectionName}" not found`);
-
-    const docs = await listCollectionEntries(collectionName, collection.embeddingKey, collection.tenantId);
-
-    return docs.map((doc: Document) => ({
-      id: (doc.metadata._id as string) || "",
-      content: doc.pageContent,
-      metadata: Object.fromEntries(
-        Object.entries(doc.metadata).filter(([k]) => !k.startsWith("_"))
-      ),
-    }));
-  }
-
-  async createEntry(
-    request: FastifyRequest,
-    collectionName: string,
-    data: { content: string; metadata?: Record<string, unknown> }
-  ): Promise<EntryResponse> {
-    const collection = await this.getCollectionByName(request, collectionName);
-    if (!collection) throw new Error(`Collection "${collectionName}" not found`);
-
-    const vectorStore = await getOrCreateCollectionVectorStore(
-      collectionName, collection.embeddingKey, collection.tenantId
-    );
-
-    const entryId = uuidv4();
-    const now = new Date().toISOString();
-    const doc = new Document({
-      pageContent: data.content,
-      metadata: {
-        _id: entryId,
-        _created_at: now,
-        _updated_at: now,
-        ...(data.metadata || {}),
-      },
-    });
-
-    await vectorStore.addDocuments([doc]);
-
-    return { id: entryId, content: data.content, metadata: data.metadata || {} };
-  }
-
-  async getEntry(
-    request: FastifyRequest,
-    collectionName: string,
-    entryId: string
-  ): Promise<EntryResponse | null> {
-    const collection = await this.getCollectionByName(request, collectionName);
-    if (!collection) throw new Error(`Collection "${collectionName}" not found`);
-
-    const docs = await listCollectionEntries(collectionName, collection.embeddingKey, collection.tenantId);
-    const doc = docs.find((d: Document) => d.metadata._id === entryId);
-    if (!doc) return null;
-    return {
-      id: entryId,
-      content: doc.pageContent,
-      metadata: Object.fromEntries(
-        Object.entries(doc.metadata).filter(([k]) => !k.startsWith("_"))
-      ),
-    };
-  }
-
-  async updateEntry(
-    request: FastifyRequest,
-    collectionName: string,
-    entryId: string,
-    data: { content?: string; metadata?: Record<string, unknown> }
-  ): Promise<EntryResponse | null> {
-    const existing = await this.getEntry(request, collectionName, entryId);
-    if (!existing) return null;
-
-    const collection = await this.getCollectionByName(request, collectionName);
-    if (!collection) throw new Error(`Collection "${collectionName}" not found`);
-
-    const vectorStore = await getOrCreateCollectionVectorStore(
-      collectionName, collection.embeddingKey, collection.tenantId
-    );
-
-    try {
-      await vectorStore.delete({ filter: { _id: entryId } } as any);
-    } catch {
-      // best effort
-    }
-
-    const now = new Date().toISOString();
-    const mergedMetadata = { ...existing.metadata, ...(data.metadata || {}) };
-    const doc = new Document({
-      pageContent: data.content ?? existing.content,
-      metadata: { _id: entryId, _created_at: now, _updated_at: now, ...mergedMetadata },
-    });
-
-    await vectorStore.addDocuments([doc]);
-
-    return { id: entryId, content: data.content ?? existing.content, metadata: mergedMetadata };
-  }
-
-  async deleteEntry(
-    request: FastifyRequest,
-    collectionName: string,
-    entryId: string
-  ): Promise<boolean> {
-    const collection = await this.getCollectionByName(request, collectionName);
-    if (!collection) throw new Error(`Collection "${collectionName}" not found`);
-
-    const vectorStore = await getOrCreateCollectionVectorStore(
-      collectionName, collection.embeddingKey, collection.tenantId
-    );
-
-    try {
-      await vectorStore.delete({ filter: { _id: entryId } } as any);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  async searchEntries(
-    request: FastifyRequest,
-    collectionName: string,
-    params: { query: string; filter?: Record<string, unknown>; top_k?: number }
-  ): Promise<EntryResponse[]> {
-    const collection = await this.getCollectionByName(request, collectionName);
-    if (!collection) throw new Error(`Collection "${collectionName}" not found`);
-
-    const vectorStore = await getOrCreateCollectionVectorStore(
-      collectionName, collection.embeddingKey, collection.tenantId
-    );
-
-    let embeddings;
-    try {
-      embeddings = embeddingsLatticeManager.getEmbeddingsClient(collection.embeddingKey);
-    } catch {
-      embeddings = embeddingsLatticeManager.getEmbeddingsClient("default");
-    }
-
-    const queryVector = await embeddings.embedQuery(params.query);
-    const results = await vectorStore.similaritySearchVectorWithScore(
-      queryVector, params.top_k || 5, params.filter as any
-    );
-
-    return results.map(([doc, score]: [Document, number]) => ({
-      id: (doc.metadata._id as string) || uuidv4(),
-      content: doc.pageContent,
-      metadata: Object.fromEntries(
-        Object.entries(doc.metadata).filter(([k]) => !k.startsWith("_"))
-      ),
-      score,
-    }));
-  }
-}