""" 频道/IM绑定 API 参考 QwenPaw / 悟空IM 标准设计，支持飞书、微信、钉钉、WhatsApp、Telegram、Slack """ from fastapi import APIRouter, Body, Depends, HTTPException, Query, Header from sqlalchemy.orm import Session from sqlalchemy import and_, desc from pydantic import BaseModel, Field from typing import Optional, List import json import os import secrets import uuid import logging from datetime import datetime from ..config import APP_ACCESS_URL from ..database import get_db from ..models import ( User, Channel, ChannelMember, ChannelMessage, gen_uuid ) from ..auth import get_current_user from ..platform_adapter import get_platform_adapter, list_platforms, platform_cls_map, platform_registry from ..message_session import MessageSession, SessionType logger = logging.getLogger("aiflow") router = APIRouter() # ============================================================ # 平台接入配置 - 按 QwenPaw 标准定义 # 每个平台包含：凭证字段、AI行为开关、IM交互策略 # ============================================================ # 公共AI行为配置字段 COMMON_AI_SETTINGS = { "bot_prefix": { "key": "bot_prefix", "label": "Bot Prefix", "type": "text", "default": "@bot", "placeholder": "@bot", "tooltip": "唤醒机器人的前缀命令，用户消息以此为前缀时触发AI处理" }, "show_tool_msg": { "key": "show_tool_msg", "label": "显示工具消息", "type": "switch", "default": True, "tooltip": "是否在对话中显示AI调用工具（Function Call/MCP）时的中间消息" }, "show_thinking": { "key": "show_thinking", "label": "显示思考过程", "type": "switch", "default": False, "tooltip": "是否显示AI推理过程（如Chain-of-Thought），开启后会展示思考链" }, "stream_output": { "key": "stream_output", "label": "流式输出", "type": "switch", "default": True, "tooltip": "AI回复是否以流式（逐字）方式推送到IM平台" }, "private_chat_strategy": { "key": "private_chat_strategy", "label": "私聊策略", "type": "select", "options": ["开放", "白名单", "关闭"], "default": "开放", "tooltip": "私聊场景下的AI响应策略：开放=所有私聊均可触发AI，白名单=仅白名单用户可触发，关闭=不响应私聊" }, "group_chat_strategy": { "key": "group_chat_strategy", "label": "群聊策略", "type": "select", "options": ["开放", "需要@提及", "白名单", "关闭"], "default": "开放", "tooltip": "群聊场景下的AI响应策略：开放=群中所有消息均触发，需要@提及=仅被@Bot的消息触发" }, "require_mention": { "key": "require_mention", "label": "需要@提及", "type": "switch", "default": True, "tooltip": "群聊中是否需要@机器人才会触发AI响应" }, "whitelist_users": { "key": "whitelist_users", "label": "白名单用户", "type": "tag_input", "default": [], "tooltip": "白名单策略下的用户ID列表，输入用户ID后按回车添加" }, "media_dir": { "key": "media_dir", "label": "媒体文件目录", "type": "text", "default": "/app/working/workspaces/default/media", "placeholder": "/app/working/workspaces/default/media", "tooltip": "IM端传输的媒体文件（图片/视频/音频）在服务端的存储目录" }, } # 飞书频道配置 PLATFORM_FEISHU = { "name": "飞书", "description": "通过飞书开放平台应用接入，支持飞书国内/海外版本，可扫码自动创建飞书Bot", "doc_url": "https://open.feishu.cn/document/home/index", "enable_region": True, # 支持地区选择 "regions": ["飞书国内", "飞书海外"], "qr_config": { "title": "扫码创建飞书机器人", "description": "打开飞书开发者后台，使用飞书管理员账号扫码授权，系统将自动创建飞书应用并获取 App ID 和 App Secret。请将获取到的凭证填入下方表单。", "qr_url": "https://open.feishu.cn/app", # 飞书开放平台 "action_label": "打开飞书开发者后台", "flow_hint": "扫码后请将获取的 App ID 和 App Secret 填入以下表单完成绑定" }, "credential_fields": [ {"key": "app_id", "label": "App ID", "type": "text", "required": True, "placeholder": "从飞书开放平台获取应用App ID", "tooltip": "飞书应用的唯一标识，在开发者后台-凭证与基础信息中获取"}, {"key": "app_secret", "label": "App Secret", "type": "password", "required": True, "placeholder": "从飞书开放平台获取应用App Secret", "tooltip": "飞书应用的密钥，需保密存储。在开发者后台-凭证与基础信息中获取"}, {"key": "encrypt_key", "label": "Encrypt Key", "type": "password", "required": False, "placeholder": "飞书事件订阅的Encrypt Key（选填）", "tooltip": "事件订阅的加密密钥，配置了事件订阅时需要填写"}, {"key": "verification_token", "label": "Verification Token", "type": "password", "required": False, "placeholder": "飞书事件订阅的Verification Token（选填）", "tooltip": "事件订阅的验证Token，配置了事件订阅时需要填写"}, ], "ai_settings": COMMON_AI_SETTINGS, } # 微信开放平台配置（需要用户提供微信开放平台AppID和AppSecret） PLATFORM_WECHAT = { "name": "微信", "description": "通过微信ClawBot官方API接入，扫描二维码授权后AI机器人将成为您的微信联系人，可通过微信个人号与AI对话。", "doc_url": "https://developers.weixin.qq.com/doc/aispeech/knowledge/openapi/Clawbotrelated.html", "qr_config": { "title": "扫码绑定微信个人号", "description": "调用微信ClawBot官方API生成授权二维码，使用微信扫码后确认授权，即可将AI机器人绑定到您的微信个人号。", "qr_url": "", # 动态生成 - 调用ClawBot API获取 "action_label": "生成绑定二维码", "flow_hint": "点击下方按钮调用微信ClawBot API生成授权二维码，使用微信扫码后确认授权", "config_guide": False }, "platform_tips": [ {"type": "info", "content": "需要先在微信开放平台(open.weixin.qq.com)注册网站应用并获取AppID和AppSecret，点击下方按钮生成授权二维码，用微信扫码完成授权"}, {"type": "warning", "content": "微信个人号每条消息最多回复10条内容，建议关闭「显示工具消息」和「显示思考过程」"}, ], "credential_fields": [ {"key": "appid", "label": "AppID", "type": "text", "required": True, "placeholder": "微信开放平台网站应用的AppID", "tooltip": "在微信开放平台-管理中心-网站应用详情页获取"}, {"key": "appsecret", "label": "AppSecret", "type": "password", "required": True, "placeholder": "微信开放平台网站应用的AppSecret", "tooltip": "在微信开放平台-管理中心-网站应用详情页获取，需保密存储"}, {"key": "bot_token", "label": "Bot Token", "type": "password", "required": False, "placeholder": "微信机器人Token（选填）", "tooltip": "如已获取Bot Token可填入，否则可留空"}, ], "extra_settings": { "message_merge": { "key": "message_merge", "label": "消息合并", "type": "switch", "default": False, "tooltip": "将多条回复合并为一条消息发送（可突破单条10条回复限制）" }, "merge_delay": { "key": "merge_delay", "label": "合并延时(毫秒)", "type": "number", "default": 500, "min": 100, "max": 5000, "show_if": {"message_merge": True}, "tooltip": "合并窗口等待时长" }, }, "ai_settings": { **COMMON_AI_SETTINGS, "show_tool_msg": {**COMMON_AI_SETTINGS["show_tool_msg"], "default": False}, "show_thinking": {**COMMON_AI_SETTINGS["show_thinking"], "default": False}, }, } # 钉钉配置 PLATFORM_DINGTALK = { "name": "钉钉", "description": "钉钉机器人接入，通过钉钉开放平台创建企业内部应用或自定义机器人", "doc_url": "https://open.dingtalk.com/document/", "qr_config": { "title": "扫码登录钉钉开发者后台", "description": "使用钉钉管理员账号扫码登录钉钉开放平台，创建企业内部应用获取 AppKey 和 AppSecret。", "qr_url": "https://open-dev.dingtalk.com/", "action_label": "打开钉钉开放平台", "flow_hint": "扫码后在开发者后台创建应用，将获取的凭证填入下方表单" }, "credential_fields": [ {"key": "app_key", "label": "AppKey", "type": "text", "required": True, "placeholder": "钉钉开放平台应用的AppKey", "tooltip": "钉钉应用的唯一标识，在钉钉开发者后台获取"}, {"key": "app_secret", "label": "AppSecret", "type": "password", "required": True, "placeholder": "钉钉开放平台应用的AppSecret", "tooltip": "钉钉应用的密钥"}, {"key": "webhook_url", "label": "Webhook URL", "type": "text", "required": False, "placeholder": "钉钉群机器人的Webhook地址（选填）", "tooltip": "如果使用自定义机器人方式接入，填写Webhook地址"}, ], "ai_settings": COMMON_AI_SETTINGS, } # WhatsApp配置 PLATFORM_WHATSAPP = { "name": "WhatsApp", "description": "Meta WhatsApp Business Platform API接入，需先配置Meta开发者应用并关联WhatsApp Business号码", "doc_url": "https://developers.facebook.com/docs/whatsapp/cloud-api", "credential_fields": [ {"key": "phone_number_id", "label": "Phone Number ID", "type": "text", "required": True, "placeholder": "WhatsApp Business号码ID", "tooltip": "在Meta开发者后台 WhatsApp-配置 中获取"}, {"key": "access_token", "label": "Access Token", "type": "password", "required": True, "placeholder": "Meta Business API的Access Token", "tooltip": "长期访问令牌，在Meta开发者后台生成"}, {"key": "verify_token", "label": "Verify Token", "type": "text", "required": False, "placeholder": "Webhook验证Token（选填）", "tooltip": "自定义的Webhook验证字符串"}, ], "ai_settings": COMMON_AI_SETTINGS, } # Telegram配置 PLATFORM_TELEGRAM = { "name": "Telegram", "description": "Telegram Bot API接入，通过@BotFather创建Bot获取Token", "doc_url": "https://core.telegram.org/bots/api", "credential_fields": [ {"key": "bot_token", "label": "Bot Token", "type": "password", "required": True, "placeholder": "从@BotFather获取的Bot Token", "tooltip": "通过Telegram @BotFather 创建机器人后获取的Token"}, ], "ai_settings": COMMON_AI_SETTINGS, } # Slack配置 PLATFORM_SLACK = { "name": "Slack", "description": "Slack App接入，通过Slack API创建Bot并配置OAuth权限", "doc_url": "https://api.slack.com/docs", "credential_fields": [ {"key": "bot_token", "label": "Bot User OAuth Token", "type": "password", "required": True, "placeholder": "Slack App的Bot User OAuth Token (xoxb-...)", "tooltip": "在Slack API后台 OAuth & Permissions 中获取"}, {"key": "app_token", "label": "App-Level Token", "type": "password", "required": False, "placeholder": "Socket Mode使用的App Token (xapp-...)（选填）", "tooltip": "如使用Socket Mode连接，需要配置App-Level Token"}, {"key": "signing_secret", "label": "Signing Secret", "type": "password", "required": False, "placeholder": "Slack签名密钥（选填）", "tooltip": "用于验证Slack请求签名的密钥"}, ], "ai_settings": COMMON_AI_SETTINGS, } PLATFORM_CONFIGS = { "feishu": PLATFORM_FEISHU, "wechat": PLATFORM_WECHAT, "dingtalk": PLATFORM_DINGTALK, "whatsapp": PLATFORM_WHATSAPP, "telegram": PLATFORM_TELEGRAM, "slack": PLATFORM_SLACK, } VALID_PLATFORMS = ("feishu", "wechat", "wecom", "dingtalk", "whatsapp", "telegram", "slack") SENSITIVE_FIELDS = {"app_secret", "secret", "access_token", "bot_token", "signing_secret", "token", "api_key", "password", "encrypt_key", "verification_token", "app_token", "verify_token", "app_key", "encoding_aes_key", "appsecret"} # ============================================================ # Pydantic Models # ============================================================ class CreateChannelRequest(BaseModel): name: str = Field(min_length=1, max_length=100) description: Optional[str] = None platform: str = Field(default="feishu") credential: Optional[dict] = None webhook_url: Optional[str] = None settings: Optional[dict] = None region: Optional[str] = None class UpdateChannelRequest(BaseModel): name: Optional[str] = None description: Optional[str] = None credential: Optional[dict] = None webhook_url: Optional[str] = None settings: Optional[dict] = None is_active: Optional[bool] = None region: Optional[str] = None class WebhookMessageRequest(BaseModel): from_user: str = Field(min_length=1, max_length=100) content: str = Field(min_length=1, max_length=10000) message_type: str = Field(default="text") class SendChannelMessageRequest(BaseModel): content: str = Field(min_length=1, max_length=10000) class AuthorizeRequest(BaseModel): platform: str = Field(default="feishu") class InviteMemberRequest(BaseModel): user_id: str # ============================================================ # Helper Functions # ============================================================ def _check_channel_access(db: Session, channel_id: str, user_id: str): member = db.query(ChannelMember).filter( and_(ChannelMember.channel_id == channel_id, ChannelMember.user_id == user_id) ).first() if not member: raise HTTPException(status_code=403, detail="您不是该频道成员") return member def _check_channel_owner(db: Session, channel_id: str, user_id: str): member = db.query(ChannelMember).filter( and_(ChannelMember.channel_id == channel_id, ChannelMember.user_id == user_id) ).first() if not member or member.role != "owner": raise HTTPException(status_code=403, detail="仅频道所有者可执行此操作") return member def _mask_credential(credential: dict) -> dict: """对凭证中的敏感字段进行脱敏处理""" if not credential: return {} masked = {} for key, value in credential.items(): value_str = str(value) if value else "" if key in SENSITIVE_FIELDS and len(value_str) > 8: masked[key] = value_str[:4] + "***...***" + value_str[-4:] elif key in SENSITIVE_FIELDS and len(value_str) > 0: masked[key] = value_str[:2] + "****" else: masked[key] = value return masked def _verify_credential(platform: str, credential: dict) -> tuple: """验证平台凭证是否完整""" if platform not in PLATFORM_CONFIGS: return False, f"不支持的平台类型: {platform}" config = PLATFORM_CONFIGS[platform] required_fields = [f for f in config["credential_fields"] if f.get("required")] for field in required_fields: if not credential or field["key"] not in credential or not credential[field["key"]]: return False, f"缺少必填字段: {field['label']} ({field['key']})" return True, "凭证验证通过" def _get_default_settings(platform: str) -> dict: """获取平台默认的AI行为设置""" if platform not in PLATFORM_CONFIGS: return {} ai_settings = PLATFORM_CONFIGS[platform].get("ai_settings", {}) defaults = {} for key, cfg in ai_settings.items(): if cfg.get("type") == "switch": defaults[key] = cfg.get("default", False) elif cfg.get("type") == "select": defaults[key] = cfg.get("default", "") elif cfg.get("type") == "tag_input": defaults[key] = cfg.get("default", []) elif cfg.get("type") == "text": defaults[key] = cfg.get("default", "") elif cfg.get("type") == "number": defaults[key] = cfg.get("default", 0) return defaults def _build_channel_response(channel: Channel, db: Session, user_id: str, include_credential: bool = False) -> dict: """构建频道响应数据""" member = db.query(ChannelMember).filter( and_(ChannelMember.channel_id == channel.id, ChannelMember.user_id == user_id) ).first() member_count = db.query(ChannelMember).filter(ChannelMember.channel_id == channel.id).count() message_count = db.query(ChannelMessage).filter(ChannelMessage.channel_id == channel.id).count() data = { "id": channel.id, "name": channel.name, "description": channel.description, "platform": channel.platform, "status": channel.status, "is_active": channel.is_active, "webhook_url": channel.webhook_url, "role": member.role if member else None, "member_count": member_count, "message_count": message_count, "default_agent_id": channel.default_agent_id, "default_skill_id": channel.default_skill_id, "knowledge_base_id": channel.knowledge_base_id, "bound_model_id": channel.bound_model_id, "settings": channel.settings, "last_active": str(channel.last_active) if channel.last_active else None, "created_at": str(channel.created_at) if channel.created_at else None, "updated_at": str(channel.updated_at) if channel.updated_at else None, } if include_credential: data["credential"] = channel.credential data["credential_masked"] = _mask_credential(channel.credential) if channel.credential else None else: data["credential_masked"] = _mask_credential(channel.credential) if channel.credential else None return data # ============================================================ # API Endpoints # ============================================================ # ---- 平台配置 ---- @router.get("/platforms/config") def get_platform_configs(): """获取各平台完整接入配置（QwenPaw标准），含凭证字段+AI行为配置+平台提示""" result = {} for platform_key, config in PLATFORM_CONFIGS.items(): result[platform_key] = { "name": config["name"], "description": config["description"], "doc_url": config["doc_url"], "credential_fields": config["credential_fields"], "ai_settings": config.get("ai_settings", {}), "extra_settings": config.get("extra_settings", {}), "platform_tips": config.get("platform_tips", []), "enable_region": config.get("enable_region", False), "regions": config.get("regions", []), "qr_config": config.get("qr_config"), # QR scan config for WeChat/Feishu/DingTalk } return {"code": 0, "data": result, "message": "ok"} # ---- 扫码授权 ---- @router.post("/authorize/scan") def scan_authorize( platform: str = Query(...), body: dict = Body({}), db: Session = Depends(get_db), current_user: User = Depends(get_current_user), ): """扫码授权流程 - 返回授权二维码（微信平台统一调用ClawBot API）""" if platform not in VALID_PLATFORMS: raise HTTPException(status_code=400, detail="不支持的平台类型") platform_name = PLATFORM_CONFIGS.get(platform, {}).get("name", platform) # 微信平台：调用微信ClawBot API获取授权二维码 if platform == "wechat": # 获取AppID和Secret（优先从请求体 > 已保存频道配置 > 环境变量） appid = "" secret = "" # 1. 从请求体获取 req_creds = body.get("credentials", {}) or {} appid = req_creds.get("appid", "") secret = req_creds.get("appsecret", "") or req_creds.get("secret", "") # 查找已保存的微信频道 existing_channel = db.query(Channel).filter( and_(Channel.platform == "wechat", Channel.owner_id == current_user.id) ).first() # 2. 从已保存的频道配置获取 if not appid or not secret: if existing_channel and existing_channel.credential: creds = existing_channel.credential if isinstance(creds, str): creds = json.loads(creds) if not appid: appid = creds.get("appid", "") if not secret: secret = creds.get("appsecret", "") # 3. 从环境变量获取兜底 if not appid: appid = os.environ.get("WECHAT_APPID", "") if not secret: secret = os.environ.get("WECHAT_SECRET", "") # 没有凭证时直接返回错误，不回退到本地QR if not appid or not secret: print(f"[WARN] WeChat credentials not found: appid={'set' if appid else 'missing'}, secret={'set' if secret else 'missing'}") return { "code": 1, "data": None, "message": "缺少微信AppID/AppSecret凭证，请在频道设置中填写或通过请求体提供", } # 有凭证 - 调用微信ClawBot API import hmac import hashlib import time as time_module clawbot_base = "https://weknora.weixin.qq.com" request_id = secrets.token_hex(16) timestamp = str(int(time_module.time())) nonce = secrets.token_hex(8) request_body = "{}" sign_string = f"{timestamp}\n{nonce}\n{request_id}\n{request_body}" if isinstance(sign_string, str): sign_string = sign_string.encode('utf-8') signature = hmac.new( secret.encode('utf-8'), sign_string, hashlib.sha256 ).hexdigest() headers = { "Content-Type": "application/json", "X-APPID": appid, "X-Request-ID": request_id, "X-Timestamp": timestamp, "X-Nonce": nonce, "X-Signature": signature, } print(f"[INFO] Calling ClawBot API: {clawbot_base}/api/v1/wechat/qrcode with appid={appid[:8]}***") try: import requests as http_requests resp = http_requests.post( f"{clawbot_base}/api/v1/wechat/qrcode", json={}, headers=headers, timeout=10, ) resp_body = resp.text print(f"[INFO] ClawBot API response: HTTP {resp.status_code}, body={resp_body[:300]}") # 尝试解析JSON try: qrcode_data = resp.json() except ValueError: print(f"[WARN] ClawBot API returned non-JSON response") return { "code": 1, "data": None, "message": f"微信ClawBot API返回了非JSON响应: {resp_body[:200]}", } # 微信API成功响应: {"success": true, "data": {"qrcode_url": "...", "qrcode": "..."}} if resp.status_code == 200 and qrcode_data.get("success") and qrcode_data.get("data"): qr_url = qrcode_data["data"].get("qrcode_url", "") qrcode_token = qrcode_data["data"].get("qrcode", "") if existing_channel: existing_channel.oauth_state = qrcode_token db.commit() else: # 如果没有现有频道，生成一个临时token保存在响应中 print(f"[INFO] No existing channel found, returning qrcode token directly") print(f"[INFO] ClawBot real QR obtained: token={qrcode_token}") return { "code": 0, "data": { "platform": platform, "platform_name": platform_name, "qr_url": qr_url, "qrcode": qrcode_token, "qrcode_token": qrcode_token, "status": "waiting", "is_mock": False, "message": "请使用微信扫描二维码完成授权", "expires_in": 300, }, "message": "ok", } # ClawBot API返回了错误 error_msg = "" if qrcode_data.get("error"): err = qrcode_data["error"] error_msg = err.get("message", "") or err.get("detail", "") or str(err) elif qrcode_data.get("message"): error_msg = qrcode_data["message"] print(f"[WARN] ClawBot API returned error (HTTP {resp.status_code}): {error_msg}") return { "code": 1, "data": {"error": error_msg or f"HTTP {resp.status_code}"}, "message": f"微信ClawBot API调用失败: {error_msg or '未知错误'}", } except Exception as e: print(f"[ERROR] ClawBot API call exception: {e}") import traceback traceback.print_exc() return { "code": 1, "data": {"error": str(e)}, "message": f"微信ClawBot API调用异常: {str(e)}", } # 其他平台：返回模拟授权数据 binding_token = str(uuid.uuid4()) # 查找已有频道并关联binding_token existing_channel = db.query(Channel).filter( and_(Channel.platform == platform, Channel.owner_id == current_user.id) ).first() if existing_channel: existing_channel.oauth_state = binding_token db.commit() return { "code": 0, "data": { "platform": platform, "platform_name": platform_name, "qr_url": "", "qrcode": binding_token, "status": "waiting", "message": f"请在{platform_name}客户端完成授权", "expires_in": 300, }, "message": "ok", } @router.post("/authorize/scan/status") def scan_authorize_status( platform: str = Query(...), db: Session = Depends(get_db), current_user: User = Depends(get_current_user), ): """查询扫码授权状态（微信平台调用ClawBot API轮询）""" if platform not in VALID_PLATFORMS: raise HTTPException(status_code=400, detail="不支持的平台类型") # 微信平台：调用ClawBot API轮询扫码状态 if platform == "wechat": channel = db.query(Channel).filter( and_(Channel.platform == "wechat", Channel.owner_id == current_user.id) ).first() qrcode_token = channel.oauth_state if channel else None if not qrcode_token: return { "code": 0, "data": {"platform": platform, "status": "expired"}, "message": "二维码已过期，请重新生成", } # 获取AppID和Secret用于签名 appid = os.environ.get("WECHAT_APPID", "") secret = os.environ.get("WECHAT_SECRET", "") if channel and channel.credential: creds = channel.credential if isinstance(creds, str): creds = json.loads(creds) appid = creds.get("appid", appid) secret = creds.get("appsecret", secret) import hmac import hashlib import time as time_module clawbot_base = "https://weknora.weixin.qq.com" request_id = secrets.token_hex(16) timestamp = str(int(time_module.time())) nonce = secrets.token_hex(8) request_body = json.dumps({"qrcode": qrcode_token}) sign_string = f"{timestamp}\n{nonce}\n{request_id}\n{request_body}" if isinstance(sign_string, str): sign_string = sign_string.encode('utf-8') signature = hmac.new( secret.encode('utf-8'), sign_string, hashlib.sha256 ).hexdigest() headers = { "Content-Type": "application/json", "X-APPID": appid, "X-Request-ID": request_id, "X-Timestamp": timestamp, "X-Nonce": nonce, "X-Signature": signature, } try: import requests as http_requests resp = http_requests.post( f"{clawbot_base}/api/v1/wechat/qrcode/status", json={"qrcode": qrcode_token}, headers=headers, timeout=30, ) status_data = resp.json() print(f"[INFO] ClawBot QR status: {json.dumps(status_data, ensure_ascii=False)[:300]}") if status_data.get("success") and status_data.get("data"): data = status_data["data"] status = data.get("status", "wait") if status == "confirmed": # 保存授权凭据 credentials = data.get("credentials", {}) baseurl = data.get("baseurl", clawbot_base) if channel: creds_store = channel.credential or {} if isinstance(creds_store, str): creds_store = json.loads(creds_store) creds_store["bot_token"] = credentials.get("bot_token", "") creds_store["ilink_bot_id"] = credentials.get("ilink_bot_id", "") creds_store["ilink_user_id"] = credentials.get("ilink_user_id", "") creds_store["baseurl"] = baseurl creds_store["authorized_at"] = datetime.now().isoformat() channel.credential = creds_store channel.status = "connected" channel.oauth_state = "" db.commit() print(f"[INFO] WeChat channel connected: channel_id={channel.id}") return { "code": 0, "data": { "platform": platform, "status": "authorized", "credentials": credentials, "baseurl": baseurl, }, "message": "授权成功！微信个人号已绑定", } else: return { "code": 0, "data": {"platform": platform, "status": status}, "message": f"状态: {status}", } else: print(f"[WARN] ClawBot QR status API returned unexpected response: {json.dumps(status_data, ensure_ascii=False)[:200]}") return { "code": 0, "data": {"platform": platform, "status": "error"}, "message": status_data.get("message", "查询状态失败"), } except Exception as e: print(f"[ERROR] ClawBot status check failed: {e}") import traceback traceback.print_exc() return { "code": 1, "data": {"platform": platform, "status": "error"}, "message": f"微信ClawBot状态查询异常: {str(e)}", } # 其他平台：返回模拟授权状态 access_token = f"sim_{platform}_{secrets.token_hex(16)}" return { "code": 0, "data": { "platform": platform, "status": "authorized", "access_token": access_token, "credential": _generate_mock_credential(platform), }, "message": "授权成功", } def _generate_mock_credential(platform: str) -> dict: """根据平台生成模拟凭证""" mock_map = { "feishu": {"app_id": "cli_a" + secrets.token_hex(8), "app_secret": secrets.token_hex(16)}, "wechat": {"appid": "wx" + secrets.token_hex(8), "appsecret": secrets.token_hex(16)}, "dingtalk": {"app_key": "ding" + secrets.token_hex(8), "app_secret": secrets.token_hex(16)}, "whatsapp": {"phone_number_id": "10" + "".join([str(secrets.randbelow(10)) for _ in range(13)]), "access_token": "EAA" + secrets.token_hex(32)}, "telegram": {"bot_token": f"{secrets.randbelow(10**9)}:AA" + secrets.token_hex(16)}, "slack": {"bot_token": "xoxb-" + secrets.token_hex(20)}, } return mock_map.get(platform, {"token": secrets.token_hex(16)}) # ---- 频道列表 ---- @router.get("/") def list_channels( db: Session = Depends(get_db), current_user: User = Depends(get_current_user), ): """获取用户所在的所有频道""" memberships = db.query(ChannelMember).filter( ChannelMember.user_id == current_user.id ).all() channel_ids = [m.channel_id for m in memberships] if not channel_ids: return {"code": 0, "data": [], "message": "ok"} channels = db.query(Channel).filter(Channel.id.in_(channel_ids)).order_by(desc(Channel.updated_at)).all() result = [] for ch in channels: member = next((m for m in memberships if m.channel_id == ch.id), None) member_count = db.query(ChannelMember).filter(ChannelMember.channel_id == ch.id).count() message_count = db.query(ChannelMessage).filter(ChannelMessage.channel_id == ch.id).count() result.append({ "id": ch.id, "name": ch.name, "description": ch.description, "platform": ch.platform, "status": ch.status, "is_active": ch.is_active, "role": member.role if member else None, "member_count": member_count, "message_count": message_count, "credential_masked": _mask_credential(ch.credential) if ch.credential else None, "created_at": str(ch.created_at) if ch.created_at else None, "updated_at": str(ch.updated_at) if ch.updated_at else None, }) return {"code": 0, "data": result, "message": "ok"} # ---- 创建频道 (静态路由必须在动态路由之前) ---- @router.post("/") def create_channel( req: CreateChannelRequest, db: Session = Depends(get_db), current_user: User = Depends(get_current_user), ): """创建新频道，支持QwenPaw标准配置""" if req.platform not in VALID_PLATFORMS: raise HTTPException(status_code=400, detail="不支持的平台类型") # 构建默认 settings（AI行为配置） default_ai_settings = _get_default_settings(req.platform) merged_settings = {**default_ai_settings, **(req.settings or {})} if req.region: merged_settings["region"] = req.region channel = Channel( id=gen_uuid(), owner_id=current_user.id, name=req.name, description=req.description, platform=req.platform, webhook_url=req.webhook_url, credential=req.credential, settings=merged_settings, status="pending", is_active=True, created_at=datetime.now(), updated_at=datetime.now(), ) db.add(channel) db.flush() member = ChannelMember( id=gen_uuid(), channel_id=channel.id, user_id=current_user.id, role="owner", joined_at=datetime.now(), ) db.add(member) db.commit() db.refresh(channel) return { "code": 0, "data": _build_channel_response(channel, db, current_user.id, include_credential=True), "message": "频道创建成功", } # ---- 频道详情 ---- @router.get("/{channel_id}") def get_channel( channel_id: str, db: Session = Depends(get_db), current_user: User = Depends(get_current_user), ): """获取频道详情""" _check_channel_access(db, channel_id, current_user.id) channel = db.query(Channel).filter(Channel.id == channel_id).first() if not channel: raise HTTPException(status_code=404, detail="频道不存在") return { "code": 0, "data": _build_channel_response(channel, db, current_user.id, include_credential=True), "message": "ok", } # ---- 更新频道配置 ---- @router.put("/{channel_id}") def update_channel( channel_id: str, req: UpdateChannelRequest, db: Session = Depends(get_db), current_user: User = Depends(get_current_user), ): """更新频道配置，支持完整QwenPaw标准settings""" _check_channel_owner(db, channel_id, current_user.id) channel = db.query(Channel).filter(Channel.id == channel_id).first() if not channel: raise HTTPException(status_code=404, detail="频道不存在") if req.name is not None: channel.name = req.name if req.description is not None: channel.description = req.description if req.webhook_url is not None: channel.webhook_url = req.webhook_url if req.region is not None: existing_settings = channel.settings or {} existing_settings["region"] = req.region channel.settings = existing_settings if req.credential is not None: is_valid, err_msg = _verify_credential(channel.platform, req.credential) if not is_valid: raise HTTPException(status_code=400, detail=err_msg) channel.credential = req.credential if req.settings is not None: # 合并 settings（保留未提交的配置项） existing = channel.settings or {} channel.settings = {**existing, **req.settings} settings = channel.settings if "agent_id" in settings: channel.default_agent_id = settings["agent_id"] if "knowledge_base_id" in settings: channel.knowledge_base_id = settings["knowledge_base_id"] if "skill_ids" in settings: skill_ids = settings["skill_ids"] if isinstance(skill_ids, list) and len(skill_ids) > 0: channel.default_skill_id = skill_ids[0] if req.is_active is not None: channel.is_active = req.is_active channel.updated_at = datetime.now() db.commit() db.refresh(channel) return { "code": 0, "data": _build_channel_response(channel, db, current_user.id, include_credential=True), "message": "更新成功", } # ---- 删除频道 ---- @router.delete("/{channel_id}") def delete_channel( channel_id: str, db: Session = Depends(get_db), current_user: User = Depends(get_current_user), ): """删除频道及其关联数据""" _check_channel_owner(db, channel_id, current_user.id) channel = db.query(Channel).filter(Channel.id == channel_id).first() if not channel: raise HTTPException(status_code=404, detail="频道不存在") db.query(ChannelMessage).filter(ChannelMessage.channel_id == channel_id).delete() db.query(ChannelMember).filter(ChannelMember.channel_id == channel_id).delete() db.delete(channel) db.commit() return {"code": 0, "message": "频道已删除"} # ---- 连接/断开频道 ---- @router.post("/{channel_id}/connect") def connect_channel( channel_id: str, db: Session = Depends(get_db), current_user: User = Depends(get_current_user), ): """连接频道""" _check_channel_owner(db, channel_id, current_user.id) channel = db.query(Channel).filter(Channel.id == channel_id).first() if not channel: raise HTTPException(status_code=404, detail="频道不存在") platform = channel.platform if platform not in PLATFORM_CONFIGS: raise HTTPException(status_code=400, detail=f"不支持的平台类型: {platform}") if not channel.credential: raise HTTPException(status_code=400, detail="尚未配置平台凭证，请先填写接入配置") is_valid, err_msg = _verify_credential(platform, channel.credential) if not is_valid: raise HTTPException(status_code=400, detail=f"凭证配置不完整: {err_msg}") channel.status = "connected" channel.is_active = True channel.last_active = datetime.now() channel.updated_at = datetime.now() db.commit() db.refresh(channel) platform_name = PLATFORM_CONFIGS[platform]["name"] return { "code": 0, "data": { "connected": True, "platform": platform, "platform_name": platform_name, "status": "connected", "message": f"{platform_name}平台连接成功，AI机器人已在线", "connected_at": str(datetime.now()), }, "message": "连接成功", } @router.post("/{channel_id}/disconnect") def disconnect_channel( channel_id: str, db: Session = Depends(get_db), current_user: User = Depends(get_current_user), ): """断开频道连接""" _check_channel_owner(db, channel_id, current_user.id) channel = db.query(Channel).filter(Channel.id == channel_id).first() if not channel: raise HTTPException(status_code=404, detail="频道不存在") channel.status = "disconnected" channel.updated_at = datetime.now() db.commit() db.refresh(channel) return { "code": 0, "data": {"id": channel.id, "status": channel.status, "message": "频道已断开连接"}, "message": "已断开连接", } # ---- Webhook 模拟消息 ---- @router.post("/{channel_id}/webhook") def webhook_receive_message( channel_id: str, req: WebhookMessageRequest, db: Session = Depends(get_db), current_user: User = Depends(get_current_user), ): """模拟IM平台消息接收""" _check_channel_access(db, channel_id, current_user.id) channel = db.query(Channel).filter(Channel.id == channel_id).first() if not channel: raise HTTPException(status_code=404, detail="频道不存在") if channel.status != "connected": raise HTTPException(status_code=400, detail="频道未连接，无法接收消息") user_msg = ChannelMessage( id=gen_uuid(), channel_id=channel_id, user_id=current_user.id, role="user", content=f"[{req.from_user}] {req.content}", created_at=datetime.now(), ) db.add(user_msg) platform_name = PLATFORM_CONFIGS.get(channel.platform, {}).get("name", "IM平台") ai_reply = _generate_ai_reply(req.content, channel, platform_name, current_user) ai_msg = ChannelMessage( id=gen_uuid(), channel_id=channel_id, user_id=current_user.id, role="assistant", content=ai_reply, token_used=len(ai_reply), created_at=datetime.now(), ) db.add(ai_msg) channel.last_active = datetime.now() channel.updated_at = datetime.now() db.commit() db.refresh(user_msg) db.refresh(ai_msg) return { "code": 0, "data": { "received": { "id": user_msg.id, "from_user": req.from_user, "content": req.content, "message_type": req.message_type, "created_at": str(user_msg.created_at), }, "reply": { "id": ai_msg.id, "content": ai_reply, "role": "assistant", "created_at": str(ai_msg.created_at), }, }, "message": "消息已处理", } def _generate_ai_reply(user_content: str, channel: Channel, platform_name: str, user: User) -> str: """生成模拟AI回复消息""" content_lower = user_content.lower().strip() greetings = ["你好", "hi", "hello", "嗨", "早上好", "下午好", "晚上好"] for g in greetings: if g in content_lower: return f"你好！我是通过{platform_name}接入的AI助手{channel.name}。我可以帮你解答问题、查询数据、执行任务等，请随时告诉我你的需求。" if "天气" in content_lower: return "根据最新气象数据，今天天气晴好，气温22-30℃，适合外出活动。如需详细天气预报，请告知具体城市。" if "销售" in content_lower or "数据" in content_lower: return "已查询今日数据。截至当前，GMV为12.8万元，订单量326单，环比昨日同期增长8.5%。详细报表已整理完成，可随时导出。" if "任务" in content_lower or "待办" in content_lower: return "你当前有3项待办任务：\n1. 审核市场推广方案（截止今日18:00）\n2. 周报提交（截止明日10:00）\n3. 团队例会准备（截止本周五）\n需要我帮你处理哪一项？" if "帮助" in content_lower or "help" in content_lower or "能做什么" in content_lower: return f"我是通过{platform_name}接入的AI智能助手，可以为你提供以下服务：\n- 数据查询与分析\n- 任务管理与提醒\n- 文档撰写与总结\n- 智能问答与信息检索\n- 图表生成与报表导出\n请直接告诉我你的需求。" if "谢谢" in content_lower or "感谢" in content_lower: return "不客气！很高兴能帮到你。如有其他需要，随时找我。" content_preview = user_content[:50] + ("..." if len(user_content) > 50 else "") return f"收到你的消息：{content_preview}。\n\n我是通过{platform_name}接入的AI助手，正在为你处理这个请求。请稍候，我会尽快给出回复。如果需要更具体的帮助，请详细描述你的需求。" # ---- 频道消息 ---- @router.get("/{channel_id}/messages") def get_channel_messages( channel_id: str, limit: int = Query(default=50, ge=1, le=200), offset: int = Query(default=0, ge=0), db: Session = Depends(get_db), current_user: User = Depends(get_current_user), ): """获取频道消息列表""" _check_channel_access(db, channel_id, current_user.id) messages = ( db.query(ChannelMessage) .filter(ChannelMessage.channel_id == channel_id) .order_by(desc(ChannelMessage.created_at)) .offset(offset) .limit(limit) .all() ) result = [] for msg in messages: sender = db.query(User).filter(User.id == msg.user_id).first() result.append({ "id": msg.id, "channel_id": msg.channel_id, "user_id": msg.user_id, "username": sender.username if sender else "unknown", "avatar": sender.avatar if sender else None, "role": msg.role, "content": msg.content, "token_used": msg.token_used, "created_at": str(msg.created_at) if msg.created_at else None, }) return {"code": 0, "data": result, "message": "ok"} @router.post("/{channel_id}/messages") def send_channel_message( channel_id: str, req: SendChannelMessageRequest, db: Session = Depends(get_db), current_user: User = Depends(get_current_user), ): """用户手动发送消息""" _check_channel_access(db, channel_id, current_user.id) channel = db.query(Channel).filter(Channel.id == channel_id).first() if not channel: raise HTTPException(status_code=404, detail="频道不存在") msg = ChannelMessage( id=gen_uuid(), channel_id=channel_id, user_id=current_user.id, role="user", content=req.content, created_at=datetime.now(), ) db.add(msg) platform_name = PLATFORM_CONFIGS.get(channel.platform, {}).get("name", "IM平台") ai_reply = _generate_ai_reply(req.content, channel, platform_name, current_user) ai_msg = ChannelMessage( id=gen_uuid(), channel_id=channel_id, user_id=current_user.id, role="assistant", content=ai_reply, token_used=len(ai_reply), created_at=datetime.now(), ) db.add(ai_msg) channel.last_active = datetime.now() channel.updated_at = datetime.now() db.commit() db.refresh(msg) db.refresh(ai_msg) return { "code": 0, "data": { "message": {"id": msg.id, "channel_id": msg.channel_id, "user_id": msg.user_id, "content": msg.content, "created_at": str(msg.created_at)}, "reply": {"id": ai_msg.id, "content": ai_reply, "role": "assistant", "created_at": str(ai_msg.created_at)}, "webhook_response": {"status": "delivered", "platform": channel.platform, "message": f"消息已通过{platform_name}通道成功推送"}, }, "message": "发送成功", } # ---- 频道成员管理 ---- @router.get("/{channel_id}/members") def get_channel_members( channel_id: str, db: Session = Depends(get_db), current_user: User = Depends(get_current_user), ): """获取频道成员列表""" _check_channel_access(db, channel_id, current_user.id) members = db.query(ChannelMember).filter(ChannelMember.channel_id == channel_id).all() result = [] for m in members: user = db.query(User).filter(User.id == m.user_id).first() result.append({ "id": m.id, "user_id": m.user_id, "username": user.username if user else "unknown", "avatar": user.avatar if user else None, "role": m.role, "joined_at": str(m.joined_at) if m.joined_at else None, }) return {"code": 0, "data": result, "message": "ok"} @router.post("/{channel_id}/members") def invite_member( channel_id: str, req: InviteMemberRequest, db: Session = Depends(get_db), current_user: User = Depends(get_current_user), ): """邀请成员加入频道""" _check_channel_owner(db, channel_id, current_user.id) channel = db.query(Channel).filter(Channel.id == channel_id).first() if not channel: raise HTTPException(status_code=404, detail="频道不存在") target_user = db.query(User).filter(User.id == req.user_id).first() if not target_user: raise HTTPException(status_code=404, detail="用户不存在") existing = db.query(ChannelMember).filter( and_(ChannelMember.channel_id == channel_id, ChannelMember.user_id == req.user_id) ).first() if existing: raise HTTPException(status_code=400, detail="该用户已是频道成员") member = ChannelMember( id=gen_uuid(), channel_id=channel_id, user_id=req.user_id, role="member", joined_at=datetime.now(), ) db.add(member) channel.updated_at = datetime.now() db.commit() db.refresh(member) return {"code": 0, "data": { "id": member.id, "user_id": member.user_id, "role": member.role, "joined_at": str(member.joined_at), }, "message": "邀请成功"} @router.delete("/{channel_id}/members/{member_user_id}") def remove_member( channel_id: str, member_user_id: str, db: Session = Depends(get_db), current_user: User = Depends(get_current_user), ): """移除频道成员""" _check_channel_owner(db, channel_id, current_user.id) if member_user_id == current_user.id: raise HTTPException(status_code=400, detail="不能移除自己，请使用删除频道功能") member = db.query(ChannelMember).filter( and_(ChannelMember.channel_id == channel_id, ChannelMember.user_id == member_user_id) ).first() if not member: raise HTTPException(status_code=404, detail="该用户不在频道中") db.delete(member) channel = db.query(Channel).filter(Channel.id == channel_id).first() if channel: channel.updated_at = datetime.now() db.commit() return {"code": 0, "message": "成员已移除"} # ---- 授权（兼容） ---- @router.post("/authorize") def authorize_platform( req: AuthorizeRequest, current_user: User = Depends(get_current_user), ): """OAuth授权流程（兼容旧接口）""" if req.platform not in VALID_PLATFORMS: raise HTTPException(status_code=400, detail="不支持的平台类型") access_token = f"sim_{req.platform}_{secrets.token_hex(16)}" return { "code": 0, "data": { "authorized": True, "platform": req.platform, "access_token": access_token, }, "message": "ok", } # ---- OAuth2回调与频道重置 ---- @router.post("/authorize/scan/channel_reset") def channel_reset( channel_id: str = Query(...), db: Session = Depends(get_db), current_user: User = Depends(get_current_user), ): """重置微信IM通道 - 对应ClawBot文档 POST /api/v1/wechat/channel_reset""" channel = db.query(Channel).filter( and_(Channel.id == channel_id, Channel.owner_id == current_user.id) ).first() if not channel: raise HTTPException(status_code=404, detail="频道不存在") # 微信平台：调用ClawBot API重置通道 if channel.platform == "wechat": # 获取AppID和Secret用于签名 appid = os.environ.get("WECHAT_APPID", "") secret = os.environ.get("WECHAT_SECRET", "") if channel.credential: creds = channel.credential if isinstance(creds, str): creds = json.loads(creds) appid = creds.get("appid", appid) secret = creds.get("appsecret", secret) import hmac import hashlib import time as time_module clawbot_base = "https://weknora.weixin.qq.com" request_id = secrets.token_hex(16) timestamp = str(int(time_module.time())) nonce = secrets.token_hex(8) request_body = json.dumps({"channel_id": channel_id}) sign_string = f"{timestamp}\n{nonce}\n{request_id}\n{request_body}" if isinstance(sign_string, str): sign_string = sign_string.encode('utf-8') signature = hmac.new( secret.encode('utf-8'), sign_string, hashlib.sha256 ).hexdigest() headers = { "Content-Type": "application/json", "X-APPID": appid, "X-Request-ID": request_id, "X-Timestamp": timestamp, "X-Nonce": nonce, "X-Signature": signature, } print(f"[INFO] Calling ClawBot channel_reset: channel_id={channel_id}") try: import requests as http_requests resp = http_requests.post( f"{clawbot_base}/api/v1/wechat/channel_reset", json={"channel_id": channel_id}, headers=headers, timeout=10, ) print(f"[INFO] ClawBot channel_reset response: HTTP {resp.status_code}, body={resp.text[:300]}") except Exception as e: print(f"[WARN] ClawBot channel_reset API call failed: {e}") import traceback traceback.print_exc() # 清空本地 channel 的 oauth_state 和 credential channel.status = "pending" channel.oauth_state = "" channel.credential = {} channel.updated_at = datetime.now() db.commit() return { "code": 0, "data": { "message": "IM通道重置任务已提交", "channel_id": channel_id, }, "message": "通道已重置", } # ============================================================ # 统一Webhook端点 - AstrBot借鉴优化方案 P0.2 + P1 # 所有IM平台消息通过此入口接入，使用平台适配器模式 # ============================================================ @router.post("/webhook/{platform}") def unified_webhook( platform: str, payload: dict = Body(...), signature: str = Header(None, alias="X-Webhook-Signature"), timestamp: str = Header(None, alias="X-Webhook-Timestamp"), db: Session = Depends(get_db), ): """统一Webhook端点：所有IM平台消息通过此入口接入（使用适配器模式） 流程: 1. 根据platform参数识别平台（使用platform_cls_map注册表） 2. 查找活跃频道获取配置 3. 使用平台适配器验证签名 4. 使用平台适配器解析消息为统一格式 5. 创建MessageSession和ChannelMessage记录 6. 返回标准Webhook响应 """ # 使用适配器注册表验证平台 if platform not in platform_cls_map: raise HTTPException( status_code=400, detail=f"不支持的平台: {platform}. 可用: {list(platform_cls_map.keys())}" ) logger.info(f"[Webhook] 收到 {platform} 平台消息: signature={signature is not None}") # URL验证必须在频道存在性检查之前——平台验证URL时与频道是否存在无关 if platform == "feishu" and payload.get("challenge"): logger.info(f"[Webhook-FeiShu] URL验证请求") return {"challenge": payload["challenge"]} if platform == "slack" and payload.get("type") == "url_verification": logger.info(f"[Webhook-Slack] URL验证请求") return {"challenge": payload.get("challenge", "")} # 查找活跃频道获取配置 channel = db.query(Channel).filter( Channel.platform == platform, Channel.is_active == True, ).first() if not channel: return { "code": 0, "data": {"handled": False}, "message": f"无活跃的{platform}频道", } # 创建平台适配器实例 try: adapter = get_platform_adapter(platform, channel.credential or {}) except Exception as e: logger.error(f"[Webhook] 创建平台适配器失败: {e}") raise HTTPException(status_code=500, detail=f"平台适配器初始化失败: {str(e)}") # 验证签名 if signature: if not adapter.verify_signature(payload, signature, timestamp): logger.warning(f"[Webhook] {platform} 签名验证失败") raise HTTPException(status_code=401, detail="Webhook签名验证失败") # 解析消息为统一格式 parsed = adapter.parse_webhook(payload) # 创建MessageSession统一会话标识 session = MessageSession.from_channel_event( platform=platform, channel_id=channel.id, user_id=parsed.get("sender_id", ""), group_id=parsed.get("group_id"), ) # 创建消息记录 msg_id = gen_uuid() channel_msg = ChannelMessage( id=msg_id, channel_id=channel.id, user_id=channel.owner_id, role="user", content=parsed.get("content", ""), token_used=0, created_at=datetime.now(), ) db.add(channel_msg) # 更新频道最后活跃时间 channel.last_active = datetime.now() channel.updated_at = datetime.now() db.commit() # 发布到事件总线（Redis队列），异步处理 try: from ..event_bus import MessageEvent, get_event_bus event = MessageEvent( platform=platform, channel_id=channel.id, content=parsed.get("content", ""), sender_id=parsed.get("sender_id", ""), sender_name=parsed.get("sender_name", ""), message_id=str(msg_id), group_id=parsed.get("group_id"), content_type=parsed.get("content_type", "text"), raw=payload, ) get_event_bus().publish(event) logger.info(f"[Webhook] 事件已发布到EventBus: {platform}:{msg_id}") except Exception as e: logger.warning(f"[Webhook] EventBus发布失败(不影响消息接收): {e}") logger.info( f"[Webhook] 消息已记录: platform={platform}, " f"channel={channel.name}, msg_id={msg_id}, session={session}" ) return { "code": 0, "data": { "handled": True, "message_id": msg_id, "session": str(session), "platform": platform, }, "message": "消息已接收", } @router.get("/webhook/platforms") def list_supported_platforms(): """列出所有支持的平台（从适配器注册表获取）""" platforms = [] for name, meta in platform_registry.items(): platforms.append({ "name": meta.name, "display_name": meta.display_name, "description": meta.description, "icon": meta.icon, "support_streaming": meta.support_streaming, "support_image": meta.support_image, "support_file": meta.support_file, "support_voice": meta.support_voice, }) return {"code": 0, "data": {"platforms": platforms}, "message": "ok"}