@axiom-lattice/gateway 2.1.44 → 2.1.45

package/src/services/agent_service.ts

@@ -1,375 +0,0 @@
-import {
-  AIMessage,
-  AIMessageChunk,
-  BaseMessage,
-  filterMessages,
-  HumanMessage,
-  ToolMessage,
-  ToolMessageChunk,
-} from "@langchain/core/messages";
-import { Command, CommandParams } from "@langchain/langgraph";
-import { v4 } from "uuid";
-import {
-  getAgentClient,
-  agentLatticeManager,
-  InMemoryChunkBuffer,
-  registerChunkBuffer,
-  getChunkBuffer,
-  hasChunkBuffer,
-} from "@axiom-lattice/core";
-
-/**
- * Check if an agent exists for the given tenant and assistant ID
- */
-export async function checkAgentExists(
-  tenant_id: string,
-  assistant_id: string
-): Promise<boolean> {
-  try {
-    const agentLattice = agentLatticeManager.getAgentLatticeWithTenant(tenant_id, assistant_id);
-    return agentLattice !== undefined;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Get or create the global ChunkBuffer instance
- */
-function getOrCreateChunkBuffer(): InMemoryChunkBuffer {
-  if (!hasChunkBuffer("default")) {
-    const buffer = new InMemoryChunkBuffer({
-      ttl: 60 * 60 * 1000, // 1 hour TTL
-      cleanupInterval: 5 * 60 * 1000, // Clean every 5 minutes
-    });
-    registerChunkBuffer("default", buffer);
-  }
-  return getChunkBuffer("default") as InMemoryChunkBuffer;
-}
-
-export async function agent_invoke({
-  input,
-  thread_id,
-  assistant_id,
-  tenant_id,
-  workspace_id,
-  project_id,
-  command,
-  run_id,
-  custom_run_config,
-}: {
-  assistant_id: string;
-  input: any;
-  thread_id: string;
-  tenant_id: string;
-  workspace_id?: string;
-  project_id?: string;
-  run_id?: string;
-  command?: CommandParams<any>;
-  custom_run_config?: Record<string, any>;
-}) {
-  const agentLattice = agentLatticeManager.getAgentLatticeWithTenant(tenant_id, assistant_id);
-  const runnable_agent = agentLattice?.client;
-
-  const { message, ...rest } = input;
-  const humanMessage = new HumanMessage(message || "");
-  const messages = [humanMessage];
-  if (!runnable_agent) {
-    throw new Error(`Agent ${assistant_id} not found`);
-  }
-
-  // Get runConfig from agent config and merge with custom_run_config
-  const runConfig = {
-    ...agentLattice?.config?.runConfig || {},
-    tenantId: tenant_id,
-    workspaceId: workspace_id,
-    projectId: project_id,
-    ...custom_run_config || {},
-    assistant_id,
-
-  }
-
-  const result = await runnable_agent.invoke(
-    command
-      ? new Command(command)
-      : { ...rest, messages, "x-tenant-id": tenant_id },
-    {
-      context: {
-        runConfig
-      },
-      configurable: {
-        thread_id: thread_id,
-        run_id: run_id || v4(),
-        "x-tenant-id": tenant_id,
-        "x-workspace-id": workspace_id,
-        "x-project-id": project_id,
-        "x-request-id": run_id,
-        "x-thread-id": thread_id,
-        "x-assistant-id": assistant_id,
-        runConfig,
-      },
-      recursionLimit: 200,
-    }
-  );
-
-  const data = result.messages.map((message: BaseMessage) => {
-    const { type, data } = message.toDict();
-    return {
-      ...data,
-      role: type,
-    };
-  });
-  return { messages: data };
-}
-
-export async function agent_stream({
-  input,
-  thread_id,
-  command,
-  tenant_id,
-  workspace_id,
-  project_id,
-  assistant_id,
-  run_id,
-  custom_run_config,
-}: {
-  assistant_id: string;
-  input: any;
-  thread_id: string;
-  command?: CommandParams<any>;
-  tenant_id: string;
-  workspace_id?: string;
-  project_id?: string;
-  run_id?: string;
-  custom_run_config?: Record<string, any>;
-}) {
-  const runnable_agent = await getAgentClient(tenant_id, assistant_id);
-  const agentLattice = agentLatticeManager.getAgentLatticeWithTenant(tenant_id, assistant_id);
-  const { message, ...rest } = input;
-  let messages: BaseMessage[] = [];
-  if (!command) {
-    const humanMessage = new HumanMessage(message);
-    messages = [humanMessage];
-  }
-
-  // Get ChunkBuffer instance
-  const chunkBuffer = getOrCreateChunkBuffer();
-
-  // Get runConfig from agent config and merge with custom_run_config
-  const runConfig = {
-    ...agentLattice?.config?.runConfig || {},
-    tenantId: tenant_id,
-    workspaceId: workspace_id,
-    projectId: project_id,
-    ...custom_run_config || {},
-    assistant_id,
-
-  }
-
-  try {
-    if (!runnable_agent) {
-      throw new Error(`Agent ${assistant_id} not found`);
-    }
-    const agentStream = await (runnable_agent as any).stream(
-      command
-        ? new Command(command)
-        : {
-          ...rest,
-          messages,
-          "x-tenant-id": tenant_id,
-        },
-
-      {
-        context: {
-          runConfig
-        },
-        configurable: {
-          thread_id: thread_id,
-          run_id: run_id || v4(),
-          "x-tenant-id": tenant_id,
-          "x-workspace-id": workspace_id,
-          "x-project-id": project_id,
-          "x-request-id": run_id,
-          "x-thread-id": thread_id,
-          "x-assistant-id": assistant_id,
-          runConfig, // Inject runConfig for tools to access
-        },
-        streamMode: ["updates", "messages"],
-        subgraphs: false,
-        recursionLimit: 200,
-      }
-    );
-
-    // 创建一个可迭代的 ReadableStream with ChunkBuffer integration
-    return {
-      [Symbol.asyncIterator]: async function* () {
-        try {
-          for await (const chunk of agentStream) {
-            let data;
-            let chunkContent = "";
-
-            if (chunk[0] === "updates") {
-              const update = chunk[1];
-              const values = Object.values(update);
-              const messages = (values[0] as any)?.messages;
-              if (messages?.[0]?.tool_call_id) {
-                data = messages[0].toDict();
-              }
-            } else if (chunk[0] === "messages") {
-              const messages = chunk[1];
-              // console.log(messages);
-              data = messages?.[0]?.toDict();
-            }
-
-            if ((chunk?.[1] as any)?.__interrupt__) {
-              //data = chunk?.[1]?.[0]?.toDict();
-              // 原有的中断消息处理
-              data = {
-                type: "interrupt",
-                id: (chunk?.[1] as any)?.__interrupt__[0].id,
-                data: { content: (chunk?.[1] as any)?.__interrupt__[0].value },
-              };
-            }
-
-            if (data) {
-              //console.log(data);
-              if (data.type !== "interrupt") {
-                await chunkBuffer.addChunk(thread_id, data);
-              }
-              yield data;
-            }
-          }
-
-          // Mark thread as completed when streaming finishes successfully
-          await chunkBuffer.completeThread(thread_id);
-        } catch (error) {
-          console.error("Stream error:", error);
-          // Mark thread as aborted on error
-          await chunkBuffer.abortThread(thread_id);
-          throw error;
-        }
-      },
-    };
-  } catch (error) {
-    // Mark thread as aborted on initialization error
-    await chunkBuffer.abortThread(thread_id);
-    throw error;
-  }
-}
-
-export async function agent_state({
-  assistant_id,
-  thread_id,
-  tenant_id,
-}: {
-  assistant_id: string;
-  thread_id: string;
-  tenant_id: string;
-}) {
-  const runnable_agent = await getAgentClient(tenant_id, 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 = await getAgentClient(tenant_id, 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,
-    ...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;
-  // console.log(messagesArray);
-
-  return new_messages;
-}
-
-export async function draw_graph(assistant_id: string, tenant_id: string) {
-  const runnable_agent = await getAgentClient(tenant_id, 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;
-}
-
-/**
- * Resume streaming from a known position
- * Creates an async iterator that yields new chunks as they arrive
- *
- * @param thread_id - Thread identifier
- * @param message_id - Message identifier (usually run_id)
- * @param known_content - Content already received (used to find resume position)
- * @param poll_interval - Polling interval in milliseconds (default: 100ms)
- */
-export async function resume_stream({
-  thread_id,
-  message_id,
-  known_content,
-  poll_interval = 100,
-}: {
-  thread_id: string;
-  message_id: string;
-  known_content: string;
-  poll_interval?: number;
-}) {
-  const chunkBuffer = getOrCreateChunkBuffer();
-
-  const stream = await chunkBuffer.getNewChunksSinceContentIterator(
-    thread_id,
-    message_id,
-    known_content
-  );
-  return {
-    [Symbol.asyncIterator]: async function* () {
-      try {
-        for await (const chunk of stream) {
-          yield chunk;
-        }
-      } catch (error) {
-        console.error("Resume stream error:", error);
-        throw error;
-      }
-    },
-  };
-}