@shulex/cxclawctl 0.1.2 → 0.1.4

package/skills/agent-builder/scripts/patch_agent_tools.py

@@ -1,135 +0,0 @@
-#!/usr/bin/env python3
-"""Patch headers on tools attached to one or more agents.
-
-Usage:
-  python3 /skills/agent-builder/scripts/patch_agent_tools.py \
-    --agent-id 123 --tool-name new_Order_information_ship --patch-x-token --dry-run --pretty
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import os
-import sys
-
-sys.path.insert(0, os.path.join(os.environ.get("SOLVEA_LIB_DIR", ""), "skill-runtime"))
-try:
-    from bootstrap import *  # noqa: F401,F403
-except Exception:
-    sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "..", "__lib__", "skill-runtime"))
-    from bootstrap import *  # noqa: F401,F403
-
-from client import SolveaClient
-
-
-def _token_value(raw) -> str:
-    if isinstance(raw, dict):
-        return str(raw.get("apiKey") or raw.get("key") or raw.get("value") or raw.get("data") or "")
-    return str(raw or "")
-
-
-def _tool_items(response):
-    if isinstance(response, list):
-        return response
-    if isinstance(response, dict):
-        for key in ("list", "data", "records"):
-            if isinstance(response.get(key), list):
-                return response[key]
-    return []
-
-
-def _patch_headers(config: dict, headers: dict[str, str]) -> dict:
-    updated = dict(config or {})
-    existing = dict(updated.get("headers") or {})
-    existing.update(headers)
-    updated["headers"] = existing
-
-    external = updated.get("externalHttpCallConfig")
-    if isinstance(external, dict) and isinstance(external.get("headerParams"), list):
-        by_name = {h.get("name"): h for h in external["headerParams"] if isinstance(h, dict)}
-        for name, value in headers.items():
-            if name in by_name:
-                by_name[name]["value"] = value
-            else:
-                external["headerParams"].append({"name": name, "value": value, "description": ""})
-    return updated
-
-
-def patch_agent_tools(
-    client: SolveaClient,
-    agent_id: int,
-    tool_names: set[str],
-    headers: dict[str, str],
-    dry_run: bool = False,
-) -> list[dict]:
-    response = client._curl("GET", f"/api_v2/gpt/ap/agent/{agent_id}/tools", {})
-    results = []
-    for tool in _tool_items(response):
-        name = tool.get("name")
-        if tool_names and name not in tool_names:
-            continue
-        tool_id = tool.get("id")
-        if not tool_id:
-            continue
-        config = _patch_headers(tool.get("config") or {}, headers)
-        item = {"agent_id": agent_id, "tool_id": tool_id, "tool_name": name, "dry_run": dry_run}
-        if not dry_run:
-            client._curl("PUT", f"/api_v2/gpt/ap/tools/{tool_id}", {"config": config})
-            item["updated"] = True
-        results.append(item)
-    return results
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(description="Patch headers for tools attached to agents")
-    parser.add_argument("--agent-id", type=int, action="append", required=True,
-                        help="Agent id. Can be repeated.")
-    parser.add_argument("--tool-name", action="append", default=[],
-                        help="Only patch matching tool name. Can be repeated. Omit to patch all tools.")
-    parser.add_argument("--header", action="append", default=[],
-                        help="Header assignment, e.g. X-Token=abc. Can be repeated.")
-    parser.add_argument("--patch-x-token", action="store_true",
-                        help="Fetch current project API key and patch X-Token.")
-    parser.add_argument("--env", choices=["staging", "prod"], default=os.environ.get("SOLVEA_ENV", "prod"))
-    parser.add_argument("--project-id", default=None)
-    parser.add_argument("--dry-run", action="store_true")
-    parser.add_argument("--pretty", action="store_true")
-    args = parser.parse_args()
-
-    headers = {}
-    for item in args.header:
-        if "=" not in item:
-            raise ValueError(f"--header must be NAME=VALUE, got {item!r}")
-        name, value = item.split("=", 1)
-        headers[name] = value
-
-    client = SolveaClient(env=args.env, project_id=args.project_id)
-    if args.patch_x_token:
-        x_token = _token_value(client.get_api_key())
-        if not x_token:
-            raise RuntimeError("get_api_key returned no token value")
-        headers["X-Token"] = x_token
-    if not headers:
-        raise ValueError("provide --header NAME=VALUE or --patch-x-token")
-
-    patched = []
-    for agent_id in args.agent_id:
-        patched.extend(
-            patch_agent_tools(
-                client,
-                agent_id,
-                set(args.tool_name),
-                headers,
-                dry_run=args.dry_run,
-            )
-        )
-    output = {
-        "patched": patched,
-        "matched_count": len(patched),
-        "headers": sorted(headers),
-    }
-    print(json.dumps(output, ensure_ascii=False, indent=2 if args.pretty else None))
-
-
-if __name__ == "__main__":
-    main()

package/skills/agent-builder/scripts/tools/validate_tool_config.py

@@ -1,384 +0,0 @@
-#!/usr/bin/env python3
-"""Validate a local Agent Builder HTTP tool JSON payload."""
-from __future__ import annotations
-
-import argparse
-import json
-import math
-from pathlib import Path
-from typing import Any
-
-
-PARAMETER_TYPES = {"string", "integer", "number", "date", "boolean", "array", "object"}
-API_TYPES_BY_PARAMETER_TYPE = {
-    "string": {"TEXT"},
-    "integer": {"NUMBER"},
-    "number": {"NUMBER"},
-    "date": {"DATE_TO_NOW", "NOW_TO_DATE"},
-    "boolean": {"BOOLEAN"},
-    "array": {"ARRAY_SIZE"},
-    "object": set(),
-}
-RELATIONS_BY_API_TYPE = {
-    "TEXT": {"CONTAIN", "NOT_CONTAIN", "IS_EMPTY", "NOT_EMPTY", "EQUAL", "NOT_EQUAL"},
-    "NUMBER": {
-        "GREATER_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN", "LESS_THAN_OR_EQUAL",
-        "BETWEEN", "EQUAL", "NOT_EQUAL", "IS_EMPTY", "NOT_EMPTY",
-    },
-    "DATE_TO_NOW": {
-        "GREATER_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN", "LESS_THAN_OR_EQUAL",
-        "BETWEEN", "EQUAL", "NOT_EQUAL", "IS_EMPTY", "NOT_EMPTY",
-    },
-    "NOW_TO_DATE": {
-        "GREATER_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN", "LESS_THAN_OR_EQUAL",
-        "BETWEEN", "EQUAL", "NOT_EQUAL", "IS_EMPTY", "NOT_EMPTY",
-    },
-    "ARRAY_SIZE": {
-        "GREATER_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN", "LESS_THAN_OR_EQUAL",
-        "BETWEEN", "EQUAL", "NOT_EQUAL", "IS_EMPTY", "NOT_EMPTY",
-    },
-    "BOOLEAN": {"EQUAL", "NOT_EQUAL", "IS_EMPTY", "NOT_EMPTY"},
-}
-
-
-def reject_non_finite_json_number(value: str) -> None:
-    raise ValueError(f"non-finite JSON number {value} is not allowed")
-
-
-def parse_finite_json_float(value: str) -> float:
-    parsed = float(value)
-    if not math.isfinite(parsed):
-        reject_non_finite_json_number(value)
-    return parsed
-
-
-def is_finite_number_value(value: Any) -> bool:
-    if isinstance(value, bool):
-        return False
-    if isinstance(value, (int, float)):
-        return math.isfinite(value)
-    if isinstance(value, str) and value.strip():
-        try:
-            return math.isfinite(float(value.strip()))
-        except ValueError:
-            return False
-    return False
-
-
-def validate_tool_config(data: Any) -> dict[str, Any]:
-    errors: list[dict[str, str]] = []
-
-    def add_error(path: str, code: str, message: str) -> None:
-        errors.append({"path": path, "code": code, "message": message})
-
-    if not isinstance(data, dict):
-        add_error("$", "invalid_tool_config", "tool config must be a JSON object")
-        return {"valid": False, "errors": errors}
-
-    if data.get("type") != "EXTERNAL_HTTP_CALL":
-        add_error("type", "invalid_tool_type", "type must be EXTERNAL_HTTP_CALL")
-
-    meta = data.get("meta")
-    if not isinstance(meta, dict):
-        add_error("meta", "missing_meta", "meta must be an object")
-        meta = {}
-    external = meta.get("externalHttpCallConfig")
-    if not isinstance(external, dict):
-        add_error(
-            "meta.externalHttpCallConfig",
-            "missing_external_http_call_config",
-            "externalHttpCallConfig must be an object",
-        )
-        external = {}
-
-    category = meta.get("category")
-    is_manual = category == "MANUAL" or (category is None and data.get("source") == "MANUAL")
-    if is_manual and not str(external.get("url") or "").strip():
-        add_error(
-            "meta.externalHttpCallConfig.url",
-            "missing_manual_url",
-            "MANUAL tools require a non-empty URL",
-        )
-    if meta.get("category") == "EXCEL" and not str(meta.get("fileName") or "").strip():
-        add_error("meta.fileName", "missing_excel_file_name", "EXCEL tools require fileName")
-
-    headers = external.get("headerParams", [])
-    if not isinstance(headers, list):
-        add_error(
-            "meta.externalHttpCallConfig.headerParams",
-            "invalid_headers",
-            "headerParams must be an array",
-        )
-    else:
-        for index, header in enumerate(headers):
-            header_path = f"meta.externalHttpCallConfig.headerParams[{index}]"
-            if not isinstance(header, dict):
-                add_error(header_path, "invalid_header", "header must be an object")
-                continue
-            name = header.get("name")
-            if not isinstance(name, str) or not name.strip():
-                add_error(
-                    f"{header_path}.name",
-                    "invalid_header_name",
-                    "header name must not be empty",
-                )
-
-    parameter_count = {"request": 0, "response": 0}
-    response_paths: dict[str, str] = {}
-
-    def validate_items(
-        items: Any,
-        schema_path: str,
-        kind: str,
-        api_parent: tuple[str, ...] = (),
-        include_api_name: bool = True,
-    ) -> None:
-        if not isinstance(items, list):
-            add_error(schema_path, "invalid_parameter_items", "items must be an array")
-            return
-
-        names: set[str] = set()
-        for index, item in enumerate(items):
-            item_path = f"{schema_path}[{index}]"
-            if not isinstance(item, dict):
-                add_error(item_path, "invalid_parameter", "parameter must be an object")
-                continue
-            parameter_count[kind] += 1
-            name = item.get("name")
-            clean_name = name.strip() if isinstance(name, str) else ""
-            if not clean_name:
-                add_error(f"{item_path}.name", "invalid_parameter_name", "parameter name must not be empty")
-            elif "." in clean_name:
-                add_error(f"{item_path}.name", "invalid_parameter_name", "parameter name must not contain dots")
-            if clean_name in names:
-                add_error(
-                    f"{item_path}.name",
-                    "duplicate_parameter_name",
-                    f"duplicate parameter name {clean_name!r} in the same scope",
-                )
-            elif clean_name:
-                names.add(clean_name)
-
-            parameter_type = item.get("type")
-            valid_parameter_type = isinstance(parameter_type, str) and parameter_type in PARAMETER_TYPES
-            if not valid_parameter_type:
-                add_error(
-                    f"{item_path}.type",
-                    "invalid_parameter_type",
-                    f"type must be one of {sorted(PARAMETER_TYPES)}",
-                )
-
-            api_path = api_parent + ((clean_name,) if clean_name and include_api_name else ())
-            if kind == "response" and clean_name and include_api_name and valid_parameter_type:
-                response_paths[".".join(api_path)] = parameter_type
-
-            if parameter_type == "array":
-                child = item.get("listSubItem")
-                if not isinstance(child, dict):
-                    add_error(f"{item_path}.listSubItem", "missing_list_sub_item", "array requires listSubItem")
-                else:
-                    validate_items([child], f"{item_path}.listSubItem", kind, api_path, False)
-            elif parameter_type == "object":
-                children = item.get("objectItems")
-                if not isinstance(children, list) or not children:
-                    add_error(f"{item_path}.objectItems", "missing_object_items", "object requires non-empty objectItems")
-                else:
-                    validate_items(children, f"{item_path}.objectItems", kind, api_path)
-
-    for kind, key in (("request", "requestParam"), ("response", "responseParam")):
-        container_path = f"meta.externalHttpCallConfig.{key}"
-        container = external.get(key, {})
-        if not isinstance(container, dict):
-            add_error(container_path, "invalid_parameter_config", f"{key} must be an object")
-            continue
-        validate_items(container.get("items", []), f"{container_path}.items", kind)
-
-    statuses = external.get("actionStatuses", [])
-    if not isinstance(statuses, list):
-        add_error(
-            "meta.externalHttpCallConfig.actionStatuses",
-            "invalid_action_statuses",
-            "actionStatuses must be an array",
-        )
-        statuses = []
-
-    status_names: set[str] = set()
-    for status_index, status in enumerate(statuses):
-        status_path = f"meta.externalHttpCallConfig.actionStatuses[{status_index}]"
-        if not isinstance(status, dict):
-            add_error(status_path, "invalid_action_status", "action status must be an object")
-            continue
-        name = status.get("name")
-        clean_name = name.strip() if isinstance(name, str) else ""
-        if not clean_name:
-            add_error(f"{status_path}.name", "invalid_status_name", "action status name must not be empty")
-        elif clean_name in status_names:
-            add_error(f"{status_path}.name", "duplicate_status_name", "action status names must be unique")
-        else:
-            status_names.add(clean_name)
-
-        condition = status.get("condition")
-        is_default = condition == {} or condition == {"or": []}
-        if status_index == len(statuses) - 1:
-            if not is_default:
-                add_error(
-                    f"{status_path}.condition",
-                    "invalid_default_status",
-                    "the last action status must have condition: {}",
-                )
-        elif is_default:
-            add_error(
-                f"{status_path}.condition",
-                "invalid_default_status",
-                "only the last action status may be the default",
-            )
-
-        if is_default:
-            continue
-        groups = condition.get("or") if isinstance(condition, dict) else None
-        all_rules: list[tuple[dict[str, Any], str]] = []
-        if isinstance(groups, list):
-            for group_index, group in enumerate(groups):
-                group_path = f"{status_path}.condition.or[{group_index}]"
-                if not isinstance(group, dict):
-                    add_error(group_path, "invalid_condition_group", "condition group must be an object")
-                    continue
-                rules = group.get("rules")
-                if not isinstance(rules, list) or not rules:
-                    add_error(
-                        f"{group_path}.rules",
-                        "missing_group_rules",
-                        "each condition group requires a non-empty rules array",
-                    )
-                    continue
-                for rule_index, rule in enumerate(rules):
-                    rule_path = f"{group_path}.rules[{rule_index}]"
-                    if isinstance(rule, dict):
-                        all_rules.append((rule, rule_path))
-                    else:
-                        add_error(rule_path, "invalid_status_rule", "rule must be an object")
-        if not all_rules:
-            add_error(
-                f"{status_path}.condition",
-                "missing_status_rules",
-                "non-default action statuses require at least one rule",
-            )
-            continue
-
-        for rule, rule_path in all_rules:
-            if rule.get("type") != "GENERIC":
-                add_error(f"{rule_path}.type", "invalid_rule_type", "rule type must be GENERIC")
-            api_name = rule.get("apiName")
-            if not isinstance(api_name, str) or not api_name.strip():
-                add_error(f"{rule_path}.apiName", "missing_api_name", "apiName must not be empty")
-                response_type = None
-            else:
-                response_type = response_paths.get(api_name)
-                if response_type is None:
-                    add_error(
-                        f"{rule_path}.apiName",
-                        "unknown_response_path",
-                        f"apiName {api_name!r} is not an exact response parameter path",
-                    )
-                elif response_type == "object":
-                    add_error(
-                        f"{rule_path}.apiName",
-                        "object_status_not_supported",
-                        "object response parameters cannot be used in action status rules",
-                    )
-
-            api_type = rule.get("apiType")
-            if api_type is None or api_type == "":
-                add_error(f"{rule_path}.apiType", "missing_api_type", "apiType is required")
-                valid_api_type = None
-            elif not isinstance(api_type, str) or api_type not in RELATIONS_BY_API_TYPE:
-                add_error(
-                    f"{rule_path}.apiType",
-                    "invalid_api_type",
-                    f"apiType must be one of {sorted(RELATIONS_BY_API_TYPE)}",
-                )
-                valid_api_type = None
-            else:
-                valid_api_type = api_type
-            if (
-                response_type
-                and valid_api_type is not None
-                and valid_api_type not in API_TYPES_BY_PARAMETER_TYPE.get(response_type, set())
-            ):
-                add_error(
-                    f"{rule_path}.apiType",
-                    "api_type_mismatch",
-                    f"apiType {api_type!r} is incompatible with response type {response_type!r}",
-                )
-
-            relation = rule.get("relation")
-            valid_relation = relation if isinstance(relation, str) else None
-            if valid_relation not in RELATIONS_BY_API_TYPE.get(valid_api_type, set()):
-                add_error(
-                    f"{rule_path}.relation",
-                    "invalid_relation",
-                    f"relation {relation!r} is not supported for apiType {api_type!r}",
-                )
-
-            values = rule.get("values")
-            values_valid = isinstance(values, list)
-            if values_valid and valid_relation in {"IS_EMPTY", "NOT_EMPTY"}:
-                values_valid = values == []
-            elif values_valid and valid_relation == "BETWEEN":
-                values_valid = len(values) == 2
-            elif values_valid and valid_api_type == "TEXT" and valid_relation in {"CONTAIN", "NOT_CONTAIN"}:
-                values_valid = len(values) >= 1
-            elif values_valid:
-                values_valid = len(values) == 1
-            if values_valid and valid_api_type == "BOOLEAN" and valid_relation in {"EQUAL", "NOT_EQUAL"}:
-                boolean_value = values[0]
-                values_valid = isinstance(boolean_value, bool) or (
-                    isinstance(boolean_value, str)
-                    and boolean_value.strip().lower() in {"true", "false"}
-                )
-            if values_valid and valid_api_type == "TEXT" and values:
-                values_valid = all(isinstance(value, str) for value in values)
-            if values_valid and valid_api_type in {"NUMBER", "DATE_TO_NOW", "NOW_TO_DATE", "ARRAY_SIZE"} and values:
-                values_valid = all(is_finite_number_value(value) for value in values)
-            if not values_valid:
-                add_error(
-                    f"{rule_path}.values",
-                    "invalid_rule_values",
-                    "values has an invalid count or value type for the selected relation and apiType",
-                )
-
-    if errors:
-        return {"valid": False, "errors": errors}
-    return {
-        "valid": True,
-        "request_parameter_count": parameter_count["request"],
-        "response_parameter_count": parameter_count["response"],
-        "action_status_count": len(statuses),
-    }
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(description="Validate an Agent Builder tool JSON payload")
-    parser.add_argument("--data-file", required=True, help="Path to a local JSON file")
-    parser.add_argument("--pretty", action="store_true")
-    args = parser.parse_args()
-
-    try:
-        with Path(args.data_file).open(encoding="utf-8") as file:
-            data = json.load(
-                file,
-                parse_constant=reject_non_finite_json_number,
-                parse_float=parse_finite_json_float,
-            )
-        output = validate_tool_config(data)
-    except (OSError, UnicodeDecodeError, ValueError) as exc:
-        output = {
-            "valid": False,
-            "errors": [{"path": "$", "code": "invalid_data_file", "message": str(exc)}],
-        }
-    print(json.dumps(output, ensure_ascii=False, indent=2 if args.pretty else None))
-    return 0 if output["valid"] else 1
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/skills/agent-tester/SKILL.md

@@ -1,35 +0,0 @@
----
-name: agent-tester
-description: Use when directly testing, regression-testing, batch-testing, or checking Download Center progress for one Shulex Agent. Supports live_test single cases and system-native batch tests; CHAT_FLOW Agents use the canvas multi-turn batch-test path and other Agents use the menu batch-test path.
-requires:
-  libs: [solvea-api]
----
-
-# Agent Tester
-
-本文件是完整文档目录。先根据请求定位到唯一工作流，然后**直接读取该工作流指定的最终文档**；不要逐层读取无关文档。
-
-## 文档目录
-
-| 用户场景 | 直接读取 | 说明 |
-|---|---|---|
-| 指定 Agent、单个问题、“随便测一下”、继续探索 | `single-test/direct-test.md` | 使用 `live_test` 运行固定 case 或探索式单轮 |
-| 历史 ChatId、badcase 复测、验证修复或比较变化 | `single-test/badcase-retest.md` | 读取原会话，重放 USER 消息并比较 AgentAction |
-| 多个 case、测试集、Excel、批测、下载中心进度 | `batch-test/overview.md` | 系统 xlsx 批测：Chatflow 多轮或普通 Agent 菜单批测 |
-
-## 目录层级
-
-```text
-agent-tester/
-├── SKILL.md
-├── single-test/
-│   ├── overview.md              # 单测公共 live_test 契约（仅 direct/badcase 文档需要时读取）
-│   ├── direct-test.md           # 单问题与探索式测试
-│   └── badcase-retest.md        # 历史 ChatId 复测
-├── batch-test/
-│   └── overview.md              # 系统批测工作流
-└── scripts/
-    └── batch_test_sheet.py      # 生成 xlsx、上传、提交、查询下载中心
-```
-
-批测必须提交系统下载中心任务，不要调用或复用 POC / Delivery 的本地并发脚本、状态、cases 协议或报告模板。

package/skills/agent-tester/batch-test/overview.md

@@ -1,86 +0,0 @@
-# 系统批量测试
-
-批测必须对齐系统入口：生成并填充系统模板兼容 xlsx，提交下载中心任务，再按需查询进度。不要使用 POC / Delivery 的本地并发脚本、状态或报告协议。
-
-## 入口路由
-
-先执行 `npx --yes @shulex/cxclawctl@latest api get-agent --id <agentId> --pretty`：
-
-| 类型 | 系统入口 | task type | 数据 | 上限 |
-|---|---|---|---|---|
-| `CHAT_FLOW` | Chatflow 画布“批量多轮测试” | `MULTI_TURN_REPLY` | 一个 case 多 turn | 600 case |
-| 其他 Agent | 菜单“批量测试” | `REPLY` | 一个 case 一个 question | 200 case |
-
-不要把 Chatflow 降级为菜单批测，也不要将普通 Agent 当作多轮 Chatflow 任务。
-
-### case 数量建议
-
-- 1-10 个 case：如果需要即时查看每轮回复、节点和调试信息，可使用 `live_test`。
-- **超过 10 个 case：优先生成系统模板并提交下载中心批测任务**，不要把每个 case 拆成多个 `live_test`。
-- Chatflow 批测使用 `MULTI_TURN_REPLY`；普通 Agent 批测使用 `REPLY`。
-
-## 创建测试表
-
-用户可以给问题列表/文件、ChatId 列表，或要求按条件找一批历史对话。JSON 仅是 skill 在后台归一化输入给脚本的中间产物，**不要要求用户创建、上传或确认 JSON**。
-
-先向用户展示可读的测试集表格并确认，再在后台生成 JSON 和 xlsx。表格至少展示：case 名称、来源（手工问题/ChatId/历史筛选）、轮次、用户问题、固定 metadata、目标模式；订单号、邮箱等 metadata 不得编造。用户确认后才执行生成和提交。
-
-脚本内部使用 case JSON 生成第 1 行说明、第 2 行表头的系统兼容 xlsx：
-
-```bash
-npx --yes @shulex/cxclawctl@latest script skills/agent-tester/scripts/batch_test_sheet.py create-sheet \
-  --mode chatflow --cases-file /workspace/outputs/agent-tester/chatflow_cases.json
-
-npx --yes @shulex/cxclawctl@latest script skills/agent-tester/scripts/batch_test_sheet.py create-sheet \
-  --mode agent --cases-file /workspace/outputs/agent-tester/agent_cases.json
-```
-
-Chatflow JSON：
-
-```json
-[{"case_name":"refund-follow-up","turns":[{"question":"我要退款","metadata":{"order_number":"A-1001"}},{"question":"订单号就是 A-1001"}]}]
-```
-
-普通 Agent JSON：
-
-```json
-[{"case_name":"shipping","question":"我的订单什么时候发货？","metadata":{"order_number":"A-1001"}}]
-```
-
-### `REPLY` 模板的 `meta_data` 格式
-
-普通 Agent（`REPLY`）批测模板的 `meta_data` 列目前必须填写为**纯文本键值对**，多个字段用英文或中文分号分隔：
-
-```text
-touchPoint: LIVE_CHAT; order_number: A-1001
-```
-
-请按上述格式填写，`LIVE_CHAT`、`EMAIL` 等渠道值使用系统枚举值。
-
-Chatflow 表头是 `case_name, chat_id, metadata_1, question_1, ai_answer_1, ...`；普通 Agent 是 `question, origin_answer, ai_answer, similarity, judgement, reason, chat_id, meta_data, fail_reason`。所有系统输出列保持空白。xlsx 输出到 `/workspace/outputs/agent-tester/`，状态写到 `/workspace/state/agent-tester/latest_batch_test.json`。
-
-## 提交和查询
-
-默认不指定 `specified_agent_id` 或 `specified_flow_version`，让任务从最外层意图识别和系统策略路由开始执行。只有用户明确要求锁定某个 Chatflow Agent（例如验证该 Agent 的草稿或已发布版本）时，才先用 `get-chatflow-graph --agent-id <agentId>` 取得实际 version，并同时传入 Agent 和版本；不要只传其中一个。历史预览或调试面板打开时，画布不允许提交。
-
-```bash
-npx --yes @shulex/cxclawctl@latest script skills/agent-tester/scripts/batch_test_sheet.py submit \
-  --mode chatflow --file <generated.xlsx> --bot-id <botId>
-
-# 只有明确指定 Chatflow Agent / 版本时追加：
-npx --yes @shulex/cxclawctl@latest script skills/agent-tester/scripts/batch_test_sheet.py submit \
-  --mode chatflow --file <generated.xlsx> --bot-id <botId> \
-  --agent-id <agentId> --flow-version <currentVersion>
-
-npx --yes @shulex/cxclawctl@latest script skills/agent-tester/scripts/batch_test_sheet.py submit \
-  --mode agent --file <generated.xlsx> --bot-id <botId>
-```
-
-脚本获取临时 S3 凭证并上传 xlsx。默认 Chatflow 请求不带路由 metadata；仅在指定模式下才携带 `specified_agent_id` 和 `specified_flow_version`。提交接口只返回 `success`，不返回 taskId；随后按类型查询下载中心，选本次时间相符的最新任务：
-
-```bash
-npx --yes @shulex/cxclawctl@latest script skills/agent-tester/scripts/batch_test_sheet.py get-tasks --mode chatflow
-npx --yes @shulex/cxclawctl@latest script skills/agent-tester/scripts/batch_test_sheet.py get-tasks --mode agent
-```
-
-`WAIT_TAG` 是等待中，`TAGGING` 是执行中，`SUCCESS` 完成且 `file` 可下载，`FAIL` 是失败；`successCount / totalCount` 为当前进度。除非用户明确要求，不要阻塞式轮询。