qizhong/inquiry_robot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

空运协同里手工改费用、有起运地、锁舱失败或缺参会被误判，报价单已出后再激活又重发模板。按销售侧口径收紧这些分支，并让价格卡和未成交回执带上真实工单号。

Browse Source 
Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
jillion886
2026-10-08 18:05:29 +08:00
co-authored by Cursor
parent 43e633f359
commit 6141978a9e
25 changed files with 1347 additions and 98 deletions
Download Patch File Download Diff File Expand all files Collapse all files
inquiry-agent/agent/handlers/air_group_collab.py
+61 -36
View File
@@ -22,6 +22,8 @@ from agent.policy.air_group_ops import (
apply_air_file,
apply_air_lock,
apply_air_quote,
lock_params_from_text,
text_has_lock_supplement,
apply_air_release,
apply_air_tms_choice,
current_ticket,
@@ -229,10 +231,18 @@ def handle_air_group(
if is_handoff_ticket(ticket):
logger.info("air_group 转人工不再跟 chat=%s", chat_id)
return "handoff_ignore"
from agent.policy.system_exception import reply_paused_ticket, ticket_is_paused
from agent.policy.system_exception import (
cabin_failure_pause,
reply_paused_ticket,
ticket_is_paused,
)
# 锁舱失败留下的暂停只拦还要打 TMS 的操作。成交、未成交和补原因不调用 TMS。
if ticket_is_paused(ticket) and not _deal_ignores_tms_pause(ticket, intent):
# 查价失败的暂停仍要拦住。锁舱/释放失败已经告诉过原因，不能挡住后面的报价和成交。
if (
ticket_is_paused(ticket)
and not cabin_failure_pause(ticket)
and not _deal_ignores_tms_pause(ticket, intent)
):
reply_paused_ticket(
ticket=ticket,
reply=lambda text: send_group_text(group_client_of(engine), chat_id, text),
@@ -310,6 +320,29 @@ def _handle_cabin(
_ = injected_quote
chat_id = message.chat_id
if not work_order_no:
# 本群已经在锁这张单时，补舱位不用再报工单号。
bound = current_ticket(engine, chat_id)
if bound is not None and is_air_ticket(bound):
ticket = bound
if intent == INTENT_RELEASE:
return apply_air_release(
flow=engine,
ticket=ticket,
sender_id=message.sender_id,
chat_id=chat_id,
instruction=message.content or "",
)
option_no, airline, flight_no = lock_params_from_text(message.content or "")
return apply_air_lock(
flow=engine,
ticket=ticket,
sender_id=message.sender_id,
chat_id=chat_id,
instruction=message.content or "",
option_no=option_no,
airline=airline,
flight_no=flight_no,
)
send_group_text(group_client_of(engine), chat_id, copy.air_lock_need_work_order())
return "cabin_need_work_order"
ticket, phase = resolve_cabin_ticket(
@@ -328,15 +361,17 @@ def _handle_cabin(
chat_id=chat_id,
instruction=message.content or "",
)
# 「WO…锁舱，锁AIR-OPT01 TH」要带上句中的舱位和航司，不能只靠报价里碰巧只有一条。
# 「锁 AIR-OPT01 CZ 航班CZ327」要带上舱位、航司、航班号。缺了先补，不能直接锁。
option_no, airline, flight_no = lock_params_from_text(message.content or "")
return apply_air_lock(
flow=engine,
ticket=ticket,
sender_id=message.sender_id,
chat_id=chat_id,
instruction=message.content or "",
option_no=_option_from_text(message.content or ""),
airline=_airline_from_text(message.content or ""),
option_no=option_no,
airline=airline,
flight_no=flight_no,
)
@@ -373,19 +408,20 @@ def _handle_bound(
if lost:
return lost
facts = dict(ticket_view(ticket).get("collab_facts") or {})
if intent == INTENT_PICK_OPTION or (
intent == INTENT_OTHER and str(facts.get("__pending_air_lock") or "") == "1"
):
option = _option_from_text(message.content or "")
if option:
pending_lock = str(facts.get("__pending_air_lock") or "") == "1"
# 等补舱位时，报价/选线路等意图让路：话里带了舱位、航司或航班号就继续锁。
if intent == INTENT_PICK_OPTION or pending_lock or text_has_lock_supplement(message.content or ""):
option_no, airline, flight_no = lock_params_from_text(message.content or "")
if option_no or airline or flight_no:
return apply_air_lock(
flow=engine,
ticket=ticket,
sender_id=message.sender_id,
chat_id=chat_id,
instruction=message.content or "",
option_no=option,
airline=_airline_from_text(message.content or ""),
option_no=option_no,
airline=airline,
flight_no=flight_no,
)
if intent in {INTENT_DEAL, INTENT_LOST, INTENT_NEGOTIATE}:
outcome = {
@@ -421,6 +457,18 @@ def _handle_bound(
sender_id=message.sender_id,
chat_id=chat_id,
)
from agent.policy.sea_group_ops import is_sales
from agent.routing.group_intent import resolve_price_intent
# 航线写出「空运费改为900」是报价。模型若判成调价，这里按说话人改回来。
priced = resolve_price_intent(
intent,
message.content or "",
sales=is_sales(ticket, message.sender_id),
)
if priced != intent:
logger.info("air_group 报价/调价改判 %s -> %s chat=%s", intent, priced, chat_id)
intent = priced
if intent == INTENT_ADJUST:
from agent.policy.quote_adjust_ops import apply_group_adjust
@@ -448,26 +496,3 @@ def _handle_bound(
return "group_ignore"
def _option_from_text(text: str) -> str:
"""从「锁AIR-OPT01 TH」抽出舱位编号；不要把后面的航司码拼进 optionNo。"""
import re
m = re.search(r"AIR-?OPT-?\d+", (text or "").upper())
if not m:
return ""
raw = m.group(0)
# 统一成 TMS 常见写法 AIR-OPT01（中间可保留已有的第二根横杠）
if raw.startswith("AIROPT"):
return "AIR-OPT" + raw[6:]
return raw
def _airline_from_text(text: str) -> str:
"""从「AIR-OPT01 TH」抽出两位航司码；没有就不猜。"""
import re
blob = (text or "").upper()
m = re.search(r"AIR-?OPT-?\d+\s*([A-Z]{2})(?![A-Z0-9])", blob)
if m:
return m.group(1)
return ""
inquiry-agent/agent/handlers/group_collab.py
+19 -2
View File
@@ -126,9 +126,14 @@ def handle_group_inbound(
logger.info("group_inbound 忽略非成员 sender=%s chat=%s", message.sender_id, chat_id)
return "group_ignore"
from agent.policy.system_exception import reply_paused_ticket, ticket_is_paused
from agent.policy.system_exception import (
cabin_failure_pause,
reply_paused_ticket,
ticket_is_paused,
)
if ticket_is_paused(ticket):
# 锁舱失败不挡海运/陆运群里的后续报价。查价失败的暂停仍要停。
if ticket_is_paused(ticket) and not cabin_failure_pause(ticket):
reply_paused_ticket(
ticket=ticket,
reply=lambda text: send_group_text(group_client_of(engine), chat_id, text),
@@ -238,6 +243,18 @@ def handle_group_inbound(
sender_id=message.sender_id,
sess=sess,
)
from agent.policy.sea_group_ops import is_sales
from agent.routing.group_intent import resolve_price_intent
# 产品写出「报关费改为300」是报价。不是这张单的销售时，不能回调价话术。
priced = resolve_price_intent(
intent,
message.content or "",
sales=is_sales(ticket, message.sender_id),
)
if priced != intent:
logger.info("group_inbound 报价/调价改判 %s -> %s chat=%s", intent, priced, chat_id)
intent = priced
if intent == INTENT_ADJUST:
from agent.policy.quote_adjust_ops import apply_group_adjust
inquiry-agent/agent/handlers/text_inquiry.py
+2 -1
View File
@@ -404,6 +404,7 @@ def handle_text_inquiry(
return info if ok else ""
from agent.policy.system_exception import (
cabin_failure_pause,
extract_work_order_nos,
reply_paused_ticket,
ticket_is_paused,
@@ -420,7 +421,7 @@ def handle_text_inquiry(
getter = getattr(ledger, "get_for_agent", None)
if callable(getter):
ticket = getter(work_order_no=no, sender_id=message.sender_id)
if ticket_is_paused(ticket):
if ticket_is_paused(ticket) and not cabin_failure_pause(ticket):
reply_paused_ticket(ticket=ticket, reply=reply)
logger.info("text_inquiry 暂停工单只回兜底 wo=%s sender=%s", no, message.sender_id)
return "system_exception_paused"
inquiry-agent/agent/ledger/http_ledger.py
+5 -1
View File
@@ -423,7 +423,9 @@ class HttpLedger:
operator_name: str = "",
instruction_text: str = "",
airline: str = "",
flight_no: str = "",
) -> dict[str, Any]:
"""锁舱出站。航班号和航司一并带上，主账缺了这两项不能当锁舱失败。"""
body: dict[str, Any] = {
"workOrderNo": work_order_no,
"optionNo": option_no,
@@ -433,10 +435,12 @@ class HttpLedger:
}
if (airline or "").strip():
body["airline"] = airline.strip().upper()
if (flight_no or "").strip():
body["flightNo"] = flight_no.strip().upper()
return self._post(
"/inquiry/agent/tms/lockCabin",
body,
idem=f"air-lock:{work_order_no}:{option_no}",
idem=f"air-lock:{work_order_no}:{option_no}:{(airline or '').strip()}:{(flight_no or '').strip()}",
)
def release_cabin(
inquiry-agent/agent/ledger/memory_ledger.py
+2 -1
View File
@@ -827,9 +827,10 @@ class MemoryLedger:
operator_name: str = "",
instruction_text: str = "",
airline: str = "",
flight_no: str = "",
) -> dict[str, Any]:
"""单测可注入 _cabin_lock_result；默认成功。"""
_ = sender_id, operator_name, instruction_text, airline
_ = sender_id, operator_name, instruction_text, airline, flight_no
forced = getattr(self, "_cabin_lock_result", None)
if isinstance(forced, dict):
return dict(forced)
inquiry-agent/agent/policy/air_group_ops.py
+425 -20
View File
@@ -10,6 +10,7 @@ from __future__ import annotations
import json
import logging
import re
from typing import Any, Optional
from agent.llm.extract_text import extract_air_collab_fields, extract_product_quote
@@ -43,6 +44,9 @@ AIRLINE_ROLE = "air"
_PENDING_QUOTE = "__pending_air_quote"
_PENDING_LOCK = "__pending_air_lock"
_PENDING_LOCK_OPTION = "__pending_lock_option"
_PENDING_LOCK_AIRLINE = "__pending_lock_airline"
_PENDING_LOCK_FLIGHT = "__pending_lock_flight"
_LOCK_ID = "__air_lock_id"
_LOCK_OPTION = "__air_lock_option"
_LOCK_QUOTE = "__air_lock_quote"
@@ -116,7 +120,7 @@ def activate_ticket(
把本群当前工单切到指定空运未结案单。
返回 (工单, phase)。失败时工单为 None。
航线已经用附件或文字落过价时，再发工单号只回到成交跟进，不再发空白模板。
已经在成交跟进，或航线/产品价已经落账时，再发工单号只回到成交跟进，不再发工单摘要和模板。
"""
book = flow.ledger
no = (work_order_no or "").strip()
@@ -174,23 +178,45 @@ def activate_ticket(
def _air_already_quoted_for_deal(ticket: object) -> bool:
"""
航线报价已经落账，再激活应回成交跟进。
再激活应回成交跟进，而不是重发工单摘要和空运模板。
附件报价会把来源标成「航线附件报价」，但报价编号仍可能留着 TMS。
只看 source 会误当成还没报价。还只有 TMS 标准价时仍发模板。
报价单已经发给销售（quoteFileIssued）或主账停在 wait_deal 时，
即使报价来源仍是 TMS 标准价，也已经在成交跟进。
协商中、航线/产品价、销售调价同样只回成交跟进。
报价单还没出、也没在等成交时，仍发模板给航线填。
"""
status = ticket_status(ticket)
if status == "协商中":
return True
view = ticket_view(ticket)
phase = str(view.get("wait_phase") or view.get("waitPhase") or "").strip()
if phase == "wait_deal":
return True
quote = dict(view.get("quote") or {})
if _quote_file_issued(quote):
return True
if status != "已报价":
return False
quote = dict(ticket_view(ticket).get("quote") or {})
label = str(quote.get("source_label") or quote.get("sourceLabel") or "")
if "航线" in label or "产品" in label:
return True
return copy.quote_is_sales_adjust(quote)
def _quote_file_issued(quote: dict[str, Any]) -> bool:
"""报价单已发给销售，且没有被作废。作废后重新激活仍要发模板。"""
if _flag_on(quote.get("quoteFileVoided") or quote.get("quote_file_voided")):
return False
return _flag_on(quote.get("quoteFileIssued") or quote.get("quote_file_issued"))
def _flag_on(val: object) -> bool:
"""主账布尔可能是 true / \"true\" / 1。"""
if isinstance(val, str):
return val.strip().lower() in {"1", "true", "yes"}
return bool(val)
def _collab_slot_empty(val: object) -> bool:
"""协同项没写，或只写了横杠。横杠是摘要占位，不能当成已经填过。"""
return str(val or "").strip() in {"", "-", "—", "－"}
@@ -817,30 +843,45 @@ def apply_air_lock(
instruction: str,
option_no: str = "",
airline: str = "",
flight_no: str = "",
) -> str:
"""
航线锁舱。
舱位编号、航司、航班号没齐时只请补全，不调 TMS 锁舱，不标系统异常。
三项齐了（话里写的优先，报价里已有的可以补上）才打主账锁舱。
上次锁舱失败标过暂停的，航线再锁仍要打 TMS。
"""
if not is_airline(flow, sender_id):
send_group_text(group_client_of(flow), chat_id, copy.air_airline_only_cabin())
return "not_airline"
# 锁舱是航线主动再试：即使工单因上次失败标了系统异常，也要再打 TMS，
# 不能只回「TMS接口异常，IT运维排查中」。
no = ticket_no(ticket)
name = operator_name(flow, sender_id)
view_quote = dict(ticket_view(ticket).get("quote") or {})
air_quote = dict((view_quote.get("segment_quotes") or {}).get("AIR") or {})
quote = air_quote or view_quote
options = _air_options(quote)
quote_id = _quote_id(quote)
picked = (option_no or "").strip()
if not picked and len(options) > 1:
facts = dict(ticket_view(ticket).get("collab_facts") or {})
if str(facts.get(_PENDING_LOCK) or "") != "1":
flow.ledger.patch_collab_facts(
work_order_no=no, facts={_PENDING_LOCK: "1"}, sender_id=sender_id
)
send_group_text(group_client_of(flow), chat_id, copy.air_ask_lock_option(options))
return "wait_lock_option"
if not picked and len(options) == 1:
picked = str(options[0].get("optionNo") or options[0].get("option_no") or "").strip()
facts = dict(ticket_view(ticket).get("collab_facts") or {})
picked, air_code, flight = _resolve_lock_params(
quote,
facts,
option_no=option_no,
airline=airline,
flight_no=flight_no,
instruction=instruction,
)
missing = _missing_lock_labels(picked, air_code, flight)
if missing and _quote_ready_for_lock(quote):
_remember_partial_lock(
flow,
work_order_no=no,
sender_id=sender_id,
option_no=picked,
airline=air_code,
flight_no=flight,
)
send_group_text(group_client_of(flow), chat_id, copy.air_lock_need_params(missing))
return "wait_lock_params"
locker = getattr(flow.ledger, "lock_cabin", None)
if not callable(locker):
send_group_text(
@@ -864,7 +905,8 @@ def apply_air_lock(
sender_id=sender_id,
operator_name=name,
instruction_text=instruction,
airline=(airline or "").strip(),
airline=air_code,
flight_no=flight,
)
or {},
is_ok=lambda x: bool((x or {}).get("ok")),
@@ -873,6 +915,20 @@ def apply_air_lock(
if str(out.get("error") or "") == "no_quote":
send_group_text(group_client_of(flow), chat_id, copy.air_lock_need_quote(no))
return "no_quote"
# 主账在出站前发现三项不齐：只请补，不当 TMS 故障，不通知 IT。
reason_text = str(out.get("failReason") or "")
if str(out.get("error") or "") == "lock_params_incomplete" or "锁舱参数不完整" in reason_text:
labels = missing or _labels_from_incomplete_reason(reason_text)
_remember_partial_lock(
flow,
work_order_no=no,
sender_id=sender_id,
option_no=picked,
airline=air_code,
flight_no=flight,
)
send_group_text(group_client_of(flow), chat_id, copy.air_lock_need_params(labels))
return "wait_lock_params"
# 多段是产品限制，不是 TMS 故障。只回原因，不标系统异常、不暂停工单。
if str(out.get("error") or "") == "multi_no_lock":
send_group_text(
@@ -903,6 +959,8 @@ def apply_air_lock(
conversation_target=chat_id,
extra={
"option_no": picked,
"airline": air_code,
"flight_no": flight,
"instruction": instruction,
"sender_id": sender_id,
"operator_name": name,
@@ -922,6 +980,9 @@ def apply_air_lock(
_LOCK_QUOTE: quote_no,
_LOCK_EXEC: exec_no,
_PENDING_LOCK: "",
_PENDING_LOCK_OPTION: "",
_PENDING_LOCK_AIRLINE: "",
_PENDING_LOCK_FLIGHT: "",
},
sender_id=sender_id,
)
@@ -1168,6 +1229,350 @@ def _is_product_quote(quote: dict[str, Any]) -> bool:
return "航线" in src or "产品" in src
_OPTION_RE = re.compile(r"AIR-?OPT-?\d+")
_AIRLINE_AFTER_OPTION_RE = re.compile(r"AIR-?OPT-?\d+\s*([A-Z]{2})(?![A-Z0-9])")
_AIRLINE_LABELED_CODE_RE = re.compile(
r"航司(?:代码|二字码)?\s*[:：]?\s*(?:是|为)?\s*([A-Z]{2}|[A-Z]\d|\d[A-Z])(?![A-Z0-9])"
)
_AIRLINE_LABELED_NAME_RE = re.compile(
r"航司(?:代码|二字码)?\s*[:：]?\s*(?:是|为)?\s*([\u4e00-\u9fffA-Za-z0-9]{2,12})"
)
_FLIGHT_LABELED_RE = re.compile(
r"(?:航班号|航班)\s*[:：]?\s*(?:是|为)?\s*([A-Z]{2}\s*\d{2,4}|[A-Z]\d\s*\d{2,4}|\d[A-Z]\s*\d{2,4})"
)
_FLIGHT_TRAIL_RE = re.compile(
r"AIR-?OPT-?\d+\s+(?:[A-Z]{2}\s+)?([A-Z]{2}\s*\d{2,4})"
)
_FLIGHT_LOOSE_RE = re.compile(r"(?<![A-Z0-9])(?!WO)([A-Z]{2}\d{2,4})(?!\d)")
_AIRLINE_CODE_RE = re.compile(r"^(?:[A-Z]{2}|[A-Z]\d|\d[A-Z])$")
_FLIGHT_CODE_RE = re.compile(r"^(?:[A-Z]{2}|[A-Z]\d|\d[A-Z])\d{2,4}$")
# 口语航司名归一成二字码。认不出的原样留下，交给 TMS，不因此再追问。
_AIRLINE_ALIASES = (
("中国南方航空", "CZ"),
("南方航空", "CZ"),
("南航", "CZ"),
("中国国际航空", "CA"),
("国际航空", "CA"),
("国航", "CA"),
("中国东方航空", "MU"),
("东方航空", "MU"),
("东航", "MU"),
("海南航空", "HU"),
("海航", "HU"),
("厦门航空", "MF"),
("厦航", "MF"),
("深圳航空", "ZH"),
("深航", "ZH"),
("四川航空", "3U"),
("川航", "3U"),
("山东航空", "SC"),
("山航", "SC"),
("春秋航空", "9C"),
("吉祥航空", "HO"),
("新加坡航空", "SQ"),
("新航", "SQ"),
("泰国航空", "TG"),
("泰航", "TG"),
("国泰航空", "CX"),
("国泰", "CX"),
("卡塔尔航空", "QR"),
("顺丰航空", "O3"),
)
def lock_params_from_text(text: str) -> tuple[str, str, str]:
"""
从航线原话抽出舱位编号、航司、航班号。
不要求「AIR-OPT01 CZ 航班CZ327」这一种写法。
带「舱位 / 航司 / 航班」的说法、换顺序、航司用中文名，都认。
本地对不上、话里又在补这三项时，再问模型。没说的不猜。
"""
option, airline, flight = _lock_params_local(text)
if option and airline and flight:
return option, airline, flight
if not _should_ask_lock_model(text, option, airline, flight):
return option, airline, flight
got_opt, got_air, got_flight = _lock_params_from_model(text)
return (
option or got_opt,
airline or _normalize_airline(got_air),
flight or _normalize_flight(got_flight),
)
def text_has_lock_supplement(text: str) -> bool:
"""这句话是在补锁舱三项，不是报价或闲聊。凑齐两项，或点名了舱位/航司/航班，都算。"""
option, airline, flight = _lock_params_local(text)
filled = sum(1 for item in (option, airline, flight) if item)
if filled >= 2:
return True
raw = text or ""
if filled < 1 or not any(word in raw for word in ("舱位", "航司", "航班")):
return False
from agent.routing.group_intent import text_is_staff_fee_quote
return not text_is_staff_fee_quote(raw)
def _lock_params_local(text: str) -> tuple[str, str, str]:
"""按原话里的编号、标签和常见航司名收三项。不调模型。"""
raw = text or ""
blob = raw.upper()
option = _option_from_blob(blob)
flight = _flight_from_blob(blob)
airline = _airline_from_text(raw, blob, option=option, flight=flight)
return option, airline, flight
def _option_from_blob(blob: str) -> str:
found = _OPTION_RE.search(blob or "")
if not found:
return ""
raw = found.group(0)
if raw.startswith("AIROPT"):
return "AIR-OPT" + raw[6:]
return raw
def _flight_from_blob(blob: str) -> str:
labeled = _FLIGHT_LABELED_RE.search(blob or "")
if labeled:
return _normalize_flight(labeled.group(1))
trailed = _FLIGHT_TRAIL_RE.search(blob or "")
if trailed:
return _normalize_flight(trailed.group(1))
loose = _FLIGHT_LOOSE_RE.search(blob or "")
if loose:
return _normalize_flight(loose.group(1))
return ""
def _airline_from_text(raw: str, blob: str, *, option: str, flight: str) -> str:
"""航司可以是二字码，也可以是「航司南航」这种说法。"""
labeled = _AIRLINE_LABELED_CODE_RE.search(blob or "")
if labeled:
return labeled.group(1)
named = _AIRLINE_LABELED_NAME_RE.search(raw or "")
if named:
token = named.group(1).strip()
if token.upper() not in {"AIR", "OPT"} and not token.upper().startswith("AIR-OPT"):
return _normalize_airline(token)
after = _AIRLINE_AFTER_OPTION_RE.search(blob or "")
if after:
return after.group(1)
# 没写「航司」二字时，只有这句话已经带了舱位或航班，才从航司名里认，避免报价句子被误伤。
if option or flight:
found = _alias_in_text(raw)
if found:
return found
return ""
def _normalize_flight(value: str) -> str:
compact = re.sub(r"\s+", "", (value or "").upper())
return compact if _FLIGHT_CODE_RE.match(compact) else ""
def _normalize_airline(value: str) -> str:
text = (value or "").strip()
if not text:
return ""
upper = re.sub(r"\s+", "", text.upper())
if _FLIGHT_CODE_RE.match(upper):
return ""
if _AIRLINE_CODE_RE.match(upper):
return upper
alias = _alias_in_text(text)
if alias:
return alias
if re.fullmatch(r"[\u4e00-\u9fffA-Za-z0-9]{2,12}", text) and not text.upper().startswith("AIR"):
return text
return ""
def _alias_in_text(text: str) -> str:
raw = text or ""
for name, code in _AIRLINE_ALIASES:
if name in raw:
return code
return ""
def _airline_ready(airline: str) -> bool:
text = (airline or "").strip()
if _AIRLINE_CODE_RE.match(text.upper()):
return True
return bool(_normalize_airline(text))
def _should_ask_lock_model(text: str, option: str, airline: str, flight: str) -> bool:
"""三项已经齐，或这句话根本没在说舱位，就不要再打模型。"""
if option and airline and flight:
return False
raw = text or ""
if any(word in raw for word in ("舱位", "航司", "航班")):
return True
blob = raw.upper()
return "AIR-OPT" in blob or "AIROPT" in blob
def _lock_params_from_model(text: str) -> tuple[str, str, str]:
"""
模型只抽舱位编号、航司、航班号。
网络未开或调用失败时当没抽到，群里继续按缺项追问。不在请求里猜。
"""
try:
from agent.config import get_settings
from agent.llm.http_client import LlmHttpClient
from agent.llm.modes import LlmMode
settings = get_settings()
if not (
getattr(settings, "llm_allow_network", False)
and getattr(settings, "llm_data_usage_confirmed", False)
):
return "", "", ""
client = LlmHttpClient.from_settings(settings)
data = client.chat(
mode=LlmMode.EXTRACT_FIELDS,
messages=[
{
"role": "system",
"content": (
"从航线这句话抽出锁舱三项。只回复一行 JSON，不要解释。"
'键为 optionNo、airline、flightNo。没有的填空字符串。'
"optionNo 是舱位编号，如 AIR-OPT01；airline 是航司二字码或航司名；"
"flightNo 是航班号，如 CZ327。不要编造原文没有的值。"
),
},
{"role": "user", "content": (text or "")[:500]},
],
)
content = str((data or {}).get("content") or "")
start = content.find("{")
end = content.rfind("}")
if start < 0 or end <= start:
return "", "", ""
payload = json.loads(content[start : end + 1])
if not isinstance(payload, dict):
return "", "", ""
option = _option_from_blob(str(payload.get("optionNo") or "").upper())
airline = _normalize_airline(str(payload.get("airline") or ""))
flight = _normalize_flight(str(payload.get("flightNo") or ""))
return option, airline, flight
except Exception:
logger.exception("锁舱三项模型抽取失败")
return "", "", ""
def _resolve_lock_params(
quote: dict[str, Any],
facts: dict[str, Any],
*,
option_no: str,
airline: str,
flight_no: str,
instruction: str,
) -> tuple[str, str, str]:
"""
拼出锁舱三项。
这一句里写的优先；没写的用上一句暂存的；再没有才用报价上已有的舱位。
航司写成南航、东方航空这类名字时归一成二字码；归一不了也算已经补充，不再追问。
"""
said_opt, said_air, said_flight = lock_params_from_text(instruction)
option = (option_no or said_opt or str(facts.get(_PENDING_LOCK_OPTION) or "")).strip()
air = _normalize_airline(airline or said_air or str(facts.get(_PENDING_LOCK_AIRLINE) or ""))
flight = _normalize_flight(flight_no or said_flight or str(facts.get(_PENDING_LOCK_FLIGHT) or ""))
chosen = _option_row(quote, option)
if chosen is None and not option:
options = _air_options(quote)
if len(options) == 1:
chosen = options[0]
option = str(chosen.get("optionNo") or chosen.get("option_no") or "").strip()
if not _airline_ready(air) and chosen is not None:
air = _normalize_airline(
str(chosen.get("airlineCode") or chosen.get("airline") or "")
)
if not flight and chosen is not None:
flight = _normalize_flight(str(chosen.get("flightNo") or chosen.get("flight_no") or ""))
if not flight:
flight = _normalize_flight(str(quote.get("flightNo") or quote.get("flight_no") or ""))
if not _airline_ready(air):
air = ""
if not air and len(flight) >= 2 and flight[:2].isalpha():
air = flight[:2]
return option, air, flight
def _option_row(quote: dict[str, Any], option_no: str) -> Optional[dict[str, Any]]:
"""按舱位编号找报价里的那一条；对不上返回空。"""
want = (option_no or "").strip().upper()
if not want:
return None
for row in _air_options(quote):
no = str(row.get("optionNo") or row.get("option_no") or "").strip().upper()
if no == want:
return row
return None
def _missing_lock_labels(option_no: str, airline: str, flight_no: str) -> list[str]:
"""缺的中文名，顺序固定：舱位编号、航司、航班号。"""
missing: list[str] = []
if not (option_no or "").strip():
missing.append("舱位编号")
if not _airline_ready(airline):
missing.append("航司")
if not _FLIGHT_CODE_RE.match((flight_no or "").strip().upper()):
missing.append("航班号")
return missing
def _labels_from_incomplete_reason(reason: str) -> list[str]:
"""主账回了「缺少：…」时，按中文名收回缺项，丢掉英文字段名。"""
found = [label for label in ("舱位编号", "航司", "航班号") if label in (reason or "")]
return found or ["舱位编号", "航司", "航班号"]
def _quote_ready_for_lock(quote: dict[str, Any]) -> bool:
"""有总价、费用或报价编号才值得让航线补舱位。完全没报价仍走「还没有报价」。"""
if str(quote.get("total") or "").strip() not in {"", "-"}:
return True
if quote.get("fee_lines") or quote.get("feeItems") or quote.get("departureCharges"):
return True
if _air_options(quote):
return True
return bool(str(quote.get("quoteId") or quote.get("quote_id") or "").strip())
def _remember_partial_lock(
flow: Any,
*,
work_order_no: str,
sender_id: str,
option_no: str,
airline: str,
flight_no: str,
) -> None:
"""先记下已经说清的项，下一句补齐后接着锁，不用重说。"""
patcher = getattr(flow.ledger, "patch_collab_facts", None)
if not callable(patcher):
return
patcher(
work_order_no=work_order_no,
facts={
_PENDING_LOCK: "1",
_PENDING_LOCK_OPTION: option_no,
_PENDING_LOCK_AIRLINE: airline,
_PENDING_LOCK_FLIGHT: flight_no,
},
sender_id=sender_id,
)
def _quote_id(quote: dict[str, Any]) -> str:
return str(quote.get("quoteId") or quote.get("quote_id") or "").strip()
inquiry-agent/agent/policy/air_text_flow.py
+34 -3
View File
@@ -1260,13 +1260,39 @@ class AirTextInquiryFlow:
quote = tms["quote"]
from agent.schema.air_route_options import (
choose_stated_origin_option,
needs_route_pick,
options_matching_origin,
parse_air_options,
project_selected_quote,
)
options = parse_air_options(quote)
if options and not needs_route_pick(quote):
stated_origin = str(
(sess.facts or {}).get("起运港") or (sess.facts or {}).get("起运地") or ""
).strip()
# 写了起运地：只认这个起运地的线路，直接报价，不让销售再选。
# 没写起运地：TMS 按目的地回多条时，才进选线页。
if stated_origin:
matched = options_matching_origin(options, stated_origin)
if options and not matched:
logger.info(
"air 起运地对不上回包线路 origin=%s wo=%s options=%s",
stated_origin,
no,
len(options),
)
self._emit_tms_miss(reply, no)
sess.phase = "tms_miss"
sess.status = "询价中"
sess.allowed = ()
self._save(sess)
return "tms_miss"
if matched:
quote = project_selected_quote(
quote, choose_stated_origin_option(matched, quote)
)
elif options and not needs_route_pick(quote):
quote = project_selected_quote(quote, options[0])
up = self._ledger.upsert_quote(work_order_no=no, quote=quote, to_status="已报价")
if not up.get("ok"):
@@ -1278,7 +1304,7 @@ class AirTextInquiryFlow:
copy.remember_tms_quote(sess, quote)
sess.tms_quote = dict(quote)
sess.status = "已报价"
if needs_route_pick(quote):
if not stated_origin and needs_route_pick(quote):
return self._offer_air_routes(
sess=sess,
work_order_no=no,
@@ -1976,7 +2002,12 @@ class AirTextInquiryFlow:
sess.phase = "done"
sess.allowed = ()
self._save(sess)
reply(copy.lost_reason_ack(str(result.get("lost_reason") or text)))
reply(
copy.lost_reason_ack(
str(result.get("lost_reason") or text),
work_order_no=sess.work_order_no,
)
)
return "done"
def mark_wait_deal(self, sender_id: str, work_order_no: str) -> None:
inquiry-agent/agent/policy/inquiry_copy.py
+32 -8
View File
@@ -1219,10 +1219,10 @@ def sea_quote_detail_text(
def collab_hint(work_order_no: str) -> str:
"""价格卡协同说明：无「内部协同」前缀，紧挨生成报价单按钮上方。"""
"""空运价格卡协同说明：请把相关方拉进原有协同群，并 @ 询价小助手。紧挨生成报价单按钮上方。"""
return (
f"若需要咨询内部航线人员，请手动拉新人与智能体到原有群，"
f"并在群聊发送工单编号{work_order_no}。"
f"请手动将相关方拉到空运原有协同群，并在空运协同群中发送"
f"“ {work_order_no}@询价小助手”，谢谢。"
)
@@ -2723,7 +2723,7 @@ def deal_ack(
if outcome == "未成交":
reason = (lost_reason or "").strip()
if reason:
return f"已记录为「未成交」。{lost_reason_ack(reason)}"
return f"已记录为「未成交」。{lost_reason_ack(reason, work_order_no=no)}"
return _r("lost.ask_reason", "已记录为「未成交」。请补充未成交原因。", ticket_no=no)
when = _followup_month_day(next_followup_at) or "第四个工作日"
return _r(
@@ -2750,14 +2750,20 @@ def _followup_month_day(raw: str) -> str:
return ""
def lost_reason_ack(reason: str = "") -> str:
"""收下未成交原因后回显原句。后台 lost.reason_ack。"""
def lost_reason_ack(reason: str = "", work_order_no: str = "") -> str:
"""
收下未成交原因后的回执。后台 lost.reason_ack。
后台模板里的 {{lost_reason}}、{{ticket_no}} 都在这里填。
不传工单号时占位留空串，避免群里再露出 {{ticket_no}}。
"""
text = (reason or "").strip()
no = (work_order_no or "").strip()
if text.endswith(("。", ".", "！", "!", "？", "?")):
default = f"已记下未成交原因：{text}"
else:
default = f"已记下未成交原因：{text}。" if text else "已记下未成交原因。"
return _r("lost.reason_ack", default, lost_reason=text)
return _r("lost.reason_ack", default, lost_reason=text, ticket_no=no)
def deal_notify_card(
@@ -2901,7 +2907,8 @@ def air_group_brief(
空运群激活摘要：与海运进群同一套结构，字段用空运。
先 @ 销售和航线，再工单号 + 询价字段 + 协同补充（含电/含磁）+ TMS报价。
TMS 段跟单聊同一套线路分项，总销售价只一行；禁止用「空运费=总价」冒充。
TMS 段跟单聊同一套线路分项，总销售价只一行。
已有运输费等分项时，不再叠一行「空运费=总价」；只有空运费这一项时要写出来。
不写「当前工单/询价要点/现在等到哪一步」。
"""
no = (work_order_no or "").strip()
@@ -3028,6 +3035,23 @@ def air_no_tms_quote_to_lock(work_order_no: str) -> str:
return air_lock_need_quote(work_order_no)
def air_lock_need_params(missing=None) -> str:
"""
舱位编号、航司、航班号没齐时，只请航线补全。
这时还没锁舱，不能说 TMS 锁舱失败，也不能通知 IT。
缺哪项就点哪项；三项都缺时是产品指定的那一句。
"""
labels = [str(x).strip() for x in (missing or []) if str(x).strip()]
if not labels:
labels = ["舱位编号", "航司", "航班号"]
joined = "、".join(labels)
return (
f"锁舱参数不完整，缺少：{joined}。"
"请补充后再锁，例如：AIR-OPT01，南航，航班CZ327。"
)
def air_lock_need_quote(work_order_no: str) -> str:
"""没有任何报价时的锁舱拒绝。后台 inquiring.air_lock_need_quote。"""
no = (work_order_no or "").strip()
inquiry-agent/agent/policy/sea_group_ops.py
+5 -1
View File
@@ -1337,7 +1337,11 @@ def capture_group_lost_reason(
sess.phase = "done"
sess.allowed = ()
flow._save(sess)
send_group_text(client, chat_id, copy.lost_reason_ack(str(result.get("lost_reason") or text)))
send_group_text(
client,
chat_id,
copy.lost_reason_ack(str(result.get("lost_reason") or text), work_order_no=no),
)
return "done"
inquiry-agent/agent/policy/system_exception.py
+31
View File
@@ -95,6 +95,35 @@ def ticket_is_paused(ticket: Any) -> bool:
return bool(ticket_exception_type(ticket))
def ticket_pause_step(ticket: Any) -> str:
"""暂停是哪一步留下的。查价、锁舱、释放各算各的。"""
if ticket is None:
return ""
if isinstance(ticket, dict):
step = str(
ticket.get("system_exception_step") or ticket.get("systemExceptionStep") or ""
).strip()
payload = ticket.get("system_exception_payload") or ticket.get("systemExceptionPayload") or {}
else:
step = str(getattr(ticket, "system_exception_step", "") or "").strip()
payload = getattr(ticket, "system_exception_payload", {}) or {}
if step:
return step
if isinstance(payload, dict):
return str(payload.get("step") or "").strip()
return ""
def cabin_failure_pause(ticket: Any) -> bool:
"""
锁舱或释放失败留下的暂停。
群里已经回过失败原因，并通知了 IT。之后的手工报价、补字段、成交不能再被
「TMS接口异常」挡住。查价失败的暂停不在这里，那种仍要停。
"""
return ticket_pause_step(ticket) in {STEP_TMS_LOCK, STEP_TMS_RELEASE, STEP_TMS_CABIN}
def extract_work_order_nos(text: str) -> list[str]:
"""从原话抽出正式工单号（WO + 日期流水）。不认虚拟号。"""
import re
@@ -867,6 +896,8 @@ def _resume_cabin_step(
option_no=option_no,
sender_id=sender,
instruction_text=instruction,
airline=str(extra.get("airline") or ""),
flight_no=str(extra.get("flight_no") or ""),
)
or {}
if callable(locker)
inquiry-agent/agent/routing/air_group_intent.py
+15 -5
View File
@@ -26,6 +26,8 @@ from agent.routing.group_intent import (
_hint_confirm_tms,
_hint_deal_outcome,
_hint_tms_choice,
_prefer_staff_quote,
text_is_staff_fee_quote,
)
logger = logging.getLogger(__name__)
@@ -95,6 +97,11 @@ def classify_air_group_text(
locked = _hint_lock_or_release(raw)
if locked:
return locked
# 补舱位不限写法。凑齐舱位编号、航司、航班号就当选舱，不要先当成报价。
from agent.policy.air_group_ops import text_has_lock_supplement
if text_has_lock_supplement(raw):
return INTENT_PICK_OPTION
# 本单已有 TMS 报价时，航线回「2」是选不用 TMS，不是把价格改成 2。
exact = _exact_tms_choice(raw)
if exact:
@@ -118,12 +125,15 @@ def classify_air_group_text(
if use_net and getattr(settings, "llm_data_usage_confirmed", False):
got = _classify_with_model(raw, settings)
if got in _VALID:
return got
return _prefer_staff_quote(got, raw)
except Exception:
logger.exception("空运群意图模型失败，回退规则")
from agent.llm.extract_text import extract_air_collab_fields, extract_product_quote
from agent.schema.quote_adjust import extract_adjust
# 费用金额先当航线报价。「空运费改为900」不是销售调价。
if text_is_staff_fee_quote(raw):
return INTENT_QUOTE
if extract_adjust(raw).is_adjust:
return INTENT_ADJUST
if extract_product_quote(raw):
@@ -176,10 +186,10 @@ def _classify_with_model(text: str, settings) -> str:
"你是空运协同群意图分类。只回复一个英文词，不要解释。"
"air_lock=航线要锁舱；air_release=航线要释放舱位；"
"air_activate=只是指定/切换工单号；"
"air_pick_option=在选舱位选项编号；"
"air_pick_option=在补充或选择舱位编号、航司、航班号，写法不限；"
"collab_fields=在补是否含电/是否含磁；"
"quote_adjust=销售在调已有费用，口令不写死（上升、往上抬、加一成、改到某金额都算），不是新产品报价；"
"product_quote=航线在报价格或费用（含具体金额）；"
"quote_adjust=销售在按比例改已有费用（上调、上浮、加10%、减5%、加一成），或只改总价/总销售价；"
"product_quote=航线在报某一项费用的金额。写出「空运费9900」「空运费改为900USD」是报价，不是调价；"
"quote_confirm_tms=确认沿用当前TMS报价；"
"quote_keep_tms=要在已有TMS报价上改；"
"quote_drop_tms=不要TMS、只用刚报的价；"
@@ -188,7 +198,7 @@ def _classify_with_model(text: str, settings) -> str:
"other=闲聊。"
"一句话里既有锁舱又有工单号，回 air_lock。"
"一句话里既有工单号又确认成交/未成交/协商中，回 deal_won/deal_lost/deal_negotiate，不要回 air_activate。"
"改已有费用优先 quote_adjust；新报价格才是 product_quote。"
"有具体费用金额就是 product_quote。只有比例或只改总价才是 quote_adjust。"
)
data = client.chat(
mode=LlmMode.ORDERED_ACTIONS,
inquiry-agent/agent/routing/group_intent.py
+65 -4
View File
@@ -117,6 +117,63 @@ _DROP_HINTS = (
)
def text_is_staff_fee_quote(text: str) -> bool:
"""
航线/产品在报某一项费用的金额。
「空运费 9900」「空运费改为900USD」「报关费改为300CNY」都算手工报价。
比例调价和只改总价/总销售价不算，那两句仍留给销售调价。
句里没有费用名、只剩一个数字，也不算，避免把选项编号当成报价。
不打模型。分类和入站改判都会用。
"""
raw = (text or "").strip()
if not raw:
return False
from agent.schema.quote_adjust import text_has_relative_adjust, text_has_total_only_adjust
if text_has_relative_adjust(raw) or text_has_total_only_adjust(raw):
return False
from agent.llm.extract_text import extract_product_quote
quote = extract_product_quote(raw)
rows = [row for row in (quote.get("fee_rows") or []) if isinstance(row, dict)]
if not rows:
return False
# 「费用合计」里的「费」不能单独把改总价认成报价；上面已经排除只改总价。
if "费" in raw:
return True
names = [str(row.get("name") or "").strip() for row in rows]
return any(name and name != "海运费" for name in names)
def resolve_price_intent(intent: str, text: str, *, sales: bool) -> str:
"""
按说话人把「报价」和「调价」分开。
航线/产品写出费用金额：按报价办，不能回「只有销售能调价」。
销售在做比例、改总价，或点名把某项费用改到某个金额：仍按调价办。
不打模型。群入站分发前调用，避免手工报价被调价话术拦住。
"""
if intent not in {INTENT_ADJUST, INTENT_QUOTE}:
return intent
from agent.schema.quote_adjust import extract_adjust
# 这里只用本地规则。正式调价抽取仍在调价处理里，必要时再问模型。
if sales and extract_adjust(text, allow_model=False).is_adjust:
return INTENT_ADJUST
if text_is_staff_fee_quote(text):
return INTENT_QUOTE
return intent
def _prefer_staff_quote(intent: str, text: str) -> str:
"""模型或本地规则把费用金额判成调价时，改回报价。比例和改总价不动。"""
if intent == INTENT_ADJUST and text_is_staff_fee_quote(text):
logger.info("判成调价，但这是费用报价，改回报价 text=%s", (text or "")[:40])
return INTENT_QUOTE
return intent
def classify_group_text(
text: str,
*,
@@ -163,12 +220,15 @@ def classify_group_text(
if hinted_deal and got in {INTENT_DISSOLVE, INTENT_OTHER, INTENT_FIELDS}:
logger.warning("群意图模型把成交判成%s，改回 %s text=%s", got, hinted_deal, raw[:40])
return hinted_deal
return got
return _prefer_staff_quote(got, raw)
except Exception:
logger.exception("群意图模型失败，回退标签字段")
from agent.llm.extract_text import extract_product_quote
from agent.schema.quote_adjust import extract_adjust
# 费用金额先当报价。「改为900」是航线/产品常用写法，不能先被调价规则抢走。
if text_is_staff_fee_quote(raw):
return INTENT_QUOTE
if extract_adjust(raw).is_adjust:
return INTENT_ADJUST
if extract_product_quote(raw):
@@ -249,8 +309,8 @@ def _classify_with_model(text: str, settings) -> str:
system = (
"你是海运协同群意图分类。只回复一个英文词，不要解释。"
"collab_fields=在补货好时间/商品海关编码/含油含电含磁；"
"quote_adjust=销售在调已有费用，口令不写死（上升、上浮、往上抬、加一成、减、改到某金额都算），不是新产品报价；"
"product_quote=产品在报价格或费用（含具体金额）；"
"quote_adjust=销售在按比例改已有费用（上调、上浮、加10%、减5%、加一成），或只改总价/总销售价；"
"product_quote=产品在报某一项费用的金额。写出「运费1000」「报关费改为300CNY」是报价，不是调价；"
"quote_confirm_tms=产品确认沿用当前TMS报价，没有报新金额；"
"quote_keep_tms=要在已有TMS报价上改，没有报新金额；"
"quote_drop_tms=不要TMS、只用产品刚报的价，没有报新金额；"
@@ -260,7 +320,8 @@ def _classify_with_model(text: str, settings) -> str:
"dissolve=要把这个协同群解散；"
"other=闲聊、问候、对询价港口的随口更正（不当改单）。"
"一句话里既补字段又报价，回 product_quote。"
"有金额就是 product_quote，不要判成 quote_keep_tms。"
"有具体费用金额就是 product_quote，不要判成 quote_adjust 或 quote_keep_tms。"
"只有比例或只改总价才是 quote_adjust。"
)
data = client.chat(
mode=LlmMode.ORDERED_ACTIONS,
inquiry-agent/agent/schema/air_route_options.py
+64 -10
View File
@@ -45,10 +45,55 @@ def parse_air_options(quote: dict[str, Any] | None) -> list[dict[str, Any]]:
def needs_route_pick(quote: dict[str, Any] | None) -> bool:
"""多于一条线路才进 H5 选。"""
"""没写起运地、且多于一条线路，才进 H5 选。有起运地时由调用方先按起运地收口。"""
return len(parse_air_options(quote)) > 1
def options_matching_origin(
options: list[dict[str, Any]],
origin_text: str,
) -> list[dict[str, Any]]:
"""
销售已经写了起运地时，只留起运机场对得上的线路。
杭州对 HGH，珠海对 ZUH。回包里的南京/深圳/郑州不能拿来给这张单选。
对不上返回空列表。不改入参。
"""
text = (origin_text or "").strip()
if not text:
return list(options)
code = resolve_airport_code(text).upper()
raw = text.upper()
matched: list[dict[str, Any]] = []
for opt in options:
origin = str(opt.get("originAirportCode") or opt.get("origin") or "").strip().upper()
if not origin:
continue
if code and origin == code:
matched.append(opt)
elif origin == raw:
matched.append(opt)
return matched
def choose_stated_origin_option(
options: list[dict[str, Any]],
quote: dict[str, Any] | None = None,
) -> dict[str, Any]:
"""
起运地已指定时直接用一条，不再让销售选线。
只有一条就用它。多条时优先和报价总价相同的那条，否则用第一条。
"""
if len(options) == 1:
return options[0]
total = (quote or {}).get("total")
for opt in options:
if _same_amount(opt.get("salePrice"), total):
return opt
return options[0]
def _place_name(code: str, fallback: str = "") -> str:
"""三字码能对上就用中文，否则用原文或 fallback。"""
raw = (code or "").strip()
@@ -331,14 +376,14 @@ def _same_amount(left: Any, right: Any) -> bool:
def drop_air_freight_total_alias(quote: dict[str, Any] | None) -> dict[str, Any]:
"""
整单兜底「空运费=总价」不是线路分项，群摘要禁止再写。
已经有其它费用分项时，去掉「空运费=总价」这一行兜底。
真有空运费且金额不等于总价（例如另有附加费）则保留。
舱位上有运输费、提送货费时，主账快照常再塞一行空运费，金额就是总价，不能和分项叠在一起。
只有空运费这一项时必须留下：TMS 经常只回这一项，金额自然等于总价，群里仍要写出费用名。
不写库。群摘要投影之后调用。
"""
src = dict(quote or {})
total = src.get("total")
if _same_amount(src.get("freight"), total):
src["freight"] = "-"
raw = src.get("fee_lines") or src.get("fee_rows")
parsed: Any = raw
if isinstance(raw, str) and raw.strip():
@@ -348,17 +393,26 @@ def drop_air_freight_total_alias(quote: dict[str, Any] | None) -> dict[str, Any]
parsed = None
if not isinstance(parsed, list):
return src
kept: list[Any] = []
others: list[Any] = []
alias: list[Any] = []
for item in parsed:
if not isinstance(item, dict):
kept.append(item)
others.append(item)
continue
name = str(item.get("name") or item.get("label") or "").strip()
name = str(item.get("name") or item.get("label") or item.get("feeName") or "").strip()
amount = item.get("amount") or item.get("value")
if name == "空运费" and _same_amount(amount, total):
alias.append(item)
continue
kept.append(item)
src["fee_lines"] = kept
others.append(item)
if others:
# 分项已经在，空运费=总价是重复兜底。运费字段同值也不再补一行。
src["fee_lines"] = others
if _same_amount(src.get("freight"), total):
src["freight"] = "-"
return src
# 明细就是这一条空运费，群摘要要显示费用名，不能只剩费用合计。
src["fee_lines"] = alias
return src
inquiry-agent/agent/schema/quote_adjust.py
+34
View File
@@ -493,6 +493,40 @@ def effective_quote(tms: dict[str, Any] | None, overlay: dict[str, Any] | None)
return out
def text_has_relative_adjust(text: str) -> bool:
"""
这句话是在按比例改价：加10%、减5%、上调、上浮、加一成。
这种是销售调价，不是航线/产品报一个新金额。不打模型。
"""
raw = text or ""
if _PERCENT_UP.search(raw) or _PERCENT_DOWN.search(raw):
return True
blob = raw.replace(" ", "").replace("　", "")
return any(phrase in blob for phrase in ("加一成", "减一成", "往上抬", "往下压", "上浮", "下浮"))
def text_has_total_only_adjust(text: str) -> bool:
"""
只动总价/总销售价/费用合计，没有点名某一项费用。
「总销售价改为180」仍是销售调价。点了「空运费」「报关费」则不是。不打模型。
"""
raw = text or ""
if not (_TARGET.search(raw) or _PERCENT_UP.search(raw) or _PERCENT_DOWN.search(raw)):
return False
if not any(word in raw for word in _TOTAL_WORDS) and "报价" not in raw:
return False
real: list[str] = []
for name in _FEE_TOKEN.findall(raw):
if name in {"费用", "费用合计"}:
continue
if any(word in name for word in ("合计", "总价", "汇总")):
continue
real.append(name)
return not real
def extract_adjust(
text: str,
*,
inquiry-agent/agent/schema/tms_air_query.py
+4 -1
View File
@@ -35,6 +35,9 @@ _AIRPORTS = {
"南京": "NKG",
"吉隆坡": "KUL",
"北京": "PEK",
"杭州": "HGH",
"萧山": "HGH",
"杭州萧山": "HGH",
}
# 历史字典：只给对照，空运出站不再编成 1/2/3。
@@ -199,7 +202,7 @@ def assemble_air_query(facts: dict[str, Any] | None) -> dict[str, Any]:
包装只看销售是否说了，散货等原文原样保留。
"""
src = dict(facts or {})
origin = str(src.get("起运港") or "").strip()
origin = str(src.get("起运港") or src.get("起运地") or "").strip()
dest = str(src.get("目的港") or "").strip()
cargo = str(src.get("品名") or "").strip()
pieces = _first_number(str(src.get("件数") or ""))