| """agent.py — 极简工具调用 Agent，用于测试小模型（MiniCPM5-2B 等）的 function calling |
| |
| 为什么需要它：Claude Code / ZCode 这类 agent 的系统提示动辄上万 token， |
| 超过本地小模型的上下文包线（本机 6GB 卡：bf16 ~3K / fp16 ~8K token）。 |
| 本 agent 的固定开销控制在 ~150 token 以内。 |
| |
| 用法： |
| .venv/bin/python agent.py # 交互式终端界面（REPL） |
| .venv/bin/python agent.py "创建 /tmp/agent_test.txt 写入 hello，然后读回确认" # 单轮模式 |
| .venv/bin/python agent.py --url http://127.0.0.1:8000/v1 --thinking off "列出当前目录文件" |
| |
| 交互界面命令： |
| /quit /exit 退出 |
| /reset 清空会话历史 |
| /yes 切换 shell 命令逐条确认开关 |
| /ablate off|on [k] 本次会话的请求级消融开关与子空间维度（默认跟随服务端） |
| /tokens 显示当前会话估计 token 数 |
| /help 帮助 |
| |
| 选项： |
| --url serve.py 的 OpenAI 端点（默认 http://127.0.0.1:8000/v1） |
| --max-steps 最大工具调用轮数（默认 10） |
| --budget 对话 token 预算（默认 6000；超限自动把最老的工具输出替换为占位符） |
| --out-chars 单次工具输出截断长度（默认 1000 字符） |
| --thinking on/off 思维链开关（默认 off，省 token） |
| --yes 执行 shell 命令前不询问（默认逐条询问） |
| """ |
| import argparse |
| import json |
| import os |
| import subprocess |
| import sys |
| import urllib.request |
|
|
| SYSTEM = "你是命令行助手。通过调用工具完成任务。工具结果给你后，继续调用工具或给出简短最终答复。" |
|
|
| TOOLS = [ |
| {"type": "function", "function": { |
| "name": "run_shell", |
| "description": "执行 shell 命令并返回输出", |
| "parameters": {"type": "object", |
| "properties": {"command": {"type": "string", "description": "shell 命令"}}, |
| "required": ["command"]}}}, |
| {"type": "function", "function": { |
| "name": "read_file", |
| "description": "读取文本文件", |
| "parameters": {"type": "object", |
| "properties": {"path": {"type": "string", "description": "文件路径"}, |
| "offset": {"type": "integer", "description": "起始行号(从1起)"}, |
| "limit": {"type": "integer", "description": "最多读取行数"}}, |
| "required": ["path"]}}}, |
| {"type": "function", "function": { |
| "name": "write_file", |
| "description": "写入文本文件（覆盖）", |
| "parameters": {"type": "object", |
| "properties": {"path": {"type": "string", "description": "文件路径"}, |
| "content": {"type": "string", "description": "文件内容"}}, |
| "required": ["path", "content"]}}}, |
| ] |
|
|
|
|
| |
| def run_shell(command, assume_yes): |
| if not assume_yes: |
| ans = input(f"\033[33m执行命令?\033[0m {command}\n[y/N] ").strip().lower() |
| if ans != "y": |
| return "用户拒绝了该命令" |
| try: |
| r = subprocess.run(command, shell=True, capture_output=True, text=True, timeout=60) |
| out = (r.stdout + r.stderr).strip() |
| return out or f"(退出码 {r.returncode}，无输出)" |
| except subprocess.TimeoutExpired: |
| return "(命令超时 60s)" |
|
|
|
|
| def read_file(path, offset=None, limit=None): |
| try: |
| with open(path, errors="replace") as f: |
| lines = f.readlines() |
| start = max(0, (offset or 1) - 1) |
| sel = lines[start: start + (limit or 200)] |
| return "".join(sel) or "(空文件)" |
| except Exception as e: |
| return f"(读取失败: {e})" |
|
|
|
|
| def write_file(path, content): |
| try: |
| os.makedirs(os.path.dirname(os.path.abspath(path)), exist_ok=True) |
| with open(path, "w") as f: |
| f.write(content) |
| return f"(已写入 {len(content)} 字符)" |
| except Exception as e: |
| return f"(写入失败: {e})" |
|
|
|
|
| def execute(call, assume_yes): |
| fn = call["function"] |
| try: |
| args = json.loads(fn["arguments"] or "{}") |
| except json.JSONDecodeError: |
| return f"(参数 JSON 解析失败: {fn['arguments'][:100]!r})" |
| if fn["name"] == "run_shell": |
| return run_shell(args.get("command", ""), assume_yes) |
| if fn["name"] == "read_file": |
| return read_file(args.get("path", ""), args.get("offset"), args.get("limit")) |
| if fn["name"] == "write_file": |
| return write_file(args.get("path", ""), args.get("content", "")) |
| return f"(未知工具: {fn['name']})" |
|
|
|
|
| |
| def chat(url, messages, max_tokens, thinking, ablate=None, ablate_k=None): |
| body = {"messages": messages, "tools": TOOLS, "max_tokens": max_tokens, |
| "enable_thinking": thinking} |
| if ablate is not None: |
| body["ablate_refusal"] = ablate |
| if ablate_k is not None: |
| body["ablate_k"] = ablate_k |
| req = urllib.request.Request(f"{url}/chat/completions", data=json.dumps(body).encode(), |
| headers={"Content-Type": "application/json"}) |
| with urllib.request.urlopen(req, timeout=600) as r: |
| resp = json.load(r) |
| return resp["choices"][0]["message"], resp["choices"][0]["finish_reason"] |
|
|
|
|
| def estimate_tokens(messages): |
| """粗略估计：中英文混合按 2 字符/token 偏保守""" |
| return sum(len(json.dumps(m, ensure_ascii=False)) for m in messages) // 2 |
|
|
|
|
| def shrink(messages, budget): |
| """超预算时把最老的 tool 输出替换为占位符（保留系统提示与最近上下文）""" |
| for m in messages: |
| if estimate_tokens(messages) <= budget: |
| break |
| if m["role"] == "tool" and m["content"] != "[历史输出已省略]": |
| m["content"] = "[历史输出已省略]" |
|
|
|
|
| def run_task(messages, task, args, ablate=None, ablate_k=None, ui=None): |
| """执行一个任务的多轮工具循环。ui 非 None 时用 rich 渲染，否则纯文本。 |
| 返回 True=完成，False=达到轮数上限/出错。""" |
| messages.append({"role": "user", "content": task}) |
| for step in range(1, args.max_steps + 1): |
| shrink(messages, args.budget) |
| try: |
| if ui is not None: |
| with ui.status("[dim]思考中…[/]", spinner="dots"): |
| msg, finish = chat(args.url, messages, args.max_tokens, |
| args.thinking == "on", ablate, ablate_k) |
| else: |
| msg, finish = chat(args.url, messages, args.max_tokens, |
| args.thinking == "on", ablate, ablate_k) |
| except urllib.error.HTTPError as e: |
| print(f"[HTTP {e.code}] {e.read().decode()[:200]}") |
| return False |
|
|
| tool_calls = msg.get("tool_calls") or [] |
| if finish != "tool_calls" or not tool_calls: |
| content = msg.get("content") or "(空)" |
| if ui is not None: |
| from rich.markdown import Markdown |
| from rich.panel import Panel |
| ui.print(Panel(Markdown(content), title=f"[green]助手[/]（第 {step} 轮）", |
| border_style="green")) |
| else: |
| print(f"\n=== 最终答复（第 {step} 轮）===\n{content}") |
| return True |
|
|
| messages.append({"role": "assistant", "content": msg.get("content") or "", |
| "tool_calls": tool_calls}) |
| for call in tool_calls: |
| fn = call["function"] |
| if ui is not None: |
| ui.print(f"[cyan]🔧 step {step}[/] [bold]{fn['name']}[/]" |
| f"[dim]({fn['arguments'][:120]})[/]") |
| else: |
| print(f"[step {step}] {fn['name']}({fn['arguments'][:120]})") |
| out = execute(call, args.yes) |
| if len(out) > args.out_chars: |
| out = out[:args.out_chars] + f"... [截断，共 {len(out)} 字符]" |
| if ui is not None: |
| ui.print(f" [dim]→ {out[:150]!r}[/]") |
| else: |
| print(f" → {out[:150]!r}") |
| messages.append({"role": "tool", "content": out}) |
|
|
| print(f"\n达到最大轮数 {args.max_steps}，任务未完成。") |
| return False |
|
|
|
|
| HELP_TEXT = """\ |
| [bold]命令[/]： |
| /quit, /exit 退出 |
| /reset 清空会话历史（保留系统提示） |
| /yes 切换 shell 命令逐条确认开关 |
| /ablate off 本会话关闭消融 |
| /ablate on [k] 本会话开启消融，可选子空间维度 k（1–32） |
| /ablate 跟随服务端默认 |
| /tokens 显示当前会话估计 token 数 |
| /help 本帮助 |
| 直接输入任务文本即可开始多轮工具调用。""" |
|
|
|
|
| def interactive(args): |
| from rich.console import Console |
| from rich.panel import Panel |
| con = Console() |
|
|
| health_txt = "" |
| try: |
| hurl = args.url.rstrip("/") |
| hurl = hurl[:-3] + "/health" if hurl.endswith("/v1") else hurl + "/health" |
| with urllib.request.urlopen(hurl, timeout=5) as r: |
| h = json.load(r) |
| health_txt = (f"模型 [bold]{h.get('model')}[/]（{h.get('device')}）" |
| f"｜服务端消融默认: {'开' if h.get('ablate_default') else '关'}") |
| except Exception as e: |
| con.print(f"[red]无法连接 {args.url}: {e}[/]") |
| sys.exit(1) |
|
|
| con.print(Panel(f"[bold]MiniAgent[/] — 极简小模型工具调用测试台\n{health_txt}\n" |
| f"token 预算 {args.budget}｜思维链 {args.thinking}｜输入 /help 查看命令", |
| border_style="cyan")) |
|
|
| messages = [{"role": "system", "content": SYSTEM}] |
| ablate, ablate_k = None, None |
| assume_yes = args.yes |
|
|
| while True: |
| try: |
| line = con.input("[bold magenta]任务 ›[/] ").strip() |
| except (EOFError, KeyboardInterrupt): |
| con.print("\n再见。") |
| return |
| if not line: |
| continue |
| if line.startswith("/"): |
| parts = line.split() |
| cmd = parts[0].lower() |
| if cmd in ("/quit", "/exit"): |
| con.print("再见。") |
| return |
| elif cmd == "/reset": |
| messages[:] = messages[:1] |
| con.print("[dim]会话已清空。[/]") |
| elif cmd == "/yes": |
| assume_yes = not assume_yes |
| args.yes = assume_yes |
| con.print(f"[dim]shell 逐条确认: {'关（自动执行）' if assume_yes else '开'}[/]") |
| elif cmd == "/ablate": |
| if len(parts) == 1 or parts[1] == "auto": |
| ablate, ablate_k = None, None |
| con.print("[dim]消融: 跟随服务端默认[/]") |
| elif parts[1] == "off": |
| ablate, ablate_k = False, None |
| con.print("[dim]消融: 本会话关闭[/]") |
| elif parts[1] == "on": |
| ablate = True |
| if len(parts) > 2 and parts[2].isdigit(): |
| ablate_k = max(1, min(32, int(parts[2]))) |
| con.print(f"[dim]消融: 本会话开启，k={ablate_k or '服务端默认'}[/]") |
| else: |
| con.print("[red]用法: /ablate [off|on [k]|auto][/]") |
| elif cmd == "/tokens": |
| con.print(f"[dim]会话估计 {estimate_tokens(messages)} token（预算 {args.budget}）[/]") |
| elif cmd == "/help": |
| con.print(HELP_TEXT) |
| else: |
| con.print(f"[red]未知命令 {cmd}，输入 /help[/]") |
| continue |
| run_task(messages, line, args, ablate=ablate, ablate_k=ablate_k, ui=con) |
|
|
|
|
| def main(): |
| p = argparse.ArgumentParser() |
| p.add_argument("task", nargs="?", help="任务（省略则进入交互式终端界面）") |
| p.add_argument("--url", default="http://127.0.0.1:8000/v1") |
| p.add_argument("--max-steps", type=int, default=10) |
| p.add_argument("--budget", type=int, default=6000) |
| p.add_argument("--out-chars", type=int, default=1000) |
| p.add_argument("--max-tokens", type=int, default=512) |
| p.add_argument("--thinking", choices=["on", "off"], default="off") |
| p.add_argument("--yes", action="store_true", help="shell 命令不再逐条确认") |
| args = p.parse_args() |
|
|
| if args.task is None: |
| interactive(args) |
| return |
|
|
| messages = [{"role": "system", "content": SYSTEM}] |
| ok = run_task(messages, args.task, args) |
| sys.exit(0 if ok else 2) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
