p-api-agent 0.0.2 → 0.0.3

package/dist/index.cjs

@@ -0,0 +1,372 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Agent: () => Agent,
+  FunctionCall: () => FunctionCall,
+  LLM_Utils: () => LLM_Utils
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/agent/index.ts
+var import_fs = __toESM(require("fs"), 1);
+
+// src/utils/llm_utils.ts
+var import_jsonrepair = require("jsonrepair");
+var _LLM_Utils = class {
+  /**
+   * 提取大模型返回的markdown
+   */
+  extract_markdown(content) {
+    const regex = /```markdown\n(.*?)\n```/s;
+    const match = content.match(regex);
+    if (!match) return content;
+    return match[1];
+  }
+  /**
+   * 提取大模型的json格式
+   */
+  extract_json(content) {
+    const regex = /```json\n(.*?)\n```/s;
+    const match = content.match(regex);
+    let json_content = match ? match[1] : content;
+    try {
+      return JSON.parse(json_content);
+    } catch (err) {
+      return JSON.parse((0, import_jsonrepair.jsonrepair)(json_content));
+    }
+  }
+  /**
+   * 提取mermaid格式
+   */
+  extract_mermaid(content) {
+    const regex = /```mermaid\n(.*?)\n```/s;
+    const match = content.match(regex);
+    if (!match) return content;
+    return match[1];
+  }
+  /**
+   * 提取svg格式
+   */
+  extract_svg(content) {
+    const regex = /```svg\n(.*?)\n```/s;
+    const match = content.match(regex);
+    if (!match) return content;
+    return match[1];
+  }
+  parse_json(content) {
+    if (typeof content === "object") {
+      return content;
+    }
+    try {
+      return JSON.parse(content);
+    } catch (err) {
+      return JSON.parse((0, import_jsonrepair.jsonrepair)(content));
+    }
+  }
+};
+var LLM_Utils = new _LLM_Utils();
+
+// src/agent/index.ts
+var import_path = __toESM(require("path"), 1);
+var Agent = class {
+  constructor(options = {}) {
+    __publicField(this, "function_call", null);
+    __publicField(this, "llm_chat_func", null);
+    __publicField(this, "max_loop");
+    __publicField(this, "retry_times");
+    __publicField(this, "custom_system_prompt", null);
+    this.max_loop = options.maxLoop ?? 20;
+    this.retry_times = options.retryTimes ?? 2;
+    if (options.customSystemPrompt) {
+      this.custom_system_prompt = options.customSystemPrompt;
+    }
+  }
+  // ─────────── Registration ───────────
+  /** 注册工具函数集合，支持链式调用 */
+  register_function_call(fc) {
+    this.function_call = fc;
+    return this;
+  }
+  /** 注册 LLM 文字能力，支持链式调用 */
+  register_llm_text_ability(func) {
+    this.llm_chat_func = func;
+    return this;
+  }
+  /** 覆盖系统提示词 */
+  set_system_prompt(prompt) {
+    this.custom_system_prompt = prompt;
+    return this;
+  }
+  /** 动态修改最大循环次数 */
+  set_max_loop(n) {
+    this.max_loop = n;
+    return this;
+  }
+  // ─────────── Main ReAct Loop ───────────
+  /**
+   * 发起对话。
+   *
+   * 架构：ReAct 单调用循环
+   *   每轮只调用一次 LLM，LLM 在拥有完整工具 schema 的系统提示词下
+   *   直接输出 end / use_tool / no_ability 三种指令，
+   *   彻底消除了旧版 "判断→查文档→生成参数→再生成答案" 的多次调用开销。
+   */
+  async create_chat(user_input) {
+    if (!this.llm_chat_func) {
+      return { result: "\u672A\u6CE8\u518CLLM\u80FD\u529B", use_tools: [] };
+    }
+    const history = this.normalize_input(user_input);
+    const system_msg = {
+      role: "system",
+      content: [{ type: "text", text: this.build_system_prompt() }]
+    };
+    const result = { result: "", use_tools: [] };
+    const tool_fail_count = {};
+    for (let turn = 0; turn < this.max_loop; turn++) {
+      let raw;
+      try {
+        raw = await this.call_llm_with_retry([system_msg, ...history]);
+      } catch (err) {
+        result.result = `LLM\u8C03\u7528\u5931\u8D25: ${err?.message ?? String(err)}`;
+        return result;
+      }
+      const cmd = this.parse_command(raw);
+      if (!cmd) {
+        result.result = raw;
+        return result;
+      }
+      if (cmd.command === "end") {
+        result.result = cmd.result;
+        return result;
+      }
+      if (cmd.command === "no_ability") {
+        result.result = cmd.result || "\u65E0\u6CD5\u6267\u884C\u6B64\u64CD\u4F5C";
+        return result;
+      }
+      if (cmd.command === "use_tool") {
+        const { tool_name, params } = cmd;
+        if (!this.function_call) {
+          result.result = "\u672A\u6CE8\u518C\u5DE5\u5177\u51FD\u6570\u96C6\u5408\uFF0C\u65E0\u6CD5\u6267\u884C\u5DE5\u5177\u8C03\u7528";
+          return result;
+        }
+        history.push({
+          role: "assistant",
+          content: [{ type: "text", text: raw }]
+        });
+        let tool_result;
+        try {
+          tool_result = await this.function_call.exec_function(tool_name, params);
+        } catch (err) {
+          const err_msg = err?.message ?? String(err);
+          tool_fail_count[tool_name] = (tool_fail_count[tool_name] ?? 0) + 1;
+          history.push({
+            role: "user",
+            content: [{
+              type: "text",
+              text: `[\u5DE5\u5177\u6267\u884C\u5931\u8D25] ${tool_name}
+\u9519\u8BEF\u4FE1\u606F: ${err_msg}
+\u8BF7\u6839\u636E\u9519\u8BEF\u8C03\u6574\u7B56\u7565\u540E\u7EE7\u7EED`
+            }]
+          });
+          if (tool_fail_count[tool_name] >= 2) {
+            result.result = `\u5DE5\u5177 "${tool_name}" \u8FDE\u7EED\u8C03\u7528\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5`;
+            return result;
+          }
+          continue;
+        }
+        history.push({
+          role: "user",
+          content: [{
+            type: "text",
+            text: `[\u5DE5\u5177\u8C03\u7528\u7ED3\u679C] ${tool_name}
+${JSON.stringify(tool_result, null, 2)}`
+          }]
+        });
+        result.use_tools.push({ tool_name, params, exec_result: tool_result });
+        continue;
+      }
+    }
+    result.result = "\u8D85\u51FA\u6700\u5927\u63A8\u7406\u8F6E\u6B21\uFF0C\u8BF7\u7CBE\u7B80\u95EE\u9898\u540E\u91CD\u8BD5";
+    return result;
+  }
+  // ─────────── System Prompt ───────────
+  /**
+   * 构建系统提示词。
+   * 将所有工具的完整 schema（含参数类型、必填项、示例值）
+   * 直接注入系统提示词，让 LLM 在单次调用中就能做出准确的工具选择和参数填写。
+   */
+  build_system_prompt() {
+    if (this.custom_system_prompt) return this.custom_system_prompt;
+    const base = this.load_preset_prompt();
+    if (!this.function_call) return base;
+    const tool_schemas = this.function_call.get_tools_with_schema().map((t) => {
+      const props = Object.entries(t.input_schema.properties).map(([k, v]) => {
+        const req = t.input_schema.required?.includes(k) ? "\u5FC5\u586B" : "\u53EF\u9009";
+        const ex = v.examples?.length ? `\uFF0C\u793A\u4F8B: ${v.examples.join(" / ")}` : "";
+        return `    - ${k} (${v.type}, ${req}): ${v.description}${ex}`;
+      }).join("\n");
+      return `### ${t.name}
+\u63CF\u8FF0: ${t.description}
+\u53C2\u6570:
+${props}`;
+    }).join("\n\n");
+    return `${base}
+
+## \u53EF\u7528\u5DE5\u5177\u5217\u8868
+
+${tool_schemas}`;
+  }
+  load_preset_prompt() {
+    try {
+      return import_fs.default.readFileSync(import_path.default.join(__dirname, "./preset_prompt.md"), "utf-8");
+    } catch {
+      return "";
+    }
+  }
+  // ─────────── Helpers ───────────
+  normalize_input(input) {
+    if (typeof input === "string") {
+      return [{ role: "user", content: [{ type: "text", text: input }] }];
+    }
+    return [...input];
+  }
+  parse_command(raw) {
+    const json = this.safe_extract_json(raw);
+    if (!json || typeof json.command !== "string") return null;
+    return json;
+  }
+  safe_extract_json(content) {
+    try {
+      return LLM_Utils.extract_json(content);
+    } catch {
+      return null;
+    }
+  }
+  async call_llm_with_retry(input) {
+    let last_error;
+    for (let i = 0; i <= this.retry_times; i++) {
+      try {
+        const res = await this.llm_chat_func(input);
+        if (typeof res === "string" && res.trim()) return res;
+        throw new Error("\u7A7A\u54CD\u5E94");
+      } catch (err) {
+        last_error = err;
+      }
+    }
+    throw last_error ?? new Error("LLM\u8C03\u7528\u5931\u8D25");
+  }
+};
+
+// src/function_call/index.ts
+var import_path2 = __toESM(require("path"), 1);
+var import_fs2 = __toESM(require("fs"), 1);
+var FunctionCall = class {
+  constructor(tool_path) {
+    this.tool_path = tool_path;
+    __publicField(this, "tools", {});
+    this.init();
+  }
+  init() {
+    for (const file_name of import_fs2.default.readdirSync(this.tool_path)) {
+      const route_path = import_path2.default.join(this.tool_path, file_name);
+      const mcp = require(route_path);
+      const info = mcp.register();
+      this.tools[info.name] = info;
+    }
+  }
+  /**
+   * 生成完整的工具函数说明文档
+   */
+  gen_tool_doc(name) {
+    const info = this.tools[name];
+    if (!info) {
+      throw `${name}\u5DE5\u5177\u51FD\u6570\u4E0D\u5B58\u5728`;
+    }
+    const schema = info.input_schema;
+    const schemaDesc = `\u7C7B\u578B: ${schema.type}`;
+    const params = Object.keys(schema.properties).map((key) => {
+      const item = schema.properties[key];
+      const required = schema.required?.includes(key) ? "\u5FC5\u586B" : "\u53EF\u9009";
+      const examples = item.examples && item.examples.length > 0 ? `\u793A\u4F8B\u503C: ${item.examples.join(", ")}` : "\u65E0\u793A\u4F8B";
+      return `  - ${key} (${item.type}, ${required})
+    \u8BF4\u660E: ${item.description}
+    ${examples}`;
+    }).join("\n");
+    return `\u5DE5\u5177\u51FD\u6570\u540D\u79F0: ${info.name}
+\u529F\u80FD\u63CF\u8FF0: ${info.description}
+\u8F93\u5165\u7ED3\u6784: ${schemaDesc}
+\u53C2\u6570\u5217\u8868:
+${params}`;
+  }
+  /**
+   * 获取工具函数列表（仅名称 + 描述）
+   */
+  get_tools_list() {
+    return Object.keys(this.tools).map((key) => {
+      const info = this.tools[key];
+      return {
+        name: info.name,
+        description: info.description
+      };
+    });
+  }
+  /**
+   * 获取工具函数列表（含完整 input_schema），供 Agent 注入系统提示词
+   */
+  get_tools_with_schema() {
+    return Object.keys(this.tools).map((key) => {
+      const info = this.tools[key];
+      return {
+        name: info.name,
+        description: info.description,
+        input_schema: info.input_schema
+      };
+    });
+  }
+  /**
+   * 执行工具函数
+   */
+  async exec_function(name, params) {
+    const info = this.tools[name];
+    if (!info) {
+      throw `\u5DE5\u5177\u51FD\u6570${name}\u4E0D\u5B58\u5728`;
+    }
+    return await info.register_func(params);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Agent,
+  FunctionCall,
+  LLM_Utils
+});

package/dist/index.d.cts

@@ -0,0 +1,148 @@
+interface RegisterInfo {
+    name: string;
+    description: string;
+    input_schema: {
+        type: string;
+        properties: {
+            [key: string]: {
+                type: string;
+                description: string;
+                examples?: string[];
+            };
+        };
+        required?: string[];
+    };
+    register_func: (...args: any[]) => Promise<any>;
+}
+declare class FunctionCall {
+    tool_path: string;
+    private tools;
+    constructor(tool_path: string);
+    private init;
+    /**
+     * 生成完整的工具函数说明文档
+     */
+    gen_tool_doc(name: string): string;
+    /**
+     * 获取工具函数列表（仅名称 + 描述）
+     */
+    get_tools_list(): {
+        name: string;
+        description: string;
+    }[];
+    /**
+     * 获取工具函数列表（含完整 input_schema），供 Agent 注入系统提示词
+     */
+    get_tools_with_schema(): {
+        name: string;
+        description: string;
+        input_schema: {
+            type: string;
+            properties: {
+                [key: string]: {
+                    type: string;
+                    description: string;
+                    examples?: string[];
+                };
+            };
+            required?: string[];
+        };
+    }[];
+    /**
+     * 执行工具函数
+     */
+    exec_function(name: string, params: any): Promise<any>;
+}
+
+interface TextContent {
+    type: 'text';
+    text: string;
+}
+interface ImageContent {
+    type: 'image_url';
+    image_url: {
+        url: string;
+    };
+}
+type Content = TextContent | ImageContent;
+type Message = {
+    role: 'system' | 'user' | 'assistant';
+    content: Content[];
+};
+type UserChatInput = Message[];
+interface ToolRecord {
+    tool_name: string;
+    params: any;
+    exec_result: any;
+}
+interface CreateChatResult {
+    result: string;
+    use_tools: ToolRecord[];
+}
+interface AgentOptions {
+    /** 最大推理循环次数，默认 20 */
+    maxLoop?: number;
+    /** LLM 失败重试次数，默认 2 */
+    retryTimes?: number;
+    /** 完全覆盖系统提示词 */
+    customSystemPrompt?: string;
+}
+declare class Agent {
+    private function_call;
+    private llm_chat_func;
+    private max_loop;
+    private retry_times;
+    private custom_system_prompt;
+    constructor(options?: AgentOptions);
+    /** 注册工具函数集合，支持链式调用 */
+    register_function_call(fc: FunctionCall): this;
+    /** 注册 LLM 文字能力，支持链式调用 */
+    register_llm_text_ability(func: (input: UserChatInput) => Promise<string>): this;
+    /** 覆盖系统提示词 */
+    set_system_prompt(prompt: string): this;
+    /** 动态修改最大循环次数 */
+    set_max_loop(n: number): this;
+    /**
+     * 发起对话。
+     *
+     * 架构：ReAct 单调用循环
+     *   每轮只调用一次 LLM，LLM 在拥有完整工具 schema 的系统提示词下
+     *   直接输出 end / use_tool / no_ability 三种指令，
+     *   彻底消除了旧版 "判断→查文档→生成参数→再生成答案" 的多次调用开销。
+     */
+    create_chat(user_input: string | UserChatInput): Promise<CreateChatResult>;
+    /**
+     * 构建系统提示词。
+     * 将所有工具的完整 schema（含参数类型、必填项、示例值）
+     * 直接注入系统提示词，让 LLM 在单次调用中就能做出准确的工具选择和参数填写。
+     */
+    private build_system_prompt;
+    private load_preset_prompt;
+    private normalize_input;
+    private parse_command;
+    private safe_extract_json;
+    private call_llm_with_retry;
+}
+
+declare class _LLM_Utils {
+    /**
+     * 提取大模型返回的markdown
+     */
+    extract_markdown(content: any): any;
+    /**
+     * 提取大模型的json格式
+     */
+    extract_json(content: any): any;
+    /**
+     * 提取mermaid格式
+     */
+    extract_mermaid(content: any): any;
+    /**
+     * 提取svg格式
+     */
+    extract_svg(content: any): any;
+    parse_json(content: string | object): any;
+}
+declare const LLM_Utils: _LLM_Utils;
+
+export { Agent, type AgentOptions, type CreateChatResult, FunctionCall, LLM_Utils, type Message, type RegisterInfo, type ToolRecord, type UserChatInput };

package/dist/index.d.ts

@@ -24,12 +24,30 @@ declare class FunctionCall {
      */
     gen_tool_doc(name: string): string;
     /**
-     * 获取工具函数列表
+     * 获取工具函数列表（仅名称 + 描述）
      */
     get_tools_list(): {
         name: string;
         description: string;
     }[];
+    /**
+     * 获取工具函数列表（含完整 input_schema），供 Agent 注入系统提示词
+     */
+    get_tools_with_schema(): {
+        name: string;
+        description: string;
+        input_schema: {
+            type: string;
+            properties: {
+                [key: string]: {
+                    type: string;
+                    description: string;
+                    examples?: string[];
+                };
+            };
+            required?: string[];
+        };
+    }[];
     /**
      * 执行工具函数
      */
@@ -47,51 +65,63 @@ interface ImageContent {
     };
 }
 type Content = TextContent | ImageContent;
-type UserChatInput = {
+type Message = {
     role: 'system' | 'user' | 'assistant';
     content: Content[];
-}[];
+};
+type UserChatInput = Message[];
+interface ToolRecord {
+    tool_name: string;
+    params: any;
+    exec_result: any;
+}
+interface CreateChatResult {
+    result: string;
+    use_tools: ToolRecord[];
+}
+interface AgentOptions {
+    /** 最大推理循环次数，默认 20 */
+    maxLoop?: number;
+    /** LLM 失败重试次数，默认 2 */
+    retryTimes?: number;
+    /** 完全覆盖系统提示词 */
+    customSystemPrompt?: string;
+}
 declare class Agent {
     private function_call;
-    private function_call_doc;
     private llm_chat_func;
-    preset_prompt: string;
-    constructor();
-    /**
-     * 注册工具函数
-     */
-    register_function_call(function_call: FunctionCall): boolean;
-    /**
-     * 注册LLM模型文字能力
-     */
-    register_llm_text_ability(func: (user_input: UserChatInput) => Promise<string>): void;
-    /**
-    * 注册LLM模型图片能力
-    */
-    register_llm_image_ability(): boolean;
-    /**
-     * 判断是否需要调用function_call, 以及调用哪个工具函数
-     */
-    check_whether_use_function_call(user_input: UserChatInput): Promise<any>;
-    /**
-     * 创建聊天
-     */
-    create_chat(user_input: string | UserChatInput): Promise<{
-        result: string;
-        use_tools: any[];
-    }>;
-    /**
-     * agent预置提示词
-     */
-    get_preset_prompt(): string;
+    private max_loop;
+    private retry_times;
+    private custom_system_prompt;
+    constructor(options?: AgentOptions);
+    /** 注册工具函数集合，支持链式调用 */
+    register_function_call(fc: FunctionCall): this;
+    /** 注册 LLM 文字能力，支持链式调用 */
+    register_llm_text_ability(func: (input: UserChatInput) => Promise<string>): this;
+    /** 覆盖系统提示词 */
+    set_system_prompt(prompt: string): this;
+    /** 动态修改最大循环次数 */
+    set_max_loop(n: number): this;
     /**
-     * 预处理用户输入
+     * 发起对话。
+     *
+     * 架构：ReAct 单调用循环
+     *   每轮只调用一次 LLM，LLM 在拥有完整工具 schema 的系统提示词下
+     *   直接输出 end / use_tool / no_ability 三种指令，
+     *   彻底消除了旧版 "判断→查文档→生成参数→再生成答案" 的多次调用开销。
      */
-    pre_dispose_user_input(user_input: string | UserChatInput): UserChatInput;
+    create_chat(user_input: string | UserChatInput): Promise<CreateChatResult>;
     /**
-     * 深拷贝方法
+     * 构建系统提示词。
+     * 将所有工具的完整 schema（含参数类型、必填项、示例值）
+     * 直接注入系统提示词，让 LLM 在单次调用中就能做出准确的工具选择和参数填写。
      */
-    private deepClone;
+    private build_system_prompt;
+    private load_preset_prompt;
+    private normalize_input;
+    private parse_command;
+    private safe_extract_json;
+    private call_llm_with_retry;
 }
 
 declare class _LLM_Utils {
@@ -115,4 +145,4 @@ declare class _LLM_Utils {
 }
 declare const LLM_Utils: _LLM_Utils;
 
-export { Agent, FunctionCall, LLM_Utils, type RegisterInfo };
+export { Agent, type AgentOptions, type CreateChatResult, FunctionCall, LLM_Utils, type Message, type RegisterInfo, type ToolRecord, type UserChatInput };