用户输入（Start）
    │
    ▼
意图识别（LLM · Qwen3.6）
    │
    ▼
抽出意图标签（Code · 四类中文标签）
    │
    ▼
意图路由（IF/ELSE）
    ├─ 知识库问答 → 知识库检索 → 生成回答 → End
    ├─ 工单报修   → HTTP POST http://192.168.110.207:8778/ticket → 模板拼工单号 → End
    ├─ 人工客服   → 转人工固定文案 → End
    └─ 其他       → 兜底固定文案 → End

【0】POST http://127.0.0.1/console/api/apps/f0e82c66-e324-4df7-a1fe-44d6ce6ec7cf/workflows/draft/run
      inputs.query = "怎么请假"
        │
        ▼
【1】Start 写入变量 query
        │
        ▼
【2】LLM 意图识别（116 vLLM）
      输出四类标签之一：知识库问答 / 工单报修 / 人工客服 / 其他
        │
        ▼
【3】Code 清洗  并规范化 intent 字符串
        │
        ▼
【4】IF/ELSE 按 intent 走四条边之一
        │
        ├─ 知识库路径
        │     Xinference bge-m3 向量检索 + bge-reranker（207 CPU）
        │     → LLM 读 context 生成回答
        │
        ├─ 工单路径
        │     docker-api / worker 经 SSRF 访问 207:8778
        │     → 返回 {"ticket_id":"WO-xxxx",...}
        │
        └─ 人工 / 其他
              Template 固定文案 → End.outputs.answer

/usr/bin/python3 /opt/workbuddy/scripts_cursor/作业2_客服意图路由工作流/作业2_01_部署工单模拟服务.py
/usr/bin/python3 /opt/workbuddy/scripts_cursor/作业2_客服意图路由工作流/作业2_02_创建工作流空壳.py
/usr/bin/python3 /opt/workbuddy/scripts_cursor/作业2_客服意图路由工作流/作业2_03_同步工作流草稿.py
/usr/bin/python3 /opt/workbuddy/scripts_cursor/作业2_客服意图路由工作流/作业2_04_验收三句.py

用户输入
  → Workflow「开始」→ LLM 意图识别（四类）
  ├─ 产品咨询 → 知识库检索 → LLM 回答
  ├─ 报修工单 → HTTP 调 :8789 创建工单
  ├─ 转人工   → 固定回复 + 人工队列
  └─ 其它     → 兜底话术

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/apps?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/apps' \
  -d '{
    "name": "客服意图路由工作流",
    "description": "作业 2：客服意图路由（知识库 / 工单报修 / 人工客服 / 兜底）",
    "mode": "workflow",
    "icon_type": "emoji",
    "icon": "🎧",
    "icon_background": "#E3F2FD"
  }'

curl -s -b /tmp/dify_cj.txt -H "X-CSRF-Token: $CSRF" \
  'http://127.0.0.1/console/api/apps/f0e82c66-e324-4df7-a1fe-44d6ce6ec7cf/workflows/draft'

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/apps/f0e82c66-e324-4df7-a1fe-44d6ce6ec7cf/workflows/draft/run' \
  -d '{"inputs":{"query":"怎么请假"},"files":[]}'

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/apps/f0e82c66-e324-4df7-a1fe-44d6ce6ec7cf/workflows/draft/run' \
  -d '{"inputs":{"query":"帮我报修设备"},"files":[]}'

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/apps/f0e82c66-e324-4df7-a1fe-44d6ce6ec7cf/workflows/draft/run' \
  -d '{"inputs":{"query":"我要投诉"},"files":[]}'

curl -s 'http://192.168.110.207:8778/health'
curl -s -X POST 'http://192.168.110.207:8778/ticket' \
  -H 'Content-Type: application/json' \
  -d '{"query":"帮我报修设备","category":"repair"}'

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""作业 2 · 步骤 1：把工单模拟服务部署到 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/ticket_api"
LOCAL_API = Path(__file__).resolve().parent / "作业2_ticket_api.py"
LOCAL_SH = Path(__file__).resolve().parents[1] / "scripts_bash_cursor" / "作业2_启动_ticket.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 + "/作业2_ticket_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/ticket_api.pid ]]; then "
            "kill $(cat /tmp/ticket_api.pid) 2>/dev/null || true; "
            "rm -f /tmp/ticket_api.pid; fi"
        )
        out, err = d.sh("TICKET_API_PORT=%d bash %s/start.sh" % (C.TICKET_API_PORT, REMOTE_DIR))
        print(out or err)
        r = d.sh(
            "curl -s -X POST 'http://127.0.0.1:%d/ticket' "
            "-H 'Content-Type: application/json' "
            "-d '{\"query\":\"帮我报修设备\",\"category\":\"repair\"}'"
            % C.TICKET_API_PORT
        )
        print("probe:", r[0].strip())
        return 0 if "WO-" in (r[0] or "") else 1
    finally:
        d.close()


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

#!/usr/bin/env bash
# 作业 2 · 在 207 上启动模拟「工单报修」FastAPI 服务
set -euo pipefail

DIR="/opt/ticket_api"
PORT="${TICKET_API_PORT:-8778}"
PIDFILE="/tmp/ticket_api.pid"
LOG="/tmp/ticket_api.log"

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

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

cd "$DIR"
nohup python3 -m uvicorn 作业2_ticket_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 -X POST 'http://192.168.110.207:8778/ticket' \
  -H 'Content-Type: application/json' \
  -d '{"query":"帮我报修设备","category":"repair"}'
curl -s 'http://192.168.110.207:8778/health'

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""作业 2 · 模拟「工单报修」HTTP API（FastAPI）。

启动（207 上）：
  pip3 install fastapi uvicorn -q
  uvicorn 作业2_ticket_api:app --host 0.0.0.0 --port 8778

或：bash /opt/workbuddy/scripts_bash_cursor/作业2_客服意图路由工作流/作业2_启动_ticket.sh
"""
from __future__ import annotations

import itertools
from typing import Any

from fastapi import FastAPI
from pydantic import BaseModel, Field

app = FastAPI(
    title="Ticket API",
    version="1.0.0",
    description="Dify Workflow 作业 2：模拟创建报修工单，返回工单号",
)

_seq = itertools.count(1001)


class TicketIn(BaseModel):
    query: str = Field(default="", description="用户报修描述")
    category: str = Field(default="repair", description="工单类别")


@app.post("/ticket", operation_id="createTicket", summary="创建报修工单")
def create_ticket(body: TicketIn) -> dict[str, Any]:
    n = next(_seq)
    ticket_id = "WO-%d" % n
    return {
        "ticket_id": ticket_id,
        "status": "created",
        "category": body.category,
        "issue": body.query or "未填写故障描述",
        "message": "报修工单已创建，工单号 %s" % ticket_id,
    }


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


if __name__ == "__main__":
    import uvicorn

    uvicorn.run("作业2_ticket_api:app", host="0.0.0.0", port=8778, reload=False)

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""作业 2 · 步骤 2：创建 Workflow 空壳（mode=workflow）。"""
from __future__ import annotations

import sys

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


def find_app(d: Dify) -> dict | None:
    r = d.get("/apps?page=1&limit=50")
    for item in (r.get("json") or {}).get("data") or []:
        if item.get("name") == C.HOMEWORK2_APP_NAME and item.get("mode") == "workflow":
            return item
    aid = getattr(C, "HOMEWORK2_APP_ID", "") or ""
    if aid:
        for item in (r.get("json") or {}).get("data") or []:
            if item.get("id") == aid:
                return item
    return None


def main() -> int:
    d = Dify(C.DIFY_EMAIL, C.DIFY_PASSWORD)
    try:
        d.login()
        found = find_app(d)
        if found:
            print("already exists app_id=", found.get("id"), "mode=", found.get("mode"))
            print("下一步：运行 作业2_03_同步工作流草稿.py")
            return 0
        body = {
            "name": C.HOMEWORK2_APP_NAME,
            "description": "作业 2：客服意图路由（知识库 / 工单报修 / 人工客服 / 兜底）",
            "mode": "workflow",
            "icon_type": "emoji",
            "icon": "🎧",
            "icon_background": "#E3F2FD",
        }
        r = d.post("/apps", body)
        pp("create workflow app", r)
        j = r.get("json") or {}
        print("app_id", j.get("id"))
        if r.get("code") not in ("200", "201"):
            return 1
        print("下一步：运行 作业2_03_同步工作流草稿.py")
        return 0
    finally:
        d.close()


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

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""作业 2 · 客服意图路由工作流 graph 定义（给草稿同步用）。

结构：用户输入 → LLM 意图识别 → 代码抽出类别 → IF/ELSE
  ├ 知识库问答 → 知识库检索 → 生成回答 → 结束
  ├ 工单报修 → HTTP 工单 API → 返回工单号 → 结束
  ├ 人工客服 → 转人工提示 → 结束
  └ 其他 → 兜底回复 → 结束

不用 question-classifier：Qwen3.6 带 reasoning 时经常不吐 ```json```，
该节点会报 could not find json block。
"""
from __future__ import annotations

from typing import Any

import _config as C

CLS_KB = "cls_kb"
CLS_TICKET = "cls_ticket"
CLS_HUMAN = "cls_human"
CLS_OTHER = "cls_other"

N_START = "start"
N_LLM_INTENT = "llm_intent"
N_PARSE = "parse_intent"
N_IF = "route"
N_KR = "kr"
N_LLM_KB = "llm_kb"
N_HTTP = "http_ticket"
N_TPL_TICKET = "tpl_ticket"
N_TPL_HUMAN = "tpl_human"
N_TPL_OTHER = "tpl_other"
N_END_KB = "end_kb"
N_END_TICKET = "end_ticket"
N_END_HUMAN = "end_human"
N_END_OTHER = "end_other"

PARSE_CODE = r'''
import re

LABELS = ("人工客服", "工单报修", "知识库问答", "其他")


def main(text: str) -> dict:
    raw = text or ""
    cleaned = re.sub(r"<think[^>]*>[\s\S]*?</think>", "", raw, flags=re.I)
    # 优先看清洗后的正文，避免思考链里同时出现多个类别名
    for blob in (cleaned, raw):
        for lab in LABELS:
            if lab in blob:
                return {"intent": lab}
    low = (cleaned or raw).lower()
    if any(k in low for k in ("投诉", "complain", "human", "转人工")):
        return {"intent": "人工客服"}
    if any(k in low for k in ("报修", "repair", "ticket", "工单")):
        return {"intent": "工单报修"}
    if any(k in low for k in ("请假", "制度", "knowledge", "知识库")):
        return {"intent": "知识库问答"}
    return {"intent": "其他"}
'''.lstrip()

INTENT_SYS = """你是客服意图分类器。根据用户原话，只输出下面四个标签之一，不要解释、不要思考过程、不要 Markdown。

标签：
- 人工客服：投诉、举报、找领导、要人工、转人工。例句：我要投诉
- 工单报修：报修、设备故障、开维修单。例句：帮我报修设备
- 知识库问答：制度、流程、请假、加班、打卡、福利。例句：怎么请假
- 其他：闲聊或无法归类

只输出这四个中文词之一。"""


def _model(max_tokens: int, temperature: float = 0.2) -> dict[str, Any]:
    return {
        "provider": C.OPENAI_PROVIDER,
        "name": C.QWEN_MODEL,
        "mode": "chat",
        "completion_params": {
            "temperature": temperature,
            "max_tokens": max_tokens,
            "enable_thinking": False,
        },
    }


def _node(nid: str, ntype: str, title: str, data: dict[str, Any], x: float, y: float, h: int = 110) -> dict[str, Any]:
    payload = {
        "type": ntype,
        "title": title,
        "desc": "",
        "selected": False,
        **data,
    }
    return {
        "id": nid,
        "type": "custom",
        "position": {"x": x, "y": y},
        "positionAbsolute": {"x": x, "y": y},
        "sourcePosition": "right",
        "targetPosition": "left",
        "width": 244,
        "height": h,
        "data": payload,
    }


def _edge(src: str, dst: str, src_type: str, dst_type: str, handle: str = "source") -> dict[str, Any]:
    return {
        "id": "%s-%s-%s" % (src, handle, dst),
        "source": src,
        "sourceHandle": handle,
        "target": dst,
        "targetHandle": "target",
        "type": "custom",
        "zIndex": 0,
        "data": {
            "sourceType": src_type,
            "targetType": dst_type,
            "isInIteration": False,
        },
    }


FEATURES: dict[str, Any] = {
    "file_upload": {
        "image": {
            "enabled": False,
            "number_limits": 3,
            "transfer_methods": ["local_file", "remote_url"],
        }
    },
    "opening_statement": "",
    "retriever_resource": {"enabled": True},
    "sensitive_word_avoidance": {"enabled": False},
    "speech_to_text": {"enabled": False},
    "suggested_questions": [],
    "suggested_questions_after_answer": {"enabled": False},
    "text_to_speech": {"enabled": False, "language": "", "voice": ""},
}


def build_graph() -> dict[str, Any]:
    ticket_url = C.TICKET_API_BASE.rstrip("/") + "/ticket"
    body_json = '{"query": "{{#%s.query#}}", "category": "repair"}' % N_START
    nodes = [
        _node(
            N_START,
            "start",
            "用户输入",
            {
                "variables": [
                    {
                        "variable": "query",
                        "label": "用户问题",
                        "type": "paragraph",
                        "required": True,
                        "max_length": 2000,
                        "options": [],
                    }
                ]
            },
            40,
            420,
            90,
        ),
        _node(
            N_LLM_INTENT,
            "llm",
            "意图识别",
            {
                "model": _model(1024, 0.0),
                "prompt_template": [
                    {"role": "system", "text": INTENT_SYS, "edition_type": "basic"},
                    {
                        "role": "user",
                        "text": "用户原话：{{#%s.query#}}" % N_START,
                        "edition_type": "basic",
                    },
                ],
                "context": {"enabled": False, "variable_selector": []},
                "vision": {"enabled": False},
            },
            330,
            400,
            140,
        ),
        _node(
            N_PARSE,
            "code",
            "抽出意图标签",
            {
                "variables": [
                    {"variable": "text", "value_selector": [N_LLM_INTENT, "text"]}
                ],
                "code_language": "python3",
                "code": PARSE_CODE,
                "outputs": {"intent": {"type": "string", "children": None}},
            },
            620,
            400,
            100,
        ),
        _node(
            N_IF,
            "if-else",
            "意图路由",
            {
                "cases": [
                    {
                        "case_id": CLS_KB,
                        "logical_operator": "and",
                        "conditions": [
                            {
                                "id": "c_kb",
                                "variable_selector": [N_PARSE, "intent"],
                                "comparison_operator": "is",
                                "value": "知识库问答",
                            }
                        ],
                    },
                    {
                        "case_id": CLS_TICKET,
                        "logical_operator": "and",
                        "conditions": [
                            {
                                "id": "c_ticket",
                                "variable_selector": [N_PARSE, "intent"],
                                "comparison_operator": "is",
                                "value": "工单报修",
                            }
                        ],
                    },
                    {
                        "case_id": CLS_HUMAN,
                        "logical_operator": "and",
                        "conditions": [
                            {
                                "id": "c_human",
                                "variable_selector": [N_PARSE, "intent"],
                                "comparison_operator": "is",
                                "value": "人工客服",
                            }
                        ],
                    },
                    {
                        "case_id": CLS_OTHER,
                        "logical_operator": "and",
                        "conditions": [
                            {
                                "id": "c_other",
                                "variable_selector": [N_PARSE, "intent"],
                                "comparison_operator": "is",
                                "value": "其他",
                            }
                        ],
                    },
                ]
            },
            900,
            380,
            220,
        ),
        _node(
            N_KR,
            "knowledge-retrieval",
            "知识库检索",
            {
                "query_variable_selector": [N_START, "query"],
                "dataset_ids": [C.DS_ID],
                "retrieval_mode": "multiple",
                "multiple_retrieval_config": {
                    "top_k": 5,
                    "score_threshold": None,
                    "reranking_enable": True,
                    "reranking_mode": "reranking_model",
                    "reranking_model": {
                        "provider": C.XINFERENCE_PROVIDER,
                        "model": C.RERANK_MODEL,
                    },
                },
            },
            1180,
            40,
            100,
        ),
        _node(
            N_LLM_KB,
            "llm",
            "生成回答",
            {
                "model": _model(2048, 0.3),
                "prompt_template": [
                    {
                        "role": "system",
                        "text": (
                            "你是播城内部行政客服。只根据知识库片段回答，不要编造。"
                            "若片段不足，明确说不知道并建议转人工。\n"
                            "使用 <context></context> 中的资料：\n"
                            "<context>\n{{#context#}}\n</context>"
                        ),
                        "edition_type": "basic",
                    },
                    {
                        "role": "user",
                        "text": "用户问题：{{#%s.query#}}" % N_START,
                        "edition_type": "basic",
                    },
                ],
                "context": {
                    "enabled": True,
                    "variable_selector": [N_KR, "result"],
                },
                "vision": {"enabled": False},
            },
            1480,
            40,
            150,
        ),
        _node(
            N_END_KB,
            "end",
            "结束·知识库",
            {
                "outputs": [
                    {"variable": "answer", "value_selector": [N_LLM_KB, "text"]}
                ]
            },
            1780,
            40,
            90,
        ),
        _node(
            N_HTTP,
            "http-request",
            "调用工单API",
            {
                "method": "post",
                "url": ticket_url,
                "authorization": {"type": "no-auth", "config": None},
                "headers": "Content-Type:application/json",
                "params": "",
                "body": {
                    "type": "json",
                    "data": [{"type": "text", "key": "", "value": body_json}],
                },
                "timeout": {
                    "connect": 10,
                    "read": 30,
                    "write": 30,
                    "max_connect_timeout": 10,
                    "max_read_timeout": 60,
                    "max_write_timeout": 60,
                },
                "ssl_verify": False,
            },
            1180,
            280,
            150,
        ),
        _node(
            N_TPL_TICKET,
            "template-transform",
            "返回工单号",
            {
                "template": "已为您创建报修工单。\n{{ body }}\n请保存工单号，维修人员会联系您。",
                "variables": [
                    {"variable": "body", "value_selector": [N_HTTP, "body"]}
                ],
            },
            1480,
            280,
            90,
        ),
        _node(
            N_END_TICKET,
            "end",
            "结束·工单",
            {
                "outputs": [
                    {"variable": "answer", "value_selector": [N_TPL_TICKET, "output"]}
                ]
            },
            1780,
            280,
            90,
        ),
        _node(
            N_TPL_HUMAN,
            "template-transform",
            "转人工提示",
            {
                "template": (
                    "正在为您转接人工客服。投诉类诉求需要人工跟进，"
                    "请保持在线，工作人员会尽快接入。"
                ),
                "variables": [],
            },
            1180,
            500,
            90,
        ),
        _node(
            N_END_HUMAN,
            "end",
            "结束·人工",
            {
                "outputs": [
                    {"variable": "answer", "value_selector": [N_TPL_HUMAN, "output"]}
                ]
            },
            1480,
            500,
            90,
        ),
        _node(
            N_TPL_OTHER,
            "template-transform",
            "兜底回复",
            {
                "template": (
                    "我暂时无法判断您的具体诉求。您可以：\n"
                    "1）问制度流程（例如怎么请假）；\n"
                    "2）报修设备；\n"
                    "3）明确说要投诉或转人工。"
                ),
                "variables": [],
            },
            1180,
            680,
            90,
        ),
        _node(
            N_END_OTHER,
            "end",
            "结束·其他",
            {
                "outputs": [
                    {"variable": "answer", "value_selector": [N_TPL_OTHER, "output"]}
                ]
            },
            1480,
            680,
            90,
        ),
    ]
    edges = [
        _edge(N_START, N_LLM_INTENT, "start", "llm"),
        _edge(N_LLM_INTENT, N_PARSE, "llm", "code"),
        _edge(N_PARSE, N_IF, "code", "if-else"),
        _edge(N_IF, N_KR, "if-else", "knowledge-retrieval", CLS_KB),
        _edge(N_KR, N_LLM_KB, "knowledge-retrieval", "llm"),
        _edge(N_LLM_KB, N_END_KB, "llm", "end"),
        _edge(N_IF, N_HTTP, "if-else", "http-request", CLS_TICKET),
        _edge(N_HTTP, N_TPL_TICKET, "http-request", "template-transform"),
        _edge(N_TPL_TICKET, N_END_TICKET, "template-transform", "end"),
        _edge(N_IF, N_TPL_HUMAN, "if-else", "template-transform", CLS_HUMAN),
        _edge(N_TPL_HUMAN, N_END_HUMAN, "template-transform", "end"),
        _edge(N_IF, N_TPL_OTHER, "if-else", "template-transform", CLS_OTHER),
        _edge(N_TPL_OTHER, N_END_OTHER, "template-transform", "end"),
        _edge(N_IF, N_TPL_OTHER, "if-else", "template-transform", "false"),
    ]
    return {
        "nodes": nodes,
        "edges": edges,
        "viewport": {"x": 0, "y": 0, "zoom": 0.65},
    }

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""作业 2 · 步骤 3：把意图路由 graph 同步到 Workflow 草稿。"""
from __future__ import annotations

import sys

import _bootstrap  # noqa: F401
import _config as C
from dify_api import Dify, pp
from 作业2_graph import FEATURES, build_graph
from 作业2_02_创建工作流空壳 import find_app


def main() -> int:
    d = Dify(C.DIFY_EMAIL, C.DIFY_PASSWORD)
    try:
        d.login()
        found = find_app(d)
        if not found:
            print("找不到应用，请先跑 作业2_02_创建工作流空壳.py")
            return 1
        app_id = found["id"]
        print("app_id", app_id)

        hash_val = None
        r0 = d.get("/apps/%s/workflows/draft" % app_id)
        if r0.get("code") == "200":
            hash_val = (r0.get("json") or {}).get("hash")
            print("existing draft hash", hash_val)

        body = {
            "graph": build_graph(),
            "features": FEATURES,
            "environment_variables": [],
            "conversation_variables": [],
        }
        if hash_val:
            body["hash"] = hash_val

        r = d.post("/apps/%s/workflows/draft" % app_id, body)
        pp("sync draft", r, limit=2000)
        if r.get("code") not in ("200", "201"):
            return 1

        # 再读一遍确认节点数量
        r2 = d.get("/apps/%s/workflows/draft" % app_id)
        g = ((r2.get("json") or {}).get("graph")) or {}
        print("nodes", len(g.get("nodes") or []), "edges", len(g.get("edges") or []))
        print("hash", (r.get("json") or {}).get("hash") or (r2.get("json") or {}).get("hash"))
        print("下一步：运行 作业2_04_验收三句.py")
        return 0
    finally:
        d.close()


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

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""作业 2 · 步骤 4：三句验收（知识库 / 工单 / 人工）。"""
from __future__ import annotations

import json
import sys

import _bootstrap  # noqa: F401
import _config as C
from dify_api import Dify, pp
from 作业2_02_创建工作流空壳 import find_app


def parse_sse(text: str) -> dict:
    """从 Dify workflow 流式响应里抽出分类名、结束输出、错误。"""
    class_name = ""
    answer = ""
    errors: list[str] = []
    node_titles: list[str] = []
    for raw in text.splitlines():
        line = raw.strip()
        if line.startswith("data:"):
            line = line[5:].strip()
        if not line.startswith("{"):
            continue
        try:
            ev = json.loads(line)
        except json.JSONDecodeError:
            continue
        event = ev.get("event") or ""
        data = ev.get("data") or ev
        title = (data.get("title") or data.get("node_type") or "") if isinstance(data, dict) else ""
        if event in ("node_started", "node_finished") and title:
            node_titles.append("%s:%s" % (event, title))
        if event == "node_finished":
            outputs = data.get("outputs") or {}
            if outputs.get("class_name"):
                class_name = str(outputs.get("class_name"))
            if outputs.get("class_label") and not class_name:
                class_name = str(outputs.get("class_label"))
            if outputs.get("intent"):
                class_name = str(outputs.get("intent"))
            err = data.get("error")
            if err:
                errors.append("%s: %s" % (title or data.get("node_id"), err))
        if event in ("workflow_finished", "workflow_succeeded"):
            outs = (data.get("outputs") or {}) if isinstance(data, dict) else {}
            if outs.get("answer"):
                answer = str(outs.get("answer"))
            elif outs:
                answer = json.dumps(outs, ensure_ascii=False)
        if event == "error":
            errors.append(str(data))
    if not answer:
        # 兜底：全文里找 WO- / 转人工 / 请假
        answer = text[-4000:]
    return {
        "class_name": class_name,
        "answer": answer,
        "errors": errors,
        "node_titles": node_titles[-30:],
    }


def run_one(d: Dify, app_id: str, query: str) -> dict:
    r = d.post(
        "/apps/%s/workflows/draft/run" % app_id,
        body={"inputs": {"query": query}, "files": []},
        extra="-m 420 --max-time 420",
        t=450,
    )
    parsed = parse_sse(r.get("text") or "")
    parsed["http"] = r.get("code")
    parsed["raw_head"] = (r.get("text") or "")[:800]
    return parsed


def main() -> int:
    cases = [
        (
            C.HOMEWORK2_PROBE_KB,
            "知识库问答",
            ("请假", "知识库", "制度", "流程", "hr", "行政"),
            ("知识库检索", "生成回答"),
        ),
        (
            C.HOMEWORK2_PROBE_TICKET,
            "工单报修",
            ("WO-", "工单", "报修"),
            ("调用工单API", "返回工单号"),
        ),
        (
            C.HOMEWORK2_PROBE_HUMAN,
            "人工客服",
            ("转接", "人工", "投诉"),
            ("转人工提示",),
        ),
    ]
    d = Dify(C.DIFY_EMAIL, C.DIFY_PASSWORD)
    try:
        d.login()
        found = find_app(d)
        if not found:
            print("找不到应用")
            return 1
        app_id = found["id"]
        print("app_id", app_id)
        failed = 0
        for query, expect_cls, markers, path_nodes in cases:
            print("\n======== 问句:", query, "期望分类:", expect_cls)
            parsed = run_one(d, app_id, query)
            print("http", parsed["http"])
            print("class_name", parsed["class_name"])
            print("errors", parsed["errors"][:3])
            print("nodes", parsed["node_titles"])
            ans = parsed["answer"] or ""
            print("answer_head", ans[:500].replace("\n", " / "))
            hits = [m for m in markers if m.lower() in ans.lower() or m in (parsed["class_name"] or "")]
            cls_ok = expect_cls in (parsed["class_name"] or "") or expect_cls in ans
            path_ok = any(n in str(parsed["node_titles"]) for n in path_nodes)
            ok = parsed["http"] in ("200",) and (cls_ok or path_ok) and (len(hits) >= 1 or cls_ok)
            if not parsed["errors"] and ok:
                print("[PASS]")
            else:
                print("[FAIL] hits=", hits, "cls_ok=", cls_ok, "path_ok=", path_ok)
                failed += 1
                print("raw_head", parsed["raw_head"][:800])
        if failed:
            print("\n[FAIL] %d / %d 未通过" % (failed, len(cases)))
            return 1
        print("\n[PASS] 三句验收均走对应路径。")
        return 0
    finally:
        d.close()


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

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""作业 2 · 客服意图路由工作流 graph 定义（给草稿同步用）。

结构：用户输入 → LLM 意图识别 → 代码抽出类别 → IF/ELSE
  ├ 知识库问答 → 知识库检索 → 生成回答 → 结束
  ├ 工单报修 → HTTP 工单 API → 返回工单号 → 结束
  ├ 人工客服 → 转人工提示 → 结束
  └ 其他 → 兜底回复 → 结束

不用 question-classifier：Qwen3.6 带 reasoning 时经常不吐 ```json```，
该节点会报 could not find json block。
"""
from __future__ import annotations

from typing import Any

import _config as C

CLS_KB = "cls_kb"
CLS_TICKET = "cls_ticket"
CLS_HUMAN = "cls_human"
CLS_OTHER = "cls_other"

N_START = "start"
N_LLM_INTENT = "llm_intent"
N_PARSE = "parse_intent"
N_IF = "route"
N_KR = "kr"
N_LLM_KB = "llm_kb"
N_HTTP = "http_ticket"
N_TPL_TICKET = "tpl_ticket"
N_TPL_HUMAN = "tpl_human"
N_TPL_OTHER = "tpl_other"
N_END_KB = "end_kb"
N_END_TICKET = "end_ticket"
N_END_HUMAN = "end_human"
N_END_OTHER = "end_other"

PARSE_CODE = r'''
import re

LABELS = ("人工客服", "工单报修", "知识库问答", "其他")


def main(text: str) -> dict:
    raw = text or ""
    cleaned = re.sub(r"<think[^>]*>[\s\S]*?</think>", "", raw, flags=re.I)
    # 优先看清洗后的正文，避免思考链里同时出现多个类别名
    for blob in (cleaned, raw):
        for lab in LABELS:
            if lab in blob:
                return {"intent": lab}
    low = (cleaned or raw).lower()
    if any(k in low for k in ("投诉", "complain", "human", "转人工")):
        return {"intent": "人工客服"}
    if any(k in low for k in ("报修", "repair", "ticket", "工单")):
        return {"intent": "工单报修"}
    if any(k in low for k in ("请假", "制度", "knowledge", "知识库")):
        return {"intent": "知识库问答"}
    return {"intent": "其他"}
'''.lstrip()

INTENT_SYS = """你是客服意图分类器。根据用户原话，只输出下面四个标签之一，不要解释、不要思考过程、不要 Markdown。

标签：
- 人工客服：投诉、举报、找领导、要人工、转人工。例句：我要投诉
- 工单报修：报修、设备故障、开维修单。例句：帮我报修设备
- 知识库问答：制度、流程、请假、加班、打卡、福利。例句：怎么请假
- 其他：闲聊或无法归类

只输出这四个中文词之一。"""


def _model(max_tokens: int, temperature: float = 0.2) -> dict[str, Any]:
    return {
        "provider": C.OPENAI_PROVIDER,
        "name": C.QWEN_MODEL,
        "mode": "chat",
        "completion_params": {
            "temperature": temperature,
            "max_tokens": max_tokens,
            "enable_thinking": False,
        },
    }


def _node(nid: str, ntype: str, title: str, data: dict[str, Any], x: float, y: float, h: int = 110) -> dict[str, Any]:
    payload = {
        "type": ntype,
        "title": title,
        "desc": "",
        "selected": False,
        **data,
    }
    return {
        "id": nid,
        "type": "custom",
        "position": {"x": x, "y": y},
        "positionAbsolute": {"x": x, "y": y},
        "sourcePosition": "right",
        "targetPosition": "left",
        "width": 244,
        "height": h,
        "data": payload,
    }


def _edge(src: str, dst: str, src_type: str, dst_type: str, handle: str = "source") -> dict[str, Any]:
    return {
        "id": "%s-%s-%s" % (src, handle, dst),
        "source": src,
        "sourceHandle": handle,
        "target": dst,
        "targetHandle": "target",
        "type": "custom",
        "zIndex": 0,
        "data": {
            "sourceType": src_type,
            "targetType": dst_type,
            "isInIteration": False,
        },
    }


FEATURES: dict[str, Any] = {
    "file_upload": {
        "image": {
            "enabled": False,
            "number_limits": 3,
            "transfer_methods": ["local_file", "remote_url"],
        }
    },
    "opening_statement": "",
    "retriever_resource": {"enabled": True},
    "sensitive_word_avoidance": {"enabled": False},
    "speech_to_text": {"enabled": False},
    "suggested_questions": [],
    "suggested_questions_after_answer": {"enabled": False},
    "text_to_speech": {"enabled": False, "language": "", "voice": ""},
}


def build_graph() -> dict[str, Any]:
    ticket_url = C.TICKET_API_BASE.rstrip("/") + "/ticket"
    body_json = '{"query": "{{#%s.query#}}", "category": "repair"}' % N_START
    nodes = [
        _node(
            N_START,
            "start",
            "用户输入",
            {
                "variables": [
                    {
                        "variable": "query",
                        "label": "用户问题",
                        "type": "paragraph",
                        "required": True,
                        "max_length": 2000,
                        "options": [],
                    }
                ]
            },
            40,
            420,
            90,
        ),
        _node(
            N_LLM_INTENT,
            "llm",
            "意图识别",
            {
                "model": _model(1024, 0.0),
                "prompt_template": [
                    {"role": "system", "text": INTENT_SYS, "edition_type": "basic"},
                    {
                        "role": "user",
                        "text": "用户原话：{{#%s.query#}}" % N_START,
                        "edition_type": "basic",
                    },
                ],
                "context": {"enabled": False, "variable_selector": []},
                "vision": {"enabled": False},
            },
            330,
            400,
            140,
        ),
        _node(
            N_PARSE,
            "code",
            "抽出意图标签",
            {
                "variables": [
                    {"variable": "text", "value_selector": [N_LLM_INTENT, "text"]}
                ],
                "code_language": "python3",
                "code": PARSE_CODE,
                "outputs": {"intent": {"type": "string", "children": None}},
            },
            620,
            400,
            100,
        ),
        _node(
            N_IF,
            "if-else",
            "意图路由",
            {
                "cases": [
                    {
                        "case_id": CLS_KB,
                        "logical_operator": "and",
                        "conditions": [
                            {
                                "id": "c_kb",
                                "variable_selector": [N_PARSE, "intent"],
                                "comparison_operator": "is",
                                "value": "知识库问答",
                            }
                        ],
                    },
                    {
                        "case_id": CLS_TICKET,
                        "logical_operator": "and",
                        "conditions": [
                            {
                                "id": "c_ticket",
                                "variable_selector": [N_PARSE, "intent"],
                                "comparison_operator": "is",
                                "value": "工单报修",
                            }
                        ],
                    },
                    {
                        "case_id": CLS_HUMAN,
                        "logical_operator": "and",
                        "conditions": [
                            {
                                "id": "c_human",
                                "variable_selector": [N_PARSE, "intent"],
                                "comparison_operator": "is",
                                "value": "人工客服",
                            }
                        ],
                    },
                    {
                        "case_id": CLS_OTHER,
                        "logical_operator": "and",
                        "conditions": [
                            {
                                "id": "c_other",
                                "variable_selector": [N_PARSE, "intent"],
                                "comparison_operator": "is",
                                "value": "其他",
                            }
                        ],
                    },
                ]
            },
            900,
            380,
            220,
        ),
        _node(
            N_KR,
            "knowledge-retrieval",
            "知识库检索",
            {
                "query_variable_selector": [N_START, "query"],
                "dataset_ids": [C.DS_ID],
                "retrieval_mode": "multiple",
                "multiple_retrieval_config": {
                    "top_k": 5,
                    "score_threshold": None,
                    "reranking_enable": True,
                    "reranking_mode": "reranking_model",
                    "reranking_model": {
                        "provider": C.XINFERENCE_PROVIDER,
                        "model": C.RERANK_MODEL,
                    },
                },
            },
            1180,
            40,
            100,
        ),
        _node(
            N_LLM_KB,
            "llm",
            "生成回答",
            {
                "model": _model(2048, 0.3),
                "prompt_template": [
                    {
                        "role": "system",
                        "text": (
                            "你是播城内部行政客服。只根据知识库片段回答，不要编造。"
                            "若片段不足，明确说不知道并建议转人工。\n"
                            "使用 <context></context> 中的资料：\n"
                            "<context>\n{{#context#}}\n</context>"
                        ),
                        "edition_type": "basic",
                    },
                    {
                        "role": "user",
                        "text": "用户问题：{{#%s.query#}}" % N_START,
                        "edition_type": "basic",
                    },
                ],
                "context": {
                    "enabled": True,
                    "variable_selector": [N_KR, "result"],
                },
                "vision": {"enabled": False},
            },
            1480,
            40,
            150,
        ),
        _node(
            N_END_KB,
            "end",
            "结束·知识库",
            {
                "outputs": [
                    {"variable": "answer", "value_selector": [N_LLM_KB, "text"]}
                ]
            },
            1780,
            40,
            90,
        ),
        _node(
            N_HTTP,
            "http-request",
            "调用工单API",
            {
                "method": "post",
                "url": ticket_url,
                "authorization": {"type": "no-auth", "config": None},
                "headers": "Content-Type:application/json",
                "params": "",
                "body": {
                    "type": "json",
                    "data": [{"type": "text", "key": "", "value": body_json}],
                },
                "timeout": {
                    "connect": 10,
                    "read": 30,
                    "write": 30,
                    "max_connect_timeout": 10,
                    "max_read_timeout": 60,
                    "max_write_timeout": 60,
                },
                "ssl_verify": False,
            },
            1180,
            280,
            150,
        ),
        _node(
            N_TPL_TICKET,
            "template-transform",
            "返回工单号",
            {
                "template": "已为您创建报修工单。\n{{ body }}\n请保存工单号，维修人员会联系您。",
                "variables": [
                    {"variable": "body", "value_selector": [N_HTTP, "body"]}
                ],
            },
            1480,
            280,
            90,
        ),
        _node(
            N_END_TICKET,
            "end",
            "结束·工单",
            {
                "outputs": [
                    {"variable": "answer", "value_selector": [N_TPL_TICKET, "output"]}
                ]
            },
            1780,
            280,
            90,
        ),
        _node(
            N_TPL_HUMAN,
            "template-transform",
            "转人工提示",
            {
                "template": (
                    "正在为您转接人工客服。投诉类诉求需要人工跟进，"
                    "请保持在线，工作人员会尽快接入。"
                ),
                "variables": [],
            },
            1180,
            500,
            90,
        ),
        _node(
            N_END_HUMAN,
            "end",
            "结束·人工",
            {
                "outputs": [
                    {"variable": "answer", "value_selector": [N_TPL_HUMAN, "output"]}
                ]
            },
            1480,
            500,
            90,
        ),
        _node(
            N_TPL_OTHER,
            "template-transform",
            "兜底回复",
            {
                "template": (
                    "我暂时无法判断您的具体诉求。您可以：\n"
                    "1）问制度流程（例如怎么请假）；\n"
                    "2）报修设备；\n"
                    "3）明确说要投诉或转人工。"
                ),
                "variables": [],
            },
            1180,
            680,
            90,
        ),
        _node(
            N_END_OTHER,
            "end",
            "结束·其他",
            {
                "outputs": [
                    {"variable": "answer", "value_selector": [N_TPL_OTHER, "output"]}
                ]
            },
            1480,
            680,
            90,
        ),
    ]
    edges = [
        _edge(N_START, N_LLM_INTENT, "start", "llm"),
        _edge(N_LLM_INTENT, N_PARSE, "llm", "code"),
        _edge(N_PARSE, N_IF, "code", "if-else"),
        _edge(N_IF, N_KR, "if-else", "knowledge-retrieval", CLS_KB),
        _edge(N_KR, N_LLM_KB, "knowledge-retrieval", "llm"),
        _edge(N_LLM_KB, N_END_KB, "llm", "end"),
        _edge(N_IF, N_HTTP, "if-else", "http-request", CLS_TICKET),
        _edge(N_HTTP, N_TPL_TICKET, "http-request", "template-transform"),
        _edge(N_TPL_TICKET, N_END_TICKET, "template-transform", "end"),
        _edge(N_IF, N_TPL_HUMAN, "if-else", "template-transform", CLS_HUMAN),
        _edge(N_TPL_HUMAN, N_END_HUMAN, "template-transform", "end"),
        _edge(N_IF, N_TPL_OTHER, "if-else", "template-transform", CLS_OTHER),
        _edge(N_TPL_OTHER, N_END_OTHER, "template-transform", "end"),
        _edge(N_IF, N_TPL_OTHER, "if-else", "template-transform", "false"),
    ]
    return {
        "nodes": nodes,
        "edges": edges,
        "viewport": {"x": 0, "y": 0, "zoom": 0.65},
    }

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""作业 2 · 模拟「工单报修」HTTP API（FastAPI）。

启动（207 上）：
  pip3 install fastapi uvicorn -q
  uvicorn 作业2_ticket_api:app --host 0.0.0.0 --port 8778

或：bash /opt/workbuddy/scripts_bash_cursor/作业2_客服意图路由工作流/作业2_启动_ticket.sh
"""
from __future__ import annotations

import itertools
from typing import Any

from fastapi import FastAPI
from pydantic import BaseModel, Field

app = FastAPI(
    title="Ticket API",
    version="1.0.0",
    description="Dify Workflow 作业 2：模拟创建报修工单，返回工单号",
)

_seq = itertools.count(1001)


class TicketIn(BaseModel):
    query: str = Field(default="", description="用户报修描述")
    category: str = Field(default="repair", description="工单类别")


@app.post("/ticket", operation_id="createTicket", summary="创建报修工单")
def create_ticket(body: TicketIn) -> dict[str, Any]:
    n = next(_seq)
    ticket_id = "WO-%d" % n
    return {
        "ticket_id": ticket_id,
        "status": "created",
        "category": body.category,
        "issue": body.query or "未填写故障描述",
        "message": "报修工单已创建，工单号 %s" % ticket_id,
    }


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


if __name__ == "__main__":
    import uvicorn

    uvicorn.run("作业2_ticket_api:app", host="0.0.0.0", port=8778, reload=False)

#!/usr/bin/env bash
# 作业 2 · 在 207 上启动模拟「工单报修」FastAPI 服务
set -euo pipefail

DIR="/opt/ticket_api"
PORT="${TICKET_API_PORT:-8778}"
PIDFILE="/tmp/ticket_api.pid"
LOG="/tmp/ticket_api.log"

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

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

cd "$DIR"
nohup python3 -m uvicorn 作业2_ticket_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"

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""作业 2 · 步骤 1：把工单模拟服务部署到 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/ticket_api"
LOCAL_API = Path(__file__).resolve().parent / "作业2_ticket_api.py"
LOCAL_SH = Path(__file__).resolve().parents[1] / "scripts_bash_cursor" / "作业2_启动_ticket.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 + "/作业2_ticket_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/ticket_api.pid ]]; then "
            "kill $(cat /tmp/ticket_api.pid) 2>/dev/null || true; "
            "rm -f /tmp/ticket_api.pid; fi"
        )
        out, err = d.sh("TICKET_API_PORT=%d bash %s/start.sh" % (C.TICKET_API_PORT, REMOTE_DIR))
        print(out or err)
        r = d.sh(
            "curl -s -X POST 'http://127.0.0.1:%d/ticket' "
            "-H 'Content-Type: application/json' "
            "-d '{\"query\":\"帮我报修设备\",\"category\":\"repair\"}'"
            % C.TICKET_API_PORT
        )
        print("probe:", r[0].strip())
        return 0 if "WO-" in (r[0] or "") else 1
    finally:
        d.close()


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

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""作业 2 · 步骤 2：创建 Workflow 空壳（mode=workflow）。"""
from __future__ import annotations

import sys

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


def find_app(d: Dify) -> dict | None:
    r = d.get("/apps?page=1&limit=50")
    for item in (r.get("json") or {}).get("data") or []:
        if item.get("name") == C.HOMEWORK2_APP_NAME and item.get("mode") == "workflow":
            return item
    aid = getattr(C, "HOMEWORK2_APP_ID", "") or ""
    if aid:
        for item in (r.get("json") or {}).get("data") or []:
            if item.get("id") == aid:
                return item
    return None


def main() -> int:
    d = Dify(C.DIFY_EMAIL, C.DIFY_PASSWORD)
    try:
        d.login()
        found = find_app(d)
        if found:
            print("already exists app_id=", found.get("id"), "mode=", found.get("mode"))
            print("下一步：运行 作业2_03_同步工作流草稿.py")
            return 0
        body = {
            "name": C.HOMEWORK2_APP_NAME,
            "description": "作业 2：客服意图路由（知识库 / 工单报修 / 人工客服 / 兜底）",
            "mode": "workflow",
            "icon_type": "emoji",
            "icon": "🎧",
            "icon_background": "#E3F2FD",
        }
        r = d.post("/apps", body)
        pp("create workflow app", r)
        j = r.get("json") or {}
        print("app_id", j.get("id"))
        if r.get("code") not in ("200", "201"):
            return 1
        print("下一步：运行 作业2_03_同步工作流草稿.py")
        return 0
    finally:
        d.close()


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

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""作业 2 · 步骤 3：把意图路由 graph 同步到 Workflow 草稿。"""
from __future__ import annotations

import sys

import _bootstrap  # noqa: F401
import _config as C
from dify_api import Dify, pp
from 作业2_graph import FEATURES, build_graph
from 作业2_02_创建工作流空壳 import find_app


def main() -> int:
    d = Dify(C.DIFY_EMAIL, C.DIFY_PASSWORD)
    try:
        d.login()
        found = find_app(d)
        if not found:
            print("找不到应用，请先跑 作业2_02_创建工作流空壳.py")
            return 1
        app_id = found["id"]
        print("app_id", app_id)

        hash_val = None
        r0 = d.get("/apps/%s/workflows/draft" % app_id)
        if r0.get("code") == "200":
            hash_val = (r0.get("json") or {}).get("hash")
            print("existing draft hash", hash_val)

        body = {
            "graph": build_graph(),
            "features": FEATURES,
            "environment_variables": [],
            "conversation_variables": [],
        }
        if hash_val:
            body["hash"] = hash_val

        r = d.post("/apps/%s/workflows/draft" % app_id, body)
        pp("sync draft", r, limit=2000)
        if r.get("code") not in ("200", "201"):
            return 1

        # 再读一遍确认节点数量
        r2 = d.get("/apps/%s/workflows/draft" % app_id)
        g = ((r2.get("json") or {}).get("graph")) or {}
        print("nodes", len(g.get("nodes") or []), "edges", len(g.get("edges") or []))
        print("hash", (r.get("json") or {}).get("hash") or (r2.get("json") or {}).get("hash"))
        print("下一步：运行 作业2_04_验收三句.py")
        return 0
    finally:
        d.close()


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

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""作业 2 · 步骤 4：三句验收（知识库 / 工单 / 人工）。"""
from __future__ import annotations

import json
import sys

import _bootstrap  # noqa: F401
import _config as C
from dify_api import Dify, pp
from 作业2_02_创建工作流空壳 import find_app


def parse_sse(text: str) -> dict:
    """从 Dify workflow 流式响应里抽出分类名、结束输出、错误。"""
    class_name = ""
    answer = ""
    errors: list[str] = []
    node_titles: list[str] = []
    for raw in text.splitlines():
        line = raw.strip()
        if line.startswith("data:"):
            line = line[5:].strip()
        if not line.startswith("{"):
            continue
        try:
            ev = json.loads(line)
        except json.JSONDecodeError:
            continue
        event = ev.get("event") or ""
        data = ev.get("data") or ev
        title = (data.get("title") or data.get("node_type") or "") if isinstance(data, dict) else ""
        if event in ("node_started", "node_finished") and title:
            node_titles.append("%s:%s" % (event, title))
        if event == "node_finished":
            outputs = data.get("outputs") or {}
            if outputs.get("class_name"):
                class_name = str(outputs.get("class_name"))
            if outputs.get("class_label") and not class_name:
                class_name = str(outputs.get("class_label"))
            if outputs.get("intent"):
                class_name = str(outputs.get("intent"))
            err = data.get("error")
            if err:
                errors.append("%s: %s" % (title or data.get("node_id"), err))
        if event in ("workflow_finished", "workflow_succeeded"):
            outs = (data.get("outputs") or {}) if isinstance(data, dict) else {}
            if outs.get("answer"):
                answer = str(outs.get("answer"))
            elif outs:
                answer = json.dumps(outs, ensure_ascii=False)
        if event == "error":
            errors.append(str(data))
    if not answer:
        # 兜底：全文里找 WO- / 转人工 / 请假
        answer = text[-4000:]
    return {
        "class_name": class_name,
        "answer": answer,
        "errors": errors,
        "node_titles": node_titles[-30:],
    }


def run_one(d: Dify, app_id: str, query: str) -> dict:
    r = d.post(
        "/apps/%s/workflows/draft/run" % app_id,
        body={"inputs": {"query": query}, "files": []},
        extra="-m 420 --max-time 420",
        t=450,
    )
    parsed = parse_sse(r.get("text") or "")
    parsed["http"] = r.get("code")
    parsed["raw_head"] = (r.get("text") or "")[:800]
    return parsed


def main() -> int:
    cases = [
        (
            C.HOMEWORK2_PROBE_KB,
            "知识库问答",
            ("请假", "知识库", "制度", "流程", "hr", "行政"),
            ("知识库检索", "生成回答"),
        ),
        (
            C.HOMEWORK2_PROBE_TICKET,
            "工单报修",
            ("WO-", "工单", "报修"),
            ("调用工单API", "返回工单号"),
        ),
        (
            C.HOMEWORK2_PROBE_HUMAN,
            "人工客服",
            ("转接", "人工", "投诉"),
            ("转人工提示",),
        ),
    ]
    d = Dify(C.DIFY_EMAIL, C.DIFY_PASSWORD)
    try:
        d.login()
        found = find_app(d)
        if not found:
            print("找不到应用")
            return 1
        app_id = found["id"]
        print("app_id", app_id)
        failed = 0
        for query, expect_cls, markers, path_nodes in cases:
            print("\n======== 问句:", query, "期望分类:", expect_cls)
            parsed = run_one(d, app_id, query)
            print("http", parsed["http"])
            print("class_name", parsed["class_name"])
            print("errors", parsed["errors"][:3])
            print("nodes", parsed["node_titles"])
            ans = parsed["answer"] or ""
            print("answer_head", ans[:500].replace("\n", " / "))
            hits = [m for m in markers if m.lower() in ans.lower() or m in (parsed["class_name"] or "")]
            cls_ok = expect_cls in (parsed["class_name"] or "") or expect_cls in ans
            path_ok = any(n in str(parsed["node_titles"]) for n in path_nodes)
            ok = parsed["http"] in ("200",) and (cls_ok or path_ok) and (len(hits) >= 1 or cls_ok)
            if not parsed["errors"] and ok:
                print("[PASS]")
            else:
                print("[FAIL] hits=", hits, "cls_ok=", cls_ok, "path_ok=", path_ok)
                failed += 1
                print("raw_head", parsed["raw_head"][:800])
        if failed:
            print("\n[FAIL] %d / %d 未通过" % (failed, len(cases)))
            return 1
        print("\n[PASS] 三句验收均走对应路径。")
        return 0
    finally:
        d.close()


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