""" Order Agent - Handles order-related queries and operations """ import json from typing import Any from core.state import AgentState, ConversationState, add_tool_call, set_response, update_context from core.llm import get_llm_client, Message from utils.logger import get_logger from integrations.chatwoot import ChatwootClient logger = get_logger(__name__) # Order status constants (Mall API) ORDER_STATUS = { 0: "已取消", # ORDER_STATUS_CANCEL 1: "待支付", # ORDER_STATUS_WAIT_PAY 2: "已支付", # ORDER_STATUS_PAID 3: "已发货", # ORDER_STATUS_SHIPPED 4: "已签收", # ORDER_STATUS_SIGNED 15: "已完成", # ORDER_STATUS_FINISH 100: "超时取消", # ORDER_STATUS_CANCEL_OVER_TIME 110: "已废弃", # ORDER_STATUS_PAY_SUCCESS (deprecated) 10000: "全部" # All } def get_status_text(status_value: Any) -> str: """获取订单状态文本 Args: status_value: 状态值（数字或字符串） Returns: 状态文本 """ if status_value is None: return "" # 转换为整数 try: status_int = int(status_value) return ORDER_STATUS.get(status_int, str(status_value)) except (ValueError, TypeError): return str(status_value) ORDER_AGENT_PROMPT = """你是一个专业的 B2B 订单服务助手。 你的职责是帮助用户处理订单相关的问题，包括： - 订单查询 - 物流跟踪 - 订单修改 - 订单取消 - 发票获取 ## 可用工具 1. **get_mall_order** - 从商城 API 查询单个订单详情（推荐使用） - order_id: 订单号（必需） - user_token: 用户 token（自动注入） - 说明：此工具会自动使用用户的身份 token 查询商城订单详情 2. **get_mall_order_list** - 从商城 API 查询订单列表（推荐使用） - user_token: 用户 token（自动注入） - page: 页码（可选，默认 1） - limit: 每页数量（可选，默认 5） - 说明：查询用户的所有订单，按时间倒序排列，返回最近的 5 个订单 3. **get_logistics** - 从商城 API 查询物流信息 - order_id: 订单号（必需） - user_token: 用户 token（自动注入） - 说明：查询订单的物流轨迹和配送状态 4. **modify_order** - 修改订单 - order_id: 订单号 - user_id: 用户 ID（自动注入） - modifications: 修改内容（address/items/quantity 等） 5. **cancel_order** - 取消订单 - order_id: 订单号 - user_id: 用户 ID（自动注入） - reason: 取消原因 6. **get_invoice** - 获取发票 - order_id: 订单号 - invoice_type: 发票类型（normal/vat） ## 回复格式要求 **重要**：你必须始终返回完整的 JSON 对象，不要包含任何其他文本或解释。 ### 格式 1：调用工具 当需要使用工具查询信息时，返回： ```json { "action": "call_tool", "tool_name": "get_mall_order", "arguments": { "order_id": "202071324" } } ``` ### 格式 2：询问信息 当需要向用户询问更多信息时，返回： ```json { "action": "ask_info", "question": "请提供您的订单号" } ``` ### 格式 3：直接回复 当可以直接回答时，返回： ```json { "action": "respond", "response": "您的订单已发货，预计3天内到达" } ``` ## 示例对话 用户: "查询订单 202071324" 回复: ```json { "action": "call_tool", "tool_name": "get_mall_order", "arguments": { "order_id": "202071324" } } ``` 用户: "查询我最近的订单" 或 "我的订单列表" 回复: ```json { "action": "call_tool", "tool_name": "get_mall_order_list", "arguments": {} } ``` 用户: "我的订单发货了吗？" 回复: ```json { "action": "ask_info", "question": "请提供您的订单号，以便查询订单状态" } ``` 用户: "帮我查一下订单 202071324 的物流" 回复: ```json { "action": "call_tool", "tool_name": "get_logistics", "arguments": { "order_id": "202071324" } } ``` ## 重要约束 - **必须返回完整的 JSON 对象**，不要只返回部分内容 - **不要添加任何 markdown 代码块标记**（如 \`\`\`json） - **不要添加任何解释性文字**，只返回 JSON - **每次调用工具必须指定 tool_name** - user_id 和 account_id 会自动注入到 arguments 中，无需手动添加 - 如果用户提供了具体订单号，使用 get_mall_order 工具 - 如果用户想查询订单列表或最近的订单，使用 get_mall_order_list 工具 - 如果用户想查询物流状态，使用 get_logistics 工具 - 对于敏感操作（取消、修改），确保有明确的订单号 """ async def order_agent(state: AgentState) -> AgentState: """Order agent node Handles order queries, tracking, modifications, and cancellations. Args: state: Current agent state Returns: Updated state with tool calls or response """ logger.info( "Order agent processing", conversation_id=state["conversation_id"], sub_intent=state.get("sub_intent") ) state["current_agent"] = "order" state["agent_history"].append("order") state["state"] = ConversationState.PROCESSING.value # Check if we have tool results to process if state["tool_results"]: return await _generate_order_response(state) # Build messages for LLM messages = [ Message(role="system", content=ORDER_AGENT_PROMPT), ] # Add conversation history for msg in state["messages"][-6:]: messages.append(Message(role=msg["role"], content=msg["content"])) # Build context info context_info = f"用户ID: {state['user_id']}\n账户ID: {state['account_id']}\n" # Add entities if available if state["entities"]: context_info += f"已提取的信息: {json.dumps(state['entities'], ensure_ascii=False)}\n" # Add existing context if state["context"].get("order_id"): context_info += f"当前讨论的订单号: {state['context']['order_id']}\n" user_content = f"{context_info}\n用户消息: {state['current_message']}" messages.append(Message(role="user", content=user_content)) try: llm = get_llm_client() response = await llm.chat(messages, temperature=0.5) # Parse response content = response.content.strip() logger.info( "LLM response received", conversation_id=state["conversation_id"], response_length=len(content), response_preview=content[:300] ) # 检查是否是简化的工具调用格式：工具名称\n{参数} # 例如：get_mall_order\n{"order_id": "202071324"} if "\n" in content and "{" in content: lines = content.split("\n") if len(lines) >= 2: tool_name_line = lines[0].strip() json_line = "\n".join(lines[1:]).strip() # 如果第一行看起来像工具名称（不包含 {），且第二行是 JSON if "{" not in tool_name_line and "{" in json_line: logger.info( "Detected simplified tool call format", tool_name=tool_name_line, json_preview=json_line[:200] ) try: arguments = json.loads(json_line) # 直接构建工具调用 arguments["user_id"] = state["user_id"] arguments["account_id"] = state["account_id"] # Inject user_token if available # 优先使用 mall_token（用于 Mall API），如果没有则使用 user_token token_to_use = state.get("mall_token") or state.get("user_token") if token_to_use: arguments["user_token"] = token_to_use logger.info( "Injected token into tool call", token_type="mall_token" if state.get("mall_token") else "user_token", token_prefix=token_to_use[:20] if token_to_use else None ) else: logger.warning( "No token available in state, MCP will use default token", conversation_id=state["conversation_id"] ) # Use entity if available if "order_id" not in arguments and state["entities"].get("order_id"): arguments["order_id"] = state["entities"]["order_id"] state = add_tool_call( state, tool_name=tool_name_line, arguments=arguments, server="order" ) state["state"] = ConversationState.TOOL_CALLING.value logger.info( "Tool call added from simplified format", tool_name=tool_name_line, arguments_keys=list(arguments.keys()) ) return state except json.JSONDecodeError as e: logger.warning( "Failed to parse simplified format", error=str(e), json_line=json_line[:200] ) # 清理内容，去除可能的 markdown 代码块标记 # 例如：```json\n{...}\n``` 或 ```\n{...}\n``` if "```" in content: # 找到第一个 ``` 后的内容 parts = content.split("```") if len(parts) >= 2: content = parts[1].strip() # 去掉可能的 "json" 标记 if content.startswith("json"): content = content[4:].strip() # 去掉结尾的 ``` 标记 if content.endswith("```"): content = content[:-3].strip() # 尝试提取 JSON 对象（处理周围可能有文本的情况） json_start = content.find("{") json_end = content.rfind("}") if json_start != -1 and json_end != -1 and json_end > json_start: content = content[json_start:json_end + 1] logger.info( "Cleaned content for JSON parsing", conversation_id=state["conversation_id"], content_length=len(content), content_preview=content[:500] ) try: result = json.loads(content) except json.JSONDecodeError as e: logger.error( "Failed to parse LLM response as JSON", conversation_id=state["conversation_id"], error=str(e), content_preview=content[:500] ) # Don't use raw content as response - use fallback instead state = set_response(state, "抱歉，我无法理解您的请求。请尝试重新表述或联系人工客服。") return state action = result.get("action") logger.info( "LLM action parsed", conversation_id=state["conversation_id"], action=action, tool_name=result.get("tool_name") ) if action == "call_tool": # Inject user context into arguments arguments = result.get("arguments", {}) arguments["user_id"] = state["user_id"] arguments["account_id"] = state["account_id"] # Inject user_token if available (for Mall API calls) # 优先使用 mall_token（用于 Mall API），如果没有则使用 user_token token_to_use = state.get("mall_token") or state.get("user_token") if token_to_use: arguments["user_token"] = token_to_use logger.debug( "Injected token into tool call", token_type="mall_token" if state.get("mall_token") else "user_token", token_prefix=token_to_use[:20] if token_to_use else None ) else: logger.warning( "No token available in state, MCP will use default token", conversation_id=state["conversation_id"] ) # Use entity if available (only for single-order queries, not for order list) tool_name = result["tool_name"] if "order_id" not in arguments and state["entities"].get("order_id"): # 只在查询单个订单的工具中添加 order_id if tool_name in ["get_mall_order", "get_logistics", "query_order"]: arguments["order_id"] = state["entities"]["order_id"] # Force limit=5 for order list queries (unless explicitly set) if tool_name == "get_mall_order_list" and "limit" not in arguments: arguments["limit"] = 5 logger.debug( "Forced limit=5 for order list query", conversation_id=state["conversation_id"] ) state = add_tool_call( state, tool_name=result["tool_name"], arguments=arguments, server="order" ) state["state"] = ConversationState.TOOL_CALLING.value logger.info( "Tool call added", tool_name=result["tool_name"], arguments_keys=list(arguments.keys()) ) elif action == "ask_info": state = set_response(state, result["question"]) state["state"] = ConversationState.AWAITING_INFO.value elif action == "respond": state = set_response(state, result["response"]) state["state"] = ConversationState.GENERATING.value elif action == "handoff": state["requires_human"] = True state["handoff_reason"] = result.get("reason", "Complex order operation") return state except Exception as e: logger.error("Order agent failed", error=str(e)) state["error"] = str(e) return state async def _generate_order_response(state: AgentState) -> AgentState: """Generate response based on order tool results""" # 检查是否是邮件渠道 is_email = state.get("context", {}).get("is_email", False) # 邮件渠道：使用纯文本回复（不支持富媒体） if is_email: logger.info( "Email channel detected, using text response instead of rich media", conversation_id=state.get("conversation_id") ) return await _generate_text_response(state) # 获取检测到的语言，默认为英文 detected_language = state.get("detected_language", "en") # 解析订单数据并尝试使用 form 格式发送 order_data = None order_list = [] # 订单列表 user_message = "" logistics_data = None for result in state["tool_results"]: if result["success"]: data = result["data"] tool_name = result["tool_name"] # 提取订单ID到上下文 if isinstance(data, dict): if data.get("order_id"): state = update_context(state, {"order_id": data["order_id"]}) elif data.get("orders") and len(data["orders"]) > 0: state = update_context(state, {"order_id": data["orders"][0].get("order_id")}) # 处理 get_mall_order_list 返回的订单列表 if tool_name == "get_mall_order_list" and isinstance(data, dict): mcp_result = data.get("result", {}) if mcp_result.get("orders") and isinstance(mcp_result["orders"], list): # 解析订单列表 for order_item in mcp_result["orders"]: parsed_order = _parse_mall_order_data(order_item) if parsed_order.get("order_id"): order_list.append(parsed_order) # 处理 get_mall_order 返回的单个订单数据 elif tool_name == "get_mall_order" and isinstance(data, dict): # MCP 返回结构: {"success": true, "result": {...}} # result 可能包含: {"success": bool, "order": {...}, "order_id": "...", "error": "..."} mcp_result = data.get("result", {}) # 检查是否有错误（如未登录） if mcp_result.get("error") or not mcp_result.get("success"): logger.warning( "get_mall_order returned error", error=mcp_result.get("error"), require_login=mcp_result.get("require_login") ) # 设置错误消息到状态中 if mcp_result.get("require_login"): user_message = mcp_result.get("error", "请先登录账户以查询订单信息") elif mcp_result.get("order"): # 有订单数据 order_data = _parse_mall_order_data(mcp_result["order"]) # 如果 order_data 中没有 order_id，从外层获取 if not order_data.get("order_id") and mcp_result.get("order_id"): order_data["order_id"] = mcp_result["order_id"] else: logger.warning( "get_mall_order returned success but no order data", data_keys=list(data.keys()), result_keys=list(mcp_result.keys()) if isinstance(mcp_result, dict) else None ) # 处理 query_order 返回的订单数据 elif tool_name == "query_order" and isinstance(data, dict): if data.get("orders") and len(data["orders"]) > 0: # 如果有多个订单，添加到列表 if len(data["orders"]) > 1: for order_item in data["orders"]: parsed = _parse_order_data(order_item) if parsed.get("order_id"): order_list.append(parsed) user_message = f"找到 {len(data['orders'])} 个订单" else: # 只有一个订单，作为单个订单处理 order_data = _parse_order_data(data["orders"][0]) # 处理 get_logistics 返回的物流数据 elif tool_name == "get_logistics" and isinstance(data, dict): logistics_data = _parse_logistics_data(data) # 如果之前有订单数据，添加物流信息 if order_data: order_data["logistics"] = logistics_data # 如果只有物流数据，单独发送物流信息 elif logistics_data and logistics_data.get("tracking_number"): # 添加订单号（如果有） order_id = state.get("order_id", logistics_data.get("order_id", "")) if order_id: logistics_data["order_id"] = order_id try: chatwoot = ChatwootClient(account_id=int(state.get("account_id", 1))) conversation_id = state.get("conversation_id") if conversation_id: logger.info( "Preparing to send logistics info", conversation_id=conversation_id, tracking_number=logistics_data.get("tracking_number"), carrier=logistics_data.get("carrier"), language=detected_language ) await chatwoot.send_logistics_info( conversation_id=int(conversation_id), logistics_data=logistics_data, language=detected_language ) logger.info( "Logistics info sent successfully", conversation_id=conversation_id, tracking_number=logistics_data.get("tracking_number") ) state = set_response(state, "") state["state"] = ConversationState.GENERATING.value return state except Exception as e: logger.error( "Failed to send logistics info, falling back to text response", error=str(e), tracking_number=logistics_data.get("tracking_number") ) # 如果有订单列表（多个订单），使用订单列表格式 if order_list and len(order_list) > 1: try: chatwoot = ChatwootClient(account_id=int(state.get("account_id", 1))) conversation_id = state.get("conversation_id") if conversation_id: logger.info( "Preparing to send order list", conversation_id=conversation_id, orders_count=len(order_list), language=detected_language ) await chatwoot.send_order_list( conversation_id=int(conversation_id), orders=order_list, language=detected_language ) logger.info( "Order list sent successfully", conversation_id=conversation_id, orders_count=len(order_list), language=detected_language ) state = set_response(state, "") state["state"] = ConversationState.GENERATING.value return state except Exception as e: logger.error( "Failed to send order list, falling back to text response", error=str(e), orders_count=len(order_list) ) # 尝试使用 Chatwoot form 格式发送单个订单 if order_data: try: # 检查是否有有效的 order_id if not order_data.get("order_id"): logger.warning( "No valid order_id in order_data, falling back to text response", order_data=order_data ) return await _generate_text_response(state) chatwoot = ChatwootClient(account_id=int(state.get("account_id", 1))) conversation_id = state.get("conversation_id") if conversation_id: # 记录订单数据（用于调试） logger.info( "Preparing to send order card", conversation_id=conversation_id, order_id=order_data.get("order_id"), items_count=len(order_data.get("items", [])), language=detected_language ) await chatwoot.send_order_form( conversation_id=int(conversation_id), order_data=order_data, language=detected_language ) logger.info( "Order card sent successfully", conversation_id=conversation_id, order_id=order_data.get("order_id"), language=detected_language ) state = set_response(state, "") state["state"] = ConversationState.GENERATING.value return state except Exception as e: logger.error( "Failed to send order card, falling back to text response", error=str(e), order_id=order_data.get("order_id") ) # 降级处理：使用原来的 LLM 生成逻辑 return await _generate_text_response(state) def _parse_mall_order_data(data: dict[str, Any]) -> dict[str, Any]: """解析商城 API 返回的订单数据""" # 记录原始数据结构（用于调试） logger.info( "Parsing mall order data", data_keys=list(data.keys()), has_order_id=bool(data.get("order_id")), has_order_sn=bool(data.get("order_sn")), has_nested_order=bool(data.get("order")), order_id_preview=data.get("order_id", data.get("order_sn", "")), # 如果有 order 字段，记录其内容类型和键 nested_order_type=type(data.get("order")).__name__ if data.get("order") else None, nested_order_keys=list(data.get("order", {}).keys()) if isinstance(data.get("order"), dict) else None ) # Mall API 返回结构：外层包含 userId, reqContext 等，实际的订单数据在 order 字段中 # 如果有嵌套的 order 字段，提取出来 actual_order_data = data.get("order", data) if data.get("order") else data # 记录提取的订单数据结构（用于调试） logger.info( "Extracted order data structure", actual_order_keys=list(actual_order_data.keys()) if isinstance(actual_order_data, dict) else type(actual_order_data).__name__, has_items=bool(actual_order_data.get("items")), has_order_items=bool(actual_order_data.get("order_items")), has_products=bool(actual_order_data.get("products")), has_orderProduct=bool(actual_order_data.get("orderProduct")), has_orderGoods=bool(actual_order_data.get("orderGoods")), has_goods=bool(actual_order_data.get("goods")) ) order_data = { "order_id": actual_order_data.get("orderId", actual_order_data.get("order_id", actual_order_data.get("order_sn", ""))), "order_type": actual_order_data.get("orderType", actual_order_data.get("order_type", "")), "status": actual_order_data.get("orderStatusId", actual_order_data.get("status", "unknown")), "status_text": actual_order_data.get("statusText", ""), "total_amount": actual_order_data.get("total", actual_order_data.get("total_amount", actual_order_data.get("order_amount", "0.00"))), "shipping_fee": actual_order_data.get("shipping_fee", actual_order_data.get("freight_amount", "0")), "payment_method": actual_order_data.get("paymentCode", actual_order_data.get("paymentMethod", "")), } # 如果 statusText 为空，使用 orderStatusId 映射获取状态文本 if not order_data["status_text"]: status_id = actual_order_data.get("orderStatusId", actual_order_data.get("status")) order_data["status_text"] = get_status_text(status_id) # 下单时间 if actual_order_data.get("created_at"): order_data["created_at"] = actual_order_data["created_at"] elif actual_order_data.get("add_time"): order_data["created_at"] = actual_order_data["add_time"] elif actual_order_data.get("dateAdded"): order_data["created_at"] = actual_order_data["dateAdded"] # 商品列表 - 直接使用 Mall API 返回的 orderProduct 字段 order_product = actual_order_data.get("orderProduct", []) # 记录商品列表数据结构（用于调试） logger.info( "Parsing orderProduct array", has_order_product=bool(order_product), order_product_count=len(order_product) if isinstance(order_product, list) else 0, order_product_type=type(order_product).__name__ ) if order_product and isinstance(order_product, list) and len(order_product) > 0: order_data["items"] = [] for product in order_product: if not isinstance(product, dict): continue item_data = { "name": product.get("productName", product.get("name", product.get("product_name", "未知商品"))), "quantity": product.get("quantity", product.get("num", product.get("productNum", 1))), "price": product.get("price", product.get("productPrice", product.get("product_price", "0.00"))) } # 商品图片直接从 product 的 imageUrl 字段获取 image_url = product.get("imageUrl") if image_url: item_data["image_url"] = image_url order_data["items"].append(item_data) # 备注 if actual_order_data.get("remark") or actual_order_data.get("user_remark"): order_data["remark"] = actual_order_data.get("remark", actual_order_data.get("user_remark", "")) # 物流信息（如果有）- 添加 has_parcels 标记用于判断是否显示物流按钮 has_parcels = actual_order_data.get("parcels") and len(actual_order_data.get("parcels", [])) > 0 order_data["has_parcels"] = has_parcels if has_parcels: # parcels 是一个数组，包含物流信息 first_parcel = actual_order_data["parcels"][0] if isinstance(actual_order_data["parcels"], list) else actual_order_data["parcels"] if isinstance(first_parcel, dict): logistics_info = { "carrier": first_parcel.get("courier", first_parcel.get("carrier", first_parcel.get("company", ""))), "tracking_number": first_parcel.get("trackingCode", first_parcel.get("tracking_number", first_parcel.get("trackingNumber", ""))), } # 只有在有有效数据时才添加 if logistics_info["carrier"] or logistics_info["tracking_number"]: order_data["logistics"] = logistics_info # 收货地址 shipping_firstname = actual_order_data.get("shippingFirstname", "") shipping_lastname = actual_order_data.get("shippingLastname", "") shipping_company = actual_order_data.get("shippingCompany", "") shipping_address_1 = actual_order_data.get("shippingAddress_1", "") shipping_address_2 = actual_order_data.get("shippingAddress_2", "") shipping_city = actual_order_data.get("shippingCity", "") shipping_postcode = actual_order_data.get("shippingPostcode", "") shipping_country = actual_order_data.get("shippingCountry", "") shipping_zone = actual_order_data.get("shippingZone", "") # 如果有任何地址字段存在，构建收货地址 if any([shipping_firstname, shipping_lastname, shipping_address_1, shipping_city]): order_data["shipping_address"] = { "name": f"{shipping_firstname} {shipping_lastname}".strip() or "", "line1": shipping_address_1 or "", "line2": shipping_address_2 or "", "city": shipping_city or "", "state": shipping_zone or "", "postal_code": shipping_postcode or "", "country": shipping_country or "" } # 发票地址 billing_firstname = actual_order_data.get("paymentFirstname", "") billing_lastname = actual_order_data.get("paymentLastname", "") billing_company = actual_order_data.get("paymentCompany", "") billing_address_1 = actual_order_data.get("paymentAddress_1", "") billing_address_2 = actual_order_data.get("paymentAddress_2", "") billing_city = actual_order_data.get("paymentCity", "") billing_postcode = actual_order_data.get("paymentPostcode", "") billing_country = actual_order_data.get("paymentCountry", "") billing_zone = actual_order_data.get("paymentZone", "") # 如果有任何地址字段存在，构建发票地址 if any([billing_firstname, billing_lastname, billing_address_1, billing_city]): order_data["billing_address"] = { "name": f"{billing_firstname} {billing_lastname}".strip() or "", "line1": billing_address_1 or "", "line2": billing_address_2 or "", "city": billing_city or "", "state": billing_zone or "", "postal_code": billing_postcode or "", "country": billing_country or "" } return order_data def _parse_order_data(data: dict[str, Any]) -> dict[str, Any]: """解析历史订单数据""" return _parse_mall_order_data(data) def _parse_logistics_data(data: dict[str, Any]) -> dict[str, Any]: """解析物流数据""" # MCP 返回结构: {"success": true, "result": {...物流数据...}} mcp_result = data.get("result", data) if data.get("result") else data logger.info( "Parsing logistics data", data_keys=list(data.keys()) if isinstance(data, dict) else None, has_result_in_data=bool(data.get("result")), mcp_result_keys=list(mcp_result.keys()) if isinstance(mcp_result, dict) else None, raw_tracking_number_value=repr(mcp_result.get("tracking_number")) if mcp_result.get("tracking_number") is not None else None, raw_courier_value=repr(mcp_result.get("courier")) if mcp_result.get("courier") is not None else None, has_tracking_number=bool(mcp_result.get("tracking_number")), has_courier=bool(mcp_result.get("courier")), has_timeline=bool(mcp_result.get("timeline")) ) return { "order_id": mcp_result.get("order_id", ""), # 添加订单号 "carrier": mcp_result.get("courier", mcp_result.get("carrier", mcp_result.get("express_name", "未知"))), "tracking_number": mcp_result.get("tracking_number") or "", "tracking_url": mcp_result.get("tracking_url", mcp_result.get("trackingUrl", "")), # 添加追踪链接 "status": mcp_result.get("status"), "estimated_delivery": mcp_result.get("estimatedDelivery"), "timeline": mcp_result.get("timeline", []) } async def _generate_text_response(state: AgentState) -> AgentState: """生成纯文本回复（降级方案）""" # Build context from tool results tool_context = [] for result in state["tool_results"]: if result["success"]: data = result["data"] tool_context.append(f"工具 {result['tool_name']} 返回:\n{json.dumps(data, ensure_ascii=False, indent=2)}") else: tool_context.append(f"工具 {result['tool_name']} 执行失败: {result['error']}") prompt = f"""基于以下订单系统返回的信息，生成对用户的回复。 用户问题: {state["current_message"]} 系统返回信息: {chr(10).join(tool_context)} 请生成一个清晰、友好的回复，包含订单的关键信息（订单号、状态、金额、物流等）。 如果是物流信息，请按时间线整理展示。 只返回回复内容，不要返回 JSON。""" messages = [ Message(role="system", content="你是一个专业的订单客服助手，请根据系统返回的信息回答用户的订单问题。"), Message(role="user", content=prompt) ] try: llm = get_llm_client() response = await llm.chat(messages, temperature=0.7) state = set_response(state, response.content) return state except Exception as e: logger.error("Order response generation failed", error=str(e)) state = set_response(state, "抱歉，处理订单信息时遇到问题。请稍后重试或联系人工客服。") return state