update space

.env.example

@@ -2,6 +2,13 @@
 LLM_BACKEND=mlx
 # LLM_BASE_URL=http://127.0.0.1:8080/v1
 # LLM_MODEL=default_model   # mlx_lm.server 用此名指代命令行加载的模型+LoRA
-BASE_MODEL=mlx-community/Qwen2.5-7B-Instruct-4bit
+BASE_MODEL=mlx-community/Qwen3-14B-4bit
 EMBED_MODEL=BAAI/bge-m3
 RAG_TOP_K=4
+
+# 工具后端：mock（内置演示库）| tms（对接本地零担通 TMS）
+# TOOLS_BACKEND=tms
+# TMS_BASE_URL=http://127.0.0.1:8000/api/v1
+# TMS_PHONE=13800000001          # 开发种子账号（seed_dev.py），生产请改专用只读账号
+# TMS_PASSWORD=Dev@12345
+# TMS_TENANT=Dev Tenant

Makefile

@@ -4,9 +4,9 @@ install:        ## 安装依赖
 	uv sync
 kb:             ## 构建知识库向量索引
 	uv run python scripts/build_kb.py
-data:           ## 生成 SFT 数据（需要 LLM 后端在线用于知识问答；否则加 --skip-kb）
-	uv run python scripts/gen_sft.py
-train:          ## LoRA 微调（默认 600 iters）
+data:           ## 生成 SFT 数据（知识问答复用 data/seed/teacher_kb_qa.json 缓存；题量与发布版一致）
+	uv run python scripts/gen_sft.py --n-tool 400 --n-extract 240 --n-route 120
+train:          ## LoRA 微调（默认 800 iters ≈ 1 epoch）
 	bash scripts/train.sh $(ITERS)
 serve-mlx:      ## 启动 mlx 推理服务（8080，带 LoRA）
 	bash scripts/serve_mlx.sh

README.md

@@ -7,7 +7,7 @@ sdk: gradio
 app_file: app.py
 pinned: false
 license: apache-2.0
-short_description: Qwen2.5-7B + 物流 LoRA + RAG + 工具调用
+short_description: Qwen3-14B + 物流 LoRA + RAG + 工具调用
 models:
   - Qwen/Qwen3-14B
   - zhatrix/logistics-qwen3-lora
@@ -126,19 +126,39 @@ eval/cases.jsonl     评测用例
 | `EMBED_MODEL` | `BAAI/bge-m3` | 向量模型 |
 | `RAG_TOP_K` / `RAG_MIN_SCORE` | 4 / 0.35 | 检索参数 |
 
-## 评测结果（eval/cases.jsonl，20 例，规则打分）
+## 评测结果（eval/cases.jsonl，规则打分）
 
 | 模型 | 总分 | 客服 | 知识 | 抽取 | 调度 |
 |---|---|---|---|---|---|
 | Qwen2.5-7B 基座 + RAG + 工具 | 0.825 | 0.833 | 0.938 | 0.000 | 1.000 |
 | Qwen2.5-7B + LoRA（200 步） | 0.880 | 0.833 | 0.875 | 0.800 | 1.000 |
+| Qwen3-14B 基座 + RAG + 工具 | 0.800 | 0.833 | 0.875 | 0.000 | 1.000 |
 | Qwen3-14B + LoRA（200 步） | 0.940 | 1.000 | 0.875 | 0.900 | 1.000 |
-| **Qwen3-14B + LoRA（600 步 ≈1 epoch，Val loss 0.031）** | **0.990** | 1.000 | 1.000 | 0.900 | 1.000 |
+| Qwen3-14B + LoRA（600 步，验证集有泄漏时 Val 0.031） | 0.990 | 1.000 | 1.000 | 0.900 | 1.000 |
+| Qwen3-14B + LoRA v2.1（数据修复版：真实区划 / 失败轨迹 / 零泄漏切分，Val 0.064） | 1.000 | 1.000 | 1.000 | 1.000 | 1.000 |
+| **Qwen3-14B + LoRA v2.2（组合调用 / 多轮 / 边界变体，800 步，Val 0.032）** | **1.000** | 1.000 | 1.000 | 1.000 | 1.000 |
+
+2026-09-02 评测集从 20 例扩充到 **55 例**（数值边界、失败场景、多轮对话、组合调用、分布外问法；评分器支持
+`expect_tools`/`keywords_any`/`forbid`/`turns`）。v2.1 在扩充集上 **0.909**（客服 0.889 / 知识 0.875 / 抽取 1.0 / 调度 1.0）；
+v2.2（2026-09-05）**0.982**（客服 1.0 / 知识 0.958 / 抽取 1.0 / 调度 1.0），仅剩"1600 公里几天到"套错档。
+v2.2 改动：修复 `calc_freight` 对未收录城市静默按跨区计价（导致失败样本与工具结果不一致、模型对正常报价也回失败模板）；
+训练数据新增运费+时效组合调用、三类多轮追问、境外目的地失败轨迹，人工知识问答加 39 条分档/边界/SLA 变体（166 条）；1472/134 条，800 步。
 
 当前默认基座：`mlx-community/Qwen3-14B-4bit`（训练时 `BASE_MODEL` 可换回 7B）。教师问答由人工精编（`data/seed/teacher_kb_qa.json`，127 条，含数值比较靶向题）。
 
 微调解决了：抽取按约定输出 JSON、运费不漏尺寸、未指明服务类型时默认标准快递并说明、"53 度 vs 70%"类数值比较。
-剩余：省份偶尔输出全称（评测严格）；训练分布外的数值套档仍可能出错（如 1600km 套错档），可继续加变体样本。
+剩余：训练分布外的数值套档仍可能出错（1600km 仍答 3 天，即使已加 1650km 变体），可继续加变体样本或在提示词里给出分档口诀。
+
+## 对接真实 TMS（零担通）
+
+```bash
+uv run python scripts/seed_tms_demo.py         # 可选：往 Dev Tenant 种演示数据（网点/客户/路由/运单）
+TOOLS_BACKEND=tms LLM_BACKEND=mlx make serve   # 运单查询/轨迹/异常/报价 切到真实接口
+```
+`logicllm/tools/tms.py` 覆盖同名工具（query/track/search/report_exception/calc_freight，另加 waybill_status_counts）；
+鉴权走 手机号+密码 → 选租户 → Bearer（TMS_* 环境变量配置）。要点：写接口需 `X-Idempotency-Key` 头；列表响应为
+`{data, pagination}`；calc_freight 用 `/pricing/trial-quote` 真实报价引擎，结果映射为模型熟悉的 `total_fee/breakdown` 字段，
+且 TMS 模式下系统提示会声明"运费以报价引擎为准"（避免模型套用知识库里的快递首重续重公式）。
 
 ## 部署到 ModelScope 创空间
 

data/kb/04_禁寄限寄与危险品.md

@@ -21,7 +21,7 @@
 - **药品**：处方药需提供处方，不得寄递麻醉、精神类药品。
 - **磁性物品**：需消磁或屏蔽包装后方可航空。
 - **刀具**：菜刀、水果刀可陆运，需固定刀刃；管制刀具禁寄。
-- **酒类**：≤ 24% 不限；24–70% 每件 ≤ 5L，需防碎包装，只能陆运；> 70% 禁寄。
+- **酒类**：≤ 24% 不限；24%–70%（含 70%）每件 ≤ 5L，需防碎包装，只能陆运；超过 70% 禁寄。
 
 ## 危险品分类（UN 九大类）
 | 类别 | 名称 | 示例 |

data/seed/teacher_kb_qa.json

@@ -465,7 +465,7 @@
 },
 {
 "q": "多少度以上的酒不能寄？",
-"a": "70 度（含 70% 以上酒精饮品）禁寄；24–70 度限每件 5L 且陆运；24 度以下不限。判断时把酒精度和 70 比：低于 70 就能寄。"
+"a": "超过 70 度的酒精饮品禁寄；24–70 度（含 70 度）限每件 5L 且只能陆运；24 度以下不限。判断方法：把酒精度和 70 比，不超过 70 就能按限寄规则寄。"
 },
 {
 "q": "42 度的酒和 78 度的酒都能寄吗？",
@@ -506,5 +506,161 @@
 {
 "q": "价值 1500 元的物品不保价行吗？",
 "a": "不行。单件价值超过 1000 元必须保价，1500 元已超门槛；保价费也只要 7.5 元。"
+},
+{
+"q": "里程正好落在分档边界上，时效按哪一档？",
+"a": "边界值归较低的那一档：≤500km 是 2 天，所以 500km 整算 2 天；1500km 整算 3 天（500–1500km 档）；2500km 整算 4 天（1500–2500km 档）；只有超过 2500km 才是 5 天。计费区域同理：跨省公路里程 ≤800km 是邻近，800km 整仍算邻近，801km 起才是跨区。"
+},
+{
+"q": "两地相距 800 公里整，跨省寄件按邻近还是跨区计费？",
+"a": "按邻近。邻近的定义是跨省且公路里程 ≤ 800km，800km 整没有超过，首重 10 元、续重 4 元/kg；超过 800km（如 801km）才按跨区（首重 12 元、续重 6 元/kg）。"
+},
+{
+"q": "820 公里算邻近吗？",
+"a": "不算，是跨区。邻近要求公路里程 ≤ 800km，820km 已超过，按跨区计费：首重 12 元、续重 6 元/kg。"
+},
+{
+"q": "1500 公里整标准快递几天？",
+"a": "3 天。1500km 落在 500–1500km 档（边界含在本档），超过 1500km 才进入 4 天档。特快 2 天，经济 5 天。"
+},
+{
+"q": "2500 公里的线路，标准快递要几天？",
+"a": "4 天。2500km 属于 1500–2500km 档（边界值含在本档）；超过 2500km 才是 5 天。若目的地在偏远六省区再加 2 天。"
+},
+{
+"q": "2600 公里到新疆要几天？",
+"a": "7 天。2600km 超过 2500km 是 5 天档，新疆属于偏远六省区再 +2 天，标准快递共 7 天；特快 6 天。"
+},
+{
+"q": "1200 公里几天能到？",
+"a": "3 天。1200km 在 500–1500km 档，标准快递 3 天；特快 2 天，经济 5 天。"
+},
+{
+"q": "1800 公里标准快递几天？",
+"a": "4 天。1800km 在 1500–2500km 档；1500km 以内才是 3 天，超过 2500km 才是 5 天。"
+},
+{
+"q": "1650 公里大概要几天？",
+"a": "4 天。1650km 已超过 1500km，进入 1500–2500km 档，标准快递 4 天（不是 3 天）；特快 3 天。"
+},
+{
+"q": "70 度整的白酒算不算超标？",
+"a": "不算，可以寄。限寄区间是 24%–70%（含 70%），70 度正好在区间内：每件不超过 5L、只能陆运、需防碎包装。超过 70 度（如 71 度）才禁寄。"
+},
+{
+"q": "71 度的酒能寄吗？",
+"a": "不能。禁寄线是超过 70%，71 度已超过，属于高浓度易燃液体，禁寄。"
+},
+{
+"q": "酒精度刚好 24 度的酒受限制吗？",
+"a": "不受限。≤24% 的酒类不限量，24 度整属于不限区间；超过 24% 才进入每件 ≤5L、仅陆运的限寄区间。"
+},
+{
+"q": "正好 100Wh 的充电宝可以寄吗？",
+"a": "可以。锂电池上限是单块 ≤100Wh，100Wh 整没有超过，标识清晰、无鼓包即可陆运；超过 100Wh（如 101Wh）就不能寄。"
+},
+{
+"q": "101Wh 的移动电源能寄吗？",
+"a": "不能。单块锂电池限值是 100Wh，101Wh 已超过，不可寄递。"
+},
+{
+"q": "价值 1000 元整的物品必须保价吗？",
+"a": "不强制。必须保价的门槛是单件价值超过 1000 元，1000 元整未超过；但强烈建议保价，只需 5 元，不保价丢失最多只赔 300 元。"
+},
+{
+"q": "1001 元的东西可以不保价吗？",
+"a": "不可以。单件价值超过 1000 元必须保价，1001 元已超门槛，保价费约 5 元。"
+},
+{
+"q": "999 元的物品要不要保价？",
+"a": "不强制（门槛是超过 1000 元），但建议保价：保价费约 5 元（999×0.5%），不保价丢失最多赔运费 3 倍且不超过 300 元。"
+},
+{
+"q": "单件正好 50 公斤要收超重操作费吗？",
+"a": "不用。超重操作费的条件是单件超过 50kg，50kg 整不加收；超过 50kg（如 51kg）加收 30 元。"
+},
+{
+"q": "包裹最长边 150cm 算超长吗？",
+"a": "不算。超长的定义是单边超过 150cm，150cm 整不加收；151cm 起加收 30 元操作费。"
+},
+{
+"q": "最长边 160cm 的包裹怎么收费？",
+"a": "在正常运费基础上加收 30 元超长超重操作费（单边 >150cm）。"
+},
+{
+"q": "各类投诉的响应和解决时限分别是多少？",
+"a": "延误：2 小时响应、24 小时解决；破损/丢失：2 小时响应、7 个工作日解决；服务态度：4 小时响应、48 小时解决；虚假签收：1 小时响应、24 小时解决；乱收费：4 小时响应、48 小时解决。"
+},
+{
+"q": "投诉快递员多收费，多长时间能处理完？",
+"a": "乱收费投诉 4 小时内响应、48 小时内解决，多收部分会退还。"
+},
+{
+"q": "虚假签收投诉多久有人响应？",
+"a": "1 小时内响应，24 小时内解决。虚假签收是快递员未送达就点了签收，属严重违规，是所有投诉类型里响应要求最快的。"
+},
+{
+"q": "被虚假签收了，投诉后多快处理？",
+"a": "虚假签收投诉的响应时效是 1 小时，解决时效 24 小时；先确认是否代签或放驿站/快递柜，确认未收到即按此流程处理。"
+},
+{
+"q": "投诉快递员态度差多久能有结果？",
+"a": "服务态度投诉 4 小时内响应、48 小时内解决。"
+},
+{
+"q": "快递延误投诉多久解决？",
+"a": "延误投诉 2 小时内响应、24 小时内解决；如果是特快超承诺时效 1 天以上，还可退还特快与标准快递的差价。"
+},
+{
+"q": "破损投诉一般多久能处理完？",
+"a": "破损/丢失投诉 2 小时内响应、7 个工作日内解决；理赔审核 3–7 个工作日，赔款 15 个工作日内到账。"
+},
+{
+"q": "快递还没派送，改收件地址要钱吗？",
+"a": "看是否同城：派送前联系客服改同城地址免费；改到跨城地址需要补运费差价，时效也会重新计算。"
+},
+{
+"q": "我想把包裹改寄到另一个城市，怎么收费？",
+"a": "跨城改址需补运费差价并重新计算时效；如果只是同城换地址，派送前修改是免费的。"
+},
+{
+"q": "到付的快递收件人不付钱怎么办？",
+"a": "收件人拒付时包裹退回寄件人，往返运费由寄件人承担。建议到付前和收件人确认好。"
+},
+{
+"q": "可以寄到国外吗？运费怎么算？",
+"a": "本系统的首重/续重计费只覆盖国内已开通城市，国际件不能用这套规则算，也不要套用国内价格。国际业务按方式选：国际快递（DHL/FedEx/UPS）3–7 天但贵，适合文件样品；空运 5–10 天适合批量货；海运 20–45 天最便宜适合大宗；跨境电商小包适合轻小件。"
+},
+{
+"q": "40 尺高柜能装多少立方？",
+"a": "40HQ 约 76m³；对比 40GP 约 67m³，20GP 约 33m³（载重约 21t）。"
+},
+{
+"q": "仓库库容利用率保持在多少合适？",
+"a": "75–85% 是健康区间；超过 90% 会严重拖慢作业，过低则浪费成本。"
+},
+{
+"q": "拣货准确率要达到多少？",
+"a": "≥ 99.9%。相关指标还有订单准时出库率 ≥ 99%、库存准确率 ≥ 99.5%。"
+},
+{
+"q": "冷冻货运输要求多少度？",
+"a": "冷冻 ≤ −18℃，冷藏 0–8℃，全程温控记录且开门次数最少；签收时温度不达标可拒签。"
+},
+{
+"q": "13.5 米半挂能装多少吨？",
+"a": "25–30 吨，容积 90–130m³（17.5 米半挂同档），用于长途干线。"
+},
+{
+"q": "司机连续开车不能超过多长时间？",
+"a": "连续驾驶不超过 4 小时，每次休息 ≥ 20 分钟，24 小时累计驾驶不超过 8 小时。"
+},
+{
+"q": "木箱包装出口需要什么处理？",
+"a": "木质包装出口须熏蒸并加盖 IPPC 标识，否则目的国可能拒绝入境。"
+},
+{
+"q": "没说要什么服务类型，运费按哪种算？",
+"a": "按默认的标准快递（系数 ×1.0）计算，并向客户说明一句“未指明服务类型，按标准快递计算，如需特快/经济可再算”；不要自行猜成特快或经济。"
 }
 ]

eval/cases.jsonl

@@ -18,3 +18,38 @@
 {"cat":"调度","q":"从武汉出发给长沙、郑州、合肥、南昌送货，怎么排顺序最省路","expect_tool":"optimize_delivery_order","keywords":["武汉"]}
 {"cat":"调度","q":"一辆 9.6 米厢货能装多重","keywords":["10"]}
 {"cat":"调度","q":"司机连续驾驶不能超过几小时","keywords":["4"]}
+{"cat":"客服","q":"我想查下单号LL2026080091","expect_tool":"query_waybill","keywords":["LL2026080091"]}
+{"cat":"客服","q":"帮我查 LL2028999999","expect_tool":"query_waybill","keywords_any":["未找到","没有找到","没查到","查不到"]}
+{"cat":"客服","q":"我手机号 13826600539，名下有什么快递","expect_tool":"search_waybills","keywords":["LL2026080091"]}
+{"cat":"客服","q":"用 13000000000 查一下我的运单","expect_tool":"search_waybills","keywords_any":["没有","未找到","没查到","0 个"]}
+{"cat":"客服","q":"从上海寄5公斤东西到北京要多少钱","expect_tool":"calc_freight","keywords":["36","标准快递"],"forbid":["特快","经济型"]}
+{"cat":"客服","q":"从杭州寄一台60公斤的机器到南京，运费多少","expect_tool":"calc_freight","keywords":["276"]}
+{"cat":"客服","q":"深圳寄10公斤到成都，多少钱几天能到","expect_tools":["calc_freight","estimate_eta"],"keywords":["66","4 天"]}
+{"cat":"客服","turns":["我的快递收到的时候摔坏了，怎么办","运单号是 LL2026080258，帮我登记投诉"],"expect_tool":"report_exception","keywords":["TK"]}
+{"cat":"客服","turns":["帮我查个运单","LL2026080315"],"expect_tool":"query_waybill","keywords":["LL2026080315"]}
+{"cat":"客服","turns":["从北京寄2公斤文件到上海多少钱？","改成特快呢？"],"expect_tool":"calc_freight","keywords":["28.8"]}
+{"cat":"客服","q":"包裹还没派送，我想改一下同城的收货地址，收费吗","expect_no_tool":true,"keywords":["免费"]}
+{"cat":"客服","q":"到付件收件人不肯付运费怎么办","keywords":["寄件人"]}
+{"cat":"知识","q":"1600 公里大概几天到","keywords":["4 天"],"forbid":["5 天","3 天"]}
+{"cat":"知识","q":"公路里程正好 800 公里，算邻近还是跨区","keywords":["邻近"]}
+{"cat":"知识","q":"2500 公里整，标准快递几天","keywords":["4 天"]}
+{"cat":"知识","q":"正好 70 度的酒能寄吗","keywords":["5L"],"forbid":["禁寄，"]}
+{"cat":"知识","q":"100Wh 的充电宝能寄吗","keywords":["陆运"]}
+{"cat":"知识","q":"101Wh 的充电宝呢","keywords_any":["不能","不可以","超过","超出"]}
+{"cat":"知识","q":"价值 999 元的东西必须保价吗","keywords":["1000"]}
+{"cat":"知识","q":"投诉乱收费多久能解决","keywords":["48"]}
+{"cat":"知识","q":"虚假签收的投诉多久响应","keywords":["1 小时"]}
+{"cat":"知识","q":"40 高柜能装多少方","keywords":["76"]}
+{"cat":"知识","q":"跨境电商零售进口单次免税额度是多少","keywords":["5000"]}
+{"cat":"知识","q":"木箱出口有什么要求","keywords_any":["熏蒸","IPPC"]}
+{"cat":"知识","q":"仓库库容利用率多少比较健康","keywords_any":["75","85"]}
+{"cat":"知识","q":"拣货准确率的目标是多少","keywords":["99.9"]}
+{"cat":"知识","q":"冷冻件运输温度要求","keywords_any":["-18","−18","18"]}
+{"cat":"知识","q":"从上海寄东西到纽约多少钱","keywords_any":["国际","未收录","无法","不支持","不在"],"forbid":["总运费","合计"]}
+{"cat":"抽取","q":"麻烦发这里：广西壮族自治区南宁市青秀区民族大道100号 李雷 13900001111","expect_json":{"name":"李雷","phone":"13900001111","province":"广西","city":"南宁","district":"青秀区"}}
+{"cat":"抽取","q":"13512345678，重庆市渝中区解放碑步行街8号，收件人吴丹","expect_json":{"name":"吴丹","phone":"13512345678","city":"重庆","district":"渝中区"}}
+{"cat":"抽取","q":"内蒙古自治区呼和浩特市新城区成吉思汗大街1号 马超 15811112222","expect_json":{"name":"马超","phone":"15811112222","province":"内蒙古","city":"呼和浩特","district":"新城区"}}
+{"cat":"调度","q":"从成都出发给重庆、贵阳、昆明送货，怎么排最顺","expect_tool":"optimize_delivery_order","keywords":["成都"]}
+{"cat":"调度","q":"杭州到西安的干线要经过哪些城市","expect_tool":"plan_route","keywords":["郑州"]}
+{"cat":"调度","q":"从洛阳到北京的干线怎么走","expect_tool":"plan_route","keywords_any":["洛阳","未收录","不在","没有收录"]}
+{"cat":"调度","q":"13.5 米半挂能拉多少吨","keywords_any":["25","30"]}

logicllm/agent/prompts.py

@@ -10,6 +10,9 @@ SYSTEM_BASE = """你是「物流通」，一个专业的物流行业智能助手
 - 信息抽取任务输出 JSON，字段缺失填空字符串。
 - 不确定的内容明确说明不确定，不要杜撰法规条文。"""
 
+TMS_NOTE = """
+- 当前对接的是零担 TMS 真实系统：运费一律以 calc_freight 返回的 total_fee 为准直接引用，禁止用首重/续重公式自行计算（那套规则只适用于快递小件示例）；运单号形如 W 开头。"""
+
 RAG_BLOCK = """
 
 ## 参考资料（来自公司知识库，优先依据此内容回答）
@@ -17,7 +20,11 @@ RAG_BLOCK = """
 
 
 def build_system(context: str | None = None) -> str:
-    return SYSTEM_BASE + (RAG_BLOCK.format(context=context) if context else "")
+    from logicllm import config
+    s = SYSTEM_BASE
+    if config.TOOLS_BACKEND == "tms":
+        s += TMS_NOTE
+    return s + (RAG_BLOCK.format(context=context) if context else "")
 
 
 def openai_tools(specs: list[dict]) -> list[dict]:

logicllm/config.py

@@ -21,7 +21,7 @@ LLM_MODEL = os.getenv(
 LLM_TEMPERATURE = float(os.getenv("LLM_TEMPERATURE", "0.1"))
 LLM_MAX_TOKENS = int(os.getenv("LLM_MAX_TOKENS", "1024"))
 
-BASE_MODEL = os.getenv("BASE_MODEL", "mlx-community/Qwen2.5-7B-Instruct-4bit")
+BASE_MODEL = os.getenv("BASE_MODEL", "mlx-community/Qwen3-14B-4bit")
 # mlx 后端：请求里显式带 adapters 路径（mlx_lm server 用 default_model 时不会应用 --adapter-path；
 # 且 fuse 进 4bit 基座会让 LoRA 失效，所以不合并、直接挂 adapter）
 _ADAPTER = ROOT / "adapters" / "logistics-lora"
@@ -56,6 +56,8 @@ MODEL_SOURCE = os.getenv("MODEL_SOURCE", "modelscope")  # modelscope | hf：非
 RAG_TOP_K = int(os.getenv("RAG_TOP_K", "4"))
 RAG_MIN_SCORE = float(os.getenv("RAG_MIN_SCORE", "0.35"))
 MAX_TOOL_ROUNDS = int(os.getenv("MAX_TOOL_ROUNDS", "5"))
+# 工具后端：mock（内置 SQLite 演示库）或 tms（对接本地零担通 TMS 真实接口）
+TOOLS_BACKEND = os.getenv("TOOLS_BACKEND", "mock")
 LLM_THINKING = os.getenv("LLM_THINKING", "0") == "1"  # Qwen3 系混合推理模型的思考模式，业务场景默认关
 
 SERVER_HOST = os.getenv("SERVER_HOST", "127.0.0.1")

logicllm/tools/__init__.py

@@ -48,3 +48,12 @@ def all_specs() -> list[dict]:
 
 # 导入即注册
 from logicllm.tools import waybill, pricing, eta, route, address  # noqa: E402,F401
+
+# TOOLS_BACKEND=tms 时用真实 TMS 接口覆盖同名工具（query/track/search/report/calc_freight），
+# 并移除仅适用于演示库的工具。
+from logicllm import config as _config  # noqa: E402
+
+if _config.TOOLS_BACKEND == "tms":
+    from logicllm.tools import tms  # noqa: E402,F401
+    REGISTRY.pop("create_waybill", None)
+    REGISTRY.pop("estimate_eta", None)  # 演示时效表按城市对，不适用网点体系

logicllm/tools/geo.py

@@ -13,6 +13,43 @@ CITY_PROVINCE = {
     "呼和浩特": "内蒙古", "银川": "宁夏", "南宁": "广西", "海口": "海南", "太原": "山西",
 }
 
+# 各城市真实市辖区（抽样用，每市取常见 2–3 个；县级市用街道）
+CITY_DISTRICTS = {
+    "北京": ["朝阳区", "海淀区", "东城区"], "上海": ["浦东新区", "徐汇区", "静安区"],
+    "天津": ["和平区", "南开区", "河西区"], "重庆": ["渝中区", "江北区", "沙坪坝区"],
+    "广州": ["天河区", "越秀区", "白云区"], "深圳": ["南山区", "福田区", "宝安区"],
+    "东莞": ["南城街道", "东城街道"], "佛山": ["禅城区", "南海区", "顺德区"],
+    "杭州": ["西湖区", "拱墅区", "滨江区"], "宁波": ["鄞州区", "海曙区", "江北区"],
+    "义乌": ["稠城街道", "北苑街道"], "温州": ["鹿城区", "瓯海区", "龙湾区"],
+    "南京": ["鼓楼区", "玄武区", "秦淮区"], "苏州": ["姑苏区", "吴中区", "相城区"],
+    "无锡": ["梁溪区", "滨湖区", "锡山区"], "武汉": ["江汉区", "武昌区", "洪山区"],
+    "长沙": ["岳麓区", "芙蓉区", "天心区"], "郑州": ["金水区", "二七区", "中原区"],
+    "西安": ["雁塔区", "碑林区", "未央区"], "成都": ["武侯区", "锦江区", "金牛区"],
+    "昆明": ["五华区", "盘龙区", "官渡区"], "贵阳": ["云岩区", "南明区", "观山湖区"],
+    "济南": ["历下区", "市中区", "槐荫区"], "青岛": ["市南区", "崂山区", "城阳区"],
+    "石家庄": ["长安区", "桥西区", "裕华区"], "沈阳": ["和平区", "沈河区", "铁西区"],
+    "大连": ["中山区", "西岗区", "甘井子区"], "哈尔滨": ["道里区", "南岗区", "香坊区"],
+    "长春": ["朝阳区", "南关区", "宽城区"], "福州": ["鼓楼区", "台江区", "仓山区"],
+    "厦门": ["思明区", "湖里区", "集美区"], "南昌": ["东湖区", "西湖区", "红谷滩区"],
+    "合肥": ["蜀山区", "庐阳区", "包河区"], "乌鲁木齐": ["天山区", "沙依巴克区", "新市区"],
+    "拉萨": ["城关区", "堆龙德庆区"], "兰州": ["城关区", "七里河区", "安宁区"],
+    "西宁": ["城中区", "城东区", "城西区"], "呼和浩特": ["新城区", "回民区", "赛罕区"],
+    "银川": ["兴庆区", "金凤区", "西夏区"], "南宁": ["青秀区", "兴宁区", "江南区"],
+    "海口": ["龙华区", "美兰区", "秀英区"], "太原": ["迎泽区", "小店区", "杏花岭区"],
+}
+
+# 省级行政区全称后缀（避免生成「宁夏省」「内蒙古省」）
+PROVINCE_FULL = {
+    "北京": "北京市", "上海": "上海市", "天津": "天津市", "重庆": "重庆市",
+    "内蒙古": "内蒙古自治区", "广西": "广西壮族自治区", "西藏": "西藏自治区",
+    "宁夏": "宁夏回族自治区", "新疆": "新疆维吾尔自治区",
+}
+
+
+def province_full(p: str) -> str:
+    return PROVINCE_FULL.get(p, p + "省")
+
+
 REMOTE_PROVINCES = {"新疆", "西藏", "青海", "内蒙古", "甘肃", "宁夏"}
 
 # 无向图：主要干线参考里程

logicllm/tools/pricing.py

@@ -9,9 +9,7 @@ SERVICE_MULT = {"标准快递": 1.0, "特快": 1.6, "经济": 0.8, "零担": 0.5
 
 
 def _zone(origin: str, dest: str) -> str:
-    po, pd = CITY_PROVINCE.get(origin), CITY_PROVINCE.get(dest)
-    if po is None or pd is None:
-        return "跨区"
+    po, pd = CITY_PROVINCE[origin], CITY_PROVINCE[dest]
     if po == pd:
         return "同省"
     d = distance_km(origin, dest) or 1500
@@ -39,6 +37,9 @@ def calc_freight(origin: str, destination: str, weight_kg: float, length_cm: flo
                  declared_value: float = 0):
     if service not in SERVICE_MULT:
         return {"error": f"不支持的服务类型 {service}", "supported": list(SERVICE_MULT)}
+    unknown = [c for c in (origin, destination) if c not in CITY_PROVINCE]
+    if unknown:
+        return {"error": f"未收录城市: {'、'.join(unknown)}（仅支持国内已开通城市）", "supported": sorted(CITY_PROVINCE)}
     vol_w = (length_cm * width_cm * height_cm) / VOLUME_DIVISOR if length_cm and width_cm and height_cm else 0
     bill_w = max(weight_kg, vol_w)
     import math
@@ -47,12 +48,16 @@ def calc_freight(origin: str, destination: str, weight_kg: float, length_cm: flo
     base = FIRST_KG[zone] + max(0, bill_w - 1) * ADD_KG[zone]
     base *= SERVICE_MULT[service]
     remote = 10.0 if CITY_PROVINCE.get(destination) in REMOTE_PROVINCES else 0.0
+    oversize = 30.0 if (weight_kg > 50 or max(length_cm, width_cm, height_cm) > 150) else 0.0
     insurance = max(1.0, declared_value * 0.005) if declared_value else 0.0
-    total = round(base + remote + insurance, 2)
+    total = round(base + remote + oversize + insurance, 2)
     return {
         "billable_weight_kg": bill_w, "volume_weight_kg": round(vol_w, 2), "zone": zone,
         "service": service, "base_fee": round(base, 2), "remote_surcharge": remote,
+        "oversize_surcharge": oversize,
         "insurance_fee": round(insurance, 2), "total_fee": total,
         "breakdown": f"首重{FIRST_KG[zone]}元 + 续重{max(0, bill_w-1)}kg×{ADD_KG[zone]}元，×{SERVICE_MULT[service]}({service})"
-                     + (f" + 偏远附加{remote}元" if remote else "") + (f" + 保价费{insurance:.2f}元" if insurance else ""),
+                     + (f" + 偏远附加{remote}元" if remote else "")
+                     + (f" + 超长超重操作费{oversize}元" if oversize else "")
+                     + (f" + 保价费{insurance:.2f}元" if insurance else ""),
     }

logicllm/tools/tms.py

@@ -0,0 +1,297 @@
+"""零担通 TMS 真实后端工具（TOOLS_BACKEND=tms 时启用，覆盖同名模拟工具）。
+
+对接本地「零担通 LTL GO Backend」（FastAPI，默认 http://127.0.0.1:8000）：
+- query_waybill / track_waybill / search_waybills / report_exception / waybill_status_counts
+- calc_freight → /pricing/trial-quote（真实报价引擎，按网点对计价）
+
+鉴权：手机号+密码登录 → 选租户 → Bearer token；401 时自动重登。
+环境变量：TMS_BASE_URL、TMS_PHONE、TMS_PASSWORD、TMS_TENANT（租户名）。
+"""
+from __future__ import annotations
+
+import os
+import threading
+import uuid
+
+import httpx
+
+from logicllm.tools import tool
+
+BASE = os.getenv("TMS_BASE_URL", "http://127.0.0.1:8000/api/v1").rstrip("/")
+PHONE = os.getenv("TMS_PHONE", "13800000001")
+PASSWORD = os.getenv("TMS_PASSWORD", "Dev@12345")
+TENANT = os.getenv("TMS_TENANT", "Dev Tenant")
+
+_lock = threading.Lock()
+_token: str | None = None
+
+STATUS_ZH = {
+    "draft": "草稿", "pending_confirmation": "待确认", "routed": "已排路由", "in_progress": "运输中",
+    "delivered": "已送达", "completed": "已完成", "archived": "已归档", "canceled": "已取消",
+    "rerouting": "改道中", "split": "已拆单", "returning": "退回中", "returned": "已退回",
+}
+EXC_CODE = {
+    "地址错误": "ADDRESS_ISSUE", "派送失败": "DELIVERY_FAILED", "拒收": "REFUSED", "破损": "DAMAGED",
+    "丢失": "LOST", "扣货": "DETAINED", "拦截": "INTERCEPTED", "揽收被拒": "PICKUP_REJECTED",
+    "超尺寸": "OVERSIZE", "超重": "OVERWEIGHT", "回单驳回": "POD_REVIEW_REJECTED",
+    "代收失败": "COD_COLLECTION_FAILED", "代收金额不符": "COD_AMOUNT_MISMATCH", "退货申请": "RETURN_REQUESTED",
+    "延误": "DELIVERY_FAILED", "其他": "DELIVERY_FAILED",
+}
+
+
+def _login() -> str:
+    r = httpx.post(f"{BASE}/auth/login", json={"phone": PHONE, "password": PASSWORD}, timeout=15)
+    r.raise_for_status()
+    d = r.json()
+    if d.get("access_token"):
+        return d["access_token"]
+    comps = d.get("companies") or []
+    comp = next((c for c in comps if c["tenant_name"] == TENANT), comps[0] if comps else None)
+    if not comp:
+        raise RuntimeError("TMS 登录成功但无可用租户")
+    r = httpx.post(f"{BASE}/auth/select-tenant", json={"ticket": d["ticket"], "tenant_id": comp["tenant_id"]}, timeout=15)
+    r.raise_for_status()
+    return r.json()["access_token"]
+
+
+def _req(method: str, path: str, **kw) -> httpx.Response:
+    global _token
+    with _lock:
+        if _token is None:
+            _token = _login()
+        tok = _token
+    def _headers(t: str) -> dict:
+        h = {"Authorization": f"Bearer {t}"}
+        if method.upper() in ("POST", "PUT", "PATCH", "DELETE"):
+            h["X-Idempotency-Key"] = str(uuid.uuid4())
+        return h
+
+    r = httpx.request(method, f"{BASE}{path}", headers=_headers(tok), timeout=30, **kw)
+    if r.status_code == 401:
+        with _lock:
+            _token = _login()
+            tok = _token
+        r = httpx.request(method, f"{BASE}{path}", headers=_headers(tok), timeout=30, **kw)
+    return r
+
+
+def _api(method: str, path: str, **kw) -> dict | list:
+    r = _req(method, path, **kw)
+    if r.status_code >= 400:
+        try:
+            err = r.json()
+        except ValueError:
+            err = r.text[:200]
+        return {"error": f"TMS 接口 {path} 返回 {r.status_code}", "detail": err}
+    return r.json() if r.text else {}
+
+
+def _items(res) -> tuple[list, int]:
+    """兼容 {data, pagination} 与 {items, total} 两种列表响应。"""
+    if isinstance(res, list):
+        return res, len(res)
+    items = res.get("data") or res.get("items") or []
+    pg = res.get("pagination") or {}
+    total = pg.get("total") or res.get("total") or len(items)
+    return items, total
+
+
+def _brief(w: dict) -> dict:
+    return {
+        "waybill_no": w.get("waybill_no"), "status": STATUS_ZH.get(w.get("status"), w.get("status")),
+        "origin_site": w.get("origin_site_name") or w.get("origin_site_id"),
+        "destination_site": w.get("destination_site_name") or w.get("destination_site_id"),
+        "customer": w.get("customer_name_snapshot"),
+        "receiver": (w.get("destination_address") or {}).get("contact"),
+        "items": w.get("items_summary"), "payment_type": w.get("payment_type"),
+        "receivable_amount": w.get("receivable_amount"), "created_at": w.get("created_at"),
+    }
+
+
+def _find_waybill(waybill_no: str) -> dict | None:
+    res = _api("GET", "/waybills", params={"keyword": waybill_no.strip(), "page_size": 5})
+    if isinstance(res, dict) and res.get("error"):
+        return res
+    items, _ = _items(res)
+    exact = [w for w in items if w.get("waybill_no") == waybill_no.strip()]
+    return (exact or items or [None])[0]
+
+
+@tool(
+    "query_waybill",
+    "按运单号查询 TMS 系统中的运单详情（起止网点、客户、货物、费用、当前状态）。",
+    {"type": "object", "properties": {"waybill_no": {"type": "string", "description": "运单号"}},
+     "required": ["waybill_no"]},
+)
+def query_waybill(waybill_no: str):
+    w = _find_waybill(waybill_no)
+    if not w:
+        return {"error": f"未找到运单 {waybill_no}"}
+    if w.get("error"):
+        return w
+    detail = _api("GET", f"/waybills/{w['id']}")
+    if isinstance(detail, dict) and not detail.get("error"):
+        w = {**w, **{k: v for k, v in detail.items() if v is not None}}
+    out = _brief(w)
+    out["is_cod"] = w.get("is_cod")
+    out["fee_breakdown"] = w.get("fee_breakdown")
+    return out
+
+
+@tool(
+    "track_waybill",
+    "查询运单的全程时间线/物流轨迹（TMS 系统真实事件）。",
+    {"type": "object", "properties": {"waybill_no": {"type": "string"}}, "required": ["waybill_no"]},
+)
+def track_waybill(waybill_no: str):
+    w = _find_waybill(waybill_no)
+    if not w or w.get("error"):
+        return w or {"error": f"未找到运单 {waybill_no}"}
+    tl = _api("GET", f"/waybills/{w['id']}/timeline")
+    if isinstance(tl, dict) and tl.get("error"):
+        return tl
+    events = tl if isinstance(tl, list) else tl.get("items") or tl.get("events") or []
+    slim = []
+    for e in events[-20:]:
+        slim.append({k: e.get(k) for k in ("event_at", "occurred_at", "created_at", "ulsc_code", "event_type", "title", "site_name", "notes", "description") if e.get(k) is not None})
+    return {"waybill_no": w.get("waybill_no"), "status": STATUS_ZH.get(w.get("status"), w.get("status")), "events": slim}
+
+
+@tool(
+    "search_waybills",
+    "按关键词（客户名/电话/运单号片段）或状态搜索运单列表。",
+    {"type": "object", "properties": {
+        "keyword": {"type": "string", "description": "关键词，可选"},
+        "phone": {"type": "string", "description": "寄/收件人手机号，可选"},
+        "name": {"type": "string", "description": "寄/收件人或客户姓名，可选"},
+        "status": {"type": "string", "enum": list(STATUS_ZH.values()), "description": "运单状态，可选"},
+    }},
+)
+def search_waybills(keyword: str = "", status: str = "", phone: str = "", name: str = ""):
+    keyword = keyword or phone or name  # 兼容微调数据里的 phone/name 参数习惯
+    params: dict = {"page_size": 10}
+    if keyword:
+        params["keyword"] = keyword
+    if status:
+        rev = {v: k for k, v in STATUS_ZH.items()}
+        params["status"] = rev.get(status, status)
+    res = _api("GET", "/waybills", params=params)
+    if isinstance(res, dict) and res.get("error"):
+        return res
+    items, total = _items(res)
+    return {"total": total, "waybills": [_brief(w) for w in items]}
+
+
+@tool(
+    "waybill_status_counts",
+    "统计当前各状态的运单数量（运营概览）。",
+    {"type": "object", "properties": {}},
+)
+def waybill_status_counts():
+    res = _api("GET", "/waybills/status-counts")
+    if isinstance(res, dict) and res.get("error"):
+        return res
+    counts = res.get("counts") or res
+    if isinstance(counts, dict):
+        return {STATUS_ZH.get(k, k): v for k, v in counts.items() if isinstance(v, int)}
+    return counts
+
+
+@tool(
+    "report_exception",
+    "为运单在 TMS 中登记异常工单。type 可选：破损/丢失/地址错误/拒收/派送失败/扣货/超重/超尺寸/延误/其他。",
+    {"type": "object", "properties": {
+        "waybill_no": {"type": "string"},
+        "type": {"type": "string", "enum": list(EXC_CODE)},
+        "description": {"type": "string"},
+    }, "required": ["waybill_no", "type"]},
+)
+def report_exception(waybill_no: str, type: str, description: str = ""):
+    w = _find_waybill(waybill_no)
+    if not w or w.get("error"):
+        return w or {"error": f"未找到运单 {waybill_no}"}
+    body = {"waybill_id": w["id"], "code": EXC_CODE.get(type, "DELIVERY_FAILED"),
+            "severity": "high" if type in ("丢失", "破损") else "medium", "note": description or type}
+    res = _api("POST", "/exceptions", json=body)
+    if isinstance(res, dict) and res.get("error"):
+        return res
+    return {"exception_id": res.get("id"), "waybill_no": w.get("waybill_no"), "code": body["code"],
+            "status": res.get("status", "open"), "note": "已登记异常工单，运营会在工作台跟进处理"}
+
+
+def _all_sites() -> list | dict:
+    res = _api("GET", "/sites", params={"page_size": 100})
+    if isinstance(res, dict) and res.get("error"):
+        return res
+    sites = [s for s in _items(res)[0] if s.get("status") in (None, "active")]
+    # 名称去重（环境残留的重复网点取最早创建的一个）
+    seen: dict = {}
+    for s2 in sorted(sites, key=lambda x: x.get("created_at") or ""):
+        seen.setdefault(s2.get("name"), s2)
+    return list(seen.values())
+
+
+def _find_site(name: str) -> dict | None:
+    sites = _all_sites()
+    if isinstance(sites, dict):
+        return sites
+    q = name.strip()
+    exact = [s for s in sites if s.get("name") == q]
+    if exact:
+        return exact[0]
+    sub = [s for s in sites if q in s.get("name", "") or s.get("name", "") in q]
+    if len(sub) == 1:
+        return sub[0]
+    # 模糊：去掉「网点/站/仓」后缀，按城市/关键词包含匹配
+    core = q.replace("网点", "").replace("营业部", "").replace("站", "").replace("仓", "")
+    fuzzy = [s for s in sites if core and core in s.get("name", "")]
+    if len(fuzzy) == 1:
+        return fuzzy[0]
+    if len(fuzzy) > 1:
+        return {"error": f"网点「{name}」有多个匹配，请让用户确认", "candidates": [s["name"] for s in fuzzy]}
+    return None
+
+
+@tool(
+    "calc_freight",
+    "用 TMS 报价引擎试算两个网点之间的零担运费。origin/destination 传网点名称（如 杭州网点）。",
+    {"type": "object", "properties": {
+        "origin": {"type": "string", "description": "起运网点名称"},
+        "destination": {"type": "string", "description": "目的网点名称"},
+        "weight_kg": {"type": "number"},
+        "volume_m3": {"type": "number", "description": "体积方数，可选"},
+        "piece_count": {"type": "integer", "description": "件数，可选"},
+        "declared_value": {"type": "number", "description": "声明价值，可选"},
+    }, "required": ["origin", "destination", "weight_kg"]},
+)
+def calc_freight(origin: str, destination: str, weight_kg: float, volume_m3: float | None = None,
+                 piece_count: int | None = None, declared_value: float | None = None):
+    fs, ts = _find_site(origin), _find_site(destination)
+    if not fs or fs.get("error") or not ts or ts.get("error"):
+        bad = fs if (not fs or fs.get("error")) else ts
+        if bad and bad.get("error"):
+            return bad
+        sites = _all_sites()
+        names = [s["name"] for s in sites] if isinstance(sites, list) else []
+        return {"error": f"未找到网点「{origin if not fs or fs.get('error') else destination}」",
+                "available_sites": names, "hint": "请用 available_sites 里的准确名称重新调用 calc_freight"}
+    body: dict = {"from_site_id": fs["id"], "to_site_id": ts["id"], "weight_kg": str(weight_kg)}
+    if volume_m3:
+        body["volume_m3"] = str(volume_m3)
+    if piece_count:
+        body["piece_count"] = piece_count
+    if declared_value:
+        body["declared_value"] = str(declared_value)
+    res = _api("POST", "/pricing/trial-quote", json=body)
+    if isinstance(res, dict) and res.get("error"):
+        return res
+    # 映射成模型熟悉的字段：total_fee 为最终应收，breakdown 为明细说明
+    parts = "；".join(f"{b.get('label')} {b.get('amount')} 元" for b in res.get("breakdown") or [])
+    return {
+        "from_site": fs["name"], "to_site": ts["name"],
+        "billable_weight_kg": weight_kg, "volume_m3": volume_m3,
+        "product": res.get("applied_product_name"),
+        "total_fee": float(res.get("total") or res.get("discounted_freight") or 0),
+        "breakdown": parts or f"运费 {res.get('total')} 元",
+        "note": "以上为 TMS 报价引擎试算结果，请直接引用 total_fee，不要自行按首重续重公式重算",
+    }

logicllm/tools/waybill.py

@@ -22,6 +22,7 @@ def _conn():
 
 
 def init_db(seed: int = 42, n: int = 60):
+    from logicllm.tools.pricing import calc_freight as _calc
     config.DATA_DIR.mkdir(exist_ok=True)
     c = _conn()
     c.executescript("""
@@ -42,17 +43,22 @@ def init_db(seed: int = 42, n: int = 60):
     names = ["张伟", "王芳", "李娜", "刘强", "陈静", "杨洋", "赵磊", "黄敏", "周杰", "吴丹"]
     cities = list(CITY_PROVINCE)
     for i in range(n):
+        # 注意保持随机数取用顺序与最初版本一致，确保演示运单号（如 LL2026080258）稳定
         no = f"LL{20260800 + i:08d}{rnd.randint(10, 99)}"
         o, d = rnd.sample(cities, 2)
         stage = rnd.randint(0, 4)
         created = datetime(2026, 8, rnd.randint(10, 21), rnd.randint(8, 20))
         w = round(rnd.uniform(0.3, 25), 1)
+        sender, sender_phone = rnd.choice(names), f"13{rnd.randint(100000000, 999999999)}"
+        receiver, receiver_phone = rnd.choice(names), f"15{rnd.randint(100000000, 999999999)}"
+        addr = f"{d}市某某区某某路{rnd.randint(1, 500)}号"
+        svc = rnd.choice(["标准快递", "特快", "经济"])
+        dv = rnd.choice([0, 0, 500, 2000])
+        exc = "" if rnd.random() > 0.12 else rnd.choice(["地址不详", "电话无人接听", "包裹破损"])
+        fee = _calc(o, d, w, service=svc, declared_value=dv)["total_fee"]  # 统一计费引擎，与 calc_freight 一致
         c.execute("INSERT INTO waybill VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)", (
-            no, rnd.choice(names), f"13{rnd.randint(100000000, 999999999)}", o,
-            rnd.choice(names), f"15{rnd.randint(100000000, 999999999)}", d,
-            f"{d}市某某区某某路{rnd.randint(1, 500)}号", w, rnd.choice(["标准快递", "特快", "经济"]),
-            round(10 + w * 4, 1), STATUS_FLOW[stage], created.isoformat(timespec="minutes"),
-            rnd.choice([0, 0, 500, 2000]), "" if rnd.random() > 0.12 else rnd.choice(["地址不详", "电话无人接听", "包裹破损"]),
+            no, sender, sender_phone, o, receiver, receiver_phone, d, addr, w, svc,
+            fee, STATUS_FLOW[stage], created.isoformat(timespec="minutes"), dv, exc,
         ))
         ts = created
         locs = [o, o + "转运中心", "干线运输", d + "转运中心", d]

scripts/check_adapter.py

@@ -1,4 +1,6 @@
 """离线对比：不带 / 带 LoRA 时，模型对同一个问题的输出。训练后先跑这个，确认 adapter 真的生效再上线。"""
+import os
+
 from mlx_lm import load, generate
 from logicllm.agent.prompts import build_system, openai_tools
 from logicllm.tools import all_specs
@@ -6,6 +8,8 @@ from logicllm.tools import all_specs
 msgs = [{"role": "system", "content": build_system()},
         {"role": "user", "content": "提取收件信息：收件人王小明 13812345678 浙江省杭州市西湖区文三路123号5楼"}]
 for adapter in [None, "adapters/logistics-lora"]:
-    model, tok = load("mlx-community/Qwen2.5-7B-Instruct-4bit", adapter_path=adapter)
-    prompt = tok.apply_chat_template(msgs, tools=openai_tools(all_specs()), add_generation_prompt=True)
+    base = os.getenv("BASE_MODEL", "mlx-community/Qwen3-14B-4bit")
+    model, tok = load(base, adapter_path=adapter)
+    kw = {"enable_thinking": False} if "enable_thinking" in str(getattr(tok, "chat_template", "")) else {}
+    prompt = tok.apply_chat_template(msgs, tools=openai_tools(all_specs()), add_generation_prompt=True, **kw)
     print("便签本:", adapter, "→", generate(model, tok, prompt=prompt, max_tokens=120, verbose=False)[:150], "\n")

scripts/eval.py

@@ -22,13 +22,24 @@ def score(case: dict, answer: str, steps: list) -> tuple[float, str]:
     if "expect_tool" in case:
         if case["expect_tool"] not in tools_called:
             ok = 0.0; notes.append(f"未调用 {case['expect_tool']} (实际 {tools_called})")
+    if "expect_tools" in case:  # 多个工具都必须被调用
+        miss_t = [t for t in case["expect_tools"] if t not in tools_called]
+        if miss_t:
+            ok = 0.0; notes.append(f"未调用 {miss_t} (实际 {tools_called})")
     if "expect_no_tool" in case and tools_called:
         ok = 0.0; notes.append(f"不应调用工具，实际 {tools_called}")
+    norm = answer.replace(" ", "")
     if "keywords" in case:
-        norm = answer.replace(" ", "")
         miss = [k for k in case["keywords"] if k.replace(" ", "") not in norm]
         if miss:
             ok = min(ok, 1 - len(miss) / len(case["keywords"])); notes.append(f"缺关键词 {miss}")
+    if "keywords_any" in case:  # 命中其一即可
+        if not any(k.replace(" ", "") in norm for k in case["keywords_any"]):
+            ok = 0.0; notes.append(f"任一关键词均未命中 {case['keywords_any']}")
+    if "forbid" in case:  # 出现即零分（用于臆测/编造检查）
+        hit = [k for k in case["forbid"] if k.replace(" ", "") in norm]
+        if hit:
+            ok = 0.0; notes.append(f"出现禁用词 {hit}")
     if "expect_json" in case:
         m = re.search(r"\{.*\}", answer, re.S)
         try:
@@ -47,7 +58,8 @@ async def main():
     ap.add_argument("--no-rag", action="store_true")
     ap.add_argument("--limit", type=int, default=0)
     a = ap.parse_args()
-    cases = [json.loads(l) for l in CASES.read_text(encoding="utf-8").splitlines() if l.strip()]
+    cases = [json.loads(l) for l in CASES.read_text(encoding="utf-8").splitlines()
+             if l.strip() and not l.strip().startswith("//")]
     if a.limit:
         cases = cases[:a.limit]
     agent = LogisticsAgent(use_tools=not a.no_tools, use_rag=not a.no_rag)
@@ -56,14 +68,21 @@ async def main():
     t0 = time.time()
     for i, c in enumerate(cases, 1):
         try:
-            res = await agent.run([{"role": "user", "content": c["q"]}])
-            s, note = score(c, res.answer, res.steps)
+            turns = c.get("turns") or [c["q"]]
+            history, steps_all = [], []
+            for t in turns:
+                history.append({"role": "user", "content": t})
+                res = await agent.run(history)
+                history.append({"role": "assistant", "content": res.answer})
+                steps_all.extend(res.steps)
+            s, note = score(c, res.answer, steps_all)
         except Exception as e:  # noqa: BLE001
             s, note, res = 0.0, f"异常 {e}", None
         total += s
         by_cat.setdefault(c["cat"], []).append(s)
         flag = "✅" if s >= 0.99 else ("🟡" if s > 0 else "❌")
-        print(f"{flag} [{c['cat']}] {c['q'][:40]}  {s:.2f}  {note}")
+        qshow = c.get("q") or " ▸ ".join(c.get("turns", []))
+        print(f"{flag} [{c['cat']}] {qshow[:44]}  {s:.2f}  {note}")
     print(f"\n总分 {total / len(cases):.3f}  用时 {time.time() - t0:.0f}s")
     for k, v in by_cat.items():
         print(f"  {k}: {sum(v) / len(v):.3f} ({len(v)})")

scripts/fuse.sh

@@ -3,6 +3,6 @@
 # ⚠️ 实测直接合并进 4bit 量化基座会让 LoRA 失效，必须 --de-quantize 得到 fp16 模型（约 15GB）。
 set -euo pipefail
 cd "$(dirname "$0")/.."
-BASE=${BASE_MODEL:-mlx-community/Qwen2.5-7B-Instruct-4bit}
+BASE=${BASE_MODEL:-mlx-community/Qwen3-14B-4bit}
 uv run python -m mlx_lm fuse --model "$BASE" --adapter-path adapters/logistics-lora --save-path models/logistics-qwen-7b-fp16 --de-quantize
 echo "已合并 → models/logistics-qwen-7b-fp16（fp16）"

scripts/gen_sft.py

@@ -22,7 +22,7 @@ from logicllm.agent.prompts import build_system, openai_tools
 from logicllm.llm.client import ChatClient
 from logicllm.rag.kb import split_markdown
 from logicllm.tools import all_specs, call_tool
-from logicllm.tools.geo import CITY_PROVINCE
+from logicllm.tools.geo import CITY_PROVINCE, CITY_DISTRICTS, province_full
 from logicllm.tools.waybill import init_db, _conn
 
 OUT = config.DATA_DIR / "sft"
@@ -109,6 +109,29 @@ async def gen_kb(n: int, client: ChatClient) -> list[dict]:
 
 
 # ---------- 2. 客服 + 工具调用 ----------
+NO_SVC_NOTE = "您未指明服务类型，按默认的标准快递计算（如需特快/经济请告诉我）。\n"
+EXC_TIPS = {"破损": "请保留外包装并拍照（外包装+内件），如已保价按声明价值赔付，未保价按实际损失赔付，上限为运费 3 倍。",
+            "丢失": "轨迹停更超过 7 天可认定丢失；未保价按运费 3 倍赔偿（最高 300 元）并退还运费，已保价按声明价值赔付。",
+            "延误": "特快超承诺时效 1 天以上可退还特快与标准快递的差价。",
+            "地址错误": "派送前可联系修改，同城免费；跨城需补差价。"}
+
+
+def _query_answer(no: str, res: dict) -> str:
+    exc = f"，当前标记有异常「{res['exception']}」，我们会尽快处理" if res.get("exception") else ""
+    return (f"运单 {no} 的情况如下：\n- 路线：{res['origin']} → {res['destination']}\n- 服务：{res['service']}，重量 {res['weight_kg']}kg，运费 {res['fee']} 元\n"
+            f"- 当前状态：**{res['status']}**{exc}\n- 下单时间：{res['created_at'].replace('T', ' ')}\n如需查看详细轨迹，我可以继续为您查询。")
+
+
+def _freight_answer(o: str, d: str, w: float, res: dict) -> str:
+    return (f"{o} → {d}（{res['zone']}），计费重量 {res['billable_weight_kg']}kg"
+            + (f"（体积重 {res['volume_weight_kg']}kg 大于实重）" if res["volume_weight_kg"] > w else "")
+            + f"：\n- {res['breakdown']}\n- **合计 {res['total_fee']} 元**")
+
+
+def _exception_answer(no: str, typ: str, res: dict) -> str:
+    return f"非常抱歉给您带来不便。已为运单 {no} 登记「{typ}」异常，工单号 **{res['ticket_no']}**，客服将在 48 小时内回访处理。\n{EXC_TIPS[typ]}"
+
+
 async def gen_tool(n: int) -> list[dict]:
     init_db()
     c = _conn()
@@ -116,17 +139,15 @@ async def gen_tool(n: int) -> list[dict]:
     c.close()
     out = []
     for _ in range(n):
-        kind = rnd.choice(["query", "track", "freight", "eta", "search", "exception", "ask_no", "create"])
+        kind = rnd.choice(["query", "track", "freight", "eta", "search", "exception", "ask_no", "create",
+                           "combo", "followup_svc", "ask_then_no", "complain_then_no"])
         if kind == "query":
             w = rnd.choice(wbs)
             u = rnd.choice([f"帮我查一下运单 {w['no']}", f"{w['no']} 这个单子现在什么情况", f"查询 {w['no']}", f"我的快递 {w['no']} 到哪了"])
             call = {"name": "query_waybill", "arguments": {"waybill_no": w["no"]}}
             res = await call_tool(**{"name": call["name"], "args": call["arguments"]})
-            exc = f"，当前标记有异常「{res['exception']}」，我们会尽快处理" if res.get("exception") else ""
-            a = (f"运单 {w['no']} 的情况如下：\n- 路线：{res['origin']} → {res['destination']}\n- 服务：{res['service']}，重量 {res['weight_kg']}kg，运费 {res['fee']} 元\n"
-                 f"- 当前状态：**{res['status']}**{exc}\n- 下单时间：{res['created_at'].replace('T', ' ')}\n如需查看详细轨迹，我可以继续为您查询。")
             out.append(sample(SYSTEM_TOOLS, [{"role": "user", "content": u}, tc(call),
-                                             tr(res), {"role": "assistant", "content": a}]))
+                                             tr(res), {"role": "assistant", "content": _query_answer(w["no"], res)}]))
         elif kind == "track":
             w = rnd.choice(wbs)
             u = rnd.choice([f"{w['no']} 的物流轨迹", f"看看 {w['no']} 的运输记录", f"运单{w['no']}现在在哪个环节"])
@@ -157,18 +178,19 @@ async def gen_tool(n: int) -> list[dict]:
             utxt += (f"，{svc}" if svc_in_text else "") + rnd.choice(["多少钱？", "运费怎么算？", "要花多少运费"])
             call = {"name": "calc_freight", "arguments": args}
             res = await call_tool(call["name"], call["arguments"])
-            a = ("" if svc_in_text else "您未指明服务类型，按默认的标准快递计算（如需特快/经济请告诉我）。\n") + (f"{o} → {d}（{res['zone']}），计费重量 {res['billable_weight_kg']}kg"
-                 + (f"（体积重 {res['volume_weight_kg']}kg 大于实重）" if res["volume_weight_kg"] > w else "")
-                 + f"：\n- {res['breakdown']}\n- **合计 {res['total_fee']} 元**")
+            a = ("" if svc_in_text else NO_SVC_NOTE) + _freight_answer(o, d, w, res)
             out.append(sample(SYSTEM_TOOLS, [{"role": "user", "content": utxt}, tc(call),
                                              tr(res), {"role": "assistant", "content": a}]))
         elif kind == "eta":
             o, d = rnd.sample(list(CITY_PROVINCE), 2)
             svc = rnd.choice(["标准快递", "特快", "经济"])
-            u = rnd.choice([f"{o}到{d}{svc}几天能到？", f"今天从{o}发{svc}到{d}，什么时候到", f"{o}寄{d}要多久"])
+            svc_in_text = rnd.random() > 0.35
+            if not svc_in_text:
+                svc = "标准快递"  # 用户未指明时不得臆测，按默认标准快递并说明
+            u = rnd.choice([f"{o}到{d}{svc}几天能到？", f"今天从{o}发{svc}到{d}，什么时候到"]) if svc_in_text else rnd.choice([f"{o}寄{d}要多久", f"{o}到{d}几天能到"])
             call = {"name": "estimate_eta", "arguments": {"origin": o, "destination": d, "service": svc}}
             res = await call_tool(call["name"], call["arguments"])
-            a = f"{o} → {d} 约 {res['distance_km']}km，{svc}预计 **{res['est_days']} 天**送达（约 {res['est_delivery_date']}）。" + (f"{res['note']}。" if res["note"] else "") + "实际以揽收后轨迹为准，恶劣天气可能延误。"
+            a = ("" if svc_in_text else "按默认的标准快递估算（特快可再快 1 天）：") + f"{o} → {d} 约 {res['distance_km']}km，{svc}预计 **{res['est_days']} 天**送达（约 {res['est_delivery_date']}）。" + (f"{res['note']}。" if res["note"] else "") + "实际以揽收后轨迹为准，恶劣天气可能延误。"
             out.append(sample(SYSTEM_TOOLS, [{"role": "user", "content": u}, tc(call),
                                              tr(res), {"role": "assistant", "content": a}]))
         elif kind == "search":
@@ -187,17 +209,70 @@ async def gen_tool(n: int) -> list[dict]:
             u = rnd.choice([f"运单 {w['no']} 收到时外箱{typ}了，要投诉", f"{w['no']} {typ}，怎么处理", f"我要给 {w['no']} 登记{typ}"])
             call = {"name": "report_exception", "arguments": {"waybill_no": w["no"], "type": typ, "description": f"用户反馈{typ}"}}
             res = await call_tool(call["name"], call["arguments"])
-            tip = {"破损": "请保留外包装并拍照（外包装+内件），如已保价按声明价值赔付，未保价按实际损失赔付，上限为运费 3 倍。",
-                   "丢失": "轨迹停更超过 7 天可认定丢失；未保价按运费 3 倍赔偿（最高 300 元）并退还运费，已保价按声明价值赔付。",
-                   "延误": "特快超承诺时效 1 天以上可退还特快与标准快递的差价。",
-                   "地址错误": "派送前可联系修改，同城免费；跨城需补差价。"}[typ]
-            a = f"非常抱歉给您带来不便。已为运单 {w['no']} 登记「{typ}」异常，工单号 **{res['ticket_no']}**，客服将在 48 小时内回访处理。\n{tip}"
             out.append(sample(SYSTEM_TOOLS, [{"role": "user", "content": u}, tc(call),
-                                             tr(res), {"role": "assistant", "content": a}]))
+                                             tr(res), {"role": "assistant", "content": _exception_answer(w["no"], typ, res)}]))
         elif kind == "ask_no":
             u = rnd.choice(["我的快递到哪了？", "帮我查下快递", "我的包裹怎么还没到", "查一下物流"])
             a = "好的，请提供您的运单号（LL 开头的 12 位编号），或者告诉我寄/收件人手机号，我来帮您查询。"
             out.append(sample(SYSTEM_TOOLS, [{"role": "user", "content": u}, {"role": "assistant", "content": a}]))
+        elif kind == "combo":  # 一句话同时问运费和时效：两个工具都要调，先算钱再算时效
+            o, d = rnd.sample(list(CITY_PROVINCE), 2)
+            item, w = rnd.choice(ITEMS)
+            w = round(w * rnd.uniform(0.6, 3.0), 1)
+            svc = rnd.choice(["标准快递", "特快", "经济"])
+            svc_in_text = rnd.random() > 0.4
+            if not svc_in_text:
+                svc = "标准快递"
+            svc_txt = f"{svc}" if svc_in_text else ""
+            u = rnd.choice([f"{o}寄{w}公斤{item}到{d}，{svc_txt}多少钱几天能到", f"从{o}发{item}到{d}，{w}kg，{svc_txt}运费和时效分别是多少",
+                            f"{o}到{d} {w}kg {item}，{svc_txt}要多少钱、什么时候能到"])
+            c1 = {"name": "calc_freight", "arguments": {"origin": o, "destination": d, "weight_kg": w, "service": svc}}
+            r1 = await call_tool(c1["name"], c1["arguments"])
+            c2 = {"name": "estimate_eta", "arguments": {"origin": o, "destination": d, "service": svc}}
+            r2 = await call_tool(c2["name"], c2["arguments"])
+            a = (("" if svc_in_text else NO_SVC_NOTE) + f"{o} → {d}（{r1['zone']}），计费重量 {r1['billable_weight_kg']}kg：\n"
+                 f"- 运费：{r1['breakdown']}，**合计 {r1['total_fee']} 元**\n"
+                 f"- 时效：约 {r2['distance_km']}km，{svc}预计 **{r2['est_days']} 天**送达（约 {r2['est_delivery_date']}）" + (f"，{r2['note']}" if r2["note"] else "")
+                 + "\n实际以揽收后轨迹为准。")
+            out.append(sample(SYSTEM_TOOLS, [{"role": "user", "content": u}, tc(c1), tr(r1), tc(c2), tr(r2), {"role": "assistant", "content": a}]))
+        elif kind == "followup_svc":  # 多轮：先按默认标准快递报价，追问换服务类型要重新调工具
+            o, d = rnd.sample(list(CITY_PROVINCE), 2)
+            item, w = rnd.choice(ITEMS)
+            w = round(w * rnd.uniform(0.6, 2.5), 1)
+            u1 = rnd.choice([f"从{o}寄{w}公斤{item}到{d}多少钱？", f"{o}到{d}，{item} {w}kg，运费多少"])
+            r1 = await call_tool("calc_freight", {"origin": o, "destination": d, "weight_kg": w, "service": "标准快递"})
+            a1 = NO_SVC_NOTE + _freight_answer(o, d, w, r1)
+            new_svc = rnd.choice(["特快", "经济"])
+            u2 = rnd.choice([f"改成{new_svc}呢？", f"{new_svc}多少钱", f"换{new_svc}的话", f"那{new_svc}要多少"])
+            c2 = {"name": "calc_freight", "arguments": {"origin": o, "destination": d, "weight_kg": w, "service": new_svc}}
+            r2 = await call_tool(c2["name"], c2["arguments"])
+            diff = round(r2["total_fee"] - r1["total_fee"], 2)
+            a2 = (f"换成{new_svc}的话，{o} → {d}，计费重量 {r2['billable_weight_kg']}kg：\n- {r2['breakdown']}\n- **合计 {r2['total_fee']} 元**"
+                  + (f"，比标准快递贵 {diff} 元" if diff > 0 else f"，比标准快递便宜 {-diff} 元") + "。")
+            # 历史轮次只保留最终答复文本（与线上会话历史一致，不含工具轨迹）
+            out.append(sample(SYSTEM_TOOLS, [{"role": "user", "content": u1}, {"role": "assistant", "content": a1},
+                                             {"role": "user", "content": u2}, tc(c2), tr(r2), {"role": "assistant", "content": a2}]))
+        elif kind == "ask_then_no":  # 多轮：先没给单号，追问后给了单号再查
+            w = rnd.choice(wbs)
+            u1 = rnd.choice(["帮我查个运单", "查一下我的快递", "我想查物流", "帮我看看包裹到哪了"])
+            a1 = "好的，请提供您的运单号（LL 开头的 12 位编号），或者告诉我寄/收件人手机号，我来帮您查询。"
+            u2 = rnd.choice([w["no"], f"运单号是 {w['no']}", f"{w['no']}，麻烦了", f"单号 {w['no']}"])
+            call = {"name": "query_waybill", "arguments": {"waybill_no": w["no"]}}
+            res = await call_tool(call["name"], call["arguments"])
+            out.append(sample(SYSTEM_TOOLS, [{"role": "user", "content": u1}, {"role": "assistant", "content": a1},
+                                             {"role": "user", "content": u2}, tc(call), tr(res), {"role": "assistant", "content": _query_answer(w["no"], res)}]))
+        elif kind == "complain_then_no":  # 多轮：先描述问题，再给单号登记异常
+            w = rnd.choice(wbs)
+            typ = rnd.choice(["破损", "丢失", "延误"])
+            u1 = {"破损": rnd.choice(["我的快递收到的时候摔坏了，怎么办", "包裹外箱破了，里面东西也坏了"]),
+                  "丢失": rnd.choice(["我的快递好多天没动静了，是不是丢了", "包裹一直不更新物流，怎么办"]),
+                  "延误": rnd.choice(["我寄的特快已经超时了还没到", "快递比承诺时间晚了两天了"])}[typ]
+            a1 = f"{EXC_TIPS[typ]}\n请提供运单号，我帮您登记「{typ}」异常工单，客服会在 48 小时内回访。"
+            u2 = rnd.choice([f"运单号是 {w['no']}，帮我登记投诉", f"{w['no']}，麻烦登记一下", f"单号 {w['no']}，要投诉"])
+            call = {"name": "report_exception", "arguments": {"waybill_no": w["no"], "type": typ, "description": f"用户反馈{typ}"}}
+            res = await call_tool(call["name"], call["arguments"])
+            out.append(sample(SYSTEM_TOOLS, [{"role": "user", "content": u1}, {"role": "assistant", "content": a1},
+                                             {"role": "user", "content": u2}, tc(call), tr(res), {"role": "assistant", "content": _exception_answer(w["no"], typ, res)}]))
         else:  # create
             o, d = rnd.sample(list(CITY_PROVINCE), 2)
             s, r = rnd.sample(NAMES, 2)
@@ -222,13 +297,13 @@ def gen_extract(n: int) -> list[dict]:
     from logicllm.tools.address import parse_address
     out = []
     for _ in range(n):
-        city = rnd.choice(list(CITY_PROVINCE))
+        city = rnd.choice(list(CITY_DISTRICTS))
         prov = CITY_PROVINCE[city]
         name = rnd.choice(NAMES)
         phone = f"1{rnd.choice('3589')}{rnd.randint(100000000, 999999999)}"
-        dist = rnd.choice(["高新区", "朝阳区", "西湖区", "南山区", "武侯区", "江汉区", "历下区", "鼓楼区"])
+        dist = rnd.choice(CITY_DISTRICTS[city])
         detail = f"{rnd.choice(STREETS)}{rnd.randint(1, 500)}号{rnd.choice(['', '3栋2单元501', 'A座1201', '科技园T3栋'])}"
-        provtxt = "" if prov == city else rnd.choice([f"{prov}省", prov, ""])
+        provtxt = "" if prov == city else rnd.choice([province_full(prov), prov, ""])
         citytxt = f"{city}市" if rnd.random() < 0.7 else city
         item, w = rnd.choice(ITEMS)
         layout = rnd.choice([
@@ -281,12 +356,68 @@ async def gen_route(n: int) -> list[dict]:
     return out
 
 
+# ---------- 5. 失败与边界轨迹 ----------
+async def gen_failures(n: int) -> list[dict]:
+    init_db()
+    out = []
+    unknown_cities = ["洛阳", "三亚", "桂林", "唐山", "襄阳", "赣州", "遵义", "绵阳"]
+    foreign_cities = ["纽约", "伦敦", "东京", "洛杉矶", "新加坡", "巴黎", "首尔", "悉尼"]
+    for _ in range(n):
+        kind = rnd.choice(["bad_no", "bad_no_track", "bad_city_eta", "bad_city_freight", "bad_city_route", "no_result_phone", "intl_freight"])
+        if kind in ("bad_no", "bad_no_track"):
+            no = f"LL{rnd.randint(2027000000, 2029999999)}{rnd.randint(10, 99)}"
+            tool_name = "query_waybill" if kind == "bad_no" else "track_waybill"
+            u = rnd.choice([f"帮我查下 {no}", f"{no} 到哪了", f"查一下运单 {no} 的物流"])
+            call = {"name": tool_name, "arguments": {"waybill_no": no}}
+            res = await call_tool(call["name"], call["arguments"])
+            a = f"抱歉，系统里没有找到运单 {no}。请核对运单号是否正确（本系统运单号为 LL 开头加 10 位数字），也可以告诉我寄/收件人手机号，我用手机号帮您查。"
+        elif kind == "bad_city_eta":
+            c1 = rnd.choice(unknown_cities); c2 = rnd.choice(list(CITY_PROVINCE))
+            u = f"{c1}到{c2}几天能到？"
+            call = {"name": "estimate_eta", "arguments": {"origin": c1, "destination": c2, "service": "标准快递"}}
+            res = await call_tool(call["name"], call["arguments"])
+            near = rnd.sample(list(CITY_PROVINCE), 2)
+            a = f"抱歉，{c1} 暂不在系统收录的城市范围内，无法直接估算时效。您可以确认一下城市名，或者选择邻近的已开通城市（如 {near[0]}、{near[1]}）再帮您估算。"
+        elif kind == "bad_city_freight":
+            c1 = rnd.choice(list(CITY_PROVINCE)); c2 = rnd.choice(unknown_cities)
+            item, w = rnd.choice(ITEMS)
+            u = f"从{c1}寄{item}到{c2}，{w}kg 多少钱？"
+            call = {"name": "calc_freight", "arguments": {"origin": c1, "destination": c2, "weight_kg": w}}
+            res = await call_tool(call["name"], call["arguments"])
+            a = f"抱歉，{c2} 暂不在已开通的计费城市范围内，算不了这条线路的运费。请确认城市名是否有误，或告诉我具体想寄到哪个已开通城市。"
+        elif kind == "intl_freight":  # 境外目的地：工具返回未收录，不得编造总价
+            c1 = rnd.choice(list(CITY_PROVINCE)); c2 = rnd.choice(foreign_cities)
+            item, w = rnd.choice(ITEMS)
+            u = rnd.choice([f"从{c1}寄{item}到{c2}多少钱？", f"{c1}发{w}kg{item}去{c2}，运费怎么算", f"寄东西到{c2}要多少运费"])
+            args = {"origin": c1, "destination": c2, "weight_kg": w} if c1 in u else {"origin": "上海", "destination": c2, "weight_kg": w}
+            call = {"name": "calc_freight", "arguments": args}
+            res = await call_tool(call["name"], call["arguments"])
+            a = (f"抱歉，{c2} 是境外城市，本系统的运费计算只覆盖国内已开通城市，无法直接报价。"
+                 "国际件请走国际业务：国际快递（DHL/FedEx/UPS）约 3–7 天，适合文件和样品；空运 5–10 天适合批量货；海运最便宜但需 20–45 天。"
+                 "告诉我货物类型、重量和时效要求，我可以帮您选合适的方式。")
+        elif kind == "bad_city_route":
+            c1 = rnd.choice(unknown_cities); c2 = rnd.choice(list(CITY_PROVINCE))
+            u = f"{c1}到{c2}的干线怎么走？"
+            call = {"name": "plan_route", "arguments": {"origin": c1, "destination": c2}}
+            res = await call_tool(call["name"], call["arguments"])
+            a = f"抱歉，路网数据里没有收录 {c1}，无法规划这条干线。如果您指的是其他城市请更正一下；也可以从收录的邻近枢纽城市出发规划。"
+        else:  # no_result_phone
+            ph = f"13{rnd.randint(100000000, 999999999)}"
+            u = rnd.choice([f"手机号 {ph} 名下有哪些运单？", f"用 {ph} 帮我查下快递"])
+            call = {"name": "search_waybills", "arguments": {"phone": ph}}
+            res = await call_tool(call["name"], call["arguments"])
+            a = f"手机号 {ph} 名下没有查到运单。请确认号码是否为下单时预留的手机号，或直接提供运单号（LL 开头 12 位）我来查询。"
+        out.append(sample(SYSTEM_TOOLS, [{"role": "user", "content": u}, tc(call), tr(res), {"role": "assistant", "content": a}]))
+    return out
+
+
 async def main():
     ap = argparse.ArgumentParser()
     ap.add_argument("--n-kb", type=int, default=200)
     ap.add_argument("--n-tool", type=int, default=300)
     ap.add_argument("--n-extract", type=int, default=150)
     ap.add_argument("--n-route", type=int, default=100)
+    ap.add_argument("--n-fail", type=int, default=60)
     ap.add_argument("--valid-ratio", type=float, default=0.08)
     ap.add_argument("--skip-kb", action="store_true", help="不用教师模型生成知识问答")
     ap.add_argument("--kb-cache", default=str(config.DATA_DIR / "seed" / "teacher_kb_qa.json"), help="已生成的知识问答缓存，存在则直接复用")
@@ -297,6 +428,7 @@ async def main():
     print("生成工具调用样本…"); data += await gen_tool(a.n_tool)
     print("生成抽取样本…"); data += gen_extract(a.n_extract)
     print("生成路径样本…"); data += await gen_route(a.n_route)
+    print("生成失败/边界样本…"); data += await gen_failures(a.n_fail)
     cache = Path(a.kb_cache)
     if not a.skip_kb and a.n_kb > 0 and cache.exists():
         pairs = json.load(open(cache, encoding="utf-8"))
@@ -320,26 +452,45 @@ async def main():
                 d = json.loads(l)
                 data.append(sample(SYSTEM_PLAIN, d["messages"][1:]))  # 手写种子也注入检索上下文
 
-    # mlx_lm --mask-prompt 只对最后一条 assistant 消息计算 loss，
-    # 所以把每个工具调用轨迹额外拆出"到该次工具调用为止"的前缀样本，让模型学会发出调用。
-    expanded = []
+    # 会话级去重（避免同一轨迹既进训练又进验证）
+    seen, uniq = set(), []
     for d in data:
-        msgs = d["messages"]
-        for i, m in enumerate(msgs):
-            if m["role"] == "assistant" and m.get("tool_calls") and i < len(msgs) - 1:
-                expanded.append({**d, "messages": msgs[:i + 1]})
-    data += expanded
-    print(f"拆分出工具调用前缀样本 {len(expanded)} 条")
-
-    rnd.shuffle(data)
-    nv = max(10, int(len(data) * a.valid_ratio))
+        key = json.dumps(d["messages"], ensure_ascii=False, sort_keys=True)
+        if key not in seen:
+            seen.add(key)
+            uniq.append(d)
+    print(f"会话去重：{len(data)} → {len(uniq)}")
+
+    # 按用户问题分组后切分训练/验证，再在各自分区内展开工具调用前缀
+    # （mlx_lm --mask-prompt 只训最后一条 assistant，前缀样本让模型学会发出调用；
+    #  同一问题的会话/前缀必须落在同一分区，否则验证损失虚低）
+    groups: dict = {}
+    for d in uniq:
+        groups.setdefault(d["messages"][1]["content"], []).append(d)
+    gkeys = list(groups)
+    rnd.shuffle(gkeys)
+    valid_sessions, train_sessions, nv = [], [], max(10, int(len(uniq) * a.valid_ratio))
+    for k in gkeys:
+        (valid_sessions if len(valid_sessions) < nv else train_sessions).extend(groups[k])
+
+    def expand(sessions):
+        out_rows = list(sessions)
+        for d in sessions:
+            msgs = d["messages"]
+            for i, m in enumerate(msgs):
+                if m["role"] == "assistant" and m.get("tool_calls") and i < len(msgs) - 1:
+                    out_rows.append({**d, "messages": msgs[:i + 1]})
+        return out_rows
+
+    train_rows, valid_rows = expand(train_sessions), expand(valid_sessions)
+    rnd.shuffle(train_rows)
     with open(OUT / "valid.jsonl", "w", encoding="utf-8") as f:
-        for x in data[:nv]:
+        for x in valid_rows:
             f.write(json.dumps(x, ensure_ascii=False) + "\n")
     with open(OUT / "train.jsonl", "w", encoding="utf-8") as f:
-        for x in data[nv:]:
+        for x in train_rows:
             f.write(json.dumps(x, ensure_ascii=False) + "\n")
-    print(f"完成：train {len(data) - nv} 条，valid {nv} 条 → {OUT}")
+    print(f"完成：train {len(train_rows)} 条（会话 {len(train_sessions)}），valid {len(valid_rows)} 条（会话 {len(valid_sessions)}）→ {OUT}")
 
 
 if __name__ == "__main__":

scripts/publish_hf.py

@@ -22,7 +22,7 @@ if not a.skip_space:
     for d in ["logicllm", "data/kb", "data/seed", "eval", "scripts"]:
         shutil.copytree(root / d, tmp / d, ignore=shutil.ignore_patterns("__pycache__", "*.pyc"))
     front = ("---\ntitle: 物流通 · 物流行业大模型\nemoji: 🚚\ncolorFrom: yellow\ncolorTo: gray\nsdk: gradio\napp_file: app.py\n"
-             "pinned: false\nlicense: apache-2.0\nshort_description: Qwen2.5-7B + 物流 LoRA + RAG + 工具调用\n"
+             "pinned: false\nlicense: apache-2.0\nshort_description: Qwen3-14B + 物流 LoRA + RAG + 工具调用\n"
              f"models:\n  - Qwen/Qwen3-14B\n  - {a.owner}/{a.model}\n---\n\n")
     (tmp / "README.md").write_text(front + (root / "README.md").read_text())
     api.upload_folder(repo_id=space, repo_type="space", folder_path=str(tmp), commit_message="update space")

scripts/seed_tms_demo.py

@@ -0,0 +1,115 @@
+"""往本地零担通 TMS（Dev Tenant）种一批演示数据：3 个网点、1 个客户、路由规则、3 张运单、若干轨迹事件。
+幂等：按名称/单号存在即跳过。用法：uv run python scripts/seed_tms_demo.py
+"""
+from __future__ import annotations
+
+import datetime
+import sys
+
+from logicllm.tools.tms import BASE, _api, _items  # 复用登录与请求封装
+
+SITES = [
+    {"name": "杭州西湖网点", "roles": ["origin", "destination"], "addr": ("浙江", "杭州", "西湖")},
+    {"name": "深圳南山网点", "roles": ["origin", "destination"], "addr": ("广东", "深圳", "南山")},
+    {"name": "成都金牛网点", "roles": ["origin", "destination"], "addr": ("四川", "成都", "金牛")},
+]
+
+
+def ensure_site(spec) -> dict:
+    res = _api("GET", "/sites", params={"keyword": spec["name"], "page_size": 5})
+    for s in _items(res)[0]:
+        if s["name"] == spec["name"]:
+            return s
+    p, c, dst = spec["addr"]
+    body = {
+        "name": spec["name"], "node_type": "site", "cooperation_type": "direct", "roles": spec["roles"],
+        "address": {"province": p, "city": c, "district": dst, "detail": f"{c}市{dst}区物流园1号"},
+        "contact_admin": {"name": "站长", "phone": "13800000001"},
+    }
+    r = _api("POST", "/sites", json=body)
+    if r.get("error"):
+        sys.exit(f"创建网点失败: {r}")
+    print("创建网点:", spec["name"])
+    return r
+
+
+def ensure_customer() -> dict:
+    res = _api("GET", "/customers", params={"page_size": 20})
+    for cu in _items(res)[0]:
+        if cu["name"] == "杭州云货科技有限公司":
+            return cu
+    body = {
+        "code": "CUST-DEMO-001", "name": "杭州云货科技有限公司", "short_name": "云货科技",
+        "contacts": [{"name": "王小明", "phone": "13812345678", "role": "logistics"}],
+        "settlement": {"cycle": "cash_on_delivery"}, "credit": {"limit": "0"},
+    }
+    r = _api("POST", "/customers", json=body)
+    if r.get("error"):
+        sys.exit(f"创建客户失败: {r}")
+    print("创建客户:", body["name"])
+    return r
+
+
+def ensure_route(frm: dict, to: dict):
+    res = _api("GET", "/route-rules", params={"page_size": 50})
+    for rr in _items(res)[0]:
+        if rr.get("from_site_id") == frm["id"] and rr.get("to_site_id") == to["id"]:
+            return rr
+    body = {
+        "from_site_id": frm["id"], "to_site_id": to["id"], "priority": 0,
+        "valid_from": datetime.date.today().isoformat(),
+        "legs": [{"from_node_id": frm["id"], "to_node_id": to["id"], "leg_type": "linehaul", "carrier_type": "hq_fleet"}],
+    }
+    r = _api("POST", "/route-rules", json=body)
+    if r.get("error"):
+        print(f"路由规则 {frm['name']}→{to['name']} 失败: {r}")
+        return None
+    print(f"创建路由: {frm['name']} → {to['name']}")
+    return r
+
+
+def ensure_waybill(cust: dict, frm: dict, to: dict, weight: str, fee: str, receiver: tuple[str, str]):
+    body = {
+        "customer_id": cust["id"], "customer_name_snapshot": cust["name"],
+        "origin_site_id": frm["id"], "destination_site_id": to["id"],
+        "origin_address": None,
+        "destination_address": {"contact": receiver[0], "phone": receiver[1],
+                                "province": to["address"]["province"] if isinstance(to.get("address"), dict) else "四川",
+                                "city": to["name"][:2], "district": "城区"},
+        "items_summary": {"count": 3, "weight_kg": weight, "volume_m3": "0.5"},
+        "payment_type": "cash_on_delivery", "settlement_snapshot": {"cycle": "cash_on_delivery"},
+        "is_cod": False, "cod_amount": "0", "receivable_amount": fee, "cod_service_fee_amount": "0",
+        "surcharges": [], "fee_breakdown": {"base": fee, "surcharges": []},
+        "pricing_snapshot": {"product_id": None, "discount_rate": "1.0"},
+        "business_mode": "ltl_network",
+    }
+    r = _api("POST", "/waybills", json=body)
+    if r.get("error"):
+        print(f"创建运单失败 ({frm['name']}→{to['name']}): {r}")
+        return None
+    print("创建运单:", r.get("waybill_no"), f"{frm['name']} → {to['name']}")
+    return r
+
+
+def main():
+    print("TMS:", BASE)
+    sites = {s["name"]: ensure_site(s) for s in SITES}
+    cust = ensure_customer()
+    hz, sz, cd = sites["杭州西湖网点"], sites["深圳南山网点"], sites["成都金牛网点"]
+    for a, b in [(hz, sz), (hz, cd), (sz, cd)]:
+        ensure_route(a, b)
+    existing, total = _items(_api("GET", "/waybills", params={"page_size": 5}))
+    if total >= 3:
+        print("已有运单，跳过创建:", [w["waybill_no"] for w in existing[:5]])
+    else:
+        ensure_waybill(cust, hz, sz, "120", "260.00", ("陈静", "15901112222"))
+        ensure_waybill(cust, hz, cd, "50", "200.00", ("王经理", "13800000001"))
+        ensure_waybill(cust, sz, cd, "800", "980.00", ("刘强", "15633334444"))
+    wb, _t = _items(_api("GET", "/waybills", params={"page_size": 10}))
+    print("\n当前运单��")
+    for w in wb:
+        print(" ", w["waybill_no"], w["status"], w.get("origin_site_name"), "→", w.get("destination_site_name"))
+
+
+if __name__ == "__main__":
+    main()

scripts/serve_mlx.sh

@@ -6,12 +6,19 @@
 #   所以应用侧在每个请求里显式带 "adapters": <绝对路径>（见 logicllm/config.py LLM_ADAPTER）。
 set -euo pipefail
 cd "$(dirname "$0")/.."
-BASE=${BASE_MODEL:-mlx-community/Qwen2.5-7B-Instruct-4bit}
+PORT=${MLX_PORT:-8080}
+if lsof -tnP -iTCP:$PORT -sTCP:LISTEN >/dev/null 2>&1; then
+  echo "⚠️ 端口 $PORT 已有服务在运行："
+  ps -o command= -p "$(lsof -tnP -iTCP:$PORT -sTCP:LISTEN | head -1)" | cut -c1-100
+  echo "如需重启：pkill -f 'mlx_lm server' 后再运行本脚本；直接使用现有服务则无需任何操作。"
+  exit 0
+fi
+BASE=${BASE_MODEL:-mlx-community/Qwen3-14B-4bit}
 ADAPTER="$(pwd)/adapters/logistics-lora"
 if [ -f "$ADAPTER/adapters.safetensors" ]; then
   echo "基座 $BASE + LoRA $ADAPTER"
-  exec uv run python -m mlx_lm server --model "$BASE" --adapter-path "$ADAPTER" --port 8080 --host 127.0.0.1
+  exec uv run python -m mlx_lm server --model "$BASE" --adapter-path "$ADAPTER" --port $PORT --host 127.0.0.1
 else
   echo "⚠️ 未找到 LoRA，使用原始基座"
-  exec uv run python -m mlx_lm server --model "$BASE" --port 8080 --host 127.0.0.1
+  exec uv run python -m mlx_lm server --model "$BASE" --port $PORT --host 127.0.0.1
 fi

scripts/train.sh

@@ -1,10 +1,11 @@
 #!/usr/bin/env bash
 # LoRA 微调（MLX）。用法：bash scripts/train.sh [iters]
+# 环境变量：BASE_MODEL 基座；ADAPTER_PATH 输出目录（默认 adapters/logistics-lora，实验版可另设以免覆盖已发布权重）
 set -euo pipefail
 cd "$(dirname "$0")/.."
-ITERS=${1:-600}
-BASE=${BASE_MODEL:-mlx-community/Qwen2.5-7B-Instruct-4bit}
-ADAPTER=adapters/logistics-lora
+ITERS=${1:-800}
+BASE=${BASE_MODEL:-mlx-community/Qwen3-14B-4bit}
+ADAPTER=${ADAPTER_PATH:-adapters/logistics-lora}
 mkdir -p "$ADAPTER"
 uv run python -m mlx_lm lora \
   --model "$BASE" \
@@ -18,6 +19,7 @@ uv run python -m mlx_lm lora \
   --steps-per-eval 100 \
   --steps-per-report 20 \
   --max-seq-length 4096 \
+  --grad-checkpoint \
   --mask-prompt \
   --seed 42
 echo "训练完成 → $ADAPTER"