fr-cli 2.2.5__tar.gz → 2.2.7__tar.gz

{fr_cli-2.2.5/fr_cli.egg-info → fr_cli-2.2.7}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: fr-cli
-Version: 2.2.5
-Summary: 凡人打字机 - 支持多模型(Zhipu/DeepSeek/Kimi/Qwen/StepFun/MiniMax/Spark)的终极全能终端工具
+Version: 2.2.7
+Summary: 凡人打字机 - 支持多模型(Zhipu/DeepSeek/Kimi/Qwen/StepFun/MiniMax/Spark/Doubao/MiMo)的终极全能终端工具
 Author: FANREN CLI Author
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/yourname/fr-cli
@@ -37,7 +37,7 @@ Requires-Dist: pyodbc>=4.0.0; extra == "db"
 Requires-Dist: oracledb>=1.3.0; extra == "db"
 Provides-Extra: rag
 Requires-Dist: chromadb>=0.4.0; extra == "rag"
-Requires-Dist: sentence-transformers>=2.2.5; extra == "rag"
+Requires-Dist: sentence-transformers>=2.2.0; extra == "rag"
 Provides-Extra: remote
 Requires-Dist: paramiko>=3.0.0; extra == "remote"
 Provides-Extra: spider
@@ -56,7 +56,7 @@ Requires-Dist: psycopg2-binary>=2.9.0; extra == "all"
 Requires-Dist: pyodbc>=4.0.0; extra == "all"
 Requires-Dist: oracledb>=1.3.0; extra == "all"
 Requires-Dist: chromadb>=0.4.0; extra == "all"
-Requires-Dist: sentence-transformers>=2.2.5; extra == "all"
+Requires-Dist: sentence-transformers>=2.2.0; extra == "all"
 Requires-Dist: paramiko>=3.0.0; extra == "all"
 Requires-Dist: selenium>=4.10.0; extra == "all"
 Requires-Dist: bypy; extra == "all"
@@ -71,11 +71,11 @@ Dynamic: license-file
 
 # 凡人打字机 (fr-cli)
 
-基于智谱 AI (ZhipuAI/GLM) 的终极全能终端工具。
+支持多模型（智谱/DeepSeek/Kimi/Qwen/StepFun/MiniMax/讯飞星火）的终极全能终端工具。
 
 ## ✨ 功能特性
 
-- 🤖 **AI 对话**：基于 GLM-4 系列模型的智能对话
+- 🤖 **AI 对话**：支持多模型（智谱 GLM / DeepSeek / Kimi / 通义千问 / StepFun / MiniMax / 讯飞星火）
 - 🧠 **MasterAgent 主控**：自我进化的 ReAct 主控 Agent，自动规划、调用工具、反思进化
 - 🧩 **思维模式**：direct / CoT / ToT / ReAct 四种推理模式切换
 - 📁 **文件沙盒**：安全的虚拟文件系统，支持读写/目录操作
@@ -105,7 +105,7 @@ pip install fr-cli
 fr-cli
 ```
 
-首次运行会引导输入智谱 API Key。
+首次运行会引导输入当前道统的 API Key。
 
 ## 📝 使用示例
 

{fr_cli-2.2.5 → fr_cli-2.2.7}/README.md

@@ -1,10 +1,10 @@
 # 凡人打字机 (fr-cli)
 
-基于智谱 AI (ZhipuAI/GLM) 的终极全能终端工具。
+支持多模型（智谱/DeepSeek/Kimi/Qwen/StepFun/MiniMax/讯飞星火）的终极全能终端工具。
 
 ## ✨ 功能特性
 
-- 🤖 **AI 对话**：基于 GLM-4 系列模型的智能对话
+- 🤖 **AI 对话**：支持多模型（智谱 GLM / DeepSeek / Kimi / 通义千问 / StepFun / MiniMax / 讯飞星火）
 - 🧠 **MasterAgent 主控**：自我进化的 ReAct 主控 Agent，自动规划、调用工具、反思进化
 - 🧩 **思维模式**：direct / CoT / ToT / ReAct 四种推理模式切换
 - 📁 **文件沙盒**：安全的虚拟文件系统，支持读写/目录操作
@@ -34,7 +34,7 @@ pip install fr-cli
 fr-cli
 ```
 
-首次运行会引导输入智谱 API Key。
+首次运行会引导输入当前道统的 API Key。
 
 ## 📝 使用示例
 

{fr_cli-2.2.5 → fr_cli-2.2.7}/fr_cli/README.md

@@ -1,14 +1,14 @@
 # 凡人打字机 (fr-cli)
 
-基于智谱 AI (ZhipuAI / GLM) 的终极全能终端工具。
+支持多模型（智谱/DeepSeek/Kimi/Qwen/StepFun/MiniMax/讯飞星火）的终极全能终端工具。
 
 **🇨🇳 中文简介**
 
-支持：AI 智能对话、MasterAgent 自我进化主控、思维模式切换（direct/CoT/ToT/ReAct）、文件沙盒操作、联网搜索（SSRF 防护）、图片生成与识别、邮件收发、定时任务（shlex 安全解析）、云盘集成、会话记忆、按日期自动存档、插件进化（子进程隔离）、四阶安全拦截、Shell 管道直通 AI。
+支持：多模型 AI 对话（智谱/DeepSeek/Kimi/Qwen/StepFun/MiniMax/讯飞星火）、MasterAgent 自我进化主控、思维模式切换（direct/CoT/ToT/ReAct）、文件沙盒操作、联网搜索（SSRF 防护）、图片生成与识别、邮件收发、定时任务（shlex 安全解析）、云盘集成、会话记忆、按日期自动存档、插件进化（子进程隔离）、四阶安全拦截、Shell 管道直通 AI。
 
 **🇺🇸 English Intro**
 
-The ultimate all-knowing terminal tool based on Zhipu AI. Supports AI chat, MasterAgent self-evolving controller, thinking modes (direct/CoT/ToT/ReAct), virtual filesystem, web search (SSRF-protected), image generation & vision, email, cron jobs (shlex-safe), cloud drive, session memory, auto date-based archiving, self-evolving plugins (subprocess-isolated), and powerful Shell piping.
+The ultimate all-knowing terminal tool supporting multiple LLM providers (Zhipu/DeepSeek/Kimi/Qwen/StepFun/MiniMax/Spark). Supports AI chat, MasterAgent self-evolving controller, thinking modes (direct/CoT/ToT/ReAct), virtual filesystem, web search (SSRF-protected), image generation & vision, email, cron jobs (shlex-safe), cloud drive, session memory, auto date-based archiving, self-evolving plugins (subprocess-isolated), and powerful Shell piping.
 
 ---
 
@@ -19,7 +19,7 @@ pip install fr-cli
 fr-cli
 ```
 
-首次运行会引导输入智谱 API Key。
+首次运行会引导输入当前道统的 API Key。
 
 ## 🎮 使用方式
 
@@ -41,6 +41,13 @@ fr-cli
 /session_load <idx>  加载存档会话
 /mode direct|cot|tot|react  切换思维模式
 /master on|off|status        MasterAgent 主控
+/model <模型名>              切换当前道统模型
+/model <道统>:<模型名>       同时切换道统和模型
+/key <key>                   修改当前道统 API Key
+/key <道统> <key>            为指定道统设置 Key
+/providers                   查看所有道统配置
+/providers add <p> <k> [m]   添加/更新道统配置
+/providers use <p>           切换到指定道统
 /mcp_list          列出 MCP 服务器及工具
 /mcp_add <名> <命令> [参数]  添加 MCP 服务器
 /mcp_del <名>      删除 MCP 服务器

{fr_cli-2.2.5 → fr_cli-2.2.7}/fr_cli/__init__.py

@@ -1,4 +1,4 @@
 """
 凡人打字机 - 基于智谱AI的终极全能终端工具
 """
-__version__ = "2.2.5"
+__version__ = "2.2.7"

{fr_cli-2.2.5 → fr_cli-2.2.7}/fr_cli/agent/executor.py

@@ -19,12 +19,17 @@ def run_agent(name, state, **kwargs):
         return None, "agent.py missing run(context, **kwargs)"
     progress = load_progress(name)
     latest = progress.get("latest", {})
+
+    # 解析 Agent 专属 LLM 配置
+    client, provider, model = state.resolve_agent_llm(name)
+
     context = {
         "persona": persona,
         "memory": memory,
         "skills": skills,
-        "client": state.client,
-        "model": state.model_name,
+        "client": client,
+        "provider": provider,
+        "model": model,
         "lang": state.lang,
         "executor": state.executor,
         "state": state,
@@ -34,11 +39,15 @@ def run_agent(name, state, **kwargs):
         "latest_status": latest.get("status", ""),
         "execution_count": progress.get("counter", 0),
     }
+    # 将工具调用的 LLM 上下文切换为 Agent 专属配置
+    state.executor.push_agent_context(client, model)
     try:
         result = mod.run(context, **kwargs)
         return result, None
     except Exception as e:
         return None, str(e)
+    finally:
+        state.executor.pop_agent_context()
 
 
 def delegate_to_agent(name, state, pipeline_input=None, **kwargs):
@@ -53,23 +62,32 @@ def delegate_to_agent(name, state, pipeline_input=None, **kwargs):
         return None, "agent.py not found or load failed"
     if not hasattr(mod, "run"):
         return None, "agent.py missing run(context, **kwargs)"
+
+    # 解析 Agent 专属 LLM 配置
+    client, provider, model = state.resolve_agent_llm(name)
+
     context = {
         "persona": persona,
         "memory": memory,
         "skills": skills,
-        "client": state.client,
-        "model": state.model_name,
+        "client": client,
+        "provider": provider,
+        "model": model,
         "lang": state.lang,
         "executor": state.executor,
         "state": state,
         "agent_name": name,
         "pipeline_input": pipeline_input,
     }
+    # 将工具调用的 LLM 上下文切换为 Agent 专属配置
+    state.executor.push_agent_context(client, model)
     try:
         result = mod.run(context, **kwargs)
         return result, None
     except Exception as e:
         return None, str(e)
+    finally:
+        state.executor.pop_agent_context()
 
 
 def run_multi_agent(names, state, initial_input=None, **kwargs):

{fr_cli-2.2.5 → fr_cli-2.2.7}/fr_cli/agent/generator.py

@@ -33,7 +33,8 @@ Agent 名称: {name}
    - 'persona': str — 人设文本
    - 'memory': str — 记忆文本
    - 'skills': str — 技能文本
-   - 'client': ZhipuAI 实例
+   - 'client': LLM 客户端实例（已根据 Agent 专属配置或全局默认初始化）
+   - 'provider': str — 当前使用的道统/提供商 ID（如 'zhipu', 'deepseek'）
    - 'model': str — 模型名称
    - 'lang': str — 语言代码（'zh' 或 'en'）
    - 'executor': CommandExecutor 实例（可使用 invoke_tool/execute 调用工具）

{fr_cli-2.2.5 → fr_cli-2.2.7}/fr_cli/agent/manager.py

@@ -12,6 +12,7 @@ MEMORY_FILE = "memory.md"
 SKILLS_FILE = "skills.md"
 AGENT_CODE_FILE = "agent.py"
 PROGRESS_FILE = "progress.json"
+AGENT_CONFIG_FILE = "config.json"
 
 
 def _agent_dir(name: str) -> Path:
@@ -53,6 +54,7 @@ def list_agents() -> list:
                 "has_persona": (d / PERSONA_FILE).exists(),
                 "has_memory": (d / MEMORY_FILE).exists(),
                 "has_skills": (d / SKILLS_FILE).exists(),
+                "has_config": (d / AGENT_CONFIG_FILE).exists(),
             })
     return agents
 
@@ -191,3 +193,28 @@ def get_progress_history(name: str, limit: int = 10) -> list:
     progress = load_progress(name)
     history = progress.get("history", [])
     return history[-limit:] if history else []
+
+
+# ---------- Agent 专属配置读写 ----------
+
+def load_agent_config(name: str) -> dict:
+    """读取 Agent 的专属模型配置（config.json）"""
+    f = _agent_dir(name) / AGENT_CONFIG_FILE
+    if not f.exists():
+        return {}
+    try:
+        return json.loads(f.read_text(encoding="utf-8"))
+    except Exception:
+        return {}
+
+
+def save_agent_config(name: str, data: dict):
+    """保存 Agent 的专属模型配置到 config.json"""
+    d = _agent_dir(name)
+    # 确保 Agent 洞府存在，避免在无效目录创建孤立文件
+    d.mkdir(parents=True, exist_ok=True)
+    f = d / AGENT_CONFIG_FILE
+    try:
+        f.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+    except Exception:
+        pass

{fr_cli-2.2.5 → fr_cli-2.2.7}/fr_cli/agent/workflow.py

@@ -4,6 +4,7 @@ Agent workflow engine
 """
 
 import re
+from fr_cli.agent.manager import load_persona, load_memory, load_skills, save_memory
 
 WORKFLOW_FILE = "workflow.md"
 
@@ -101,64 +102,73 @@ def run_workflow(name, state, user_input=None, **kwargs):
     memory = load_memory(name)
     skills = load_skills(name)
 
+    # 解析 Agent 专属 LLM 配置
+    client, provider, model = state.resolve_agent_llm(name)
+
     context = {
         "persona": persona,
         "memory": memory,
         "skills": skills,
-        "client": state.client,
-        "model": state.model_name,
+        "client": client,
+        "provider": provider,
+        "model": model,
         "lang": state.lang,
         "executor": state.executor,
         "state": state,
         "agent_name": name,
     }
 
+    # 将工具调用的 LLM 上下文切换为 Agent 专属配置
+    state.executor.push_agent_context(client, model)
     step_results = []
-    for step in steps:
-        action = step["action"]
-        params = {k: _substitute_vars(v, context, step_results, user_input) for k, v in step["params"].items()}
-        result = None
-        error = None
-
-        try:
-            if action in ("invoke_tool", "tool"):
-                tool_name = params.pop("tool", list(params.keys())[0] if params else "")
-                tool_params = params
-                result, error = state.executor.invoke_tool(tool_name, tool_params)
-            elif action in ("execute_cmd", "cmd", "command"):
-                cmd_str = params.get("cmd", "")
-                result, error = state.executor.execute(cmd_str)
-            elif action in ("agent_call", "agent", "call_agent"):
-                target = params.get("target") or params.get("agent") or params.get("to")
-                message = params.get("message", "")
-                result, error = run_agent(target, state, pipeline_input=message, **kwargs)
-            elif action in ("ai_generate", "ai", "generate", "ask"):
-                prompt = params.get("prompt", "")
-                from fr_cli.core.stream import stream_cnt
-                msgs = [{"role": "user", "content": prompt}]
-                result, _, _ = stream_cnt(state.client, state.model_name, msgs, state.lang)
-            elif action in ("save_memory", "memory_append"):
-                mem = params.get("content", "")
-                from fr_cli.agent.manager import save_memory, load_memory
-                old = load_memory(name)
-                save_memory(name, old + "\n" + mem if old else mem)
-                result = "记忆已更新"
-            else:
-                error = f"未知动作: {action}"
-        except Exception as e:
-            error = str(e)
-
-        step_results.append({
-            "step": step["num"],
-            "title": step["title"],
-            "action": action,
-            "result": result,
-            "error": error,
-        })
-
-        if error:
-            return None, f"步骤 {step['num']} ({step['title']}) 失败: {error}", step_results
-
-    final_result = step_results[-1]["result"] if step_results else None
-    return final_result, None, step_results
+    try:
+        for step in steps:
+            action = step["action"]
+            params = {k: _substitute_vars(v, context, step_results, user_input) for k, v in step["params"].items()}
+            result = None
+            error = None
+
+            try:
+                if action in ("invoke_tool", "tool"):
+                    tool_name = params.pop("tool", list(params.keys())[0] if params else "")
+                    tool_params = params
+                    result, error = state.executor.invoke_tool(tool_name, tool_params)
+                elif action in ("execute_cmd", "cmd", "command"):
+                    cmd_str = params.get("cmd", "")
+                    result, error = state.executor.execute(cmd_str)
+                elif action in ("agent_call", "agent", "call_agent"):
+                    target = params.get("target") or params.get("agent") or params.get("to")
+                    message = params.get("message", "")
+                    result, error = run_agent(target, state, pipeline_input=message, **kwargs)
+                elif action in ("ai_generate", "ai", "generate", "ask"):
+                    prompt = params.get("prompt", "")
+                    from fr_cli.core.stream import stream_cnt
+                    msgs = [{"role": "user", "content": prompt}]
+                    # 使用 context 中的 client/model，已根据 Agent 专属配置解析
+                    result, _, _ = stream_cnt(context["client"], context["model"], msgs, state.lang)
+                elif action in ("save_memory", "memory_append"):
+                    mem = params.get("content", "")
+                    old = load_memory(name)
+                    save_memory(name, old + "\n" + mem if old else mem)
+                    result = "记忆已更新"
+                else:
+                    error = f"未知动作: {action}"
+            except Exception as e:
+                error = str(e)
+
+            step_results.append({
+                "step": step["num"],
+                "title": step["title"],
+                "action": action,
+                "result": result,
+                "error": error,
+            })
+
+            if error:
+                return None, f"步骤 {step['num']} ({step['title']}) 失败: {error}", step_results
+
+        final_result = step_results[-1]["result"] if step_results else None
+        return final_result, None, step_results
+    finally:
+        state.executor.pop_agent_context()
 

{fr_cli-2.2.5 → fr_cli-2.2.7}/fr_cli/command/executor.py

@@ -10,8 +10,13 @@ from fr_cli.command.registry import get_registry
 from fr_cli.addon.plugin import exec_plugin
 
 
-def _build_deps(state):
-    """根据 AppState 动态构建依赖命名空间（每次调用实时反射，避免快照过时）"""
+def _build_deps(state, client=None, model_name=None):
+    """根据 AppState 动态构建依赖命名空间（每次调用实时反射，避免快照过时）
+    
+    Args:
+        client: 可选的覆盖 client（如 Agent 专属模型）
+        model_name: 可选的覆盖模型名
+    """
     return SimpleNamespace(
         vfs=state.vfs,
         mail_c=state.mail_c,
@@ -21,8 +26,8 @@ def _build_deps(state):
         lang=state.lang,
         security=state.security,
         cfg=state.cfg,
-        client=state.client,
-        model_name=state.model_name,
+        client=client or state.client,
+        model_name=model_name or state.model_name,
         mcp=getattr(state, "mcp", None),
     )
 
@@ -41,13 +46,34 @@ class CommandExecutor:
     def __init__(self, state):
         self.state = state
         self._reg = get_registry()
+        # Agent 专属模型上下文覆盖（栈结构，支持嵌套 Agent 调用）
+        self._agent_ctx_stack = []
+
+    # ------------------------------------------------------------------
+    # Agent 上下文覆盖管理
+    # ------------------------------------------------------------------
+    def push_agent_context(self, client, model_name):
+        """临时将工具调用的 LLM 上下文切换为 Agent 专属配置"""
+        self._agent_ctx_stack.append((client, model_name))
+
+    def pop_agent_context(self):
+        """恢复工具调用的 LLM 上下文为全局默认"""
+        if self._agent_ctx_stack:
+            self._agent_ctx_stack.pop()
+
+    def _get_deps(self):
+        """构建依赖命名空间，优先使用 Agent 专属覆盖"""
+        if self._agent_ctx_stack:
+            client, model_name = self._agent_ctx_stack[-1]
+            return _build_deps(self.state, client, model_name)
+        return _build_deps(self.state)
 
     # ------------------------------------------------------------------
     # 第一层：结构化工具调用
     # ------------------------------------------------------------------
     def invoke_tool(self, tool_name, kwargs, msgs=None):
         """根据工具名和结构化参数，通过注册表调度执行。返回 (result, error)"""
-        return self._reg.dispatch(_build_deps(self.state), tool_name, msgs=msgs, **kwargs)
+        return self._reg.dispatch(self._get_deps(), tool_name, msgs=msgs, **kwargs)
 
     # ------------------------------------------------------------------
     # 第二层：传统命令解析（用户输入 / 插件调用）
@@ -65,7 +91,7 @@ class CommandExecutor:
             exec_plugin(cmd, self.state.plugins[cmd], p_args, self.state.lang)
             return f"Plugin {cmd} executed", None
         # 其余命令通过注册表内部接口直接调度，避免 dispatch_cmd 再次 split
-        return self._reg._dispatch_cmd_parts(_build_deps(self.state), parts, msgs=msgs)
+        return self._reg._dispatch_cmd_parts(self._get_deps(), parts, msgs=msgs)
 
     # ------------------------------------------------------------------
     # 第三层：AI 回复解析

{fr_cli-2.2.5 → fr_cli-2.2.7}/fr_cli/core/core.py

@@ -11,7 +11,7 @@ from fr_cli.command.security import SecurityManager
 from fr_cli.command.executor import CommandExecutor
 from fr_cli.weapon.loader import load_weapon_md
 from fr_cli.weapon.mcp import MCPManager
-from fr_cli.core.llm import create_llm_client, list_providers, get_provider_info, resolve_provider_model
+from fr_cli.core.llm import create_llm_client, create_llm_client_for, list_providers, get_provider_info, resolve_provider_model
 
 
 class AppState:
@@ -49,6 +49,9 @@ class AppState:
         # 自动会话存档路径（按日期编号）
         self.auto_session_path = None
 
+        # LLM 客户端缓存（供 Agent 专属模型复用）
+        self._client_cache = {}
+
         # 命令执行引擎
         self.executor = CommandExecutor(self)
 
@@ -146,3 +149,39 @@ class AppState:
         self.cfg["thinking_mode"] = mode
         self.thinking_mode = mode
         self.save_cfg()
+
+    def get_client_for(self, provider: str, model: str, override_key: str = None):
+        """
+        获取指定 provider + model 的 LLM 客户端，带缓存避免重复初始化
+        若提供了 override_key，则优先使用（如 Agent 专属 key）
+        """
+        cache_key = (provider, model, override_key)
+        cached = self._client_cache.get(cache_key)
+        if cached is not None:
+            return cached
+
+        client, _, _ = create_llm_client_for(provider, model, self.cfg, override_key)
+        self._client_cache[cache_key] = client
+        return client
+
+    def resolve_agent_llm(self, agent_name: str):
+        """
+        解析 Agent 的 LLM 配置：优先读取 Agent 的 config.json，
+        若无专属配置则回退到全局默认。
+
+        返回: (client, provider, model)
+        """
+        from fr_cli.agent.manager import load_agent_config
+        agent_cfg = load_agent_config(agent_name)
+
+        provider = agent_cfg.get("provider")
+        model = agent_cfg.get("model")
+        override_key = agent_cfg.get("key") or None
+
+        # 防御性校验：provider 和 model 必须均为非空字符串才生效
+        if provider and model and isinstance(provider, str) and isinstance(model, str):
+            client = self.get_client_for(provider, model, override_key)
+            return client, provider, model
+
+        # 回退到全局默认
+        return self.client, self.provider, self.model_name

{fr_cli-2.2.5 → fr_cli-2.2.7}/fr_cli/core/llm.py

@@ -118,9 +118,43 @@ _PROVIDERS: Dict[str, Dict[str, Any]] = {
         "client_class": OpenAICompatibleClient,
         "base_url": "https://spark-api-open.xf-yun.com/v1",
     },
+    "doubao": {
+        "name": "豆包 (Doubao)",
+        "default_model": "doubao-1-5-pro-32k-250115",
+        "client_class": OpenAICompatibleClient,
+        "base_url": "https://ark.cn-beijing.volces.com/api/v3",
+    },
+    "mimo": {
+        "name": "小米 MiMo",
+        "default_model": "mimo-v2-flash",
+        "client_class": OpenAICompatibleClient,
+        "base_url": "https://api.xiaomimimo.com/v1",
+    },
 }
 
 
+def _resolve_llm_kwargs(provider: str, cfg: dict, override_key: str = None):
+    """
+    根据配置解析创建 LLM 客户端所需的参数。
+    返回: (client_class, kwargs_dict)
+    """
+    providers_cfg = cfg.get("providers", {})
+    pcfg = providers_cfg.get(provider, {})
+
+    # 解析 key：override_key > provider 专属 > 顶层 key（zhipu 向后兼容）
+    api_key = override_key or pcfg.get("key") or cfg.get("key", "")
+
+    info = _PROVIDERS.get(provider, _PROVIDERS["zhipu"])
+    client_class = info["client_class"]
+    base_url = pcfg.get("base_url") or info.get("base_url")
+
+    kwargs = {"api_key": api_key}
+    if base_url:
+        kwargs["base_url"] = base_url
+
+    return client_class, kwargs
+
+
 def create_llm_client(cfg: dict):
     """
     根据配置创建对应的 LLM 客户端
@@ -133,25 +167,12 @@ def create_llm_client(cfg: dict):
     """
     provider = cfg.get("provider", "zhipu")
     providers_cfg = cfg.get("providers", {})
-
-    # 获取当前提供商配置
     pcfg = providers_cfg.get(provider, {})
 
-    # 向后兼容：如果 providers 中没有当前 provider，从顶层读取 key/model
-    # 使用 'or' 确保空字符串也能正确回退到顶层 key
-    api_key = pcfg.get("key") or cfg.get("key", "")
     default_model = _PROVIDERS.get(provider, _PROVIDERS["zhipu"])["default_model"]
     model = pcfg.get("model") or cfg.get("model", default_model)
 
-    info = _PROVIDERS.get(provider, _PROVIDERS["zhipu"])
-    client_class = info["client_class"]
-    # 优先使用用户自定义的 base_url，其次使用内置默认
-    base_url = pcfg.get("base_url") or info.get("base_url")
-
-    kwargs = {"api_key": api_key}
-    if base_url:
-        kwargs["base_url"] = base_url
-
+    client_class, kwargs = _resolve_llm_kwargs(provider, cfg)
     return client_class(**kwargs), provider, model
 
 
@@ -168,6 +189,22 @@ def get_provider_info(provider_id: str):
     return _PROVIDERS.get(provider_id)
 
 
+def create_llm_client_for(provider: str, model: str, cfg: dict, override_key: str = None):
+    """
+    根据全局配置创建指定 provider + model 的 LLM 客户端
+
+    Args:
+        provider: 提供商 ID
+        model: 模型名称
+        cfg: 全局配置字典
+        override_key: 可选的覆盖 key（如 Agent 专属 key）
+
+    返回: (client_instance, provider_id, model_name)
+    """
+    client_class, kwargs = _resolve_llm_kwargs(provider, cfg, override_key)
+    return client_class(**kwargs), provider, model
+
+
 def resolve_provider_model(arg: str) -> tuple:
     """
     解析用户输入的模型参数