Files
AgentLab/backend/app/tools/custom.py
T
ThearchyHelios 587bf7e27c 第三波前两批:六个「看着成功其实没干活」的平台漏洞堵上,记录页能回放,管理页与画布收尾
起因是一次探索运行:Copilot 改节点时把工具绑定整份抹掉,agent 没有工具只能写「假设调用」,
校验节点的自动修复编出 total_count=0 让 schema 通过,协作成员把工具调用标记当文字输出了四轮,
轮数用完后节点把原话当成功结果交出去——运行标成已完成,数据库一次都没查。

平台可信度(先写失败测试)
- Copilot 修改节点改为合并:没写的字段保留,null 才删除;协作成员按名字合并。前后端同一套规则,
  工具集合变小时自查报警、改图回执列出变化
- 新校验规则:提示词点名了某个工具而节点没有绑定它,判错误,Copilot 自查会交回去修
- 校验修复只许改格式:冒出原文没有的值就判修复无效;修复这次模型调用计入用量
- 识别模型把工具调用写成文字的情况(DSML、<tool_call> 等标记):纠正一次,仍然如此就判失败并说明原因
- 协作团队用完轮数不再按成功交付:默认失败,可选降档,点出一次都没派到的成员
- 审批恢复后,同一节点里已经执行过的工具调用复用结果,不再重复执行

后端
- 查询时限交给数据库执行(Oracle call_timeout、PG statement_timeout、MySQL max_execution_time、
  SQLite progress handler),可按数据源配置;超时报错与实际耗时一致
- 等审批的运行可以真正取消;会话列表带最后一轮状态;测连接结果持久化;探查结构可只看不存;
  自定义工具可草稿试跑、写坏的参数定义保存时拒绝;MCP 服务改动后作废旧工具缓存;
  检索命中带贡献分解;重建索引在后台跑并报进度;报错统一收进 core/errors

前端
- 公共层:管理页共用件、失败说明(lib/explain)、健康状态进公共库;目录按表各自加载并有超时,
  一张表卡住不再拖垮整站;上传显示真实字节进度;离线横幅只播报不变的句子
- 画布:卡片只说游标所在的那一次执行;等审批时可放弃运行;团队收尾判定与未完成说清楚;
  回放用量取那一刻的值
- 编排页:Copilot 合并语义与工具变化回执;「用完轮数时」选项;正式运行期间锁住所有改图入口
- 回答流 / 问数据:新失败类型说人话并给下一步;画布与右栏互相定位;数据源范围、回收站、重新核对
- 记录页:「航迹」页签复用画布时间轴,可拖动回放、列出关键时刻;列表行带执行 / 等人 / 失败缩略条
- 外壳:统一的离开前确认(data router),导航、⌘K、快捷键、后退都会先问

验证(沙箱):tsc 干净,pytest 838 passed(两遍),14 个检查脚本中 13 个全绿;
check-ui 余 1 项旧断言(按旧日期格式找运行行),3c 更新。
2026-09-27 10:16:32 +08:00

244 lines
11 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
from __future__ import annotations
import json
from typing import Any
from langchain_core.tools import BaseTool, StructuredTool
from pydantic import BaseModel, Field, create_model
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from app.db.models import CustomTool
from app.engine.expressions import render_deep, render_template
from app.sandbox.base import SandboxLimits
from app.sandbox.manager import sandbox_manager
from app.tools.net import UnsafeUrlError, safe_request
from app.tools.registry import ToolBuildError, ToolContext, prepare_args
_TYPES = {
"string": str,
"number": float,
"integer": int,
"boolean": bool,
"array": list,
"object": dict,
}
#: 手写参数定义时常见的类型写法(Python 的、其他语言的、缩写)。只用来在报错里
#: 猜「是不是想写 X」,不自动放行:悄悄按猜的类型建出来,试跑和运行对不上还没人知道
_TYPE_ALIASES = {
"int": "integer", "long": "integer", "float": "number", "double": "number",
"decimal": "number", "str": "string", "text": "string", "bool": "boolean",
"list": "array", "dict": "object", "map": "object", "json": "object",
}
def _type_guess(value: Any) -> str | None:
"""value 像是哪个合法类型;认不出来返回 None。"""
if not isinstance(value, str):
return None
low = value.strip().lower()
return low if low in _TYPES else _TYPE_ALIASES.get(low)
def schema_to_model(name: str, schema: dict[str, Any]) -> type[BaseModel]:
"""把 JSON Schema 转成 pydantic 模型,好让它能绑成 LangChain 工具。"""
props = (schema or {}).get("properties") or {}
required = set((schema or {}).get("required") or [])
fields: dict[str, Any] = {}
for key, spec in props.items():
py_type = _TYPES.get(spec.get("type", "string"), str)
description = spec.get("description", "")
if key in required:
fields[key] = (py_type, Field(description=description))
else:
fields[key] = (py_type | None, Field(default=spec.get("default"), description=description))
if not fields:
fields["input"] = (str, Field(default="", description="工具输入"))
return create_model(f"{name}_Args", **fields) # type: ignore[call-overload]
def schema_problem(schema: Any) -> str | None:
"""参数定义哪里写得不对;没问题返回 None。
参数定义是用户在编辑器里手写的 JSON。schema_to_model 只认 {"type": "integer"}
这样的写法,写成 "int" 或 {"type": "int"} 时要么炸在 .get 上、要么悄悄当成
字符串——前者会被说成「后端内部出错了」,后者试跑通过、到了模型那边类型不对。
"""
if not isinstance(schema, dict):
return "参数定义要是一个 JSON 对象"
props = schema.get("properties")
if props is not None and not isinstance(props, dict):
return '参数定义格式不对:properties 要是一个对象,每个参数一项,比如 {"n": {"type": "integer"}}'
for key, spec in (props or {}).items():
if not str(key).strip():
return "参数定义格式不对:有一个参数名是空的,给它起个名字"
if str(key).startswith("_"):
return (f"参数定义格式不对:参数名 {key} 不能以下划线开头,"
f"换成 {str(key).lstrip('_') or 'value'} 这样的名字")
if str(key).startswith("model_") and hasattr(BaseModel, str(key)):
return f"参数定义格式不对:参数名 {key} 和内部保留的名字冲突,换一个名字"
if not isinstance(spec, dict):
# 示例照着他写的那个类型给,照抄就能改好:写了 "string" 却让人改成 integer 只会添乱
shown = json.dumps(spec, ensure_ascii=False)
meant = _type_guess(spec) or "string"
return (f'参数定义格式不对:参数 {key} 要写成 {{"type": "{meant}"}} 这样的对象,'
f"不能直接写 {shown}")
kind = spec.get("type", "string")
if not isinstance(kind, str) or kind not in _TYPES:
shown = kind if isinstance(kind, str) else json.dumps(kind, ensure_ascii=False)
meant = _type_guess(kind)
guess = f",是不是想写 {meant}" if meant else ""
return (f"参数定义格式不对:参数 {key} 的类型「{shown}」认不出来{guess};"
f"只能是 {'、'.join(_TYPES)} 里的一个")
if not isinstance(spec.get("description", ""), str):
return f"参数定义格式不对:参数 {key} 的 description 要是一段文字"
required = schema.get("required")
if required is not None and (
not isinstance(required, list) or not all(isinstance(k, str) for k in required)
):
return '参数定义格式不对:required 要是参数名的列表,比如 ["n"]'
# 上面没认出来的写法,最后按运行时同一个转换真建一次:放行的一定建得出来
import warnings
try:
with warnings.catch_warnings():
warnings.simplefilter("ignore") # 和 BaseModel 同名的参数(json、copy)只是警告,照样能用
schema_to_model("probe", schema)
except Exception: # noqa: BLE001
return "参数定义格式不对:按它建不出工具的参数表,检查参数名和每个参数的 type"
return None
def broken_tool_message(name: str, problem: str) -> str:
"""库里存着的坏工具被节点绑上时的报错:哪个工具、坏在哪、去哪里改。"""
return f"自定义工具「{name}」的{problem}。到「工具」页把它的参数定义改好再运行"
class ToolFailure(dict):
"""工具自己报的失败:沙箱里代码出错、地址被拦、请求体不是 JSON。
运行时照旧当成 {"error": …} 交给模型——它看了会换个参数再试;但试跑时要
认得出这是失败,不能在界面上标「成功」再贴一段报错。所以是个 dict 的子类:
序列化出来和原来一模一样,只多了一个能 isinstance 的身份。
"""
async def _run_http(row: CustomTool, args: dict[str, Any]) -> Any:
"""HTTP 模板工具:url / headers / body 里可以用 {{ 参数名 }} 插值。"""
config = row.config or {}
ctx = dict(args)
url = render_template(config.get("url", ""), ctx)
headers = render_deep(config.get("headers") or {}, ctx)
body = config.get("body")
json_body = None
if body:
rendered = render_deep(body, ctx) if isinstance(body, dict) else render_template(str(body), ctx)
json_body = rendered if isinstance(rendered, dict) else json.loads(rendered or "null")
try:
result = await safe_request(
config.get("method", "GET"),
url,
headers={k: str(v) for k, v in (headers or {}).items()},
json_body=json_body,
timeout=config.get("timeout"),
)
except UnsafeUrlError as e:
return ToolFailure(error=str(e))
except json.JSONDecodeError as e:
return ToolFailure(error=f"请求体不是合法 JSON:{e}")
text = str(result.get("body", ""))
if config.get("parse_json"):
try:
return {"status": result["status"], "data": json.loads(text)}
except json.JSONDecodeError:
return {"status": result["status"], "body": text}
return {"status": result["status"], "body": text}
async def _run_python(row: CustomTool, args: dict[str, Any], ctx: ToolContext) -> Any:
"""Python 工具:用户代码跑在沙箱里,参数通过 args 变量注入。"""
config = row.config or {}
code = config.get("code", "")
preamble = (
"import json, sys\n"
f"args = json.loads({json.dumps(json.dumps(args, ensure_ascii=False))})\n"
)
result = await sandbox_manager.run(
preamble + code,
language="python",
limits=SandboxLimits(timeout=int(config.get("timeout") or 30)),
session_id=ctx.sandbox_session,
)
if not result.ok:
return ToolFailure(error=result.error or result.stderr or "执行失败", exit_code=result.exit_code)
out = result.stdout.strip()
try:
return json.loads(out)
except json.JSONDecodeError:
return out
async def build_custom_tools(
names: list[str], ctx: ToolContext, session: AsyncSession
) -> list[BaseTool]:
rows = list(
(
await session.execute(
select(CustomTool).where(
CustomTool.name.in_(names), CustomTool.enabled.is_(True)
)
)
).scalars()
)
# 保存时已经拒掉写坏的参数定义,但那道关卡之前存进去的还在库里。不交给
# schema_to_model 去炸——那样节点只能报一句「'str' object has no attribute 'get'」,
# 看不出是哪个工具。也不悄悄跳过它接着跑:少了一个它指望的工具,模型只会
# 假装调过、编出一个答案。绑了它的节点失败,协作成员这一步记为失败交给调度者
broken = [broken_tool_message(row.name, problem) for row in rows
if (problem := schema_problem(row.parameters or {}))]
if broken:
raise ToolBuildError(";".join(broken))
tools: list[BaseTool] = []
for row in rows:
args_model = schema_to_model(row.name, row.parameters or {})
def _make(bound_row: CustomTool):
async def _run(**kwargs: Any) -> str:
if bound_row.kind == "python":
value = await _run_python(bound_row, kwargs, ctx)
else:
value = await _run_http(bound_row, kwargs)
if isinstance(value, str):
return value
return json.dumps(value, ensure_ascii=False, default=str, indent=2)
return _run
tools.append(
StructuredTool(
name=row.name,
description=row.description or f"自定义工具 {row.name}",
args_schema=args_model,
coroutine=_make(row),
func=None,
)
)
return tools
async def trial(row: CustomTool, args: dict[str, Any], ctx: ToolContext) -> tuple[Any, str | None]:
"""试跑一次,参数的处理和运行时一样:先按参数 schema 校验、纠正,再执行。
row 可以是还没保存的草稿。以前试跑直接把参数原样塞进去,运行时却要过
schema——试跑通过的参数,到了工作流里被拒。参数不对抛 ToolArgsError。
返回 (结果, 纠正说明或 None)。参数名写错被替换时,运行时会把说明报出去;
试跑也得报,否则用户照着一份「跑通了」的错参数去配工作流。
"""
payload, note = prepare_args(schema_to_model(row.name or "draft", row.parameters or {}), args)
if row.kind == "python":
return await _run_python(row, payload, ctx), note
return await _run_http(row, payload), note