shihao/WechatHookBot
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feta:api统一为Gemini格式

Browse Source
This commit is contained in:
shihao
2025-12-11 14:30:55 +08:00
parent e13be17a37
commit 908b5c8c07
8 changed files with 653 additions and 1286 deletions
Download Patch File Download Diff File Expand all files Collapse all files

719
plugins/AIChat/main.py
View File

@@ -620,6 +620,615 @@ class AIChat(PluginBase):
return tools
# ==================== Gemini API 格式转换方法 ====================
def _convert_tools_to_gemini(self, openai_tools: list) -> list:
"""
将 OpenAI 格式的工具定义转换为 Gemini 格式
OpenAI: [{"type": "function", "function": {"name": ..., "parameters": ...}}]
Gemini: [{"function_declarations": [{"name": ..., "parameters": ...}]}]
"""
if not openai_tools:
return []
function_declarations = []
for tool in openai_tools:
if tool.get("type") == "function":
func = tool.get("function", {})
function_declarations.append({
"name": func.get("name", ""),
"description": func.get("description", ""),
"parameters": func.get("parameters", {})
})
if function_declarations:
return [{"function_declarations": function_declarations}]
return []
def _build_gemini_contents(self, system_content: str, history_messages: list,
current_message: dict, is_group: bool = False) -> list:
"""
构建 Gemini API 的 contents 格式
Args:
system_content: 系统提示词（包含人设、时间、持久记忆等）
history_messages: 历史消息列表
current_message: 当前用户消息 {"text": str, "media": optional}
is_group: 是否群聊
Returns:
Gemini contents 格式的列表
"""
contents = []
# Gemini 没有 system role，将系统提示放在第一条 user 消息中
# 然后用一条简短的 model 回复来"确认"
system_parts = [{"text": f"[系统指令]\n{system_content}\n\n请按照以上指令进行对话。"}]
contents.append({"role": "user", "parts": system_parts})
contents.append({"role": "model", "parts": [{"text": "好的，我会按照指令进行对话。"}]})
# 添加历史消息
for msg in history_messages:
gemini_msg = self._convert_message_to_gemini(msg, is_group)
if gemini_msg:
contents.append(gemini_msg)
# 添加当前用户消息
current_parts = []
if current_message.get("text"):
current_parts.append({"text": current_message["text"]})
# 添加媒体内容（图片/视频）
if current_message.get("image_base64"):
image_data = current_message["image_base64"]
# 去除 data:image/xxx;base64, 前缀
if image_data.startswith("data:"):
mime_type = image_data.split(";")[0].split(":")[1]
image_data = image_data.split(",", 1)[1]
else:
mime_type = "image/jpeg"
current_parts.append({
"inline_data": {
"mime_type": mime_type,
"data": image_data
}
})
if current_message.get("video_base64"):
video_data = current_message["video_base64"]
# 去除 data:video/xxx;base64, 前缀
if video_data.startswith("data:"):
video_data = video_data.split(",", 1)[1]
current_parts.append({
"inline_data": {
"mime_type": "video/mp4",
"data": video_data
}
})
if current_parts:
contents.append({"role": "user", "parts": current_parts})
return contents
def _convert_message_to_gemini(self, msg: dict, is_group: bool = False) -> dict:
"""
将单条历史消息转换为 Gemini 格式
支持的输入格式：
1. 群聊历史: {"nickname": str, "content": str|list}
2. 私聊记忆: {"role": "user"|"assistant", "content": str|list}
"""
parts = []
# 群聊历史格式
if "nickname" in msg:
nickname = msg.get("nickname", "")
content = msg.get("content", "")
if isinstance(content, list):
# 多模态内容
for item in content:
if item.get("type") == "text":
text = item.get("text", "")
parts.append({"text": f"[{nickname}] {text}" if nickname else text})
elif item.get("type") == "image_url":
image_url = item.get("image_url", {}).get("url", "")
if image_url.startswith("data:"):
mime_type = image_url.split(";")[0].split(":")[1]
image_data = image_url.split(",", 1)[1]
parts.append({
"inline_data": {
"mime_type": mime_type,
"data": image_data
}
})
else:
# 纯文本
parts.append({"text": f"[{nickname}] {content}" if nickname else content})
# 群聊历史都作为 user 消息（因为是多人对话记录）
return {"role": "user", "parts": parts} if parts else None
# 私聊记忆格式
elif "role" in msg:
role = msg.get("role", "user")
content = msg.get("content", "")
# 转换角色名
gemini_role = "model" if role == "assistant" else "user"
if isinstance(content, list):
for item in content:
if item.get("type") == "text":
parts.append({"text": item.get("text", "")})
elif item.get("type") == "image_url":
image_url = item.get("image_url", {}).get("url", "")
if image_url.startswith("data:"):
mime_type = image_url.split(";")[0].split(":")[1]
image_data = image_url.split(",", 1)[1]
parts.append({
"inline_data": {
"mime_type": mime_type,
"data": image_data
}
})
else:
parts.append({"text": content})
return {"role": gemini_role, "parts": parts} if parts else None
return None
def _parse_gemini_tool_calls(self, response_parts: list) -> list:
"""
从 Gemini 响应中解析工具调用
Gemini 格式: {"functionCall": {"name": "...", "args": {...}}}
转换为内部格式: {"id": "...", "function": {"name": "...", "arguments": "..."}}
"""
tool_calls = []
for i, part in enumerate(response_parts):
if "functionCall" in part:
func_call = part["functionCall"]
tool_calls.append({
"id": f"call_{uuid.uuid4().hex[:8]}",
"type": "function",
"function": {
"name": func_call.get("name", ""),
"arguments": json.dumps(func_call.get("args", {}), ensure_ascii=False)
}
})
return tool_calls
def _build_tool_response_contents(self, contents: list, tool_calls: list,
tool_results: list) -> list:
"""
构建包含工具调用结果的 contents，用于继续对话
Args:
contents: 原始 contents
tool_calls: 工具调用列表
tool_results: 工具执行结果列表
"""
new_contents = contents.copy()
# 添加 model 的工具调用响应
function_call_parts = []
for tc in tool_calls:
function_call_parts.append({
"functionCall": {
"name": tc["function"]["name"],
"args": json.loads(tc["function"]["arguments"])
}
})
if function_call_parts:
new_contents.append({"role": "model", "parts": function_call_parts})
# 添加工具执行结果
function_response_parts = []
for i, result in enumerate(tool_results):
tool_name = tool_calls[i]["function"]["name"] if i < len(tool_calls) else "unknown"
function_response_parts.append({
"functionResponse": {
"name": tool_name,
"response": {"result": result.get("message", str(result))}
}
})
if function_response_parts:
new_contents.append({"role": "user", "parts": function_response_parts})
return new_contents
# ==================== 统一的 Gemini API 调用 ====================
async def _call_gemini_api(self, contents: list, tools: list = None,
bot=None, from_wxid: str = None,
chat_id: str = None, nickname: str = "",
user_wxid: str = None, is_group: bool = False) -> tuple:
"""
统一的 Gemini API 调用方法
Args:
contents: Gemini 格式的对话内容
tools: Gemini 格式的工具定义（可选）
bot: WechatHookClient 实例
from_wxid: 消息来源
chat_id: 会话ID
nickname: 用户昵称
user_wxid: 用户wxid
is_group: 是否群聊
Returns:
(response_text, tool_calls) - 响应文本和工具调用列表
"""
import json
api_config = self.config["api"]
model = api_config["model"]
api_url = api_config.get("gemini_url", api_config.get("url", "").replace("/v1/chat/completions", "/v1beta/models"))
api_key = api_config["api_key"]
# 构建完整 URL
full_url = f"{api_url}/{model}:streamGenerateContent?alt=sse"
# 构建请求体
payload = {
"contents": contents,
"generationConfig": {
"maxOutputTokens": api_config.get("max_tokens", 8192)
}
}
if tools:
payload["tools"] = tools
headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {api_key}"
}
timeout = aiohttp.ClientTimeout(total=api_config.get("timeout", 120))
# 配置代理
connector = None
proxy_config = self.config.get("proxy", {})
if proxy_config.get("enabled", False) and PROXY_SUPPORT:
proxy_type = proxy_config.get("type", "socks5").upper()
proxy_host = proxy_config.get("host", "127.0.0.1")
proxy_port = proxy_config.get("port", 7890)
proxy_username = proxy_config.get("username")
proxy_password = proxy_config.get("password")
if proxy_username and proxy_password:
proxy_url = f"{proxy_type}://{proxy_username}:{proxy_password}@{proxy_host}:{proxy_port}"
else:
proxy_url = f"{proxy_type}://{proxy_host}:{proxy_port}"
try:
connector = ProxyConnector.from_url(proxy_url)
logger.debug(f"[Gemini] 使用代理: {proxy_type}://{proxy_host}:{proxy_port}")
except Exception as e:
logger.warning(f"[Gemini] 代理配置失败: {e}")
# 保存用户信息供工具调用使用
self._current_user_wxid = user_wxid
self._current_is_group = is_group
try:
async with aiohttp.ClientSession(timeout=timeout, connector=connector) as session:
logger.debug(f"[Gemini] 发送流式请求: {full_url}")
async with session.post(full_url, json=payload, headers=headers) as resp:
if resp.status != 200:
error_text = await resp.text()
logger.error(f"[Gemini] API 错误: {resp.status}, {error_text[:500]}")
raise Exception(f"Gemini API 错误 {resp.status}: {error_text[:200]}")
# 流式接收响应
full_text = ""
all_parts = []
tool_call_hint_sent = False
async for line in resp.content:
line = line.decode('utf-8').strip()
if not line or not line.startswith("data: "):
continue
try:
data = json.loads(line[6:])
candidates = data.get("candidates", [])
if not candidates:
continue
content = candidates[0].get("content", )
parts = content.get("parts", [])
for part in parts:
all_parts.append(part)
# 收集文本
if "text" in part:
full_text += part["text"]
# 检测到工具调用时，先发送已有文本
if "functionCall" in part:
if not tool_call_hint_sent and bot and from_wxid:
tool_call_hint_sent = True
if full_text.strip():
logger.info(f"[Gemini] 检测到工具调用，先发送文本: {full_text[:30]}...")
await bot.send_text(from_wxid, full_text.strip())
except json.JSONDecodeError:
continue
# 解析工具调用
tool_calls = self._parse_gemini_tool_calls(all_parts)
logger.info(f"[Gemini] 响应完成, 文本长度: {len(full_text)}, 工具调用: {len(tool_calls)}")
return full_text.strip(), tool_calls
except aiohttp.ClientError as e:
logger.error(f"[Gemini] 网络请求失败: {e}")
raise
except asyncio.TimeoutError:
logger.error(f"[Gemini] 请求超时")
raise
async def _handle_gemini_response(self, response_text: str, tool_calls: list,
contents: list, tools: list,
bot, from_wxid: str, chat_id: str,
nickname: str, user_wxid: str, is_group: bool):
"""
处理 Gemini API 响应，包括工具调用
Args:
response_text: AI 响应文本
tool_calls: 工具调用列表
contents: 原始 contents（用于工具调用后继续对话）
tools: 工具定义
bot, from_wxid, chat_id, nickname, user_wxid, is_group: 上下文信息
"""
if tool_calls:
# 有工具调用，异步执行
logger.info(f"[Gemini] 启动异步工具执行，共 {len(tool_calls)} 个工具")
asyncio.create_task(
self._execute_gemini_tools_async(
tool_calls, contents, tools,
bot, from_wxid, chat_id, nickname, user_wxid, is_group
)
)
return None # 工具调用异步处理
return response_text
async def _execute_gemini_tools_async(self, tool_calls: list, contents: list, tools: list,
bot, from_wxid: str, chat_id: str,
nickname: str, user_wxid: str, is_group: bool):
"""
异步执行 Gemini 工具调用
"""
import json
try:
logger.info(f"[Gemini] 开始执行 {len(tool_calls)} 个工具")
# 收集需要 AI 回复的工具结果
need_ai_reply_results = []
tool_results = []
for tool_call in tool_calls:
function_name = tool_call["function"]["name"]
try:
arguments = json.loads(tool_call["function"]["arguments"])
except:
arguments = {}
logger.info(f"[Gemini] 执行工具: {function_name}, 参数: {arguments}")
result = await self._execute_tool_and_get_result(function_name, arguments, bot, from_wxid)
tool_results.append(result)
if result and result.get("success"):
logger.success(f"[Gemini] 工具 {function_name} 执行成功")
# 检查是否需要 AI 继续回复
if result.get("need_ai_reply"):
need_ai_reply_results.append({
"tool_call": tool_call,
"result": result
})
elif not result.get("already_sent") and result.get("message"):
if result.get("send_result_text"):
await bot.send_text(from_wxid, result["message"])
else:
logger.warning(f"[Gemini] 工具 {function_name} 执行失败: {result}")
if result and result.get("message"):
await bot.send_text(from_wxid, f"❌ {result['message']}")
# 如果有需要 AI 回复的工具结果，继续对话
if need_ai_reply_results:
await self._continue_gemini_with_tool_results(
contents, tools, tool_calls, tool_results,
bot, from_wxid, chat_id, nickname, user_wxid, is_group
)
logger.info("[Gemini] 所有工具执行完成")
except Exception as e:
logger.error(f"[Gemini] 工具执行异常: {e}")
import traceback
logger.error(traceback.format_exc())
try:
await bot.send_text(from_wxid, "❌ 工具执行出错")
except:
pass
async def _continue_gemini_with_tool_results(self, contents: list, tools: list,
tool_calls: list, tool_results: list,
bot, from_wxid: str, chat_id: str,
nickname: str, user_wxid: str, is_group: bool):
"""
基于工具结果继续 Gemini 对话
"""
try:
# 构建包含工具结果的新 contents
new_contents = self._build_tool_response_contents(contents, tool_calls, tool_results)
# 继续调用 API（不带工具，避免循环调用）
response_text, new_tool_calls = await self._call_gemini_api(
new_contents, tools=None,
bot=bot, from_wxid=from_wxid, chat_id=chat_id,
nickname=nickname, user_wxid=user_wxid, is_group=is_group
)
if response_text:
await bot.send_text(from_wxid, response_text)
logger.success(f"[Gemini] 工具回传后 AI 回复: {response_text[:50]}...")
# 保存到记忆
if chat_id:
self._add_to_memory(chat_id, "assistant", response_text)
if is_group:
import tomllib
with open("main_config.toml", "rb") as f:
main_config = tomllib.load(f)
bot_nickname = main_config.get("Bot", {}).get("nickname", "机器人")
await self._add_to_history(from_wxid, bot_nickname, response_text)
except Exception as e:
logger.error(f"[Gemini] 工具回传后继续对话失败: {e}")
import traceback
logger.error(traceback.format_exc())
async def _process_with_gemini(self, text: str = "", image_base64: str = None,
video_base64: str = None, bot=None,
from_wxid: str = None, chat_id: str = None,
nickname: str = "", user_wxid: str = None,
is_group: bool = False) -> str:
"""
统一的 Gemini 消息处理入口
支持：纯文本、图片+文本、视频+文本
Args:
text: 用户消息文本
image_base64: 图片 base64（可选）
video_base64: 视频 base64（可选）
bot, from_wxid, chat_id, nickname, user_wxid, is_group: 上下文信息
Returns:
AI 响应文本，如果是工具调用则返回 None
"""
import json
# 1. 构建系统提示词
system_content = self._build_system_content(nickname, from_wxid, user_wxid, is_group)
# 2. 加载历史消息
history_messages = []
if is_group and from_wxid:
history = await self._load_history(from_wxid)
max_context = self.config.get("history", {}).get("max_context", 50)
history_messages = history[-max_context:] if len(history) > max_context else history
elif chat_id:
memory_messages = self._get_memory_messages(chat_id)
if memory_messages and len(memory_messages) > 1:
history_messages = memory_messages[:-1] # 排除刚添加的当前消息
# 3. 构建当前消息
current_message = {"text": f"[{nickname}] {text}" if is_group and nickname else text}
if image_base64:
current_message["image_base64"] = image_base64
if video_base64:
current_message["video_base64"] = video_base64
# 4. 构建 Gemini contents
contents = self._build_gemini_contents(system_content, history_messages, current_message, is_group)
# 5. 收集并转换工具
openai_tools = self._collect_tools()
gemini_tools = self._convert_tools_to_gemini(openai_tools)
if gemini_tools:
logger.info(f"[Gemini] 已加载 {len(openai_tools)} 个工具")
# 6. 调用 Gemini API（带重试）
max_retries = self.config.get("api", {}).get("max_retries", 2)
last_error = None
for attempt in range(max_retries + 1):
try:
response_text, tool_calls = await self._call_gemini_api(
contents=contents,
tools=gemini_tools if gemini_tools else None,
bot=bot,
from_wxid=from_wxid,
chat_id=chat_id,
nickname=nickname,
user_wxid=user_wxid,
is_group=is_group
)
# 处理工具调用
if tool_calls:
result = await self._handle_gemini_response(
response_text, tool_calls, contents, gemini_tools,
bot, from_wxid, chat_id, nickname, user_wxid, is_group
)
return result # None 表示工具调用已异步处理
# 检查空响应
if not response_text and attempt < max_retries:
logger.warning(f"[Gemini] 返回空内容，重试 {attempt + 1}/{max_retries}")
await asyncio.sleep(1)
continue
return response_text
except Exception as e:
last_error = e
if attempt < max_retries:
logger.warning(f"[Gemini] API 调用失败，重试 {attempt + 1}/{max_retries}: {e}")
await asyncio.sleep(1)
else:
raise
return ""
def _build_system_content(self, nickname: str, from_wxid: str,
user_wxid: str, is_group: bool) -> str:
"""构建系统提示词（包含人设、时间、持久记忆等）"""
system_content = self.system_prompt
# 添加当前时间
current_time = datetime.now()
weekday_map = {
0: "星期一", 1: "星期二", 2: "星期三", 3: "星期四",
4: "星期五", 5: "星期六", 6: "星期日"
}
weekday = weekday_map[current_time.weekday()]
time_str = current_time.strftime(f"%Y年%m月%d日 %H:%M:%S {weekday}")
system_content += f"\n\n当前时间：{time_str}"
if nickname:
system_content += f"\n当前对话用户的昵称是：{nickname}"
# 加载持久记忆
memory_chat_id = from_wxid if is_group else user_wxid
if memory_chat_id:
persistent_memories = self._get_persistent_memories(memory_chat_id)
if persistent_memories:
system_content += "\n\n【持久记忆】以下是用户要求你记住的重要信息：\n"
for m in persistent_memories:
mem_time = m['time'][:10] if m['time'] else ""
system_content += f"- [{mem_time}] {m['nickname']}: {m['content']}\n"
return system_content
# ==================== 结束 Gemini API 方法 ====================
async def _handle_list_prompts(self, bot, from_wxid: str):
"""处理人设列表指令"""
try:
@@ -982,41 +1591,19 @@ class AIChat(PluginBase):
chat_id = self._get_chat_id(from_wxid, user_wxid, is_group)
self._add_to_memory(chat_id, "user", actual_content)
# 调用 AI API（带重试机制）
max_retries = self.config.get("api", {}).get("max_retries", 2)
response = None
last_error = None
for attempt in range(max_retries + 1):
try:
response = await self._call_ai_api(actual_content, bot, from_wxid, chat_id, nickname, user_wxid, is_group)
# 检查返回值：
# - None: 工具调用已异步处理，不需要重试
# - "": 真正的空响应，需要重试
# - 有内容: 正常响应
if response is None:
# 工具调用，不重试
logger.info("AI 触发工具调用，已异步处理")
break
if response == "" and attempt < max_retries:
logger.warning(f"AI 返回空内容，重试 {attempt + 1}/{max_retries}")
await asyncio.sleep(1) # 等待1秒后重试
continue
break # 成功或已达到最大重试次数
except Exception as e:
last_error = e
if attempt < max_retries:
logger.warning(f"AI API 调用失败，重试 {attempt + 1}/{max_retries}: {e}")
await asyncio.sleep(1)
else:
raise
# 使用统一的 Gemini API 处理消息
response = await self._process_with_gemini(
text=actual_content,
bot=bot,
from_wxid=from_wxid,
chat_id=chat_id,
nickname=nickname,
user_wxid=user_wxid,
is_group=is_group
)
# 发送回复并添加到记忆
# 注意：如果返回 None 或空字符串，说明已经以其他形式处理了，不需要再发送文本
# 注意：如果返回 None 或空字符串，说明已经以其他形式处理了（如工具调用）
if response:
await bot.send_text(from_wxid, response)
self._add_to_memory(chat_id, "assistant", response)
@@ -1028,7 +1615,7 @@ class AIChat(PluginBase):
await self._add_to_history(from_wxid, bot_nickname, response)
logger.success(f"AI 回复成功: {response[:50]}...")
else:
logger.info("AI 回复为空或已通过其他方式发送（如聊天记录）")
logger.info("AI 回复为空或已通过其他方式发送（如工具调用）")
except Exception as e:
import traceback
@@ -2060,8 +2647,17 @@ class AIChat(PluginBase):
if is_group:
await self._add_to_history(from_wxid, nickname, title_text, image_base64=image_base64)
# 调用AI API（带图片）
response = await self._call_ai_api_with_image(title_text, image_base64, bot, from_wxid, chat_id, nickname, user_wxid, is_group)
# 使用统一的 Gemini API 处理图片消息
response = await self._process_with_gemini(
text=title_text,
image_base64=image_base64,
bot=bot,
from_wxid=from_wxid,
chat_id=chat_id,
nickname=nickname,
user_wxid=user_wxid,
is_group=is_group
)
if response:
await bot.send_text(from_wxid, response)
@@ -2074,7 +2670,7 @@ class AIChat(PluginBase):
bot_nickname = main_config.get("Bot", {}).get("nickname", "机器人")
await self._add_to_history(from_wxid, bot_nickname, response)
logger.success(f"AI回复成功: {response[:50]}...")
return False
except Exception as e:
@@ -2083,15 +2679,8 @@ class AIChat(PluginBase):
async def _handle_quote_video(self, bot, video_elem, title_text: str, from_wxid: str,
user_wxid: str, is_group: bool, nickname: str, chat_id: str):
"""处理引用的视频消息 - 双AI架构"""
"""处理引用的视频消息 - 统一 Gemini API（直接处理视频）"""
try:
# 检查视频识别功能是否启用
video_config = self.config.get("video_recognition", {})
if not video_config.get("enabled", True):
logger.info("[视频识别] 功能未启用")
await bot.send_text(from_wxid, "❌ 视频识别功能未启用")
return False
# 提取视频 CDN 信息
cdnvideourl = video_elem.get("cdnvideourl", "")
aeskey = video_elem.get("aeskey", "")
@@ -2102,11 +2691,11 @@ class AIChat(PluginBase):
aeskey = video_elem.get("cdnrawvideoaeskey", "")
if not cdnvideourl or not aeskey:
logger.warning(f"[视频识别] 视频信息不完整: cdnurl={bool(cdnvideourl)}, aeskey={bool(aeskey)}")
logger.warning(f"[视频] 视频信息不完整: cdnurl={bool(cdnvideourl)}, aeskey={bool(aeskey)}")
await bot.send_text(from_wxid, "❌ 无法获取视频信息")
return False
logger.info(f"[视频识别] 处理引用视频: {title_text[:50]}...")
logger.info(f"[视频] 处理引用视频: {title_text[:50]}...")
# 提示用户正在处理
await bot.send_text(from_wxid, "🎬 正在分析视频，请稍候...")
@@ -2114,35 +2703,33 @@ class AIChat(PluginBase):
# 下载并编码视频
video_base64 = await self._download_and_encode_video(bot, cdnvideourl, aeskey)
if not video_base64:
logger.error("[视频识别] 视频下载失败")
logger.error("[视频] 视频下载失败")
await bot.send_text(from_wxid, "❌ 视频下载失败")
return False
logger.info("[视频识别] 视频下载和编码成功")
logger.info("[视频] 视频下载和编码成功")
# ========== 第一步：视频AI 分析视频内容 ==========
video_description = await self._analyze_video_content(video_base64, video_config)
if not video_description:
logger.error("[视频识别] 视频AI分析失败")
await bot.send_text(from_wxid, "❌ 视频分析失败")
return False
logger.info(f"[视频识别] 视频AI分析完成: {video_description[:100]}...")
# ========== 第二步：主AI 基于视频描述生成回复 ==========
# 构造包含视频描述的用户消息
# 用户问题
user_question = title_text.strip() if title_text.strip() else "这个视频讲了什么？"
combined_message = f"[用户发送了一个视频，以下是视频内容描述]\n{video_description}\n\n[用户的问题]\n{user_question}"
# 添加到记忆（让主AI知道用户发了视频）
self._add_to_memory(chat_id, "user", combined_message)
# 添加到记忆
self._add_to_memory(chat_id, "user", f"[发送了一个视频] {user_question}")
# 如果是群聊，添加到历史记录
if is_group:
await self._add_to_history(from_wxid, nickname, f"[发送了一个视频] {user_question}")
# 调用主AI生成回复（使用现有的 _call_ai_api 方法，继承完整上下文）
response = await self._call_ai_api(combined_message, chat_id, from_wxid, is_group, nickname)
# 使用统一的 Gemini API 直接处理视频（不再需要两步架构）
response = await self._process_with_gemini(
text=user_question,
video_base64=video_base64,
bot=bot,
from_wxid=from_wxid,
chat_id=chat_id,
nickname=nickname,
user_wxid=user_wxid,
is_group=is_group
)
if response:
await bot.send_text(from_wxid, response)
@@ -2154,7 +2741,7 @@ class AIChat(PluginBase):
main_config = tomllib.load(f)
bot_nickname = main_config.get("Bot", {}).get("nickname", "机器人")
await self._add_to_history(from_wxid, bot_nickname, response)
logger.success(f"[视频识别] 主AI回复成功: {response[:50]}...")
logger.success(f"[视频] AI回复成功: {response[:50]}...")
else:
await bot.send_text(from_wxid, "❌ AI 回复生成失败")