@axiom-lattice/gateway 1.0.20

package/src/services/agent_service.ts

@@ -0,0 +1,292 @@
+import {
+  AIMessage,
+  AIMessageChunk,
+  BaseMessage,
+  filterMessages,
+  HumanMessage,
+  ToolMessage,
+  ToolMessageChunk,
+} from "@langchain/core/messages";
+import { Command, CommandParams } from "@langchain/langgraph";
+import { v4 } from "uuid";
+// 修改导入路径，使用 lattice_core 包
+import { getAgentClient, getAgentLattice } from "@axiom-lattice/core";
+
+function isAIMessageChunk(msg: any): msg is AIMessageChunk {
+  return msg && msg.constructor.name === "AIMessageChunk";
+}
+function isToolMessageChunk(msg: any): msg is ToolMessageChunk {
+  return msg && msg.constructor.name === "ToolMessageChunk";
+}
+function isAIMessage(msg: any): msg is AIMessage {
+  return msg && msg.constructor.name === "AIMessage";
+}
+function isToolMessage(msg: any): msg is ToolMessage {
+  return msg && msg.constructor.name === "ToolMessage";
+}
+
+export async function agent_invoke({
+  input,
+  thread_id,
+  assistant_id,
+  tenant_id,
+  command,
+  run_id,
+}: {
+  assistant_id: string;
+  input: any;
+  thread_id: string;
+  tenant_id: string;
+  run_id?: string;
+  command?: CommandParams<any>;
+}) {
+  const runnable_agent = getAgentLattice(assistant_id)?.client;
+  const { files, message, ...rest } = input;
+  const humanMessage = new HumanMessage(message || "");
+  humanMessage.additional_kwargs = { files: files };
+  const messages = [humanMessage];
+  if (!runnable_agent) {
+    throw new Error(`Agent ${assistant_id} not found`);
+  }
+
+  const result = await runnable_agent.invoke(
+    command
+      ? new Command(command)
+      : { ...rest, messages, "x-tenant-id": tenant_id },
+    {
+      configurable: {
+        thread_id: thread_id,
+        run_id: run_id || v4(),
+        recursionLimit: 200,
+        "x-tenant-id": tenant_id,
+        "x-request-id": run_id,
+        "x-thread-id": thread_id,
+      },
+    }
+  );
+
+  return result;
+}
+
+export async function agent_stream({
+  input,
+  thread_id,
+  command,
+  tenant_id,
+  assistant_id,
+  run_id,
+}: {
+  assistant_id: string;
+  input: any;
+  thread_id: string;
+  command?: CommandParams<any>;
+  tenant_id: string;
+  run_id?: string;
+}) {
+  const runnable_agent = getAgentClient(assistant_id);
+  const { files, message, ...rest } = input;
+  let messages: BaseMessage[] = [];
+  if (!command) {
+    const humanMessage = new HumanMessage(message);
+    humanMessage.additional_kwargs = { files: files };
+    messages = [humanMessage];
+  }
+
+  try {
+    if (!runnable_agent) {
+      throw new Error(`Agent ${assistant_id} not found`);
+    }
+    const agentStream = await runnable_agent.stream(
+      command
+        ? new Command(command)
+        : {
+            ...rest,
+            messages,
+            "x-tenant-id": tenant_id,
+          },
+
+      {
+        configurable: {
+          thread_id: thread_id,
+          run_id: run_id || v4(),
+          "x-tenant-id": tenant_id,
+          "x-request-id": run_id,
+          "x-thread-id": thread_id,
+        },
+        streamMode: ["updates", "messages"],
+        subgraphs: false,
+      }
+    );
+
+    // 创建一个可迭代的 ReadableStream
+    return {
+      [Symbol.asyncIterator]: async function* () {
+        try {
+          for await (const chunk of agentStream) {
+            //            console.log("-----chunk----", chunk);
+            let data;
+            // for (const [node, values] of Object.entries(chunk)) {
+            //   console.log(`Receiving update from node: ${node}`);
+            //   console.log(values);
+            //   console.log("\n====\n");
+            // }
+            //console.log("chunk", JSON.stringify(chunk));
+            // if (chunk[0] === "updates") {
+            //   const updates = chunk[1];
+            //   console.log("update", updates);
+            // }
+            if (chunk[0] === "messages") {
+              //console.log(chunk[1][0]);
+              const messages = chunk[1];
+              data = messages?.[0]?.toDict();
+
+              // const messagesArray = messages
+              //   .map((message: any) => {
+              //     if (isAIMessageChunk(message)) {
+              //       return {
+              //         id: message.id,
+              //         role: "ai",
+              //         name: message.name,
+              //         content: message.content,
+              //         type: "message_chunk",
+              //         tool_calls: message.tool_calls,
+              //         tool_call_chunks: message.tool_call_chunks,
+              //       };
+              //     } else if (isToolMessage(message)) {
+              //       return {
+              //         id: message.id,
+              //         role: "tool",
+              //         content: message.content,
+              //         type: "tool_message",
+              //         tool_call_id: message.tool_call_id,
+              //         name: message.name,
+              //       };
+              //     } else if (isAIMessage(message)) {
+              //       return {
+              //         id: message.id,
+              //         role: "ai",
+              //         content: message.content,
+              //         type: "message",
+              //       };
+              //     } else if (isToolMessageChunk(message)) {
+              //       return {
+              //         id: message.id,
+              //         role: "tool",
+              //         type: "tool_message_chunk",
+              //         content: message.content,
+              //       };
+              //     }
+              //   })
+              //   .filter((item: any) => item);
+              // // 如果messagesArray为空，则不返回数据,如果返回数据会导致界面清掉历史message
+              // if (messagesArray.length > 0) {
+              //   data = {
+              //     messages: messagesArray,
+              //   };
+              // }
+            }
+
+            if ((chunk?.[1] as any)?.__interrupt__) {
+              data = chunk?.[1]?.[0]?.toDict();
+              // 原有的中断消息处理
+              // data = {
+              //   messages: [
+              //     {
+              //       role: "ai",
+              //       content: (chunk?.[1] as any)?.__interrupt__[0].value,
+              //       type: "action",
+              //     },
+              //   ],
+              // };
+            }
+
+            if (data) {
+              console.log(data);
+              yield data;
+            }
+          }
+        } catch (error) {
+          console.error("Stream error:", error);
+          throw error;
+        }
+      },
+    };
+  } catch (error) {
+    throw error;
+  }
+}
+
+export async function agent_state({
+  thread_id,
+  assistant_id,
+}: {
+  assistant_id: string;
+  thread_id: string;
+}) {
+  const runnable_agent = getAgentClient(assistant_id);
+  if (!runnable_agent) {
+    throw new Error(`Agent ${assistant_id} not found`);
+  }
+  const state = await runnable_agent.getState({
+    configurable: { thread_id: thread_id, subgraphs: false },
+  });
+  return state;
+}
+
+export async function agent_messages({
+  thread_id,
+  tenant_id,
+  assistant_id,
+}: {
+  assistant_id: string;
+  thread_id: string;
+  tenant_id: string;
+}) {
+  const runnable_agent = getAgentClient(assistant_id);
+  if (!runnable_agent) {
+    throw new Error(`Agent ${assistant_id} not found`);
+  }
+  const state = await runnable_agent.getState({
+    configurable: { thread_id: thread_id, subgraphs: false },
+  });
+
+  const messages = state.values.messages || [];
+  const filteredMessages = filterMessages(messages, {
+    includeTypes: ["ai", "human", "tool"], //["human", "ai", "tool"],
+  });
+
+  //  console.log(filteredMessages);
+
+  let messagesArray = filteredMessages.map((message: BaseMessage) => ({
+    id: message.id,
+    role: message.getType(),
+    content: message.content,
+    files: message.additional_kwargs.files,
+    ...message.lc_kwargs,
+  }));
+
+  const action_messages = state.tasks.flatMap((task) => {
+    return task.interrupts.map((interrupt) => {
+      return {
+        role: "ai",
+        content: interrupt.value,
+        type: "action",
+      };
+    });
+  });
+
+  const new_messages = [...messagesArray, ...action_messages];
+  // console.log(messagesArray);
+
+  return new_messages;
+}
+
+export async function draw_graph(assistant_id: string) {
+  const runnable_agent = getAgentClient(assistant_id);
+  if (!runnable_agent) {
+    throw new Error(`Agent ${assistant_id} not found`);
+  }
+  const drawableGraph = await runnable_agent.getGraphAsync();
+  const image = await drawableGraph.drawMermaid();
+  return image;
+}

package/src/services/agent_task_types.ts

@@ -0,0 +1,2 @@
+// 任务事件名称
+export const AGENT_TASK_EVENT = "agent:execute";

package/src/services/event_bus.ts

@@ -0,0 +1,62 @@
+import { EventEmitter } from "events";
+import { pushAgentTaskToQueue } from "./queue_service";
+
+/**
+ * 事件总线服务
+ * 用于系统内部组件间的事件发布与订阅
+ */
+class EventBus {
+  private emitter: EventEmitter;
+
+  constructor() {
+    this.emitter = new EventEmitter();
+    // 设置最大监听器数量，避免内存泄漏警告
+    this.emitter.setMaxListeners(100);
+  }
+
+  /**
+   * 发布事件
+   * @param eventName 事件名称
+   * @param data 事件数据
+   */
+  publish(eventName: string, data: any, useQueue: boolean = false): void {
+    //console.log(`发布事件: ${eventName}`, data);
+    if (useQueue) {
+      pushAgentTaskToQueue(data);
+    } else {
+      this.emitter.emit(eventName, data);
+    }
+  }
+
+  /**
+   * 订阅事件
+   * @param eventName 事件名称
+   * @param callback 回调函数
+   */
+  subscribe(eventName: string, callback: (data: any) => void): void {
+    this.emitter.on(eventName, callback);
+  }
+
+  /**
+   * 取消订阅事件
+   * @param eventName 事件名称
+   * @param callback 回调函数
+   */
+  unsubscribe(eventName: string, callback: (data: any) => void): void {
+    this.emitter.off(eventName, callback);
+  }
+
+  /**
+   * 只订阅一次事件
+   * @param eventName 事件名称
+   * @param callback 回调函数
+   */
+  subscribeOnce(eventName: string, callback: (data: any) => void): void {
+    this.emitter.once(eventName, callback);
+  }
+}
+
+// 创建单例实例
+const eventBus = new EventBus();
+
+export default eventBus;

package/src/services/queue_service.ts

@@ -0,0 +1,82 @@
+import { createClient } from "redis";
+
+// 创建Redis客户端 - 使用正确的密码
+const redisOptions: any = {
+  url: process.env.REDIS_URL || "redis://localhost:6379",
+  password: process.env.REDIS_PASSWORD,
+};
+
+const redisClient = createClient(redisOptions);
+
+// 连接Redis
+(async () => {
+  redisClient.on("error", (err: Error) =>
+    console.error("Redis Client Error", err)
+  );
+  try {
+    await redisClient.connect();
+    console.log("Redis连接成功");
+  } catch (error) {
+    console.error("Redis连接失败:", error);
+  }
+})();
+
+const queue_name = process.env.QUEUE_NAME || "tasks"; // 队列名称,本地开发需要自己配置自己的队列
+
+//Enqueue Message
+const sendToQueue = async (queue_name: string, message: any) => {
+  try {
+    // 将消息推送到队列
+    const result = await redisClient.lPush(queue_name, JSON.stringify(message));
+    console.log("lPush", result);
+    return { data: result, error: null };
+  } catch (error) {
+    console.error(error);
+    return { data: null, error };
+  }
+};
+
+//Dequeue Message
+const popFromQueue = async (queue_name: string) => {
+  try {
+    // 从队列中获取消息
+    const message = await redisClient.rPop(queue_name);
+    if (message) {
+      return { data: JSON.parse(message), error: null };
+    }
+    return { data: null, error: null };
+  } catch (error) {
+    console.error(error);
+    return { data: null, error };
+  }
+};
+
+const createTenantQueue = async () => {
+  // Redis不需要显式创建队列，但我们可以保留这个函数以保持API兼容
+  // 可以进行一些初始化操作，如检查队列是否存在
+  try {
+    const exists = await redisClient.exists(queue_name);
+    return { success: true, queue_name };
+  } catch (error) {
+    console.error(error);
+    return { success: false, error };
+  }
+};
+
+export const pushAgentTaskToQueue = async (agentTask: any) => {
+  const tenantId = agentTask["x-tenant-id"];
+
+  try {
+    await createTenantQueue();
+    const result = await sendToQueue(`${queue_name}`, agentTask);
+    return result;
+  } catch (error) {
+    console.error(error);
+    return null;
+  }
+};
+
+export const popAgentTaskFromQueue = async () => {
+  const result = await popFromQueue(`${queue_name}`);
+  return result;
+};

package/src/services/supabase.ts

@@ -0,0 +1,26 @@
+import { createClient } from "@supabase/supabase-js";
+import { config } from "../config";
+// 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;
+
+export const createSupabaseClient = (headers: Record<string, string>) => {
+  const currentTenantId = headers["x-tenant-id"];
+  return createClient(config.supabase.url, config.supabase.key, {
+    global: {
+      fetch: async (input, init) => {
+        const headers = new Headers(init?.headers);
+        if (currentTenantId) headers.set("x-tenant-id", currentTenantId);
+        return fetch(input, { ...init, headers });
+      },
+    },
+  });
+};
+
+export const supabaseQueueClient = createClient(
+  config.supabase.url,
+  config.supabase.key
+);

package/src/types/index.ts

@@ -0,0 +1,123 @@
+// 助手类型
+export interface Assistant {
+  id: string;
+  name: string;
+  description?: string;
+  graphDefinition: any;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+// 运行状态枚举
+export enum RunStatus {
+  CREATED = "created",
+  RUNNING = "running",
+  COMPLETED = "completed",
+  FAILED = "failed",
+  WAITING_FOR_INPUT = "waiting_for_input",
+  CANCELLED = "cancelled",
+}
+
+// 运行类型
+export interface Run {
+  id: string;
+  assistantId: string;
+  status: RunStatus;
+  input: any;
+  output?: any;
+  error?: string;
+  checkpoints: any[];
+  createdAt: Date;
+  updatedAt: Date;
+  completedAt?: Date;
+}
+
+// 消息类型
+export interface Message {
+  id: string;
+  runId: string;
+  role: "user" | "assistant" | "system";
+  content: any;
+  createdAt: Date;
+}
+
+// 内存存储类型
+export interface MemoryItem {
+  id: string;
+  assistantId: string;
+  key: string;
+  value: any;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+// 定时任务类型
+export interface CronJob {
+  id: string;
+  assistantId: string;
+  name: string;
+  schedule: string;
+  action: any;
+  isActive: boolean;
+  lastRunAt?: Date;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+// Webhook类型
+export interface Webhook {
+  id: string;
+  assistantId: string;
+  url: string;
+  events: string[];
+  isActive: boolean;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+// 创建助手请求类型
+export interface CreateAssistantRequest {
+  name: string;
+  description?: string;
+  graphDefinition: any;
+}
+
+// 创建运行请求类型
+export interface CreateRunRequest {
+  tenant_id: string;
+  thread_id: string;
+  assistant_id: string;
+  message: any;
+  command?: any;
+  streaming?: boolean;
+  background?: boolean;
+}
+
+// 添加消息请求类型
+export interface AddMessageRequest {
+  runId: string;
+  role: "user" | "assistant" | "system";
+  content: any;
+}
+
+// 流式响应类型
+export interface StreamEvent {
+  type: "start" | "data" | "end" | "error" | "heartbeat";
+  data?: any;
+  error?: string;
+}
+
+// 双重消息处理策略
+export enum DoubleTextStrategy {
+  IGNORE = 0,
+  QUEUE = 1,
+  CANCEL_PREVIOUS = 2,
+  RESTART = 3,
+}
+
+// 服务响应类型
+export interface ServiceResponse<T = any> {
+  success: boolean;
+  data?: T;
+  error?: string;
+}

package/src/types/koa.d.ts

@@ -0,0 +1,7 @@
+import "koa";
+
+declare module "koa" {
+  interface Request {
+    body?: any;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "preserve",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "moduleResolution": "Bundler",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "types": ["node", "jest"],
+    "paths": {
+      "@*": ["./src/*"]
+    },
+    "sourceMap": true,
+    "incremental": true, // 确保启用增量编译
+    "tsBuildInfoFile": "./.tsbuildinfo" // 指定构建信息文件位置
+  },
+  "include": ["src/index.ts"],
+  "exclude": ["node_modules", "dist"]
+}