【0】用户在 Dify 工作室 / API 发问
      query = "帮我看看 gpu-server-01 的状态"
      conversation_id = ""（必须新开对话）
        │
        ▼
【1】docker-api-1 接收（完整 URL，agent_id 为本环境实测值）
      POST http://127.0.0.1/console/api/agent/01a0189c-7d7e-742f-83d1-74c5c16878da/chat-messages
      读取 agent_config_snapshots：
        - model → qwen3.6-27b
        - prompt.system_prompt → 要求必须调 getServerStatus
        - tools.dify_tools[] → API 工具元数据
        │
        ▼
【2】docker-agent_backend-1 组装 Agent 运行请求
      把 OpenAPI 工具 schema 转成 LLM 可见的 tools 定义
        │
        ▼
【3】第一次 LLM（116 vLLM · Qwen3.6-27B）
      模型输出 tool_call：getServerStatus(server_name="gpu-server-01")
      ※ 依赖 vLLM --tool-call-parser qwen3_xml（专题四/九）
        │
        ▼
【4】Dify 执行 HTTP 工具
      经 ssrf_proxy 出网
      GET http://192.168.110.207:8777/server/status?server_name=gpu-server-01
        │
        ▼
【5】FastAPI 模拟服务（207 CPU）
      返回 JSON：cpu/memory/gpu_util/gpu_memory
        │
        ▼
【6】第二次 LLM
      把 tool observation 塞进上下文，按 system_prompt 格式化中文汇报
        │
        ▼
【7】写 messages 表，SSE 推流给前端
      可选：Celery → Langfuse Trace

工作区「集成 → 工具」          ← 注册 OpenAPI Provider（server_status）
        │
Agent 快照 tools.dify_tools[]  ← 对话真正挂载哪些工具（provider_id 必须是 UUID）
        │
Agent 快照 prompt / model      ← 会不会调工具、用什么 LLM

/usr/bin/python3 /opt/workbuddy/scripts_cursor/作业1_带工具调用的Agent_服务器状态/作业1_01_部署模拟服务.py
/usr/bin/python3 /opt/workbuddy/scripts_cursor/作业1_带工具调用的Agent_服务器状态/作业1_02_注册OpenAPI工具.py
/usr/bin/python3 /opt/workbuddy/scripts_cursor/作业1_带工具调用的Agent_服务器状态/作业1_03_创建Agent空壳.py
/usr/bin/python3 /opt/workbuddy/scripts_cursor/作业1_带工具调用的Agent_服务器状态/作业1_04_查ID并挂工具.py
/usr/bin/python3 /opt/workbuddy/scripts_cursor/作业1_带工具调用的Agent_服务器状态/作业1_05_对话验收.py

用户问「gpu-server-01 状态」
  → Dify Agent（207）
  → OpenAPI Provider「server_status」
  → FastAPI :8788（207 本机，模拟三台服务器 JSON）
  → Agent 汇总 CPU/内存/磁盘 回复

ssh root@192.168.110.207
rm -f /tmp/dify_cj.txt
python3 - <<'PY'
import json, base64
open("/tmp/dify_login.json", "w").write(json.dumps({
    "email": "38205036@qq.com",
    "password": base64.b64encode(b"Difyai123456").decode(),
    "language": "zh-Hans",
    "remember_me": True,
}))
PY
curl -s -c /tmp/dify_cj.txt -X POST 'http://127.0.0.1/console/api/login' \
  -H 'Content-Type: application/json' \
  -d @/tmp/dify_login.json
CSRF=$(python3 - <<'PY'
jar=open("/tmp/dify_cj.txt").read()
for line in jar.splitlines():
    if "csrf_token" in line:
        print(line.split("\t")[-1].strip())
PY
)
echo "CSRF=$CSRF"

curl -s -b /tmp/dify_cj.txt -H "X-CSRF-Token: $CSRF" \
  'http://127.0.0.1/console/api/agent?page=1&limit=50'

curl -s -b /tmp/dify_cj.txt -c /tmp/dify_cj.txt \
  -H "X-CSRF-Token: $CSRF" -H 'Content-Type: application/json' \
  -X POST 'http://127.0.0.1/console/api/agent' \
  -d '{
    "name": "运维巡检 Agent",
    "description": "作业 1：带 HTTP 工具的运维巡检 Agent（查询服务器状态）",
    "icon_type": "emoji",
    "icon": "🖥️",
    "icon_background": "#E8F5E9",
    "role": "ops"
  }'

curl -s -b /tmp/dify_cj.txt -c /tmp/dify_cj.txt \
  -H "X-CSRF-Token: $CSRF" -H 'Content-Type: application/json' \
  --max-time 420 \
  -X POST 'http://127.0.0.1/console/api/agent/01a0189c-7d7e-742f-83d1-74c5c16878da/chat-messages' \
  -d '{
    "inputs": {},
    "query": "帮我看看 gpu-server-01 的状态",
    "response_mode": "streaming",
    "files": [],
    "conversation_id": ""
  }'

curl -s 'http://192.168.110.207:8777/health'
curl -s 'http://192.168.110.207:8777/server/status?server_name=gpu-server-01'
curl -H "Authorization: Bearer 123456" 'http://116.62.10.183:8000/v1/models'

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""作业 1 · 步骤 1：把 FastAPI 模拟服务部署到 207 并启动。"""
from __future__ import annotations

import sys
from pathlib import Path

import _bootstrap  # noqa: F401
import _config as C
from dify_api import Dify

REMOTE_DIR = "/opt/server_status_api"
LOCAL_API = Path(__file__).resolve().parent / "作业1_server_status_api.py"
LOCAL_SH = Path(__file__).resolve().parents[1] / "scripts_bash_cursor" / "作业1_启动_server_status.sh"


def main() -> int:
    d = Dify(C.DIFY_EMAIL, C.DIFY_PASSWORD)
    try:
        d.login()
        d.sh("mkdir -p %s" % REMOTE_DIR)
        d.sftp.put(str(LOCAL_API), REMOTE_DIR + "/作业1_server_status_api.py")
        d.sftp.put(str(LOCAL_SH), REMOTE_DIR + "/start.sh")
        d.sh("chmod +x %s/start.sh" % REMOTE_DIR)
        # 若旧进程占端口则先停
        d.sh(
            "if [[ -f /tmp/server_status_api.pid ]]; then "
            "kill $(cat /tmp/server_status_api.pid) 2>/dev/null || true; fi"
        )
        out, err = d.sh("bash %s/start.sh" % REMOTE_DIR)
        print(out or err)
        r = d.sh(
            "curl -s 'http://127.0.0.1:%d/server/status?server_name=gpu-server-01'"
            % C.SERVER_STATUS_PORT
        )
        print("probe:", r[0].strip())
        return 0 if "gpu-server-01" in (r[0] or "") else 1
    finally:
        d.close()


if __name__ == "__main__":
    sys.exit(main())

#!/usr/bin/env bash
# 作业 1 · 在 207 上启动模拟「查询服务器状态」FastAPI 服务
set -euo pipefail

DIR="/opt/server_status_api"
PORT="${SERVER_STATUS_PORT:-8777}"
PIDFILE="/tmp/server_status_api.pid"
LOG="/tmp/server_status_api.log"

mkdir -p "$DIR"
pip3 install fastapi uvicorn -q

if [[ -f "$PIDFILE" ]] && kill -0 "$(cat "$PIDFILE")" 2>/dev/null; then
  echo "server_status_api already running pid=$(cat "$PIDFILE")"
  exit 0
fi

cd "$DIR"
nohup python3 -m uvicorn 作业1_server_status_api:app \
  --host 0.0.0.0 --port "$PORT" >>"$LOG" 2>&1 &
echo $! >"$PIDFILE"
sleep 1
curl -sf "http://127.0.0.1:${PORT}/health" && echo
echo "started on :${PORT}, log=$LOG"

curl -s 'http://192.168.110.207:8777/server/status?server_name=gpu-server-01'
curl -s 'http://192.168.110.207:8777/health'

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""作业 1 · 模拟「查询服务器状态」HTTP 工具（FastAPI）。

启动（207 上）：
  pip3 install fastapi uvicorn -q
  uvicorn 作业1_server_status_api:app --host 0.0.0.0 --port 8777

或：bash /opt/workbuddy/scripts_bash_cursor/作业1_带工具调用的Agent_服务器状态/作业1_启动_server_status.sh
"""
from __future__ import annotations

from fastapi import FastAPI

app = FastAPI(
    title="Server Status API",
    version="1.0.0",
    description="Dify Agent 作业 1：模拟查询服务器 CPU / 内存 / GPU 状态",
)


@app.get("/server/status", operation_id="getServerStatus", summary="查询服务器状态")
def get_status(server_name: str) -> dict[str, str]:
    """根据 server_name 返回模拟监控指标（本服务不连真实监控）。"""
    return {
        "server": server_name,
        "cpu": "45%",
        "memory": "62%",
        "gpu_util": "78%",
        "gpu_memory": "18.2/24 GB",
    }


@app.get("/health")
def health() -> dict[str, str]:
    return {"status": "ok"}


if __name__ == "__main__":
    import uvicorn

    uvicorn.run("作业1_server_status_api:app", host="0.0.0.0", port=8777, reload=False)

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""作业 1 · 步骤 2：在 Dify 注册 OpenAPI 自定义工具（查询服务器状态）。"""
from __future__ import annotations

import sys
from pathlib import Path

import _bootstrap  # noqa: F401
import _config as C
from dify_api import Dify, pp

SCHEMA_PATH = (
    Path(__file__).resolve().parents[1]
    / "patches_cursor"
    / "作业1_server_status_openapi.yaml"
)


def main() -> int:
    schema = SCHEMA_PATH.read_text(encoding="utf-8")
    d = Dify(C.DIFY_EMAIL, C.DIFY_PASSWORD)
    try:
        d.login()
        # 若已存在则先删再建，保证作业可重复跑
        existing = d.get("/workspaces/current/tools/api")
        names = []
        for item in existing.get("json") or []:
            names.append(item.get("name") or item.get("provider"))
        print("existing api tools:", names)
        if C.SERVER_STATUS_PROVIDER in names:
            r_del = d.post(
                "/workspaces/current/tool-provider/api/delete",
                body={"provider": C.SERVER_STATUS_PROVIDER},
            )
            pp("delete old", r_del)

        body = {
            "provider": C.SERVER_STATUS_PROVIDER,
            "credentials": {"auth_type": "none"},
            "schema_type": "openapi",
            "schema": schema,
            "icon": {"background": "#E8F5E9", "content": "🖥️"},
            "privacy_policy": "",
            "custom_disclaimer": "",
            "labels": ["ops", "homework1"],
        }
        r = d.post("/workspaces/current/tool-provider/api/add", body=body)
        pp("add api tool", r)
        if r.get("code") not in ("200", "201"):
            return 1

        r2 = d.get(
            "/workspaces/current/tool-provider/api/tools?provider=%s"
            % C.SERVER_STATUS_PROVIDER
        )
        pp("list tools", r2, limit=2000)
        r3 = d.get("/workspaces/current/tools/api")
        print("api tools now:", [
            (x.get("name") or x.get("provider")) for x in (r3.get("json") or [])
        ])
        return 0
    finally:
        d.close()


if __name__ == "__main__":
    sys.exit(main())

openapi: 3.0.0
info:
  title: Server Status API
  version: 1.0.0
  description: 作业 1 · 模拟查询服务器 CPU / 内存 / GPU 状态
servers:
  - url: http://192.168.110.207:8777
paths:
  /server/status:
    get:
      operationId: getServerStatus
      summary: 查询服务器状态
      description: 根据服务器名称返回 CPU、内存、GPU 利用率等模拟指标
      parameters:
        - name: server_name
          in: query
          required: true
          description: 服务器名称，例如 gpu-server-01
          schema:
            type: string
      responses:
        "200":
          description: 成功
          content:
            application/json:
              schema:
                type: object
                properties:
                  server:
                    type: string
                  cpu:
                    type: string
                  memory:
                    type: string
                  gpu_util:
                    type: string
                  gpu_memory:
                    type: string

# 注册 OpenAPI 工具：schema 很长，务必用脚本上传 yaml，不要手贴。
# 脚本内部等价于：
# POST http://127.0.0.1/console/api/workspaces/current/tool-provider/api/add
/usr/bin/python3 /opt/workbuddy/scripts_cursor/作业1_带工具调用的Agent_服务器状态/作业1_02_注册OpenAPI工具.py

# 列出该 provider 下的 tools
curl -s -b /tmp/dify_cj.txt -H "X-CSRF-Token: $CSRF" \
  'http://127.0.0.1/console/api/workspaces/current/tool-provider/api/tools?provider=server_status'

# 列出工作区全部 API 工具
curl -s -b /tmp/dify_cj.txt -H "X-CSRF-Token: $CSRF" \
  'http://127.0.0.1/console/api/workspaces/current/tools/api'

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""作业 1 · 步骤 3：创建带工具调用的 Agent 空壳（mode=agent）。"""
from __future__ import annotations

import sys

import _bootstrap  # noqa: F401
import _config as C
from dify_api import Dify, pp


def main() -> int:
    d = Dify(C.DIFY_EMAIL, C.DIFY_PASSWORD)
    try:
        d.login()
        # 若同名已存在，打印 ID 供后续步骤用，不重复创建
        r_list = d.get("/agent?page=1&limit=50")
        data = (r_list.get("json") or {}).get("data") or []
        for item in data:
            if item.get("name") == C.HOMEWORK1_APP_NAME:
                print("already exists app_id=", item.get("id"), "agent_id=", item.get("agent_id") or item.get("id"))
                print("下一步：运行 作业1_04_查ID并挂工具.py")
                return 0

        # Dify 1.16 新 Agent 用 POST /agent（不是 /apps + mode=agent）
        body = {
            "name": C.HOMEWORK1_APP_NAME,
            "description": "作业 1：带 HTTP 工具的运维巡检 Agent（查询服务器状态）",
            "icon_type": "emoji",
            "icon": "🖥️",
            "icon_background": "#E8F5E9",
            "role": "ops",
        }
        r = d.post("/agent", body)
        pp("create agent", r)
        j = r.get("json") or {}
        print("app_id", j.get("id"))
        print("agent_id", j.get("agent_id") or j.get("id"))
        if r.get("code") not in ("200", "201"):
            return 1
        print("下一步：运行 作业1_04_查ID并挂工具.py")
        return 0
    finally:
        d.close()


if __name__ == "__main__":
    sys.exit(main())

{
  "enabled": true,
  "provider_type": "api",
  "provider_id": "021a4445-098d-4821-81fe-ff0ebc660ecc",
  "tool_name": "getServerStatus",
  "credential_type": "unauthorized",
  "credential_ref": null
}

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""作业 1 · 步骤 4：查 app/agent/snap/draft ID，挂工具，写提示词。"""
from __future__ import annotations

import json
import sys

import _bootstrap  # noqa: F401
import _agent_cfg as AC
import _config as C
from dify_api import Dify, pp

SYSTEM_PROMPT = """你是企业内部运维助手。当用户询问某台服务器的状态、CPU、内存、GPU 时，
必须调用工具 getServerStatus（参数 server_name），并根据工具返回结果用中文格式化汇报。

汇报格式示例：
- 服务器：{server}
- CPU：{cpu}
- 内存：{memory}
- GPU 利用率：{gpu_util}
- GPU 显存：{gpu_memory}

不要编造指标；工具失败时如实说明。"""


def find_ids(d: Dify) -> tuple[str, str, str, str]:
    # 列表 API 返回 UTF-8 正常；不要用中文名拼进远程 psql（Windows 编码易乱）
    r_list = d.get("/agent?page=1&limit=50")
    app_id = agent_id = ""
    for item in (r_list.get("json") or {}).get("data") or []:
        if item.get("name") == C.HOMEWORK1_APP_NAME:
            app_id = item.get("id") or ""
            agent_id = item.get("agent_id") or item.get("id") or ""
            break
    if not agent_id:
        raise RuntimeError("列表里找不到应用：%s" % C.HOMEWORK1_APP_NAME)

    sql = (
        "SELECT a.app_id, a.id, a.active_config_snapshot_id, d.id "
        "FROM agents a JOIN agent_config_drafts d ON d.agent_id=a.id "
        "WHERE a.id='%s' LIMIT 1;" % agent_id
    )
    out, err = d.sh(
        'docker exec %s psql -U postgres -d dify -t -A -F "|" -c "%s"'
        % (C.PG_CONTAINER, sql)
    )
    line = (out or "").strip().splitlines()
    if not line or "|" not in line[0]:
        # 有时列表的 id 就是 app_id
        sql2 = (
            "SELECT a.app_id, a.id, a.active_config_snapshot_id, d.id "
            "FROM agents a JOIN agent_config_drafts d ON d.agent_id=a.id "
            "WHERE a.app_id='%s' LIMIT 1;" % app_id
        )
        out, err = d.sh(
            'docker exec %s psql -U postgres -d dify -t -A -F "|" -c "%s"'
            % (C.PG_CONTAINER, sql2)
        )
        line = (out or "").strip().splitlines()
    if not line or "|" not in line[0]:
        raise RuntimeError("找不到快照/草稿: %s %s" % (out, err))
    app_id, agent_id, snap_id, draft_id = line[0].split("|")
    return app_id, agent_id, snap_id, draft_id


def resolve_tool_meta(d: Dify) -> dict:
    # provider_id 必须是 tool_api_providers.id（UUID），不能用 name
    out, err = d.sh(
        "docker exec %s psql -U postgres -d dify -t -A -c "
        "\"SELECT id FROM tool_api_providers WHERE name='%s' LIMIT 1;\""
        % (C.PG_CONTAINER, C.SERVER_STATUS_PROVIDER)
    )
    provider_uuid = (out or "").strip()
    if not provider_uuid:
        raise RuntimeError("找不到 tool_api_providers.name=%s: %s" % (C.SERVER_STATUS_PROVIDER, err))

    r = d.get(
        "/workspaces/current/tool-provider/api/tools?provider=%s"
        % C.SERVER_STATUS_PROVIDER
    )
    pp("api tools meta", r, limit=2500)
    data = r.get("json") or []
    if isinstance(data, dict):
        data = data.get("data") or data.get("tools") or [data]
    if not data:
        raise RuntimeError("未找到 provider=%s 的工具列表" % C.SERVER_STATUS_PROVIDER)
    tool = data[0]
    tool_name = tool.get("name") or tool.get("tool_name") or "getServerStatus"
    return {
        "enabled": True,
        "provider_type": "api",
        "provider_id": provider_uuid,
        "tool_name": tool_name,
        "credential_type": "unauthorized",
        "credential_ref": None,
        "runtime_parameters": {},
    }


def patch_cfg(cfg: dict, tool_entry: dict) -> dict:
    prompt = cfg.setdefault("prompt", {})
    if prompt is None:
        cfg["prompt"] = {}
        prompt = cfg["prompt"]
    prompt["system_prompt"] = SYSTEM_PROMPT

    tools = cfg.get("tools")
    if not isinstance(tools, dict):
        tools = {}
        cfg["tools"] = tools
    tools["cli_tools"] = tools.get("cli_tools") or []
    tools["dify_tools"] = [tool_entry]

    model = cfg.get("model")
    if not isinstance(model, dict):
        model = {}
        cfg["model"] = model
    model["model"] = C.QWEN_MODEL
    model["plugin_id"] = "langgenius/openai"
    model["model_provider"] = C.OPENAI_PROVIDER
    model["credential_ref"] = None
    ms = model.get("model_settings")
    if not isinstance(ms, dict):
        ms = {}
        model["model_settings"] = ms
    ms["max_tokens"] = ms.get("max_tokens") or 4096
    for k in ("stop", "top_p", "temperature", "response_format", "presence_penalty", "frequency_penalty"):
        ms.setdefault(k, None)
    return cfg


def main() -> int:
    d = Dify(C.DIFY_EMAIL, C.DIFY_PASSWORD)
    try:
        d.login()
        app_id, agent_id, snap_id, draft_id = find_ids(d)
        print("app_id", app_id)
        print("agent_id", agent_id)
        print("snap_id", snap_id)
        print("draft_id", draft_id)

        tool_entry = resolve_tool_meta(d)
        print("tool_entry", json.dumps(tool_entry, ensure_ascii=False))

        snap = AC.load_cfg(d, "agent_config_snapshots", snap_id)
        draft = AC.load_cfg(d, "agent_config_drafts", draft_id)
        AC.save_cfg(d, "agent_config_snapshots", snap_id, patch_cfg(snap, tool_entry), "hw1s")
        AC.save_cfg(d, "agent_config_drafts", draft_id, patch_cfg(draft, tool_entry), "hw1d")

        # 写回 _config 提示（不自动改文件，打印给人工确认）
        print("\n请把以下常量写入 /opt/workbuddy/scripts_cursor/作业1_带工具调用的Agent_服务器状态/_config.py（若尚未写）：")
        print('HOMEWORK1_APP_ID = "%s"' % app_id)
        print('HOMEWORK1_AGENT_ID = "%s"' % agent_id)
        print('HOMEWORK1_SNAP_ID = "%s"' % snap_id)
        print('HOMEWORK1_DRAFT_ID = "%s"' % draft_id)
        print("\n[WARN] 改完不要点「构建/发布」；强刷后新开对话验收。")
        return 0
    finally:
        d.close()


if __name__ == "__main__":
    sys.exit(main())

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""作业 1 · 步骤 5：对话验收 —— 问 gpu-server-01 状态，应触发工具并返回指标。"""
from __future__ import annotations

import sys

import _bootstrap  # noqa: F401
import _config as C
from dify_api import Dify, pp


def resolve_agent_id(d: Dify) -> str:
    aid = getattr(C, "HOMEWORK1_AGENT_ID", "") or ""
    if aid:
        return aid
    sql = (
        "SELECT a.id FROM apps ap JOIN agents a ON a.app_id=ap.id "
        "WHERE ap.name='%s' ORDER BY ap.created_at DESC LIMIT 1;"
        % C.HOMEWORK1_APP_NAME.replace("'", "''")
    )
    out, err = d.sh(
        'docker exec %s psql -U postgres -d dify -t -A -c "%s"'
        % (C.PG_CONTAINER, sql)
    )
    aid = (out or "").strip()
    if not aid:
        raise RuntimeError("找不到 Agent: %s %s" % (out, err))
    return aid


def main() -> int:
    d = Dify(C.DIFY_EMAIL, C.DIFY_PASSWORD)
    try:
        d.login()
        agent_id = resolve_agent_id(d)
        print("agent_id", agent_id)
        r = d.post(
            "/agent/%s/chat-messages" % agent_id,
            body={
                "inputs": {},
                "query": C.HOMEWORK1_PROBE_QUERY,
                "response_mode": "streaming",
                "files": [],
                "conversation_id": "",
            },
            extra="-m 420 --max-time 420",
            t=450,
        )
        pp("chat", r, limit=4000)
        text = r.get("text") or ""
        ok_markers = ("45%", "62%", "78%", "18.2", "gpu-server-01", "getServerStatus")
        hits = [m for m in ok_markers if m in text]
        print("\n匹配到的验收关键词:", hits)
        if r.get("code") not in ("200",) or len(hits) < 2:
            print("\n[FAIL] 未看到工具返回的模拟指标，请检查工具挂载与 SSRF 出网。")
            return 1
        print("\n[PASS] Agent 已调用工具并返回状态信息。")
        return 0
    finally:
        d.close()


if __name__ == "__main__":
    sys.exit(main())

服务器：gpu-server-01
CPU：45%
内存：62%
GPU 利用率：78%
GPU 显存：18.2/24 GB

用户问句 ──► 207 Dify ──► 116 GPU（2 次 LLM）──► 207 CPU（1 次 HTTP GET）──► 116 GPU（汇总回答）

# 116 上
nvidia-smi
curl -s -H "Authorization: Bearer 123456" http://127.0.0.1:8000/v1/models

# 207 上测跨机
curl -s -H "Authorization: Bearer 123456" http://116.62.10.183:8000/v1/models

curl -s -X POST http://116.62.10.183:8000/v1/chat/completions \
  -H "Authorization: Bearer 123456" -H "Content-Type: application/json" \
  -d '{"model":"qwen3.6-27b","messages":[{"role":"user","content":"hi"}],
       "tools":[{"type":"function","function":{"name":"getServerStatus",
       "parameters":{"type":"object","properties":{"server_name":{"type":"string"}},"required":["server_name"]}}}],
       "tool_choice":"auto"}'

{"code":"invalid_param","message":"... mode ... Input should be 'chat', 'agent-chat' ..."}

invalid input syntax for type uuid: "server_status"
WHERE tool_api_providers.id = 'server_status'::UUID

SELECT id, name FROM tool_api_providers WHERE name='server_status';
-- 021a4445-098d-4821-81fe-ff0ebc660ecc

"provider_id": "021a4445-098d-4821-81fe-ff0ebc660ecc"

model["model"] = "qwen3.6-27b"
model["model_provider"] = "langgenius/openai/openai"
model["model_settings"]["max_tokens"] = 4096

curl -s -b /tmp/dify_cj.txt -H "X-CSRF-Token: $CSRF" \
  'http://127.0.0.1/console/api/workspaces/current/tool-provider/builtin/021a4445-098d-4821-81fe-ff0ebc660ecc/credential/info'

/usr/bin/python3 /opt/workbuddy/scripts_cursor/作业1_带工具调用的Agent_服务器状态/作业1_06_修复配置页InternalServerError.py