foliko 1.1.7 → 1.1.9

package/plugins/python-plugin-loader.js

@@ -74,6 +74,9 @@ class PythonPluginLoader extends Plugin {
     // 先设置 framework 引用（供 _loadPythonPlugins 使用）
     this._framework = framework
 
+    // 获取 ExtensionExecutorPlugin 实例，用于直接注册 Python 插件工具
+    this._extensionExecutor = framework.pluginManager?.get('extension-executor') || null
+
     // 加载所有 Python 插件（会注册工具到 ExtensionExecutor）
     this._loadPythonPlugins()
 
@@ -96,14 +99,15 @@ class PythonPluginLoader extends Plugin {
 
   /**
    * 构建 Python 插件描述
+   * 格式与 MCP 一致，通过 ext_call 调用
    */
   _buildPythonPluginsDescription() {
     if (this._pythonPlugins.size === 0) {
       return ''
     }
 
-    let desc = '## 【Python 插件】\n'
-    desc += 'Python 插件工具已注册为 `插件名_工具名` 格式，通过 ext_call 调用：\n\n'
+    let desc = '## 【Python 插件】\n\n'
+    desc += 'Python 插件工具通过 `ext_call` 调用：\n\n'
 
     for (const [name, plugin] of this._pythonPlugins) {
       desc += `### ${plugin.info.name}\n`
@@ -111,8 +115,21 @@ class PythonPluginLoader extends Plugin {
       if (plugin.info.tools && Array.isArray(plugin.info.tools)) {
         for (const tool of plugin.info.tools) {
           const fullName = `${name}_${tool.name}`
-          const paramsStr = this._formatParams(tool.params || {})
-          desc += `- **${fullName}**(${paramsStr}): ${tool.description || '无描述'}\n`
+          desc += `- **${fullName}**: ${tool.description || '无描述'}\n`
+          // 使用 zodSchemaToMarkdown 生成参数描述
+          const params = tool.params || {}
+          if (Object.keys(params).length > 0) {
+            try {
+              const jsonSchema = this._paramsToJsonSchema(params)
+              const zodSchema = this._jsonSchemaToZod(jsonSchema)
+              const schemaMd = zodSchemaToMarkdown(zodSchema)
+              if (schemaMd) {
+                desc += `**参数:**\n\n${schemaMd}\n`
+              }
+            } catch (e) {
+              // 忽略参数描述生成错误
+            }
+          }
         }
       }
       desc += '\n'
@@ -124,6 +141,127 @@ class PythonPluginLoader extends Plugin {
     return desc.trim()
   }
 
+  /**
+   * 将参数对象转换为 JSON Schema 格式
+   */
+  _paramsToJsonSchema(params) {
+    const properties = {}
+    const required = []
+
+    for (const [key, value] of Object.entries(params)) {
+      let type = 'string'
+      if (typeof value === 'boolean') type = 'boolean'
+      else if (typeof value === 'number') type = 'number'
+      else if (Array.isArray(value)) type = 'array'
+      else if (typeof value === 'object' && value !== null) type = 'object'
+
+      properties[key] = {
+        type,
+        description: ''
+      }
+      required.push(key)
+    }
+
+    return {
+      type: 'object',
+      properties,
+      required
+    }
+  }
+
+  /**
+   * 将 JSON Schema 转换为 Zod schema
+   */
+  _jsonSchemaToZod(jsonSchema) {
+    if (!jsonSchema || !jsonSchema.properties) {
+      return z.object({})
+    }
+
+    try {
+      const shape = {}
+      const properties = jsonSchema.properties
+      const required = jsonSchema.required || []
+
+      for (const [key, prop] of Object.entries(properties)) {
+        shape[key] = this._jsonSchemaPropToZod(prop, required.includes(key))
+      }
+
+      return z.object(shape)
+    } catch (e) {
+      return z.object({})
+    }
+  }
+
+  /**
+   * 将 JSON Schema 属性转换为 Zod 类型（支持完整嵌套）
+   */
+  _jsonSchemaPropToZod(prop, isRequired) {
+    // 1. 处理 enum（枚举值）
+    if (prop.enum) {
+      let zodType = z.string().enum(prop.enum)
+      return isRequired ? zodType : zodType.optional()
+    }
+
+    const type = prop.type || 'string'
+
+    // 2. 简单类型
+    switch (type) {
+      case 'string':
+        return isRequired ? z.string() : z.string().optional()
+      case 'number':
+      case 'integer':
+        return isRequired ? z.number() : z.number().optional()
+      case 'boolean':
+        return isRequired ? z.boolean() : z.boolean().optional()
+      default:
+        break
+    }
+
+    // 3. 数组类型
+    if (type === 'array') {
+      let itemsZod = z.any()
+      if (prop.items) {
+        // 支持 oneOf（联合类型数组）
+        if (prop.items.oneOf) {
+          const unionTypes = prop.items.oneOf.map(item => this._jsonSchemaPropToZod(item, true))
+          if (unionTypes.length > 0) {
+            itemsZod = z.union(unionTypes)
+          }
+        } else {
+          itemsZod = this._jsonSchemaPropToZod(prop.items, true)
+        }
+      }
+      return isRequired ? z.array(itemsZod) : z.array(itemsZod).optional()
+    }
+
+    // 4. 对象类型
+    if (type === 'object') {
+      if (prop.properties && Object.keys(prop.properties).length > 0) {
+        const nested = {}
+        for (const [k, v] of Object.entries(prop.properties)) {
+          nested[k] = this._jsonSchemaPropToZod(v, prop.required?.includes(k) || false)
+        }
+        const objZod = z.object(nested)
+        return isRequired ? objZod : objZod.optional()
+      }
+      // 无 properties 的 object，视为 record
+      const recordZod = z.record(z.any())
+      return isRequired ? recordZod : recordZod.optional()
+    }
+
+    // 5. oneOf（联合类型）
+    if (prop.oneOf) {
+      const unionTypes = prop.oneOf.map(item => this._jsonSchemaPropToZod(item, true))
+      if (unionTypes.length > 0) {
+        const unionZod = z.union(unionTypes)
+        return isRequired ? unionZod : unionZod.optional()
+      }
+    }
+
+    // 6. Fallback
+    return isRequired ? z.any() : z.any().optional()
+  }
+
   /**
    * 刷新单个 agent 的 Python 插件提示词
    */
@@ -208,6 +346,7 @@ class PythonPluginLoader extends Plugin {
   /**
    * 注册 Python 插件的工具
    * 工具名格式：插件名_工具名（如 stock_get_price）
+   * 直接注册到 ExtensionExecutor，使用 ext_call({ plugin: "python", tool: "插件名_工具名", args: {...} }) 调用
    */
   _registerPythonTool(pluginName, tool) {
     if (!tool.name) return
@@ -215,38 +354,56 @@ class PythonPluginLoader extends Plugin {
     // 格式：pluginname_toolname
     const fullToolName = `${pluginName}_${tool.name}`
 
+    const toolDef = {
+      name: fullToolName,
+      description: tool.description || `${pluginName} 的 ${tool.name} 工具`,
+      inputSchema: this._parseToolParams(tool.params || {}),
+      execute: async (args) => {
+        return this._executePythonTool(pluginName, tool.name, args)
+      }
+    }
+
     try {
-      this.registerTool({
-        name: fullToolName,
-        description: `[${pluginName}] ${tool.description || ''}`,
-        pluginName: pluginName,
-        inputSchema: this._parseToolParams(tool.params || {}),
-        execute: async (args) => {
-          return this._executePythonTool(pluginName, tool.name, args)
-        }
-      })
+      // 直接注册到 ExtensionExecutor（如果可用）
+      if (this._extensionExecutor) {
+        this._extensionExecutor.registerTool(
+          'python',  // 插件名，用于 ext_call 的 plugin 参数
+          { name: 'python', description: 'Python 插件工具', version: '1.0.0' },
+          toolDef
+        )
+      } else {
+        // 回退到基类的 registerTool
+        this.registerTool({
+          name: fullToolName,
+          description: `[${pluginName}] ${tool.description || ''}`,
+          pluginName: pluginName,
+          inputSchema: this._parseToolParams(tool.params || {}),
+          execute: toolDef.execute
+        })
+      }
     } catch (err) {
       log.error(` Failed to register tool ${fullToolName}:`, err.message)
     }
   }
 
   /**
-   * 解析工具参数 schema
+   * 解析工具参数 schema - 支持多重嵌套解析
+   * 支持 Python 常见写法：
+   *   - "name": "string"                      # 类型字符串占位符
+   *   - "data": {"type": "object", "properties": {...}}  # 完整 JSON Schema
+   *   - "tags": ["string"]                    # 简单数组
+   *   - "tags": {"type": "array", "items": "string"}     # JSON Schema 数组
+   *   - "filter": {}                          # 简单 dict
+   *   - "filter": []                          # 简单 list
    */
   _parseToolParams(params) {
-    // 构建 JSON Schema 格式
     const properties = {}
     const required = []
 
     for (const [key, value] of Object.entries(params)) {
-      let type = 'string'
-      if (typeof value === 'boolean') type = 'boolean'
-      else if (typeof value === 'number') type = 'number'
-      else if (Array.isArray(value)) type = 'array'
-      else if (typeof value === 'object') type = 'object'
-
+      const parsed = this._parseTypeValue(value)
       properties[key] = {
-        type,
+        ...parsed,
         description: ''
       }
       required.push(key)
@@ -259,7 +416,256 @@ class PythonPluginLoader extends Plugin {
     }
 
     // 转换为 Zod Schema 以兼容 AI SDK
-    return jsonSchemaToZod(jsonSchema)
+    return this._jsonSchemaToZod(jsonSchema)
+  }
+
+  /**
+   * 解析单个值的类型（支持递归嵌套）
+   * @param {any} value - Python 插件中的参数值
+   * @returns {object} - JSON Schema 属性对象
+   */
+  _parseTypeValue(value) {
+    // 1. 空值/None/null
+    if (value === null || value === undefined) {
+      return { type: 'string' }
+    }
+
+    // 2. 字符串类型占位符（如 "string", "number", "boolean"）
+    if (typeof value === 'string') {
+      return this._parseTypeString(value)
+    }
+
+    // 3. JavaScript 原生类型
+    if (typeof value === 'boolean') {
+      return { type: 'boolean' }
+    }
+    if (typeof value === 'number') {
+      return { type: 'number' }
+    }
+
+    // 4. 数组
+    if (Array.isArray(value)) {
+      return this._parseArrayValue(value)
+    }
+
+    // 5. 对象（字典）
+    if (typeof value === 'object') {
+      return this._parseObjectValue(value)
+    }
+
+    // 6. Fallback
+    return { type: 'string' }
+  }
+
+  /**
+   * 解析类型字符串占位符
+   * 支持："string", "number", "boolean", "array", "object", "any"
+   * 也支持嵌套简写如："string[]", "object{name:string}"
+   */
+  _parseTypeString(str) {
+    const typeStringMap = {
+      'string': 'string',
+      'number': 'number',
+      'integer': 'number',
+      'boolean': 'boolean',
+      'bool': 'boolean',
+      'array': 'array',
+      'object': 'object',
+      'any': 'string'
+    }
+
+    const normalized = str.toLowerCase().trim()
+
+    // 直接类型映射
+    if (typeStringMap[normalized]) {
+      return { type: typeStringMap[normalized] }
+    }
+
+    // 数组简写：string[] -> {type: array, items: {type: string}}
+    if (normalized.endsWith('[]')) {
+      const itemType = normalized.slice(0, -2).trim()
+      const mappedType = typeStringMap[itemType] || 'string'
+      return {
+        type: 'array',
+        items: { type: mappedType }
+      }
+    }
+
+    // 对象简写：{name:string,age:number} -> {type: object, properties: {...}}
+    if (normalized.startsWith('{') && normalized.endsWith('}')) {
+      const inner = normalized.slice(1, -1)
+      const properties = {}
+      const required = []
+      
+      const parts = this._splitByComma(inner)
+      for (const part of parts) {
+        const colonIdx = part.indexOf(':')
+        if (colonIdx > 0) {
+          const propName = part.substring(0, colonIdx).trim()
+          const propType = part.substring(colonIdx + 1).trim()
+          properties[propName] = this._parseTypeString(propType)
+          required.push(propName)
+        }
+      }
+
+      return {
+        type: 'object',
+        properties,
+        required
+      }
+    }
+
+    // 未知类型，默认 string
+    return { type: 'string' }
+  }
+
+  /**
+   * 分割字符串（考虑嵌套的括号）
+   */
+  _splitByComma(str) {
+    const result = []
+    let current = ''
+    let depth = 0
+
+    for (const char of str) {
+      if (char === '(' || char === '[' || char === '{') {
+        depth++
+        current += char
+      } else if (char === ')' || char === ']' || char === '}') {
+        depth--
+        current += char
+      } else if (char === ',' && depth === 0) {
+        result.push(current.trim())
+        current = ''
+      } else {
+        current += char
+      }
+    }
+
+    if (current.trim()) {
+      result.push(current.trim())
+    }
+
+    return result
+  }
+
+  /**
+   * 解析数组值
+   * 支持：
+   *   - [] -> {type: array, items: {type: string}}
+   *   - ["string", "number"] -> {type: array, items: {type: string, enum: [...]}}
+   *   - {"type": "array", "items": "string"} -> 完整 JSON Schema 格式
+   */
+  _parseArrayValue(arr) {
+    // 空数组，默认 string 类型数组
+    if (arr.length === 0) {
+      return { type: 'array', items: { type: 'string' } }
+    }
+
+    // 完整 JSON Schema 格式
+    if (arr.length === 1 && typeof arr[0] === 'object' && arr[0].type === 'array') {
+      return this._parseTypeValue(arr[0])
+    }
+
+    // 简单同类型数组：["string", "number"] -> 收集所有类型
+    const types = new Set()
+    for (const item of arr) {
+      if (typeof item === 'string') {
+        types.add(item.toLowerCase())
+      }
+    }
+
+    // 检查是否是类型字符串数组
+    const typeStringMap = ['string', 'number', 'integer', 'boolean', 'bool', 'array', 'object', 'any']
+    const isTypeArray = types.size > 0 && [...types].every(t => typeStringMap.includes(t))
+
+    if (isTypeArray) {
+      // 单一类型：["string"] -> {type: array, items: {type: "string"}}
+      if (types.size === 1) {
+        const itemType = [...types][0]
+        const mappedType = {
+          'string': 'string', 'number': 'number', 'integer': 'number',
+          'boolean': 'boolean', 'bool': 'boolean', 'array': 'array', 'object': 'object', 'any': 'string'
+        }[itemType] || 'string'
+        return { type: 'array', items: { type: mappedType } }
+      }
+      // 多类型联合数组：["string", "number"] -> z.union
+      const zodTypes = [...types].map(t => {
+        const mappedType = {
+          'string': 'string', 'number': 'number', 'integer': 'number',
+          'boolean': 'boolean', 'bool': 'boolean', 'array': 'array', 'object': 'object', 'any': 'string'
+        }[t] || 'string'
+        return mappedType
+      })
+      // 转换为 JSON Schema 的 oneOf
+      return { type: 'array', items: { oneOf: zodTypes.map(t => ({ type: t })) } }
+    }
+
+    // 复杂数组，内部是对象
+    const firstObj = arr.find(item => typeof item === 'object' && item !== null)
+    if (firstObj) {
+      return { type: 'array', items: this._parseTypeValue(firstObj) }
+    }
+
+    // 默认返回 string 数组
+    return { type: 'array', items: { type: 'string' } }
+  }
+
+  /**
+   * 解析对象值
+   * 支持：
+   *   - {} -> {type: object}
+   *   - {"type": "object", "properties": {...}} -> 完整 JSON Schema
+   *   - {"type": "object", "properties": {"name": "string", "age": "number"}} -> 递归
+   */
+  _parseObjectValue(obj) {
+    // 已经是完整 JSON Schema 格式
+    if (obj.type) {
+      const typeStr = typeof obj.type === 'string' ? obj.type.toLowerCase() : ''
+
+      // object 类型
+      if (typeStr === 'object' || typeStr === '') {
+        if (obj.properties) {
+          const properties = {}
+          const required = obj.required || []
+
+          for (const [key, value] of Object.entries(obj.properties)) {
+            properties[key] = this._parseTypeValue(value)
+          }
+
+          return { type: 'object', properties, required }
+        }
+        return { type: 'object' }
+      }
+
+      // array 类型
+      if (typeStr === 'array') {
+        const items = obj.items ? this._parseTypeValue(obj.items) : { type: 'string' }
+        return { type: 'array', items }
+      }
+
+      // 简单类型
+      const typeMap = {
+        'string': 'string', 'number': 'number', 'integer': 'number',
+        'boolean': 'boolean', 'bool': 'boolean'
+      }
+      if (typeMap[typeStr]) {
+        return { type: typeMap[typeStr] }
+      }
+
+      return { type: typeStr }
+    }
+
+    // 普通对象字面量，递归解析每个属性
+    const properties = {}
+    const required = []
+
+    for (const [key, value] of Object.entries(obj)) {
+      properties[key] = this._parseTypeValue(value)
+      required.push(key)
+    }
+
+    return { type: 'object', properties, required }
   }
 
   /**
@@ -660,23 +1066,38 @@ class PythonPluginLoader extends Plugin {
       return { success: false, error: `Plugin '${pluginName}' not found` }
     }
 
-    // 构建执行代码 - 使用 base64 避免转义问题
+    // 构建执行代码 - 使用数组拼接避免缩进问题
     const pluginDir = path.dirname(plugin.path)
     const codeBase64 = Buffer.from(plugin.code, 'utf-8').toString('base64')
 
-    const execCode = `
-import sys
-import base64
-sys.path.insert(0, r'${pluginDir}')
-
-# 加载插件代码
-plugin_code = base64.b64decode('${codeBase64}').decode('utf-8')
-exec(compile(plugin_code, '${pluginName}.py', 'exec'))
-
-# 执行工具
-result = execute_tool('${toolName}', ${JSON.stringify(params)})
-print(result)
-`
+    // 从 TOOLS 提取工具名称列表，构建路由函数
+    const toolNames = (plugin.info.tools || []).map(t => t.name)
+
+    const execCode = [
+      'import sys',
+      'import base64',
+      'import json as _json',
+      `sys.path.insert(0, r'${pluginDir}')`,
+      '',
+      '# 加载插件代码（使用 textwrap.dedent 去除缩进）',
+      `plugin_code = base64.b64decode('${codeBase64}').decode('utf-8')`,
+      `import textwrap`,
+      `exec(compile(textwrap.dedent(plugin_code), '${pluginName}.py', 'exec'))`,
+      '',
+      '# 工具路由函数',
+      `_tool_map = {${toolNames.map(n => `"${n}": ${n}`).join(', ')}}`,
+      `def execute_tool(name, params):`,
+      `    if name not in _tool_map:`,
+      `        return {"success": False, "error": f"Tool '{name}' not found in plugin '${pluginName}'"}`,
+      `    try:`,
+      `        return _tool_map[name](params)`,
+      `    except Exception as e:`,
+      `        return {"success": False, "error": str(e)}`,
+      '',
+      '# 执行工具',
+      `result = execute_tool('${toolName}', ${JSON.stringify(params)})`,
+      'print(_json.dumps(result))'
+    ].join('\n')
 
     try {
       // 通过 python-execute 工具执行
@@ -690,13 +1111,13 @@ print(result)
       if (pythonResult.success) {
         try {
           // 尝试解析 JSON 结果
-          const parsed = JSON.parse(pythonResult.output)
+          const parsed = JSON.parse(pythonResult.stdout)
           return parsed
         } catch {
-          return { success: true, output: pythonResult.output }
+          return { success: true, output: pythonResult.stdout }
         }
       } else {
-        return { success: false, error: pythonResult.error }
+        return { success: false, error: pythonResult.stderr || pythonResult.error }
       }
     } catch (err) {
       return { success: false, error: err.message }