diff --git a/docs/plugins/pipes/github-copilot-sdk.md b/docs/plugins/pipes/github-copilot-sdk.md
index 90cbc73..fe4f928 100644
--- a/docs/plugins/pipes/github-copilot-sdk.md
+++ b/docs/plugins/pipes/github-copilot-sdk.md
@@ -1,32 +1,36 @@
 # GitHub Copilot SDK Pipe for OpenWebUI
 
-**Author:** [Fu-Jie](https://github.com/Fu-Jie/awesome-openwebui) | **Version:** 0.3.0 | **Project:** [Awesome OpenWebUI](https://github.com/Fu-Jie/awesome-openwebui) | **License:** MIT
+**Author:** [Fu-Jie](https://github.com/Fu-Jie/awesome-openwebui) | **Version:** 0.5.1 | **Project:** [Awesome OpenWebUI](https://github.com/Fu-Jie/awesome-openwebui) | **License:** MIT
 
-This is an advanced Pipe function for [OpenWebUI](https://github.com/open-webui/open-webui) that allows you to use GitHub Copilot models (such as `gpt-5`, `gpt-5-mini`, `claude-sonnet-4.5`) directly within OpenWebUI. It is built upon the official [GitHub Copilot SDK for Python](https://github.com/github/copilot-sdk), providing a native integration experience.
+This is an advanced Pipe function for [OpenWebUI](https://github.com/open-webui/open-webui) that integrates the official [GitHub Copilot SDK](https://github.com/github/copilot-sdk). It enables you to use **GitHub Copilot models** (e.g., `gpt-5.2-codex`, `claude-sonnet-4.5`, `gemini-3-pro`, `gpt-5-mini`) **AND** your own models via **BYOK** (OpenAI, Anthropic) directly within OpenWebUI, providing a unified agentic experience.
 
-> [!IMPORTANT]
-> **Active GitHub Copilot Subscription Required**
-> This plugin requires a valid GitHub Copilot subscription (Individual, Business, or Enterprise). It will verify your subscription status during authentication.
+> [!TIP]
+> **No Subscription Required for BYOK**
+> If you are using your own API keys (BYOK mode with OpenAI/Anthropic), **you do NOT need a GitHub Copilot subscription.**
+> A subscription is only required to access GitHub's official models.
 
-## 🚀 What's New (v0.3.0) - The Power of "Unified Ecosystem"
+## 🚀 What's New (v0.5.1) - Major Upgrade
 
-* **🔌 Zero-Config Tool Bridge**: Automatically transforms your existing OpenWebUI Functions (Tools) into Copilot-compatible tools. **Copilot now has total access to your entire WebUI toolset!**
-* **🔗 Dynamic MCP Discovery**: Seamlessly connects to MCP servers defined in **Admin Settings -> Connections**. No configuration files required—it just works.
-* **⚡ High-Performance Async Engine**: Background CLI updates and optimized event-driven streaming ensure lightning-fast responses without UI lag.
-* **🛡️ Robust Interoperability**: Advanced sanitization and dynamic Pydantic model generation ensure smooth integration even with complex third-party tools.
+- **🧠 Smarter BYOK Detection**: Improved logic to correctly identify BYOK vs. Official Copilot models, supporting custom models (Characters/Prompts) and fixing multiplier detection (e.g., `(0x)`, `(1x)`).
+- **⚡ Performance Boost**: Implemented **Tool Caching** to persist tool definitions across requests, significantly reducing overhead.
+- **🧩 Enriched Tool Integration**: Tool descriptions now include source grouping (Built-in/User/Server) and automatic metadata extraction (Title/Description) from Python docstrings.
+- **🛡️ Precise Control**: Added support for OpenWebUI's `function_name_filter_list` to filter MCP and OpenAPI functions.
+- **🔑 User-Level BYOK**: Fully leverage Copilot SDK with your own Model Providers (OpenAI, Anthropic) with user-level API Key overrides.
+- **📝 Better Formatting**: Enforced standard Markdown tables in system prompts to prevent rendering issues with HTML tables.
 
 ## ✨ Key Capabilities
 
-* **🌉 The Ultimate Bridge**: The first and only plugin that creates a seamless bridge between **OpenWebUI Tools** and **GitHub Copilot SDK**.
-* **🚀 Official & Native**: Built directly on the official Python SDK, providing the most stable and authentic Copilot experience.
-* **🌊 Advanced Streaming (Thought Process)**: Supports full model reasoning/thinking display with typewriter effects.
-* **🖼️ Intelligent Multimodal**: Full support for images and attachments, enabling Copilot to "see" your workspace.
-* **🛠️ Effortless Setup**: Automatic CLI detection, version enforcement, and dependency management.
-* **🔑 Dual-Layer Security**: Supports secure OAuth flow for Chat and standard PAT for extended MCP capabilities.
+- **🔑 Flexible Auth & BYOK**: Supports GitHub Copilot subscription (PAT) OR Bring Your Own Key (OpenAI/Anthropic), giving you total control over model access and billing.
+- **🌉 The Ultimate Bridge**: The first and only plugin that creates a seamless bridge between **OpenWebUI Tools** and **GitHub Copilot SDK**.
+- **🚀 Official & Native**: Built directly on the official Python SDK, providing the most stable and authentic Copilot experience.
+- **🌊 Advanced Streaming (Thought Process)**: Supports full model reasoning/thinking display with typewriter effects.
+- **🖼️ Intelligent Multimodal**: Full support for images and attachments, enabling Copilot to "see" your workspace.
+- **🛠️ Effortless Setup**: Automatic CLI detection, version enforcement, and dependency management.
+- **🛡️ Integrated Security**: Supports secure PAT authentication for standard and extended capabilities.
 
-## 📦 Installation & Usage
+## Installation & Configuration
 
-### 1. Import Function
+### 1) Import Function
 
 1. Open OpenWebUI.
 2. Go to **Workspace** -> **Functions**.
@@ -34,7 +38,7 @@ This is an advanced Pipe function for [OpenWebUI](https://github.com/open-webui/
 4. Paste the content of `github_copilot_sdk.py` (or `github_copilot_sdk_cn.py` for Chinese) completely.
 5. Save.
 
-### 2. Configure Valves (Settings)
+### 2) Configure Valves (Settings)
 
 Find "GitHub Copilot" in the function list and click the **⚙️ (Valves)** icon to configure:
 
@@ -53,9 +57,14 @@ Find "GitHub Copilot" in the function list and click the **⚙️ (Valves)** ico
 | **TIMEOUT** | Timeout for each stream chunk (seconds). | `300` |
 | **CUSTOM_ENV_VARS** | Custom environment variables (JSON format). | - |
 | **REASONING_EFFORT** | Reasoning effort level: low, medium, high. `xhigh` is supported for some models. | `medium` |
-| **ENFORCE_FORMATTING** | Add formatting instructions to system prompt for better readability. | `True` |
 | **ENABLE_MCP_SERVER** | Enable Direct MCP Client connection (Recommended). | `True` |
 | **ENABLE_OPENWEBUI_TOOLS** | Enable OpenWebUI Tools (includes defined and server tools). | `True` |
+| **BYOK_ENABLED** | Enable BYOK (Bring Your Own Key) to use custom providers. | `False` |
+| **BYOK_TYPE** | BYOK Provider Type: `openai`, `azure`, `anthropic`. | `openai` |
+| **BYOK_BASE_URL** | BYOK Base URL (e.g., `https://api.openai.com/v1`). | - |
+| **BYOK_API_KEY** | BYOK API Key (Global Setting). | - |
+| **BYOK_BEARER_TOKEN** | BYOK Bearer Token (Global, overrides API Key). | - |
+| **BYOK_WIRE_API** | BYOK Wire API: `completions`, `responses`. | `completions` |
 
 #### User Valves (per-user overrides)
 
@@ -69,9 +78,13 @@ These optional settings can be set per user (overrides global Valves):
 | **SHOW_THINKING** | Show model reasoning/thinking process. | `True` |
 | **ENABLE_OPENWEBUI_TOOLS** | Enable OpenWebUI Tools (overrides global). | `True` |
 | **ENABLE_MCP_SERVER** | Enable MCP server loading (overrides global). | `True` |
-| **ENFORCE_FORMATTING** | Enforce formatting guidelines (overrides global). | `True` |
+| **BYOK_API_KEY** | BYOK API Key (User override). | - |
 
-### 3. Get Token
+## ⭐ Support
+
+If this plugin has been useful, a star on [Awesome OpenWebUI](https://github.com/Fu-Jie/awesome-openwebui) is a big motivation for me. Thank you for the support.
+
+### Get Token
 
 To use GitHub Copilot, you need a GitHub Personal Access Token (PAT) with appropriate permissions.
 
@@ -81,24 +94,24 @@ To use GitHub Copilot, you need a GitHub Personal Access Token (PAT) with approp
 2. Click **Generate new token (fine-grained)**.
 3. **Repository access**: Select **Public Repositories** (simplest) or **All repositories**.
 4. **Permissions**:
-    * If you chose **All repositories**, you must click **Account permissions**.
-    * Find **Copilot Requests**, and select **Access**.
+    - If you chose **All repositories**, you must click **Account permissions**.
+    - Find **Copilot Requests**, and select **Access**.
 5. Generate and copy the Token.
 
 ## 📋 Dependencies
 
 This Pipe will automatically attempt to install the following dependencies:
 
-* `github-copilot-sdk` (Python package)
-* `github-copilot-cli` (Binary file, installed via official script)
+- `github-copilot-sdk` (Python package)
+- `github-copilot-cli` (Binary file, installed via official script)
 
 ## Troubleshooting ❓
 
-* **Images and Multimodal Usage**:
-  * Ensure `MODEL_ID` is a model that supports multimodal input.
-* **Thinking not shown**:
-  * Ensure **streaming is enabled** and the selected model supports reasoning output.
+- **Images not recognized**:
+  - Ensure `MODEL_ID` is a model that supports multimodal input.
+- **Thinking not shown**:
+  - Ensure **streaming is enabled** and the selected model supports reasoning output.
 
-## 📄 License
+## Changelog
 
-MIT
+See the full history on GitHub: [Awesome OpenWebUI](https://github.com/Fu-Jie/awesome-openwebui)
diff --git a/docs/plugins/pipes/github-copilot-sdk.zh.md b/docs/plugins/pipes/github-copilot-sdk.zh.md
index 1cb1276..fb0d7ca 100644
--- a/docs/plugins/pipes/github-copilot-sdk.zh.md
+++ b/docs/plugins/pipes/github-copilot-sdk.zh.md
@@ -1,30 +1,35 @@
 # GitHub Copilot SDK 官方管道
 
-**作者:** [Fu-Jie](https://github.com/Fu-Jie/awesome-openwebui) | **版本:** 0.3.0 | **项目:** [Awesome OpenWebUI](https://github.com/Fu-Jie/awesome-openwebui) | **许可证:** MIT
+**作者:** [Fu-Jie](https://github.com/Fu-Jie/awesome-openwebui) | **版本:** 0.5.1 | **项目:** [Awesome OpenWebUI](https://github.com/Fu-Jie/awesome-openwebui) | **许可证:** MIT
 
-这是一个用于 [OpenWebUI](https://github.com/open-webui/open-webui) 的高级 Pipe 函数，允许你直接在 OpenWebUI 中使用 GitHub Copilot 模型（如 `gpt-5`, `gpt-5-mini`, `claude-sonnet-4.5`）。它基于官方 [GitHub Copilot SDK for Python](https://github.com/github/copilot-sdk) 构建，提供了原生级的集成体验。
+这是一个用于 [OpenWebUI](https://github.com/open-webui/open-webui) 的高级 Pipe 函数，深度集成了 **GitHub Copilot SDK**。它不仅支持 **GitHub Copilot 官方模型**（如 `gpt-5.2-codex`, `claude-sonnet-4.5`, `gemini-3-pro`, `gpt-5-mini`），还支持 **BYOK (自带 Key)** 模式对接自定义服务商（OpenAI, Anthropic），提供统一的 Agent 交互体验。
 
 > [!IMPORTANT]
-> **需 GitHub Copilot 订阅**
-> 本插件需要有效的 GitHub Copilot 订阅（个人版、商业版或企业版）。插件将在认证阶段验证您的订阅状态。
+> [!TIP]
+> **使用 BYOK 模式无需订阅**
+> 如果您使用自己的 API Key (OpenAI, Anthropic) 运行 BYOK 模式，**则完全不需要** GitHub Copilot 订阅。
+> 仅当您希望使用 GitHub 官方提供的模型时，才需要订阅。
 
-## 🚀 最新特性 (v0.3.0) - “统一生态”的力量
+## 🚀 最新特性 (v0.5.1) - 重大升级
 
-* **🔌 零配置工具桥接 (Unified Tool Bridge)**: 自动将您现有的 OpenWebUI Functions (工具) 转换为 Copilot 兼容工具。**Copilot 现在可以无缝调用您手头所有的 WebUI 工具！**
-* **🔗 动态 MCP 自动发现**: 直接联动 OpenWebUI **管理面板 -> 连接**。无需编写任何配置文件，即插即用，瞬间扩展 Copilot 能力边界。
-* **⚡ 高性能异步引擎**: 异步 CLI 更新检查与高度优化的事件驱动流式处理，确保对话毫秒级响应。
-* **🛡️ 卓越的兼容性**: 独创的动态 Pydantic 模型生成技术，确保复杂工具参数在 Copilot 端也能得到精准验证。
+- **🧠 智能 BYOK 检测**: 优化了 BYOK 与官方 Copilot 模型的识别逻辑，完美支持自定义模型（角色/提示词）及倍率检测（如 `(0x)`, `(1x)`）。
+- **⚡ 性能飙升**: 引入 **工具缓存 (Tool Caching)** 机制，在请求间持久化工具定义，显著降低调用开销。
+- **🧩 丰富工具集成**: 工具描述现包含来源分组（内置/用户/服务器）及 Docstring 元数据自动解析。
+- **🛡️ 精确控制**: 完美兼容 OpenWebUI 全局函数过滤配置 (`function_name_filter_list`)，可精准控制暴露给 LLM 的函数。
+- **🔑 用户级 BYOK**: 支持在用户层面配置自定义 API Key 对接 AI 供应商（OpenAI, Anthropic）。
+- **📝 格式优化**: 系统提示词强制使用标准 Markdown 表格，彻底解决 HTML 表格渲染问题。
 
 ## ✨ 核心能力
 
-* **🌉 强大的生态桥接**: 首个且唯一完美打通 **OpenWebUI Tools** 与 **GitHub Copilot SDK** 的插件。
-* **🚀 官方原生产体验**: 基于官方 Python SDK 构建，提供最稳定、最纯正的 Copilot 交互体验。
-* **🌊 深度推理展示**: 完整支持模型思考过程 (Thinking Process) 的流式渲染。
-* **🖼️ 智能多模态**: 支持图像识别与附件上传，让 Copilot 拥有视觉能力。
-* **🛠️ 极简部署流程**: 自动检测环境、自动下载 CLI、自动管理依赖，全自动化开箱即用。
-* **🔑 安全认证体系**: 完美支持 OAuth 授权与 PAT 模式，兼顾便捷与安全性。
+- **🔑 灵活鉴权与 BYOK**: 支持 GitHub Copilot 订阅 (PAT) 或自带 Key (OpenAI/Anthropic)，完全掌控模型访问与计费。
+- **🌉 强大的生态桥接**: 首个且唯一完美打通 **OpenWebUI Tools** 与 **GitHub Copilot SDK** 的插件。
+- **🚀 官方原生产体验**: 基于官方 Python SDK 构建，提供最稳定、最纯正的 Copilot 交互体验。
+- **🌊 深度推理展示**: 完整支持模型思考过程 (Thinking Process) 的流式渲染。
+- **🖼️ 智能多模态**: 支持图像识别与附件上传，让 Copilot 拥有视觉能力。
+- **🛠️ 极简部署流程**: 自动检测环境、自动下载 CLI、自动管理依赖，全自动化开箱即用。
+- **🛡️ 纯净安全体系**: 支持标准 PAT 认证，确保数据安全。
 
-## 📦 安装与使用
+## 安装与配置
 
 ### 1. 导入函数
 
@@ -53,9 +58,14 @@
 | **TIMEOUT** | 每个流式分块超时（秒）。 | `300` |
 | **CUSTOM_ENV_VARS** | 自定义环境变量 (JSON 格式)。 | - |
 | **REASONING_EFFORT** | 推理强度级别: low, medium, high. `xhigh` 仅部分模型支持。 | `medium` |
-| **ENFORCE_FORMATTING** | 在系统提示词中添加格式化指导。 | `True` |
 | **ENABLE_MCP_SERVER** | 启用直接 MCP 客户端连接 (建议)。 | `True` |
 | **ENABLE_OPENWEBUI_TOOLS** | 启用 OpenWebUI 工具 (包括自定义和服务器工具)。 | `True` |
+| **BYOK_ENABLED** | 启用 BYOK (自带 Key) 模式以使用自定义供应商。 | `False` |
+| **BYOK_TYPE** | BYOK 供应商类型: `openai`, `azure`, `anthropic`。 | `openai` |
+| **BYOK_BASE_URL** | BYOK 基础 URL (如 `https://api.openai.com/v1`)。 | - |
+| **BYOK_API_KEY** | BYOK API Key (全局设置)。 | - |
+| **BYOK_BEARER_TOKEN** | BYOK Bearer Token (全局，覆盖 API Key)。 | - |
+| **BYOK_WIRE_API** | BYOK 通信协议: `completions`, `responses`。 | `completions` |
 
 #### 用户 Valves（按用户覆盖）
 
@@ -69,9 +79,12 @@
 | **SHOW_THINKING** | 是否显示思考过程。 | `True` |
 | **ENABLE_OPENWEBUI_TOOLS** | 启用 OpenWebUI 工具（覆盖全局设置）。 | `True` |
 | **ENABLE_MCP_SERVER** | 启用动态 MCP 服务器加载（覆盖全局设置）。 | `True` |
-| **ENFORCE_FORMATTING** | 强制启用格式化指导（覆盖全局设置）。 | `True` |
 
-### 3. 获取 Token
+## ⭐ 支持
+
+如果这个插件对你有帮助，欢迎到 [Awesome OpenWebUI](https://github.com/Fu-Jie/awesome-openwebui) 点个 Star，这将是我持续改进的动力，感谢支持。
+
+### 获取 Token
 
 要使用 GitHub Copilot，您需要一个具有适当权限的 GitHub 个人访问令牌 (PAT)。
 
@@ -81,24 +94,24 @@
 2. 点击 **Generate new token (fine-grained)**。
 3. **Repository access**: 选择 **Public Repositories** (最简单) 或 **All repositories**。
 4. **Permissions**:
-    * 如果您选择了 **All repositories**，则必须点击 **Account permissions**。
-    * 找到 **Copilot Requests**，选择 **Access**。
+    - 如果您选择了 **All repositories**，则必须点击 **Account permissions**。
+    - 找到 **Copilot Requests**，选择 **Access**。
 5. 生成并复制令牌。
 
 ## 📋 依赖说明
 
 该 Pipe 会自动尝试安装以下依赖（如果环境中缺失）：
 
-* `github-copilot-sdk` (Python 包)
-* `github-copilot-cli` (二进制文件，通过官方脚本安装)
+- `github-copilot-sdk` (Python 包)
+- `github-copilot-cli` (二进制文件，通过官方脚本安装)
 
 ## 故障排除 (Troubleshooting) ❓
 
-* **图片及多模态使用说明**：
-  * 确保 `MODEL_ID` 是支持多模态的模型。
-* **看不到思考过程**：
-  * 确认已开启**流式输出**，且所选模型支持推理输出。
+- **图片及多模态使用说明**：
+  - 确保 `MODEL_ID` 是支持多模态的模型。
+- **看不到思考过程**：
+  - 确认已开启**流式输出**，且所选模型支持推理输出。
 
-## 📄 许可证
+## 更新日志
 
-MIT
+完整历史请查看 GitHub 项目： [Awesome OpenWebUI](https://github.com/Fu-Jie/awesome-openwebui)
diff --git a/docs/plugins/pipes/index.md b/docs/plugins/pipes/index.md
index 9cf6b1b..7e37fcb 100644
--- a/docs/plugins/pipes/index.md
+++ b/docs/plugins/pipes/index.md
@@ -15,7 +15,7 @@ Pipes allow you to:
 
 ## Available Pipe Plugins
 
-- [GitHub Copilot SDK](github-copilot-sdk.md) (v0.3.0) - Official GitHub Copilot SDK integration. Features **zero-config OpenWebUI Tool Bridge** and **dynamic MCP discovery**. Supports streaming, multimodal, and infinite sessions.
+- [GitHub Copilot SDK](github-copilot-sdk.md) (v0.5.1) - Official GitHub Copilot SDK integration. Features **zero-config OpenWebUI Tool Bridge**, **BYOK** support, and **dynamic MCP discovery**. Supports streaming, multimodal, and infinite sessions.
 
 ---
 
diff --git a/docs/plugins/pipes/index.zh.md b/docs/plugins/pipes/index.zh.md
index d2885f0..69030d2 100644
--- a/docs/plugins/pipes/index.zh.md
+++ b/docs/plugins/pipes/index.zh.md
@@ -15,7 +15,7 @@ Pipes 可以用于：
 
 ## 可用的 Pipe 插件
 
-- [GitHub Copilot SDK](github-copilot-sdk.zh.md) (v0.3.0) - GitHub Copilot SDK 官方集成。**零配置工具桥接**与**动态 MCP 发现**。支持流式输出、多模态及无限会话。
+- [GitHub Copilot SDK](github-copilot-sdk.zh.md) (v0.5.1) - GitHub Copilot SDK 官方集成。**零配置工具桥接**与**BYOK (自带 Key) 支持**。支持流式输出、多模态及无限会话。
 
 ---
 
diff --git a/plugins/pipes/github-copilot-sdk/README.md b/plugins/pipes/github-copilot-sdk/README.md
index cc897a5..079cbb7 100644
--- a/plugins/pipes/github-copilot-sdk/README.md
+++ b/plugins/pipes/github-copilot-sdk/README.md
@@ -1,28 +1,32 @@
 # GitHub Copilot SDK Pipe for OpenWebUI
 
-**Author:** [Fu-Jie](https://github.com/Fu-Jie/awesome-openwebui) | **Version:** 0.3.0 | **Project:** [Awesome OpenWebUI](https://github.com/Fu-Jie/awesome-openwebui) | **License:** MIT
+**Author:** [Fu-Jie](https://github.com/Fu-Jie/awesome-openwebui) | **Version:** 0.5.1 | **Project:** [Awesome OpenWebUI](https://github.com/Fu-Jie/awesome-openwebui) | **License:** MIT
 
-This is an advanced Pipe function for [OpenWebUI](https://github.com/open-webui/open-webui) that allows you to use GitHub Copilot models (such as `gpt-5`, `gpt-5-mini`, `claude-sonnet-4.5`) directly within OpenWebUI. It is built upon the official [GitHub Copilot SDK for Python](https://github.com/github/copilot-sdk), providing a native integration experience.
+This is an advanced Pipe function for [OpenWebUI](https://github.com/open-webui/open-webui) that integrates the official [GitHub Copilot SDK](https://github.com/github/copilot-sdk). It enables you to use **GitHub Copilot models** (e.g., `gpt-5.2-codex`, `claude-sonnet-4.5`,`gemini-3-pro`, `gpt-5-mini`) **AND** your own models via **BYOK** (OpenAI, Anthropic) directly within OpenWebUI, providing a unified agentic experience.
 
-> [!IMPORTANT]
-> **Active GitHub Copilot Subscription Required**
-> This plugin requires a valid GitHub Copilot subscription (Individual, Business, or Enterprise). It will verify your subscription status during authentication.
+> [!TIP]
+> **No Subscription Required for BYOK**
+> If you are using your own API keys (BYOK mode with OpenAI/Anthropic), **you do NOT need a GitHub Copilot subscription.**
+> A subscription is only required to access GitHub's official models.
 
-## 🚀 What's New (v0.3.0) - The Power of "Unified Ecosystem"
+## 🚀 What's New (v0.5.1) - Major Upgrade
 
-* **🔌 Zero-Config Tool Bridge**: Automatically transforms your existing OpenWebUI Functions (Tools) into Copilot-compatible tools. **Copilot now has total access to your entire WebUI toolset!**
-* **🔗 Dynamic MCP Discovery**: Seamlessly connects to MCP servers defined in **Admin Settings -> Connections**. No configuration files required—it just works.
-* **⚡ High-Performance Async Engine**: Background CLI updates and optimized event-driven streaming ensure lightning-fast responses without UI lag.
-* **🛡️ Robust Interoperability**: Advanced sanitization and dynamic Pydantic model generation ensure smooth integration even with complex third-party tools.
+- **🧠 Smarter BYOK Detection**: Improved logic to correctly identify BYOK vs. Official Copilot models, supporting custom models (Characters/Prompts) and fixing multiplier detection (e.g., `(0x)`, `(1x)`).
+- **⚡ Performance Boost**: Implemented **Tool Caching** to persist tool definitions across requests, significantly reducing overhead.
+- **🧩 Enriched Tool Integration**: Tool descriptions now include source grouping (Built-in/User/Server) and automatic metadata extraction (Title/Description) from Python docstrings.
+- **🛡️ Precise Control**: Added support for OpenWebUI's `function_name_filter_list` to filter MCP and OpenAPI functions.
+- **🔑 User-Level BYOK**: Fully leverage Copilot SDK with your own Model Providers (OpenAI, Anthropic) with user-level API Key overrides.
+- **📝 Better Formatting**: Enforced standard Markdown tables in system prompts to prevent rendering issues with HTML tables.
 
 ## ✨ Key Capabilities
 
-* **🌉 The Ultimate Bridge**: The first and only plugin that creates a seamless bridge between **OpenWebUI Tools** and **GitHub Copilot SDK**.
-* **🚀 Official & Native**: Built directly on the official Python SDK, providing the most stable and authentic Copilot experience.
-* **🌊 Advanced Streaming (Thought Process)**: Supports full model reasoning/thinking display with typewriter effects.
-* **🖼️ Intelligent Multimodal**: Full support for images and attachments, enabling Copilot to "see" your workspace.
-* **🛠️ Effortless Setup**: Automatic CLI detection, version enforcement, and dependency management.
-* **🔑 Dual-Layer Security**: Supports secure OAuth flow for Chat and standard PAT for extended MCP capabilities.
+- **🔑 Flexible Auth & BYOK**: Supports GitHub Copilot subscription (PAT) OR Bring Your Own Key (OpenAI/Anthropic), giving you total control over model access and billing.
+- **🌉 The Ultimate Bridge**: The first and only plugin that creates a seamless bridge between **OpenWebUI Tools** and **GitHub Copilot SDK**.
+- **🚀 Official & Native**: Built directly on the official Python SDK, providing the most stable and authentic Copilot experience.
+- **🌊 Advanced Streaming (Thought Process)**: Supports full model reasoning/thinking display with typewriter effects.
+- **🖼️ Intelligent Multimodal**: Full support for images and attachments, enabling Copilot to "see" your workspace.
+- **🛠️ Effortless Setup**: Automatic CLI detection, version enforcement, and dependency management.
+- **🛡️ Integrated Security**: Supports secure PAT authentication for standard and extended capabilities.
 
 ## Installation & Configuration
 
@@ -53,9 +57,15 @@ Find "GitHub Copilot" in the function list and click the **⚙️ (Valves)** ico
 | **TIMEOUT** | Timeout for each stream chunk (seconds). | `300` |
 | **CUSTOM_ENV_VARS** | Custom environment variables (JSON format). | - |
 | **REASONING_EFFORT** | Reasoning effort level: low, medium, high. `xhigh` is supported for some models. | `medium` |
-| **ENFORCE_FORMATTING** | Add formatting instructions to system prompt for better readability. | `True` |
+
 | **ENABLE_MCP_SERVER** | Enable Direct MCP Client connection (Recommended). | `True` |
 | **ENABLE_OPENWEBUI_TOOLS** | Enable OpenWebUI Tools (includes defined and server tools). | `True` |
+| **BYOK_ENABLED** | Enable BYOK (Bring Your Own Key) to use custom providers. | `False` |
+| **BYOK_TYPE** | BYOK Provider Type: `openai`, `azure`, `anthropic`. | `openai` |
+| **BYOK_BASE_URL** | BYOK Base URL (e.g., `https://api.openai.com/v1`). | - |
+| **BYOK_API_KEY** | BYOK API Key (Global Setting). | - |
+| **BYOK_BEARER_TOKEN** | BYOK Bearer Token (Global, overrides API Key). | - |
+| **BYOK_WIRE_API** | BYOK Wire API: `completions`, `responses`. | `completions` |
 
 #### User Valves (per-user overrides)
 
@@ -69,7 +79,8 @@ These optional settings can be set per user (overrides global Valves):
 | **SHOW_THINKING** | Show model reasoning/thinking process. | `True` |
 | **ENABLE_OPENWEBUI_TOOLS** | Enable OpenWebUI Tools (overrides global). | `True` |
 | **ENABLE_MCP_SERVER** | Enable MCP server loading (overrides global). | `True` |
-| **ENFORCE_FORMATTING** | Enforce formatting guidelines (overrides global). | `True` |
+
+| **BYOK_API_KEY** | BYOK API Key (User override). | - |
 
 ## ⭐ Support
 
@@ -85,23 +96,23 @@ To use GitHub Copilot, you need a GitHub Personal Access Token (PAT) with approp
 2. Click **Generate new token (fine-grained)**.
 3. **Repository access**: Select **Public Repositories** (simplest) or **All repositories**.
 4. **Permissions**:
-    * If you chose **All repositories**, you must click **Account permissions**.
-    * Find **Copilot Requests**, and select **Access**.
+    - If you chose **All repositories**, you must click **Account permissions**.
+    - Find **Copilot Requests**, and select **Access**.
 5. Generate and copy the Token.
 
 ## 📋 Dependencies
 
 This Pipe will automatically attempt to install the following dependencies:
 
-* `github-copilot-sdk` (Python package)
-* `github-copilot-cli` (Binary file, installed via official script)
+- `github-copilot-sdk` (Python package)
+- `github-copilot-cli` (Binary file, installed via official script)
 
 ## Troubleshooting ❓
 
-* **Images not recognized**:
-  * Ensure `MODEL_ID` is a model that supports multimodal input.
-* **Thinking not shown**:
-  * Ensure **streaming is enabled** and the selected model supports reasoning output.
+- **Images not recognized**:
+  - Ensure `MODEL_ID` is a model that supports multimodal input.
+- **Thinking not shown**:
+  - Ensure **streaming is enabled** and the selected model supports reasoning output.
 
 ## Changelog
 
diff --git a/plugins/pipes/github-copilot-sdk/README_CN.md b/plugins/pipes/github-copilot-sdk/README_CN.md
index 34d2b99..fb0d7ca 100644
--- a/plugins/pipes/github-copilot-sdk/README_CN.md
+++ b/plugins/pipes/github-copilot-sdk/README_CN.md
@@ -1,28 +1,33 @@
 # GitHub Copilot SDK 官方管道
 
-**作者:** [Fu-Jie](https://github.com/Fu-Jie/awesome-openwebui) | **版本:** 0.3.0 | **项目:** [Awesome OpenWebUI](https://github.com/Fu-Jie/awesome-openwebui) | **许可证:** MIT
+**作者:** [Fu-Jie](https://github.com/Fu-Jie/awesome-openwebui) | **版本:** 0.5.1 | **项目:** [Awesome OpenWebUI](https://github.com/Fu-Jie/awesome-openwebui) | **许可证:** MIT
 
-这是一个用于 [OpenWebUI](https://github.com/open-webui/open-webui) 的高级 Pipe 函数，允许你直接在 OpenWebUI 中使用 GitHub Copilot 模型（如 `gpt-5`, `gpt-5-mini`, `claude-sonnet-4.5`）。它基于官方 [GitHub Copilot SDK for Python](https://github.com/github/copilot-sdk) 构建，提供了原生级的集成体验。
+这是一个用于 [OpenWebUI](https://github.com/open-webui/open-webui) 的高级 Pipe 函数，深度集成了 **GitHub Copilot SDK**。它不仅支持 **GitHub Copilot 官方模型**（如 `gpt-5.2-codex`, `claude-sonnet-4.5`, `gemini-3-pro`, `gpt-5-mini`），还支持 **BYOK (自带 Key)** 模式对接自定义服务商（OpenAI, Anthropic），提供统一的 Agent 交互体验。
 
 > [!IMPORTANT]
-> **需 GitHub Copilot 订阅**
-> 本插件需要有效的 GitHub Copilot 订阅（个人版、商业版或企业版）。插件将在认证阶段验证您的订阅状态。
+> [!TIP]
+> **使用 BYOK 模式无需订阅**
+> 如果您使用自己的 API Key (OpenAI, Anthropic) 运行 BYOK 模式，**则完全不需要** GitHub Copilot 订阅。
+> 仅当您希望使用 GitHub 官方提供的模型时，才需要订阅。
 
-## 🚀 最新特性 (v0.3.0) - “统一生态”的力量
+## 🚀 最新特性 (v0.5.1) - 重大升级
 
-* **🔌 零配置工具桥接 (Unified Tool Bridge)**: 自动将您现有的 OpenWebUI Functions (工具) 转换为 Copilot 兼容工具。**Copilot 现在可以无缝调用您手头所有的 WebUI 工具！**
-* **🔗 动态 MCP 自动发现**: 直接联动 OpenWebUI **管理面板 -> 连接**。无需编写任何配置文件，即插即用，瞬间扩展 Copilot 能力边界。
-* **⚡ 高性能异步引擎**: 异步 CLI 更新检查与高度优化的事件驱动流式处理，确保对话毫秒级响应。
-* **🛡️ 卓越的兼容性**: 独创的动态 Pydantic 模型生成技术，确保复杂工具参数在 Copilot 端也能得到精准验证。
+- **🧠 智能 BYOK 检测**: 优化了 BYOK 与官方 Copilot 模型的识别逻辑，完美支持自定义模型（角色/提示词）及倍率检测（如 `(0x)`, `(1x)`）。
+- **⚡ 性能飙升**: 引入 **工具缓存 (Tool Caching)** 机制，在请求间持久化工具定义，显著降低调用开销。
+- **🧩 丰富工具集成**: 工具描述现包含来源分组（内置/用户/服务器）及 Docstring 元数据自动解析。
+- **🛡️ 精确控制**: 完美兼容 OpenWebUI 全局函数过滤配置 (`function_name_filter_list`)，可精准控制暴露给 LLM 的函数。
+- **🔑 用户级 BYOK**: 支持在用户层面配置自定义 API Key 对接 AI 供应商（OpenAI, Anthropic）。
+- **📝 格式优化**: 系统提示词强制使用标准 Markdown 表格，彻底解决 HTML 表格渲染问题。
 
 ## ✨ 核心能力
 
-* **🌉 强大的生态桥接**: 首个且唯一完美打通 **OpenWebUI Tools** 与 **GitHub Copilot SDK** 的插件。
-* **🚀 官方原生产体验**: 基于官方 Python SDK 构建，提供最稳定、最纯正的 Copilot 交互体验。
-* **🌊 深度推理展示**: 完整支持模型思考过程 (Thinking Process) 的流式渲染。
-* **🖼️ 智能多模态**: 支持图像识别与附件上传，让 Copilot 拥有视觉能力。
-* **🛠️ 极简部署流程**: 自动检测环境、自动下载 CLI、自动管理依赖，全自动化开箱即用。
-* **🔑 安全认证体系**: 完美支持 OAuth 授权与 PAT 模式，兼顾便捷与安全性。
+- **🔑 灵活鉴权与 BYOK**: 支持 GitHub Copilot 订阅 (PAT) 或自带 Key (OpenAI/Anthropic)，完全掌控模型访问与计费。
+- **🌉 强大的生态桥接**: 首个且唯一完美打通 **OpenWebUI Tools** 与 **GitHub Copilot SDK** 的插件。
+- **🚀 官方原生产体验**: 基于官方 Python SDK 构建，提供最稳定、最纯正的 Copilot 交互体验。
+- **🌊 深度推理展示**: 完整支持模型思考过程 (Thinking Process) 的流式渲染。
+- **🖼️ 智能多模态**: 支持图像识别与附件上传，让 Copilot 拥有视觉能力。
+- **🛠️ 极简部署流程**: 自动检测环境、自动下载 CLI、自动管理依赖，全自动化开箱即用。
+- **🛡️ 纯净安全体系**: 支持标准 PAT 认证，确保数据安全。
 
 ## 安装与配置
 
@@ -53,9 +58,14 @@
 | **TIMEOUT** | 每个流式分块超时（秒）。 | `300` |
 | **CUSTOM_ENV_VARS** | 自定义环境变量 (JSON 格式)。 | - |
 | **REASONING_EFFORT** | 推理强度级别: low, medium, high. `xhigh` 仅部分模型支持。 | `medium` |
-| **ENFORCE_FORMATTING** | 在系统提示词中添加格式化指导。 | `True` |
 | **ENABLE_MCP_SERVER** | 启用直接 MCP 客户端连接 (建议)。 | `True` |
 | **ENABLE_OPENWEBUI_TOOLS** | 启用 OpenWebUI 工具 (包括自定义和服务器工具)。 | `True` |
+| **BYOK_ENABLED** | 启用 BYOK (自带 Key) 模式以使用自定义供应商。 | `False` |
+| **BYOK_TYPE** | BYOK 供应商类型: `openai`, `azure`, `anthropic`。 | `openai` |
+| **BYOK_BASE_URL** | BYOK 基础 URL (如 `https://api.openai.com/v1`)。 | - |
+| **BYOK_API_KEY** | BYOK API Key (全局设置)。 | - |
+| **BYOK_BEARER_TOKEN** | BYOK Bearer Token (全局，覆盖 API Key)。 | - |
+| **BYOK_WIRE_API** | BYOK 通信协议: `completions`, `responses`。 | `completions` |
 
 #### 用户 Valves（按用户覆盖）
 
@@ -69,7 +79,6 @@
 | **SHOW_THINKING** | 是否显示思考过程。 | `True` |
 | **ENABLE_OPENWEBUI_TOOLS** | 启用 OpenWebUI 工具（覆盖全局设置）。 | `True` |
 | **ENABLE_MCP_SERVER** | 启用动态 MCP 服务器加载（覆盖全局设置）。 | `True` |
-| **ENFORCE_FORMATTING** | 强制启用格式化指导（覆盖全局设置）。 | `True` |
 
 ## ⭐ 支持
 
@@ -85,23 +94,23 @@
 2. 点击 **Generate new token (fine-grained)**。
 3. **Repository access**: 选择 **Public Repositories** (最简单) 或 **All repositories**。
 4. **Permissions**:
-    * 如果您选择了 **All repositories**，则必须点击 **Account permissions**。
-    * 找到 **Copilot Requests**，选择 **Access**。
+    - 如果您选择了 **All repositories**，则必须点击 **Account permissions**。
+    - 找到 **Copilot Requests**，选择 **Access**。
 5. 生成并复制令牌。
 
 ## 📋 依赖说明
 
 该 Pipe 会自动尝试安装以下依赖（如果环境中缺失）：
 
-* `github-copilot-sdk` (Python 包)
-* `github-copilot-cli` (二进制文件，通过官方脚本安装)
+- `github-copilot-sdk` (Python 包)
+- `github-copilot-cli` (二进制文件，通过官方脚本安装)
 
 ## 故障排除 (Troubleshooting) ❓
 
-* **图片及多模态使用说明**：
-  * 确保 `MODEL_ID` 是支持多模态的模型。
-* **看不到思考过程**：
-  * 确认已开启**流式输出**，且所选模型支持推理输出。
+- **图片及多模态使用说明**：
+  - 确保 `MODEL_ID` 是支持多模态的模型。
+- **看不到思考过程**：
+  - 确认已开启**流式输出**，且所选模型支持推理输出。
 
 ## 更新日志
 
diff --git a/plugins/pipes/github-copilot-sdk/debug/test_system_message_resume.py b/plugins/pipes/github-copilot-sdk/debug/test_system_message_resume.py
new file mode 100644
index 0000000..d5d32c0
--- /dev/null
+++ b/plugins/pipes/github-copilot-sdk/debug/test_system_message_resume.py
@@ -0,0 +1,424 @@
+#!/usr/bin/env python3
+"""
+Copilot SDK System Message Test Script
+Tests whether system_message is properly applied during session.resume
+
+This script verifies the bug hypothesis:
+- session.resume with system_message config may not reliably update the system prompt
+
+Test scenarios:
+1. Create a new session with a custom system message
+2. Resume the same session with a DIFFERENT system message
+3. Ask the model to describe its current system instructions
+
+Requirements:
+- github-copilot-sdk>=0.1.23
+"""
+
+import asyncio
+import os
+import sys
+import time
+
+from copilot import CopilotClient
+from copilot.types import SessionConfig
+from copilot.generated.session_events import SessionEventType
+
+
+# Test system messages
+SYSTEM_MSG_A = """You are a helpful assistant named "ALPHA". 
+When asked about your name or identity, you MUST respond: "I am ALPHA, the first assistant."
+Always start your responses with "[ALPHA]:" prefix.
+"""
+
+SYSTEM_MSG_B = """You are a helpful assistant named "BETA". 
+When asked about your name or identity, you MUST respond: "I am BETA, the second assistant."
+Always start your responses with "[BETA]:" prefix.
+"""
+
+
+async def send_and_get_response(session, prompt: str) -> str:
+    """Send a message and collect the full response using event subscription."""
+    full_response = ""
+    response_complete = asyncio.Event()
+
+    def event_handler(event):
+        nonlocal full_response
+        if event.type == SessionEventType.ASSISTANT_MESSAGE_DELTA:
+            delta = getattr(event.data, "content", "") or ""
+            print(delta, end="", flush=True)
+            full_response += delta
+        elif event.type == SessionEventType.ASSISTANT_MESSAGE:
+            # Final complete message
+            content = getattr(event.data, "content", "") or ""
+            if content and not full_response:
+                full_response = content
+                print(content, end="", flush=True)
+        elif event.type == SessionEventType.SESSION_IDLE:
+            response_complete.set()
+        elif event.type == SessionEventType.ASSISTANT_TURN_END:
+            response_complete.set()
+
+    # Subscribe to events
+    unsubscribe = session.on(event_handler)
+
+    try:
+        # Send the message
+        await session.send({"prompt": prompt, "mode": "immediate"})
+        # Wait for completion (with timeout)
+        await asyncio.wait_for(response_complete.wait(), timeout=120)
+        print()  # newline after completion
+    finally:
+        unsubscribe()
+
+    return full_response
+
+
+async def test_new_session_system_message(client: CopilotClient):
+    """Test 1: New session with system message A"""
+    print("\n" + "=" * 60)
+    print("TEST 1: New Session with System Message A (ALPHA)")
+    print("=" * 60)
+
+    session_config = SessionConfig(
+        session_id="test-session-001",
+        model="gpt-5-mini",
+        streaming=True,
+        system_message={
+            "mode": "replace",
+            "content": SYSTEM_MSG_A,
+        },
+    )
+
+    session = await client.create_session(config=session_config)
+    print(f"✅ Created new session: {session.session_id}")
+
+    print("\n📤 Asking: 'What is your name?'")
+    print("📥 Response: ", end="")
+    response = await send_and_get_response(session, "What is your name?")
+
+    if "ALPHA" in response:
+        print("✅ SUCCESS: Model correctly identified as ALPHA")
+    else:
+        print("⚠️ WARNING: Model did NOT identify as ALPHA")
+
+    return session
+
+
+async def test_resume_session_with_new_system_message(
+    client: CopilotClient, session_id: str
+):
+    """Test 2: Resume session with DIFFERENT system message B"""
+    print("\n" + "=" * 60)
+    print("TEST 2: Resume Session with System Message B (BETA)")
+    print("=" * 60)
+
+    resume_config = {
+        "model": "gpt-5-mini",
+        "streaming": True,
+        "system_message": {
+            "mode": "replace",
+            "content": SYSTEM_MSG_B,
+        },
+    }
+
+    print(f"📋 Resume config includes system_message with mode='replace'")
+    print(f"📋 New system_message content: BETA identity")
+
+    session = await client.resume_session(session_id, resume_config)
+    print(f"✅ Resumed session: {session.session_id}")
+
+    print("\n📤 Asking: 'What is your name now? Did your identity change?'")
+    print("📥 Response: ", end="")
+    response = await send_and_get_response(
+        session, "What is your name now? Did your identity change?"
+    )
+
+    if "BETA" in response:
+        print("✅ SUCCESS: System message was updated to BETA")
+        return True
+    elif "ALPHA" in response:
+        print("❌ BUG CONFIRMED: System message was NOT updated (still ALPHA)")
+        return False
+    else:
+        print("⚠️ INCONCLUSIVE: Model response doesn't clearly indicate identity")
+        return None
+
+
+async def test_resume_without_system_message(client: CopilotClient, session_id: str):
+    """Test 3: Resume session without specifying system_message"""
+    print("\n" + "=" * 60)
+    print("TEST 3: Resume Session WITHOUT System Message")
+    print("=" * 60)
+
+    resume_config = {
+        "model": "gpt-4o",
+        "streaming": True,
+        # No system_message specified
+    }
+
+    session = await client.resume_session(session_id, resume_config)
+    print(f"✅ Resumed session: {session.session_id}")
+
+    print("\n📤 Asking: 'What is your name? Tell me your current identity.'")
+    print("📥 Response: ", end="")
+    response = await send_and_get_response(
+        session, "What is your name? Tell me your current identity."
+    )
+
+    if "ALPHA" in response:
+        print(
+            "ℹ️ Without system_message: Model still remembers ALPHA from original session"
+        )
+    elif "BETA" in response:
+        print("ℹ️ Without system_message: Model remembers BETA from Test 2")
+    else:
+        print("ℹ️ Model identity unclear")
+
+
+async def main():
+    print("=" * 60)
+    print("🧪 Copilot SDK System Message Resume Test")
+    print("=" * 60)
+    print(f"Time: {time.strftime('%Y-%m-%d %H:%M:%S')}")
+    print(f"Testing with SDK from: {CopilotClient.__module__}")
+
+    # Create client with explicit CLI path if provided
+    cli_path = os.environ.get("COPILOT_CLI_PATH")
+    client_config = {"log_level": "info"}
+    if cli_path:
+        client_config["cli_path"] = cli_path
+
+    client = CopilotClient(client_config)
+
+    try:
+        await client.start()
+        print("✅ Client started successfully")
+
+        # Test 1: Create new session with system message A
+        session = await test_new_session_system_message(client)
+        session_id = session.session_id
+
+        # Wait a bit before resuming
+        print("\n⏳ Waiting 2 seconds before resume test...")
+        await asyncio.sleep(2)
+
+        # Test 2: Resume with different system message B
+        bug_confirmed = await test_resume_session_with_new_system_message(
+            client, session_id
+        )
+
+        # Test 3: Resume without system message
+        await test_resume_without_system_message(client, session_id)
+
+        # Summary
+        print("\n" + "=" * 60)
+        print("📊 TEST SUMMARY (Native Copilot)")
+        print("=" * 60)
+        if bug_confirmed is False:
+            print(
+                "❌ BUG CONFIRMED: session.resume does NOT apply system_message updates"
+            )
+            print("   The system message from create_session persists even when")
+            print("   resume_session specifies a different system_message.")
+            print("\n   WORKAROUND: Inject system context into user prompt instead.")
+        elif bug_confirmed is True:
+            print("✅ NO BUG: session.resume correctly updates system_message")
+        else:
+            print("⚠️ INCONCLUSIVE: Could not determine if bug exists")
+
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        import traceback
+
+        traceback.print_exc()
+    finally:
+        await client.stop()
+        print("\n✅ Client stopped")
+
+
+# =============================================================================
+# BYOK OpenAI Test
+# =============================================================================
+
+
+async def test_byok_new_session(client: CopilotClient, provider_config: dict):
+    """BYOK Test 1: New session with BYOK provider and system message A"""
+    print("\n" + "=" * 60)
+    print("BYOK TEST 1: New Session with BYOK Provider + System Message A (ALPHA)")
+    print("=" * 60)
+    print(
+        f"📋 Provider: {provider_config.get('type')} @ {provider_config.get('base_url')}"
+    )
+
+    session_config = SessionConfig(
+        session_id="byok-test-session-001",
+        model="gpt-4o",  # or your model name
+        streaming=True,
+        provider=provider_config,
+        system_message={
+            "mode": "replace",
+            "content": SYSTEM_MSG_A,
+        },
+    )
+
+    session = await client.create_session(config=session_config)
+    print(f"✅ Created BYOK session: {session.session_id}")
+
+    print("\n📤 Asking: 'What is your name?'")
+    print("📥 Response: ", end="")
+    response = await send_and_get_response(session, "What is your name?")
+
+    if "ALPHA" in response:
+        print("✅ SUCCESS: Model correctly identified as ALPHA")
+    else:
+        print("⚠️ WARNING: Model did NOT identify as ALPHA")
+
+    return session
+
+
+async def test_byok_resume_with_new_system_message(
+    client: CopilotClient, session_id: str, provider_config: dict
+):
+    """BYOK Test 2: Resume BYOK session with DIFFERENT system message B"""
+    print("\n" + "=" * 60)
+    print("BYOK TEST 2: Resume BYOK Session with System Message B (BETA)")
+    print("=" * 60)
+
+    resume_config = {
+        "model": "gpt-4o",
+        "streaming": True,
+        "provider": provider_config,
+        "system_message": {
+            "mode": "replace",
+            "content": SYSTEM_MSG_B,
+        },
+    }
+
+    print(f"📋 Resume config includes system_message with mode='replace'")
+    print(f"📋 New system_message content: BETA identity")
+    print(
+        f"📋 Provider: {provider_config.get('type')} @ {provider_config.get('base_url')}"
+    )
+
+    session = await client.resume_session(session_id, resume_config)
+    print(f"✅ Resumed BYOK session: {session.session_id}")
+
+    print("\n📤 Asking: 'What is your name now? Did your identity change?'")
+    print("📥 Response: ", end="")
+    response = await send_and_get_response(
+        session, "What is your name now? Did your identity change?"
+    )
+
+    if "BETA" in response:
+        print("✅ SUCCESS: System message was updated to BETA")
+        return True
+    elif "ALPHA" in response:
+        print("❌ BUG CONFIRMED: System message was NOT updated (still ALPHA)")
+        return False
+    else:
+        print("⚠️ INCONCLUSIVE: Model response doesn't clearly indicate identity")
+        return None
+
+
+async def main_byok():
+    """Run BYOK-specific tests"""
+    print("=" * 60)
+    print("🧪 Copilot SDK BYOK System Message Resume Test")
+    print("=" * 60)
+    print(f"Time: {time.strftime('%Y-%m-%d %H:%M:%S')}")
+
+    # Get BYOK configuration from environment
+    byok_api_key = os.environ.get("BYOK_API_KEY") or os.environ.get("OPENAI_API_KEY")
+    byok_base_url = os.environ.get("BYOK_BASE_URL", "https://api.openai.com/v1")
+    byok_model = os.environ.get("BYOK_MODEL", "gpt-4o")
+
+    if not byok_api_key:
+        print(
+            "❌ Error: Please set BYOK_API_KEY or OPENAI_API_KEY environment variable"
+        )
+        print("   export BYOK_API_KEY='your_api_key'")
+        print("   export BYOK_BASE_URL='https://api.openai.com/v1'  # optional")
+        print("   export BYOK_MODEL='gpt-4o'  # optional")
+        return
+
+    provider_config = {
+        "type": "openai",
+        "base_url": byok_base_url,
+        "api_key": byok_api_key,
+    }
+
+    print(f"📋 BYOK Provider: openai @ {byok_base_url}")
+    print(f"📋 BYOK Model: {byok_model}")
+
+    # Create client
+    cli_path = os.environ.get("COPILOT_CLI_PATH")
+    client_config = {"log_level": "info"}
+    if cli_path:
+        client_config["cli_path"] = cli_path
+
+    client = CopilotClient(client_config)
+
+    try:
+        await client.start()
+        print("✅ Client started successfully")
+
+        # BYOK Test 1: Create new session with BYOK provider
+        session = await test_byok_new_session(client, provider_config)
+        session_id = session.session_id
+
+        # Wait a bit before resuming
+        print("\n⏳ Waiting 2 seconds before resume test...")
+        await asyncio.sleep(2)
+
+        # BYOK Test 2: Resume with different system message B
+        bug_confirmed = await test_byok_resume_with_new_system_message(
+            client, session_id, provider_config
+        )
+
+        # Summary
+        print("\n" + "=" * 60)
+        print("📊 BYOK TEST SUMMARY")
+        print("=" * 60)
+        if bug_confirmed is False:
+            print(
+                "❌ BYOK BUG CONFIRMED: session.resume does NOT apply system_message updates"
+            )
+            print("   In BYOK mode, the system message from create_session persists")
+            print("   even when resume_session specifies a different system_message.")
+            print("\n   WORKAROUND: Inject system context into user prompt instead.")
+        elif bug_confirmed is True:
+            print("✅ BYOK NO BUG: session.resume correctly updates system_message")
+        else:
+            print("⚠️ BYOK INCONCLUSIVE: Could not determine if bug exists")
+
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        import traceback
+
+        traceback.print_exc()
+    finally:
+        await client.stop()
+        print("\n✅ Client stopped")
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="Copilot SDK System Message Resume Test"
+    )
+    parser.add_argument(
+        "--byok",
+        action="store_true",
+        help="Run BYOK (Bring Your Own Key) test instead of native Copilot test",
+    )
+    args = parser.parse_args()
+
+    if args.byok:
+        print("Running BYOK test mode...")
+        asyncio.run(main_byok())
+    else:
+        print("Running native Copilot test mode...")
+        print("(Use --byok flag for BYOK provider test)")
+        asyncio.run(main())
diff --git a/plugins/pipes/github-copilot-sdk/github_copilot_sdk.py b/plugins/pipes/github-copilot-sdk/github_copilot_sdk.py
index 279f8a2..5870523 100644
--- a/plugins/pipes/github-copilot-sdk/github_copilot_sdk.py
+++ b/plugins/pipes/github-copilot-sdk/github_copilot_sdk.py
@@ -5,8 +5,8 @@ author_url: https://github.com/Fu-Jie/awesome-openwebui
 funding_url: https://github.com/open-webui
 openwebui_id: ce96f7b4-12fc-4ac3-9a01-875713e69359
 description: Integrate GitHub Copilot SDK. Supports dynamic models, multi-turn conversation, streaming, multimodal input, infinite sessions, and frontend debug logging.
-version: 0.3.0
-requirements: github-copilot-sdk==0.1.22
+version: 0.5.1
+requirements: github-copilot-sdk==0.1.23
 """
 
 import os
@@ -19,8 +19,9 @@ import logging
 import shutil
 import subprocess
 import hashlib
+import aiohttp
 from pathlib import Path
-from typing import Optional, Union, AsyncGenerator, List, Any, Dict
+from typing import Optional, Union, AsyncGenerator, List, Any, Dict, Literal, Tuple
 from types import SimpleNamespace
 from pydantic import BaseModel, Field, create_model
 
@@ -28,14 +29,57 @@ from pydantic import BaseModel, Field, create_model
 from copilot import CopilotClient, define_tool
 
 # Import Tool Server Connections and Tool System from OpenWebUI Config
-from open_webui.config import TOOL_SERVER_CONNECTIONS
-from open_webui.utils.tools import get_tools as get_openwebui_tools
+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[Environment & Capabilities Context]\n"
+    "You are an AI assistant operating within a specific, high-capability environment. Understanding your context is crucial for optimal decision-making.\n"
+    "\n"
+    "**System Environment:**\n"
+    "- **Platform**: You are running inside a Linux containerized environment hosted within **OpenWebUI**.\n"
+    "- **Core Engine**: You are powered by the **GitHub Copilot SDK** and interact via the **GitHub Copilot CLI**.\n"
+    "- **Access**: You have direct access to the **OpenWebUI source code**. You can read, analyze, and reference the internal implementation of the platform you are running on via file operations or tools.\n"
+    "- **FileSystem Access**: You are running as **root**. You have **READ access to the entire container file system** (including system files). However, you should **ONLY WRITE** to your designated persistent workspace directory.\n"
+    "- **Native Python Environment**: You are running in a **rich Python environment** that already includes all OpenWebUI dependencies. You can natively import and use these installed libraries (e.g., for data processing, utility functions) without installing anything new.\n"
+    "- **Package Management**: Only if you need **additional** libraries, you should **create a virtual environment** within your workspace and install them there. Do NOT mess with the global pip.\n"
+    "- **Network**: You have internet access and can interact with external APIs if provided with the necessary tools (e.g., Web Search, MCP Servers).\n"
+    "\n"
+    "**Interface Capabilities (OpenWebUI):**\n"
+    "- **Rich Web UI**: You are NOT limited to a simple terminal or text-only responses. You are rendering in a modern web browser.\n"
+    "- **Visual Rendering**: You can and should use advanced visual elements to explain concepts clearly.\n"
+    "- **Interactive Scripting**: You can often run Python scripts directly to perform calculations, data analysis, or automate tasks if the environment supports it/tools are available.\n"
+    "- **Built-in Tools Integration**: OpenWebUI provides native tools for direct interaction with its internal services. For example, tools like `create_note`, `get_notes`, or `manage_memories` interact directly with the platform's database. Use these tools to persistently manage user data and system state.\n"
+    "\n"
+    "**Formatting & Presentation Directives:**\n"
+    "1. **Markdown & Multimedia**:\n"
+    "   - Use **bold**, *italics*, lists, and **Markdown tables** (standard format, never use HTML tables) liberally to structure your answer.\n"
+    "   - **Mermaid Diagrams**: For flowcharts, sequence diagrams, or architecture logic, ALWAYS use the standard ```mermaid code block. Do NOT use other formats.\n"
+    "   - **LaTeX Math**: Use standard LaTeX formatting for mathematical expressions.\n"
+    "\n"
+    "2. **Images & Files**:\n"
+    "   - If a tool generated an image or file, you **MUST** embed it directly using `![caption](url)`.\n"
+    "   - Do NOT simply provide a text link unless explicitly asked.\n"
+    "\n"
+    "3. **Interactive HTML/JS**:\n"
+    "   - You can output standalone HTML/JS/CSS code blocks. OpenWebUI will render them as interactive widgets in an iframe.\n"
+    "   - **IMPORTANT**: Combine all HTML, CSS (in `<style>`), and JavaScript (in `<script>`) into a **SINGLE** ` ```html ` code block.\n"
+    "   - Use this for dynamic data visualizations (e.g., charts, graphs), interactive demos, or custom UI components.\n"
+    "\n"
+    "4. **Response Structure**:\n"
+    "   - **Think First**: Before complex tasks, briefly outline your plan.\n"
+    "   - **Be Concise but Complete**: specific answers are better than generic ones.\n"
+    "   - **Premium Feel**: Format your output to look professional and polished, like a technical blog post or documentation.\n"
+)
+
 
 class Pipe:
     class Valves(BaseModel):
@@ -43,9 +87,30 @@ class Pipe:
             default="",
             description="GitHub Fine-grained Token (Requires 'Copilot Requests' permission)",
         )
-        COPILOT_CLI_VERSION: str = Field(
-            default="0.0.405",
-            description="Specific Copilot CLI version to install/enforce (e.g. '0.0.405'). Leave empty for latest.",
+        ENABLE_OPENWEBUI_TOOLS: bool = Field(
+            default=True,
+            description="Enable OpenWebUI Tools (includes defined Tools and Tool Server Tools).",
+        )
+        ENABLE_MCP_SERVER: bool = Field(
+            default=True,
+            description="Enable Direct MCP Client connection (Recommended).",
+        )
+        ENABLE_TOOL_CACHE: bool = Field(
+            default=True,
+            description="Cache OpenWebUI tools and MCP servers (performance optimization).",
+        )
+        REASONING_EFFORT: Literal["low", "medium", "high", "xhigh"] = Field(
+            default="medium",
+            description="Reasoning effort level (low, medium, high). Only affects standard Copilot models (not BYOK).",
+        )
+        SHOW_THINKING: bool = Field(
+            default=True,
+            description="Show model reasoning/thinking process",
+        )
+
+        INFINITE_SESSION: bool = Field(
+            default=True,
+            description="Enable Infinite Sessions (automatic context compaction)",
         )
         DEBUG: bool = Field(
             default=False,
@@ -55,21 +120,21 @@ class Pipe:
             default="error",
             description="Copilot CLI log level: none, error, warning, info, debug, all",
         )
-        SHOW_THINKING: bool = Field(
-            default=True,
-            description="Show model reasoning/thinking process",
-        )
-        EXCLUDE_KEYWORDS: str = Field(
-            default="",
-            description="Exclude models containing these keywords (comma separated, e.g.: codex, haiku)",
+        TIMEOUT: int = Field(
+            default=300,
+            description="Timeout for each stream chunk (seconds)",
         )
         WORKSPACE_DIR: str = Field(
             default="",
             description="Restricted workspace directory for file operations. If empty, allows access to the current process directory.",
         )
-        INFINITE_SESSION: bool = Field(
-            default=True,
-            description="Enable Infinite Sessions (automatic context compaction)",
+        COPILOT_CLI_VERSION: str = Field(
+            default="0.0.405",
+            description="Specific Copilot CLI version to install/enforce (e.g. '0.0.405'). Leave empty for latest.",
+        )
+        EXCLUDE_KEYWORDS: str = Field(
+            default="",
+            description="Exclude models containing these keywords (comma separated, e.g.: codex, haiku)",
         )
         COMPACTION_THRESHOLD: float = Field(
             default=0.8,
@@ -79,30 +144,34 @@ class Pipe:
             default=0.95,
             description="Buffer exhaustion threshold (0.0-1.0)",
         )
-        TIMEOUT: int = Field(
-            default=300,
-            description="Timeout for each stream chunk (seconds)",
-        )
         CUSTOM_ENV_VARS: str = Field(
             default="",
             description='Custom environment variables (JSON format, e.g., {"VAR": "value"})',
         )
 
-        ENABLE_OPENWEBUI_TOOLS: bool = Field(
-            default=True,
-            description="Enable OpenWebUI Tools (includes defined Tools and Tool Server Tools).",
+        BYOK_TYPE: Literal["openai", "anthropic"] = Field(
+            default="openai",
+            description="BYOK Provider Type: openai, anthropic",
         )
-        ENABLE_MCP_SERVER: bool = Field(
-            default=True,
-            description="Enable Direct MCP Client connection (Recommended).",
+        BYOK_BASE_URL: str = Field(
+            default="",
+            description="BYOK Base URL (e.g., https://api.openai.com/v1)",
         )
-        REASONING_EFFORT: str = Field(
-            default="medium",
-            description="Reasoning effort level: low, medium, high. (gpt-5.2-codex also supports xhigh)",
+        BYOK_API_KEY: str = Field(
+            default="",
+            description="BYOK API Key (Global Setting)",
         )
-        ENFORCE_FORMATTING: bool = Field(
-            default=True,
-            description="Add formatting instructions to system prompt for better readability (paragraphs, line breaks, structure).",
+        BYOK_BEARER_TOKEN: str = Field(
+            default="",
+            description="BYOK Bearer Token (Global, overrides API Key)",
+        )
+        BYOK_MODELS: str = Field(
+            default="",
+            description="BYOK Model List (comma separated). Leave empty to fetch from API.",
+        )
+        BYOK_WIRE_API: Literal["completions", "responses"] = Field(
+            default="completions",
+            description="BYOK Wire API: completions, responses",
         )
 
     class UserValves(BaseModel):
@@ -110,18 +179,18 @@ class Pipe:
             default="",
             description="Personal GitHub Fine-grained Token (overrides global setting)",
         )
-        REASONING_EFFORT: str = Field(
+        REASONING_EFFORT: Literal["", "low", "medium", "high", "xhigh"] = Field(
             default="",
-            description="Reasoning effort level (low, medium, high, xhigh). Leave empty to use global setting.",
-        )
-        DEBUG: bool = Field(
-            default=False,
-            description="Enable technical debug logs (connection info, etc.)",
+            description="Reasoning effort override. Only affects standard Copilot Models.",
         )
         SHOW_THINKING: bool = Field(
             default=True,
             description="Show model reasoning/thinking process",
         )
+        DEBUG: bool = Field(
+            default=False,
+            description="Enable technical debug logs (connection info, etc.)",
+        )
         ENABLE_OPENWEBUI_TOOLS: bool = Field(
             default=True,
             description="Enable OpenWebUI Tools (includes defined Tools and Tool Server Tools).",
@@ -130,21 +199,54 @@ class Pipe:
             default=True,
             description="Enable dynamic MCP server loading (overrides global).",
         )
-
-        ENFORCE_FORMATTING: bool = Field(
+        ENABLE_TOOL_CACHE: bool = Field(
             default=True,
-            description="Enforce formatting guidelines (overrides global)",
+            description="Enable Tool/MCP configuration caching for this user.",
         )
 
+        # BYOK User Overrides
+        BYOK_API_KEY: str = Field(
+            default="",
+            description="BYOK API Key (User override)",
+        )
+        BYOK_TYPE: Literal["", "openai", "anthropic"] = Field(
+            default="",
+            description="BYOK Provider Type override.",
+        )
+        BYOK_BASE_URL: str = Field(
+            default="",
+            description="BYOK Base URL override.",
+        )
+        BYOK_BEARER_TOKEN: str = Field(
+            default="",
+            description="BYOK Bearer Token override.",
+        )
+        BYOK_MODELS: str = Field(
+            default="",
+            description="BYOK Model List override.",
+        )
+        BYOK_WIRE_API: Literal["", "completions", "responses"] = Field(
+            default="",
+            description="BYOK Wire API override.",
+        )
+
+    # ==================== Class-Level Caches ====================
+    # These caches persist across requests since OpenWebUI may create
+    # new Pipe instances for each request.
+    # =============================================================
+    _model_cache: List[dict] = []  # Model list cache
+    _standard_model_ids: set = set()  # Track standard model IDs
+    _tool_cache = None  # Cache for converted OpenWebUI tools
+    _mcp_server_cache = None  # Cache for MCP server config
+    _env_setup_done = False  # Track if env setup has been completed
+    _last_update_check = 0  # Timestamp of last CLI update check
+
     def __init__(self):
         self.type = "pipe"
-        self.id = "copilotsdk"
+        self.id = "copilot"
         self.name = "copilotsdk"
         self.valves = self.Valves()
         self.temp_dir = tempfile.mkdtemp(prefix="copilot_images_")
-        self.thinking_started = False
-        self._model_cache = []  # Model list cache
-        self._last_update_check = 0  # Timestamp of last CLI update check
 
     def __del__(self):
         try:
@@ -186,11 +288,54 @@ class Pipe:
         if not self.valves.ENABLE_OPENWEBUI_TOOLS:
             return []
 
+        # Determine cache setting (user override > global)
+        enable_cache = self.valves.ENABLE_TOOL_CACHE
+        if __user__:
+            try:
+                # Attempt to get user valve, handling potential missing field or type issues gracefully
+                # We need to construct UserValves to access defaults/overrides correctly if passed as dict
+                raw_user_valves = __user__.get("valves", {})
+                if isinstance(raw_user_valves, dict):
+                    uv = self.UserValves(**raw_user_valves)
+                    enable_cache = uv.ENABLE_TOOL_CACHE
+                elif isinstance(raw_user_valves, self.UserValves):
+                    enable_cache = raw_user_valves.ENABLE_TOOL_CACHE
+            except:
+                pass
+
+        # Check Cache
+        if enable_cache and self._tool_cache is not None:
+            await self._emit_debug_log(
+                "ℹ️ Using cached OpenWebUI tools.", __event_call__
+            )
+            return self._tool_cache
+
         # Load OpenWebUI tools dynamically
         openwebui_tools = await self._load_openwebui_tools(
             __user__=__user__, __event_call__=__event_call__
         )
 
+        # Update Cache
+        if enable_cache:
+            self._tool_cache = openwebui_tools
+            await self._emit_debug_log(
+                "✅ OpenWebUI tools cached for subsequent requests.", __event_call__
+            )
+
+        # Log details only when cache is cold
+        if openwebui_tools:
+            tool_names = [t.name for t in openwebui_tools]
+            await self._emit_debug_log(
+                f"Loaded {len(openwebui_tools)} tools: {tool_names}",
+                __event_call__,
+            )
+            if self.valves.DEBUG:
+                for t in openwebui_tools:
+                    await self._emit_debug_log(
+                        f"📋 Tool Detail: {t.name} - {t.description[:100]}...",
+                        __event_call__,
+                    )
+
         return openwebui_tools
 
     def _json_schema_to_python_type(self, schema: dict) -> Any:
@@ -198,6 +343,13 @@ class Pipe:
         if not isinstance(schema, dict):
             return Any
 
+        # Check for Enum (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])
@@ -252,6 +404,11 @@ class Pipe:
             if isinstance(param_schema, dict):
                 description = param_schema.get("description", "")
 
+            # Extract default value if present
+            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] = (
@@ -261,14 +418,15 @@ class Pipe:
                 else:
                     fields[param_name] = (param_type, ...)
             else:
+                # If not required, wrap in Optional and use default_value
                 optional_type = Optional[param_type]
                 if description:
                     fields[param_name] = (
                         optional_type,
-                        Field(default=None, description=description),
+                        Field(default=default_value, description=description),
                     )
                 else:
-                    fields[param_name] = (optional_type, None)
+                    fields[param_name] = (optional_type, default_value)
 
         if fields:
             ParamsModel = create_model(f"{sanitized_tool_name}_Params", **fields)
@@ -280,13 +438,68 @@ class Pipe:
         if not tool_description and isinstance(spec, dict):
             tool_description = spec.get("summary", "")
 
-        # Critical: If the tool name was sanitized (e.g. Chinese -> Hash), instructions are lost.
-        # We must inject the original name into the description so the model knows what it is.
+        # Determine tool source/group for description prefix
+        tool_id = tool_dict.get("tool_id", "")
+        tool_type = tool_dict.get(
+            "type", ""
+        )  # "builtin", "external", or empty (user-defined)
+
+        if tool_type == "builtin":
+            # OpenWebUI Built-in Tool (system tools like web search, memory, notes)
+            group_prefix = "[OpenWebUI Built-in]"
+        elif tool_type == "external" or tool_id.startswith("server:"):
+            # OpenAPI Tool Server - use metadata if available
+            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:
+                if tool_group_desc:
+                    group_prefix = (
+                        f"[Tool Server: {tool_group_name} - {tool_group_desc}]"
+                    )
+                else:
+                    group_prefix = f"[Tool Server: {tool_group_name}]"
+            else:
+                group_prefix = f"[Tool Server: {server_id}]"
+        else:
+            # User-defined Python script tool - use metadata if available
+            tool_group_name = tool_dict.get("_tool_group_name")
+            tool_group_desc = tool_dict.get("_tool_group_description")
+
+            if tool_group_name:
+                # Use the tool's title from docstring, e.g., "Prefect API Tools"
+                if tool_group_desc:
+                    group_prefix = f"[User Tool: {tool_group_name} - {tool_group_desc}]"
+                else:
+                    group_prefix = f"[User Tool: {tool_group_name}]"
+            else:
+                group_prefix = f"[User Tool: {tool_id}]" if tool_id else "[User Tool]"
+
+        # Build final description with group prefix
         if sanitized_tool_name != tool_name:
-            tool_description = f"Function '{tool_name}': {tool_description}"
+            # Include original name if it was sanitized
+            tool_description = (
+                f"{group_prefix} Function '{tool_name}': {tool_description}"
+            )
+        else:
+            tool_description = f"{group_prefix} {tool_description}"
 
         async def _tool(params):
-            payload = params.model_dump() if hasattr(params, "model_dump") else {}
+            # Crucial Fix: Use exclude_unset=True.
+            # This ensures that parameters not explicitly provided by the LLM
+            # (which default to None in the Pydantic model) are COMPLETELY OMITTED
+            # from the function call. This allows the underlying Python function's
+            # own default values to take effect, instead of receiving an explicit None.
+            payload = (
+                params.model_dump(exclude_unset=True)
+                if hasattr(params, "model_dump")
+                else {}
+            )
             return await tool_callable(**payload)
 
         _tool.__name__ = sanitized_tool_name
@@ -304,19 +517,57 @@ class Pipe:
             params_type=ParamsModel,
         )(_tool)
 
-    def _build_openwebui_request(self):
-        """Build a minimal request-like object for OpenWebUI tool loading."""
+    def _build_openwebui_request(self, user: dict = None):
+        """Build a more complete request-like object with dynamically loaded OpenWebUI configs."""
+        # Dynamically build config from the official registry
+        config = SimpleNamespace()
+        for item in PERSISTENT_CONFIG_REGISTRY:
+            # Special handling for TOOL_SERVER_CONNECTIONS which might be a list/dict object
+            # rather than a simple primitive value, though .value handles the latest state
+            val = item.value
+            if hasattr(val, "value"):  # Handling nested structures if any
+                val = val.value
+            setattr(config, item.env_name, val)
+
         app_state = SimpleNamespace(
-            config=SimpleNamespace(
-                TOOL_SERVER_CONNECTIONS=TOOL_SERVER_CONNECTIONS.value
-            ),
+            config=config,
             TOOLS={},
+            TOOL_CONTENTS={},
+            FUNCTIONS={},
+            FUNCTION_CONTENTS={},
+            MODELS={},
         )
-        app = SimpleNamespace(state=app_state)
+
+        def url_path_for(name: str, **path_params):
+            """Mock url_path_for for tool compatibility."""
+            if name == "get_file_content_by_id":
+                return f"/api/v1/files/{path_params.get('id')}/content"
+            return f"/mock/{name}"
+
+        app = SimpleNamespace(
+            state=app_state,
+            url_path_for=url_path_for,
+        )
+
+        # Mocking generic request attributes
         request = SimpleNamespace(
             app=app,
+            url=SimpleNamespace(
+                path="/api/chat/completions",
+                base_url="http://localhost:8080",
+                __str__=lambda s: "http://localhost:8080/api/chat/completions",
+            ),
+            base_url="http://localhost:8080",
+            headers={
+                "user-agent": "Mozilla/5.0 (OpenWebUI Plugin/GitHub-Copilot-SDK)",
+                "host": "localhost:8080",
+                "accept": "*/*",
+            },
+            method="POST",
             cookies={},
-            state=SimpleNamespace(token=SimpleNamespace(credentials="")),
+            state=SimpleNamespace(
+                token=SimpleNamespace(credentials=""), user=user if user else {}
+            ),
         )
         return request
 
@@ -360,7 +611,7 @@ class Pipe:
         if not tool_ids:
             return []
 
-        request = self._build_openwebui_request()
+        request = self._build_openwebui_request(user_data)
         extra_params = {
             "__request__": request,
             "__user__": user_data,
@@ -371,10 +622,114 @@ class Pipe:
             "__model_knowledge__": [],
         }
 
-        tools_dict = await get_openwebui_tools(request, tool_ids, user, extra_params)
+        # Fetch User/Server Tools
+        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"Error fetching user/server tools: {e}", __event_call__
+                )
+
+        # Fetch Built-in Tools (Web Search, Memory, etc.)
+        # Note: We pass minimal features/model dict as we want to expose all enabled built-ins
+        # that are globally configured.
+        try:
+            # Get builtin tools
+            builtin_tools = get_builtin_tools(
+                self._build_openwebui_request(user_data),
+                {
+                    "__user__": user_data,
+                    "__chat_id__": extra_params.get("__chat_id__"),
+                    "__message_id__": extra_params.get("__message_id__"),
+                },
+                model={
+                    "info": {
+                        "meta": {
+                            "capabilities": {
+                                "web_search": True,
+                                "image_generation": True,
+                            }
+                        }
+                    }
+                },  # Mock capabilities to allow all globally enabled tools
+            )
+            if builtin_tools:
+                tools_dict.update(builtin_tools)
+        except Exception as e:
+            await self._emit_debug_log(
+                f"Error fetching built-in tools: {e}", __event_call__
+            )
+
         if not tools_dict:
             return []
 
+        # Enrich tools with metadata from their source
+        # 1. User-defined tools: name, description from docstring
+        # 2. OpenAPI Tool Server tools: name, description from server config info
+        tool_metadata_cache = {}
+        server_metadata_cache = {}
+
+        # Pre-build server metadata cache from TOOL_SERVER_CONNECTIONS
+        if hasattr(TOOL_SERVER_CONNECTIONS, "value"):
+            for server in TOOL_SERVER_CONNECTIONS.value:
+                server_id = server.get("id") or server.get("info", {}).get("id")
+                if server_id:
+                    info = server.get("info", {})
+                    server_metadata_cache[server_id] = {
+                        "name": info.get("name") or server_id,
+                        "description": info.get("description", ""),
+                    }
+
+        for tool_name, tool_def in tools_dict.items():
+            tool_id = tool_def.get("tool_id", "")
+            tool_type = tool_def.get("type", "")
+
+            if tool_type == "builtin":
+                # Built-in tools don't need additional metadata
+                continue
+            elif tool_type == "external" or tool_id.startswith("server:"):
+                # OpenAPI Tool Server - extract server ID and get metadata
+                server_id = (
+                    tool_id.replace("server:", "").split("|")[0]
+                    if tool_id.startswith("server:")
+                    else ""
+                )
+                if server_id and server_id in server_metadata_cache:
+                    tool_def["_tool_group_name"] = server_metadata_cache[server_id].get(
+                        "name"
+                    )
+                    tool_def["_tool_group_description"] = server_metadata_cache[
+                        server_id
+                    ].get("description")
+            else:
+                # User-defined Python script tool
+                if tool_id and tool_id not in tool_metadata_cache:
+                    try:
+                        tool_model = Tools.get_tool_by_id(tool_id)
+                        if tool_model:
+                            tool_metadata_cache[tool_id] = {
+                                "name": tool_model.name,
+                                "description": (
+                                    tool_model.meta.description
+                                    if tool_model.meta
+                                    else None
+                                ),
+                            }
+                    except Exception:
+                        pass
+
+                if tool_id in tool_metadata_cache:
+                    tool_def["_tool_group_name"] = tool_metadata_cache[tool_id].get(
+                        "name"
+                    )
+                    tool_def["_tool_group_description"] = tool_metadata_cache[
+                        tool_id
+                    ].get("description")
+
         converted_tools = []
         for tool_name, tool_def in tools_dict.items():
             try:
@@ -397,6 +752,28 @@ class Pipe:
         if not self.valves.ENABLE_MCP_SERVER:
             return None
 
+        # Determine cache setting (no user context here usually, unless passed down, but for now use global as baseline + potentially stored user pref if we had access to user context easily in this method signature.
+        # However, _parse_mcp_servers is called from _build_client_config which doesn't easily pass user context.
+        # Wait, _parse_mcp_servers is called by _build_client_config(body) inside _pipe_impl.
+        # But _pipe_impl has access to user.
+        # Let's check where _parse_mcp_servers is called.
+        # It is called in _build_client_config.
+        # Actually _parse_mcp_servers is defined on 'self'.
+        # To support user override here, we'd need to pass user settings down or store them temporarily.
+        # Given the complexity, and that MCP servers are globally defined in OpenWebUI connection settings (usually),
+        # maybe global cache setting is sufficient for MCP?
+        # BUT, the user request implied "user can turn off".
+        # Let's stick to global for MCP for now unless we refactor to pass user_valves into this method.
+        # Refactoring to use self.valves.ENABLE_TOOL_CACHE is safe for now as baseline.
+        # If we really need user override for MCP cache, we need to pass `enable_cache` boolean to this method.
+
+        # Let's use the global valve for now as it matches the previous logic, but be aware of the limitation.
+        # The user's request "run user close" (user can turn off) likely applies to the tools they use.
+
+        # Check Cache
+        if self.valves.ENABLE_TOOL_CACHE and self._mcp_server_cache is not None:
+            return self._mcp_server_cache
+
         mcp_servers = {}
 
         # Iterate over OpenWebUI Tool Server Connections
@@ -436,21 +813,42 @@ class Pipe:
                 if isinstance(custom_headers, dict):
                     headers.update(custom_headers)
 
+                # Get filtering configuration
+                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": ["*"],  # Enable all tools by default
+                    "tools": allowed_tools,
                 }
 
+        # Update Cache
+        if self.valves.ENABLE_TOOL_CACHE:
+            self._mcp_server_cache = mcp_servers
+
         return mcp_servers if mcp_servers else None
 
-    async def _emit_debug_log(self, message: str, __event_call__=None):
+    async def _emit_debug_log(
+        self, message: str, __event_call__=None, debug_enabled: Optional[bool] = None
+    ):
         """Emit debug log to frontend (console) when DEBUG is enabled."""
-        # Check user config first if available (will need to be passed down or stored)
-        # For now we only check global valves in this helper, but in pipe implementation we respect user setting.
-        # This helper might need refactoring to accept user_debug_setting
-        if not self.valves.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}")
@@ -468,18 +866,25 @@ class Pipe:
         except Exception as e:
             logger.debug(f"[Copilot Pipe] Frontend debug log failed: {e}")
 
-    def _emit_debug_log_sync(self, message: str, __event_call__=None):
-        """Sync wrapper for debug logging in non-async contexts."""
-        if not self.valves.DEBUG:
+    def _emit_debug_log_sync(
+        self, message: str, __event_call__=None, debug_enabled: Optional[bool] = None
+    ):
+        """Sync wrapper for debug logging."""
+        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}")
-            return
-
-        loop.create_task(self._emit_debug_log(message, __event_call__))
 
     def _extract_text_from_content(self, content) -> str:
         """Extract text content from various message content formats."""
@@ -494,22 +899,8 @@ class Pipe:
         return ""
 
     def _apply_formatting_hint(self, prompt: str) -> str:
-        """Append a lightweight formatting hint to the user prompt when enabled."""
-        if not self.valves.ENFORCE_FORMATTING:
-            return prompt
-
-        if not prompt:
-            return prompt
-
-        if "[Formatting Guidelines]" in prompt or "[Formatting Request]" in prompt:
-            return prompt
-
-        formatting_hint = (
-            "\n\n[Formatting Request]\n"
-            "Please format your response with clear paragraph breaks, short sentences, "
-            "and bullet lists when appropriate."
-        )
-        return f"{prompt}{formatting_hint}"
+        """Return the prompt as-is (formatting hints removed)."""
+        return prompt
 
     def _dedupe_preserve_order(self, items: List[str]) -> List[str]:
         """Deduplicate while preserving order."""
@@ -522,6 +913,27 @@ class Pipe:
             result.append(item)
         return result
 
+    def _strip_model_prefix(self, model_id: str) -> str:
+        """Sequential prefix stripping: OpenWebUI plugin ID then internal pipe prefix."""
+        if not model_id:
+            return ""
+
+        res = model_id
+        # 1. Strip OpenWebUI plugin prefix (e.g. 'github_copilot_sdk.copilot-gpt-4o' -> 'copilot-gpt-4o')
+        if "." in res:
+            res = res.split(".", 1)[-1]
+
+        # 2. Strip our own internal prefix (e.g. 'copilot-gpt-4o' -> 'gpt-4o')
+        internal_prefix = f"{self.id}-"
+        if res.startswith(internal_prefix):
+            res = res[len(internal_prefix) :]
+
+        # 3. Handle legacy/variant dash-based prefix
+        if res.startswith("copilot - "):
+            res = res[10:]
+
+        return res
+
     def _collect_model_ids(
         self, body: dict, request_model: str, real_model_id: str
     ) -> List[str]:
@@ -529,8 +941,9 @@ class Pipe:
         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}-") :])
+            stripped = self._strip_model_prefix(request_model)
+            if stripped != request_model:
+                model_ids.append(stripped)
         if real_model_id:
             model_ids.append(real_model_id)
 
@@ -559,24 +972,37 @@ class Pipe:
         request_model: str,
         real_model_id: str,
         __event_call__=None,
-    ) -> tuple[Optional[str], str]:
+        debug_enabled: bool = False,
+    ) -> Tuple[Optional[str], str]:
         """Extract system prompt from metadata/model 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"Extracted system prompt from explicit body field (length: {len(system_prompt_content)})",
+                __event_call__,
+                debug_enabled=debug_enabled,
+            )
+
         # 1) metadata.model.params.system
-        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"Extracted system prompt from metadata.model.params (length: {len(system_prompt_content)})",
-                        __event_call__,
-                    )
+        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"Extracted system prompt from metadata.model.params (length: {len(system_prompt_content)})",
+                            __event_call__,
+                            debug_enabled=debug_enabled,
+                        )
 
         # 2) model DB lookup
         if not system_prompt_content:
@@ -586,23 +1012,36 @@ class Pipe:
                 model_ids_to_try = self._collect_model_ids(
                     body, request_model, real_model_id
                 )
+                await self._emit_debug_log(
+                    f"Checking system prompt for models: {model_ids_to_try}",
+                    __event_call__,
+                    debug_enabled=debug_enabled,
+                )
                 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"Extracted system prompt from model DB (length: {len(system_prompt_content)})",
-                                    __event_call__,
-                                )
-                                break
+                    if model_record:
+                        await self._emit_debug_log(
+                            f"Checking Model DB for: {mid} (Record found: {model_record.id if hasattr(model_record, 'id') else 'Yes'})",
+                            __event_call__,
+                            debug_enabled=debug_enabled,
+                        )
+                        if 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"Success! Extracted system prompt from model DB using ID: {mid} (length: {len(system_prompt_content)})",
+                                        __event_call__,
+                                        debug_enabled=debug_enabled,
+                                    )
+                                    break
             except Exception as e:
                 await self._emit_debug_log(
                     f"Failed to extract system prompt from model DB: {e}",
                     __event_call__,
+                    debug_enabled=debug_enabled,
                 )
 
         # 3) body.params.system
@@ -613,11 +1052,13 @@ class Pipe:
                 if system_prompt_content:
                     system_prompt_source = "body_params"
                     await self._emit_debug_log(
-                        f"Extracted system prompt from body.params (length: {len(system_prompt_content)})",
+                        f"Extracted system prompt from body.params.system (length: {len(system_prompt_content)})",
                         __event_call__,
+                        debug_enabled=debug_enabled,
                     )
 
-        # 4) messages (role=system)
+        # 4) messages (role=system) - Last found wins or First found wins?
+        # Typically OpenWebUI puts the active system prompt as the FIRST message.
         if not system_prompt_content:
             for msg in messages:
                 if msg.get("role") == "system":
@@ -627,8 +1068,9 @@ class Pipe:
                     if system_prompt_content:
                         system_prompt_source = "messages_system"
                         await self._emit_debug_log(
-                            f"Extracted system prompt from messages (length: {len(system_prompt_content)})",
+                            f"Extracted system prompt from messages (reverse search) (length: {len(system_prompt_content)})",
                             __event_call__,
+                            debug_enabled=debug_enabled,
                         )
                     break
 
@@ -684,6 +1126,7 @@ class Pipe:
         custom_tools: List[Any],
         system_prompt_content: Optional[str],
         is_streaming: bool,
+        provider_config: Optional[dict] = None,
     ):
         """Build SessionConfig for Copilot SDK."""
         from copilot.types import SessionConfig, InfiniteSessionConfig
@@ -696,34 +1139,19 @@ class Pipe:
                 buffer_exhaustion_threshold=self.valves.BUFFER_THRESHOLD,
             )
 
-        system_message_config = None
-        if system_prompt_content or self.valves.ENFORCE_FORMATTING:
-            # Build system message content
-            system_parts = []
+        # Prepare the combined system message content
+        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)
 
-            if system_prompt_content:
-                system_parts.append(system_prompt_content)
-
-            if self.valves.ENFORCE_FORMATTING:
-                formatting_instruction = (
-                    "\n\n[Formatting Guidelines]\n"
-                    "When providing explanations or descriptions:\n"
-                    "- Use clear paragraph breaks (double line breaks)\n"
-                    "- Break long sentences into multiple shorter ones\n"
-                    "- Use bullet points or numbered lists for multiple items\n"
-                    "- Add headings (##, ###) for major sections\n"
-                    "- Ensure proper spacing between different topics"
-                )
-                system_parts.append(formatting_instruction)
-                logger.info(
-                    f"[ENFORCE_FORMATTING] Added formatting instructions to system prompt"
-                )
-
-            if system_parts:
-                system_message_config = {
-                    "mode": "append",
-                    "content": "\n".join(system_parts),
-                }
+        # Design Choice: ALWAYS use 'replace' mode to ensure full control and avoid duplicates.
+        # This replaces any default system prompt with our combined version.
+        system_message_config = {
+            "mode": "replace",
+            "content": final_system_msg,
+        }
 
         # Prepare session config parameters
         session_params = {
@@ -731,14 +1159,21 @@ class Pipe:
             "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": system_message_config,
             "infinite_sessions": infinite_session_config,
         }
 
+        if provider_config:
+            session_params["provider"] = provider_config
+
         mcp_servers = self._parse_mcp_servers()
         if mcp_servers:
             session_params["mcp_servers"] = mcp_servers
 
+        # Ensure working directory is set to allow the agent to perform file operations
+        session_params["working_directory"] = self._get_workspace_dir()
+
         return SessionConfig(**session_params)
 
     def _get_user_context(self):
@@ -746,7 +1181,11 @@ class Pipe:
         return {}
 
     def _get_chat_context(
-        self, body: dict, __metadata__: Optional[dict] = None, __event_call__=None
+        self,
+        body: dict,
+        __metadata__: Optional[dict] = None,
+        __event_call__=None,
+        debug_enabled: bool = False,
     ) -> Dict[str, str]:
         """
         Highly reliable chat context extraction logic.
@@ -778,7 +1217,9 @@ class Pipe:
         # Debug: Log ID source
         if chat_id:
             self._emit_debug_log_sync(
-                f"Extracted ChatID: {chat_id} (Source: {source})", __event_call__
+                f"Extracted ChatID: {chat_id} (Source: {source})",
+                __event_call__,
+                debug_enabled=debug_enabled,
             )
         else:
             # If still not found, log body keys for troubleshooting
@@ -786,64 +1227,160 @@ class Pipe:
             self._emit_debug_log_sync(
                 f"Warning: Failed to extract ChatID. Body keys: {keys}",
                 __event_call__,
+                debug_enabled=debug_enabled,
             )
 
         return {
             "chat_id": str(chat_id).strip(),
         }
 
+    async def _fetch_byok_models(self) -> List[dict]:
+        """Fetch BYOK models from configured provider."""
+        model_list = []
+        if self.valves.BYOK_BASE_URL:
+            try:
+                base_url = self.valves.BYOK_BASE_URL.rstrip("/")
+                url = f"{base_url}/models"
+                headers = {}
+                provider_type = self.valves.BYOK_TYPE.lower()
+
+                if provider_type == "anthropic":
+                    if self.valves.BYOK_API_KEY:
+                        headers["x-api-key"] = self.valves.BYOK_API_KEY
+                    headers["anthropic-version"] = "2023-06-01"
+                else:
+                    if self.valves.BYOK_BEARER_TOKEN:
+                        headers["Authorization"] = (
+                            f"Bearer {self.valves.BYOK_BEARER_TOKEN}"
+                        )
+                    elif self.valves.BYOK_API_KEY:
+                        headers["Authorization"] = f"Bearer {self.valves.BYOK_API_KEY}"
+
+                timeout = aiohttp.ClientTimeout(total=5)
+                async with aiohttp.ClientSession(timeout=timeout) as session:
+                    async with session.get(url, headers=headers) as resp:
+                        if resp.status == 200:
+                            data = await resp.json()
+                            if (
+                                isinstance(data, dict)
+                                and "data" in data
+                                and isinstance(data["data"], list)
+                            ):
+                                for item in data["data"]:
+                                    if isinstance(item, dict) and "id" in item:
+                                        model_list.append(item["id"])
+                            await self._emit_debug_log(
+                                f"BYOK: Fetched {len(model_list)} models from {url}"
+                            )
+                        else:
+                            await self._emit_debug_log(
+                                f"BYOK: Failed to fetch models from {url}. Status: {resp.status}"
+                            )
+            except Exception as e:
+                await self._emit_debug_log(f"BYOK: Model fetch error: {e}")
+
+        # Fallback to configured list or defaults
+        if not model_list:
+            if self.valves.BYOK_MODELS.strip():
+                model_list = [
+                    m.strip() for m in self.valves.BYOK_MODELS.split(",") if m.strip()
+                ]
+                await self._emit_debug_log(
+                    f"BYOK: Using user-configured BYOK_MODELS ({len(model_list)} models)."
+                )
+            else:
+                defaults = {
+                    "anthropic": [
+                        "claude-3-5-sonnet-latest",
+                        "claude-3-5-haiku-latest",
+                        "claude-3-opus-latest",
+                    ],
+                }
+                model_list = defaults.get(
+                    self.valves.BYOK_TYPE.lower(),
+                    ["gpt-4o", "gpt-4o-mini", "o1", "o3-mini"],
+                )
+                await self._emit_debug_log(
+                    f"BYOK: Using default fallback models for {self.valves.BYOK_TYPE} ({len(model_list)} models)."
+                )
+
+        return [
+            {"id": m, "name": f"-{self._clean_model_id(m)}", "source": "byok"}
+            for m in model_list
+        ]
+
+    def _clean_model_id(self, model_id: str) -> str:
+        """Remove copilot prefixes from model ID."""
+        if model_id.startswith("copilot-"):
+            return model_id[8:]
+        elif model_id.startswith("copilot - "):
+            return model_id[10:]
+        return model_id
+
     async def pipes(self) -> List[dict]:
         """Dynamically fetch model list"""
-        # Return cache if available
         if self._model_cache:
             return self._model_cache
 
         await self._emit_debug_log("Fetching model list dynamically...")
         try:
             self._setup_env()
-            if not self.valves.GH_TOKEN:
-                return [{"id": f"{self.id}-error", "name": "Error: GH_TOKEN not set"}]
+
+            # Check for valid configuration
+            byok_active = bool(
+                self.valves.BYOK_BASE_URL
+                and (self.valves.BYOK_API_KEY or self.valves.BYOK_BEARER_TOKEN)
+            )
+            if not self.valves.GH_TOKEN and not byok_active:
+                self._standard_model_ids = set()
+                return [
+                    {"id": "error", "name": "Error: GH_TOKEN or BYOK not configured"}
+                ]
 
             client_config = {}
             if os.environ.get("COPILOT_CLI_PATH"):
                 client_config["cli_path"] = os.environ["COPILOT_CLI_PATH"]
 
+            # 1. Fetch BYOK Models if configured
+            byok_models = []
+            if byok_active:
+                byok_models = await self._fetch_byok_models()
+                # If GH_TOKEN is missing, return only BYOK models immediately
+                if not self.valves.GH_TOKEN:
+                    self._model_cache = byok_models
+                    return self._model_cache
+
+            # 2. Fetch Standard Copilot Models (if GH_TOKEN is present)
+            standard_models = []
             client = CopilotClient(client_config)
             try:
                 await client.start()
-                models = await client.list_models()
+                raw_models = await client.list_models()
 
-                # Update cache
-                self._model_cache = []
                 exclude_list = [
                     k.strip().lower()
                     for k in self.valves.EXCLUDE_KEYWORDS.split(",")
                     if k.strip()
                 ]
+                processed_models = []
 
-                models_with_info = []
-                for m in models:
-                    # Compatible with dict and object access
+                for m in raw_models:
+                    # Extract fields resiliently
                     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", {})
                     )
+                    m_policy = (
+                        m.get("policy")
+                        if isinstance(m, dict)
+                        else getattr(m, "policy", {})
+                    )
 
-                    # Check policy state
+                    # Skip disabled models
                     state = (
                         m_policy.get("state")
                         if isinstance(m_policy, dict)
@@ -852,61 +1389,68 @@ class Pipe:
                     if state == "disabled":
                         continue
 
-                    # Filtering logic
+                    # Apply exclusion filter
                     if any(kw in m_id.lower() for kw in exclude_list):
                         continue
 
-                    # Get multiplier
                     multiplier = (
                         m_billing.get("multiplier", 1)
                         if isinstance(m_billing, dict)
                         else getattr(m_billing, "multiplier", 1)
                     )
 
-                    # Format display name
-                    if multiplier == 0:
-                        display_name = f"-🔥 {m_id} (unlimited)"
+                    clean_id = self._clean_model_id(m_id)
+                    # Use (0x) to indicate free/unlimited with a fire emoji
+                    # User requested 'copilotsdk-🔥 model (0x)' format
+                    if multiplier > 0:
+                        display_name = f"-{clean_id} ({multiplier}x)"
                     else:
-                        display_name = f"-{m_id} ({multiplier}x)"
+                        display_name = f"-🔥 {clean_id} (0x)"
 
-                    models_with_info.append(
+                    processed_models.append(
                         {
-                            "id": f"{self.id}-{m_id}",
+                            "id": m_id,  # Keep raw ID
                             "name": display_name,
                             "multiplier": multiplier,
                             "raw_id": m_id,
                         }
                     )
 
-                # Sort: multiplier ascending, then raw_id ascending
-                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"Successfully fetched {len(self._model_cache)} models (filtered)"
-                )
-                return self._model_cache
-            except Exception as e:
-                await self._emit_debug_log(f"Failed to fetch model list: {e}")
-                # Return default model on failure
-                return [
+                # Sort by multiplier (cheapest first), then name
+                processed_models.sort(key=lambda x: (x["multiplier"], x["raw_id"]))
+                standard_models = [
                     {
-                        "id": f"{self.id}-gpt-5-mini",
-                        "name": f"GitHub Copilot (gpt-5-mini)",
+                        "id": f"{self.id}-{m['raw_id']}",
+                        "name": m["name"],
+                        "source": "copilot",
                     }
+                    for m in processed_models
                 ]
+                self._standard_model_ids = {m["raw_id"] for m in processed_models}
+
+            except Exception as e:
+                await self._emit_debug_log(f"Failed to fetch standard model list: {e}")
+                self._standard_model_ids = set()
+                # If standard fetch fails but we have BYOK, use BYOK
+                if byok_models:
+                    self._model_cache = byok_models
+                    return self._model_cache
+                # Otherwise, soft fail with default model
+                return [{"id": "gpt-5-mini", "name": "-gpt-5-mini"}]
             finally:
                 await client.stop()
+
+            # 3. Merge and Return
+            self._model_cache = standard_models + byok_models
+
+            await self._emit_debug_log(
+                f"Successfully fetched {len(standard_models)} standard models and {len(byok_models)} BYOK models. Total: {len(self._model_cache)}"
+            )
+            return self._model_cache
+
         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)",
-                }
-            ]
+            return [{"id": "gpt-5-mini", "name": "-gpt-5-mini"}]
 
     async def _get_client(self):
         """Helper to get or create a CopilotClient instance."""
@@ -918,8 +1462,31 @@ class Pipe:
         await client.start()
         return client
 
-    def _setup_env(self, __event_call__=None):
-        # Default CLI path logic
+    def _setup_env(self, __event_call__=None, debug_enabled: bool = False):
+        """Setup environment variables and verify Copilot CLI."""
+        if self._env_setup_done:
+            return
+
+        # 1. Environment Variables for Auth
+        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(
+                "Warning: GH_TOKEN is not set.",
+                __event_call__,
+                debug_enabled=debug_enabled,
+            )
+
+        # Disable CLI auto-update to ensure version consistency
+        os.environ["COPILOT_AUTO_UPDATE"] = "false"
+        self._emit_debug_log_sync(
+            "Disabled CLI auto-update (COPILOT_AUTO_UPDATE=false)",
+            __event_call__,
+            debug_enabled=debug_enabled,
+        )
+
+        # 2. CLI Path Discovery
         cli_path = "/usr/local/bin/copilot"
         if os.environ.get("COPILOT_CLI_PATH"):
             cli_path = os.environ["COPILOT_CLI_PATH"]
@@ -928,7 +1495,6 @@ class Pipe:
         found = False
         current_version = None
 
-        # internal helper to get version
         def get_cli_version(path):
             try:
                 output = (
@@ -938,19 +1504,18 @@ class Pipe:
                     .decode()
                     .strip()
                 )
-                # Copilot CLI version output format is usually just the version number or "copilot version X.Y.Z"
-                # We try to extract X.Y.Z
+                import re
+
                 match = re.search(r"(\d+\.\d+\.\d+)", output)
                 return match.group(1) if match else output
             except Exception:
                 return None
 
-        # Check default path
+        # Check existing version
         if os.path.exists(cli_path):
             found = True
             current_version = get_cli_version(cli_path)
 
-        # Check system path if not found
         if not found:
             sys_path = shutil.which("copilot")
             if sys_path:
@@ -958,85 +1523,80 @@ class Pipe:
                 found = True
                 current_version = get_cli_version(cli_path)
 
-        # Determine if we need to install or update
-        should_install = False
-        install_reason = ""
-
         if not found:
-            should_install = True
-            install_reason = "CLI not found"
-        elif target_version:
-            # Normalize versions for comparison (remove 'v' prefix)
+            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. Installation/Update Logic
+        should_install = not found
+        install_reason = "CLI not found"
+        if found and target_version:
             norm_target = target_version.lstrip("v")
             norm_current = current_version.lstrip("v") if current_version else ""
 
-            if norm_target != norm_current:
-                should_install = True
-                install_reason = f"Version mismatch (Current: {current_version}, Target: {target_version})"
+            # Only install if target version is GREATER than current version
+            try:
+                from packaging.version import parse as parse_version
+
+                if parse_version(norm_target) > parse_version(norm_current):
+                    should_install = True
+                    install_reason = (
+                        f"Upgrade needed ({current_version} -> {target_version})"
+                    )
+                elif parse_version(norm_target) < parse_version(norm_current):
+                    self._emit_debug_log_sync(
+                        f"Current version ({current_version}) is newer than specified ({target_version}). Skipping downgrade.",
+                        __event_call__,
+                        debug_enabled=debug_enabled,
+                    )
+            except Exception as e:
+                # Fallback to string comparison if packaging is not available
+                if norm_target != norm_current:
+                    should_install = True
+                    install_reason = (
+                        f"Version mismatch ({current_version} != {target_version})"
+                    )
 
         if should_install:
-            if self.valves.DEBUG:
-                self._emit_debug_log_sync(
-                    f"Installing Copilot CLI: {install_reason}...", __event_call__
-                )
+            self._emit_debug_log_sync(
+                f"Installing/Updating 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,
                 )
-
-                # Check default install location first, then system path
-                if os.path.exists("/usr/local/bin/copilot"):
-                    cli_path = "/usr/local/bin/copilot"
-                    found = True
-                elif shutil.which("copilot"):
-                    cli_path = shutil.which("copilot")
-                    found = True
-
-                if found:
-                    current_version = get_cli_version(cli_path)
+                # Re-verify
+                current_version = get_cli_version(cli_path)
             except Exception as e:
-                if self.valves.DEBUG:
-                    self._emit_debug_log_sync(
-                        f"Failed to install Copilot CLI: {e}", __event_call__
-                    )
-
-        if found:
-            os.environ["COPILOT_CLI_PATH"] = cli_path
-            cli_dir = os.path.dirname(cli_path)
-            if cli_dir not in os.environ["PATH"]:
-                os.environ["PATH"] = f"{cli_dir}:{os.environ['PATH']}"
-
-            if self.valves.DEBUG:
                 self._emit_debug_log_sync(
-                    f"Copilot CLI found at: {cli_path} (Version: {current_version})",
-                    __event_call__,
-                )
-        else:
-            if self.valves.DEBUG:
-                self._emit_debug_log_sync(
-                    "Error: Copilot CLI NOT found. Agent capabilities will be disabled.",
+                    f"CLI installation failed: {e}",
                     __event_call__,
+                    debug_enabled=debug_enabled,
                 )
 
-        if self.valves.GH_TOKEN:
-            os.environ["GH_TOKEN"] = self.valves.GH_TOKEN
-            os.environ["GITHUB_TOKEN"] = self.valves.GH_TOKEN
-        else:
-            if self.valves.DEBUG:
-                self._emit_debug_log_sync(
-                    "Warning: GH_TOKEN is not set.", __event_call__
-                )
+        # 4. Finalize
+        os.environ["COPILOT_CLI_PATH"] = cli_path
+        self._env_setup_done = True
+        self._emit_debug_log_sync(
+            f"Environment setup complete. CLI: {cli_path} (v{current_version})",
+            __event_call__,
+            debug_enabled=debug_enabled,
+        )
 
-        self._sync_mcp_config(__event_call__)
-
-    def _process_images(self, messages, __event_call__=None):
+    def _process_images(
+        self, messages, __event_call__=None, debug_enabled: bool = False
+    ):
         attachments = []
         text_content = ""
         if not messages:
@@ -1066,17 +1626,23 @@ class Pipe:
                                 }
                             )
                             self._emit_debug_log_sync(
-                                f"Image processed: {file_path}", __event_call__
+                                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__
+                                f"Image error: {e}",
+                                __event_call__,
+                                debug_enabled=debug_enabled,
                             )
         else:
             text_content = str(content)
         return text_content, attachments
 
-    def _sync_copilot_config(self, reasoning_effort: str, __event_call__=None):
+    def _sync_copilot_config(
+        self, reasoning_effort: str, __event_call__=None, debug_enabled: bool = False
+    ):
         """
         Dynamically update ~/.copilot/config.json if REASONING_EFFORT is set.
         This provides a fallback if API injection is ignored by the server.
@@ -1129,61 +1695,21 @@ class Pipe:
                     self._emit_debug_log_sync(
                         f"Dynamically updated ~/.copilot/config.json: reasoning_effort='{effort}'",
                         __event_call__,
+                        debug_enabled=debug_enabled,
                     )
                 except Exception as e:
                     self._emit_debug_log_sync(
-                        f"Failed to write config.json: {e}", __event_call__
+                        f"Failed to write config.json: {e}",
+                        __event_call__,
+                        debug_enabled=debug_enabled,
                     )
         except Exception as e:
-            self._emit_debug_log_sync(f"Config sync check failed: {e}", __event_call__)
-
-    async def _update_copilot_cli(self, cli_path: str, __event_call__=None):
-        """Async task to update Copilot CLI if needed."""
-        import time
-
-        try:
-            # Check frequency (e.g., once every hour)
-            now = time.time()
-            if now - self._last_update_check < 3600:
-                return
-
-            self._last_update_check = now
-
-            # Simple check if "update" command is available or if we should just run it
-            # The user requested "async attempt to update copilot cli"
-
-            if self.valves.DEBUG:
-                self._emit_debug_log_sync(
-                    "Triggering async Copilot CLI update check...", __event_call__
-                )
-
-            # We create a subprocess to run the update
-            process = await asyncio.create_subprocess_exec(
-                cli_path,
-                "update",
-                stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.PIPE,
+            self._emit_debug_log_sync(
+                f"Config sync check failed: {e}",
+                __event_call__,
+                debug_enabled=debug_enabled,
             )
 
-            stdout, stderr = await process.communicate()
-
-            if self.valves.DEBUG:
-                output = stdout.decode().strip() or stderr.decode().strip()
-                if output:
-                    self._emit_debug_log_sync(
-                        f"Async CLI Update result: {output}", __event_call__
-                    )
-
-        except Exception as e:
-            if self.valves.DEBUG:
-                self._emit_debug_log_sync(
-                    f"Async CLI Update failed: {e}", __event_call__
-                )
-
-    def _sync_mcp_config(self, __event_call__=None):
-        """Deprecated: MCP config is now handled dynamically via session config."""
-        pass
-
     # ==================== Internal Implementation ====================
     # _pipe_impl() contains the main request handling logic.
     # ================================================================
@@ -1195,25 +1721,7 @@ class Pipe:
         __event_emitter__=None,
         __event_call__=None,
     ) -> Union[str, AsyncGenerator]:
-        self._setup_env(__event_call__)
-
-        cwd = self._get_workspace_dir()
-        if self.valves.DEBUG:
-            await self._emit_debug_log(f"Agent working in: {cwd}", __event_call__)
-
-        if not self.valves.GH_TOKEN:
-            return "Error: Please configure GH_TOKEN in Valves."
-
-        # Trigger async CLI update if configured
-        cli_path = os.environ.get("COPILOT_CLI_PATH")
-        if cli_path:
-            asyncio.create_task(self._update_copilot_cli(cli_path, __event_call__))
-
-        # Parse user selected model
-        request_model = body.get("model", "")
-        real_model_id = request_model
-
-        # Determine effective reasoning effort and debug setting
+        # 1. Determine effective debug setting FIRST to capture all logs
         if __user__:
             raw_valves = __user__.get("valves", {})
             if isinstance(raw_valves, self.UserValves):
@@ -1224,17 +1732,40 @@ class Pipe:
                 user_valves = self.UserValves()
         else:
             user_valves = self.UserValves()
+
+        effective_debug = self.valves.DEBUG or user_valves.DEBUG
+
+        # 2. Setup environment with effective debug
+        self._setup_env(__event_call__, debug_enabled=effective_debug)
+
+        cwd = self._get_workspace_dir()
+        await self._emit_debug_log(
+            f"Agent working in: {cwd}", __event_call__, debug_enabled=effective_debug
+        )
+
+        # Determine effective BYOK settings
+        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))
+
+        # Check that either GH_TOKEN or BYOK is configured
+        gh_token = user_valves.GH_TOKEN or self.valves.GH_TOKEN
+        if not gh_token and not byok_active:
+            return "Error: Please configure GH_TOKEN or BYOK settings in Valves."
+
+        # Parse user selected model
+        request_model = body.get("model", "")
+        real_model_id = request_model
+
+        # Determine effective reasoning effort
         effective_reasoning_effort = (
             user_valves.REASONING_EFFORT
             if user_valves.REASONING_EFFORT
             else self.valves.REASONING_EFFORT
         )
-        # Apply DEBUG user setting override if set to True (if False, respect global)
-        # Actually user setting should probably override strictly.
-        # But boolean fields in UserValves default to False, so we can't distinguish "not set" from "off" easily without Optional[bool]
-        # Let's assume if user sets DEBUG=True, it wins.
-        if user_valves.DEBUG:
-            self.valves.DEBUG = True
 
         # Apply SHOW_THINKING user setting (prefer user override when provided)
         show_thinking = (
@@ -1243,44 +1774,68 @@ class Pipe:
             else self.valves.SHOW_THINKING
         )
 
-        if request_model.startswith(f"{self.id}-"):
-            real_model_id = request_model[len(f"{self.id}-") :]
-            await self._emit_debug_log(
-                f"Using selected model: {real_model_id}", __event_call__
+        # 1. Determine the actual model ID to use
+        # Priority: __metadata__.base_model_id (for custom models/characters) > request_model
+        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. Strip prefixes to get the clean model ID (e.g. 'gpt-4o')
+        real_model_id = self._strip_model_prefix(resolved_id)
+
+        # 3. Log the resolution result
+        if real_model_id != request_model:
+            log_msg = (
+                f"Using {model_source_type} model: {real_model_id} "
+                f"(Cleaned from '{resolved_id}')"
+            )
+            await self._emit_debug_log(
+                log_msg,
+                __event_call__,
+                debug_enabled=effective_debug,
             )
-        elif __metadata__ and __metadata__.get("base_model_id"):
-            base_model_id = __metadata__.get("base_model_id", "")
-            if base_model_id.startswith(f"{self.id}-"):
-                real_model_id = base_model_id[len(f"{self.id}-") :]
-                await self._emit_debug_log(
-                    f"Using base model: {real_model_id} (derived from custom model {request_model})",
-                    __event_call__,
-                )
 
         messages = body.get("messages", [])
         if not messages:
             return "No messages."
 
         # Get Chat ID using improved helper
-        chat_ctx = self._get_chat_context(body, __metadata__, __event_call__)
+        chat_ctx = self._get_chat_context(
+            body, __metadata__, __event_call__, debug_enabled=effective_debug
+        )
         chat_id = chat_ctx.get("chat_id")
 
         # Extract system prompt from multiple sources
         system_prompt_content, system_prompt_source = await self._extract_system_prompt(
-            body, messages, request_model, real_model_id, __event_call__
+            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 confirmed (source: {system_prompt_source}, length: {len(system_prompt_content)}, preview: {preview})",
+                f"Resolved system prompt source: {system_prompt_source} (length: {len(system_prompt_content) if system_prompt_content else 0})",
                 __event_call__,
+                debug_enabled=effective_debug,
             )
 
         is_streaming = body.get("stream", False)
-        await self._emit_debug_log(f"Request Streaming: {is_streaming}", __event_call__)
+        await self._emit_debug_log(
+            f"Streaming request: {is_streaming}",
+            __event_call__,
+            debug_enabled=effective_debug,
+        )
 
-        last_text, attachments = self._process_images(messages, __event_call__)
+        last_text, attachments = self._process_images(
+            messages, __event_call__, debug_enabled=effective_debug
+        )
 
         # Determine prompt strategy
         # If we have a chat_id, we try to resume session.
@@ -1288,7 +1843,147 @@ class Pipe:
         # If new session, we send full (accumulated) messages.
 
         # Ensure we have the latest config
-        self._sync_copilot_config(effective_reasoning_effort, __event_call__)
+        # Determine if the currently selected model is a BYOK model or a Standard model
+        # Detection priority:
+        # 1. Check body.metadata.model.name for multiplier info (most direct)
+        # 2. Check model cache for explicit 'source' field
+        # 3. Check if model name in cache contains multiplier info
+        # 4. Fallback heuristics
+        import re
+
+        is_byok_model = False
+        model_display_name = ""
+
+        # Method 1: Get model name from various metadata sources
+        body_metadata = body.get("metadata", {})
+        if not isinstance(body_metadata, dict):
+            body_metadata = {}
+
+        # Priority: body.metadata.model.name > __metadata__.model.name > __metadata__.model_name
+        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__:
+            # Check __metadata__['model'] which we saw in the logs
+            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
+
+            # Further fallbacks
+            if not model_display_name:
+                model_display_name = __metadata__.get(
+                    "model_name", ""
+                ) or __metadata__.get("name", "")
+
+        if not model_display_name:
+            # Last resort: log keys and 'model' type for future debugging
+            meta_keys = list(body_metadata.keys())
+            extra_keys = list(__metadata__.keys()) if __metadata__ else []
+            model_val = __metadata__.get("model") if __metadata__ else None
+            await self._emit_debug_log(
+                f"Debug: Name not found. body.meta keys: {meta_keys}, __meta__ keys: {extra_keys}, model_type: {type(model_val)}",
+                __event_call__,
+                debug_enabled=effective_debug,
+            )
+
+        if model_display_name:
+            # Copilot models have multiplier info like "(0x)", "(1x)", "(0.5x)" or Chinese "（1x）"
+            has_multiplier = bool(re.search(r"[\(（]\d+(?:\.\d+)?x[\)）]", model_display_name))
+            
+            # Logic: If Custom Model name lacks multiplier, check the Base Model's official name
+            if not has_multiplier:
+                # Ensure cache is populated
+                if not self._model_cache:
+                    try:
+                        await self.pipes()
+                    except:
+                        pass
+                
+                # Lookup base model in cache to check its official name
+                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"Correction: Found multiplier in Base Model name '{cached_name}' for Custom Model '{model_display_name}'. Treated as Standard Copilot.",
+                            __event_call__,
+                            debug_enabled=effective_debug,
+                        )
+
+            is_byok_model = not has_multiplier and byok_active
+
+            await self._emit_debug_log(
+                f"BYOK detection via display name: '{model_display_name}' -> multiplier={has_multiplier}, is_byok={is_byok_model}",
+                __event_call__,
+                debug_enabled=effective_debug,
+            )
+        else:
+            # Fallback: lookup from cache
+            if not self._model_cache:
+                try:
+                    await self.pipes()
+                except:
+                    pass
+
+            # For custom models, use base_model_id to find the actual model info
+            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"
+                    await self._emit_debug_log(
+                        f"BYOK detection via cache source: '{model_info.get('id')}' source='{model_info['source']}' -> is_byok={is_byok_model}",
+                        __event_call__,
+                        debug_enabled=effective_debug,
+                    )
+                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
+                    await self._emit_debug_log(
+                        f"BYOK detection via cache name: '{model_name}' -> multiplier={has_multiplier}, is_byok={is_byok_model}",
+                        __event_call__,
+                        debug_enabled=effective_debug,
+                    )
+            else:
+                # Fallback to heuristics if model not in cache
+                if byok_active:
+                    if not gh_token:
+                        is_byok_model = True
+                    elif real_model_id.startswith("copilot-"):
+                        # If ID starts with copilot-, assume it's NOT BYOK even if list is old
+                        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 detection via heuristics: model_id='{real_model_id}', byok_active={byok_active} -> is_byok={is_byok_model}",
+                    __event_call__,
+                    debug_enabled=effective_debug,
+                )
+
+        # Ensure we have the latest config (only for standard Copilot models)
+        if not is_byok_model:
+            self._sync_copilot_config(effective_reasoning_effort, __event_call__)
 
         # Initialize Client
         client = CopilotClient(self._build_client_config(body))
@@ -1296,22 +1991,16 @@ class Pipe:
         try:
             await client.start()
 
-            # Initialize custom tools
+            # Initialize custom tools (Handles caching internally)
             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"Enabled {len(custom_tools)} custom tools: {tool_names}",
+                    f"Enabled {len(custom_tools)} tools (Custom/Built-in)",
                     __event_call__,
                 )
-                if self.valves.DEBUG:
-                    for t in custom_tools:
-                        await self._emit_debug_log(
-                            f"📋 Tool Detail: {t.name} - {t.description[:100]}...",
-                            __event_call__,
-                        )
 
             # Check MCP Servers
             mcp_servers = self._parse_mcp_servers()
@@ -1321,7 +2010,6 @@ class Pipe:
                     f"🔌 MCP Servers Configured: {mcp_server_names}",
                     __event_call__,
                 )
-
             else:
                 await self._emit_debug_log(
                     "ℹ️ No MCP tool servers found in OpenWebUI Connections.",
@@ -1330,76 +2018,116 @@ class Pipe:
 
             # Create or Resume Session
             session = None
+            is_new_session = True
+
+            # Build BYOK Provider Config
+            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
+                pass
+
             if chat_id:
                 try:
-                    # Prepare resume config
-                    resume_params = {}
+                    # Prepare resume config (Requires github-copilot-sdk >= 0.1.23)
+                    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
 
-                    session = (
-                        await client.resume_session(chat_id, resume_params)
-                        if resume_params
-                        else await client.resume_session(chat_id)
-                    )
+                    # Always inject the latest system prompt in 'replace' mode
+                    # This handles both custom models and user-defined system messages
+                    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,
+                    }
+
+                    preview = final_system_msg[:100].replace("\n", " ")
                     await self._emit_debug_log(
-                        f"Resumed session: {chat_id} (Reasoning: {effective_reasoning_effort or 'default'})",
+                        f"Resuming session {chat_id}. Injecting System Prompt ({len(final_system_msg)} chars). Mode: REPLACE. Content Preview: {preview}...",
+                        __event_call__,
+                        debug_enabled=effective_debug,
+                    )
+
+                    # Update provider if needed (BYOK support during resume)
+                    if provider_config:
+                        resume_params["provider"] = provider_config
+                        await self._emit_debug_log(
+                            f"BYOK provider config included: type={provider_config.get('type')}, base_url={provider_config.get('base_url')}",
+                            __event_call__,
+                            debug_enabled=effective_debug,
+                        )
+
+                    # Debug: Log the full resume_params structure
+                    await self._emit_debug_log(
+                        f"resume_params keys: {list(resume_params.keys())}. system_message mode: {resume_params.get('system_message', {}).get('mode')}",
+                        __event_call__,
+                        debug_enabled=effective_debug,
+                    )
+
+                    session = await client.resume_session(chat_id, resume_params)
+                    await self._emit_debug_log(
+                        f"Successfully resumed session {chat_id} with model {real_model_id}",
                         __event_call__,
                     )
-
-                    # Show workspace info of available
-                    if self.valves.DEBUG:
-                        if session.workspace_path:
-                            await self._emit_debug_log(
-                                f"Session workspace: {session.workspace_path}",
-                                __event_call__,
-                            )
-
                     is_new_session = False
                 except Exception as e:
                     await self._emit_debug_log(
-                        f"Session {chat_id} not found ({str(e)}), creating new.",
+                        f"Session {chat_id} not found or failed to resume ({str(e)}), creating new.",
                         __event_call__,
                     )
 
             if session is None:
+                is_new_session = True
                 session_config = self._build_session_config(
                     chat_id,
                     real_model_id,
                     custom_tools,
                     system_prompt_content,
                     is_streaming,
+                    provider_config=provider_config,
                 )
-                if system_prompt_content or self.valves.ENFORCE_FORMATTING:
-                    # Build preview of what's being sent
-                    preview_parts = []
-                    if system_prompt_content:
-                        preview_parts.append(
-                            f"custom_prompt: {system_prompt_content[:100]}..."
-                        )
-                    if self.valves.ENFORCE_FORMATTING:
-                        preview_parts.append("formatting_guidelines: enabled")
 
-                    if isinstance(session_config, dict):
-                        system_config = session_config.get("system_message", {})
-                    else:
-                        system_config = getattr(session_config, "system_message", None)
-
-                    if isinstance(system_config, dict):
-                        full_content = system_config.get("content", "")
-                    else:
-                        full_content = ""
-
-                    await self._emit_debug_log(
-                        f"System message config - {', '.join(preview_parts)} (total length: {len(full_content)} chars)",
-                        __event_call__,
-                    )
-                session = await client.create_session(config=session_config)
                 await self._emit_debug_log(
-                    f"Created new session with model: {real_model_id}",
+                    f"Injecting system prompt into new session (len: {len(system_prompt_content or '') + len(FORMATTING_GUIDELINES)})",
                     __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"New {model_type_label} session created. Selected: '{request_model}', Effective ID: '{real_model_id}'",
+                    __event_call__,
+                    debug_enabled=effective_debug,
+                )
+
                 # Show workspace info for new sessions
                 if self.valves.DEBUG:
                     if session.workspace_path:
@@ -1409,7 +2137,9 @@ class Pipe:
                         )
 
             # Construct Prompt (session-based: send only latest user input)
-            prompt = self._apply_formatting_hint(last_text)
+            # SDK testing confirmed session.resume correctly applies system_message updates,
+            # so we simply use the user's input as the prompt.
+            prompt = last_text
 
             await self._emit_debug_log(
                 f"Sending prompt ({len(prompt)} chars) to Agent...",
@@ -1420,9 +2150,13 @@ class Pipe:
             if attachments:
                 send_payload["attachments"] = attachments
 
+            # Note: temperature, top_p, max_tokens are not supported by the SDK's
+            # session.send() method. These generation parameters would need to be
+            # handled at a different level if the underlying provider supports them.
+
             if body.get("stream", False):
                 init_msg = ""
-                if self.valves.DEBUG:
+                if effective_debug:
                     init_msg = (
                         f"> [Debug] Agent working in: {self._get_workspace_dir()}\n"
                     )
@@ -1439,6 +2173,7 @@ class Pipe:
                     __event_call__,
                     reasoning_effort=effective_reasoning_effort,
                     show_thinking=show_thinking,
+                    debug_enabled=effective_debug,
                 )
             else:
                 try:
@@ -1455,7 +2190,9 @@ class Pipe:
                                 __event_call__,
                             )
         except Exception as e:
-            await self._emit_debug_log(f"Request Error: {e}", __event_call__)
+            await self._emit_debug_log(
+                f"Request Error: {e}", __event_call__, debug_enabled=effective_debug
+            )
             return f"Error: {str(e)}"
         finally:
             # Cleanup client if not transferred to stream
@@ -1464,7 +2201,9 @@ class Pipe:
                     await client.stop()
                 except Exception as e:
                     await self._emit_debug_log(
-                        f"Client cleanup warning: {e}", __event_call__
+                        f"Client cleanup warning: {e}",
+                        __event_call__,
+                        debug_enabled=effective_debug,
                     )
 
     async def stream_response(
@@ -1476,6 +2215,7 @@ class Pipe:
         __event_call__=None,
         reasoning_effort: str = "",
         show_thinking: bool = True,
+        debug_enabled: bool = False,
     ) -> AsyncGenerator:
         """
         Stream response from Copilot SDK, handling various event types.
@@ -1541,6 +2281,10 @@ class Pipe:
             # === Complete Message Event (Non-streaming response) ===
             elif event_type == "assistant.message":
                 # Handle complete message (when SDK returns full content instead of deltas)
+                # IMPORTANT: Skip if we already received delta content to avoid duplication.
+                # The SDK may emit both delta and full message events.
+                if state["content_sent"]:
+                    return
                 content = safe_get_data_attr(event, "content") or safe_get_data_attr(
                     event, "message"
                 )
@@ -1778,7 +2522,7 @@ class Pipe:
 
         # Safe initial yield with error handling
         try:
-            if self.valves.DEBUG:
+            if self.valves.DEBUG and show_thinking:
                 yield "<think>\n"
                 if init_message:
                     yield init_message
diff --git a/plugins/pipes/github-copilot-sdk/github_copilot_sdk_cn.py b/plugins/pipes/github-copilot-sdk/github_copilot_sdk_cn.py
index d15fa95..4ea7ae7 100644
--- a/plugins/pipes/github-copilot-sdk/github_copilot_sdk_cn.py
+++ b/plugins/pipes/github-copilot-sdk/github_copilot_sdk_cn.py
@@ -4,8 +4,8 @@ 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.3.0
-requirements: github-copilot-sdk==0.1.22
+version: 0.5.1
+requirements: github-copilot-sdk==0.1.23
 """
 
 import os
@@ -21,7 +21,7 @@ import subprocess
 import sys
 import hashlib
 from pathlib import Path
-from typing import Optional, Union, AsyncGenerator, List, Any, Dict, Callable
+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
@@ -30,25 +30,89 @@ import contextlib
 # 导入 Copilot SDK 模块
 from copilot import CopilotClient, define_tool
 
-# 导入 OpenWebUI 配置和工具模块
-from open_webui.config import TOOL_SERVER_CONNECTIONS
-from open_webui.utils.tools import get_tools as get_openwebui_tools
+# 导入 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"
+    "   - 如果工具生成了图像或文件，你 **必须** 使用 `![caption](url)` 直接嵌入。\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 OAuth Token (来自 'gh auth token')，用于 Copilot Chat (必须)",
+            description="GitHub Fine-grained Token (需要 'Copilot Requests' 权限)",
         )
-        COPILOT_CLI_VERSION: str = Field(
-            default="0.0.405",
-            description="指定安装/强制使用的 Copilot CLI 版本 (例如 '0.0.405')。留空则使用最新版。",
+        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,
@@ -58,22 +122,22 @@ class Pipe:
             default="error",
             description="Copilot CLI 日志级别：none, error, warning, info, debug, all",
         )
-        SHOW_THINKING: bool = Field(
-            default=True,
-            description="显示模型推理/思考过程",
+        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）",
         )
-        WORKSPACE_DIR: str = Field(
-            default="",
-            description="文件操作的受限工作区目录；为空则使用当前进程目录",
-        )
-        INFINITE_SESSION: bool = Field(
-            default=True,
-            description="启用无限会话（自动上下文压缩）",
-        )
         COMPACTION_THRESHOLD: float = Field(
             default=0.8,
             description="后台压缩阈值 (0.0-1.0)",
@@ -82,30 +146,34 @@ class Pipe:
             default=0.95,
             description="缓冲区耗尽阈值 (0.0-1.0)",
         )
-        TIMEOUT: int = Field(
-            default=300,
-            description="每个流式分块超时（秒）",
-        )
         CUSTOM_ENV_VARS: str = Field(
             default="",
             description='自定义环境变量（JSON 格式，例如 {"VAR": "value"}）',
         )
 
-        ENABLE_OPENWEBUI_TOOLS: bool = Field(
-            default=True,
-            description="启用 OpenWebUI 工具 (包括自定义工具和工具服务器工具)。",
+        BYOK_TYPE: Literal["openai", "anthropic"] = Field(
+            default="openai",
+            description="BYOK 提供商类型：openai, anthropic",
         )
-        ENABLE_MCP_SERVER: bool = Field(
-            default=True,
-            description="启用直接 MCP 客户端连接 (推荐)。",
+        BYOK_BASE_URL: str = Field(
+            default="",
+            description="BYOK 基础 URL (例如 https://api.openai.com/v1)",
         )
-        REASONING_EFFORT: str = Field(
-            default="medium",
-            description="推理强度级别: low, medium, high. (gpt-5.2-codex 额外支持 xhigh)",
+        BYOK_API_KEY: str = Field(
+            default="",
+            description="BYOK API 密钥 (全局设置)",
         )
-        ENFORCE_FORMATTING: bool = Field(
-            default=True,
-            description="在系统提示词中添加格式化指导，以提高输出的可读性（段落、换行、结构）。",
+        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):
@@ -113,31 +181,55 @@ class Pipe:
             default="",
             description="个人 GitHub Fine-grained Token (覆盖全局设置)",
         )
-        REASONING_EFFORT: str = Field(
+        REASONING_EFFORT: Literal["", "low", "medium", "high", "xhigh"] = Field(
             default="",
-            description="推理强度级别 (low, medium, high, xhigh)。留空以使用全局设置。",
+            description="推理强度级别覆盖。仅影响标准 Copilot 模型。",
+        )
+        SHOW_THINKING: bool = Field(
+            default=True,
+            description="显示模型推理/思考过程",
         )
         DEBUG: bool = Field(
             default=False,
             description="启用技术调试日志（连接信息等）",
         )
-        SHOW_THINKING: bool = Field(
-            default=True,
-            description="显示模型的推理/思考过程",
-        )
-
         ENABLE_OPENWEBUI_TOOLS: bool = Field(
             default=True,
-            description="启用 OpenWebUI 工具 (包括自定义工具和工具服务器工具，覆盖全局设置)。",
+            description="启用 OpenWebUI 工具 (包括自定义工具和工具服务器工具)。",
         )
         ENABLE_MCP_SERVER: bool = Field(
             default=True,
             description="启用动态 MCP 服务器加载 (覆盖全局设置)。",
         )
-
-        ENFORCE_FORMATTING: bool = Field(
+        ENABLE_TOOL_CACHE: bool = Field(
             default=True,
-            description="强制启用格式化指导 (覆盖全局设置)",
+            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):
@@ -146,9 +238,12 @@ class Pipe:
         self.name = "copilotsdk"
         self.valves = self.Valves()
         self.temp_dir = tempfile.mkdtemp(prefix="copilot_images_")
-        self.thinking_started = False
         self._model_cache = []  # 模型列表缓存
-        self._last_update_check = 0  # 上次 CLI 更新检查时间
+        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:
@@ -176,228 +271,59 @@ class Pipe:
             __event_call__=__event_call__,
         )
 
-    # ==================== 功能性分区说明 ====================
-    # 1) 工具注册：定义工具并在 _initialize_custom_tools 中注册
-    # 2) 调试日志：_emit_debug_log / _emit_debug_log_sync
-    # 3) 提示词/会话：_extract_system_prompt / _build_session_config / _build_prompt
-    # 4) 运行流程：pipe() 负责请求，stream_response() 负责流式输出
+    # ==================== 功能性分区 ====================
+    # 1) 工具加载与转换
+    # 2) 提示词提取与处理
+    # 3) 环境配置与工作区
     # ======================================================
-    # ==================== 自定义工具示例 ====================
-    # 工具注册：在模块级别添加 @define_tool 装饰的函数，
-    # 然后在 _initialize_custom_tools() 的 all_tools 字典中注册。
-
-    def _extract_text_from_content(self, content) -> str:
-        """从各种消息内容格式中提取文本内容"""
-        if isinstance(content, str):
-            return content
-        elif isinstance(content, list):
-            text_parts = []
-            for item in content:
-                if isinstance(item, dict) and item.get("type") == "text":
-                    text_parts.append(item.get("text", ""))
-            return " ".join(text_parts)
-        return ""
-
-    def _apply_formatting_hint(self, prompt: str) -> str:
-        """在启用格式化时，向用户提示词追加轻量格式化要求。"""
-        if not self.valves.ENFORCE_FORMATTING:
-            return prompt
-
-        if not prompt:
-            return prompt
-
-        if "[格式化指南]" in prompt or "[格式化要求]" in prompt:
-            return prompt
-
-        formatting_hint = (
-            "\n\n[格式化要求]\n" "请使用清晰的段落与换行，必要时使用项目符号列表。"
-        )
-        return f"{prompt}{formatting_hint}"
-
-    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 _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,
-    ) -> tuple[Optional[str], str]:
-        """从 metadata/模型 DB/body/messages 提取系统提示词"""
-        system_prompt_content: Optional[str] = None
-        system_prompt_source = ""
-
-        # 1) metadata.model.params.system
-        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__,
-                    )
-
-        # 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"从模型数据库提取系统提示词（长度: {len(system_prompt_content)}）",
-                                    __event_call__,
-                                )
-                                break
-            except Exception as e:
-                await self._emit_debug_log(
-                    f"从模型数据库提取系统提示词失败: {e}",
-                    __event_call__,
-                )
-
-        # 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
-
-    def _get_workspace_dir(self) -> str:
-        """获取具有智能默认值的有效工作空间目录。"""
-        if self.valves.WORKSPACE_DIR:
-            return self.valves.WORKSPACE_DIR
-
-        # OpenWebUI 容器的智能默认值
-        if os.path.exists("/app/backend/data"):
-            cwd = "/app/backend/data/copilot_workspace"
-        else:
-            # 本地回退：当前工作目录的子目录
-            cwd = os.path.join(os.getcwd(), "copilot_workspace")
-
-        # 确保目录存在
-        if not os.path.exists(cwd):
-            try:
-                os.makedirs(cwd, exist_ok=True)
-            except Exception as e:
-                print(f"Error creating workspace {cwd}: {e}")
-                return os.getcwd()  # 如果创建失败回退到 CWD
-
-        return cwd
-
-    def _build_client_config(self, body: dict) -> dict:
-        """根据 Valves 和请求构建 CopilotClient 配置"""
-        cwd = self._get_workspace_dir()
-        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
-
-        return client_config
 
     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 类型转换为 Python 类型以用于 Pydantic 模型。"""
+        """将 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])
@@ -424,14 +350,10 @@ class Pipe:
         # 净化工具名称以匹配模式 ^[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}"
 
-        if sanitized_tool_name != tool_name:
-            logger.debug(f"将工具名称 '{tool_name}' 净化为 '{sanitized_tool_name}'")
-
         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", {})
@@ -450,6 +372,11 @@ class Pipe:
             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] = (
@@ -463,64 +390,110 @@ class Pipe:
                 if description:
                     fields[param_name] = (
                         optional_type,
-                        Field(default=None, description=description),
+                        Field(default=default_value, description=description),
                     )
                 else:
-                    fields[param_name] = (optional_type, None)
+                    fields[param_name] = (optional_type, default_value)
 
-        if fields:
-            ParamsModel = create_model(f"{sanitized_tool_name}_Params", **fields)
-        else:
-            ParamsModel = create_model(f"{sanitized_tool_name}_Params")
+        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"功能 '{tool_name}': {tool_description}"
+            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() if hasattr(params, "model_dump") else {}
+            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
 
-        # 转换调试日志
-        logger.debug(
-            f"正在转换工具 '{sanitized_tool_name}': {tool_description[:50]}..."
-        )
-
-        # 核心关键点：必须显式传递 types，否则 define_tool 无法推断动态函数的参数
-        # 显式传递 name 确保 SDK 注册的名称正确
         return define_tool(
             name=sanitized_tool_name,
             description=tool_description,
             params_type=ParamsModel,
         )(_tool)
 
-    def _build_openwebui_request(self):
+    def _build_openwebui_request(self, user_data: Optional[dict] = None):
         """构建一个最小的 request 模拟对象用于 OpenWebUI 工具加载。"""
         app_state = SimpleNamespace(
             config=SimpleNamespace(
-                TOOL_SERVER_CONNECTIONS=TOOL_SERVER_CONNECTIONS.value
+                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 工具。"""
+        """加载 OpenWebUI 工具并转换为 Copilot SDK 工具。"""
         if isinstance(__user__, (list, tuple)):
             user_data = __user__[0] if __user__ else {}
         elif isinstance(__user__, dict):
@@ -535,54 +508,99 @@ class Pipe:
         if not user_id:
             return []
 
-        user = Users.get_user_by_id(user_id)
-        if not user:
+        try:
+            from open_webui.models.users import Users
+
+            user = Users.get_user_by_id(user_id)
+            if not user:
+                return []
+        except:
             return []
 
-        # 1. 获取用户自定义工具 (Python 脚本)
+        # 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. 获取 OpenAPI 工具服务器工具
-        # 我们手动添加已启用的 OpenAPI 服务器，因为 Tools.get_tools_by_user_id 仅检查数据库。
-        # open_webui.utils.tools.get_tools 会处理实际的加载和访问控制。
+        # 2. 工具服务器工具
         if hasattr(TOOL_SERVER_CONNECTIONS, "value"):
             for server in TOOL_SERVER_CONNECTIONS.value:
-                # 我们在此处仅添加 'openapi' 服务器，因为 get_tools 目前似乎仅支持 'openapi' (默认为此)。
-                # MCP 工具通过 ENABLE_MCP_SERVER 单独处理。
                 if server.get("type") == "openapi":
-                    # get_tools 期望的格式: "server:<id>" 隐含 type="openapi"
                     server_id = server.get("id")
                     if server_id:
                         tool_ids.append(f"server:{server_id}")
 
-        if not tool_ids:
-            return []
-
-        request = self._build_openwebui_request()
+        request = self._build_openwebui_request(user_data)
         extra_params = {
             "__request__": request,
             "__user__": user_data,
-            "__event_emitter__": None,
             "__event_call__": __event_call__,
-            "__chat_id__": None,
-            "__message_id__": None,
-            "__model_knowledge__": [],
         }
 
-        tools_dict = await get_openwebui_tools(request, tool_ids, user, extra_params)
+        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}",
+                    f"转换 OpenWebUI 工具 '{tool_name}' 失败: {e}",
                     __event_call__,
                 )
 
@@ -596,6 +614,10 @@ class Pipe:
         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 工具服务器连接
@@ -635,13 +657,30 @@ class Pipe:
                 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": ["*"],  # 默认启用所有工具
+                    "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(
@@ -653,6 +692,7 @@ class Pipe:
         is_streaming: bool,
     ):
         """构建 Copilot SDK 的 SessionConfig"""
+        # 处理无限会话配置
         from copilot.types import SessionConfig, InfiniteSessionConfig
 
         infinite_session_config = None
@@ -663,34 +703,19 @@ class Pipe:
                 buffer_exhaustion_threshold=self.valves.BUFFER_THRESHOLD,
             )
 
-        system_message_config = None
-        if system_prompt_content or self.valves.ENFORCE_FORMATTING:
-            # 构建系统消息内容
-            system_parts = []
+        # 始终包含格式化指南（默认开启）
+        system_parts = []
+        if system_prompt_content:
+            system_parts.append(system_prompt_content)
+        system_parts.append(FORMATTING_GUIDELINES)
 
-            if system_prompt_content:
-                system_parts.append(system_prompt_content)
+        # 始终使用 'replace' 模式以确保完全控制并避免重复
+        system_message_config = {
+            "mode": "replace",
+            "content": "\n".join(system_parts),
+        }
 
-            if self.valves.ENFORCE_FORMATTING:
-                formatting_instruction = (
-                    "\n\n[格式化指南]\n"
-                    "在提供解释或描述时：\n"
-                    "- 使用清晰的段落分隔（双换行）\n"
-                    "- 将长句拆分为多个短句\n"
-                    "- 对多个要点使用项目符号或编号列表\n"
-                    "- 为主要部分添加标题（##、###）\n"
-                    "- 确保不同主题之间有适当的间距"
-                )
-                system_parts.append(formatting_instruction)
-                logger.info(f"[ENFORCE_FORMATTING] 已添加格式化指导到系统提示词")
-
-            if system_parts:
-                system_message_config = {
-                    "mode": "append",
-                    "content": "\n".join(system_parts),
-                }
-
-        # 准备会话配置参数
+        # 准备基础参数
         session_params = {
             "session_id": chat_id if chat_id else None,
             "model": real_model_id,
@@ -698,9 +723,9 @@ class Pipe:
             "tools": custom_tools,
             "system_message": system_message_config,
             "infinite_sessions": infinite_session_config,
-            # 注册权限处理 Hook
         }
 
+        # 注入 MCP 转换器
         mcp_servers = self._parse_mcp_servers()
         if mcp_servers:
             session_params["mcp_servers"] = mcp_servers
@@ -718,6 +743,10 @@ class Pipe:
             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]:
@@ -755,24 +784,37 @@ class Pipe:
         request_model: str,
         real_model_id: str,
         __event_call__=None,
-    ) -> tuple[Optional[str], str]:
+        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
-        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__,
-                    )
+        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:
@@ -791,14 +833,16 @@ class Pipe:
                             if system_prompt_content:
                                 system_prompt_source = f"model_db:{mid}"
                                 await self._emit_debug_log(
-                                    f"从模型数据库提取系统提示词（长度: {len(system_prompt_content)}）",
+                                    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
@@ -830,9 +874,16 @@ class Pipe:
 
         return system_prompt_content, system_prompt_source
 
-    async def _emit_debug_log(self, message: str, __event_call__=None):
+    async def _emit_debug_log(
+        self, message: str, __event_call__=None, debug_enabled: Optional[bool] = None
+    ):
         """在 DEBUG 开启时将日志输出到前端控制台。"""
-        if not self.valves.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}")
@@ -850,18 +901,25 @@ class Pipe:
         except Exception as e:
             logger.debug(f"[Copilot Pipe] 前端调试日志失败: {e}")
 
-    def _emit_debug_log_sync(self, message: str, __event_call__=None):
+    def _emit_debug_log_sync(
+        self, message: str, __event_call__=None, debug_enabled: Optional[bool] = None
+    ):
         """在非异步上下文中输出调试日志。"""
-        if not self.valves.DEBUG:
+        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}")
-            return
-
-        loop.create_task(self._emit_debug_log(message, __event_call__))
 
     async def _emit_native_message(self, message_data: dict, __event_call__=None):
         """发送原生 OpenAI 格式消息事件用于工具调用/结果。"""
@@ -885,7 +943,11 @@ class Pipe:
         return {}
 
     def _get_chat_context(
-        self, body: dict, __metadata__: Optional[dict] = None, __event_call__=None
+        self,
+        body: dict,
+        __metadata__: Optional[dict] = None,
+        __event_call__=None,
+        debug_enabled: bool = False,
     ) -> Dict[str, str]:
         """
         高度可靠的聊天上下文提取逻辑。
@@ -917,13 +979,17 @@ class Pipe:
         # 调试：记录 ID 来源
         if chat_id:
             self._emit_debug_log_sync(
-                f"提取到 ChatID: {chat_id} (来源: {source})", __event_call__
+                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__
+                f"警告: 未能提取到 ChatID。Body 键: {keys}",
+                __event_call__,
+                debug_enabled=debug_enabled,
             )
 
         return {
@@ -1002,14 +1068,16 @@ class Pipe:
                     )
 
                     # 格式化显示名称
+                    # 格式化显示名称
+                    clean_id = self._clean_model_id(m_id)
                     if multiplier == 0:
-                        display_name = f"-🔥 {m_id} (unlimited)"
+                        display_name = f"-🔥 {clean_id} (0x)"
                     else:
-                        display_name = f"-{m_id} ({multiplier}x)"
+                        display_name = f"-{clean_id} ({multiplier}x)"
 
                     models_with_info.append(
                         {
-                            "id": f"{self.id}-{m_id}",
+                            "id": f"{self.id}-{m_id}",  # Keep original prefix logic for ID
                             "name": display_name,
                             "multiplier": multiplier,
                             "raw_id": m_id,
@@ -1073,7 +1141,78 @@ class Pipe:
         await client.start()
         return client
 
-    def _setup_env(self, __event_call__=None):
+    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"]
@@ -1082,7 +1221,6 @@ class Pipe:
         found = False
         current_version = None
 
-        # 内部 helper: 获取版本
         def get_cli_version(path):
             try:
                 output = (
@@ -1092,18 +1230,18 @@ class Pipe:
                     .decode()
                     .strip()
                 )
-                # Copilot CLI 输出通常包含 "copilot version X.Y.Z" 或直接是版本号
+                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:
@@ -1111,85 +1249,79 @@ class Pipe:
                 found = True
                 current_version = get_cli_version(cli_path)
 
-        # 判断是否需要安装/更新
-        should_install = False
-        install_reason = ""
-
         if not found:
-            should_install = True
-            install_reason = "CLI 未找到"
-        elif target_version:
-            # 标准化版本号 (移除 'v' 前缀)
+            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 ""
 
-            if norm_target != norm_current:
-                should_install = True
-                install_reason = (
-                    f"版本不匹配 (当前: {current_version}, 目标: {target_version})"
-                )
+            # 只有当目标版本大于当前版本时才安装
+            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:
-            if self.valves.DEBUG:
-                self._emit_debug_log_sync(
-                    f"正在安装 Copilot CLI: {install_reason}...", __event_call__
-                )
+            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,
                 )
-
-                # 优先检查默认安装路径，其次是系统路径
-                if os.path.exists("/usr/local/bin/copilot"):
-                    cli_path = "/usr/local/bin/copilot"
-                    found = True
-                elif shutil.which("copilot"):
-                    cli_path = shutil.which("copilot")
-                    found = True
-
-                if found:
-                    current_version = get_cli_version(cli_path)
+                # 重新验证
+                current_version = get_cli_version(cli_path)
             except Exception as e:
-                if self.valves.DEBUG:
-                    self._emit_debug_log_sync(
-                        f"Copilot CLI 安装失败: {e}", __event_call__
-                    )
-
-        if found:
-            os.environ["COPILOT_CLI_PATH"] = cli_path
-            cli_dir = os.path.dirname(cli_path)
-            if cli_dir not in os.environ["PATH"]:
-                os.environ["PATH"] = f"{cli_dir}:{os.environ['PATH']}"
-
-            if self.valves.DEBUG:
                 self._emit_debug_log_sync(
-                    f"已找到 Copilot CLI: {cli_path} (版本: {current_version})",
-                    __event_call__,
-                )
-        else:
-            if self.valves.DEBUG:
-                self._emit_debug_log_sync(
-                    "错误: 未找到 Copilot CLI。相关 Agent 功能将被禁用。",
+                    f"CLI 安装失败: {e}",
                     __event_call__,
+                    debug_enabled=debug_enabled,
                 )
 
-        if self.valves.GH_TOKEN:
-            os.environ["GH_TOKEN"] = self.valves.GH_TOKEN
-            os.environ["GITHUB_TOKEN"] = self.valves.GH_TOKEN
-        else:
-            if self.valves.DEBUG:
-                self._emit_debug_log_sync("Warning: GH_TOKEN 未设置。", __event_call__)
+        # 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)
 
-        self._sync_mcp_config(__event_call__)
-
-    def _process_images(self, messages, __event_call__=None):
+    def _process_images(
+        self, messages, __event_call__=None, debug_enabled: bool = False
+    ):
         attachments = []
         text_content = ""
         if not messages:
@@ -1219,74 +1351,20 @@ class Pipe:
                                 }
                             )
                             self._emit_debug_log_sync(
-                                f"Image processed: {file_path}", __event_call__
+                                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__
+                                f"Image error: {e}",
+                                __event_call__,
+                                debug_enabled=debug_enabled,
                             )
         else:
             text_content = str(content)
         return text_content, attachments
 
-    def _sync_copilot_config(self, reasoning_effort: str, __event_call__=None):
-        """
-        动态更新 ~/.copilot/config.json 中的 reasoning_effort 设置。
-        如果 API 注入被忽略，这提供了最后的保障。
-        """
-        if not reasoning_effort:
-            return
-
-        effort = reasoning_effort
-
-        # 检查模型对 xhigh 的支持
-        # 目前仅 gpt-5.2-codex 支持 xhigh
-        # 在 _sync_copilot_config 中很难获得准确的当前模型 ID，
-        # 因此这里我们放宽限制，允许写入 xhigh。
-        # 如果模型不支持，Copilot CLI 可能会忽略或降级处理，但这比在这里硬编码判断更安全，
-        # 因为获取当前请求的 body 需要修改函数签名。
-
-        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__)
-
-    def _sync_mcp_config(self, __event_call__=None):
-        """已弃用：MCP 配置现在通过 SessionConfig 动态处理。"""
-        pass
-
     # ==================== 内部实现 ====================
     # _pipe_impl() 包含主请求处理逻辑。
     # ================================================
@@ -1352,22 +1430,28 @@ class Pipe:
         except Exception as e:
             self._emit_debug_log_sync(f"配置同步检查失败: {e}", __event_call__)
 
-    async def _update_copilot_cli(self, cli_path: str, __event_call__=None):
-        """异步任务：如果需要则更新 Copilot CLI。"""
+    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:
-            # 检查频率（例如：每小时一次）
-            now = time.time()
-            if now - self._last_update_check < 3600:
-                return
-
-            self._last_update_check = now
-
-            if self.valves.DEBUG:
-                self._emit_debug_log_sync(
-                    "触发异步 Copilot CLI 更新检查...", __event_call__
-                )
+            self._emit_debug_log_sync(
+                "正在检查 Copilot CLI 更新...",
+                __event_call__,
+                debug_enabled=debug_enabled,
+            )
 
             # 我们创建一个子进程来运行更新
             process = await asyncio.create_subprocess_exec(
@@ -1379,16 +1463,23 @@ class Pipe:
 
             stdout, stderr = await process.communicate()
 
-            if self.valves.DEBUG and process.returncode == 0:
-                self._emit_debug_log_sync("Copilot CLI 更新检查完成", __event_call__)
-            elif process.returncode != 0 and self.valves.DEBUG:
+            if process.returncode == 0:
                 self._emit_debug_log_sync(
-                    f"Copilot CLI 更新失败: {stderr.decode()}", __event_call__
+                    "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:
-            if self.valves.DEBUG:
-                self._emit_debug_log_sync(f"CLI 更新任务异常: {e}", __event_call__)
+            self._emit_debug_log_sync(
+                f"CLI 更新任务异常: {e}", __event_call__, debug_enabled=debug_enabled
+            )
 
     async def _pipe_impl(
         self,
@@ -1398,26 +1489,7 @@ class Pipe:
         __event_emitter__=None,
         __event_call__=None,
     ) -> Union[str, AsyncGenerator]:
-        self._setup_env(__event_call__)
-
-        cwd = self._get_workspace_dir()
-        if self.valves.DEBUG:
-            await self._emit_debug_log(f"当前工作目录: {cwd}", __event_call__)
-
-        # CLI Update Check
-        if os.environ.get("COPILOT_CLI_PATH"):
-            asyncio.create_task(
-                self._update_copilot_cli(os.environ["COPILOT_CLI_PATH"], __event_call__)
-            )
-
-        if not self.valves.GH_TOKEN:
-            return "Error: 请在 Valves 中配置 GH_TOKEN。"
-
-        # 解析用户选择的模型
-        request_model = body.get("model", "")
-        real_model_id = request_model
-
-        # 确定有效的推理强度和调试设置
+        # 1. 首先确定有效的调试设置
         if __user__:
             raw_valves = __user__.get("valves", {})
             if isinstance(raw_valves, self.UserValves):
@@ -1428,90 +1500,235 @@ class Pipe:
                 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
         )
 
-        # Sync config for reasoning effort (Legacy/Fallback)
-        self._sync_copilot_config(effective_reasoning_effort, __event_call__)
-
-        # 如果用户启用了 DEBUG，则覆盖全局设置
-        if user_valves.DEBUG:
-            self.valves.DEBUG = True
-
-        # 处理 SHOW_THINKING（优先使用用户设置）
+        # 确定显示思考过程
         show_thinking = (
             user_valves.SHOW_THINKING
             if user_valves.SHOW_THINKING is not None
             else self.valves.SHOW_THINKING
         )
 
-        if request_model.startswith(f"{self.id}-"):
-            real_model_id = request_model[len(f"{self.id}-") :]
-            await self._emit_debug_log(
-                f"使用选择的模型: {real_model_id}", __event_call__
+        # 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,
             )
-        elif __metadata__ and __metadata__.get("base_model_id"):
-            base_model_id = __metadata__.get("base_model_id", "")
-            if base_model_id.startswith(f"{self.id}-"):
-                real_model_id = base_model_id[len(f"{self.id}-") :]
-                await self._emit_debug_log(
-                    f"使用基础模型: {real_model_id} (继承自自定义模型 {request_model})",
-                    __event_call__,
-                )
 
         messages = body.get("messages", [])
         if not messages:
-            return "No messages."
+            return "没有消息。"
 
-        # 使用改进的助手获取 Chat ID
-        chat_ctx = self._get_chat_context(body, __metadata__, __event_call__)
+        # 获取 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__
+            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)}, 预览: {preview}）",
+                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__)
+        await self._emit_debug_log(
+            f"流式请求: {is_streaming}",
+            __event_call__,
+            debug_enabled=effective_debug,
+        )
 
-        # 处理多模态（图像）和提取最后的消息文本
-        last_text, attachments = self._process_images(messages, __event_call__)
+        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)} 个自定义工具: {tool_names}",
+                    f"启用 {len(custom_tools)} 个工具 (自定义/内置)",
                     __event_call__,
                 )
-                # 详细打印每个工具的描述 (用于调试)
-                if self.valves.DEBUG:
-                    for t in custom_tools:
-                        await self._emit_debug_log(
-                            f"📋 工具详情: {t.name} - {t.description[:100]}...",
-                            __event_call__,
-                        )
 
-            # 检查 MCP 服务器
             mcp_servers = self._parse_mcp_servers()
             mcp_server_names = list(mcp_servers.keys()) if mcp_servers else []
             if mcp_server_names:
@@ -1521,121 +1738,148 @@ class Pipe:
                 )
             else:
                 await self._emit_debug_log(
-                    "ℹ️ 未在 OpenWebUI 连接中发现 MCP 服务器。",
+                    "ℹ️ 未发现 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:
-                    # 复用已解析的 mcp_servers
-                    resume_config = (
-                        {"mcp_servers": mcp_servers} if mcp_servers else None
-                    )
-                    # 尝试直接使用 chat_id 作为 session_id 恢复会话
-                    session = (
-                        await client.resume_session(chat_id, resume_config)
-                        if resume_config
-                        else await client.resume_session(chat_id)
-                    )
+                    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"已通过 ChatID 恢复会话: {chat_id}", __event_call__
+                        f"成功恢复会话 {chat_id}，模型: {real_model_id}",
+                        __event_call__,
                     )
-
-                    # 显示工作空间信息（如果可用）
-                    if self.valves.DEBUG:
-                        if session.workspace_path:
-                            await self._emit_debug_log(
-                                f"会话工作空间: {session.workspace_path}",
-                                __event_call__,
-                            )
-
                     is_new_session = False
                 except Exception as e:
-                    # 恢复失败，磁盘上可能不存在该会话
-                    reasoning_effort = (effective_reasoning_effort,)
                     await self._emit_debug_log(
-                        f"会话 {chat_id} 不存在或已过期 ({str(e)})，将创建新会话。",
+                        f"会话 {chat_id} 未找到或恢复失败 ({str(e)})，正在创建新会话。",
                         __event_call__,
                     )
-                    session = None
 
             if session is None:
-                session_config = self._build_session_config(
-                    chat_id,
-                    real_model_id,
-                    custom_tools,
-                    system_prompt_content,
-                    is_streaming,
-                )
+                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:
-                    await self._emit_debug_log(
-                        f"配置系统消息（模式: append）",
-                        __event_call__,
-                    )
+                    system_parts.append(system_prompt_content.strip())
+                system_parts.append(FORMATTING_GUIDELINES)
+                final_system_msg = "\n".join(system_parts)
 
-                # 显示系统配置预览
-                if system_prompt_content or self.valves.ENFORCE_FORMATTING:
-                    preview_parts = []
-                    if system_prompt_content:
-                        preview_parts.append(
-                            f"自定义提示词: {system_prompt_content[:100]}..."
-                        )
-                    if self.valves.ENFORCE_FORMATTING:
-                        preview_parts.append("格式化指导: 已启用")
+                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 isinstance(session_config, dict):
-                        system_config = session_config.get("system_message", {})
-                    else:
-                        system_config = getattr(session_config, "system_message", None)
+                if provider_config:
+                    session_params["provider"] = provider_config
+                
+                if mcp_servers:
+                    session_params["mcp_servers"] = mcp_servers
 
-                    if isinstance(system_config, dict):
-                        full_content = system_config.get("content", "")
-                    else:
-                        full_content = ""
+                session_config = SessionConfig(**session_params)
 
-                    await self._emit_debug_log(
-                        f"系统消息配置 - {', '.join(preview_parts)} (总长度: {len(full_content)} 字符)",
-                        __event_call__,
-                    )
+                await self._emit_debug_log(
+                    f"注入系统提示词到新会话 (长度: {len(final_system_msg)})",
+                    __event_call__,
+                )
 
                 session = await client.create_session(config=session_config)
 
-                # 获取新会话 ID
-                new_sid = getattr(session, "session_id", getattr(session, "id", None))
-                await self._emit_debug_log(f"创建了新会话: {new_sid}", __event_call__)
+                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,
+                )
 
-                # 显示新会话的工作空间信息
-                if self.valves.DEBUG:
-                    if session.workspace_path:
-                        await self._emit_debug_log(
-                            f"会话工作空间: {session.workspace_path}",
-                            __event_call__,
-                        )
-
-            # 构建 Prompt（基于会话：仅发送最新用户输入）
-            prompt = self._apply_formatting_hint(last_text)
+            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):
-                # 确定 UI 显示的会话状态消息
                 init_msg = ""
-                if self.valves.DEBUG:
-                    if is_new_session:
-                        new_sid = getattr(
-                            session, "session_id", getattr(session, "id", "unknown")
-                        )
-                        init_msg = f"> [Debug] 创建了新会话: {new_sid}\n"
-                    else:
-                        init_msg = f"> [Debug] 已通过 ChatID 恢复会话: {chat_id}\n"
-
+                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,
@@ -1644,23 +1888,22 @@ class Pipe:
                     __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 "Empty response."
+                    return response.data.content if response else "无响应。"
                 finally:
-                    # 清理：如果没有 chat_id（临时会话），销毁会话
                     if not chat_id:
                         try:
                             await session.destroy()
-                        except Exception as cleanup_error:
-                            await self._emit_debug_log(
-                                f"会话清理警告: {cleanup_error}",
-                                __event_call__,
-                            )
+                        except:
+                            pass
         except Exception as e:
-            await self._emit_debug_log(f"请求错误: {e}", __event_call__)
+            await self._emit_debug_log(
+                f"请求错误: {e}", __event_call__, debug_enabled=effective_debug
+            )
             return f"Error: {str(e)}"
         finally:
             if should_stop_client:
@@ -1678,6 +1921,7 @@ class Pipe:
         __event_call__=None,
         reasoning_effort: str = "",
         show_thinking: bool = True,
+        debug_enabled: bool = False,
     ) -> AsyncGenerator:
         """
         从 Copilot SDK 流式传输响应，处理各种事件类型。