@axiom-lattice/core 1.0.13 → 1.0.21

package/src/model_lattice/ModelLattice.ts

@@ -1,208 +0,0 @@
-import {
-  AIMessage,
-  BaseMessage,
-  BaseMessageLike,
-  HumanMessage,
-} from "@langchain/core/messages";
-import { ChatDeepSeek } from "@langchain/deepseek";
-import { AzureChatOpenAI, ChatOpenAI } from "@langchain/openai";
-import { z } from "zod";
-import { ZodType as ZodTypeV3 } from "zod/v3";
-import { $ZodType as ZodTypeV4 } from "zod/v4/core";
-import {
-  BaseChatModel,
-  BaseChatModelCallOptions,
-} from "@langchain/core/language_models/chat_models";
-import {
-  BaseLanguageModel,
-  BaseLanguageModelInput,
-} from "@langchain/core/language_models/base";
-import {
-  CallbackManagerForLLMRun,
-  Callbacks,
-} from "@langchain/core/callbacks/manager";
-import { ChatResult } from "@langchain/core/outputs";
-BaseLanguageModel;
-import { LLMConfig } from "@axiom-lattice/protocols";
-
-/**
- * ModelLattice类，继承自BaseChatModel
- * 简化版本，只保留通过LLMConfig创建LLM实例的功能
- */
-export class ModelLattice extends BaseChatModel {
-  private config: LLMConfig;
-  private llm: BaseChatModel;
-
-  lc_namespace: string[] = ["langchain", "model_lattice"];
-
-  /**
-   * 构造函数
-   * @param config LLM配置
-   */
-  constructor(config: LLMConfig) {
-    super({});
-    this.config = config;
-    this.llm = this.initChatModel(config);
-  }
-
-  /**
-   * 返回模型类型
-   */
-  _llmType(): string {
-    return "model_lattice";
-  }
-
-  /**
-   * 返回模型类型
-   */
-  _modelType(): string {
-    return this.llm._modelType();
-  }
-
-  /**
-   * 实现BaseChatModel的_generate方法
-   * @param messages 消息数组
-   * @param options 调用选项
-   * @param runManager 回调管理器
-   * @returns 聊天结果
-   */
-  async _generate(
-    messages: BaseMessage[],
-    options: this["ParsedCallOptions"],
-    runManager?: CallbackManagerForLLMRun
-  ): Promise<ChatResult> {
-    return this.llm._generate(messages, options as any, runManager);
-  }
-
-  /**
-   * 将工具绑定到模型
-   * @param tools 工具列表
-   * @param tool_choice 工具选择选项
-   * @returns 绑定工具后的模型
-   */
-  bindTools(
-    tools: any[],
-    {
-      tool_choice = "auto",
-      ...kwargs
-    }: {
-      tool_choice?: "auto" | "none" | "required" | any;
-      [key: string]: any;
-    } = {}
-  ): any {
-    // 如果底层LLM实现了bindTools方法，则使用它的实现
-    if (typeof this.llm.bindTools === "function") {
-      return this.llm.bindTools(tools, {
-        tool_choice,
-        ...kwargs,
-      });
-    }
-
-    // 如果底层LLM没有实现bindTools方法，抛出错误
-    throw new Error("llm not support bindTools");
-  }
-
-  /**
-   * 使用结构化输出调用LLM
-   * @param input 输入
-   * @param schema 结构化输出的schema
-   * @param options 调用选项
-   * @returns 结构化输出
-   */
-  async invokeWithStructuredOutput<
-    RunOutput extends Record<string, any> = Record<string, any>
-  >(
-    input: BaseLanguageModelInput,
-    schema: ZodTypeV3<RunOutput> | ZodTypeV4<RunOutput> | Record<string, any>,
-    options?: BaseChatModelCallOptions & {
-      includeRaw?: boolean;
-      name?: string;
-      method?: "functionCalling" | "jsonMode";
-    }
-  ): Promise<RunOutput | { raw: BaseMessage; parsed: RunOutput }> {
-    // 使用LLM的withStructuredOutput方法
-    if (this.llm.withStructuredOutput) {
-      // 使用类型断言解决类型兼容性问题
-      const structuredLLM = this.llm.withStructuredOutput(schema, {
-        includeRaw: options?.includeRaw ?? false,
-        name: options?.name,
-        method: options?.method,
-      } as any);
-
-      return structuredLLM.invoke(input, options);
-    }
-
-    // 如果LLM没有withStructuredOutput方法，抛出错误
-    throw new Error("当前LLM不支持结构化输出");
-  }
-
-  /**
-   * 创建LLM实例
-   * @param config LLM配置
-   * @returns LLM实例
-   */
-  private initChatModel(config: LLMConfig): BaseChatModel {
-    if (config.provider === "azure") {
-      return new AzureChatOpenAI({
-        azureOpenAIApiKey: process.env.AZURE_OPENAI_API_KEY,
-        azureOpenAIApiInstanceName: "convertlab-westus",
-        azureOpenAIApiDeploymentName: config.model,
-        azureOpenAIApiVersion: "2024-02-01",
-        temperature: config.temperature || 0,
-        maxTokens: config.maxTokens,
-        timeout: config.timeout,
-        maxRetries: config.maxRetries || 2,
-        streaming: config.streaming,
-      });
-    } else if (config.provider === "deepseek") {
-      return new ChatDeepSeek({
-        model: config.model,
-        temperature: config.temperature || 0,
-        maxTokens: config.maxTokens,
-        timeout: config.timeout,
-        maxRetries: config.maxRetries || 2,
-        apiKey: process.env[config.apiKeyEnvName || "DEEPSEEK_API_KEY"],
-        streaming: config.streaming,
-      });
-    } else if (config.provider === "siliconcloud") {
-      return new ChatOpenAI({
-        model: config.model,
-        temperature: config.temperature || 0,
-        maxTokens: config.maxTokens,
-        timeout: config.timeout,
-        maxRetries: config.maxRetries || 2,
-        apiKey: process.env[config.apiKeyEnvName || "SILICONCLOUD_API_KEY"],
-        configuration: {
-          baseURL: "https://api.siliconflow.cn/v1",
-        },
-        streaming: config.streaming,
-      });
-    } else if (config.provider === "volcengine") {
-      return new ChatOpenAI({
-        model: config.model,
-        temperature: config.temperature || 0,
-        maxTokens: config.maxTokens,
-        timeout: config.timeout,
-        maxRetries: config.maxRetries || 2,
-        apiKey: process.env[config.apiKeyEnvName || "VOLCENGINE_API_KEY"],
-        configuration: {
-          baseURL: "https://ark.cn-beijing.volces.com/api/v3",
-        },
-        streaming: config.streaming,
-      });
-    } else {
-      return new ChatOpenAI({
-        model: config.model,
-        temperature: config.temperature || 0,
-        maxTokens: config.maxTokens,
-        timeout: config.timeout,
-        maxRetries: config.maxRetries || 2,
-        streaming: config.streaming,
-        apiKey: process.env[config.apiKeyEnvName || "OPENAI_API_KEY"],
-        configuration: {
-          baseURL: config.baseURL,
-        },
-      });
-    }
-  }
-}

package/src/model_lattice/ModelLatticeManager.ts

@@ -1,125 +0,0 @@
-import { BaseLatticeManager } from "../base/BaseLatticeManager";
-import { ModelLattice as LLMModelLattice } from "./ModelLattice";
-import { LLMConfig } from "@axiom-lattice/protocols";
-
-// 模型配置接口，直接使用 LLMConfig
-export type ModelConfig = LLMConfig;
-
-// 模型客户端类型，使用 LLMManager
-type ModelClient = LLMModelLattice;
-
-// 定义接口
-export interface ModelLatticeInterface {
-  key: string;
-  client: ModelClient;
-}
-
-/**
- * ModelLatticeManager - 单例模型Lattice管理器
- * 负责注册、管理各种语言模型Lattice
- */
-export class ModelLatticeManager extends BaseLatticeManager<ModelLatticeInterface> {
-  private static _instance: ModelLatticeManager;
-
-  /**
-   * 获取ModelLatticeManager单例实例
-   */
-  public static getInstance(): ModelLatticeManager {
-    if (!ModelLatticeManager._instance) {
-      ModelLatticeManager._instance = new ModelLatticeManager();
-    }
-    return ModelLatticeManager._instance;
-  }
-
-  /**
-   * 获取Lattice类型前缀
-   */
-  protected getLatticeType(): string {
-    return "models";
-  }
-
-  /**
-   * 注册模型Lattice
-   * @param key Lattice键名
-   * @param config 模型配置
-   */
-  public registerLattice(key: string, config: ModelConfig): void {
-    // 使用 LLMManager 创建客户端
-    const client = new LLMModelLattice(config);
-
-    // 创建模型Lattice对象
-    const modelLattice: ModelLatticeInterface = {
-      key,
-      client,
-    };
-
-    // 调用基类的register方法
-    this.register(key, modelLattice);
-  }
-
-  /**
-   * 获取ModelLattice
-   * @param key Lattice键名
-   */
-  public getModelLattice(key: string): ModelLatticeInterface {
-    const modelLattice = this.get(key);
-    if (!modelLattice) {
-      throw new Error(`ModelLattice ${key} not found`);
-    }
-    return modelLattice;
-  }
-
-  /**
-   * 获取所有Lattice
-   */
-  public getAllLattices(): ModelLatticeInterface[] {
-    return this.getAll();
-  }
-
-  /**
-   * 检查Lattice是否存在
-   * @param key Lattice键名
-   */
-  public hasLattice(key: string): boolean {
-    return this.has(key);
-  }
-
-  /**
-   * 移除Lattice
-   * @param key Lattice键名
-   */
-  public removeLattice(key: string): boolean {
-    return this.remove(key);
-  }
-
-  /**
-   * 清空所有Lattice
-   */
-  public clearLattices(): void {
-    this.clear();
-  }
-
-  /**
-   * 获取Lattice数量
-   */
-  public getLatticeCount(): number {
-    return this.count();
-  }
-
-  /**
-   * 获取Lattice键名列表
-   */
-  public getLatticeKeys(): string[] {
-    return this.keys();
-  }
-}
-
-// 导出单例实例
-export const modelLatticeManager = ModelLatticeManager.getInstance();
-
-// 导出便捷方法
-export const registerModelLattice = (key: string, config: ModelConfig) =>
-  modelLatticeManager.registerLattice(key, config);
-
-export const getModelLattice = (key: string) =>
-  modelLatticeManager.getModelLattice(key);

package/src/model_lattice/index.ts

@@ -1 +0,0 @@
-export * from "./ModelLatticeManager";

package/src/tool_lattice/ToolLatticeManager.ts

@@ -1,221 +0,0 @@
-import {
-  DynamicStructuredTool,
-  StructuredTool,
-  tool,
-} from "@langchain/core/tools";
-import { BaseLatticeManager } from "../base/BaseLatticeManager";
-import { z } from "zod";
-import { interrupt } from "@langchain/langgraph";
-import { UserFeedbackResponse } from "../types";
-import { ToolConfig, ToolExecutor } from "@axiom-lattice/protocols";
-
-// 工具定义接口 - 使用协议中的ToolConfig
-export type ToolDefinition = ToolConfig;
-
-// Lattice 接口定义
-export interface ToolLattice {
-  key: string;
-  config: ToolConfig;
-  client: StructuredTool;
-}
-
-/**
- * ToolLatticeManager - 单例工具Lattice管理器
- * 负责注册、管理各种工具Lattice
- */
-export class ToolLatticeManager extends BaseLatticeManager<ToolLattice> {
-  private static _instance: ToolLatticeManager;
-
-  /**
-   * 获取ToolLatticeManager单例实例
-   */
-  public static getInstance(): ToolLatticeManager {
-    if (!ToolLatticeManager._instance) {
-      ToolLatticeManager._instance = new ToolLatticeManager();
-    }
-    return ToolLatticeManager._instance;
-  }
-
-  /**
-   * 获取Lattice类型前缀
-   */
-  protected getLatticeType(): string {
-    return "tools";
-  }
-
-  /**
-   * 注册工具Lattice
-   * @param key Lattice键名
-   * @param config 工具配置（定义）
-   * @param executor 工具执行函数
-   */
-  public registerLattice<TInput = any, TOutput = any>(
-    key: string,
-    config: ToolConfig,
-    executor: ToolExecutor<TInput, TOutput>
-  ): void {
-    // 创建工具Lattice对象
-    let toolExecutor = async (input: TInput, exe_config: any) => {
-      const result = await executor(input, exe_config);
-      return result;
-    };
-
-    // if (config.needUserApprove) {
-    //   toolExecutor = async (input: TInput, exe_config: any) => {
-    //     const contents = [
-    //       "```confirm",
-    //       JSON.stringify({
-    //         message: "try to " + config.name + ",please confirm the action",
-    //       }),
-    //       "```",
-    //     ].join("\n");
-
-    //     const feedback: UserFeedbackResponse = await interrupt(contents);
-    //     if (feedback.data.action === "yes") {
-    //       const result = await executor(input, exe_config);
-    //       return result;
-    //     } else {
-    //       return "user denied the action" as unknown as TOutput;
-    //     }
-    //   };
-    // }
-
-    const toolLattice: ToolLattice = {
-      key,
-      config,
-      client: tool(toolExecutor as ToolExecutor, config),
-    };
-
-    // 调用基类的register方法
-    this.register(key, toolLattice);
-  }
-
-  /**
-   * 获取ToolLattice
-   * @param key Lattice键名
-   */
-  public getToolLattice(key: string): ToolLattice | undefined {
-    return this.get(key);
-  }
-
-  /**
-   * 获取所有Lattice
-   */
-  public getAllLattices(): ToolLattice[] {
-    return this.getAll();
-  }
-
-  /**
-   * 检查Lattice是否存在
-   * @param key Lattice键名
-   */
-  public hasLattice(key: string): boolean {
-    return this.has(key);
-  }
-
-  /**
-   * 移除Lattice
-   * @param key Lattice键名
-   */
-  public removeLattice(key: string): boolean {
-    return this.remove(key);
-  }
-
-  /**
-   * 清空所有Lattice
-   */
-  public clearLattices(): void {
-    this.clear();
-  }
-
-  /**
-   * 获取Lattice数量
-   */
-  public getLatticeCount(): number {
-    return this.count();
-  }
-
-  /**
-   * 获取Lattice键名列表
-   */
-  public getLatticeKeys(): string[] {
-    return this.keys();
-  }
-
-  /**
-   * 获取工具定义
-   * @param key Lattice键名
-   */
-  public getToolDefinition(key: string): ToolDefinition {
-    const toolLattice = this.getToolLattice(key);
-    if (!toolLattice) {
-      throw new Error(`ToolLattice ${key} not found`);
-    }
-    return toolLattice.config;
-  }
-
-  /**
-   * 获取工具客户端
-   * @param key Lattice键名
-   */
-  public getToolClient(key: string): StructuredTool {
-    const toolLattice = this.getToolLattice(key);
-    if (!toolLattice) {
-      throw new Error(`ToolLattice ${key} not found`);
-    }
-    return toolLattice.client;
-  }
-
-  /**
-   * 获取所有工具定义
-   */
-  public getAllToolDefinitions(): ToolDefinition[] {
-    return this.getAllLattices().map((lattice) => lattice.config);
-  }
-
-  /**
-   * 验证工具输入参数
-   * @param key Lattice键名
-   * @param input 输入参数
-   */
-  public validateToolInput(key: string, input: any): boolean {
-    const toolLattice = this.getToolLattice(key);
-    if (!toolLattice) {
-      return false;
-    }
-
-    try {
-      if (toolLattice.config.schema) {
-        toolLattice.config.schema.parse(input);
-      }
-      return true;
-    } catch {
-      return false;
-    }
-  }
-}
-
-// 导出单例实例
-export const toolLatticeManager = ToolLatticeManager.getInstance();
-
-// 导出便捷方法
-export const registerToolLattice = (
-  key: string,
-  config: ToolConfig,
-  executor: ToolExecutor
-) => toolLatticeManager.registerLattice(key, config, executor);
-
-export const getToolLattice = (key: string) =>
-  toolLatticeManager.getToolLattice(key);
-
-export const getToolDefinition = (key: string) =>
-  toolLatticeManager.getToolDefinition(key);
-
-export const getToolClient = (key: string) =>
-  toolLatticeManager.getToolClient(key);
-
-export const getAllToolDefinitions = () =>
-  toolLatticeManager.getAllToolDefinitions();
-
-export const validateToolInput = (key: string, input: any) =>
-  toolLatticeManager.validateToolInput(key, input);

package/src/tool_lattice/get_current_date_time/index.ts

@@ -1,14 +0,0 @@
-import z from "zod";
-import { registerToolLattice } from "../ToolLatticeManager";
-
-registerToolLattice(
-  "get_current_date_time",
-  {
-    name: "获取当前日期时间",
-    description: "获取当前日期时间",
-    schema: z.object({}),
-  },
-  async () => {
-    return "当前日期时间：" + new Date().toLocaleString();
-  }
-);

package/src/tool_lattice/index.ts

@@ -1,2 +0,0 @@
-import "./get_current_date_time";
-import "./internet_search";

package/src/tool_lattice/internet_search/index.ts

@@ -1,66 +0,0 @@
-import z from "zod";
-import { registerToolLattice } from "../ToolLatticeManager";
-import { TavilySearch } from "@langchain/tavily";
-import "dotenv/config";
-import { LangGraphRunnableConfig } from "@langchain/langgraph";
-import { genUICard } from "@util/genUICard";
-
-type Topic = "general" | "news" | "finance";
-
-registerToolLattice(
-  "internet_search",
-  {
-    name: "internet_search",
-    description: "Run a web search",
-    needUserApprove: true,
-    schema: z.object({
-      query: z.string().describe("The search query"),
-      maxResults: z
-        .number()
-        .optional()
-        .default(5)
-        .describe("Maximum number of results to return"),
-      topic: z
-        .enum(["general", "news", "finance"])
-        .optional()
-        .default("general")
-        .describe("Search topic category"),
-      includeRawContent: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe("Whether to include raw content"),
-    }),
-  },
-  async (
-    {
-      query,
-      maxResults = 5,
-      topic = "general" as Topic,
-      includeRawContent = false,
-    }: {
-      query: string;
-      maxResults?: number;
-      topic?: Topic;
-      includeRawContent?: boolean;
-    },
-    config: LangGraphRunnableConfig
-  ) => {
-    /**
-     * Run a web search
-     */
-
-    // Note: You'll need to install and import tavily-js or similar package
-    const tavilySearch = new TavilySearch({
-      maxResults,
-      tavilyApiKey: process.env.TAVILY_API_KEY,
-      includeRawContent,
-      topic,
-    });
-    const tavilyResponse = await tavilySearch.invoke({ query });
-
-    return genUICard("Internet Search:" + query, "generic_data_table", {
-      dataSource: tavilyResponse.results,
-    });
-  }
-);

package/src/types.ts

@@ -1,28 +0,0 @@
-import { BaseMessageLike } from "@langchain/core/messages";
-import {
-  Annotation,
-  // AnnotationRoot,
-  messagesStateReducer,
-} from "@langchain/langgraph";
-
-export const BaseAnnotations = Annotation.Root({
-  "x-tenant-id": Annotation<number>(),
-  messages: Annotation<BaseMessageLike[]>({
-    reducer: messagesStateReducer,
-    default() {
-      return [];
-    },
-  }),
-});
-
-type MessagesAnnotaionType = typeof BaseAnnotations.State;
-export type StateBaseType = MessagesAnnotaionType & {
-  [key: string]: any;
-};
-
-export type UserFeedbackResponse = {
-  action: string;
-  data: any;
-  message: string;
-  config?: { thread_id?: string; work_log_id?: string };
-};

package/src/util/PGMemory.ts

@@ -1,16 +0,0 @@
-import { MemorySaver } from "@langchain/langgraph";
-import { PostgresSaver } from "@langchain/langgraph-checkpoint-postgres";
-import dotenv from "dotenv";
-
-const globalMemory = PostgresSaver.fromConnString(process.env.DATABASE_URL!);
-
-const memory = new MemorySaver();
-// 创建一个管理器来访问这个实例
-export class MemoryManager {
-  private static instance: MemorySaver = memory;
-
-  static getInstance(): MemorySaver {
-    return MemoryManager.instance;
-  }
-}
-//MemoryManager.getInstance().setup();

package/src/util/genUICard.ts

@@ -1,3 +0,0 @@
-export const genUICard = (title: string, type: string, data: any) => {
-  return [title, "```" + type, JSON.stringify(data), "```"].join("\n");
-};

package/src/util/genUIMarkdown.ts

@@ -1,3 +0,0 @@
-export const genUIMarkdown = (type: string, data: any) => {
-  return ["```" + type, JSON.stringify(data), "```"].join("\n");
-};