2301 lines
89 KiB
Python
2301 lines
89 KiB
Python
"""
|
||
title: GitHub Copilot Official SDK Pipe
|
||
author: Fu-Jie
|
||
author_url: https://github.com/Fu-Jie/awesome-openwebui
|
||
funding_url: https://github.com/open-webui
|
||
description: 集成 GitHub Copilot SDK。支持动态模型、多轮对话、流式输出、多模态输入、无限会话及前端调试日志。
|
||
version: 0.5.1
|
||
requirements: github-copilot-sdk==0.1.23
|
||
"""
|
||
|
||
import os
|
||
import re
|
||
import time
|
||
import json
|
||
import base64
|
||
import tempfile
|
||
import asyncio
|
||
import logging
|
||
import shutil
|
||
import subprocess
|
||
import sys
|
||
import hashlib
|
||
from pathlib import Path
|
||
from typing import Optional, Union, AsyncGenerator, List, Any, Dict, Callable, Tuple, Literal
|
||
from types import SimpleNamespace
|
||
from pydantic import BaseModel, Field, create_model
|
||
from datetime import datetime, timezone
|
||
import contextlib
|
||
|
||
# 导入 Copilot SDK 模块
|
||
from copilot import CopilotClient, define_tool
|
||
|
||
# 导入 Tool Server Connections 和 Tool System (从 OpenWebUI 配置)
|
||
from open_webui.config import (
|
||
PERSISTENT_CONFIG_REGISTRY,
|
||
TOOL_SERVER_CONNECTIONS,
|
||
)
|
||
from open_webui.utils.tools import get_tools as get_openwebui_tools, get_builtin_tools
|
||
from open_webui.models.tools import Tools
|
||
from open_webui.models.users import Users
|
||
|
||
# Setup logger
|
||
logger = logging.getLogger(__name__)
|
||
|
||
FORMATTING_GUIDELINES = (
|
||
"\n\n[环境与能力上下文]\n"
|
||
"你是一个在特定高性能环境中运行的 AI 助手。了解你的上下文对于做出最佳决策至关重要。\n"
|
||
"\n"
|
||
"**系统环境：**\n"
|
||
"- **平台**：你在 **OpenWebUI** 托管的 Linux 容器化环境中运行。\n"
|
||
"- **核心引擎**：你由 **GitHub Copilot SDK** 驱动，并通过 **GitHub Copilot CLI** 进行交互。\n"
|
||
"- **访问权限**：你可以直接访问 **OpenWebUI 源代码**。你可以通过文件操作或工具读取、分析和参考你正在运行的平台的内部实现。\n"
|
||
"- **文件系统访问**：你以 **root** 身份运行。你对 **整个容器文件系统** 拥有 **读取权限**（包括系统文件）。但是，你应 **仅写入** 你指定的持久化工作区目录。\n"
|
||
"- **原生 Python 环境**：你运行在一个 **丰富的 Python 环境** 中，已经包含了 OpenWebUI 的所有依赖库。你可以直接导入并使用这些已安装的库（例如用于数据处理、工具函数等），而无需安装任何新东西。\n"
|
||
"- **包管理**：仅当你需要 **额外** 的库时，才应在你的工作区内 **创建一个虚拟环境** 并在那里安装它们。不要搞乱全局 pip。\n"
|
||
"- **网络**：你有互联网访问权限，并且可以在提供相应工具（例如 Web 搜索、MCP 服务器）的情况下与外部 API 进行交互。\n"
|
||
"\n"
|
||
"**界面能力 (OpenWebUI)：**\n"
|
||
"- **丰富的 Web UI**：你不受简单终端或纯文本响应的限制。你在现代 Web 浏览器中进行渲染。\n"
|
||
"- **视觉渲染**：你可以并且应该使用高级视觉元素来清晰地解释概念。\n"
|
||
"- **交互式脚本**：如果环境支持/工具有效，你通常可以直接运行 Python 脚本来执行计算、数据分析或自动化任务。\n"
|
||
"- **内置工具集成**：OpenWebUI 提供了与内部服务直接交互的原生工具。例如，`create_note`、`get_notes` 或 `manage_memories` 等工具直接操作平台的数据库。利用这些工具来持久化地管理用户数据和系统状态。\n"
|
||
"\n"
|
||
"**格式化与呈现指令：**\n"
|
||
"1. **Markdown & 多媒体**：\n"
|
||
" - 自由使用 **粗体**、*斜体*、列表和 **Markdown 表格**（标准格式，严禁使用 HTML 表格）来构建你的答案。\n"
|
||
" - **Mermaid 图表**：对于流程图、序列图或架构逻辑，请务必使用标准的 ```mermaid 代码块。不要使用其他格式。\n"
|
||
" - **LaTeX 数学**：使用标准 LaTeX 格式表示数学表达式。\n"
|
||
"\n"
|
||
"2. **图像与文件**：\n"
|
||
" - 如果工具生成了图像或文件，你 **必须** 使用 `` 直接嵌入。\n"
|
||
" - 除非明确要求，否则不要仅提供文本链接。\n"
|
||
"\n"
|
||
"3. **交互式 HTML/JS**：\n"
|
||
" - 你可以输出独立的 HTML/JS/CSS 代码块。OpenWebUI 将在 iframe 中将其渲染为交互式小部件。\n"
|
||
" - **重要**：请将所有 HTML、CSS（在 `<style>` 中）和 JavaScript（在 `<script>` 中）合并到一个 **单一的** ` ```html ` 代码块中。\n"
|
||
" - 将此用于动态数据可视化（例如图表）、交互式演示或自定义 UI 组件。\n"
|
||
"\n"
|
||
"4. **响应结构**：\n"
|
||
" - **先思考**：在执行复杂任务之前，简要概述你的计划。\n"
|
||
" - **简洁但完整**：具体的答案优于通用的答案。\n"
|
||
" - **高级质感**：格式化你的输出，使其看起来专业且经过打磨，就像技术博客文章或文档一样。\n"
|
||
)
|
||
|
||
|
||
class Pipe:
|
||
class Valves(BaseModel):
|
||
GH_TOKEN: str = Field(
|
||
default="",
|
||
description="GitHub Fine-grained Token (需要 'Copilot Requests' 权限)",
|
||
)
|
||
ENABLE_OPENWEBUI_TOOLS: bool = Field(
|
||
default=True,
|
||
description="启用 OpenWebUI 工具 (包括自定义工具和工具服务器工具)。",
|
||
)
|
||
ENABLE_MCP_SERVER: bool = Field(
|
||
default=True,
|
||
description="启用直接 MCP 客户端连接 (推荐)。",
|
||
)
|
||
ENABLE_TOOL_CACHE: bool = Field(
|
||
default=True,
|
||
description="缓存 OpenWebUI 工具和 MCP 服务器配置 (性能优化)。",
|
||
)
|
||
REASONING_EFFORT: Literal["low", "medium", "high", "xhigh"] = Field(
|
||
default="medium",
|
||
description="推理强度级别 (low, medium, high)。仅影响标准 Copilot 模型 (非 BYOK)。",
|
||
)
|
||
SHOW_THINKING: bool = Field(
|
||
default=True,
|
||
description="显示模型推理/思考过程",
|
||
)
|
||
|
||
INFINITE_SESSION: bool = Field(
|
||
default=True,
|
||
description="启用无限会话（自动上下文压缩）",
|
||
)
|
||
DEBUG: bool = Field(
|
||
default=False,
|
||
description="启用技术调试日志（连接信息等）",
|
||
)
|
||
LOG_LEVEL: str = Field(
|
||
default="error",
|
||
description="Copilot CLI 日志级别：none, error, warning, info, debug, all",
|
||
)
|
||
TIMEOUT: int = Field(
|
||
default=300,
|
||
description="每个流式分块超时（秒）",
|
||
)
|
||
WORKSPACE_DIR: str = Field(
|
||
default="",
|
||
description="文件操作的受限工作区目录。为空则使用当前进程目录。",
|
||
)
|
||
COPILOT_CLI_VERSION: str = Field(
|
||
default="0.0.405",
|
||
description="指定安装/强制使用的 Copilot CLI 版本 (例如 '0.0.405')。留空则表示使用最新版。",
|
||
)
|
||
EXCLUDE_KEYWORDS: str = Field(
|
||
default="",
|
||
description="排除包含这些关键词的模型（逗号分隔，如：codex, haiku）",
|
||
)
|
||
COMPACTION_THRESHOLD: float = Field(
|
||
default=0.8,
|
||
description="后台压缩阈值 (0.0-1.0)",
|
||
)
|
||
BUFFER_THRESHOLD: float = Field(
|
||
default=0.95,
|
||
description="缓冲区耗尽阈值 (0.0-1.0)",
|
||
)
|
||
CUSTOM_ENV_VARS: str = Field(
|
||
default="",
|
||
description='自定义环境变量（JSON 格式，例如 {"VAR": "value"}）',
|
||
)
|
||
|
||
BYOK_TYPE: Literal["openai", "anthropic"] = Field(
|
||
default="openai",
|
||
description="BYOK 提供商类型：openai, anthropic",
|
||
)
|
||
BYOK_BASE_URL: str = Field(
|
||
default="",
|
||
description="BYOK 基础 URL (例如 https://api.openai.com/v1)",
|
||
)
|
||
BYOK_API_KEY: str = Field(
|
||
default="",
|
||
description="BYOK API 密钥 (全局设置)",
|
||
)
|
||
BYOK_BEARER_TOKEN: str = Field(
|
||
default="",
|
||
description="BYOK Bearer 令牌 (全局，优先级高于 API Key)",
|
||
)
|
||
BYOK_MODELS: str = Field(
|
||
default="",
|
||
description="BYOK 模型列表 (逗号分隔)。留空则尝试从 API 获取。",
|
||
)
|
||
BYOK_WIRE_API: Literal["completions", "responses"] = Field(
|
||
default="completions",
|
||
description="BYOK 传输 API 类型：completions, responses",
|
||
)
|
||
|
||
class UserValves(BaseModel):
|
||
GH_TOKEN: str = Field(
|
||
default="",
|
||
description="个人 GitHub Fine-grained Token (覆盖全局设置)",
|
||
)
|
||
REASONING_EFFORT: Literal["", "low", "medium", "high", "xhigh"] = Field(
|
||
default="",
|
||
description="推理强度级别覆盖。仅影响标准 Copilot 模型。",
|
||
)
|
||
SHOW_THINKING: bool = Field(
|
||
default=True,
|
||
description="显示模型推理/思考过程",
|
||
)
|
||
DEBUG: bool = Field(
|
||
default=False,
|
||
description="启用技术调试日志（连接信息等）",
|
||
)
|
||
ENABLE_OPENWEBUI_TOOLS: bool = Field(
|
||
default=True,
|
||
description="启用 OpenWebUI 工具 (包括自定义工具和工具服务器工具)。",
|
||
)
|
||
ENABLE_MCP_SERVER: bool = Field(
|
||
default=True,
|
||
description="启用动态 MCP 服务器加载 (覆盖全局设置)。",
|
||
)
|
||
ENABLE_TOOL_CACHE: bool = Field(
|
||
default=True,
|
||
description="为此用户启用工具/MCP 配置缓存。",
|
||
)
|
||
|
||
# BYOK 用户覆盖
|
||
BYOK_API_KEY: str = Field(
|
||
default="",
|
||
description="BYOK API 密钥 (用户覆盖)",
|
||
)
|
||
BYOK_TYPE: Literal["", "openai", "anthropic"] = Field(
|
||
default="",
|
||
description="BYOK 提供商类型覆盖。",
|
||
)
|
||
BYOK_BASE_URL: str = Field(
|
||
default="",
|
||
description="BYOK 基础 URL 覆盖。",
|
||
)
|
||
BYOK_BEARER_TOKEN: str = Field(
|
||
default="",
|
||
description="BYOK Bearer 令牌 覆盖。",
|
||
)
|
||
BYOK_MODELS: str = Field(
|
||
default="",
|
||
description="BYOK 模型列表覆盖。",
|
||
)
|
||
BYOK_WIRE_API: Literal["", "completions", "responses"] = Field(
|
||
default="",
|
||
description="BYOK 传输 API 覆盖。",
|
||
)
|
||
|
||
def __init__(self):
|
||
self.type = "pipe"
|
||
self.id = "copilotsdk"
|
||
self.name = "copilotsdk"
|
||
self.valves = self.Valves()
|
||
self.temp_dir = tempfile.mkdtemp(prefix="copilot_images_")
|
||
self._model_cache = [] # 模型列表缓存
|
||
self._standard_model_ids = set() # 追踪标准模型 ID，以区分 BYOK 模型
|
||
self._env_setup_done = False # 是否已完成环境初始化环境检查
|
||
self._tool_cache = None # 已转换的 OpenWebUI 工具缓存
|
||
self._mcp_server_cache = None # MCP 服务器配置缓存
|
||
self._last_update_check = 0 # Timestamp of last CLI update check
|
||
|
||
def __del__(self):
|
||
try:
|
||
shutil.rmtree(self.temp_dir)
|
||
except:
|
||
pass
|
||
|
||
# ==================== 系统固定入口 ====================
|
||
# pipe() 是 OpenWebUI 调用的稳定入口。
|
||
# 将该部分放在前面，便于快速定位与维护。
|
||
# ======================================================
|
||
async def pipe(
|
||
self,
|
||
body: dict,
|
||
__metadata__: Optional[dict] = None,
|
||
__user__: Optional[dict] = None,
|
||
__event_emitter__=None,
|
||
__event_call__=None,
|
||
) -> Union[str, AsyncGenerator]:
|
||
return await self._pipe_impl(
|
||
body,
|
||
__metadata__=__metadata__,
|
||
__user__=__user__,
|
||
__event_emitter__=__event_emitter__,
|
||
__event_call__=__event_call__,
|
||
)
|
||
|
||
# ==================== 功能性分区 ====================
|
||
# 1) 工具加载与转换
|
||
# 2) 提示词提取与处理
|
||
# 3) 环境配置与工作区
|
||
# ======================================================
|
||
|
||
async def _initialize_custom_tools(self, __user__=None, __event_call__=None):
|
||
"""根据配置初始化自定义工具"""
|
||
if not self.valves.ENABLE_OPENWEBUI_TOOLS:
|
||
return []
|
||
|
||
# 确定缓存设置 (用户覆盖 > 全局)
|
||
enable_cache = self.valves.ENABLE_TOOL_CACHE
|
||
if __user__:
|
||
try:
|
||
raw_user_valves = __user__.get("valves", {})
|
||
if isinstance(raw_user_valves, dict):
|
||
uv = self.UserValves(**raw_user_valves)
|
||
enable_cache = uv.ENABLE_TOOL_CACHE
|
||
except:
|
||
pass
|
||
|
||
# 检查缓存
|
||
if enable_cache and self._tool_cache is not None:
|
||
await self._emit_debug_log("ℹ️ 使用缓存的 OpenWebUI 工具。", __event_call__)
|
||
return self._tool_cache
|
||
|
||
# 动态加载 OpenWebUI 工具
|
||
openwebui_tools = await self._load_openwebui_tools(
|
||
__user__=__user__, __event_call__=__event_call__
|
||
)
|
||
|
||
# 更新缓存
|
||
if enable_cache:
|
||
self._tool_cache = openwebui_tools
|
||
await self._emit_debug_log(
|
||
"✅ OpenWebUI 工具已缓存，供后续请求使用。", __event_call__
|
||
)
|
||
|
||
return openwebui_tools
|
||
|
||
def _json_schema_to_python_type(self, schema: dict) -> Any:
|
||
"""将 JSON Schema 类型转换为 Pydantic 模型的 Python 类型。"""
|
||
if not isinstance(schema, dict):
|
||
return Any
|
||
|
||
# 检查枚举 (Literal)
|
||
enum_values = schema.get("enum")
|
||
if enum_values and isinstance(enum_values, list):
|
||
from typing import Literal
|
||
|
||
return Literal[tuple(enum_values)]
|
||
|
||
schema_type = schema.get("type")
|
||
if isinstance(schema_type, list):
|
||
schema_type = next((t for t in schema_type if t != "null"), schema_type[0])
|
||
|
||
if schema_type == "string":
|
||
return str
|
||
if schema_type == "integer":
|
||
return int
|
||
if schema_type == "number":
|
||
return float
|
||
if schema_type == "boolean":
|
||
return bool
|
||
if schema_type == "object":
|
||
return Dict[str, Any]
|
||
if schema_type == "array":
|
||
items_schema = schema.get("items", {})
|
||
item_type = self._json_schema_to_python_type(items_schema)
|
||
return List[item_type]
|
||
|
||
return Any
|
||
|
||
def _convert_openwebui_tool(self, tool_name: str, tool_dict: dict):
|
||
"""将 OpenWebUI 工具定义转换为 Copilot SDK 工具。"""
|
||
# 净化工具名称以匹配模式 ^[a-zA-Z0-9_-]+$
|
||
sanitized_tool_name = re.sub(r"[^a-zA-Z0-9_-]", "_", tool_name)
|
||
|
||
if not sanitized_tool_name or re.match(r"^[_.-]+$", sanitized_tool_name):
|
||
hash_suffix = hashlib.md5(tool_name.encode("utf-8")).hexdigest()[:8]
|
||
sanitized_tool_name = f"tool_{hash_suffix}"
|
||
|
||
spec = tool_dict.get("spec", {}) if isinstance(tool_dict, dict) else {}
|
||
params_schema = spec.get("parameters", {}) if isinstance(spec, dict) else {}
|
||
properties = params_schema.get("properties", {})
|
||
required = params_schema.get("required", [])
|
||
|
||
if not isinstance(properties, dict):
|
||
properties = {}
|
||
if not isinstance(required, list):
|
||
required = []
|
||
|
||
required_set = set(required)
|
||
fields = {}
|
||
for param_name, param_schema in properties.items():
|
||
param_type = self._json_schema_to_python_type(param_schema)
|
||
description = ""
|
||
if isinstance(param_schema, dict):
|
||
description = param_schema.get("description", "")
|
||
|
||
# 提取默认值
|
||
default_value = None
|
||
if isinstance(param_schema, dict) and "default" in param_schema:
|
||
default_value = param_schema.get("default")
|
||
|
||
if param_name in required_set:
|
||
if description:
|
||
fields[param_name] = (
|
||
param_type,
|
||
Field(..., description=description),
|
||
)
|
||
else:
|
||
fields[param_name] = (param_type, ...)
|
||
else:
|
||
optional_type = Optional[param_type]
|
||
if description:
|
||
fields[param_name] = (
|
||
optional_type,
|
||
Field(default=default_value, description=description),
|
||
)
|
||
else:
|
||
fields[param_name] = (optional_type, default_value)
|
||
|
||
ParamsModel = (
|
||
create_model(f"{sanitized_tool_name}_Params", **fields)
|
||
if fields
|
||
else create_model(f"{sanitized_tool_name}_Params")
|
||
)
|
||
|
||
tool_callable = tool_dict.get("callable")
|
||
tool_description = spec.get("description", "") if isinstance(spec, dict) else ""
|
||
if not tool_description and isinstance(spec, dict):
|
||
tool_description = spec.get("summary", "")
|
||
|
||
# 确定工具来源/组以添加描述前缀
|
||
tool_id = tool_dict.get("tool_id", "")
|
||
tool_type = tool_dict.get("type", "")
|
||
|
||
if tool_type == "builtin":
|
||
group_prefix = "[OpenWebUI 内置]"
|
||
elif tool_type == "external" or tool_id.startswith("server:"):
|
||
tool_group_name = tool_dict.get("_tool_group_name")
|
||
tool_group_desc = tool_dict.get("_tool_group_description")
|
||
server_id = (
|
||
tool_id.replace("server:", "").split("|")[0]
|
||
if tool_id.startswith("server:")
|
||
else tool_id
|
||
)
|
||
|
||
if tool_group_name:
|
||
group_prefix = (
|
||
f"[工具服务器: {tool_group_name} - {tool_group_desc}]"
|
||
if tool_group_desc
|
||
else f"[工具服务器: {tool_group_name}]"
|
||
)
|
||
else:
|
||
group_prefix = f"[工具服务器: {server_id}]"
|
||
else:
|
||
tool_group_name = tool_dict.get("_tool_group_name")
|
||
tool_group_desc = tool_dict.get("_tool_group_description")
|
||
|
||
if tool_group_name:
|
||
group_prefix = (
|
||
f"[用户工具: {tool_group_name} - {tool_group_desc}]"
|
||
if tool_group_desc
|
||
else f"[用户工具: {tool_group_name}]"
|
||
)
|
||
else:
|
||
group_prefix = f"[用户工具: {tool_id}]" if tool_id else "[用户工具]"
|
||
|
||
if sanitized_tool_name != tool_name:
|
||
tool_description = f"{group_prefix} 函数 '{tool_name}': {tool_description}"
|
||
else:
|
||
tool_description = f"{group_prefix} {tool_description}"
|
||
|
||
async def _tool(params):
|
||
payload = (
|
||
params.model_dump(exclude_unset=True)
|
||
if hasattr(params, "model_dump")
|
||
else {}
|
||
)
|
||
return await tool_callable(**payload)
|
||
|
||
_tool.__name__ = sanitized_tool_name
|
||
_tool.__doc__ = tool_description
|
||
|
||
return define_tool(
|
||
name=sanitized_tool_name,
|
||
description=tool_description,
|
||
params_type=ParamsModel,
|
||
)(_tool)
|
||
|
||
def _build_openwebui_request(self, user_data: Optional[dict] = None):
|
||
"""构建一个最小的 request 模拟对象用于 OpenWebUI 工具加载。"""
|
||
app_state = SimpleNamespace(
|
||
config=SimpleNamespace(
|
||
TOOL_SERVER_CONNECTIONS=(
|
||
TOOL_SERVER_CONNECTIONS.value
|
||
if hasattr(TOOL_SERVER_CONNECTIONS, "value")
|
||
else []
|
||
)
|
||
),
|
||
TOOLS={},
|
||
)
|
||
app = SimpleNamespace(state=app_state)
|
||
|
||
def url_path_for(name: str, **path_params):
|
||
return f"/mock/path/{name}"
|
||
|
||
app.url_path_for = url_path_for
|
||
|
||
request = SimpleNamespace(
|
||
app=app,
|
||
cookies={},
|
||
state=SimpleNamespace(token=SimpleNamespace(credentials="")),
|
||
)
|
||
if user_data and user_data.get("token"):
|
||
request.state.token.credentials = user_data["token"]
|
||
return request
|
||
|
||
async def _load_openwebui_tools(self, __user__=None, __event_call__=None):
|
||
"""加载 OpenWebUI 工具并转换为 Copilot SDK 工具。"""
|
||
if isinstance(__user__, (list, tuple)):
|
||
user_data = __user__[0] if __user__ else {}
|
||
elif isinstance(__user__, dict):
|
||
user_data = __user__
|
||
else:
|
||
user_data = {}
|
||
|
||
if not user_data:
|
||
return []
|
||
|
||
user_id = user_data.get("id") or user_data.get("user_id")
|
||
if not user_id:
|
||
return []
|
||
|
||
try:
|
||
from open_webui.models.users import Users
|
||
|
||
user = Users.get_user_by_id(user_id)
|
||
if not user:
|
||
return []
|
||
except:
|
||
return []
|
||
|
||
# 1. 用户自定义工具
|
||
tool_items = Tools.get_tools_by_user_id(user_id, permission="read")
|
||
tool_ids = [tool.id for tool in tool_items] if tool_items else []
|
||
|
||
# 2. 工具服务器工具
|
||
if hasattr(TOOL_SERVER_CONNECTIONS, "value"):
|
||
for server in TOOL_SERVER_CONNECTIONS.value:
|
||
if server.get("type") == "openapi":
|
||
server_id = server.get("id")
|
||
if server_id:
|
||
tool_ids.append(f"server:{server_id}")
|
||
|
||
request = self._build_openwebui_request(user_data)
|
||
extra_params = {
|
||
"__request__": request,
|
||
"__user__": user_data,
|
||
"__event_call__": __event_call__,
|
||
}
|
||
|
||
tools_dict = {}
|
||
if tool_ids:
|
||
try:
|
||
tools_dict = await get_openwebui_tools(
|
||
request, tool_ids, user, extra_params
|
||
)
|
||
except Exception as e:
|
||
await self._emit_debug_log(f"获取自定义工具出错: {e}", __event_call__)
|
||
|
||
# 内置工具
|
||
try:
|
||
builtin_tools = get_builtin_tools(
|
||
request,
|
||
{"__user__": user_data},
|
||
model={
|
||
"info": {
|
||
"meta": {
|
||
"capabilities": {
|
||
"web_search": True,
|
||
"image_generation": True,
|
||
}
|
||
}
|
||
}
|
||
},
|
||
)
|
||
if builtin_tools:
|
||
tools_dict.update(builtin_tools)
|
||
except Exception as e:
|
||
await self._emit_debug_log(f"获取内置工具出错: {e}", __event_call__)
|
||
|
||
if not tools_dict:
|
||
return []
|
||
|
||
server_metadata_cache = {}
|
||
if hasattr(TOOL_SERVER_CONNECTIONS, "value"):
|
||
for server in TOOL_SERVER_CONNECTIONS.value:
|
||
sid = server.get("id") or server.get("info", {}).get("id")
|
||
if sid:
|
||
info = server.get("info", {})
|
||
server_metadata_cache[sid] = {
|
||
"name": info.get("name") or sid,
|
||
"description": info.get("description", ""),
|
||
}
|
||
|
||
converted_tools = []
|
||
for tool_name, tool_def in tools_dict.items():
|
||
try:
|
||
# 尝试丰富元数据
|
||
tool_id = tool_def.get("tool_id", "")
|
||
if tool_id.startswith("server:"):
|
||
sid = tool_id.replace("server:", "").split("|")[0]
|
||
if sid in server_metadata_cache:
|
||
tool_def["_tool_group_name"] = server_metadata_cache[sid].get(
|
||
"name"
|
||
)
|
||
tool_def["_tool_group_description"] = server_metadata_cache[
|
||
sid
|
||
].get("description")
|
||
|
||
converted_tools.append(
|
||
self._convert_openwebui_tool(tool_name, tool_def)
|
||
)
|
||
except Exception as e:
|
||
await self._emit_debug_log(
|
||
f"转换 OpenWebUI 工具 '{tool_name}' 失败: {e}",
|
||
__event_call__,
|
||
)
|
||
|
||
return converted_tools
|
||
|
||
def _parse_mcp_servers(self) -> Optional[dict]:
|
||
"""
|
||
从 OpenWebUI TOOL_SERVER_CONNECTIONS 动态加载 MCP 服务器配置。
|
||
返回兼容 CopilotClient 的 mcp_servers 字典。
|
||
"""
|
||
if not self.valves.ENABLE_MCP_SERVER:
|
||
return None
|
||
|
||
# 检查缓存
|
||
if self.valves.ENABLE_TOOL_CACHE and self._mcp_server_cache is not None:
|
||
return self._mcp_server_cache
|
||
|
||
mcp_servers = {}
|
||
|
||
# 遍历 OpenWebUI 工具服务器连接
|
||
if hasattr(TOOL_SERVER_CONNECTIONS, "value"):
|
||
connections = TOOL_SERVER_CONNECTIONS.value
|
||
else:
|
||
connections = []
|
||
|
||
for conn in connections:
|
||
if conn.get("type") == "mcp":
|
||
info = conn.get("info", {})
|
||
# 使用 info 中的 ID 或自动生成
|
||
raw_id = info.get("id", f"mcp-server-{len(mcp_servers)}")
|
||
|
||
# 净化 server_id (使用与工具相同的逻辑)
|
||
server_id = re.sub(r"[^a-zA-Z0-9_-]", "_", raw_id)
|
||
if not server_id or re.match(r"^[_.-]+$", server_id):
|
||
hash_suffix = hashlib.md5(raw_id.encode("utf-8")).hexdigest()[:8]
|
||
server_id = f"server_{hash_suffix}"
|
||
|
||
url = conn.get("url")
|
||
if not url:
|
||
continue
|
||
|
||
# 构建 Header (处理认证)
|
||
headers = {}
|
||
auth_type = conn.get("auth_type", "bearer")
|
||
key = conn.get("key", "")
|
||
|
||
if auth_type == "bearer" and key:
|
||
headers["Authorization"] = f"Bearer {key}"
|
||
elif auth_type == "basic" and key:
|
||
headers["Authorization"] = f"Basic {key}"
|
||
|
||
# 合并自定义 headers
|
||
custom_headers = conn.get("headers", {})
|
||
if isinstance(custom_headers, dict):
|
||
headers.update(custom_headers)
|
||
|
||
# 获取过滤配置
|
||
mcp_config = conn.get("config", {})
|
||
function_filter = mcp_config.get("function_name_filter_list", "")
|
||
|
||
allowed_tools = ["*"]
|
||
if function_filter:
|
||
if isinstance(function_filter, str):
|
||
allowed_tools = [
|
||
f.strip() for f in function_filter.split(",") if f.strip()
|
||
]
|
||
elif isinstance(function_filter, list):
|
||
allowed_tools = function_filter
|
||
|
||
mcp_servers[server_id] = {
|
||
"type": "http",
|
||
"url": url,
|
||
"headers": headers,
|
||
"tools": allowed_tools,
|
||
}
|
||
|
||
# 更新缓存
|
||
if self.valves.ENABLE_TOOL_CACHE:
|
||
self._mcp_server_cache = mcp_servers
|
||
|
||
return mcp_servers if mcp_servers else None
|
||
|
||
def _build_session_config(
|
||
self,
|
||
chat_id: Optional[str],
|
||
real_model_id: str,
|
||
custom_tools: List[Any],
|
||
system_prompt_content: Optional[str],
|
||
is_streaming: bool,
|
||
):
|
||
"""构建 Copilot SDK 的 SessionConfig"""
|
||
# 处理无限会话配置
|
||
from copilot.types import SessionConfig, InfiniteSessionConfig
|
||
|
||
infinite_session_config = None
|
||
if self.valves.INFINITE_SESSION:
|
||
infinite_session_config = InfiniteSessionConfig(
|
||
enabled=True,
|
||
background_compaction_threshold=self.valves.COMPACTION_THRESHOLD,
|
||
buffer_exhaustion_threshold=self.valves.BUFFER_THRESHOLD,
|
||
)
|
||
|
||
# 始终包含格式化指南（默认开启）
|
||
system_parts = []
|
||
if system_prompt_content:
|
||
system_parts.append(system_prompt_content)
|
||
system_parts.append(FORMATTING_GUIDELINES)
|
||
|
||
# 始终使用 'replace' 模式以确保完全控制并避免重复
|
||
system_message_config = {
|
||
"mode": "replace",
|
||
"content": "\n".join(system_parts),
|
||
}
|
||
|
||
# 准备基础参数
|
||
session_params = {
|
||
"session_id": chat_id if chat_id else None,
|
||
"model": real_model_id,
|
||
"streaming": is_streaming,
|
||
"tools": custom_tools,
|
||
"system_message": system_message_config,
|
||
"infinite_sessions": infinite_session_config,
|
||
}
|
||
|
||
# 注入 MCP 转换器
|
||
mcp_servers = self._parse_mcp_servers()
|
||
if mcp_servers:
|
||
session_params["mcp_servers"] = mcp_servers
|
||
|
||
return SessionConfig(**session_params)
|
||
|
||
def _dedupe_preserve_order(self, items: List[str]) -> List[str]:
|
||
"""去重保序"""
|
||
seen = set()
|
||
result = []
|
||
for item in items:
|
||
if not item or item in seen:
|
||
continue
|
||
seen.add(item)
|
||
result.append(item)
|
||
return result
|
||
|
||
def _apply_formatting_hint(self, prompt: str) -> str:
|
||
"""返回原始提示词（已移除格式化提示）"""
|
||
return prompt
|
||
|
||
def _collect_model_ids(
|
||
self, body: dict, request_model: str, real_model_id: str
|
||
) -> List[str]:
|
||
"""收集可能的模型 ID（来自请求/metadata/body params）"""
|
||
model_ids: List[str] = []
|
||
if request_model:
|
||
model_ids.append(request_model)
|
||
if request_model.startswith(f"{self.id}-"):
|
||
model_ids.append(request_model[len(f"{self.id}-") :])
|
||
if real_model_id:
|
||
model_ids.append(real_model_id)
|
||
|
||
metadata = body.get("metadata", {})
|
||
if isinstance(metadata, dict):
|
||
meta_model = metadata.get("model")
|
||
meta_model_id = metadata.get("model_id")
|
||
if isinstance(meta_model, str):
|
||
model_ids.append(meta_model)
|
||
if isinstance(meta_model_id, str):
|
||
model_ids.append(meta_model_id)
|
||
|
||
body_params = body.get("params", {})
|
||
if isinstance(body_params, dict):
|
||
for key in ("model", "model_id", "modelId"):
|
||
val = body_params.get(key)
|
||
if isinstance(val, str):
|
||
model_ids.append(val)
|
||
|
||
return self._dedupe_preserve_order(model_ids)
|
||
|
||
async def _extract_system_prompt(
|
||
self,
|
||
body: dict,
|
||
messages: List[dict],
|
||
request_model: str,
|
||
real_model_id: str,
|
||
__event_call__=None,
|
||
debug_enabled: bool = False,
|
||
) -> Tuple[Optional[str], str]:
|
||
"""从 metadata/模型 DB/body/messages 提取系统提示词"""
|
||
system_prompt_content: Optional[str] = None
|
||
system_prompt_source = ""
|
||
|
||
# 0) body.get("system_prompt") - Explicit Override (Highest Priority)
|
||
if hasattr(body, "get") and body.get("system_prompt"):
|
||
system_prompt_content = body.get("system_prompt")
|
||
system_prompt_source = "body_explicit_system_prompt"
|
||
await self._emit_debug_log(
|
||
f"从显式 body 字段提取了系统提示词（长度: {len(system_prompt_content)}）",
|
||
__event_call__,
|
||
debug_enabled=debug_enabled,
|
||
)
|
||
|
||
# 1) metadata.model.params.system
|
||
if not system_prompt_content:
|
||
metadata = body.get("metadata", {})
|
||
if isinstance(metadata, dict):
|
||
meta_model = metadata.get("model")
|
||
if isinstance(meta_model, dict):
|
||
meta_params = meta_model.get("params")
|
||
if isinstance(meta_params, dict) and meta_params.get("system"):
|
||
system_prompt_content = meta_params.get("system")
|
||
system_prompt_source = "metadata.model.params"
|
||
await self._emit_debug_log(
|
||
f"从 metadata.model.params 提取系统提示词（长度: {len(system_prompt_content)}）",
|
||
__event_call__,
|
||
debug_enabled=debug_enabled,
|
||
)
|
||
|
||
# 2) 模型 DB
|
||
if not system_prompt_content:
|
||
try:
|
||
from open_webui.models.models import Models
|
||
|
||
model_ids_to_try = self._collect_model_ids(
|
||
body, request_model, real_model_id
|
||
)
|
||
for mid in model_ids_to_try:
|
||
model_record = Models.get_model_by_id(mid)
|
||
if model_record and hasattr(model_record, "params"):
|
||
params = model_record.params
|
||
if isinstance(params, dict):
|
||
system_prompt_content = params.get("system")
|
||
if system_prompt_content:
|
||
system_prompt_source = f"model_db:{mid}"
|
||
await self._emit_debug_log(
|
||
f"成功！使用 ID 从模型数据库中提取了系统提示词: {mid}（长度: {len(system_prompt_content)}）",
|
||
__event_call__,
|
||
debug_enabled=debug_enabled,
|
||
)
|
||
break
|
||
except Exception as e:
|
||
await self._emit_debug_log(
|
||
f"从模型数据库提取系统提示词失败: {e}",
|
||
__event_call__,
|
||
debug_enabled=debug_enabled,
|
||
)
|
||
|
||
# 3) body.params.system
|
||
if not system_prompt_content:
|
||
body_params = body.get("params", {})
|
||
if isinstance(body_params, dict):
|
||
system_prompt_content = body_params.get("system")
|
||
if system_prompt_content:
|
||
system_prompt_source = "body_params"
|
||
await self._emit_debug_log(
|
||
f"从 body.params 提取系统提示词（长度: {len(system_prompt_content)}）",
|
||
__event_call__,
|
||
)
|
||
|
||
# 4) messages (role=system)
|
||
if not system_prompt_content:
|
||
for msg in messages:
|
||
if msg.get("role") == "system":
|
||
system_prompt_content = self._extract_text_from_content(
|
||
msg.get("content", "")
|
||
)
|
||
if system_prompt_content:
|
||
system_prompt_source = "messages_system"
|
||
await self._emit_debug_log(
|
||
f"从消息中提取系统提示词（长度: {len(system_prompt_content)}）",
|
||
__event_call__,
|
||
)
|
||
break
|
||
|
||
return system_prompt_content, system_prompt_source
|
||
|
||
async def _emit_debug_log(
|
||
self, message: str, __event_call__=None, debug_enabled: Optional[bool] = None
|
||
):
|
||
"""在 DEBUG 开启时将日志输出到前端控制台。"""
|
||
should_log = (
|
||
debug_enabled
|
||
if debug_enabled is not None
|
||
else getattr(self.valves, "DEBUG", False)
|
||
)
|
||
if not should_log:
|
||
return
|
||
|
||
logger.debug(f"[Copilot Pipe] {message}")
|
||
|
||
if not __event_call__:
|
||
return
|
||
|
||
try:
|
||
js_code = f"""
|
||
(async function() {{
|
||
console.debug("%c[Copilot Pipe] " + {json.dumps(message, ensure_ascii=False)}, "color: #3b82f6;");
|
||
}})();
|
||
"""
|
||
await __event_call__({"type": "execute", "data": {"code": js_code}})
|
||
except Exception as e:
|
||
logger.debug(f"[Copilot Pipe] 前端调试日志失败: {e}")
|
||
|
||
def _emit_debug_log_sync(
|
||
self, message: str, __event_call__=None, debug_enabled: Optional[bool] = None
|
||
):
|
||
"""在非异步上下文中输出调试日志。"""
|
||
should_log = (
|
||
debug_enabled
|
||
if debug_enabled is not None
|
||
else getattr(self.valves, "DEBUG", False)
|
||
)
|
||
if not should_log:
|
||
return
|
||
|
||
try:
|
||
loop = asyncio.get_running_loop()
|
||
loop.create_task(
|
||
self._emit_debug_log(message, __event_call__, debug_enabled=True)
|
||
)
|
||
except RuntimeError:
|
||
logger.debug(f"[Copilot Pipe] {message}")
|
||
|
||
async def _emit_native_message(self, message_data: dict, __event_call__=None):
|
||
"""发送原生 OpenAI 格式消息事件用于工具调用/结果。"""
|
||
if not __event_call__:
|
||
return
|
||
|
||
try:
|
||
await __event_call__({"type": "message", "data": message_data})
|
||
await self._emit_debug_log(
|
||
f"已发送原生消息: {message_data.get('role')} - {list(message_data.keys())}",
|
||
__event_call__,
|
||
)
|
||
except Exception as e:
|
||
logger.warning(f"发送原生消息失败: {e}")
|
||
await self._emit_debug_log(
|
||
f"原生消息发送失败: {e}。回退到文本显示。", __event_call__
|
||
)
|
||
|
||
def _get_user_context(self):
|
||
"""获取用户上下文（占位，预留）。"""
|
||
return {}
|
||
|
||
def _get_chat_context(
|
||
self,
|
||
body: dict,
|
||
__metadata__: Optional[dict] = None,
|
||
__event_call__=None,
|
||
debug_enabled: bool = False,
|
||
) -> Dict[str, str]:
|
||
"""
|
||
高度可靠的聊天上下文提取逻辑。
|
||
优先级：__metadata__ > body['chat_id'] > body['metadata']['chat_id']
|
||
"""
|
||
chat_id = ""
|
||
source = "none"
|
||
|
||
# 1. 优先从 __metadata__ 获取 (OpenWebUI 注入的最可靠来源)
|
||
if __metadata__ and isinstance(__metadata__, dict):
|
||
chat_id = __metadata__.get("chat_id", "")
|
||
if chat_id:
|
||
source = "__metadata__"
|
||
|
||
# 2. 其次从 body 顶层获取
|
||
if not chat_id and isinstance(body, dict):
|
||
chat_id = body.get("chat_id", "")
|
||
if chat_id:
|
||
source = "body_root"
|
||
|
||
# 3. 最后从 body.metadata 获取
|
||
if not chat_id and isinstance(body, dict):
|
||
body_metadata = body.get("metadata", {})
|
||
if isinstance(body_metadata, dict):
|
||
chat_id = body_metadata.get("chat_id", "")
|
||
if chat_id:
|
||
source = "body_metadata"
|
||
|
||
# 调试：记录 ID 来源
|
||
if chat_id:
|
||
self._emit_debug_log_sync(
|
||
f"提取到 ChatID: {chat_id} (来源: {source})",
|
||
__event_call__,
|
||
debug_enabled=debug_enabled,
|
||
)
|
||
else:
|
||
# 如果还是没找到，记录一下 body 的键，方便排查
|
||
keys = list(body.keys()) if isinstance(body, dict) else "not a dict"
|
||
self._emit_debug_log_sync(
|
||
f"警告: 未能提取到 ChatID。Body 键: {keys}",
|
||
__event_call__,
|
||
debug_enabled=debug_enabled,
|
||
)
|
||
|
||
return {
|
||
"chat_id": str(chat_id).strip(),
|
||
}
|
||
|
||
async def pipes(self) -> List[dict]:
|
||
"""动态获取模型列表"""
|
||
# 如果有缓存，直接返回
|
||
if self._model_cache:
|
||
return self._model_cache
|
||
|
||
await self._emit_debug_log("正在动态获取模型列表...")
|
||
try:
|
||
self._setup_env()
|
||
if not self.valves.GH_TOKEN:
|
||
return [{"id": f"{self.id}-error", "name": "Error: GH_TOKEN not set"}]
|
||
|
||
client_config = {}
|
||
if os.environ.get("COPILOT_CLI_PATH"):
|
||
client_config["cli_path"] = os.environ["COPILOT_CLI_PATH"]
|
||
|
||
client = CopilotClient(client_config)
|
||
try:
|
||
await client.start()
|
||
models = await client.list_models()
|
||
|
||
# 更新缓存
|
||
self._model_cache = []
|
||
exclude_list = [
|
||
k.strip().lower()
|
||
for k in self.valves.EXCLUDE_KEYWORDS.split(",")
|
||
if k.strip()
|
||
]
|
||
|
||
models_with_info = []
|
||
for m in models:
|
||
# 兼容字典和对象访问方式
|
||
m_id = (
|
||
m.get("id") if isinstance(m, dict) else getattr(m, "id", str(m))
|
||
)
|
||
m_name = (
|
||
m.get("name")
|
||
if isinstance(m, dict)
|
||
else getattr(m, "name", m_id)
|
||
)
|
||
m_policy = (
|
||
m.get("policy")
|
||
if isinstance(m, dict)
|
||
else getattr(m, "policy", {})
|
||
)
|
||
m_billing = (
|
||
m.get("billing")
|
||
if isinstance(m, dict)
|
||
else getattr(m, "billing", {})
|
||
)
|
||
|
||
# 检查策略状态
|
||
state = (
|
||
m_policy.get("state")
|
||
if isinstance(m_policy, dict)
|
||
else getattr(m_policy, "state", "enabled")
|
||
)
|
||
if state == "disabled":
|
||
continue
|
||
|
||
# 过滤逻辑
|
||
if any(kw in m_id.lower() for kw in exclude_list):
|
||
continue
|
||
|
||
# 获取倍率
|
||
multiplier = (
|
||
m_billing.get("multiplier", 1)
|
||
if isinstance(m_billing, dict)
|
||
else getattr(m_billing, "multiplier", 1)
|
||
)
|
||
|
||
# 格式化显示名称
|
||
# 格式化显示名称
|
||
clean_id = self._clean_model_id(m_id)
|
||
if multiplier == 0:
|
||
display_name = f"-🔥 {clean_id} (0x)"
|
||
else:
|
||
display_name = f"-{clean_id} ({multiplier}x)"
|
||
|
||
models_with_info.append(
|
||
{
|
||
"id": f"{self.id}-{m_id}", # Keep original prefix logic for ID
|
||
"name": display_name,
|
||
"multiplier": multiplier,
|
||
"raw_id": m_id,
|
||
}
|
||
)
|
||
|
||
# 排序：倍率升序，然后是原始ID升序
|
||
models_with_info.sort(key=lambda x: (x["multiplier"], x["raw_id"]))
|
||
self._model_cache = [
|
||
{"id": m["id"], "name": m["name"]} for m in models_with_info
|
||
]
|
||
|
||
await self._emit_debug_log(
|
||
f"成功获取 {len(self._model_cache)} 个模型 (已过滤)"
|
||
)
|
||
return self._model_cache
|
||
except Exception as e:
|
||
await self._emit_debug_log(f"获取模型列表失败: {e}")
|
||
# 失败时返回默认模型
|
||
return [
|
||
{
|
||
"id": f"{self.id}-gpt-5-mini",
|
||
"name": f"GitHub Copilot (gpt-5-mini)",
|
||
}
|
||
]
|
||
finally:
|
||
await client.stop()
|
||
except Exception as e:
|
||
await self._emit_debug_log(f"Pipes Error: {e}")
|
||
return [
|
||
{
|
||
"id": f"{self.id}-gpt-5-mini",
|
||
"name": f"GitHub Copilot (gpt-5-mini)",
|
||
}
|
||
]
|
||
|
||
async def _get_client(self):
|
||
"""Helper to get or create a CopilotClient instance."""
|
||
# 确定工作空间目录
|
||
cwd = self.valves.WORKSPACE_DIR if self.valves.WORKSPACE_DIR else os.getcwd()
|
||
|
||
client_config = {}
|
||
if os.environ.get("COPILOT_CLI_PATH"):
|
||
client_config["cli_path"] = os.environ["COPILOT_CLI_PATH"]
|
||
client_config["cwd"] = cwd
|
||
|
||
# 设置日志级别
|
||
if self.valves.LOG_LEVEL:
|
||
client_config["log_level"] = self.valves.LOG_LEVEL
|
||
|
||
# 添加自定义环境变量
|
||
if self.valves.CUSTOM_ENV_VARS:
|
||
try:
|
||
custom_env = json.loads(self.valves.CUSTOM_ENV_VARS)
|
||
if isinstance(custom_env, dict):
|
||
client_config["env"] = custom_env
|
||
except:
|
||
pass # 静默失败，因为这是同步方法且不应影响主流程
|
||
|
||
client = CopilotClient(client_config)
|
||
await client.start()
|
||
return client
|
||
|
||
async def _update_copilot_cli(
|
||
self, cli_path, __event_call__=None, debug_enabled: bool = False
|
||
):
|
||
"""如果已配置，则异步检查 Copilot CLI 更新。"""
|
||
if not self.valves.AUTO_UPDATE:
|
||
return
|
||
|
||
# 检查更新频率（每 24 小时一次）
|
||
now = time.time()
|
||
if now - self._last_update_check < 86400:
|
||
return
|
||
|
||
self._last_update_check = now
|
||
|
||
try:
|
||
self._emit_debug_log_sync(
|
||
"正在检查 Copilot CLI 更新...",
|
||
__event_call__,
|
||
debug_enabled=debug_enabled,
|
||
)
|
||
|
||
# 我们创建一个子进程来运行更新
|
||
process = await asyncio.create_subprocess_exec(
|
||
cli_path,
|
||
"update",
|
||
stdout=asyncio.subprocess.PIPE,
|
||
stderr=asyncio.subprocess.PIPE,
|
||
)
|
||
|
||
stdout, stderr = await process.communicate()
|
||
|
||
if process.returncode == 0:
|
||
self._emit_debug_log_sync(
|
||
"Copilot CLI 更新检查完成",
|
||
__event_call__,
|
||
debug_enabled=debug_enabled,
|
||
)
|
||
else:
|
||
self._emit_debug_log_sync(
|
||
f"Copilot CLI 更新失败: {stderr.decode()}",
|
||
__event_call__,
|
||
debug_enabled=debug_enabled,
|
||
)
|
||
|
||
except Exception as e:
|
||
self._emit_debug_log_sync(
|
||
f"CLI 更新任务异常: {e}", __event_call__, debug_enabled=debug_enabled
|
||
)
|
||
|
||
def _setup_env(self, __event_call__=None, debug_enabled: bool = False):
|
||
"""初始化环境变量并验证 Copilot CLI。"""
|
||
if self._env_setup_done:
|
||
return
|
||
|
||
# 1. 认证相关的环境变量
|
||
if self.valves.GH_TOKEN:
|
||
os.environ["GH_TOKEN"] = self.valves.GH_TOKEN
|
||
os.environ["GITHUB_TOKEN"] = self.valves.GH_TOKEN
|
||
else:
|
||
self._emit_debug_log_sync(
|
||
"警告: 未设置 GH_TOKEN。", __event_call__, debug_enabled=debug_enabled
|
||
)
|
||
|
||
# 禁用 CLI 自动更新以确保版本一致性
|
||
os.environ["COPILOT_AUTO_UPDATE"] = "false"
|
||
self._emit_debug_log_sync(
|
||
"已禁用 CLI 自动更新 (COPILOT_AUTO_UPDATE=false)",
|
||
__event_call__,
|
||
debug_enabled=debug_enabled,
|
||
)
|
||
|
||
# 2. CLI 路径发现
|
||
cli_path = "/usr/local/bin/copilot"
|
||
if os.environ.get("COPILOT_CLI_PATH"):
|
||
cli_path = os.environ["COPILOT_CLI_PATH"]
|
||
|
||
target_version = self.valves.COPILOT_CLI_VERSION.strip()
|
||
found = False
|
||
current_version = None
|
||
|
||
def get_cli_version(path):
|
||
try:
|
||
output = (
|
||
subprocess.check_output(
|
||
[path, "--version"], stderr=subprocess.STDOUT
|
||
)
|
||
.decode()
|
||
.strip()
|
||
)
|
||
import re
|
||
|
||
match = re.search(r"(\d+\.\d+\.\d+)", output)
|
||
return match.group(1) if match else output
|
||
except Exception:
|
||
return None
|
||
|
||
# 检查现有版本
|
||
if os.path.exists(cli_path):
|
||
found = True
|
||
current_version = get_cli_version(cli_path)
|
||
|
||
if not found:
|
||
sys_path = shutil.which("copilot")
|
||
if sys_path:
|
||
cli_path = sys_path
|
||
found = True
|
||
current_version = get_cli_version(cli_path)
|
||
|
||
if not found:
|
||
pkg_path = os.path.join(os.path.dirname(__file__), "bin", "copilot")
|
||
if os.path.exists(pkg_path):
|
||
cli_path = pkg_path
|
||
found = True
|
||
current_version = get_cli_version(cli_path)
|
||
|
||
# 3. 安装/更新逻辑
|
||
should_install = not found
|
||
install_reason = "CLI 未找到"
|
||
if found and target_version:
|
||
norm_target = target_version.lstrip("v")
|
||
norm_current = current_version.lstrip("v") if current_version else ""
|
||
|
||
# 只有当目标版本大于当前版本时才安装
|
||
try:
|
||
from packaging.version import parse as parse_version
|
||
|
||
if parse_version(norm_target) > parse_version(norm_current):
|
||
should_install = True
|
||
install_reason = f"需要升级 ({current_version} -> {target_version})"
|
||
elif parse_version(norm_target) < parse_version(norm_current):
|
||
self._emit_debug_log_sync(
|
||
f"当前版本 ({current_version}) 比指定版本 ({target_version}) 更新。跳过降级。",
|
||
__event_call__,
|
||
debug_enabled=debug_enabled,
|
||
)
|
||
except Exception as e:
|
||
# 如果 packaging 不可用，回退到字符串比较
|
||
if norm_target != norm_current:
|
||
should_install = True
|
||
install_reason = (
|
||
f"版本不匹配 ({current_version} != {target_version})"
|
||
)
|
||
|
||
if should_install:
|
||
self._emit_debug_log_sync(
|
||
f"正在安装/更新 Copilot CLI: {install_reason}...",
|
||
__event_call__,
|
||
debug_enabled=debug_enabled,
|
||
)
|
||
try:
|
||
env = os.environ.copy()
|
||
if target_version:
|
||
env["VERSION"] = target_version
|
||
subprocess.run(
|
||
"curl -fsSL https://gh.io/copilot-install | bash",
|
||
shell=True,
|
||
check=True,
|
||
env=env,
|
||
)
|
||
# 重新验证
|
||
current_version = get_cli_version(cli_path)
|
||
except Exception as e:
|
||
self._emit_debug_log_sync(
|
||
f"CLI 安装失败: {e}",
|
||
__event_call__,
|
||
debug_enabled=debug_enabled,
|
||
)
|
||
|
||
# 4. 完成初始化
|
||
os.environ["COPILOT_CLI_PATH"] = cli_path
|
||
self._env_setup_done = True
|
||
self._emit_debug_log_sync(
|
||
f"环境设置完成。CLI 路径: {cli_path} (版本: {current_version})",
|
||
__event_call__,
|
||
debug_enabled=debug_enabled,
|
||
)
|
||
self._sync_mcp_config(__event_call__, debug_enabled=debug_enabled)
|
||
|
||
def _process_images(
|
||
self, messages, __event_call__=None, debug_enabled: bool = False
|
||
):
|
||
attachments = []
|
||
text_content = ""
|
||
if not messages:
|
||
return "", []
|
||
last_msg = messages[-1]
|
||
content = last_msg.get("content", "")
|
||
|
||
if isinstance(content, list):
|
||
for item in content:
|
||
if item.get("type") == "text":
|
||
text_content += item.get("text", "")
|
||
elif item.get("type") == "image_url":
|
||
image_url = item.get("image_url", {}).get("url", "")
|
||
if image_url.startswith("data:image"):
|
||
try:
|
||
header, encoded = image_url.split(",", 1)
|
||
ext = header.split(";")[0].split("/")[-1]
|
||
file_name = f"image_{len(attachments)}.{ext}"
|
||
file_path = os.path.join(self.temp_dir, file_name)
|
||
with open(file_path, "wb") as f:
|
||
f.write(base64.b64decode(encoded))
|
||
attachments.append(
|
||
{
|
||
"type": "file",
|
||
"path": file_path,
|
||
"display_name": file_name,
|
||
}
|
||
)
|
||
self._emit_debug_log_sync(
|
||
f"Image processed: {file_path}",
|
||
__event_call__,
|
||
debug_enabled=debug_enabled,
|
||
)
|
||
except Exception as e:
|
||
self._emit_debug_log_sync(
|
||
f"Image error: {e}",
|
||
__event_call__,
|
||
debug_enabled=debug_enabled,
|
||
)
|
||
else:
|
||
text_content = str(content)
|
||
return text_content, attachments
|
||
|
||
# ==================== 内部实现 ====================
|
||
# _pipe_impl() 包含主请求处理逻辑。
|
||
# ================================================
|
||
def _sync_copilot_config(self, reasoning_effort: str, __event_call__=None):
|
||
"""
|
||
如果设置了 REASONING_EFFORT，则动态更新 ~/.copilot/config.json。
|
||
这提供了一个回退机制，以防 API 注入被服务器忽略。
|
||
"""
|
||
if not reasoning_effort:
|
||
return
|
||
|
||
effort = reasoning_effort
|
||
|
||
# 检查模型是否支持 xhigh
|
||
# 目前只有 gpt-5.2-codex 支持 xhigh
|
||
if effort == "xhigh":
|
||
# 简单检查，使用默认模型 ID
|
||
if (
|
||
"gpt-5.2-codex"
|
||
not in self._collect_model_ids(
|
||
body={},
|
||
request_model=self.id,
|
||
real_model_id=None,
|
||
)[0].lower()
|
||
):
|
||
# 如果不支持则回退到 high
|
||
effort = "high"
|
||
|
||
try:
|
||
# 目标标准路径 ~/.copilot/config.json
|
||
config_path = os.path.expanduser("~/.copilot/config.json")
|
||
config_dir = os.path.dirname(config_path)
|
||
|
||
# 仅当目录存在时才继续（避免在路径错误时创建垃圾文件）
|
||
if not os.path.exists(config_dir):
|
||
return
|
||
|
||
data = {}
|
||
# 读取现有配置
|
||
if os.path.exists(config_path):
|
||
try:
|
||
with open(config_path, "r") as f:
|
||
data = json.load(f)
|
||
except Exception:
|
||
data = {}
|
||
|
||
# 如果有变化则更新
|
||
current_val = data.get("reasoning_effort")
|
||
if current_val != effort:
|
||
data["reasoning_effort"] = effort
|
||
try:
|
||
with open(config_path, "w") as f:
|
||
json.dump(data, f, indent=4)
|
||
|
||
self._emit_debug_log_sync(
|
||
f"已动态更新 ~/.copilot/config.json: reasoning_effort='{effort}'",
|
||
__event_call__,
|
||
)
|
||
except Exception as e:
|
||
self._emit_debug_log_sync(
|
||
f"写入 config.json 失败: {e}", __event_call__
|
||
)
|
||
except Exception as e:
|
||
self._emit_debug_log_sync(f"配置同步检查失败: {e}", __event_call__)
|
||
|
||
async def _update_copilot_cli(
|
||
self, cli_path, __event_call__=None, debug_enabled: bool = False
|
||
):
|
||
"""如果已配置，则异步检查 Copilot CLI 更新。"""
|
||
import time
|
||
|
||
if not self.valves.AUTO_UPDATE:
|
||
return
|
||
|
||
# 检查更新频率（每 24 小时一次）
|
||
now = time.time()
|
||
if now - self._last_update_check < 86400:
|
||
return
|
||
|
||
self._last_update_check = now
|
||
|
||
try:
|
||
self._emit_debug_log_sync(
|
||
"正在检查 Copilot CLI 更新...",
|
||
__event_call__,
|
||
debug_enabled=debug_enabled,
|
||
)
|
||
|
||
# 我们创建一个子进程来运行更新
|
||
process = await asyncio.create_subprocess_exec(
|
||
cli_path,
|
||
"update",
|
||
stdout=asyncio.subprocess.PIPE,
|
||
stderr=asyncio.subprocess.PIPE,
|
||
)
|
||
|
||
stdout, stderr = await process.communicate()
|
||
|
||
if process.returncode == 0:
|
||
self._emit_debug_log_sync(
|
||
"Copilot CLI 更新检查完成",
|
||
__event_call__,
|
||
debug_enabled=debug_enabled,
|
||
)
|
||
else:
|
||
self._emit_debug_log_sync(
|
||
f"Copilot CLI 更新失败: {stderr.decode()}",
|
||
__event_call__,
|
||
debug_enabled=debug_enabled,
|
||
)
|
||
|
||
except Exception as e:
|
||
self._emit_debug_log_sync(
|
||
f"CLI 更新任务异常: {e}", __event_call__, debug_enabled=debug_enabled
|
||
)
|
||
|
||
async def _pipe_impl(
|
||
self,
|
||
body: dict,
|
||
__metadata__: Optional[dict] = None,
|
||
__user__: Optional[dict] = None,
|
||
__event_emitter__=None,
|
||
__event_call__=None,
|
||
) -> Union[str, AsyncGenerator]:
|
||
# 1. 首先确定有效的调试设置
|
||
if __user__:
|
||
raw_valves = __user__.get("valves", {})
|
||
if isinstance(raw_valves, self.UserValves):
|
||
user_valves = raw_valves
|
||
elif isinstance(raw_valves, dict):
|
||
user_valves = self.UserValves(**raw_valves)
|
||
else:
|
||
user_valves = self.UserValves()
|
||
else:
|
||
user_valves = self.UserValves()
|
||
|
||
effective_debug = self.valves.DEBUG or user_valves.DEBUG
|
||
|
||
# 2. 初始化环境
|
||
self._setup_env(__event_call__, debug_enabled=effective_debug)
|
||
|
||
cwd = self._get_workspace_dir()
|
||
await self._emit_debug_log(
|
||
f"Agent 工作目录: {cwd}", __event_call__, debug_enabled=effective_debug
|
||
)
|
||
|
||
# 确定有效的 BYOK 设置
|
||
byok_api_key = user_valves.BYOK_API_KEY or self.valves.BYOK_API_KEY
|
||
byok_bearer_token = (
|
||
user_valves.BYOK_BEARER_TOKEN or self.valves.BYOK_BEARER_TOKEN
|
||
)
|
||
byok_base_url = user_valves.BYOK_BASE_URL or self.valves.BYOK_BASE_URL
|
||
byok_active = bool(byok_base_url and (byok_api_key or byok_bearer_token))
|
||
|
||
# 检查 GH_TOKEN 或 BYOK 配置
|
||
gh_token = user_valves.GH_TOKEN or self.valves.GH_TOKEN
|
||
if not gh_token and not byok_active:
|
||
return "Error: 请在 Valves 中配置 GH_TOKEN 或 BYOK 设置。"
|
||
|
||
# 解析模型
|
||
request_model = body.get("model", "")
|
||
real_model_id = request_model
|
||
|
||
# 确定推理强度
|
||
effective_reasoning_effort = (
|
||
user_valves.REASONING_EFFORT
|
||
if user_valves.REASONING_EFFORT
|
||
else self.valves.REASONING_EFFORT
|
||
)
|
||
|
||
# 确定显示思考过程
|
||
show_thinking = (
|
||
user_valves.SHOW_THINKING
|
||
if user_valves.SHOW_THINKING is not None
|
||
else self.valves.SHOW_THINKING
|
||
)
|
||
|
||
# 1. 确定实际使用的模型 ID
|
||
resolved_id = request_model
|
||
model_source_type = "selected"
|
||
|
||
if __metadata__ and __metadata__.get("base_model_id"):
|
||
resolved_id = __metadata__.get("base_model_id", "")
|
||
model_source_type = "base"
|
||
|
||
# 2. 去除前缀 (内联逻辑)
|
||
real_model_id = resolved_id
|
||
if "." in real_model_id:
|
||
real_model_id = real_model_id.split(".", 1)[-1]
|
||
if real_model_id.startswith(f"{self.id}-"):
|
||
real_model_id = real_model_id[len(f"{self.id}-") :]
|
||
if real_model_id.startswith("copilot - "):
|
||
real_model_id = real_model_id[10:]
|
||
|
||
# 3. 记录解析结果
|
||
if real_model_id != request_model:
|
||
log_msg = (
|
||
f"使用 {model_source_type} 模型: {real_model_id} "
|
||
f"(清洗自 '{resolved_id}')"
|
||
)
|
||
await self._emit_debug_log(
|
||
log_msg,
|
||
__event_call__,
|
||
debug_enabled=effective_debug,
|
||
)
|
||
|
||
messages = body.get("messages", [])
|
||
if not messages:
|
||
return "没有消息。"
|
||
|
||
# 获取 Chat ID
|
||
chat_ctx = self._get_chat_context(
|
||
body, __metadata__, __event_call__, debug_enabled=effective_debug
|
||
)
|
||
chat_id = chat_ctx.get("chat_id")
|
||
|
||
# 提取系统提示词
|
||
system_prompt_content, system_prompt_source = await self._extract_system_prompt(
|
||
body,
|
||
messages,
|
||
request_model,
|
||
real_model_id,
|
||
__event_call__,
|
||
debug_enabled=effective_debug,
|
||
)
|
||
|
||
if system_prompt_content:
|
||
preview = system_prompt_content[:60].replace("\n", " ")
|
||
await self._emit_debug_log(
|
||
f"系统提示词来源: {system_prompt_source} (长度: {len(system_prompt_content)})",
|
||
__event_call__,
|
||
debug_enabled=effective_debug,
|
||
)
|
||
|
||
is_streaming = body.get("stream", False)
|
||
await self._emit_debug_log(
|
||
f"流式请求: {is_streaming}",
|
||
__event_call__,
|
||
debug_enabled=effective_debug,
|
||
)
|
||
|
||
last_text, attachments = self._process_images(
|
||
messages, __event_call__, debug_enabled=effective_debug
|
||
)
|
||
|
||
# 判断 BYOK 模型逻辑
|
||
import re
|
||
|
||
is_byok_model = False
|
||
model_display_name = ""
|
||
|
||
# 获取模型名称
|
||
body_metadata = body.get("metadata", {})
|
||
if not isinstance(body_metadata, dict):
|
||
body_metadata = {}
|
||
|
||
meta_model = body_metadata.get("model", {})
|
||
if isinstance(meta_model, dict):
|
||
model_display_name = meta_model.get("name", "")
|
||
|
||
if not model_display_name and __metadata__:
|
||
model_obj = __metadata__.get("model", {})
|
||
if isinstance(model_obj, dict):
|
||
model_display_name = model_obj.get("name", "")
|
||
elif isinstance(model_obj, str):
|
||
model_display_name = model_obj
|
||
|
||
if not model_display_name:
|
||
model_display_name = __metadata__.get("model_name", "") or __metadata__.get("name", "")
|
||
|
||
if model_display_name:
|
||
# 这里的正则已更新支持中文括号
|
||
has_multiplier = bool(re.search(r"[\(（]\d+(?:\.\d+)?x[\)）]", model_display_name))
|
||
|
||
# 逻辑：如果自定义模型名称没有倍率，检查 Base Model 的官方名称
|
||
if not has_multiplier:
|
||
# 确保缓存已填充
|
||
if not self._model_cache:
|
||
try:
|
||
await self.pipes()
|
||
except:
|
||
pass
|
||
|
||
# 在缓存中查找 base model 以检查其官方名称
|
||
cached_model = next(
|
||
(m for m in self._model_cache if m.get("raw_id") == real_model_id or m.get("id") == real_model_id or m.get("id") == f"{self.id}-{real_model_id}"),
|
||
None
|
||
)
|
||
|
||
if cached_model:
|
||
cached_name = cached_model.get("name", "")
|
||
# 这里的正则也已更新支持中文括号
|
||
if re.search(r"[\(（]\d+(?:\.\d+)?x[\)）]", cached_name):
|
||
has_multiplier = True
|
||
await self._emit_debug_log(
|
||
f"修正：在 Base Model 名称 '{cached_name}' 中发现倍率信息 (自定义模型: '{model_display_name}')。视为标准 Copilot 模型。",
|
||
__event_call__,
|
||
debug_enabled=effective_debug,
|
||
)
|
||
|
||
is_byok_model = not has_multiplier and byok_active
|
||
await self._emit_debug_log(
|
||
f"BYOK 检测 (通过显示名称): '{model_display_name}' -> 有倍率={has_multiplier}, 是BYOK={is_byok_model}",
|
||
__event_call__,
|
||
debug_enabled=effective_debug,
|
||
)
|
||
else:
|
||
# 缓存回退逻辑
|
||
if not self._model_cache:
|
||
try:
|
||
await self.pipes()
|
||
except:
|
||
pass
|
||
|
||
base_model_id_from_meta = __metadata__.get("base_model_id", "") if __metadata__ else ""
|
||
lookup_model_id = base_model_id_from_meta if base_model_id_from_meta else request_model
|
||
|
||
model_info = next(
|
||
(m for m in (self._model_cache or []) if m["id"] == lookup_model_id),
|
||
None,
|
||
)
|
||
|
||
if model_info:
|
||
if "source" in model_info:
|
||
is_byok_model = model_info["source"] == "byok"
|
||
else:
|
||
model_name = model_info.get("name", "")
|
||
has_multiplier = bool(re.search(r"[\(（]\d+(?:\.\d+)?x[\)）]", model_name))
|
||
is_byok_model = not has_multiplier and byok_active
|
||
else:
|
||
if byok_active:
|
||
if not gh_token:
|
||
is_byok_model = True
|
||
elif real_model_id.startswith("copilot-"):
|
||
is_byok_model = False
|
||
elif real_model_id not in self._standard_model_ids:
|
||
is_byok_model = True
|
||
|
||
await self._emit_debug_log(
|
||
f"BYOK 检测 (通过启发式): model_id='{real_model_id}', byok_active={byok_active} -> is_byok={is_byok_model}",
|
||
__event_call__,
|
||
debug_enabled=effective_debug,
|
||
)
|
||
|
||
# 仅针对标准 Copilot 模型同步配置
|
||
if not is_byok_model:
|
||
self._sync_copilot_config(effective_reasoning_effort, __event_call__)
|
||
|
||
# 初始化客户端
|
||
client = CopilotClient(self._build_client_config(body))
|
||
should_stop_client = True
|
||
try:
|
||
await client.start()
|
||
|
||
custom_tools = await self._initialize_custom_tools(
|
||
__user__=__user__, __event_call__=__event_call__
|
||
)
|
||
if custom_tools:
|
||
tool_names = [t.name for t in custom_tools]
|
||
await self._emit_debug_log(
|
||
f"启用 {len(custom_tools)} 个工具 (自定义/内置)",
|
||
__event_call__,
|
||
)
|
||
|
||
mcp_servers = self._parse_mcp_servers()
|
||
mcp_server_names = list(mcp_servers.keys()) if mcp_servers else []
|
||
if mcp_server_names:
|
||
await self._emit_debug_log(
|
||
f"🔌 MCP 服务器已配置: {mcp_server_names}",
|
||
__event_call__,
|
||
)
|
||
else:
|
||
await self._emit_debug_log(
|
||
"ℹ️ 未发现 MCP 工具服务器。",
|
||
__event_call__,
|
||
)
|
||
|
||
session = None
|
||
is_new_session = True
|
||
|
||
provider_config = None
|
||
if is_byok_model:
|
||
byok_type = (user_valves.BYOK_TYPE or self.valves.BYOK_TYPE).lower()
|
||
if byok_type not in ["openai", "anthropic"]:
|
||
byok_type = "openai"
|
||
|
||
byok_wire_api = user_valves.BYOK_WIRE_API or self.valves.BYOK_WIRE_API
|
||
|
||
provider_config = {
|
||
"type": byok_type,
|
||
"wire_api": byok_wire_api,
|
||
"base_url": byok_base_url,
|
||
}
|
||
if byok_api_key:
|
||
provider_config["api_key"] = byok_api_key
|
||
if byok_bearer_token:
|
||
provider_config["bearer_token"] = byok_bearer_token
|
||
|
||
if chat_id:
|
||
try:
|
||
resume_params = {
|
||
"model": real_model_id,
|
||
"streaming": is_streaming,
|
||
"tools": custom_tools,
|
||
"available_tools": ([t.name for t in custom_tools] if custom_tools else None),
|
||
}
|
||
if mcp_servers:
|
||
resume_params["mcp_servers"] = mcp_servers
|
||
|
||
system_parts = []
|
||
if system_prompt_content:
|
||
system_parts.append(system_prompt_content.strip())
|
||
system_parts.append(FORMATTING_GUIDELINES)
|
||
final_system_msg = "\n".join(system_parts)
|
||
|
||
resume_params["system_message"] = {
|
||
"mode": "replace",
|
||
"content": final_system_msg,
|
||
}
|
||
|
||
if provider_config:
|
||
resume_params["provider"] = provider_config
|
||
await self._emit_debug_log(
|
||
f"包含 BYOK 提供商配置: type={provider_config.get('type')}",
|
||
__event_call__,
|
||
debug_enabled=effective_debug,
|
||
)
|
||
|
||
session = await client.resume_session(chat_id, resume_params)
|
||
await self._emit_debug_log(
|
||
f"成功恢复会话 {chat_id}，模型: {real_model_id}",
|
||
__event_call__,
|
||
)
|
||
is_new_session = False
|
||
except Exception as e:
|
||
await self._emit_debug_log(
|
||
f"会话 {chat_id} 未找到或恢复失败 ({str(e)})，正在创建新会话。",
|
||
__event_call__,
|
||
)
|
||
|
||
if session is None:
|
||
is_new_session = True
|
||
|
||
from copilot.types import SessionConfig, InfiniteSessionConfig
|
||
|
||
infinite_session_config = None
|
||
if self.valves.INFINITE_SESSION:
|
||
infinite_session_config = InfiniteSessionConfig(
|
||
enabled=True,
|
||
background_compaction_threshold=self.valves.COMPACTION_THRESHOLD,
|
||
buffer_exhaustion_threshold=self.valves.BUFFER_THRESHOLD,
|
||
)
|
||
|
||
system_parts = []
|
||
if system_prompt_content:
|
||
system_parts.append(system_prompt_content.strip())
|
||
system_parts.append(FORMATTING_GUIDELINES)
|
||
final_system_msg = "\n".join(system_parts)
|
||
|
||
session_params = {
|
||
"session_id": chat_id if chat_id else None,
|
||
"model": real_model_id,
|
||
"streaming": is_streaming,
|
||
"tools": custom_tools,
|
||
"available_tools": [t.name for t in custom_tools] if custom_tools else None,
|
||
"system_message": {
|
||
"mode": "replace",
|
||
"content": final_system_msg,
|
||
},
|
||
"infinite_sessions": infinite_session_config,
|
||
"working_directory": self._get_workspace_dir(),
|
||
}
|
||
|
||
if provider_config:
|
||
session_params["provider"] = provider_config
|
||
|
||
if mcp_servers:
|
||
session_params["mcp_servers"] = mcp_servers
|
||
|
||
session_config = SessionConfig(**session_params)
|
||
|
||
await self._emit_debug_log(
|
||
f"注入系统提示词到新会话 (长度: {len(final_system_msg)})",
|
||
__event_call__,
|
||
)
|
||
|
||
session = await client.create_session(config=session_config)
|
||
|
||
model_type_label = "BYOK" if is_byok_model else "Copilot"
|
||
await self._emit_debug_log(
|
||
f"新 {model_type_label} 会话已创建。选择: '{request_model}', 有效 ID: '{real_model_id}'",
|
||
__event_call__,
|
||
debug_enabled=effective_debug,
|
||
)
|
||
|
||
prompt = last_text
|
||
await self._emit_debug_log(
|
||
f"发送提示词 ({len(prompt)} 字符) 给 Agent...",
|
||
__event_call__,
|
||
)
|
||
|
||
send_payload = {"prompt": prompt, "mode": "immediate"}
|
||
if attachments:
|
||
send_payload["attachments"] = attachments
|
||
|
||
if body.get("stream", False):
|
||
init_msg = ""
|
||
if effective_debug:
|
||
init_msg = (
|
||
f"> [Debug] Agent 工作目录: {self._get_workspace_dir()}\n"
|
||
)
|
||
if mcp_server_names:
|
||
init_msg += f"> [Debug] 🔌 已连接 MCP 服务器: {', '.join(mcp_server_names)}\n"
|
||
|
||
should_stop_client = False
|
||
return self.stream_response(
|
||
client,
|
||
session,
|
||
send_payload,
|
||
init_msg,
|
||
__event_call__,
|
||
reasoning_effort=effective_reasoning_effort,
|
||
show_thinking=show_thinking,
|
||
debug_enabled=effective_debug,
|
||
)
|
||
else:
|
||
try:
|
||
response = await session.send_and_wait(send_payload)
|
||
return response.data.content if response else "无响应。"
|
||
finally:
|
||
if not chat_id:
|
||
try:
|
||
await session.destroy()
|
||
except:
|
||
pass
|
||
except Exception as e:
|
||
await self._emit_debug_log(
|
||
f"请求错误: {e}", __event_call__, debug_enabled=effective_debug
|
||
)
|
||
return f"Error: {str(e)}"
|
||
finally:
|
||
if should_stop_client:
|
||
try:
|
||
await client.stop()
|
||
except:
|
||
pass
|
||
|
||
async def stream_response(
|
||
self,
|
||
client,
|
||
session,
|
||
send_payload,
|
||
init_message: str = "",
|
||
__event_call__=None,
|
||
reasoning_effort: str = "",
|
||
show_thinking: bool = True,
|
||
debug_enabled: bool = False,
|
||
) -> AsyncGenerator:
|
||
"""
|
||
从 Copilot SDK 流式传输响应，处理各种事件类型。
|
||
遵循官方 SDK 模式进行事件处理和流式传输。
|
||
"""
|
||
from copilot.generated.session_events import SessionEventType
|
||
|
||
queue = asyncio.Queue()
|
||
done = asyncio.Event()
|
||
SENTINEL = object()
|
||
# 使用本地状态来处理并发和跟踪
|
||
state = {"thinking_started": False, "content_sent": False}
|
||
has_content = False # 追踪是否已经输出了内容
|
||
active_tools = {} # 映射 tool_call_id 到工具名称
|
||
|
||
def get_event_type(event) -> str:
|
||
"""提取事件类型为字符串，处理枚举和字符串类型。"""
|
||
if hasattr(event, "type"):
|
||
event_type = event.type
|
||
# 处理 SessionEventType 枚举
|
||
if hasattr(event_type, "value"):
|
||
return event_type.value
|
||
return str(event_type)
|
||
return "unknown"
|
||
|
||
def safe_get_data_attr(event, attr: str, default=None):
|
||
"""
|
||
安全地从 event.data 提取属性。
|
||
同时处理字典访问和对象属性访问。
|
||
"""
|
||
if not hasattr(event, "data") or event.data is None:
|
||
return default
|
||
|
||
data = event.data
|
||
|
||
# 首先尝试作为字典
|
||
if isinstance(data, dict):
|
||
return data.get(attr, default)
|
||
|
||
# 尝试作为对象属性
|
||
return getattr(data, attr, default)
|
||
|
||
def handler(event):
|
||
"""
|
||
事件处理器，遵循官方 SDK 模式。
|
||
处理流式增量、推理、工具事件和会话状态。
|
||
"""
|
||
event_type = get_event_type(event)
|
||
|
||
# === 消息增量事件（主要流式内容）===
|
||
if event_type == "assistant.message_delta":
|
||
# 官方：Python SDK 使用 event.data.delta_content
|
||
delta = safe_get_data_attr(
|
||
event, "delta_content"
|
||
) or safe_get_data_attr(event, "deltaContent")
|
||
if delta:
|
||
state["content_sent"] = True
|
||
if state["thinking_started"]:
|
||
queue.put_nowait("\n</think>\n")
|
||
state["thinking_started"] = False
|
||
queue.put_nowait(delta)
|
||
|
||
# === 完整消息事件（非流式响应） ===
|
||
elif event_type == "assistant.message":
|
||
# 处理完整消息（当 SDK 返回完整内容而不是增量时）
|
||
content = safe_get_data_attr(event, "content") or safe_get_data_attr(
|
||
event, "message"
|
||
)
|
||
if content:
|
||
state["content_sent"] = True
|
||
if state["thinking_started"]:
|
||
queue.put_nowait("\n</think>\n")
|
||
state["thinking_started"] = False
|
||
queue.put_nowait(content)
|
||
|
||
# === 推理增量事件（思维链流式传输）===
|
||
elif event_type == "assistant.reasoning_delta":
|
||
delta = safe_get_data_attr(
|
||
event, "delta_content"
|
||
) or safe_get_data_attr(event, "deltaContent")
|
||
if delta:
|
||
# 如果内容已经开始，抑制迟到的推理
|
||
if state["content_sent"]:
|
||
return
|
||
|
||
if not state["thinking_started"] and show_thinking:
|
||
queue.put_nowait("<think>\n")
|
||
state["thinking_started"] = True
|
||
if state["thinking_started"]:
|
||
queue.put_nowait(delta)
|
||
|
||
# === 完整推理事件（非流式推理） ===
|
||
elif event_type == "assistant.reasoning":
|
||
# 处理完整推理内容
|
||
reasoning = safe_get_data_attr(event, "content") or safe_get_data_attr(
|
||
event, "reasoning"
|
||
)
|
||
if reasoning:
|
||
# 如果内容已经开始，抑制延迟到达的推理
|
||
if state["content_sent"]:
|
||
return
|
||
|
||
if not state["thinking_started"] and show_thinking:
|
||
queue.put_nowait("<think>\n")
|
||
state["thinking_started"] = True
|
||
if state["thinking_started"]:
|
||
queue.put_nowait(reasoning)
|
||
|
||
# === 工具执行事件 ===
|
||
elif event_type == "tool.execution_start":
|
||
tool_name = (
|
||
safe_get_data_attr(event, "name")
|
||
or safe_get_data_attr(event, "tool_name")
|
||
or "未知工具"
|
||
)
|
||
tool_call_id = safe_get_data_attr(event, "tool_call_id", "")
|
||
|
||
# 获取工具参数
|
||
tool_args = {}
|
||
try:
|
||
args_obj = safe_get_data_attr(event, "arguments")
|
||
if isinstance(args_obj, dict):
|
||
tool_args = args_obj
|
||
elif isinstance(args_obj, str):
|
||
tool_args = json.loads(args_obj)
|
||
except:
|
||
pass
|
||
|
||
if tool_call_id:
|
||
active_tools[tool_call_id] = {
|
||
"name": tool_name,
|
||
"arguments": tool_args,
|
||
}
|
||
|
||
# 在显示工具前关闭思考标签
|
||
if state["thinking_started"]:
|
||
queue.put_nowait("\n</think>\n")
|
||
state["thinking_started"] = False
|
||
|
||
# 使用改进的格式展示工具调用
|
||
if tool_args:
|
||
tool_args_json = json.dumps(tool_args, indent=2, ensure_ascii=False)
|
||
tool_display = f"\n\n<details>\n<summary>🔧 执行工具: {tool_name}</summary>\n\n**参数:**\n\n```json\n{tool_args_json}\n```\n\n</details>\n\n"
|
||
else:
|
||
tool_display = f"\n\n<details>\n<summary>🔧 执行工具: {tool_name}</summary>\n\n*无参数*\n\n</details>\n\n"
|
||
|
||
queue.put_nowait(tool_display)
|
||
|
||
self._emit_debug_log_sync(f"工具开始: {tool_name}", __event_call__)
|
||
|
||
elif event_type == "tool.execution_complete":
|
||
tool_call_id = safe_get_data_attr(event, "tool_call_id", "")
|
||
tool_info = active_tools.get(tool_call_id)
|
||
|
||
# 处理旧的字符串格式和新的字典格式
|
||
if isinstance(tool_info, str):
|
||
tool_name = tool_info
|
||
elif isinstance(tool_info, dict):
|
||
tool_name = tool_info.get("name", "未知工具")
|
||
else:
|
||
tool_name = "未知工具"
|
||
|
||
# 尝试获取结果内容
|
||
result_content = ""
|
||
result_type = "success"
|
||
try:
|
||
result_obj = safe_get_data_attr(event, "result")
|
||
if hasattr(result_obj, "content"):
|
||
result_content = result_obj.content
|
||
elif isinstance(result_obj, dict):
|
||
result_content = result_obj.get("content", "")
|
||
result_type = result_obj.get("result_type", "success")
|
||
if not result_content:
|
||
# 如果没有 content 字段，尝试序列化整个字典
|
||
result_content = json.dumps(
|
||
result_obj, indent=2, ensure_ascii=False
|
||
)
|
||
except Exception as e:
|
||
self._emit_debug_log_sync(f"提取结果时出错: {e}", __event_call__)
|
||
result_type = "failure"
|
||
result_content = f"错误: {str(e)}"
|
||
|
||
# 使用改进的格式展示工具结果
|
||
if result_content:
|
||
status_icon = "✅" if result_type == "success" else "❌"
|
||
|
||
# 尝试检测内容类型以便更好地格式化
|
||
is_json = False
|
||
try:
|
||
json_obj = (
|
||
json.loads(result_content)
|
||
if isinstance(result_content, str)
|
||
else result_content
|
||
)
|
||
if isinstance(json_obj, (dict, list)):
|
||
result_content = json.dumps(
|
||
json_obj, indent=2, ensure_ascii=False
|
||
)
|
||
is_json = True
|
||
except:
|
||
pass
|
||
|
||
# 根据内容类型格式化
|
||
if is_json:
|
||
# JSON 内容：使用代码块和语法高亮
|
||
result_display = f"\n<details>\n<summary>{status_icon} 执行结果: {tool_name}</summary>\n\n```json\n{result_content}\n```\n\n</details>\n\n"
|
||
else:
|
||
# 纯文本：保留格式，不使用代码块
|
||
result_display = f"\n<details>\n<summary>{status_icon} 执行结果: {tool_name}</summary>\n\n{result_content}\n\n</details>\n\n"
|
||
|
||
queue.put_nowait(result_display)
|
||
|
||
elif event_type == "tool.execution_progress":
|
||
# 工具执行进度更新（用于长时间运行的工具）
|
||
tool_call_id = safe_get_data_attr(event, "tool_call_id", "")
|
||
tool_info = active_tools.get(tool_call_id)
|
||
tool_name = (
|
||
tool_info.get("name", "未知工具")
|
||
if isinstance(tool_info, dict)
|
||
else "未知工具"
|
||
)
|
||
|
||
progress = safe_get_data_attr(event, "progress", 0)
|
||
message = safe_get_data_attr(event, "message", "")
|
||
|
||
if message:
|
||
progress_display = f"\n> 🔄 **{tool_name}**: {message}\n"
|
||
queue.put_nowait(progress_display)
|
||
|
||
self._emit_debug_log_sync(
|
||
f"工具进度: {tool_name} - {progress}%", __event_call__
|
||
)
|
||
|
||
elif event_type == "tool.execution_partial_result":
|
||
# 流式工具结果（用于增量输出的工具）
|
||
tool_call_id = safe_get_data_attr(event, "tool_call_id", "")
|
||
tool_info = active_tools.get(tool_call_id)
|
||
tool_name = (
|
||
tool_info.get("name", "未知工具")
|
||
if isinstance(tool_info, dict)
|
||
else "未知工具"
|
||
)
|
||
|
||
partial_content = safe_get_data_attr(event, "content", "")
|
||
if partial_content:
|
||
queue.put_nowait(partial_content)
|
||
|
||
self._emit_debug_log_sync(f"工具部分结果: {tool_name}", __event_call__)
|
||
|
||
# === 使用统计事件 ===
|
||
elif event_type == "assistant.usage":
|
||
# 当前助手回合的 token 使用量
|
||
if self.valves.DEBUG:
|
||
input_tokens = safe_get_data_attr(event, "input_tokens", 0)
|
||
output_tokens = safe_get_data_attr(event, "output_tokens", 0)
|
||
total_tokens = safe_get_data_attr(event, "total_tokens", 0)
|
||
pass
|
||
|
||
elif event_type == "session.usage_info":
|
||
# 会话累计使用信息
|
||
pass
|
||
|
||
# === 会话状态事件 ===
|
||
elif event_type == "session.compaction_start":
|
||
self._emit_debug_log_sync("会话压缩已开始", __event_call__)
|
||
|
||
elif event_type == "session.compaction_complete":
|
||
self._emit_debug_log_sync("会话压缩已完成", __event_call__)
|
||
|
||
elif event_type == "session.idle":
|
||
# 会话处理完成 - 发出完成信号
|
||
done.set()
|
||
try:
|
||
queue.put_nowait(SENTINEL)
|
||
except:
|
||
pass
|
||
|
||
elif event_type == "session.error":
|
||
error_msg = safe_get_data_attr(event, "message", "未知错误")
|
||
queue.put_nowait(f"\n[错误: {error_msg}]")
|
||
done.set()
|
||
try:
|
||
queue.put_nowait(SENTINEL)
|
||
except:
|
||
pass
|
||
|
||
unsubscribe = session.on(handler)
|
||
|
||
self._emit_debug_log_sync(f"已订阅事件。正在发送请求...", __event_call__)
|
||
|
||
# 使用 asyncio.create_task 防止 session.send 阻塞流读取
|
||
# 如果 SDK 实现等待完成。
|
||
send_task = asyncio.create_task(session.send(send_payload))
|
||
self._emit_debug_log_sync(f"Prompt 已发送 (异步任务已启动)", __event_call__)
|
||
|
||
# 安全的初始 yield，带错误处理
|
||
try:
|
||
if self.valves.DEBUG:
|
||
yield "<think>\n"
|
||
if init_message:
|
||
yield init_message
|
||
|
||
if reasoning_effort and reasoning_effort != "off":
|
||
yield f"> [Debug] 已注入推理强度 (Reasoning Effort): {reasoning_effort.upper()}\n"
|
||
|
||
yield "> [Debug] 连接已建立，等待响应...\n"
|
||
self.thinking_started = True
|
||
except Exception as e:
|
||
# 如果初始 yield 失败，记录但继续处理
|
||
self._emit_debug_log_sync(f"初始 yield 警告: {e}", __event_call__)
|
||
|
||
try:
|
||
while not done.is_set():
|
||
try:
|
||
chunk = await asyncio.wait_for(
|
||
queue.get(), timeout=float(self.valves.TIMEOUT)
|
||
)
|
||
if chunk is SENTINEL:
|
||
break
|
||
if chunk:
|
||
has_content = True
|
||
try:
|
||
yield chunk
|
||
except Exception as yield_error:
|
||
# 客户端关闭连接，优雅停止
|
||
self._emit_debug_log_sync(
|
||
f"Yield 错误（客户端断开连接？）: {yield_error}",
|
||
__event_call__,
|
||
)
|
||
break
|
||
except asyncio.TimeoutError:
|
||
if done.is_set():
|
||
break
|
||
if self.thinking_started:
|
||
try:
|
||
yield f"> [Debug] 等待响应中 (已超过 {self.valves.TIMEOUT} 秒)...\n"
|
||
except:
|
||
# 如果超时期间 yield 失败，连接已断开
|
||
break
|
||
continue
|
||
|
||
while not queue.empty():
|
||
chunk = queue.get_nowait()
|
||
if chunk is SENTINEL:
|
||
break
|
||
if chunk:
|
||
has_content = True
|
||
try:
|
||
yield chunk
|
||
except:
|
||
# 连接关闭，停止 yielding
|
||
break
|
||
|
||
if self.thinking_started:
|
||
try:
|
||
yield "\n</think>\n"
|
||
has_content = True
|
||
except:
|
||
pass # 连接已关闭
|
||
|
||
# 核心修复：如果整个过程没有任何输出，返回一个提示，防止 OpenWebUI 报错
|
||
if not has_content:
|
||
try:
|
||
yield "⚠️ Copilot 未返回任何内容。请检查模型 ID 是否正确，或尝试在 Valves 中开启 DEBUG 模式查看详细日志。"
|
||
except:
|
||
pass # 连接已关闭
|
||
|
||
except Exception as e:
|
||
try:
|
||
yield f"\n[Stream Error: {str(e)}]"
|
||
except:
|
||
pass # 连接已关闭
|
||
finally:
|
||
unsubscribe()
|
||
# 销毁会话对象以释放内存，但保留磁盘数据
|
||
await session.destroy()
|