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

{fr_cli-2.2.6/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.6
-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

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

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

{fr_cli-2.2.6 → 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.6 → 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.6 → 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.6 → 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.6 → 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.6 → 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.6 → 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:
     """
     解析用户输入的模型参数

{fr_cli-2.2.6 → fr_cli-2.2.7}/fr_cli/lang/i18n.py

@@ -28,7 +28,7 @@ I18N = {
         "sec_title": "⚠️ 检测到高危神通，请选择因果:", "sec_opt_y": "[Y]仅此", "sec_opt_a": "[A]本轮", "sec_opt_f": "[F]永世", "sec_opt_n": "[N]拒绝", "sec_denied": "🛑 终止。",
         "sec_read": "读取卷轴", "sec_write": "写入法宝", "sec_exec": "执行法宝", "sec_mount": "开辟洞府", "sec_gen_img": "祭炼画卷", "sec_send_mail": "发送邮件", "sec_fetch_web": "抓取互联网", "sec_upload_disk": "上传至云端", "sec_download_disk": "下载自云端", "sec_shell": "执行系统命令",
         "gen_ing": "🎨 祭炼…", "gen_ok": "✅ 画卷成: {}", "gen_fail": "❌ 破碎: ", "see_warn": "⚠️ 需法器 glm-4v-plus", "see_ing": "👁️ 天眼…",
-        "help_title": "📜 修仙指南:", "help_cfg": "【配置】", "help_fs": "【洞府】", "help_sess": "【轮回】", "help_plugin": "【法宝】", "help_extra": "【神通】", "help_shell": "【破壁】",
+        "help_title": "📜 修仙指南:", "help_cfg": "【天道】", "help_fs": "【洞府】", "help_sess": "【轮回】", "help_plugin": "【法宝】", "help_extra": "【神通】", "help_shell": "【破界】",
         "help_usage": "💡 用法: /help [主题]  可用主题: config, fs, session, plugin, mail, cron, web, disk, vision, shell, tools, security, app, agent, builtin, dataframe, gatekeeper, mcp, all",
         "help_not_found": "❌ 未知主题: {}  可用: config, fs, session, plugin, mail, cron, web, disk, vision, shell, tools, security, app, agent, builtin, dataframe, gatekeeper, mcp, all",
         "empty": "空空如也…", "none": "无", "no_sess": "无记忆。", "no_plugins": "无技能。",
@@ -42,8 +42,8 @@ I18N = {
         "web_err": "❌ 迷路:", "web_no_res": "无果。", "web_title": "📜 搜魂:",
         "disk_setup": "/disk_setup", "disk_ls": "/disk_ls <盘>", "disk_up": "/disk_up <盘> <路>", "disk_down": "/disk_down <盘> <云> [本]",
         "disk_ok_up": "✅ 飞升: {}", "disk_ok_down": "✅ 降落: {}", "disk_err": "❌ 御剑: ", "disk_no_cfg": "❌ 未配盘", "disk_miss_dep": "❌ 缺库: {} (pip install {})",
-        "shell_tip": "!命令 执行本地Shell(如 !ls)",
-        "pipe_tip": "!命令 | 提示 管道喂给AI(如 !ps aux | 找出占用CPU最高的进程)",
+        "shell_tip": "!命令 调用天地法则(如 !ls)",
+        "pipe_tip": "!命令 | 提示 周天推演喂给仙人(如 !ps aux | 找出占用灵力最高的修士)",
         "pipe_prefix": "[系统管道数据]:\n",
         "artifact_detect": "⚡ 检测到法宝结构，赐名 (回车放弃): ",
         "recommend_title": "💡 推荐功能:",
@@ -72,7 +72,7 @@ I18N = {
         # ---- 详细帮助文本 ----
         "help_detail_config": """📜 【配置】
 
-/model <name>     切换AI模型 (glm-4-flash, glm-4-plus, glm-4v-plus)
+/model <name>     切换AI模型 (glm-4-flash, deepseek-chat, moonshot-v1-8k, doubao-1-5-pro-32k-250115, mimo-v2-flash 等)
 /key <key>        修改智谱AI API Key
 /limit <n>        设置Token上限 (最小1000)
 /lang <zh/en>     切换界面语言
@@ -305,6 +305,8 @@ AI自动输出调用标记, 程序解析并执行:
 /agent_edit <名称> <类型>      编辑 Agent 设定（persona/memory/skills/agent/workflow）
 /agent_run <名称> [参数]       运行指定 Agent
 /agent_delete <名称>           删除 Agent
+/agent_model <名称> [provider:model|clear|--key <key>]
+                               查看/设置 Agent 专属模型（独立 config.json 持久化）
 
 Agent 目录: ~/.fr_cli_agents/<名称>/
   • persona.md  — 角色设定
@@ -312,6 +314,12 @@ Agent 目录: ~/.fr_cli_agents/<名称>/
   • skills.md   — 技能说明
   • agent.py    — 可选自定义执行逻辑（必须包含 run(context, **kwargs)）
   • workflow.md — 可选工作流定义
+  • config.json — 专属模型配置（provider / model / key，可选）
+
+模型绑定示例：
+  /agent_model my_agent deepseek:deepseek-chat   — 绑定专属模型
+  /agent_model my_agent --key sk-own-key         — 设置独立 API Key
+  /agent_model my_agent clear                    — 清除专属配置，恢复全局默认
 
 将已有代码转为 Agent 的方法：
   1. 在对话中让 AI 生成包含 def run(context, **kwargs) 的代码
@@ -496,7 +504,7 @@ Example:
         "rec_pipe": "Pipe command output to AI",
         "help_detail_config": """📜 [Config]
 
-/model <name>     Switch AI model (glm-4-flash, glm-4-plus, glm-4v-plus)
+/model <name>     Switch AI model (glm-4-flash, deepseek-chat, moonshot-v1-8k, doubao-1-5-pro-32k-250115, mimo-v2-flash, etc.)
 /key <key>        Change ZhipuAI API Key
 /limit <n>        Set token limit (min 1000)
 /lang <zh/en>     Switch UI language
@@ -729,6 +737,8 @@ Common app aliases:
 /agent_edit <name> <type>     Edit Agent settings (persona/memory/skills/agent/workflow)
 /agent_run <name> [args]      Run specified Agent
 /agent_delete <name>          Delete Agent
+/agent_model <name> [provider:model|clear|--key <key>]
+                              View/set Agent-specific model (persisted in config.json)
 
 Agent directory: ~/.fr_cli_agents/<name>/
   • persona.md  — Character setting
@@ -736,6 +746,12 @@ Agent directory: ~/.fr_cli_agents/<name>/
   • skills.md   — Skill descriptions
   • agent.py    — Optional custom execution logic (must contain run(context, **kwargs))
   • workflow.md — Optional workflow definition
+  • config.json — Model binding config (provider / model / key, optional)
+
+Model binding examples:
+  /agent_model my_agent deepseek:deepseek-chat  — Bind exclusive model
+  /agent_model my_agent --key sk-own-key        — Set independent API Key
+  /agent_model my_agent clear                   — Clear config, fallback to global default
 
 How to turn existing code into an Agent:
   1. Ask AI to generate code containing def run(context, **kwargs)

{fr_cli-2.2.6 → fr_cli-2.2.7}/fr_cli/main.py

@@ -71,6 +71,7 @@ from fr_cli.repl.commands import (
     _cmd_agent_run,
     _cmd_agent_edit,
     _cmd_agent_forge,
+    _cmd_agent_model,
     _cmd_remote_agent_add,
     _cmd_remote_agent_list,
     _cmd_remote_agent_del,
@@ -130,6 +131,7 @@ _COMMAND_ROUTES = {
     "/agent_run": _cmd_agent_run,
     "/agent_edit": _cmd_agent_edit,
     "/agent_forge": _cmd_agent_forge,
+    "/agent_model": _cmd_agent_model,
     "/remote_agent_add": _cmd_remote_agent_add,
     "/remote_agent_list": _cmd_remote_agent_list,
     "/remote_agent_del": _cmd_remote_agent_del,