diff --git a/.agent/workflows/plugin-development.md b/.agent/workflows/plugin-development.md
index 70281fc..a34704b 100644
--- a/.agent/workflows/plugin-development.md
+++ b/.agent/workflows/plugin-development.md
@@ -45,8 +45,12 @@ When adding or updating a plugin, you **MUST** update the following documentatio
 
 ### Plugin Directory
 
-- `README.md`: Update version, description, and usage. **Explicitly describe new features in a prominent position at the beginning.**
-- `README_CN.md`: Update version, description, and usage. **Explicitly describe new features in a prominent position at the beginning.**
+- `README.md`: Update version, description, and usage.
+  - **Key Capabilities**: **MUST** include ALL core functionalities and features. Do not only list new features in "What's New".
+  - **What's New**: Explicitly describe only the latest changes/updates in a prominent position at the beginning. This section is dynamic and changes with versions.
+- `README_CN.md`: Update version, description, and usage.
+  - **核心功能 (Key Capabilities)**: **必须**包含所有核心功能和特性，不能只在 "What's New" 中列出。
+  - **最新更新 (What's New)**: 在开头显眼位置明确描述最新的更改/更新。此部分是动态的，随版本变化。
 
 ### Global Documentation (`docs/`)
 
diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
index fd18350..65469b2 100644
--- a/.github/copilot-instructions.md
+++ b/.github/copilot-instructions.md
@@ -889,6 +889,9 @@ Filter 实例是**单例 (Singleton)**。
 - [ ] 使用 logging 而非 print
 - [ ] 测试双语界面
 - [ ] **一致性检查**: 确保文档、代码、README 同步
+- [ ] **README 结构**: 
+    - **Key Capabilities** (英文) / **核心功能** (中文): 必须包含所有核心功能
+    - **What's New** (英文) / **最新更新** (中文): 仅包含最新版本的变更信息
 
 ### 2. 🔄 一致性维护 (Consistency Maintenance)
 
diff --git a/docs/plugins/filters/github-copilot-sdk-files-filter.md b/docs/plugins/filters/github-copilot-sdk-files-filter.md
new file mode 100644
index 0000000..12c2f84
--- /dev/null
+++ b/docs/plugins/filters/github-copilot-sdk-files-filter.md
@@ -0,0 +1,53 @@
+# GitHub Copilot SDK Files Filter (v0.1.2)
+
+This is a dedicated **companion filter plugin** designed specifically for the [GitHub Copilot SDK Pipe](../pipes/github-copilot-sdk.md).
+
+Its core mission is to **protect user-uploaded files from being "pre-processed" by the OpenWebUI core system, ensuring that the Copilot Agent receives the raw files for autonomous analysis.**
+
+## 🎯 Why is this needed?
+
+In OpenWebUI's default workflow, when you upload a file (e.g., PDF, Excel, Python script), OpenWebUI automatically initiates a **RAG (Retrieval-Augmented Generation)** process: parsing the file, vectorizing it, extracting text, and injecting it into the prompt.
+
+While useful for standard models, this is often disruptive for a **Copilot SDK Agent**:
+
+1. **Agent Needs Raw Files**: The Agent may need to run Python code to read an Excel file or analyze a full directory structure, not chopped-up text fragments.
+2. **Context Pollution**: Large amounts of text injected by RAG consume tokens and can confuse the Agent about "where the file is."
+3. **Conflicts**: If you have other multimodal plugins installed (like Gemini Filter), they might compete for file processing rights.
+
+**This plugin acts as a "bodyguard" to solve these issues.**
+
+## 🚀 How it Works
+
+When you select a Copilot model (name containing `copilot_sdk`) in OpenWebUI and send a file:
+
+1. **Intercept**: This plugin runs with high priority (Priority 0), before RAG and other filters.
+2. **Relocate**: Detecting a Copilot model, it moves the `files` list from the request to a secure custom field `copilot_files`.
+3. **Hide**: It clears the original `files` field.
+4. **Status Update**: It emits a status message "Managed X files for Copilot (RAG Bypassed)" to the UI.
+5. **Pass**: The OpenWebUI core sees an empty `files` list and **does not trigger RAG**.
+6. **Deliver**: The subsequent [Copilot SDK Pipe](../pipes/github-copilot-sdk.md) plugin checks `copilot_files`, retrieves file information, and automatically copies them into the Agent's isolated workspace.
+
+## 📦 Installation & Configuration
+
+### 1. Installation
+
+Import this plugin on the OpenWebUI **Functions** page.
+
+### 2. Enable
+
+Ensure this Filter is enabled globally or in chat settings.
+
+### 3. Configuration (Valves)
+
+Default settings work for most users unless you have specific needs:
+
+| Parameter | Description | Default |
+| :--- | :--- | :--- |
+| **priority** | Execution priority of the filter. **Must be lower than OpenWebUI RAG priority**. | `0` |
+| **target_model_keyword** | Keyword to identify Copilot models. Only models containing this keyword will trigger file interception. | `copilot_sdk` |
+
+## ⚠️ Important Notes
+
+* **Must be used with Copilot SDK Pipe**: If you install this plugin without the main Pipe plugin, uploaded files will simply "disappear" (as no subsequent plugin will look for them in `copilot_files`).
+* **Gemini Filter Compatibility**: This plugin is fully compatible with the Gemini Multimodal Filter. As long as the priority is set correctly (This Plugin < Gemini Plugin), they can coexist without interference.
+* **Physical File Path**: Ensure the `OPENWEBUI_UPLOAD_PATH` is correctly set in the Pipe plugin Valves for the actual file transport to work.
diff --git a/docs/plugins/filters/github-copilot-sdk-files-filter.zh.md b/docs/plugins/filters/github-copilot-sdk-files-filter.zh.md
new file mode 100644
index 0000000..615c50c
--- /dev/null
+++ b/docs/plugins/filters/github-copilot-sdk-files-filter.zh.md
@@ -0,0 +1,53 @@
+# GitHub Copilot SDK 文件过滤器 (v0.1.2)
+
+这是一个专门为 [GitHub Copilot SDK Pipe](../pipes/github-copilot-sdk.zh.md) 设计的**伴侣过滤器插件**。
+
+它的核心使命是：**保护用户上传的文件不被 OpenWebUI 核心系统“抢先处理”，确保 Copilot Agent 能够接收到原始文件并进行自主分析。**
+
+## 🎯 为什么需要它？
+
+在 OpenWebUI 的默认流程中，当你上传一个文件（如 PDF、Excel、Python 脚本）时，OpenWebUI 会自动启动 **RAG（检索增强生成）** 流程：解析文件、向量化、提取文本并注入到提示词中。
+
+虽然这对普通模型很有用，但对于 **Copilot SDK Agent** 来说，这往往是干扰：
+
+1. **Agent 需要原始文件**：Agent 可能需要运行 Python 代码读取 Excel，或者分析完整的代码结构，而不是被切碎的文本片段。
+2. **上下文污染**：RAG 注入的大量文本会消耗 Token，且容易让 Agent 混淆“文件在哪里”。
+3. **冲突**：如果你同时安装了其他多模态插件（如 Gemini Filter），它们可能会争夺文件的处理权。
+
+**本插件就是为了解决这个问题而生的“保镖”。**
+
+## 🚀 功能原理
+
+当你在 OpenWebUI 中选择了一个 Copilot 模型（名称包含 `copilot_sdk`）并发送文件时：
+
+1. **拦截 (Intercept)**：本插件会以极高的优先级（Priority 0）运行，先于 RAG 和其他过滤器。
+2. **搬运 (Relocate)**：它检测到模型是 Copilot，便将请求中的 `files`（文件列表）移动到一个安全的自定义字段 `copilot_files` 中。
+3. **隐身 (Hide)**：它清空原始的 `files` 字段。
+4. **状态更新**: 它会在 UI 中发出“已为 Copilot 管理 X 个文件 (已绕过 RAG)”的状态消息。
+5. **放行 (Pass)**：OpenWebUI 核心看到 `files` 为空，便**不会触发 RAG**。
+6. **交付 (Deliver)**：后续的 [Copilot SDK Pipe](../pipes/github-copilot-sdk.zh.md) 插件会检查 `copilot_files`，从中获取文件信息，并自动将其复制到 Agent 的独立工作区中。
+
+## 📦 安装与配置
+
+### 1. 安装
+
+在 OpenWebUI 的 **Functions** 页面导入此插件。
+
+### 2. 启用
+
+确保在全局或对话设置中启用了此 Filter。
+
+### 3. 配置 (Valves)
+
+通常不需要修改默认配置，除非你有特殊需求：
+
+| 参数 | 说明 | 默认值 |
+| :--- | :--- | :--- |
+| **priority** | 过滤器的执行优先级。**必须小于 OpenWebUI RAG 的优先级**。 | `0` |
+| **target_model_keyword** | 用于识别 Copilot 模型的关键词。只有包含此关键词的模型才会触发 file 拦截。 | `copilot_sdk` |
+
+## ⚠️ 注意事项
+
+* **必须配合 Copilot SDK Pipe 使用**：如果你没有安装主 Pipe 插件，本插件将导致上传的文件“凭空消失”（因为没有后续插件去 `copilot_files` 里找它们）。
+* **Gemini Filter 兼容性**：本插件已完美兼容 Gemini 多模态过滤器。只要优先级设置正确（本插件 < Gemini 插件），它们可以共存互不干扰。
+* **物理文件路径**: 确保在 Pipe 插件的 Valves 中正确设置了 `OPENWEBUI_UPLOAD_PATH`，以便文件自动搬运功能正常工作。
diff --git a/docs/plugins/filters/index.md b/docs/plugins/filters/index.md
index deb8e52..cc0db66 100644
--- a/docs/plugins/filters/index.md
+++ b/docs/plugins/filters/index.md
@@ -16,7 +16,7 @@ Filters act as middleware in the message pipeline:
 
 <div class="grid cards" markdown>
 
--   :material-arrow-collapse-vertical:{ .lg .middle } **Async Context Compression**
+- :material-arrow-collapse-vertical:{ .lg .middle } **Async Context Compression**
 
     ---
 
@@ -26,7 +26,7 @@ Filters act as middleware in the message pipeline:
 
     [:octicons-arrow-right-24: Documentation](async-context-compression.md)
 
--   :material-text-box-plus:{ .lg .middle } **Context Enhancement**
+- :material-text-box-plus:{ .lg .middle } **Context Enhancement**
 
     ---
 
@@ -36,7 +36,7 @@ Filters act as middleware in the message pipeline:
 
     [:octicons-arrow-right-24: Documentation](context-enhancement.md)
 
--   :material-folder-refresh:{ .lg .middle } **Folder Memory**
+- :material-folder-refresh:{ .lg .middle } **Folder Memory**
 
     ---
 
@@ -46,7 +46,7 @@ Filters act as middleware in the message pipeline:
 
     [:octicons-arrow-right-24: Documentation](folder-memory.md)
 
--   :material-format-paint:{ .lg .middle } **Markdown Normalizer**
+- :material-format-paint:{ .lg .middle } **Markdown Normalizer**
 
     ---
 
@@ -56,7 +56,7 @@ Filters act as middleware in the message pipeline:
 
     [:octicons-arrow-right-24: Documentation](markdown_normalizer.md)
 
--   :material-merge:{ .lg .middle } **Multi-Model Context Merger**
+- :material-merge:{ .lg .middle } **Multi-Model Context Merger**
 
     ---
 
@@ -66,7 +66,7 @@ Filters act as middleware in the message pipeline:
 
     [:octicons-arrow-right-24: Documentation](multi-model-context-merger.md)
 
--   :material-file-document-multiple:{ .lg .middle } **Web Gemini Multimodal Filter**
+- :material-file-document-multiple:{ .lg .middle } **Web Gemini Multimodal Filter**
 
     ---
 
@@ -76,6 +76,16 @@ Filters act as middleware in the message pipeline:
 
     [:octicons-arrow-right-24: Documentation](web-gemini-multimodel.md)
 
+- :material-file-shield:{ .lg .middle } **Copilot SDK Files Filter**
+
+    ---
+
+    A specialized filter to bypass OpenWebUI's default RAG for GitHub Copilot SDK models. It ensures the Agent receives raw files for autonomous analysis.
+
+    **Version:** 0.1.2
+
+    [:octicons-arrow-right-24: Documentation](github-copilot-sdk-files-filter.md)
+
 </div>
 
 ---
diff --git a/docs/plugins/filters/index.zh.md b/docs/plugins/filters/index.zh.md
index e565c9e..5e6eb56 100644
--- a/docs/plugins/filters/index.zh.md
+++ b/docs/plugins/filters/index.zh.md
@@ -16,7 +16,7 @@ Filter 充当消息管线中的中间件：
 
 <div class="grid cards" markdown>
 
--   :material-arrow-collapse-vertical:{ .lg .middle } **Async Context Compression**
+- :material-arrow-collapse-vertical:{ .lg .middle } **Async Context Compression**
 
     ---
 
@@ -26,7 +26,7 @@ Filter 充当消息管线中的中间件：
 
     [:octicons-arrow-right-24: 查看文档](async-context-compression.md)
 
--   :material-text-box-plus:{ .lg .middle } **Context Enhancement**
+- :material-text-box-plus:{ .lg .middle } **Context Enhancement**
 
     ---
 
@@ -36,7 +36,7 @@ Filter 充当消息管线中的中间件：
 
     [:octicons-arrow-right-24: 查看文档](context-enhancement.md)
 
--   :material-folder-refresh:{ .lg .middle } **Folder Memory**
+- :material-folder-refresh:{ .lg .middle } **Folder Memory**
 
     ---
 
@@ -46,7 +46,7 @@ Filter 充当消息管线中的中间件：
 
     [:octicons-arrow-right-24: 查看文档](folder-memory.zh.md)
 
--   :material-format-paint:{ .lg .middle } **Markdown Normalizer**
+- :material-format-paint:{ .lg .middle } **Markdown Normalizer**
 
     ---
 
@@ -56,6 +56,16 @@ Filter 充当消息管线中的中间件：
 
     [:octicons-arrow-right-24: 查看文档](markdown_normalizer.zh.md)
 
+- :material-file-shield:{ .lg .middle } **Copilot SDK 文件过滤器**
+
+    ---
+
+    专门用于绕过 OpenWebUI 默认 RAG 机制的过滤器，针对 GitHub Copilot SDK 模型。确保 Agent 能够接收到原始文件进行自主分析。
+
+    **版本：** 0.1.2
+
+    [:octicons-arrow-right-24: 查看文档](github-copilot-sdk-files-filter.zh.md)
+
 </div>
 
 ---
diff --git a/docs/plugins/pipes/github-copilot-sdk-deep-dive.md b/docs/plugins/pipes/github-copilot-sdk-deep-dive.md
new file mode 100644
index 0000000..a0de8a4
--- /dev/null
+++ b/docs/plugins/pipes/github-copilot-sdk-deep-dive.md
@@ -0,0 +1,80 @@
+# GitHub Copilot SDK Plugin Deep Dive
+
+**Version:** 0.6.0 | **Author:** [Fu-Jie](https://github.com/Fu-Jie/awesome-openwebui) | **Status:** Production-Ready
+
+The GitHub Copilot SDK plugin is far more than a simple API proxy; it is a highly integrated **Intelligent Agent Runtime Environment**. This document explores the core features, implementation details, technical architecture, and security design that define its capabilities.
+
+---
+
+## 🚀 1. Feature Catalog
+
+The plugin implements advanced capabilities that go far beyond standard API calls:
+
+- **✅ Physical Workspace Management**: Automatically creates isolated directories for each chat session to manage uploaded files and Agent-generated scripts.
+- **✅ Real-time TODO Sync**: Mounts to the OpenWebUI database to persist Agent plans directly into a UI progress bar, ensuring transparency for long-running tasks.
+- **✅ Cross-Ecosystem Tool Bridging**: Translates OpenWebUI Search, Python interpreters, and custom MCP tools into native Copilot capabilities.
+- **✅ Intelligent File Transport**: Ensures the Agent can access raw files (Excel, PDF, Code) like a local developer through physical file duplication.
+- **✅ Chain of Thought Streaming**: Full support for rendering the model's reasoning/thinking process in real-time.
+- **✅ BYOK with Plugin Power**: Connect external OpenAI/Anthropic models while retaining all the plugin's workspace and tool management features.
+
+---
+
+## 🎯 2. Use Cases: Beyond Basic Chat
+
+With these features, the plugin excels in complex, real-world scenarios:
+
+### 📁 Autonomous Repository Maintenance (Agentic DevOps)
+>
+> **Action**: Upload a Zip archive containing a codebase with bugs.
+> **Utility**: The Agent extracts the archive, uses `bash` to navigate and search, applies fixes via the `edit` tool, and runs tests to verify the solution—all within its isolated sandbox.
+
+### 📊 Deep Data Analysis (Data Scientist Agent)
+>
+> **Action**: Upload multiple heavy Excel spreadsheets.
+> **Utility**: By bypassing RAG (via the filter), the Agent loads raw files directly into its Python interpreter, performs cross-table calculations, and generates analytical charts presented via Artifacts.
+
+### 📝 Strategic Task Management
+>
+> **Action**: "Develop a full architecture for a new mobile app."
+> **Utility**: The plugin captures the Agent's breakdown of 20+ sub-tasks. The persistent progress bar reflects ongoing progress (e.g., "Designing Schema", "Drafting API"), providing clarity during long marathons.
+
+---
+
+## 🛡️ 3. Technical Architecture
+
+### 3.1 Three-Layer Sandbox Isolation
+
+To prevent data leakage in multi-user environments, the plugin enforces a strict physical directory structure:
+`/app/backend/data/copilot_workspace/{user_id}/{chat_id}/`
+
+- **Constraint**: Code execution and file storage are confined to the session-specific folder.
+- **Persistence**: Data remains valid across container restarts due to volume mounting.
+
+### 3.2 Dynamic Tool Bridging
+
+How does Copilot "learn" to use OpenWebUI tools?
+
+1. **Introspection**: Analyzes docstrings and type hints of OpenWebUI tools.
+2. **Schema Generation**: Dynamically creates JSON descriptions compliant with the GitHub Copilot specification.
+3. **Routing**: Handles parameter validation, identity injection, and result forwarding between systems.
+
+### 3.3 Event-Driven TODO Hub
+
+The plugin captures internal SDK events to power the UI progress bar:
+
+- **Interceptor**: Listens for `tool.execution_complete` events for the `update_todo` tool.
+- **Storage**: Syncs project metrics directly to the `chat_todos` table in the OpenWebUI database (SQLite/PostgreSQL).
+
+---
+
+## ⚡ 4. Runtime Performance
+
+- **Anti-Shake Logic**: Environment checks happen only once every 24 hours per process, preventing redundant system calls.
+- **Tool Caching**: Persists tool definitions across sessions to reduce overhead, improving initial response times by up to 40%.
+
+---
+
+## 🛠️ 5. Development Best Practices
+
+1. **Use the Filter**: Always pair with `github_copilot_sdk_files_filter` to ensure files reach the Agent in their original binary form.
+2. **File-First Execution**: Encourage the Agent to "write code to file and execute" rather than relying on direct interactive shell input for complex logic.
diff --git a/docs/plugins/pipes/github-copilot-sdk-deep-dive.zh.md b/docs/plugins/pipes/github-copilot-sdk-deep-dive.zh.md
new file mode 100644
index 0000000..b8ccabe
--- /dev/null
+++ b/docs/plugins/pipes/github-copilot-sdk-deep-dive.zh.md
@@ -0,0 +1,80 @@
+# GitHub Copilot SDK 插件深度解析 (Deep Dive)
+
+**版本:** 0.6.0 | **作者:** [Fu-Jie](https://github.com/Fu-Jie/awesome-openwebui) | **状态:** 生产级
+
+GitHub Copilot SDK 插件不仅仅是一个 API 转发器，它是一个高度集成的 **智能 Agent 运行环境**。本文将从功能实现、应用场景、技术架构及安全设计四个维度，深入解析这一插件的强大之处。
+
+---
+
+## 🚀 1. 核心功能清单 (Feature Catalog)
+
+插件通过深度集成实现了以下超越普通 API 调用的能力：
+
+- **✅ 物理级工作区管理**: 自动为每个对话创建独立的物理目录，管理用户上传和 Agent 生成的所有文件。
+- **✅ 实时 TODO 状态同步**: 通过数据库挂载，实时将 Agent 的计划提取到 UI 进度条中，解决长任务透明度问题。
+- **✅ 跨生态工具桥接**: 自动将 OpenWebUI 的搜索、Python 运行环境和自定义 MCP 工具转化为 Copilot 原生工具。
+- **✅ 智能文件搬运**: 物理级文件副本传输，确保 Agent 可以像本地开发者一样访问 Excel、PDF 和代码仓库。
+- **✅ 思考过程可见性**: 完整模拟 GitHub Copilot 的思维链 (Thinking Process) 流式展示。
+- **✅ BYOK 二次鉴权**: 支持在 Copilot 框架内接入外部 OpenAI/Anthropic 模型，同时享受插件的所有增强功能。
+
+---
+
+## 🎯 2. 这个插件能用来干什么？ (Use Cases)
+
+基于上述功能，该插件可以胜任以下复杂场景：
+
+### 📁 场景 A：全自动代码仓库维护 (Agentic DevOps)
+>
+> **操作**: 上传一个包含 Bug 的 Zip 压缩包。
+> **用途**: Agent 会自动解密、解压，使用 `bash` 定位问题，调用 `edit` 修改代码，最后运行测试脚本。这一切都在隔离沙箱中完成，你只需要审核最终的补丁。
+
+### 📊 场景 B：深度财务数据审计 (Data Analyst Agent)
+>
+> **操作**: 上传一年的 Excel 财务报表。
+> **用途**: 绕过传统 RAG 的文本切片限制，Agent 直接通过 Python 脚本加载原始表格，进行跨表计算和逻辑校验，并生成可视化图表。
+
+### 📝 场景 C：复杂长任务进度追踪 (Project Manager)
+>
+> **操作**: 输入“请基于以下需求文档编写一个完整的 Web 后端方案”。
+> **用途**: 插件捕捉 Agent 拆解的 20+ 个子任务。顶部的实时进度条会告诉你它正在“设计数据库”还是“编写认证逻辑”，确保你对黑盒任务了如指掌。
+
+---
+
+## 🛡️ 3. 技术架构设计 (Technical Architecture)
+
+### 3.1 三层物理安全隔离 (Workspace Isolation)
+
+为了确保多用户环境下的数据安全，插件强制执行以下物理路径：
+`/app/backend/data/copilot_workspace/{user_id}/{chat_id}/`
+
+- **隔离性**: 进程内代码执行被严格约束在 `chat_id` 目录下。
+- **持久性**: 即使容器重启，挂载路径下的工作成果依然保留。
+
+### 3.2 零配置工具桥接 (Dynamic Tool Bridging)
+
+插件如何让 Copilot “学会”使用 OpenWebUI 的工具？
+
+1. **内省 (Introspection)**: 实时读取工具的 `docstring` 和 `type hints`。
+2. **动态转换**: 生成符合 GitHub Copilot 规范的工具描述符。
+3. **双向路由**: 处理参数校验、身份注入（如认证头）以及结果回传。
+
+### 3.3 数据库集成与事件驱动
+
+插件通过监听 `NDJSON` 事件流，实现状态同步：
+
+- **监听器**: 实时过滤 `tool.execution_complete` 事件。
+- **持久层**: 使用 OpenWebUI 核心相同的 `SQLAlchemy` 引擎操作 `chat_todos` 表。
+
+---
+
+## ⚡ 4. 性能优化 (Performance)
+
+- **环境检查防抖**: 全局类变量保护，版本核对周期为 24 小时，避免高并发下的 I/O 争抢。
+- **工具定义缓存**: 仅在变更时刷新工具元数据，首包响应速度（TTFB）提升约 40%。
+
+---
+
+## 🛠️ 5. 开发建议 (Best Practices)
+
+1. **协同工作**: 必须安装 `github_copilot_sdk_files_filter` 以确保文件以“二进制原文”而非“RAG 切片”传递。
+2. **Python 范式**: 鼓励 Agent 采取“写文件 -> 运行文件”的模式，而非交互式 Shell 输出，以获得更好的执行稳定性。
diff --git a/docs/plugins/pipes/github-copilot-sdk.md b/docs/plugins/pipes/github-copilot-sdk.md
index fe4f928..9e8298d 100644
--- a/docs/plugins/pipes/github-copilot-sdk.md
+++ b/docs/plugins/pipes/github-copilot-sdk.md
@@ -1,116 +1,118 @@
 # GitHub Copilot SDK Pipe for OpenWebUI
 
-**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
+**Author:** [Fu-Jie](https://github.com/Fu-Jie/awesome-openwebui) | **Version:** 0.6.0 | **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 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.
+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 with **strict User & Chat-level Workspace Isolation**.
+
+> [!IMPORTANT]
+> **Essential Companion**
+> To unlock file handling and data analysis capabilities, you must install the [GitHub Copilot SDK Files Filter](https://openwebui.com/posts/403a62ee-a596-45e7-be65-fab9cc249dd6).
 
 > [!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.
+> 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.5.1) - Major Upgrade
+---
 
-- **🧠 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.
+## ✨ v0.6.0 Updates (What's New)
+
+- **👥 User & Chat Management**: Physical management architecture (`user_id/chat_id`) for absolute resource independence.
+- **🤖 Empowering Agent Autonomy**: Automatic synchronization of raw files to the workspace, enabling direct Python-based analysis of Excel/CSV.
+- **🔧 OpenAPI & External Tool Fixes**: Full support for tools mounted via OpenAPI servers.
+- **📊 Cost Control**: Enhanced **Billing Multiplier Limits** (`MAX_MULTIPLIER`, e.g., set to 0 for free models only) and **Model Keyword Filtering** (`EXCLUDE_KEYWORDS`) for precise cost management.
+- **🧠 Persistent TODO Lists**: Database-backed task tracking that persists across sessions.
+
+---
 
 ## ✨ Key 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.
+- **🔑 Flexible Auth & BYOK**: Official Copilot subscriptions (PAT) or Bring Your Own Key (OpenAI/Anthropic).
+- **🔌 Universal Tool Protocol**: Native support for **MCP (Model Context Protocol)**, OpenAPI, and OpenWebUI built-in tools.
+- **🛡️ Sandbox Workspace Isolation**: Strict per-session sandboxing for data privacy and security.
+- **♾️ Infinite Session Management**: Smart context window management with automatic compaction for indefinite conversation capability.
+- **🧠 Deep Database Integration**: Real-time persistence of TOD·O lists for long-running workflows.
+- **🌊 Advanced Streaming**: Full support for thinking process/Chain of Thought visualization.
+- **🖼️ Intelligent Multimodal**: Vision capabilities and raw file analysis support.
+- **⚡ Interactive Artifacts**: Automatically renders HTML/JS apps generated by the agent directly in the chat interface.
 
-## Installation & Configuration
+---
 
-### 1) Import Function
+## ⚙️ Core Configuration (Valves)
 
-1. Open OpenWebUI.
-2. Go to **Workspace** -> **Functions**.
-3. Click **+** (Create Function).
-4. Paste the content of `github_copilot_sdk.py` (or `github_copilot_sdk_cn.py` for Chinese) completely.
-5. Save.
+### 1. Administrator Settings (Base)
 
-### 2) Configure Valves (Settings)
+Administrators define the default behavior for all users in the function settings.
 
-Find "GitHub Copilot" in the function list and click the **⚙️ (Valves)** icon to configure:
-
-| Parameter | Description | Default |
+| Valve | Default | Description |
 | :--- | :--- | :--- |
-| **GH_TOKEN** | **(Required)** GitHub Access Token (PAT or OAuth Token). Access to Chat. | - |
-| **DEBUG** | Whether to enable debug logs (output to browser console). | `False` |
-| **LOG_LEVEL** | Copilot CLI log level: none, error, warning, info, debug, all. | `error` |
-| **SHOW_THINKING** | Show model reasoning/thinking process (requires streaming + model support). | `True` |
-| **COPILOT_CLI_VERSION** | Specific Copilot CLI version to install/enforce. | `0.0.405` |
-| **EXCLUDE_KEYWORDS** | Exclude models containing these keywords (comma separated). | - |
-| **WORKSPACE_DIR** | Restricted workspace directory for file operations. | - |
-| **INFINITE_SESSION** | Enable Infinite Sessions (automatic context compaction). | `True` |
-| **COMPACTION_THRESHOLD** | Background compaction threshold (0.0-1.0). | `0.8` |
-| **BUFFER_THRESHOLD** | Buffer exhaustion threshold (0.0-1.0). | `0.95` |
-| **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` |
-| **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` |
+| `GH_TOKEN` | `""` | Global GitHub Token (Requires 'Copilot Requests' permission). |
+| `ENABLE_OPENWEBUI_TOOLS` | `True` | Enable OpenWebUI Tools (includes defined Tools and Built-in Tools). |
+| `ENABLE_OPENAPI_SERVER` | `True` | Enable OpenAPI Tool Server connection. |
+| `ENABLE_MCP_SERVER` | `True` | Enable Direct MCP Client connection (Recommended). |
+| `REASONING_EFFORT` | `medium` | Reasoning effort level: low, medium, high. |
+| `SHOW_THINKING` | `True` | Show model reasoning/thinking process. |
+| `INFINITE_SESSION` | `True` | Enable Infinite Sessions (automatic context compaction). |
+| `MAX_MULTIPLIER` | `1.0` | Max allowed billing multiplier (0x for free models only). |
+| `EXCLUDE_KEYWORDS` | `""` | Exclude models containing these keywords (comma separated). |
+| `TIMEOUT` | `300` | Timeout for each stream chunk (seconds). |
+| `BYOK_TYPE` | `openai` | BYOK Provider Type: `openai`, `anthropic`. |
+| `BYOK_BASE_URL` | `""` | BYOK Base URL (e.g., <https://api.openai.com/v1>). |
+| `BYOK_MODELS` | `""` | BYOK Model List (comma separated). Leave empty to fetch from API. |
+| `CUSTOM_ENV_VARS` | `""` | Custom environment variables (JSON format). |
+| `DEBUG` | `False` | Enable this to see detailed logs in your browser console. |
 
-#### User Valves (per-user overrides)
+### 2. User Settings (Individual Overrides)
 
-These optional settings can be set per user (overrides global Valves):
+Standard users can override these settings in their individual Profile/Function settings.
 
-| Parameter | Description | Default |
-| :--- | :--- | :--- |
-| **GH_TOKEN** | Personal GitHub Token (overrides global setting). | - |
-| **REASONING_EFFORT** | Reasoning effort level (low/medium/high/xhigh). | - |
-| **DEBUG** | Enable technical debug logs. | `False` |
-| **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` |
-| **BYOK_API_KEY** | BYOK API Key (User override). | - |
+| Valve | Description |
+| :--- | :--- |
+| `GH_TOKEN` | Use your personal GitHub Token. |
+| `REASONING_EFFORT` | Individual reasoning effort preference. |
+| `SHOW_THINKING` | Show model reasoning/thinking process. |
+| `MAX_MULTIPLIER` | Maximum allowed billing multiplier override. |
+| `EXCLUDE_KEYWORDS` | Exclude models containing these keywords. |
+| `BYOK_API_KEY` | Use your personal OpenAI/Anthropic API Key. |
+
+---
+
+## 🎯 Use Cases (What can you do?)
+
+- **📁 Fully Autonomous DevOps**: Agent analyzes code, runs tests, and applies patches within its isolated sandbox.
+- **📊 Deep Data Auditing**: Directly process raw Excel/CSV data via Python (bypassing RAG) and generate visual reports.
+- **📝 Long-Task Management**: Automatically decomposes complex requests and persists TOD·O progress across sessions.
+
+---
 
 ## ⭐ 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.
+If this plugin has been useful, a **Star** on [Awesome OpenWebUI](https://github.com/Fu-Jie/awesome-openwebui) would be a great motivation for me. Thank you!
 
-### Get Token
+---
 
-To use GitHub Copilot, you need a GitHub Personal Access Token (PAT) with appropriate permissions.
+## 🚀 Installation & Configuration
 
-**Steps to generate your token:**
+### 1) Import Function
+
+1. Open OpenWebUI, go to **Workspace** -> **Functions**.
+2. Click **+** (Create Function), paste the content of `github_copilot_sdk.py`.
+3. Save and ensure it is enabled.
+
+### 2) Get Token
 
 1. Visit [GitHub Token Settings](https://github.com/settings/tokens?type=beta).
-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**.
-5. Generate and copy the Token.
+2. Create **Fine-grained token**, granting **Account permissions** -> **Copilot Requests** access.
+3. Paste the generated Token into the `GH_TOKEN` field in Valves.
 
-## 📋 Dependencies
+---
 
-This Pipe will automatically attempt to install the following dependencies:
+## 📋 Troubleshooting & Dependencies
 
-- `github-copilot-sdk` (Python package)
-- `github-copilot-cli` (Binary file, installed via official script)
+- **Agent ignores files?**: Ensure the Files Filter is enabled, otherwise RAG will interfere with raw binaries.
+- **No progress bar?**: The bar only appears when the Agent uses the `update_todo` tool.
+- **Dependencies**: This Pipe automatically installs `github-copilot-sdk` (Python) and `github-copilot-cli` (Binary).
 
-## 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.
+---
 
 ## Changelog
 
diff --git a/docs/plugins/pipes/github-copilot-sdk.zh.md b/docs/plugins/pipes/github-copilot-sdk.zh.md
index fb0d7ca..b8082d1 100644
--- a/docs/plugins/pipes/github-copilot-sdk.zh.md
+++ b/docs/plugins/pipes/github-copilot-sdk.zh.md
@@ -1,117 +1,119 @@
 # GitHub Copilot SDK 官方管道
 
-**作者:** [Fu-Jie](https://github.com/Fu-Jie/awesome-openwebui) | **版本:** 0.5.1 | **项目:** [Awesome OpenWebUI](https://github.com/Fu-Jie/awesome-openwebui) | **许可证:** MIT
+**作者:** [Fu-Jie](https://github.com/Fu-Jie/awesome-openwebui) | **版本:** 0.6.0 | **项目:** [Awesome OpenWebUI](https://github.com/Fu-Jie/awesome-openwebui) | **许可证:** MIT
 
-这是一个用于 [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 交互体验。
+这是一个用于 [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 SDK Files Filter](https://openwebui.com/posts/403a62ee-a596-45e7-be65-fab9cc249dd6)。
+
 > [!TIP]
-> **使用 BYOK 模式无需订阅**
-> 如果您使用自己的 API Key (OpenAI, Anthropic) 运行 BYOK 模式，**则完全不需要** GitHub Copilot 订阅。
-> 仅当您希望使用 GitHub 官方提供的模型时，才需要订阅。
+> **BYOK 模式无需订阅**
+> 如果您使用自带的 API Key (BYOK 模式对接 OpenAI/Anthropic)，**您不需要 GitHub Copilot 官方订阅**。只有在访问 GitHub 官方模型时才需要订阅。
 
-## 🚀 最新特性 (v0.5.1) - 重大升级
+---
 
-- **🧠 智能 BYOK 检测**: 优化了 BYOK 与官方 Copilot 模型的识别逻辑，完美支持自定义模型（角色/提示词）及倍率检测（如 `(0x)`, `(1x)`）。
-- **⚡ 性能飙升**: 引入 **工具缓存 (Tool Caching)** 机制，在请求间持久化工具定义，显著降低调用开销。
-- **🧩 丰富工具集成**: 工具描述现包含来源分组（内置/用户/服务器）及 Docstring 元数据自动解析。
-- **🛡️ 精确控制**: 完美兼容 OpenWebUI 全局函数过滤配置 (`function_name_filter_list`)，可精准控制暴露给 LLM 的函数。
-- **🔑 用户级 BYOK**: 支持在用户层面配置自定义 API Key 对接 AI 供应商（OpenAI, Anthropic）。
-- **📝 格式优化**: 系统提示词强制使用标准 Markdown 表格，彻底解决 HTML 表格渲染问题。
+## ✨ 0.6.0 更新内容 (What's New)
 
-## ✨ 核心能力
+- **👥 多用户与会话管理**: 采用 `user_id/chat_id` 的物理隔离架构，确保资源独立与稳健管理。
+- **🤖 赋予 Agent 文件自主权**: 自动将上传的文件同步至物理工作区，支持 Python 直接分析 Excel/CSV。
+- **🔧 OpenAPI & 外部工具修复**: 完美支持通过 OpenAPI 服务器挂载的工具调用。
+- **📊 计费与成本控制**: 增强的**计费倍率限制** (`MAX_MULTIPLIER`，例如设为 0 即仅限免费模型) 和**模型关键词过滤** (`EXCLUDE_KEYWORDS`)，实现更精准的成本管控。
+- **🧠 数据库持久化 TODO**: 任务进度跨会话保存，Agent 拥有更持久的任务 memory。
 
-- **🔑 灵活鉴权与 BYOK**: 支持 GitHub Copilot 订阅 (PAT) 或自带 Key (OpenAI/Anthropic)，完全掌控模型访问与计费。
-- **🌉 强大的生态桥接**: 首个且唯一完美打通 **OpenWebUI Tools** 与 **GitHub Copilot SDK** 的插件。
-- **🚀 官方原生产体验**: 基于官方 Python SDK 构建，提供最稳定、最纯正的 Copilot 交互体验。
+---
+
+## ✨ 核心能力 (Key Capabilities)
+
+- **🔑 灵活鉴权与 BYOK**: 支持 GitHub Copilot 官方订阅 (PAT) 或自带 Key (OpenAI/Anthropic)。
+- **🔌 通用工具协议**: 原生支持 **MCP (Model Context Protocol)**、OpenAPI 以及 OpenWebUI 内置工具。
+- **🛡️ 物理级工作区隔离**: 强制执行严格的用户特定沙箱，确保数据隐私与文件安全。
+- **♾️ 无限会话管理**: 智能上下文窗口管理与自动压缩算法，支持无限时长的对话交互。
+- **🧠 深度数据库集成**: 实时持久化 TOD·O 列表到 UI 进度条。
 - **🌊 深度推理展示**: 完整支持模型思考过程 (Thinking Process) 的流式渲染。
-- **🖼️ 智能多模态**: 支持图像识别与附件上传，让 Copilot 拥有视觉能力。
-- **🛠️ 极简部署流程**: 自动检测环境、自动下载 CLI、自动管理依赖，全自动化开箱即用。
-- **🛡️ 纯净安全体系**: 支持标准 PAT 认证，确保数据安全。
+- **🖼️ 智能多模态**: 完整支持图像识别与附件上传分析。
+- **⚡ 交互式伪影 (Artifacts)**: 自动渲染 Agent 生成的 HTML/JS 应用程序，直接在聊天界面交互。
 
-## 安装与配置
+---
 
-### 1. 导入函数
+## ⚙️ 核心配置参数 (Valves)
 
-1. 打开 OpenWebUI。
-2. 进入 **Workspace** -> **Functions**。
-3. 点击 **+** (创建函数)。
-4. 将 `github_copilot_sdk_cn.py` 的内容完整粘贴进去。
-5. 保存。
+### 1. 管理员配置 (基础设置)
 
-### 2. 配置 Valves (设置)
+管理员可在函数设置中定义全局默认行为。
 
-在函数列表中找到 "GitHub Copilot"，点击 **⚙️ (Valves)** 图标进行配置：
-
-| 参数 | 说明 | 默认值 |
+| 参数 | 默认值 | 说明 |
 | :--- | :--- | :--- |
-| **GH_TOKEN** | **(必填)** GitHub 访问令牌 (PAT 或 OAuth Token)。用于聊天。 | - |
-| **DEBUG** | 是否开启调试日志（输出到浏览器控制台）。 | `False` |
-| **LOG_LEVEL** | Copilot CLI 日志级别: none, error, warning, info, debug, all。 | `error` |
-| **SHOW_THINKING** | 是否显示模型推理/思考过程（需开启流式 + 模型支持）。 | `True` |
-| **COPILOT_CLI_VERSION** | 指定安装/强制使用的 Copilot CLI 版本。 | `0.0.405` |
-| **EXCLUDE_KEYWORDS** | 排除包含这些关键词的模型（逗号分隔）。 | - |
-| **WORKSPACE_DIR** | 文件操作的受限工作区目录。 | - |
-| **INFINITE_SESSION** | 启用无限会话（自动上下文压缩）。 | `True` |
-| **COMPACTION_THRESHOLD** | 后台压缩阈值 (0.0-1.0)。 | `0.8` |
-| **BUFFER_THRESHOLD** | 缓冲区耗尽阈值 (0.0-1.0)。 | `0.95` |
-| **TIMEOUT** | 每个流式分块超时（秒）。 | `300` |
-| **CUSTOM_ENV_VARS** | 自定义环境变量 (JSON 格式)。 | - |
-| **REASONING_EFFORT** | 推理强度级别: low, medium, high. `xhigh` 仅部分模型支持。 | `medium` |
-| **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` |
+| `GH_TOKEN` | `""` | 全局 GitHub Token (需具备 'Copilot Requests' 权限)。 |
+| `ENABLE_OPENWEBUI_TOOLS` | `True` | 启用 OpenWebUI 工具 (包括定义工具和内置工具)。 |
+| `ENABLE_OPENAPI_SERVER` | `True` | 启用 OpenAPI 工具服务器连接。 |
+| `ENABLE_MCP_SERVER` | `True` | 启用直接 MCP 客户端连接 (推荐)。 |
+| `REASONING_EFFORT` | `medium` | 推理强度：low, medium, high。 |
+| `SHOW_THINKING` | `True` | 显示模型推理/思考过程。 |
+| `INFINITE_SESSION` | `True` | 启用无限会话 (自动上下文压缩)。 |
+| `MAX_MULTIPLIER` | `1.0` | 最大允许的模型计费倍率 (0x 为仅限免费模型)。 |
+| `EXCLUDE_KEYWORDS` | `""` | 排除包含这些关键字的模型 (逗号分隔)。 |
+| `TIMEOUT` | `300` | 每个流数据块的超时时间 (秒)。 |
+| `BYOK_TYPE` | `openai` | BYOK 服务商类型：`openai`, `anthropic`。 |
+| `BYOK_BASE_URL` | `""` | BYOK 基础 URL (例如: <https://api.openai.com/v1>)。 |
+| `BYOK_MODELS` | `""` | BYOK 模型列表 (逗号分隔)。留空则从 API 获取。 |
+| `CUSTOM_ENV_VARS` | `""` | 自定义环境变量 (JSON 格式)。 |
+| `DEBUG` | `False` | 开启此项以在前端控制台输出详细调试日志。 |
 
-#### 用户 Valves（按用户覆盖）
+### 2. 用户配置 (个人覆盖)
 
-以下设置可按用户单独配置（覆盖全局 Valves）：
+普通用户可在各自的个人设置中根据需要覆盖以下参数。
 
-| 参数 | 说明 | 默认值 |
-| :--- | :--- | :--- |
-| **GH_TOKEN** | 个人 GitHub Token（覆盖全局设置）。 | - |
-| **REASONING_EFFORT** | 推理强度级别（low/medium/high/xhigh）。 | - |
-| **DEBUG** | 是否启用技术调试日志。 | `False` |
-| **SHOW_THINKING** | 是否显示思考过程。 | `True` |
-| **ENABLE_OPENWEBUI_TOOLS** | 启用 OpenWebUI 工具（覆盖全局设置）。 | `True` |
-| **ENABLE_MCP_SERVER** | 启用动态 MCP 服务器加载（覆盖全局设置）。 | `True` |
+| 参数 | 说明 |
+| :--- | :--- |
+| `GH_TOKEN` | 使用个人的 GitHub Token。 |
+| `REASONING_EFFORT` | 个人偏好的推理强度。 |
+| `SHOW_THINKING` | 显示模型推理/思考过程。 |
+| `MAX_MULTIPLIER` | 最大允许的模型计费倍率覆盖。 |
+| `EXCLUDE_KEYWORDS` | 排除包含这些关键字的模型。 |
+| `BYOK_API_KEY` | 使用个人的 OpenAI/Anthropic API Key。 |
 
-## ⭐ 支持
+---
 
-如果这个插件对你有帮助，欢迎到 [Awesome OpenWebUI](https://github.com/Fu-Jie/awesome-openwebui) 点个 Star，这将是我持续改进的动力，感谢支持。
+## 🎯 典型应用场景 (Use Cases)
 
-### 获取 Token
+- **📁 全自主仓库维护**: Agent 在隔离工作区内自动分析代码、运行测试并应用补丁。
+- **📊 深度财务数据审计**: 直接通过 Python 加载 Excel/CSV 原始数据（绕过 RAG），生成图表并实时预览。
+- **📝 长任务项目管理**: 自动拆解复杂任务并持久化 TOD·O 进度，跨会话跟踪执行状态。
 
-要使用 GitHub Copilot，您需要一个具有适当权限的 GitHub 个人访问令牌 (PAT)。
+---
 
-**获取步骤：**
+## ⭐ 支持与交流 (Support)
 
-1. 访问 [GitHub 令牌设置](https://github.com/settings/tokens?type=beta)。
-2. 点击 **Generate new token (fine-grained)**。
-3. **Repository access**: 选择 **Public Repositories** (最简单) 或 **All repositories**。
-4. **Permissions**:
-    - 如果您选择了 **All repositories**，则必须点击 **Account permissions**。
-    - 找到 **Copilot Requests**，选择 **Access**。
-5. 生成并复制令牌。
+如果这个插件对您有所帮助，请在 [Awesome OpenWebUI](https://github.com/Fu-Jie/awesome-openwebui) 项目上点个 **Star** 💫，这是对我最大的鼓励。
 
-## 📋 依赖说明
+---
 
-该 Pipe 会自动尝试安装以下依赖（如果环境中缺失）：
+## 🚀 安装与配置 (Installation)
 
-- `github-copilot-sdk` (Python 包)
-- `github-copilot-cli` (二进制文件，通过官方脚本安装)
+### 1) 导入函数
 
-## 故障排除 (Troubleshooting) ❓
+1. 打开 OpenWebUI，前往 **工作区** -> **函数**。
+2. 点击 **+** (创建函数)，完整粘贴 `github_copilot_sdk_cn.py` 的内容。
+3. 点击保存并确保已启用。
 
-- **图片及多模态使用说明**：
-  - 确保 `MODEL_ID` 是支持多模态的模型。
-- **看不到思考过程**：
-  - 确认已开启**流式输出**，且所选模型支持推理输出。
+### 2) 获取 Token (Get Token)
 
-## 更新日志
+1. 访问 [GitHub Token 设置](https://github.com/settings/tokens?type=beta)。
+2. 创建 **Fine-grained token**，授予 **Account permissions** -> **Copilot Requests** 访问权限。
+3. 将生成的 Token 填入插件的 `GH_TOKEN` 配置项中。
 
-完整历史请查看 GitHub 项目： [Awesome OpenWebUI](https://github.com/Fu-Jie/awesome-openwebui)
+---
+
+## 📋 常见问题与依赖 (Troubleshooting)
+
+- **Agent 无法识别文件？**: 请确保已安装并启用了 Files Filter 插件，否则原始文件会被 RAG 干扰。
+- **看不到 TODO 进度条？**: 进度条仅在 Agent 使用 `update_todo` 工具（通常是处理复杂任务）时出现。
+- **依赖安装**: 本管道会自动尝试安装 `github-copilot-sdk` (Python 包) 和 `github-copilot-cli` (官方二进制)。
+
+---
+
+## 更新日志 (Changelog)
+
+完整历史记录请见 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 7e37fcb..87f1a2b 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.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.
+- [GitHub Copilot SDK](github-copilot-sdk.md) (v0.6.0) - Official GitHub Copilot SDK integration. Features **Workspace Isolation**, **Database Persistence**, **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 69030d2..6c5f14d 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.5.1) - GitHub Copilot SDK 官方集成。**零配置工具桥接**与**BYOK (自带 Key) 支持**。支持流式输出、多模态及无限会话。
+- [GitHub Copilot SDK](github-copilot-sdk.zh.md) (v0.6.0) - GitHub Copilot SDK 官方集成。具备**工作区安全隔离**、**数据库持久化**、**零配置工具桥接**与**BYOK (自带 Key) 支持**。支持流式输出、打字机思考过程及无限会话。[查看深度架构解析](github-copilot-sdk-deep-dive.zh.md)。
 
 ---
 
diff --git a/plugins/filters/github_copilot_sdk_files_filter/README.md b/plugins/filters/github_copilot_sdk_files_filter/README.md
new file mode 100644
index 0000000..002a52f
--- /dev/null
+++ b/plugins/filters/github_copilot_sdk_files_filter/README.md
@@ -0,0 +1,53 @@
+# GitHub Copilot SDK Files Filter
+
+**Author:** [Fu-Jie](https://github.com/Fu-Jie/awesome-openwebui) | **Version:** 0.1.2 | **Project:** [Awesome OpenWebUI](https://github.com/Fu-Jie/awesome-openwebui) | **License:** MIT
+
+This is a dedicated **companion filter plugin** designed specifically for the [GitHub Copilot SDK Pipe](https://openwebui.com/posts/github_copilot_official_sdk_pipe_ce96f7b4).
+
+Its core mission is to **protect user-uploaded files from being "pre-processed" by the OpenWebUI core system, ensuring that the Copilot Agent receives the raw files for autonomous analysis.**
+
+## 🎯 Why is this needed?
+
+In OpenWebUI's default workflow, when you upload a file (e.g., PDF, Excel, Python script), OpenWebUI automatically initiates a **RAG (Retrieval-Augmented Generation)** process: parsing the file, vectorizing it, extracting text, and injecting it into the prompt.
+
+While useful for standard models, this is often disruptive for a **Copilot SDK Agent**:
+
+1. **Agent Needs Raw Files**: The Agent may need to run Python code to read an Excel file or analyze a full directory structure, not chopped-up text fragments.
+2. **Context Pollution**: Large amounts of text injected by RAG consume tokens and can confuse the Agent about "where the file is."
+3. **Control & Performance**: Bypassing the extraction step speeds up the response and gives the Agent full autonomy over how to handle the data.
+
+**This plugin acts as a "bodyguard" to solve these issues.**
+
+## 🚀 How it Works
+
+When you select a Copilot model (name containing `copilot_sdk`) in OpenWebUI and send a file:
+
+1. **Intercept**: This plugin runs with high priority (Priority 0), before RAG and other filters.
+2. **Relocate**: Detecting a Copilot model, it moves the `files` list from the request to a secure custom field `copilot_files`.
+3. **Hide**: It clears the original `files` field.
+4. **Pass**: The OpenWebUI core sees an empty `files` list and **does not trigger RAG**.
+5. **Deliver**: The subsequent Copilot SDK Pipe plugin checks `copilot_files`, retrieves file information, and automatically copies them into the Agent's isolated workspace.
+
+## 📦 Installation & Configuration
+
+### 1. Installation
+
+Import this plugin on the OpenWebUI **Functions** page.
+
+### 2. Enable
+
+Ensure this Filter is enabled globally or in chat settings.
+
+### 3. Configuration (Valves)
+
+Default settings work for most users:
+
+| Parameter | Description | Default |
+| :--- | :--- | :--- |
+| **priority** | Execution priority. **Must be lower than OpenWebUI RAG priority**. | `0` |
+| **target_model_keyword** | Keyword to identify Copilot models for interception. | `copilot_sdk` |
+
+## ⚠️ Important Notes
+
+* **Must be used with Copilot SDK Pipe**: If you install this plugin without the main Pipe plugin, uploaded files will simply "disappear" (as no subsequent plugin will look for them).
+* **Gemini Filter Compatibility**: Fully compatible with the Gemini Multimodal Filter. Just ensure priorities don't conflict.
diff --git a/plugins/filters/github_copilot_sdk_files_filter/README_CN.md b/plugins/filters/github_copilot_sdk_files_filter/README_CN.md
new file mode 100644
index 0000000..fab4c17
--- /dev/null
+++ b/plugins/filters/github_copilot_sdk_files_filter/README_CN.md
@@ -0,0 +1,51 @@
+# GitHub Copilot SDK 文件过滤器
+
+**作者:** [Fu-Jie](https://github.com/Fu-Jie/awesome-openwebui) | **版本:** 0.1.2 | **项目:** [Awesome OpenWebUI](https://github.com/Fu-Jie/awesome-openwebui) | **许可证:** MIT
+
+这是一个专门为 [GitHub Copilot SDK Pipe](https://openwebui.com/posts/github_copilot_official_sdk_pipe_ce96f7b4) 设计的**伴侣过滤器插件**。
+
+它的核心使命是：**保护用户上传的文件不被 OpenWebUI 核心系统“抢先处理”，确保 Copilot Agent 能够接收到原始文件并进行自主分析。**
+
+## 🎯 为什么需要它？
+
+在 OpenWebUI 的默认流程中，当你上传一个文件（如 PDF、Excel、Python 脚本）时，OpenWebUI 会自动启动 **RAG（检索增强生成）** 流程：解析文件、向量化、提取文本并注入到提示词中。
+
+虽然这对普通模型很有用，但对于 **Copilot SDK Agent** 来说，这往往是干扰：
+
+1. **Agent 需要原始文件**：Agent 可能需要运行 Python 代码读取 Excel，或者分析完整的代码结构，而不是被切碎的文本片段。
+2. **上下文污染**：RAG 注入的大量文本会消耗 Token，且容易让 Agent 混淆“文件在哪里”。
+3. **控制权与性能**：绕过提取步骤可以加快响应速度，并赋予 Agent 处理数据的完全自主权。
+
+**本插件就是为了解决这个问题而生的“保镖”。**
+
+## 🚀 功能原理
+
+当你在 OpenWebUI 中选择了一个 Copilot 模型（名称包含 `copilot_sdk`）并发送文件时：
+
+1. **拦截 (Intercept)**：本插件会以极高的优先级（Priority 5）运行，先于 RAG 和其他过滤器。
+2. **搬运 (Relocate)**：它检测到模型是 Copilot，便将请求中的 `files`（文件列表）移动到一个安全的自定义字段 `copilot_files` 中。
+3. **隐身 (Hide)**：它清空原始的 `files` 字段。
+4. **放行 (Pass)**：OpenWebUI 核心看到 `files` 为空，便**不会触发 RAG**。
+5. **交付 (Deliver)**：后续的 Copilot SDK Pipe 插件会检查 `copilot_files`，从中获取文件信息，并自动将其复制到 Agent 的独立工作区中。
+
+## 📦 安装与配置
+
+### 1. 安装
+
+在 OpenWebUI 的 **Functions** 页面导入此插件。
+
+### 2. 启用
+
+确保在全局或对话设置中启用了此 Filter。
+
+### 3. 配置 (Valves)
+
+| 参数 | 说明 | 默认值 |
+| :--- | :--- | :--- |
+| **priority** | 过滤器的执行优先级。**必须小于 OpenWebUI RAG 的优先级**。 | `5` |
+| **target_model_keyword** | 用户识别 Copilot 模型的关键词。只有包含此关键词的模型才会触发。 | `copilot_sdk` |
+
+## ⚠️ 注意事项
+
+* **必须配合 Copilot SDK Pipe 使用**：如果你没有安装主 Pipe 插件，本插件将导致上传的文件“凭空消失”。
+* **Gemini Filter 兼容性**：已完美兼容 Gemini 多模态过滤器。只要优先级设置正确，它们可以共存互不干扰。
diff --git a/plugins/filters/github_copilot_sdk_files_filter/github_copilot_sdk_files_filter.py b/plugins/filters/github_copilot_sdk_files_filter/github_copilot_sdk_files_filter.py
new file mode 100644
index 0000000..672c34c
--- /dev/null
+++ b/plugins/filters/github_copilot_sdk_files_filter/github_copilot_sdk_files_filter.py
@@ -0,0 +1,66 @@
+"""
+title: GitHub Copilot SDK Files Filter
+id: github_copilot_sdk_files_filter
+author: Fu-Jie
+author_url: https://github.com/Fu-Jie/awesome-openwebui
+funding_url: https://github.com/open-webui
+version: 0.1.2
+description: A specialized filter to bypass OpenWebUI's default RAG for GitHub Copilot SDK models. It moves uploaded files to a safe location ('copilot_files') so the Copilot Pipe can process them natively without interference.
+"""
+
+from pydantic import BaseModel, Field
+from typing import Optional, Callable, Awaitable
+
+
+class Filter:
+    class Valves(BaseModel):
+        priority: int = Field(
+            default=0,
+            description="Priority level. Must be lower than RAG processors to intercept files effectively.",
+        )
+        target_model_keyword: str = Field(
+            default="copilot_sdk",
+            description="Keyword to identify Copilot models (e.g., 'copilot_sdk').",
+        )
+
+    def __init__(self):
+        self.valves = self.Valves()
+
+    async def inlet(
+        self,
+        body: dict,
+        __user__: Optional[dict] = None,
+        __model__: Optional[dict] = None,
+        __metadata__: Optional[dict] = None,
+        __event_emitter__: Callable[[dict], Awaitable[None]] = None,
+    ) -> dict:
+        # Determine the actual model ID
+        base_model_id = None
+        if __model__:
+            if "openai" in __model__:
+                base_model_id = __model__["openai"].get("id")
+            else:
+                base_model_id = __model__.get("info", {}).get("base_model_id")
+
+        current_model = base_model_id if base_model_id else body.get("model", "")
+
+        # Check if it's a Copilot model
+        if self.valves.target_model_keyword.lower() in current_model.lower():
+            # If files exist, move them to 'copilot_files' and clear 'files'
+            # This prevents OpenWebUI from triggering RAG on these files
+            if "files" in body and body["files"]:
+                file_count = len(body["files"])
+                if __event_emitter__:
+                    await __event_emitter__(
+                        {
+                            "type": "status",
+                            "data": {
+                                "description": f"Managed {file_count} files for Copilot (RAG Bypassed)",
+                                "done": True,
+                            },
+                        }
+                    )
+                body["copilot_files"] = body["files"]
+                body["files"] = []
+
+        return body
diff --git a/plugins/filters/github_copilot_sdk_files_filter/github_copilot_sdk_files_filter_cn.py b/plugins/filters/github_copilot_sdk_files_filter/github_copilot_sdk_files_filter_cn.py
new file mode 100644
index 0000000..caa29dd
--- /dev/null
+++ b/plugins/filters/github_copilot_sdk_files_filter/github_copilot_sdk_files_filter_cn.py
@@ -0,0 +1,66 @@
+"""
+title: GitHub Copilot SDK 文件过滤器(GitHub Copilot SDK Files Filter)
+id: github_copilot_sdk_files_filter
+author: Fu-Jie
+author_url: https://github.com/Fu-Jie/awesome-openwebui
+funding_url: https://github.com/open-webui
+version: 0.1.2
+description: 一个专门的过滤器，用于绕过 OpenWebUI 默认的 RAG 机制，针对 GitHub Copilot SDK 模型。它将上传的文件移动到安全位置 ('copilot_files')，以便 Copilot Pipe 可以原生处理它们而不受干扰。
+"""
+
+from pydantic import BaseModel, Field
+from typing import Optional, Callable, Awaitable
+
+
+class Filter:
+    class Valves(BaseModel):
+        priority: int = Field(
+            default=0,
+            description="优先级。必须低于 RAG 处理器的优先级，以便有效拦截文件。",
+        )
+        target_model_keyword: str = Field(
+            default="copilot_sdk",
+            description="用于识别 Copilot 模型的关键词（例如 'copilot_sdk'）。",
+        )
+
+    def __init__(self):
+        self.valves = self.Valves()
+
+    async def inlet(
+        self,
+        body: dict,
+        __user__: Optional[dict] = None,
+        __model__: Optional[dict] = None,
+        __metadata__: Optional[dict] = None,
+        __event_emitter__: Callable[[dict], Awaitable[None]] = None,
+    ) -> dict:
+        # Determine the actual model ID
+        base_model_id = None
+        if __model__:
+            if "openai" in __model__:
+                base_model_id = __model__["openai"].get("id")
+            else:
+                base_model_id = __model__.get("info", {}).get("base_model_id")
+
+        current_model = base_model_id if base_model_id else body.get("model", "")
+
+        # Check if it's a Copilot model
+        if self.valves.target_model_keyword.lower() in current_model.lower():
+            # If files exist, move them to 'copilot_files' and clear 'files'
+            # This prevents OpenWebUI from triggering RAG on these files
+            if "files" in body and body["files"]:
+                file_count = len(body["files"])
+                if __event_emitter__:
+                    await __event_emitter__(
+                        {
+                            "type": "status",
+                            "data": {
+                                "description": f"已为 Copilot 管理 {file_count} 个文件 (已绕过 RAG)",
+                                "done": True,
+                            },
+                        }
+                    )
+                body["copilot_files"] = body["files"]
+                body["files"] = []
+
+        return body
diff --git a/plugins/filters/web_gemini_multimodel_filter/web_gemini_multimodel.py b/plugins/filters/web_gemini_multimodel_filter/web_gemini_multimodel.py
index 5862a9d..f872c46 100644
--- a/plugins/filters/web_gemini_multimodel_filter/web_gemini_multimodel.py
+++ b/plugins/filters/web_gemini_multimodel_filter/web_gemini_multimodel.py
@@ -3,6 +3,7 @@ title: Gemini 多模态过滤器（含字幕增强）
 author: Gemini Adapter
 author_url: https://github.com/Fu-Jie
 funding_url: https://github.com/Fu-Jie/awesome-openwebui
+
 version: 0.3.2
 description: >
     一个强大的过滤器，为 OpenWebUI 中的任何模型提供多模态能力：PDF、Office、图片、音频、视频等。
@@ -492,6 +493,13 @@ class Filter:
         print(
             f"🤖 Checking model: {current_model} (Target: {self.valves.target_model_keyword})"
         )
+        # 0. SKIP COPILOT MODELS
+        # If the model is a Copilot Pipe model, we must NOT process files here.
+        # Copilot Pipe has its own file handling logic (copy to workspace).
+        if "copilot_sdk" in current_model.lower():
+            print(f"⏩ Skipping Gemini Filter for Copilot model: {current_model}")
+            return body
+
 
         # Check if model matches target keyword
         is_target_model = (
diff --git a/plugins/pipes/github-copilot-sdk/INTERNAL_KNOWLEDGE.md b/plugins/pipes/github-copilot-sdk/INTERNAL_KNOWLEDGE.md
new file mode 100644
index 0000000..877e0b3
--- /dev/null
+++ b/plugins/pipes/github-copilot-sdk/INTERNAL_KNOWLEDGE.md
@@ -0,0 +1,73 @@
+# GitHub Copilot SDK Pipe - Internal Architecture & Knowledge
+
+This document details the core runtime mechanisms, file layout, and deep integration logic of the GitHub Copilot SDK plugin within the OpenWebUI environment.
+
+## 1. Core Environmental Context
+
+### 1.1 Filesystem Layout
+
+| Path | Description | Permissions |
+| :--- | :--- | :--- |
+| `/app/backend` | OpenWebUI backend Python source code | Read-Only |
+| `/app/build` | OpenWebUI frontend assets (Artifacts renderer location) | Read-Only |
+| `/root/.copilot/` | SDK core configuration and state storage | **Full Control** |
+| `/app/backend/data/copilot_workspace/` | Plugin-specific persistent workspace | **Read/Write** |
+
+### 1.2 Identity Mapping Mechanism
+
+* **Session ID Binding**: The plugin strictly maps OpenWebUI's `Chat ID` to the Copilot SDK's `Session ID`.
+* **Outcome**: Every chat session has its own isolated physical directory: `/root/.copilot/session-state/{chat_id}/`.
+
+## 2. TODO List Persistence (TODO Intelligence)
+
+### 2.1 Data Source
+
+TODO data is **not** stored in a standalone database table for basic operations but is captured from the session event stream via the `update_todo` tool:
+
+* **Storage File**: `/root/.copilot/session-state/{chat_id}/events.jsonl`
+* **Detection**: Scans for the latest `tool.execution_complete` event where `toolName` is `update_todo`.
+
+### 2.2 Data Format (NDJSON)
+
+```json
+{
+  "type": "tool.execution_complete",
+  "data": {
+    "toolName": "update_todo",
+    "result": { 
+      "detailedContent": "TODO List content...", 
+      "toolTelemetry": { "metrics": { "total_items": 3 } } 
+    }
+  }
+}
+```
+
+## 3. Toolchain Integration
+
+The plugin harmonizes three distinct tool systems:
+
+1. **Copilot Native**: Built-in capabilities like `bash`, `edit`, and `task`.
+2. **OpenWebUI Ecosystem**: Dynamically mounts local Python tools and built-in `Web Search` via `get_tools`.
+3. **MCP (Model Context Protocol)**: External capability extensions via servers like `GDMap` or `Pandoc`.
+
+## 4. Security & Permissions
+
+### 4.1 Admin Mode (God Mode)
+
+When `__user__['role'] == 'admin'`:
+
+* `ADMIN_EXTENSIONS` are enabled.
+* Access to `DATABASE_URL` via environment variables is permitted.
+* `bash` can be used to diagnose internal state within `/root/.copilot/`.
+
+### 4.2 Regular User Mode
+
+* `USER_RESTRICTIONS` are strictly enforced.
+* Probing environment variables or database credentials is prohibited.
+* `bash` activity is strictly confined to the isolated workspace.
+
+## 5. Common Maintenance
+
+* **Reset Session**: Delete the `/root/.copilot/session-state/{chat_id}` directory.
+* **Clear Cache**: Disable `ENABLE_TOOL_CACHE` in Valves.
+* **View Logs**: Check latest logs under `/root/.copilot/logs/`.
diff --git a/plugins/pipes/github-copilot-sdk/INTERNAL_KNOWLEDGE_CN.md b/plugins/pipes/github-copilot-sdk/INTERNAL_KNOWLEDGE_CN.md
new file mode 100644
index 0000000..9f654d7
--- /dev/null
+++ b/plugins/pipes/github-copilot-sdk/INTERNAL_KNOWLEDGE_CN.md
@@ -0,0 +1,70 @@
+# GitHub Copilot SDK Pipe - 内部架构与通用知识 (Internal Knowledge)
+
+本文档记录了 GitHub Copilot SDK 插件在 OpenWebUI 环境下的核心运行机制、文件布局及深度集成逻辑。
+
+## 1. 核心环境上下文 (Environment)
+
+### 1.1 文件系统布局
+
+| 路径 | 说明 | 权限 |
+| :--- | :--- | :--- |
+| `/app/backend` | OpenWebUI 后端 Python 源码 | 只读 |
+| `/app/build` | OpenWebUI 前端静态资源 (Artifacts 渲染器位置) | 只读 |
+| `/root/.copilot/` | SDK 核心配置与状态存储 | **完全控制** |
+| `/app/backend/data/copilot_workspace/` | 插件指定的持久化工作区 | **读写自如** |
+
+### 1.2 身份映射机制
+
+* **Session ID 绑定**: 插件强制将 OpenWebUI 的 `Chat ID` 映射为 Copilot SDK 的 `Session ID`。
+* **结果**: 每个对话窗口都有独立的物理存储目录：`/root/.copilot/session-state/{chat_id}/`。
+
+## 2. TODO List 存储机制 (TODO Intelligence)
+
+### 2.1 数据源
+
+TODO 数据**并不**仅存储在独立数据库，而是通过 `update_todo` 工具写入会话事件流：
+
+* **文件**: `/root/.copilot/session-state/{chat_id}/events.jsonl`
+* **识别**: 查找类型为 `tool.execution_complete` 且 `toolName` 为 `update_todo` 的最新 JSON 行。
+
+### 2.2 数据格式 (NDJSON)
+
+```json
+{
+  "type": "tool.execution_complete",
+  "data": {
+    "toolName": "update_todo",
+    "result": { "detailedContent": "TODO List内容...", "toolTelemetry": { "metrics": { "total_items": 39 } } }
+  }
+}
+```
+
+## 3. 工具体系 (Toolchain)
+
+插件整合了三套工具系统：
+
+1. **Copilot Native**: SDK 内置的 `bash`, `edit`, `task` 等。
+2. **OpenWebUI Ecosystem**: 通过 `get_tools` 挂载的本地 Python 脚本和内置 `Web Search`。
+3. **MCP (Model Context Protocol)**: 通过 `GDMap`, `Pandoc` 等服务器扩展的外部能力。
+
+## 4. 安全与权限 (Security)
+
+### 4.1 管理员模式 (God Mode)
+
+当 `__user__['role'] == 'admin'` 时：
+
+* 启用 `ADMIN_EXTENSIONS`。
+* 允许通过环境变量获取 `DATABASE_URL`。
+* 允许使用 `bash` 诊断 `/root/.copilot/` 内部状态。
+
+### 4.2 普通用户模式
+
+* 启用 `USER_RESTRICTIONS`。
+* 严禁探测环境变量和数据库。
+* 限制 `bash` 只能在工作区内活动。
+
+## 5. 常见维护操作
+
+* **重置会话**: 删除 `/root/.copilot/session-state/{chat_id}` 目录。
+* **清理缓存**: 在 Valves 中关闭 `ENABLE_TOOL_CACHE`。
+* **查看日志**: 检查 `/root/.copilot/logs/` 下的最新日志。
diff --git a/plugins/pipes/github-copilot-sdk/README.md b/plugins/pipes/github-copilot-sdk/README.md
index b4a5ce4..9e8298d 100644
--- a/plugins/pipes/github-copilot-sdk/README.md
+++ b/plugins/pipes/github-copilot-sdk/README.md
@@ -1,117 +1,118 @@
 # GitHub Copilot SDK Pipe for OpenWebUI
 
-**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
+**Author:** [Fu-Jie](https://github.com/Fu-Jie/awesome-openwebui) | **Version:** 0.6.0 | **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 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.
+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 with **strict User & Chat-level Workspace Isolation**.
+
+> [!IMPORTANT]
+> **Essential Companion**
+> To unlock file handling and data analysis capabilities, you must install the [GitHub Copilot SDK Files Filter](https://openwebui.com/posts/403a62ee-a596-45e7-be65-fab9cc249dd6).
 
 > [!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.
+> 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.5.1) - Major Upgrade
+---
 
-- **🧠 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.
+## ✨ v0.6.0 Updates (What's New)
+
+- **👥 User & Chat Management**: Physical management architecture (`user_id/chat_id`) for absolute resource independence.
+- **🤖 Empowering Agent Autonomy**: Automatic synchronization of raw files to the workspace, enabling direct Python-based analysis of Excel/CSV.
+- **🔧 OpenAPI & External Tool Fixes**: Full support for tools mounted via OpenAPI servers.
+- **📊 Cost Control**: Enhanced **Billing Multiplier Limits** (`MAX_MULTIPLIER`, e.g., set to 0 for free models only) and **Model Keyword Filtering** (`EXCLUDE_KEYWORDS`) for precise cost management.
+- **🧠 Persistent TODO Lists**: Database-backed task tracking that persists across sessions.
+
+---
 
 ## ✨ Key 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.
+- **🔑 Flexible Auth & BYOK**: Official Copilot subscriptions (PAT) or Bring Your Own Key (OpenAI/Anthropic).
+- **🔌 Universal Tool Protocol**: Native support for **MCP (Model Context Protocol)**, OpenAPI, and OpenWebUI built-in tools.
+- **🛡️ Sandbox Workspace Isolation**: Strict per-session sandboxing for data privacy and security.
+- **♾️ Infinite Session Management**: Smart context window management with automatic compaction for indefinite conversation capability.
+- **🧠 Deep Database Integration**: Real-time persistence of TOD·O lists for long-running workflows.
+- **🌊 Advanced Streaming**: Full support for thinking process/Chain of Thought visualization.
+- **🖼️ Intelligent Multimodal**: Vision capabilities and raw file analysis support.
+- **⚡ Interactive Artifacts**: Automatically renders HTML/JS apps generated by the agent directly in the chat interface.
 
-## Installation & Configuration
+---
 
-### 1) Import Function
+## ⚙️ Core Configuration (Valves)
 
-1. Open OpenWebUI.
-2. Go to **Workspace** -> **Functions**.
-3. Click **+** (Create Function).
-4. Paste the content of `github_copilot_sdk.py` (or `github_copilot_sdk_cn.py` for Chinese) completely.
-5. Save.
+### 1. Administrator Settings (Base)
 
-### 2) Configure Valves (Settings)
+Administrators define the default behavior for all users in the function settings.
 
-Find "GitHub Copilot" in the function list and click the **⚙️ (Valves)** icon to configure:
-
-| Parameter | Description | Default |
+| Valve | Default | Description |
 | :--- | :--- | :--- |
-| **GH_TOKEN** | **(Required)** GitHub Access Token (PAT or OAuth Token). Access to Chat. | - |
-| **DEBUG** | Whether to enable debug logs (output to browser console). | `False` |
-| **LOG_LEVEL** | Copilot CLI log level: none, error, warning, info, debug, all. | `error` |
-| **SHOW_THINKING** | Show model reasoning/thinking process (requires streaming + model support). | `True` |
-| **COPILOT_CLI_VERSION** | Specific Copilot CLI version to install/enforce. | `0.0.405` |
-| **EXCLUDE_KEYWORDS** | Exclude models containing these keywords (comma separated). | - |
-| **WORKSPACE_DIR** | Restricted workspace directory for file operations. | - |
-| **INFINITE_SESSION** | Enable Infinite Sessions (automatic context compaction). | `True` |
-| **COMPACTION_THRESHOLD** | Background compaction threshold (0.0-1.0). | `0.8` |
-| **BUFFER_THRESHOLD** | Buffer exhaustion threshold (0.0-1.0). | `0.95` |
-| **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` |
-| **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` |
+| `GH_TOKEN` | `""` | Global GitHub Token (Requires 'Copilot Requests' permission). |
+| `ENABLE_OPENWEBUI_TOOLS` | `True` | Enable OpenWebUI Tools (includes defined Tools and Built-in Tools). |
+| `ENABLE_OPENAPI_SERVER` | `True` | Enable OpenAPI Tool Server connection. |
+| `ENABLE_MCP_SERVER` | `True` | Enable Direct MCP Client connection (Recommended). |
+| `REASONING_EFFORT` | `medium` | Reasoning effort level: low, medium, high. |
+| `SHOW_THINKING` | `True` | Show model reasoning/thinking process. |
+| `INFINITE_SESSION` | `True` | Enable Infinite Sessions (automatic context compaction). |
+| `MAX_MULTIPLIER` | `1.0` | Max allowed billing multiplier (0x for free models only). |
+| `EXCLUDE_KEYWORDS` | `""` | Exclude models containing these keywords (comma separated). |
+| `TIMEOUT` | `300` | Timeout for each stream chunk (seconds). |
+| `BYOK_TYPE` | `openai` | BYOK Provider Type: `openai`, `anthropic`. |
+| `BYOK_BASE_URL` | `""` | BYOK Base URL (e.g., <https://api.openai.com/v1>). |
+| `BYOK_MODELS` | `""` | BYOK Model List (comma separated). Leave empty to fetch from API. |
+| `CUSTOM_ENV_VARS` | `""` | Custom environment variables (JSON format). |
+| `DEBUG` | `False` | Enable this to see detailed logs in your browser console. |
 
-#### User Valves (per-user overrides)
+### 2. User Settings (Individual Overrides)
 
-These optional settings can be set per user (overrides global Valves):
+Standard users can override these settings in their individual Profile/Function settings.
 
-| Parameter | Description | Default |
-| :--- | :--- | :--- |
-| **GH_TOKEN** | Personal GitHub Token (overrides global setting). | - |
-| **REASONING_EFFORT** | Reasoning effort level (low/medium/high/xhigh). | - |
-| **DEBUG** | Enable technical debug logs. | `False` |
-| **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` |
+| Valve | Description |
+| :--- | :--- |
+| `GH_TOKEN` | Use your personal GitHub Token. |
+| `REASONING_EFFORT` | Individual reasoning effort preference. |
+| `SHOW_THINKING` | Show model reasoning/thinking process. |
+| `MAX_MULTIPLIER` | Maximum allowed billing multiplier override. |
+| `EXCLUDE_KEYWORDS` | Exclude models containing these keywords. |
+| `BYOK_API_KEY` | Use your personal OpenAI/Anthropic API Key. |
 
-| **BYOK_API_KEY** | BYOK API Key (User override). | - |
+---
+
+## 🎯 Use Cases (What can you do?)
+
+- **📁 Fully Autonomous DevOps**: Agent analyzes code, runs tests, and applies patches within its isolated sandbox.
+- **📊 Deep Data Auditing**: Directly process raw Excel/CSV data via Python (bypassing RAG) and generate visual reports.
+- **📝 Long-Task Management**: Automatically decomposes complex requests and persists TOD·O progress across sessions.
+
+---
 
 ## ⭐ 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.
+If this plugin has been useful, a **Star** on [Awesome OpenWebUI](https://github.com/Fu-Jie/awesome-openwebui) would be a great motivation for me. Thank you!
 
-### Get Token
+---
 
-To use GitHub Copilot, you need a GitHub Personal Access Token (PAT) with appropriate permissions.
+## 🚀 Installation & Configuration
 
-**Steps to generate your token:**
+### 1) Import Function
+
+1. Open OpenWebUI, go to **Workspace** -> **Functions**.
+2. Click **+** (Create Function), paste the content of `github_copilot_sdk.py`.
+3. Save and ensure it is enabled.
+
+### 2) Get Token
 
 1. Visit [GitHub Token Settings](https://github.com/settings/tokens?type=beta).
-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**.
-5. Generate and copy the Token.
+2. Create **Fine-grained token**, granting **Account permissions** -> **Copilot Requests** access.
+3. Paste the generated Token into the `GH_TOKEN` field in Valves.
 
-## 📋 Dependencies
+---
 
-This Pipe will automatically attempt to install the following dependencies:
+## 📋 Troubleshooting & Dependencies
 
-- `github-copilot-sdk` (Python package)
-- `github-copilot-cli` (Binary file, installed via official script)
+- **Agent ignores files?**: Ensure the Files Filter is enabled, otherwise RAG will interfere with raw binaries.
+- **No progress bar?**: The bar only appears when the Agent uses the `update_todo` tool.
+- **Dependencies**: This Pipe automatically installs `github-copilot-sdk` (Python) and `github-copilot-cli` (Binary).
 
-## 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.
+---
 
 ## Changelog
 
diff --git a/plugins/pipes/github-copilot-sdk/README_CN.md b/plugins/pipes/github-copilot-sdk/README_CN.md
index fb0d7ca..c008946 100644
--- a/plugins/pipes/github-copilot-sdk/README_CN.md
+++ b/plugins/pipes/github-copilot-sdk/README_CN.md
@@ -1,117 +1,123 @@
 # GitHub Copilot SDK 官方管道
 
-**作者:** [Fu-Jie](https://github.com/Fu-Jie/awesome-openwebui) | **版本:** 0.5.1 | **项目:** [Awesome OpenWebUI](https://github.com/Fu-Jie/awesome-openwebui) | **许可证:** MIT
+**作者:** [Fu-Jie](https://github.com/Fu-Jie/awesome-openwebui) | **版本:** 0.6.0 | **项目:** [Awesome OpenWebUI](https://github.com/Fu-Jie/awesome-openwebui) | **许可证:** MIT
 
-这是一个用于 [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 交互体验。
+这是一个用于 [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 SDK Files Filter](https://openwebui.com/posts/403a62ee-a596-45e7-be65-fab9cc249dd6)。
+
 > [!TIP]
-> **使用 BYOK 模式无需订阅**
-> 如果您使用自己的 API Key (OpenAI, Anthropic) 运行 BYOK 模式，**则完全不需要** GitHub Copilot 订阅。
-> 仅当您希望使用 GitHub 官方提供的模型时，才需要订阅。
+> **BYOK 模式无需订阅**
+> 如果您使用自带的 API Key (BYOK 模式对接 OpenAI/Anthropic)，**您不需要 GitHub Copilot 官方订阅**。只有在访问 GitHub 官方模型时才需要订阅。
 
-## 🚀 最新特性 (v0.5.1) - 重大升级
+---
 
-- **🧠 智能 BYOK 检测**: 优化了 BYOK 与官方 Copilot 模型的识别逻辑，完美支持自定义模型（角色/提示词）及倍率检测（如 `(0x)`, `(1x)`）。
-- **⚡ 性能飙升**: 引入 **工具缓存 (Tool Caching)** 机制，在请求间持久化工具定义，显著降低调用开销。
-- **🧩 丰富工具集成**: 工具描述现包含来源分组（内置/用户/服务器）及 Docstring 元数据自动解析。
-- **🛡️ 精确控制**: 完美兼容 OpenWebUI 全局函数过滤配置 (`function_name_filter_list`)，可精准控制暴露给 LLM 的函数。
-- **🔑 用户级 BYOK**: 支持在用户层面配置自定义 API Key 对接 AI 供应商（OpenAI, Anthropic）。
-- **📝 格式优化**: 系统提示词强制使用标准 Markdown 表格，彻底解决 HTML 表格渲染问题。
+## ✨ 0.6.0 更新内容 (What's New)
 
-## ✨ 核心能力
+- **👥 多用户与会话管理**: 采用 `user_id/chat_id` 的物理隔离架构，确保资源独立与稳健管理。
+- **🤖 赋予 Agent 文件自主权**: 自动将上传的文件同步至物理工作区，支持 Python 直接分析 Excel/CSV。
+- **🔧 OpenAPI & 外部工具修复**: 完美支持通过 OpenAPI 服务器挂载的工具调用。
+- **📊 计费与成本控制**: 增强的**计费倍率限制** (`MAX_MULTIPLIER`，例如设为 0 即仅限免费模型) 和**模型关键词过滤** (`EXCLUDE_KEYWORDS`)，实现更精准的成本管控。
+- **🧠 数据库持久化 TODO**: 任务进度跨会话保存，Agent 拥有更持久的任务记忆。
 
-- **🔑 灵活鉴权与 BYOK**: 支持 GitHub Copilot 订阅 (PAT) 或自带 Key (OpenAI/Anthropic)，完全掌控模型访问与计费。
-- **🌉 强大的生态桥接**: 首个且唯一完美打通 **OpenWebUI Tools** 与 **GitHub Copilot SDK** 的插件。
-- **🚀 官方原生产体验**: 基于官方 Python SDK 构建，提供最稳定、最纯正的 Copilot 交互体验。
+---
+
+## ✨ 核心能力 (Key Capabilities)
+
+- **🔑 灵活鉴权与 BYOK**: 支持 GitHub Copilot 官方订阅 (PAT) 或自带 Key (OpenAI/Anthropic)。
+- **🔌 通用工具协议**: 原生支持 **MCP (Model Context Protocol)**、OpenAPI 以及 OpenWebUI 内置工具。
+- **🛡️ 物理级工作区隔离**: 强制执行严格的用户特定沙箱，确保数据隐私与文件安全。
+- **♾️ 无限会话管理**: 智能上下文窗口管理与自动压缩算法，支持无限时长的对话交互。
+- **🧠 深度数据库集成**: 实时持久化 TOD·O 列表到 UI 进度条。
 - **🌊 深度推理展示**: 完整支持模型思考过程 (Thinking Process) 的流式渲染。
-- **🖼️ 智能多模态**: 支持图像识别与附件上传，让 Copilot 拥有视觉能力。
-- **🛠️ 极简部署流程**: 自动检测环境、自动下载 CLI、自动管理依赖，全自动化开箱即用。
-- **🛡️ 纯净安全体系**: 支持标准 PAT 认证，确保数据安全。
+- **🖼️ 智能多模态**: 完整支持图像识别与附件上传分析。
+- **⚡ 交互式伪影 (Artifacts)**: 自动渲染 Agent 生成的 HTML/JS 应用程序，直接在聊天界面交互。
 
-## 安装与配置
+---
 
-### 1. 导入函数
+## ⚙️ 核心配置参数 (Valves)
 
-1. 打开 OpenWebUI。
-2. 进入 **Workspace** -> **Functions**。
-3. 点击 **+** (创建函数)。
-4. 将 `github_copilot_sdk_cn.py` 的内容完整粘贴进去。
-5. 保存。
+### 1. 管理员配置 (基础设置)
 
-### 2. 配置 Valves (设置)
+管理员可在函数设置中定义全局默认行为。
 
-在函数列表中找到 "GitHub Copilot"，点击 **⚙️ (Valves)** 图标进行配置：
-
-| 参数 | 说明 | 默认值 |
+| 参数 | 默认值 | 说明 |
 | :--- | :--- | :--- |
-| **GH_TOKEN** | **(必填)** GitHub 访问令牌 (PAT 或 OAuth Token)。用于聊天。 | - |
-| **DEBUG** | 是否开启调试日志（输出到浏览器控制台）。 | `False` |
-| **LOG_LEVEL** | Copilot CLI 日志级别: none, error, warning, info, debug, all。 | `error` |
-| **SHOW_THINKING** | 是否显示模型推理/思考过程（需开启流式 + 模型支持）。 | `True` |
-| **COPILOT_CLI_VERSION** | 指定安装/强制使用的 Copilot CLI 版本。 | `0.0.405` |
-| **EXCLUDE_KEYWORDS** | 排除包含这些关键词的模型（逗号分隔）。 | - |
-| **WORKSPACE_DIR** | 文件操作的受限工作区目录。 | - |
-| **INFINITE_SESSION** | 启用无限会话（自动上下文压缩）。 | `True` |
-| **COMPACTION_THRESHOLD** | 后台压缩阈值 (0.0-1.0)。 | `0.8` |
-| **BUFFER_THRESHOLD** | 缓冲区耗尽阈值 (0.0-1.0)。 | `0.95` |
-| **TIMEOUT** | 每个流式分块超时（秒）。 | `300` |
-| **CUSTOM_ENV_VARS** | 自定义环境变量 (JSON 格式)。 | - |
-| **REASONING_EFFORT** | 推理强度级别: low, medium, high. `xhigh` 仅部分模型支持。 | `medium` |
-| **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` |
+| `GH_TOKEN` | `""` | 全局 GitHub Token (需具备 'Copilot Requests' 权限)。 |
+| `ENABLE_OPENWEBUI_TOOLS` | `True` | 启用 OpenWebUI 工具 (包括定义工具和内置工具)。 |
+| `ENABLE_OPENAPI_SERVER` | `True` | 启用 OpenAPI 工具服务器连接。 |
+| `ENABLE_MCP_SERVER` | `True` | 启用直接 MCP 客户端连接 (推荐)。 |
+| `REASONING_EFFORT` | `medium` | 推理强度：low, medium, high。 |
+| `SHOW_THINKING` | `True` | 显示模型推理/思考过程。 |
+| `INFINITE_SESSION` | `True` | 启用无限会话 (自动上下文压缩)。 |
+| `MAX_MULTIPLIER` | `1.0` | 最大允许的模型计费倍率 (0x 为仅限免费模型)。 |
+| `EXCLUDE_KEYWORDS` | `""` | 排除包含这些关键字的模型 (逗号分隔)。 |
+| `TIMEOUT` | `300` | 每个流数据块的超时时间 (秒)。 |
+| `BYOK_TYPE` | `openai` | BYOK 服务商类型：`openai`, `anthropic`。 |
+| `BYOK_BASE_URL` | `""` | BYOK 基础 URL (例如: <https://api.openai.com/v1)。> |
+| `BYOK_MODELS` | `""` | BYOK 模型列表 (逗号分隔)。留空则从 API 获取。 |
+| `CUSTOM_ENV_VARS` | `""` | 自定义环境变量 (JSON 格式)。 |
+| `DEBUG` | `False` | 开启此项以在前端控制台输出详细调试日志。 |
 
-#### 用户 Valves（按用户覆盖）
+### 2. 用户配置 (个人覆盖)
 
-以下设置可按用户单独配置（覆盖全局 Valves）：
+普通用户可在各自的个人设置中根据需要覆盖以下参数。
 
-| 参数 | 说明 | 默认值 |
-| :--- | :--- | :--- |
-| **GH_TOKEN** | 个人 GitHub Token（覆盖全局设置）。 | - |
-| **REASONING_EFFORT** | 推理强度级别（low/medium/high/xhigh）。 | - |
-| **DEBUG** | 是否启用技术调试日志。 | `False` |
-| **SHOW_THINKING** | 是否显示思考过程。 | `True` |
-| **ENABLE_OPENWEBUI_TOOLS** | 启用 OpenWebUI 工具（覆盖全局设置）。 | `True` |
-| **ENABLE_MCP_SERVER** | 启用动态 MCP 服务器加载（覆盖全局设置）。 | `True` |
+| 参数 | 说明 |
+| :--- | :--- |
+| `GH_TOKEN` | 使用个人的 GitHub Token。 |
+| `REASONING_EFFORT`| 个人偏好的推理强度。 |
+| `SHOW_THINKING` | 显示模型推理/思考过程。 |
+| `MAX_MULTIPLIER` | 最大允许的模型计费倍率覆盖。 |
+| `EXCLUDE_KEYWORDS` | 排除包含这些关键字的模型。 |
+| `BYOK_API_KEY` | 使用个人的 OpenAI/Anthropic API Key。 |
 
-## ⭐ 支持
+---
 
-如果这个插件对你有帮助，欢迎到 [Awesome OpenWebUI](https://github.com/Fu-Jie/awesome-openwebui) 点个 Star，这将是我持续改进的动力，感谢支持。
+## 🎯 典型应用场景 (Use Cases)
 
-### 获取 Token
+- **📁 全自主仓库维护**: Agent 在隔离工作区内自动分析代码、运行测试并应用补丁。
+- **📊 深度财务数据审计**: 直接通过 Python 加载 Excel/CSV 原始数据（绕过 RAG），生成图表并实时预览。
+- **📝 长任务项目管理**: 自动拆解复杂任务并持久化 TOD·O 进度，跨会话跟踪执行状态。
 
-要使用 GitHub Copilot，您需要一个具有适当权限的 GitHub 个人访问令牌 (PAT)。
+---
 
-**获取步骤：**
+## ⭐ 支持与交流 (Support)
 
-1. 访问 [GitHub 令牌设置](https://github.com/settings/tokens?type=beta)。
-2. 点击 **Generate new token (fine-grained)**。
-3. **Repository access**: 选择 **Public Repositories** (最简单) 或 **All repositories**。
-4. **Permissions**:
-    - 如果您选择了 **All repositories**，则必须点击 **Account permissions**。
-    - 找到 **Copilot Requests**，选择 **Access**。
-5. 生成并复制令牌。
+如果这个插件对您有所帮助，请在 [Awesome OpenWebUI](https://github.com/Fu-Jie/awesome-openwebui) 项目上点个 **Star** 💫，这是对我最大的鼓励。
 
-## 📋 依赖说明
+---
 
-该 Pipe 会自动尝试安装以下依赖（如果环境中缺失）：
+## 🚀 安装与配置 (Installation)
 
-- `github-copilot-sdk` (Python 包)
-- `github-copilot-cli` (二进制文件，通过官方脚本安装)
+### 1) 导入函数
 
-## 故障排除 (Troubleshooting) ❓
+1. 打开 OpenWebUI，前往 **工作区** -> **函数**。
+2. 点击 **+** (创建函数)，完整粘贴 `github_copilot_sdk_cn.py` 的内容。
+3. 点击保存并确保已启用。
 
-- **图片及多模态使用说明**：
-  - 确保 `MODEL_ID` 是支持多模态的模型。
-- **看不到思考过程**：
-  - 确认已开启**流式输出**，且所选模型支持推理输出。
+### 2) 获取 Token (Get Token)
 
-## 更新日志
+1. 访问 [GitHub Token 设置](https://github.com/settings/tokens?type=beta)。
+2. 创建 **Fine-grained token**，授予 **Account permissions** -> **Copilot Requests** 访问权限。
+3. 将生成的 Token 填入插件的 `GH_TOKEN` 配置项中。
 
-完整历史请查看 GitHub 项目： [Awesome OpenWebUI](https://github.com/Fu-Jie/awesome-openwebui)
+### 3) 配套插件 (强烈推荐)
+
+为了获得最佳的文件处理体验，请安装 [GitHub Copilot SDK Files Filter](https://openwebui.com/posts/403a62ee-a596-45e7-be65-fab9cc249dd6)。
+
+---
+
+## 📋 常见问题与依赖 (Troubleshooting)
+
+- **Agent 无法识别文件？**: 请确保已安装并启用了 Files Filter 插件，否则原始文件会被 RAG 干扰。
+- **看不到 TODO 进度条？**: 进度条仅在 Agent 使用 `update_todo` 工具（通常是处理复杂任务）时出现。
+- **依赖安装**: 本管道会自动尝试安装 `github-copilot-sdk` (Python 包) 和 `github-copilot-cli` (官方二进制)。
+
+---
+
+## 更新日志 (Changelog)
+
+完整历史记录请见 GitHub: [Awesome OpenWebUI](https://github.com/Fu-Jie/awesome-openwebui)
diff --git a/plugins/pipes/github-copilot-sdk/github_copilot_sdk.py b/plugins/pipes/github-copilot-sdk/github_copilot_sdk.py
index 5870523..77266a1 100644
--- a/plugins/pipes/github-copilot-sdk/github_copilot_sdk.py
+++ b/plugins/pipes/github-copilot-sdk/github_copilot_sdk.py
@@ -5,7 +5,7 @@ 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.5.1
+version: 0.6.0
 requirements: github-copilot-sdk==0.1.23
 """
 
@@ -20,11 +20,19 @@ import shutil
 import subprocess
 import hashlib
 import aiohttp
+import contextlib
+import traceback
 from pathlib import Path
 from typing import Optional, Union, AsyncGenerator, List, Any, Dict, Literal, Tuple
 from types import SimpleNamespace
 from pydantic import BaseModel, Field, create_model
 
+# Database imports
+from sqlalchemy import Column, String, Text, DateTime, Integer, JSON, inspect
+from sqlalchemy.orm import declarative_base, sessionmaker
+from sqlalchemy.engine import Engine
+from datetime import datetime, timezone
+
 # Import copilot SDK modules
 from copilot import CopilotClient, define_tool
 
@@ -37,47 +45,126 @@ from open_webui.utils.tools import get_tools as get_openwebui_tools, get_builtin
 from open_webui.models.tools import Tools
 from open_webui.models.users import Users
 
+# Open WebUI internal database (re-use shared connection)
+try:
+    from open_webui.internal import db as owui_db
+except ImportError:
+    owui_db = None
+
 # Setup logger
 logger = logging.getLogger(__name__)
 
-FORMATTING_GUIDELINES = (
+
+def _discover_owui_engine(db_module: Any) -> Optional[Engine]:
+    """Discover the Open WebUI SQLAlchemy engine via provided db module helpers."""
+    if db_module is None:
+        return None
+
+    db_context = getattr(db_module, "get_db_context", None) or getattr(
+        db_module, "get_db", None
+    )
+    if callable(db_context):
+        try:
+            with db_context() as session:
+                try:
+                    return session.get_bind()
+                except AttributeError:
+                    return getattr(session, "bind", None) or getattr(
+                        session, "engine", None
+                    )
+        except Exception as exc:
+            logger.error(f"[DB Discover] get_db_context failed: {exc}")
+
+    for attr in ("engine", "ENGINE", "bind", "BIND"):
+        candidate = getattr(db_module, attr, None)
+        if candidate is not None:
+            return candidate
+
+    return None
+
+
+owui_engine = _discover_owui_engine(owui_db)
+owui_Base = (
+    getattr(owui_db, "Base", None) if owui_db is not None else declarative_base()
+)
+
+
+class ChatTodo(owui_Base):
+    """Chat Todo Storage Table"""
+
+    __tablename__ = "chat_todos"
+    __table_args__ = {"extend_existing": True}
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    chat_id = Column(String(255), unique=True, nullable=False, index=True)
+    content = Column(Text, nullable=False)
+    metrics = Column(JSON, nullable=True)  # {"total": 39, "completed": 0, "percent": 0}
+    updated_at = Column(
+        DateTime,
+        default=lambda: datetime.now(timezone.utc),
+        onupdate=lambda: datetime.now(timezone.utc),
+    )
+
+
+# Base guidelines for all users
+BASE_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"
+    "You are an AI assistant operating within a high-capability Linux container environment (OpenWebUI).\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"
+    "**System Environment & User Privileges:**\n"
+    "- **Output Environment**: You are rendering in the **OpenWebUI Chat Page**, a modern, interactive web interface. Optimize your output format to leverage Markdown for the best UI experience.\n"
+    "- **Root Access**: You are running as **root**. You have **READ access to the entire container file system** but you **MUST ONLY WRITE** to your designated persistent workspace directory (structured as `.../user_id/chat_id/`). All other system areas are strictly READ-ONLY.\n"
+    "- **STRICT FILE CREATION RULE**: You are **PROHIBITED** from creating or editing files outside of your specific workspace path. Never place files in `/root`, `/tmp`, or `/app` (unless specifically instructed for analysis, but writing is banned). Every file operation (`create`, `edit`, `bash`) MUST use the absolute path provided in your `Session Context` below.\n"
+    "- **Filesystem Layout (/app)**:\n"
+    "  - `/app/backend`: Python backend source code. You can analyze core package logic here.\n"
+    "  - `/app/build`: Compiled frontend assets (assets, static, pyodide, index.html).\n"
+    "- **Rich Python Environment**: You can natively import and use any installed OpenWebUI dependencies. You have access to a wealth of libraries (e.g., for data processing, utility functions). However, you **MUST NOT** install new packages in the global environment. If you need additional dependencies, you must create a virtual environment within your designated workspace directory.\n"
+    "- **Tool Availability**: You may have access to various tools (OpenWebUI Built-ins, Custom Tools, OpenAPI Servers, or MCP Servers) depending on the user's current configuration. If tools are visible in your session metadata, use them proactively to enhance your task execution.\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"
+    "1. **Markdown Excellence**: Leverage full **Markdown** capabilities (headers, bold, italics, tables, lists) to structure your response professionally for the chat interface.\n"
+    "2. **Advanced Visualization**: Use **Mermaid** for flowcharts/diagrams and **LaTeX** for math. **IMPORTANT**: Always wrap Mermaid code within a standard ` ```mermaid ` code block to ensure it is rendered correctly by the UI.\n"
+    "3. **Interactive Artifacts (HTML)**: Standalone HTML code blocks (HTML+CSS+JS) will be **AUTOMATICALLY RENDERED** as interactive web pages within the chat. **Dual Delivery Protocol**: For web applications, you MUST perform two actions:\n"
+    "   - 1. **Persist**: Create the file in the workspace (e.g., `index.html`) for project structure.\n"
+    "   - 2. **Render**: Immediately output the SAME code in a ` ```html ` block so the user can interact with it.\n"
+    "   - **Result**: The user gets both a saved file AND a live app. Never force the user to choose one over the other.\n"
+    "4. **Images & Files**: ALWAYS embed generated images/files directly using `![caption](url)`. Never provide plain text links.\n"
+    "5. **TODO Visibility**: Every time you call the `update_todo` tool, you **MUST** immediately follow up with a beautifully formatted **Markdown summary** of the current TODO list. Use task checkboxes (`- [ ]`), progress indicators, and clear headings so the user can see the status directly in the chat.\n"
+    "6. **Python Execution Standard**: For ANY task requiring Python logic (not just data analysis), you **MUST NOT** embed multi-line code directly in a shell command (e.g., using `python -c` or `<< 'EOF'`).\n"
+    '   - **Exception**: Trivial one-liners (e.g., `python -c "print(1+1)"`) are permitted.\n'
+    "   - **Protocol**: For everything else, you MUST:\n"
+    "     1. **Create** a `.py` file in the workspace (e.g., `script.py`).\n"
+    "     2. **Run** it using `python3 script.py`.\n"
+    "   - **Reason**: This ensures code is debuggable, readable, and persistent.\n"
+    "7. **Active & Autonomous**: You are an expert engineer. **DO NOT** ask for permission to proceed with obvious steps. **DO NOT** stop to ask 'Shall I continue?'.\n"
+    "   - **Behavior**: Analyze the user's request -> Formulate a plan -> **EXECUTE** the plan immediately.\n"
+    "   - **Clarification**: Only ask questions if the request is ambiguous or carries high risk (e.g., destructive actions).\n"
+    "   - **Goal**: Minimize user friction. Deliver results, not questions.\n"
+    "8. **Large Output Management**: If a tool execution output is truncated or saved to a temporary file (e.g., `/tmp/...`), DO NOT worry. The system will automatically move it to your workspace and notify you of the new filename. You can then read it directly.\n"
+)
+
+# Sensitive extensions only for Administrators
+ADMIN_EXTENSIONS = (
+    "\n**[ADMINISTRATOR PRIVILEGES - CONFIDENTIAL]**\n"
+    "You have detected that the current user is an **ADMINISTRATOR**. You are granted additional 'God Mode' perspective:\n"
+    "- **Full OS Interaction**: You can use shell tools to deep-dive into any container process or system configuration.\n"
+    "- **Database Access**: You can connect to the **OpenWebUI Database** directly using credentials found in environment variables (e.g., `DATABASE_URL`).\n"
+    "- **Copilot SDK & Metadata**: You can inspect your own session state in `/root/.copilot/session-state/` and core configuration in `/root/.copilot/config.json` to debug session persistence.\n"
+    "- **Environment Secrets**: You are permitted to read and analyze environment variables and system-wide secrets for diagnostic purposes.\n"
+    "**SECURITY NOTE**: Do NOT leak these sensitive internal details to non-admin users if you are ever switched to a lower privilege context.\n"
+)
+
+# Strict restrictions for regular Users
+USER_RESTRICTIONS = (
+    "\n**[USER ACCESS RESTRICTIONS - STRICT]**\n"
+    "You have detected that the current user is a **REGULAR USER**. You must adhere to the following security boundaries:\n"
+    "- **NO Environment Access**: You are strictly **FORBIDDEN** from accessing environment variables (e.g., via `env`, `printenv`, or Python's `os.environ`).\n"
+    "- **NO Database Access**: You must **NOT** attempt to connect to or query the OpenWebUI database.\n"
+    "- **NO System Metadata Access**: Access to `/root/.copilot/` or any system-level configuration files is strictly **PROHIBITED**.\n"
+    "- **NO Writing Outside Workspace**: Any attempt to write files to `/root`, `/app`, `/etc`, or other system folders is a **SECURITY VIOLATION**. All generated code, HTML, or data artifacts MUST be saved strictly inside the `Your Isolated Workspace` path provided.\n"
+    "- **Interactive Delivery**: When creating web/HTML content, you MUST accompanying the file creation with a rendered Artifact (` ```html ` block). Providing *only* a file path for a web app is considered a poor user experience.\n"
+    "- **Restricted Shell**: Use shell tools **ONLY** for operations within your isolated workspace sub-directory. You are strictly **PROHIBITED** from exploring or reading other users' workspace directories. Any attempt to probe system secrets or cross-user data will be logged as a security violation.\n"
+    "**SECURITY NOTE**: Your priority is to protect the platform's integrity while providing helpful assistance within these boundaries.\n"
 )
 
 
@@ -89,7 +176,11 @@ class Pipe:
         )
         ENABLE_OPENWEBUI_TOOLS: bool = Field(
             default=True,
-            description="Enable OpenWebUI Tools (includes defined Tools and Tool Server Tools).",
+            description="Enable OpenWebUI Tools (includes defined Tools and Built-in Tools).",
+        )
+        ENABLE_OPENAPI_SERVER: bool = Field(
+            default=True,
+            description="Enable OpenAPI Tool Server connection.",
         )
         ENABLE_MCP_SERVER: bool = Field(
             default=True,
@@ -124,18 +215,18 @@ class Pipe:
             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.",
-        )
         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.",
+            default="0.0.406",
+            description="Specific Copilot CLI version to install/enforce (e.g. '0.0.406'). Leave empty for latest.",
         )
         EXCLUDE_KEYWORDS: str = Field(
             default="",
             description="Exclude models containing these keywords (comma separated, e.g.: codex, haiku)",
         )
+        MAX_MULTIPLIER: float = Field(
+            default=1.0,
+            description="Maximum allowed billing multiplier for standard Copilot models. 0 means only free models (0x). Set to a high value (e.g., 100) to allow all.",
+        )
         COMPACTION_THRESHOLD: float = Field(
             default=0.8,
             description="Background compaction threshold (0.0-1.0)",
@@ -148,6 +239,10 @@ class Pipe:
             default="",
             description='Custom environment variables (JSON format, e.g., {"VAR": "value"})',
         )
+        OPENWEBUI_UPLOAD_PATH: str = Field(
+            default="/app/backend/data/uploads",
+            description="Path to OpenWebUI uploads directory (for file processing).",
+        )
 
         BYOK_TYPE: Literal["openai", "anthropic"] = Field(
             default="openai",
@@ -191,9 +286,21 @@ class Pipe:
             default=False,
             description="Enable technical debug logs (connection info, etc.)",
         )
+        MAX_MULTIPLIER: Optional[float] = Field(
+            default=None,
+            description="Maximum allowed billing multiplier override for standard Copilot models.",
+        )
+        EXCLUDE_KEYWORDS: str = Field(
+            default="",
+            description="Exclude models containing these keywords (comma separated, user override).",
+        )
         ENABLE_OPENWEBUI_TOOLS: bool = Field(
             default=True,
-            description="Enable OpenWebUI Tools (includes defined Tools and Tool Server Tools).",
+            description="Enable OpenWebUI Tools (includes defined Tools and Built-in Tools).",
+        )
+        ENABLE_OPENAPI_SERVER: bool = Field(
+            default=True,
+            description="Enable OpenAPI Tool Server loading (overrides global).",
         )
         ENABLE_MCP_SERVER: bool = Field(
             default=True,
@@ -243,11 +350,127 @@ class Pipe:
 
     def __init__(self):
         self.type = "pipe"
-        self.id = "copilot"
+        self.id = "github_copilot_sdk"
         self.name = "copilotsdk"
         self.valves = self.Valves()
         self.temp_dir = tempfile.mkdtemp(prefix="copilot_images_")
 
+        # Database initialization
+        self._owui_db = owui_db
+        self._db_engine = owui_engine
+        self._fallback_session_factory = (
+            sessionmaker(bind=self._db_engine) if self._db_engine else None
+        )
+        self._init_database()
+
+    def _init_database(self):
+        """Initializes the database table using Open WebUI's shared connection."""
+        try:
+            if self._db_engine is None:
+                return
+
+            # Check if table exists using SQLAlchemy inspect
+            inspector = inspect(self._db_engine)
+            if not inspector.has_table("chat_todos"):
+                # Create the chat_todos table if it doesn't exist
+                ChatTodo.__table__.create(bind=self._db_engine, checkfirst=True)
+                logger.info("[Database] ✅ Successfully created chat_todos table.")
+        except Exception as e:
+            logger.error(f"[Database] ❌ Initialization failed: {str(e)}")
+
+    @contextlib.contextmanager
+    def _db_session(self):
+        """Yield a database session using Open WebUI helpers with graceful fallbacks."""
+        db_module = self._owui_db
+        db_context = None
+        if db_module is not None:
+            db_context = getattr(db_module, "get_db_context", None) or getattr(
+                db_module, "get_db", None
+            )
+
+        if callable(db_context):
+            with db_context() as session:
+                yield session
+                return
+
+        factory = None
+        if db_module is not None:
+            factory = getattr(db_module, "SessionLocal", None) or getattr(
+                db_module, "ScopedSession", None
+            )
+        if callable(factory):
+            session = factory()
+            try:
+                yield session
+            finally:
+                close = getattr(session, "close", None)
+                if callable(close):
+                    close()
+            return
+
+        if self._fallback_session_factory is None:
+            raise RuntimeError("Open WebUI database session is unavailable.")
+
+        session = self._fallback_session_factory()
+        try:
+            yield session
+        finally:
+            try:
+                session.close()
+            except:
+                pass
+
+    def _save_todo_to_db(
+        self,
+        chat_id: str,
+        content: str,
+        __event_emitter__=None,
+        __event_call__=None,
+        debug_enabled: bool = False,
+    ):
+        """Saves the TODO list to the database and emits status."""
+        try:
+            # 1. Parse metrics
+            total = content.count("- [ ]") + content.count("- [x]")
+            completed = content.count("- [x]")
+            percent = int((completed / total * 100)) if total > 0 else 0
+            metrics = {"total": total, "completed": completed, "percent": percent}
+
+            # 2. Database persistent
+            with self._db_session() as session:
+                existing = session.query(ChatTodo).filter_by(chat_id=chat_id).first()
+                if existing:
+                    existing.content = content
+                    existing.metrics = metrics
+                    existing.updated_at = datetime.now(timezone.utc)
+                else:
+                    new_todo = ChatTodo(
+                        chat_id=chat_id, content=content, metrics=metrics
+                    )
+                    session.add(new_todo)
+                session.commit()
+
+            self._emit_debug_log_sync(
+                f"DB: Saved TODO for chat {chat_id} (Progress: {percent}%)",
+                __event_call__,
+                debug_enabled=debug_enabled,
+            )
+
+            # 3. Emit status to OpenWebUI
+            if __event_emitter__:
+                status_msg = f"📝 TODO Progress: {percent}% ({completed}/{total})"
+                asyncio.run_coroutine_threadsafe(
+                    __event_emitter__(
+                        {
+                            "type": "status",
+                            "data": {"description": status_msg, "done": True},
+                        }
+                    ),
+                    asyncio.get_event_loop(),
+                )
+        except Exception as e:
+            logger.error(f"[Database] ❌ Failed to save todo: {e}")
+
     def __del__(self):
         try:
             shutil.rmtree(self.temp_dir)
@@ -283,27 +506,21 @@ class Pipe:
     # ==================== Custom Tool Examples ====================
     # Tool registration: Add @define_tool decorated functions at module level,
     # then register them in _initialize_custom_tools() -> all_tools dict.
-    async def _initialize_custom_tools(self, __user__=None, __event_call__=None):
+    async def _initialize_custom_tools(
+        self, body: dict = None, __user__=None, __event_call__=None
+    ):
         """Initialize custom tools based on configuration"""
-        if not self.valves.ENABLE_OPENWEBUI_TOOLS:
+        # 1. Determine effective settings (User override > Global)
+        uv = self._get_user_valves(__user__)
+        enable_tools = uv.ENABLE_OPENWEBUI_TOOLS
+        enable_openapi = uv.ENABLE_OPENAPI_SERVER
+        enable_cache = uv.ENABLE_TOOL_CACHE
+
+        # 2. If all tool types are disabled, return empty immediately
+        if not enable_tools and not enable_openapi:
             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
+        # 3. Check Cache
         if enable_cache and self._tool_cache is not None:
             await self._emit_debug_log(
                 "ℹ️ Using cached OpenWebUI tools.", __event_call__
@@ -312,7 +529,11 @@ class Pipe:
 
         # Load OpenWebUI tools dynamically
         openwebui_tools = await self._load_openwebui_tools(
-            __user__=__user__, __event_call__=__event_call__
+            body=body,
+            __user__=__user__,
+            __event_call__=__event_call__,
+            enable_tools=enable_tools,
+            enable_openapi=enable_openapi,
         )
 
         # Update Cache
@@ -371,7 +592,9 @@ class Pipe:
 
         return Any
 
-    def _convert_openwebui_tool(self, tool_name: str, tool_dict: dict):
+    def _convert_openwebui_tool(
+        self, tool_name: str, tool_dict: dict, __event_call__=None
+    ):
         """Convert OpenWebUI tool definition to Copilot SDK tool."""
         # Sanitize tool name to match pattern ^[a-zA-Z0-9_-]+$
         sanitized_tool_name = re.sub(r"[^a-zA-Z0-9_-]", "_", tool_name)
@@ -500,7 +723,39 @@ class Pipe:
                 if hasattr(params, "model_dump")
                 else {}
             )
-            return await tool_callable(**payload)
+
+            try:
+                if self.valves.DEBUG:
+                    await self._emit_debug_log(
+                        f"🛠️ Invoking {sanitized_tool_name} with params: {list(payload.keys())}",
+                        __event_call__,
+                    )
+
+                result = await tool_callable(**payload)
+
+                # Special handling for OpenAPI tools which return (data, headers) tuple
+                if isinstance(result, tuple) and len(result) == 2:
+                    data, headers = result
+                    # Basic heuristic to detect response headers (aiohttp headers or dict)
+                    if hasattr(headers, "get") and hasattr(headers, "items"):
+                        if self.valves.DEBUG:
+                            await self._emit_debug_log(
+                                f"✅ {sanitized_tool_name} returned tuple, extracting data.",
+                                __event_call__,
+                            )
+                        return data
+
+                return result
+            except Exception as e:
+                # detailed traceback
+                err_msg = f"{str(e)}"
+                await self._emit_debug_log(
+                    f"❌ Tool Execution Failed '{sanitized_tool_name}': {err_msg}",
+                    __event_call__,
+                )
+
+                # Re-raise with a clean message so the LLM sees the error
+                raise RuntimeError(f"Tool {sanitized_tool_name} failed: {err_msg}")
 
         _tool.__name__ = sanitized_tool_name
         _tool.__doc__ = tool_description
@@ -517,7 +772,7 @@ class Pipe:
             params_type=ParamsModel,
         )(_tool)
 
-    def _build_openwebui_request(self, user: dict = None):
+    def _build_openwebui_request(self, user: dict = None, token: str = None):
         """Build a more complete request-like object with dynamically loaded OpenWebUI configs."""
         # Dynamically build config from the official registry
         config = SimpleNamespace()
@@ -529,6 +784,14 @@ class Pipe:
                 val = val.value
             setattr(config, item.env_name, val)
 
+        # Critical Fix: Explicitly sync TOOL_SERVER_CONNECTIONS to ensure OpenAPI tools work
+        # PERSISTENT_CONFIG_REGISTRY might not contain TOOL_SERVER_CONNECTIONS in all versions
+        if not hasattr(config, "TOOL_SERVER_CONNECTIONS"):
+            if hasattr(TOOL_SERVER_CONNECTIONS, "value"):
+                config.TOOL_SERVER_CONNECTIONS = TOOL_SERVER_CONNECTIONS.value
+            else:
+                config.TOOL_SERVER_CONNECTIONS = TOOL_SERVER_CONNECTIONS
+
         app_state = SimpleNamespace(
             config=config,
             TOOLS={},
@@ -536,6 +799,8 @@ class Pipe:
             FUNCTIONS={},
             FUNCTION_CONTENTS={},
             MODELS={},
+            redis=None,  # Crucial: prevent AttributeError in get_tool_servers
+            TOOL_SERVERS=[],  # Initialize as empty list
         )
 
         def url_path_for(name: str, **path_params):
@@ -550,6 +815,14 @@ class Pipe:
         )
 
         # Mocking generic request attributes
+        req_headers = {
+            "user-agent": "Mozilla/5.0 (OpenWebUI Plugin/GitHub-Copilot-SDK)",
+            "host": "localhost:8080",
+            "accept": "*/*",
+        }
+        if token:
+            req_headers["Authorization"] = f"Bearer {token}"
+
         request = SimpleNamespace(
             app=app,
             url=SimpleNamespace(
@@ -558,20 +831,24 @@ class Pipe:
                 __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": "*/*",
-            },
+            headers=req_headers,
             method="POST",
             cookies={},
             state=SimpleNamespace(
-                token=SimpleNamespace(credentials=""), user=user if user else {}
+                token=SimpleNamespace(credentials=token if token else ""),
+                user=user if user else {},
             ),
         )
         return request
 
-    async def _load_openwebui_tools(self, __user__=None, __event_call__=None):
+    async def _load_openwebui_tools(
+        self,
+        body: dict = None,
+        __user__=None,
+        __event_call__=None,
+        enable_tools: bool = True,
+        enable_openapi: bool = True,
+    ):
         """Load OpenWebUI tools and convert them to Copilot SDK tools."""
         if isinstance(__user__, (list, tuple)):
             user_data = __user__[0] if __user__ else {}
@@ -587,31 +864,119 @@ class Pipe:
         if not user_id:
             return []
 
+        # --- PROBE LOG ---
+        if __event_call__:
+            conn_status = "Missing"
+            if hasattr(TOOL_SERVER_CONNECTIONS, "value"):
+                val = TOOL_SERVER_CONNECTIONS.value
+                conn_status = (
+                    f"List({len(val)})" if isinstance(val, list) else str(type(val))
+                )
+
+            await self._emit_debug_log(
+                f"[Tools Debug] Entry. UserID: {user_id}, EnableTools: {enable_tools}, EnableOpenAPI: {enable_openapi}, Connections: {conn_status}",
+                __event_call__,
+                debug_enabled=True,
+            )
+        # -----------------
+
         user = Users.get_user_by_id(user_id)
         if not user:
             return []
 
+        tool_ids = []
         # 1. Get User defined tools (Python scripts)
-        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 []
+        if enable_tools:
+            tool_items = Tools.get_tools_by_user_id(user_id, permission="read")
+            if tool_items:
+                tool_ids.extend([tool.id for tool in tool_items])
 
         # 2. Get OpenAPI Tool Server tools
-        # We manually add enabled OpenAPI servers to the list because Tools.get_tools_by_user_id only checks the DB.
-        # open_webui.utils.tools.get_tools handles the actual loading and access control.
-        if hasattr(TOOL_SERVER_CONNECTIONS, "value"):
-            for server in TOOL_SERVER_CONNECTIONS.value:
-                # We only add 'openapi' servers here because get_tools currently only supports 'openapi' (or defaults to it).
-                # MCP tools are handled separately via ENABLE_MCP_SERVER.
-                if server.get("type") == "openapi":
-                    # Format expected by get_tools: "server:<id>" implies types="openapi"
-                    server_id = server.get("id")
-                    if server_id:
-                        tool_ids.append(f"server:{server_id}")
+        if enable_openapi:
+            if hasattr(TOOL_SERVER_CONNECTIONS, "value"):
+                raw_connections = TOOL_SERVER_CONNECTIONS.value
 
-        if not tool_ids:
+                # Handle Pydantic model vs List vs Dict
+                connections = []
+                if isinstance(raw_connections, list):
+                    connections = raw_connections
+                elif hasattr(raw_connections, "dict"):
+                    connections = raw_connections.dict()
+                elif hasattr(raw_connections, "model_dump"):
+                    connections = raw_connections.model_dump()
+
+                # Debug logging for connections
+                if self.valves.DEBUG:
+                    await self._emit_debug_log(
+                        f"[Tools] Found {len(connections)} server connections (Type: {type(raw_connections)})",
+                        __event_call__,
+                    )
+
+                for idx, server in enumerate(connections):
+                    # Handle server item type
+                    s_type = (
+                        server.get("type", "openapi")
+                        if isinstance(server, dict)
+                        else getattr(server, "type", "openapi")
+                    )
+
+                    # Handle server ID: Priority info.id > server.id > index
+                    s_id = None
+                    if isinstance(server, dict):
+                        info = server.get("info", {})
+                        s_id = info.get("id") or server.get("id")
+                    else:
+                        info = getattr(server, "info", {})
+                        if isinstance(info, dict):
+                            s_id = info.get("id")
+                        else:
+                            s_id = getattr(info, "id", None)
+
+                        if not s_id:
+                            s_id = getattr(server, "id", None)
+
+                    if not s_id:
+                        s_id = str(idx)
+
+                    if self.valves.DEBUG:
+                        await self._emit_debug_log(
+                            f"[Tools] Checking Server: ID={s_id}, Type={s_type}",
+                            __event_call__,
+                        )
+
+                    if s_type == "openapi":
+                        # Ensure we don't add empty IDs, though fallback to idx should prevent this
+                        if s_id:
+                            tool_ids.append(f"server:{s_id}")
+                    elif self.valves.DEBUG:
+                        await self._emit_debug_log(
+                            f"[Tools] Skipped non-OpenAPI server: {s_id} ({s_type})",
+                            __event_call__,
+                        )
+
+        if (
+            not tool_ids and not enable_tools
+        ):  # No IDs and no built-ins either if tools disabled
+            if self.valves.DEBUG:
+                await self._emit_debug_log(
+                    "[Tools] No tool IDs found and built-ins disabled.", __event_call__
+                )
             return []
 
-        request = self._build_openwebui_request(user_data)
+        if self.valves.DEBUG and tool_ids:
+            await self._emit_debug_log(
+                f"[Tools] Requesting tool IDs: {tool_ids}", __event_call__
+            )
+
+        # Extract token from body first (before building request)
+        token = None
+        if isinstance(body, dict):
+            token = body.get("token")
+
+        # Build request with token if available
+        request = self._build_openwebui_request(user_data, token=token)
+
+        # Pass OAuth/Auth details in extra_params
         extra_params = {
             "__request__": request,
             "__user__": user_data,
@@ -620,49 +985,81 @@ class Pipe:
             "__chat_id__": None,
             "__message_id__": None,
             "__model_knowledge__": [],
+            "__oauth_token__": (
+                {"access_token": token} if token else None
+            ),  # Mock OAuth token structure
         }
 
-        # Fetch User/Server Tools
+        # Fetch User/Server Tools (OpenWebUI Native)
         tools_dict = {}
         if tool_ids:
             try:
+                if self.valves.DEBUG:
+                    await self._emit_debug_log(
+                        f"[Tools] Calling get_openwebui_tools with IDs: {tool_ids}",
+                        __event_call__,
+                    )
+
                 tools_dict = await get_openwebui_tools(
                     request, tool_ids, user, extra_params
                 )
+
+                if self.valves.DEBUG:
+                    if tools_dict:
+                        tool_list = []
+                        for k, v in tools_dict.items():
+                            desc = v.get("description", "No description")[:50]
+                            tool_list.append(f"{k} ({desc}...)")
+                        await self._emit_debug_log(
+                            f"[Tools] Successfully loaded {len(tools_dict)} tools: {tool_list}",
+                            __event_call__,
+                        )
+                    else:
+                        await self._emit_debug_log(
+                            f"[Tools] get_openwebui_tools returned EMPTY dictionary.",
+                            __event_call__,
+                        )
+
             except Exception as e:
+                await self._emit_debug_log(
+                    f"[Tools] CRITICAL ERROR in get_openwebui_tools: {e}",
+                    __event_call__,
+                )
+                import traceback
+
+                traceback.print_exc()
                 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,
+        if enable_tools:
+            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__
-            )
+                    },  # 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 []
@@ -734,7 +1131,9 @@ class Pipe:
         for tool_name, tool_def in tools_dict.items():
             try:
                 converted_tools.append(
-                    self._convert_openwebui_tool(tool_name, tool_def)
+                    self._convert_openwebui_tool(
+                        tool_name, tool_def, __event_call__=__event_call__
+                    )
                 )
             except Exception as e:
                 await self._emit_debug_log(
@@ -744,34 +1143,18 @@ class Pipe:
 
         return converted_tools
 
-    def _parse_mcp_servers(self) -> Optional[dict]:
+    def _parse_mcp_servers(
+        self, __event_call__=None, enable_mcp: bool = True, enable_cache: bool = True
+    ) -> Optional[dict]:
         """
         Dynamically load MCP servers from OpenWebUI TOOL_SERVER_CONNECTIONS.
         Returns a dict of mcp_servers compatible with CopilotClient.
         """
-        if not self.valves.ENABLE_MCP_SERVER:
+        if not enable_mcp:
             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:
+        if enable_cache and self._mcp_server_cache is not None:
             return self._mcp_server_cache
 
         mcp_servers = {}
@@ -800,13 +1183,18 @@ class Pipe:
 
                 # Build Headers (Handle Auth)
                 headers = {}
-                auth_type = conn.get("auth_type", "bearer")
+                auth_type = str(conn.get("auth_type", "bearer")).lower()
                 key = conn.get("key", "")
 
                 if auth_type == "bearer" and key:
                     headers["Authorization"] = f"Bearer {key}"
                 elif auth_type == "basic" and key:
-                    headers["Authorization"] = f"Basic {key}"
+                    # Fix: Basic auth requires base64 encoding
+                    headers["Authorization"] = (
+                        f"Basic {base64.b64encode(key.encode()).decode()}"
+                    )
+                elif auth_type in ["api_key", "apikey"]:
+                    headers["X-API-Key"] = key
 
                 # Merge custom headers if any
                 custom_headers = conn.get("headers", {})
@@ -832,6 +1220,9 @@ class Pipe:
                     "headers": headers,
                     "tools": allowed_tools,
                 }
+                self._emit_debug_log_sync(
+                    f"🔌 MCP Integrated: {server_id}", __event_call__
+                )
 
         # Update Cache
         if self.valves.ENABLE_TOOL_CACHE:
@@ -1076,36 +1467,48 @@ class Pipe:
 
         return system_prompt_content, system_prompt_source
 
-    def _get_workspace_dir(self) -> str:
-        """Get the effective workspace directory with smart defaults."""
-        if self.valves.WORKSPACE_DIR:
-            return self.valves.WORKSPACE_DIR
-
-        # Smart default for OpenWebUI container
+    def _get_workspace_dir(self, user_id: str = None, chat_id: str = None) -> str:
+        """Get the effective workspace directory with user and chat isolation."""
+        # Fixed base directory for OpenWebUI container
         if os.path.exists("/app/backend/data"):
-            cwd = "/app/backend/data/copilot_workspace"
+            base_cwd = "/app/backend/data/copilot_workspace"
         else:
-            # Local fallback: subdirectory in current working directory
-            cwd = os.path.join(os.getcwd(), "copilot_workspace")
+            # Local fallback for development environment
+            base_cwd = os.path.join(os.getcwd(), "copilot_workspace")
+
+        cwd = base_cwd
+        if user_id:
+            # Sanitize user_id to prevent path traversal
+            safe_user_id = re.sub(r"[^a-zA-Z0-9_-]", "_", str(user_id))
+            cwd = os.path.join(cwd, safe_user_id)
+        if chat_id:
+            # Sanitize chat_id
+            safe_chat_id = re.sub(r"[^a-zA-Z0-9_-]", "_", str(chat_id))
+            cwd = os.path.join(cwd, safe_chat_id)
 
         # Ensure directory exists
         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()  # Fallback to CWD if creation fails
+                logger.error(f"Error creating workspace {cwd}: {e}")
+                return base_cwd
 
         return cwd
 
-    def _build_client_config(self, body: dict) -> dict:
+    def _build_client_config(
+        self, body: dict, user_id: str = None, chat_id: str = None
+    ) -> dict:
         """Build CopilotClient config from valves and request body."""
-        cwd = self._get_workspace_dir()
+        cwd = self._get_workspace_dir(user_id=user_id, chat_id=chat_id)
         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.LOG_LEVEL:
             client_config["log_level"] = self.valves.LOG_LEVEL
 
@@ -1127,6 +1530,13 @@ class Pipe:
         system_prompt_content: Optional[str],
         is_streaming: bool,
         provider_config: Optional[dict] = None,
+        reasoning_effort: str = "medium",
+        is_reas_model: bool = False,
+        is_admin: bool = False,
+        user_id: str = None,
+        enable_mcp: bool = True,
+        enable_cache: bool = True,
+        __event_call__=None,
     ):
         """Build SessionConfig for Copilot SDK."""
         from copilot.types import SessionConfig, InfiniteSessionConfig
@@ -1143,39 +1553,148 @@ class Pipe:
         system_parts = []
         if system_prompt_content:
             system_parts.append(system_prompt_content.strip())
-        system_parts.append(FORMATTING_GUIDELINES)
+
+        # Calculate final path once to ensure consistency
+        resolved_cwd = self._get_workspace_dir(user_id=user_id, chat_id=chat_id)
+
+        # Inject explicit path context
+        path_context = (
+            f"\n[Session Context]\n"
+            f"- **Your Isolated Workspace**: `{resolved_cwd}`\n"
+            f"- **Active User ID**: `{user_id}`\n"
+            f"- **Active Chat ID**: `{chat_id}`\n"
+            "**CRITICAL INSTRUCTION**: You MUST use the above workspace for ALL file operations.\n"
+            "- DO NOT create files in `/tmp` or any other system directories.\n"
+            "- Always interpret 'current directory' as your Isolated Workspace."
+        )
+        system_parts.append(path_context)
+
+        system_parts.append(BASE_GUIDELINES)
+        if is_admin:
+            system_parts.append(ADMIN_EXTENSIONS)
+        else:
+            system_parts.append(USER_RESTRICTIONS)
+
         final_system_msg = "\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,
         }
 
+        mcp_servers = self._parse_mcp_servers(
+            __event_call__, enable_mcp=enable_mcp, enable_cache=enable_cache
+        )
+
         # Prepare session config parameters
         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": system_message_config,
             "infinite_sessions": infinite_session_config,
+            "working_directory": resolved_cwd,
         }
 
+        if is_reas_model and reasoning_effort:
+            # Map requested effort to supported efforts if possible
+            m = next(
+                (
+                    m
+                    for m in (self._model_cache or [])
+                    if m.get("raw_id") == real_model_id
+                ),
+                None,
+            )
+            supp = (
+                m.get("meta", {})
+                .get("capabilities", {})
+                .get("supported_reasoning_efforts", [])
+                if m
+                else []
+            )
+            s_supp = [str(e).lower() for e in supp]
+            if s_supp:
+                session_params["reasoning_effort"] = (
+                    reasoning_effort
+                    if reasoning_effort.lower() in s_supp
+                    else ("high" if "high" in s_supp else "medium")
+                )
+            else:
+                session_params["reasoning_effort"] = reasoning_effort
+
+        if mcp_servers:
+            session_params["mcp_servers"] = mcp_servers
+            # Critical Fix: When using MCP, available_tools must be None to allow dynamic discovery
+            session_params["available_tools"] = None
+        else:
+            session_params["available_tools"] = (
+                [t.name for t in custom_tools] if custom_tools else None
+            )
+
         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()
+        # Inject hooks for automatic large file handling
+        session_params["hooks"] = self._build_session_hooks(
+            cwd=resolved_cwd, __event_call__=__event_call__
+        )
 
         return SessionConfig(**session_params)
 
+    def _build_session_hooks(self, cwd: str, __event_call__=None):
+        """
+        Build session lifecycle hooks.
+        Currently implements:
+        - on_post_tool_use: Auto-copy large files from /tmp to workspace
+        """
+
+        async def on_post_tool_use(input_data, invocation):
+            result = input_data.get("result", "")
+            tool_name = input_data.get("toolName", "")
+
+            # Logic to detect and move large files saved to /tmp
+            # Pattern: Saved to: /tmp/copilot_result_xxxx.txt
+            import re
+            import shutil
+
+            # We search for potential /tmp file paths in the output
+            # Common patterns from CLI: "Saved to: /tmp/..." or just "/tmp/..."
+            match = re.search(r"(/tmp/[\w\-\.]+)", str(result))
+            if match:
+                tmp_path = match.group(1)
+                if os.path.exists(tmp_path):
+                    try:
+                        filename = os.path.basename(tmp_path)
+                        target_path = os.path.join(cwd, f"auto_output_{filename}")
+                        shutil.copy2(tmp_path, target_path)
+
+                        self._emit_debug_log_sync(
+                            f"Hook [on_post_tool_use]: Auto-moved large output from {tmp_path} to {target_path}",
+                            __event_call__,
+                        )
+
+                        return {
+                            "additionalContext": (
+                                f"\n[SYSTEM AUTO-MANAGEMENT] The output was large and originally saved to {tmp_path}. "
+                                f"I have automatically moved it to your workspace as: `{os.path.basename(target_path)}`. "
+                                f"You should now use `read_file` or `grep` on this file to access the content."
+                            )
+                        }
+                    except Exception as e:
+                        self._emit_debug_log_sync(
+                            f"Hook [on_post_tool_use] Error moving file: {e}",
+                            __event_call__,
+                        )
+
+            return {}
+
+        return {
+            "on_post_tool_use": on_post_tool_use,
+        }
+
     def _get_user_context(self):
         """Helper to get user context (placeholder for future use)."""
         return {}
@@ -1298,14 +1817,19 @@ class Pipe:
                 }
                 model_list = defaults.get(
                     self.valves.BYOK_TYPE.lower(),
-                    ["gpt-4o", "gpt-4o-mini", "o1", "o3-mini"],
+                    ["gpt-4o", "gpt-4o-mini", "claude-3-5-sonnet-latest"],
                 )
                 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"}
+            {
+                "id": m,
+                "name": f"-{self._clean_model_id(m)}",
+                "source": "byok",
+                "raw_id": m,
+            }
             for m in model_list
         ]
 
@@ -1317,140 +1841,209 @@ class Pipe:
             return model_id[10:]
         return model_id
 
-    async def pipes(self) -> List[dict]:
-        """Dynamically fetch model list"""
-        if self._model_cache:
-            return self._model_cache
+    def _get_provider_name(self, m_info: Any) -> str:
+        """Identify provider from model metadata."""
+        m_id = getattr(m_info, "id", str(m_info)).lower()
+        if any(k in m_id for k in ["gpt", "codex"]):
+            return "OpenAI"
+        if "claude" in m_id:
+            return "Anthropic"
+        if "gemini" in m_id:
+            return "Google"
+        p = getattr(m_info, "policy", None)
+        if p:
+            t = str(getattr(p, "terms", "")).lower()
+            if "openai" in t:
+                return "OpenAI"
+            if "anthropic" in t:
+                return "Anthropic"
+            if "google" in t:
+                return "Google"
+        return "Unknown"
 
-        await self._emit_debug_log("Fetching model list dynamically...")
-        try:
-            self._setup_env()
+    def _get_user_valves(self, __user__: Optional[dict]) -> "Pipe.UserValves":
+        """Robustly extract UserValves from __user__ context."""
+        if not __user__:
+            return self.UserValves()
 
-            # 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"}
-                ]
+        # Handle list/tuple wrap
+        user_data = __user__[0] if isinstance(__user__, (list, tuple)) else __user__
+        if not isinstance(user_data, dict):
+            return self.UserValves()
 
-            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)
+        raw_valves = user_data.get("valves")
+        if isinstance(raw_valves, self.UserValves):
+            return raw_valves
+        if isinstance(raw_valves, dict):
             try:
-                await client.start()
-                raw_models = await client.list_models()
-
-                exclude_list = [
-                    k.strip().lower()
-                    for k in self.valves.EXCLUDE_KEYWORDS.split(",")
-                    if k.strip()
-                ]
-                processed_models = []
-
-                for m in raw_models:
-                    # Extract fields resiliently
-                    m_id = (
-                        m.get("id") if isinstance(m, dict) else getattr(m, "id", str(m))
-                    )
-                    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", {})
-                    )
-
-                    # Skip disabled models
-                    state = (
-                        m_policy.get("state")
-                        if isinstance(m_policy, dict)
-                        else getattr(m_policy, "state", "enabled")
-                    )
-                    if state == "disabled":
-                        continue
-
-                    # Apply exclusion filter
-                    if any(kw in m_id.lower() for kw in exclude_list):
-                        continue
-
-                    multiplier = (
-                        m_billing.get("multiplier", 1)
-                        if isinstance(m_billing, dict)
-                        else getattr(m_billing, "multiplier", 1)
-                    )
-
-                    clean_id = self._clean_model_id(m_id)
-                    # 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"-🔥 {clean_id} (0x)"
-
-                    processed_models.append(
-                        {
-                            "id": m_id,  # Keep raw ID
-                            "name": display_name,
-                            "multiplier": multiplier,
-                            "raw_id": m_id,
-                        }
-                    )
-
-                # Sort by multiplier (cheapest first), then name
-                processed_models.sort(key=lambda x: (x["multiplier"], x["raw_id"]))
-                standard_models = [
-                    {
-                        "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}
-
+                return self.UserValves(**raw_valves)
             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()
+                logger.warning(f"[Copilot] Failed to parse UserValves: {e}")
+        return self.UserValves()
 
-            # 3. Merge and Return
-            self._model_cache = standard_models + byok_models
+    async def pipes(self, __user__: Optional[dict] = None) -> List[dict]:
+        """Dynamically fetch and filter model list."""
+        if self.valves.DEBUG:
+            logger.info(f"[Pipes] Called with user context: {bool(__user__)}")
 
-            await self._emit_debug_log(
-                f"Successfully fetched {len(standard_models)} standard models and {len(byok_models)} BYOK models. Total: {len(self._model_cache)}"
+        uv = self._get_user_valves(__user__)
+        token = uv.GH_TOKEN
+
+        # Determine check interval (24 hours default)
+        now = datetime.now().timestamp()
+        needs_setup = not self.__class__._env_setup_done or (
+            now - self.__class__._last_update_check > 86400
+        )
+
+        # 1. Environment Setup (Only if needed or not done)
+        if needs_setup:
+            self._setup_env(token=token)
+            self.__class__._last_update_check = now
+        else:
+            # Still inject token for BYOK real-time updates
+            if token:
+                os.environ["GH_TOKEN"] = os.environ["GITHUB_TOKEN"] = token
+
+        # Get user info for isolation
+        user_data = (
+            __user__[0] if isinstance(__user__, (list, tuple)) else (__user__ or {})
+        )
+        user_id = user_data.get("id") or user_data.get("user_id") or "default_user"
+
+        token = uv.GH_TOKEN or self.valves.GH_TOKEN
+
+        # Multiplier filtering: User can constrain, but not exceed global limit
+        global_max = self.valves.MAX_MULTIPLIER
+        user_max = uv.MAX_MULTIPLIER
+        if user_max is not None:
+            eff_max = min(float(user_max), float(global_max))
+        else:
+            eff_max = float(global_max)
+
+        if self.valves.DEBUG:
+            logger.info(
+                f"[Pipes] Multiplier Filter: User={user_max}, Global={global_max}, Effective={eff_max}"
             )
-            return self._model_cache
 
-        except Exception as e:
-            await self._emit_debug_log(f"Pipes Error: {e}")
-            return [{"id": "gpt-5-mini", "name": "-gpt-5-mini"}]
+        # Keyword filtering: combine global and user keywords
+        ex_kw = [
+            k.strip().lower()
+            for k in (self.valves.EXCLUDE_KEYWORDS + "," + uv.EXCLUDE_KEYWORDS).split(
+                ","
+            )
+            if k.strip()
+        ]
+
+        if not self._model_cache:
+            if self.valves.DEBUG:
+                logger.info("[Pipes] Refreshing model cache...")
+            try:
+                # Use effective token for fetching
+                self._setup_env(token=token)
+
+                # Fetch BYOK models if configured
+                byok = []
+                if self.valves.BYOK_BASE_URL and (
+                    uv.BYOK_API_KEY
+                    or self.valves.BYOK_API_KEY
+                    or uv.BYOK_BEARER_TOKEN
+                    or self.valves.BYOK_BEARER_TOKEN
+                ):
+                    byok = await self._fetch_byok_models()
+
+                standard = []
+                if token:
+                    client_config = {
+                        "cli_path": os.environ.get("COPILOT_CLI_PATH"),
+                        "cwd": self._get_workspace_dir(
+                            user_id=user_id, chat_id="listing"
+                        ),
+                    }
+                    c = CopilotClient(client_config)
+                    try:
+                        await c.start()
+                        raw = await c.list_models()
+                        for m in raw if isinstance(raw, list) else []:
+                            try:
+                                mid = (
+                                    m.get("id")
+                                    if isinstance(m, dict)
+                                    else getattr(m, "id", "")
+                                )
+                                if not mid:
+                                    continue
+
+                                # Extract multiplier
+                                bill = (
+                                    m.get("billing")
+                                    if isinstance(m, dict)
+                                    else getattr(m, "billing", {})
+                                )
+                                if hasattr(bill, "to_dict"):
+                                    bill = bill.to_dict()
+                                mult = (
+                                    float(bill.get("multiplier", 1))
+                                    if isinstance(bill, dict)
+                                    else 1.0
+                                )
+
+                                cid = self._clean_model_id(mid)
+                                standard.append(
+                                    {
+                                        "id": f"{self.id}-{mid}",
+                                        "name": (
+                                            f"-{cid} ({mult}x)"
+                                            if mult > 0
+                                            else f"-🔥 {cid} (0x)"
+                                        ),
+                                        "multiplier": mult,
+                                        "raw_id": mid,
+                                        "source": "copilot",
+                                        "provider": self._get_provider_name(m),
+                                    }
+                                )
+                            except:
+                                pass
+                        standard.sort(key=lambda x: (x["multiplier"], x["raw_id"]))
+                        self._standard_model_ids = {m["raw_id"] for m in standard}
+                    except Exception as e:
+                        logger.error(f"[Pipes] Error listing models: {e}")
+                    finally:
+                        await c.stop()
+
+                self._model_cache = standard + byok
+                if not self._model_cache:
+                    return [
+                        {"id": "error", "name": "No models found. Check Token/Network."}
+                    ]
+            except Exception as e:
+                return [{"id": "error", "name": f"Error: {e}"}]
+
+        # Final pass filtering from cache (applied on every request)
+        res = []
+        # Use a small epsilon for float comparison to avoid precision issues (e.g. 0.33 vs 0.33000001)
+        epsilon = 0.0001
+
+        for m in self._model_cache:
+            # 1. Keyword filter
+            mid = (m.get("raw_id") or m.get("id", "")).lower()
+            mname = m.get("name", "").lower()
+            if any(kw in mid or kw in mname for kw in ex_kw):
+                continue
+
+            # 2. Multiplier filter (only for standard Copilot models)
+            if m.get("source") == "copilot":
+                m_mult = float(m.get("multiplier", 0))
+                if m_mult > (eff_max + epsilon):
+                    if self.valves.DEBUG:
+                        logger.debug(
+                            f"[Pipes] Filtered {m.get('id')} (Mult: {m_mult} > {eff_max})"
+                        )
+                    continue
+
+            res.append(m)
+
+        return res if res else [{"id": "none", "name": "No models matched filters"}]
 
     async def _get_client(self):
         """Helper to get or create a CopilotClient instance."""
@@ -1462,23 +2055,32 @@ class Pipe:
         await client.start()
         return client
 
-    def _setup_env(self, __event_call__=None, debug_enabled: bool = False):
-        """Setup environment variables and verify Copilot CLI."""
+    def _setup_env(
+        self,
+        __event_call__=None,
+        debug_enabled: bool = False,
+        token: str = None,
+        enable_mcp: bool = True,
+        enable_cache: bool = True,
+    ):
+        """Setup environment variables and verify Copilot CLI. Dynamic Token Injection."""
+        # 1. Real-time Token Injection (Always updates on each call)
+        effective_token = token or self.valves.GH_TOKEN
+        if effective_token:
+            os.environ["GH_TOKEN"] = os.environ["GITHUB_TOKEN"] = effective_token
+
         if self._env_setup_done:
+            # If done, we only sync MCP if called explicitly or in debug mode
+            # To improve speed, we avoid redundant file I/O here for regular requests
+            if debug_enabled:
+                self._sync_mcp_config(
+                    __event_call__,
+                    debug_enabled,
+                    enable_mcp=enable_mcp,
+                    enable_cache=enable_cache,
+                )
             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)",
@@ -1587,18 +2189,71 @@ class Pipe:
 
         # 4. Finalize
         os.environ["COPILOT_CLI_PATH"] = cli_path
-        self._env_setup_done = True
+        self.__class__._env_setup_done = True
+        self.__class__._last_update_check = datetime.now().timestamp()
+
         self._emit_debug_log_sync(
             f"Environment setup complete. CLI: {cli_path} (v{current_version})",
             __event_call__,
             debug_enabled=debug_enabled,
         )
 
-    def _process_images(
-        self, messages, __event_call__=None, debug_enabled: bool = False
+    def _process_attachments(
+        self,
+        messages,
+        cwd=None,
+        files=None,
+        __event_call__=None,
+        debug_enabled: bool = False,
     ):
         attachments = []
         text_content = ""
+        saved_files_info = []
+
+        # 1. Process OpenWebUI Uploaded Files (body['files'])
+        if files and cwd:
+            for file_item in files:
+                try:
+                    # Adapt to different file structures
+                    file_obj = file_item.get("file", file_item)
+                    file_id = file_obj.get("id")
+                    filename = (
+                        file_obj.get("filename") or file_obj.get("name") or "upload.bin"
+                    )
+
+                    if file_id:
+                        # Construct source path
+                        src_path = os.path.join(
+                            self.valves.OPENWEBUI_UPLOAD_PATH, f"{file_id}_{filename}"
+                        )
+
+                        if os.path.exists(src_path):
+                            # Copy to workspace
+                            dst_path = os.path.join(cwd, filename)
+                            shutil.copy2(src_path, dst_path)
+
+                            saved_files_info.append(
+                                f"- User uploaded file: `{filename}` (Saved to workspace)"
+                            )
+                            self._emit_debug_log_sync(
+                                f"Copied file to workspace: {dst_path}",
+                                __event_call__,
+                                debug_enabled,
+                            )
+                        else:
+                            self._emit_debug_log_sync(
+                                f"Source file not found: {src_path}",
+                                __event_call__,
+                                debug_enabled,
+                            )
+                except Exception as e:
+                    self._emit_debug_log_sync(
+                        f"Error processing file {file_item}: {e}",
+                        __event_call__,
+                        debug_enabled,
+                    )
+
+        # 2. Process Base64 Images in Messages
         if not messages:
             return "", []
         last_msg = messages[-1]
@@ -1638,6 +2293,16 @@ class Pipe:
                             )
         else:
             text_content = str(content)
+
+        # Append saved files info to the text content seen by the agent
+        if saved_files_info:
+            info_block = (
+                "\n\n[System Notification: New Files Available]\n"
+                + "\n".join(saved_files_info)
+                + "\nYou can access these files directly using their filenames in your workspace."
+            )
+            text_content += info_block
+
         return text_content, attachments
 
     def _sync_copilot_config(
@@ -1652,20 +2317,6 @@ class Pipe:
 
         effort = reasoning_effort
 
-        # Check model support for xhigh
-        # Only gpt-5.2-codex supports xhigh currently
-        if effort == "xhigh":
-            if (
-                "gpt-5.2-codex"
-                not in self._collect_model_ids(
-                    body={},
-                    request_model=self.id,
-                    real_model_id=None,
-                )[0].lower()
-            ):
-                # Fallback to high if not supported
-                effort = "high"
-
         try:
             # Target standard path ~/.copilot/config.json
             config_path = os.path.expanduser("~/.copilot/config.json")
@@ -1710,6 +2361,64 @@ class Pipe:
                 debug_enabled=debug_enabled,
             )
 
+    def _sync_mcp_config(
+        self,
+        __event_call__=None,
+        debug_enabled: bool = False,
+        enable_mcp: bool = True,
+        enable_cache: bool = True,
+    ):
+        """Sync MCP configuration to ~/.copilot/config.json."""
+        path = os.path.expanduser("~/.copilot/config.json")
+
+        # If disabled, we should ensure the config doesn't contain stale MCP info
+        if not enable_mcp:
+            if os.path.exists(path):
+                try:
+                    with open(path, "r") as f:
+                        data = json.load(f)
+                    if "mcp_servers" in data:
+                        del data["mcp_servers"]
+                        with open(path, "w") as f:
+                            json.dump(data, f, indent=4)
+                        self._emit_debug_log_sync(
+                            "MCP disabled: Cleared MCP servers from config.json",
+                            __event_call__,
+                            debug_enabled,
+                        )
+                except:
+                    pass
+            return
+
+        mcp = self._parse_mcp_servers(
+            __event_call__, enable_mcp=enable_mcp, enable_cache=enable_cache
+        )
+        if not mcp:
+            return
+        try:
+            path = os.path.expanduser("~/.copilot/config.json")
+            os.makedirs(os.path.dirname(path), exist_ok=True)
+            data = {}
+            if os.path.exists(path):
+                try:
+                    with open(path, "r") as f:
+                        data = json.load(f)
+                except:
+                    pass
+            if json.dumps(data.get("mcp_servers"), sort_keys=True) != json.dumps(
+                mcp, sort_keys=True
+            ):
+                data["mcp_servers"] = mcp
+                with open(path, "w") as f:
+                    json.dump(data, f, indent=4)
+                self._emit_debug_log_sync(
+                    f"Synced {len(mcp)} MCP servers to config.json",
+                    __event_call__,
+                    debug_enabled,
+                )
+        except:
+            pass
+
     # ==================== Internal Implementation ====================
     # _pipe_impl() contains the main request handling logic.
     # ================================================================
@@ -1721,26 +2430,63 @@ class Pipe:
         __event_emitter__=None,
         __event_call__=None,
     ) -> Union[str, AsyncGenerator]:
-        # 1. Determine effective debug setting FIRST to capture all logs
-        if __user__:
-            raw_valves = __user__.get("valves", {})
-            if isinstance(raw_valves, self.UserValves):
-                user_valves = raw_valves
-            elif isinstance(raw_valves, dict):
-                user_valves = self.UserValves(**raw_valves)
-            else:
-                user_valves = self.UserValves()
-        else:
-            user_valves = self.UserValves()
+        # --- PROBE LOG ---
+        if __event_call__:
+            await self._emit_debug_log(
+                f"🔔 Pipe initialized. User: {__user__.get('name') if __user__ else 'Unknown'}",
+                __event_call__,
+                debug_enabled=True,
+            )
+        # -----------------
+
+        # 1. Determine user role and settings
+        user_data = (
+            __user__[0] if isinstance(__user__, (list, tuple)) else (__user__ or {})
+        )
+        is_admin = user_data.get("role") == "admin"
+
+        # Robustly parse User Valves
+        user_valves = self._get_user_valves(__user__)
+
+        # --- DEBUG LOGGING ---
+        if self.valves.DEBUG:
+            logger.info(
+                f"[Copilot] Request received. Model: {body.get('model')}, Stream: {body.get('stream', False)}"
+            )
+            logger.info(
+                f"[Copilot] User Context: {bool(__user__)}, Event Call: {bool(__event_call__)}"
+            )
+        # ---------------------
+
+        user_id = user_data.get("id") or user_data.get("user_id") or "default_user"
 
         effective_debug = self.valves.DEBUG or user_valves.DEBUG
+        effective_token = user_valves.GH_TOKEN or self.valves.GH_TOKEN
 
-        # 2. Setup environment with effective debug
-        self._setup_env(__event_call__, debug_enabled=effective_debug)
+        # Get Chat ID using improved helper
+        chat_ctx = self._get_chat_context(
+            body, __metadata__, __event_call__, debug_enabled=effective_debug
+        )
+        chat_id = chat_ctx.get("chat_id") or "default"
 
-        cwd = self._get_workspace_dir()
+        # Determine effective MCP and cache settings
+        effective_mcp = user_valves.ENABLE_MCP_SERVER
+        effective_cache = user_valves.ENABLE_TOOL_CACHE
+
+        # 2. Setup environment with effective settings
+        self._setup_env(
+            __event_call__,
+            debug_enabled=effective_debug,
+            token=effective_token,
+            enable_mcp=effective_mcp,
+            enable_cache=effective_cache,
+        )
+
+        cwd = self._get_workspace_dir(user_id=user_id, chat_id=chat_id)
         await self._emit_debug_log(
-            f"Agent working in: {cwd}", __event_call__, debug_enabled=effective_debug
+            f"Agent working in: {cwd} (Admin: {is_admin}, MCP: {effective_mcp})",
+            __event_call__,
+            debug_enabled=effective_debug,
         )
 
         # Determine effective BYOK settings
@@ -1786,7 +2532,56 @@ class Pipe:
         # 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
+        # 3. Enforce Multiplier Constraint (Safety Check)
+        global_max = self.valves.MAX_MULTIPLIER
+        user_max = user_valves.MAX_MULTIPLIER
+        if user_max is not None:
+            eff_max = min(float(user_max), float(global_max))
+        else:
+            eff_max = float(global_max)
+
+        # Try to find model info. If missing, force refresh cache.
+        m_info = next(
+            (m for m in (self._model_cache or []) if m.get("raw_id") == real_model_id),
+            None,
+        )
+        if not m_info:
+            logger.info(
+                f"[Pipe Impl] Model info missing for {real_model_id}, refreshing cache..."
+            )
+            await self.pipes(__user__)
+            m_info = next(
+                (
+                    m
+                    for m in (self._model_cache or [])
+                    if m.get("raw_id") == real_model_id
+                ),
+                None,
+            )
+
+        # --- DEBUG MULTIPLIER ---
+        if m_info:
+            logger.info(
+                f"[Pipe Impl] Model Info: ID={real_model_id}, Source={m_info.get('source')}, Mult={m_info.get('multiplier')}, EffMax={eff_max}"
+            )
+        else:
+            logger.warning(
+                f"[Pipe Impl] Model Info STILL NOT FOUND for ID: {real_model_id}. Treating as multiplier=1.0"
+            )
+        # ------------------------
+
+        # Check multiplier (If model not found, assume Copilot source and multiplier 1.0 for safety)
+        is_copilot_source = m_info.get("source") == "copilot" if m_info else True
+        current_mult = float(m_info.get("multiplier", 1.0)) if m_info else 1.0
+
+        if is_copilot_source:
+            epsilon = 0.0001
+            if current_mult > (eff_max + epsilon):
+                err_msg = f"Error: Model '{real_model_id}' (multiplier {current_mult}x) exceeds your allowed maximum of {eff_max}x."
+                await self._emit_debug_log(err_msg, __event_call__, debug_enabled=True)
+                return err_msg
+
+        # 4. Log the resolution result
         if real_model_id != request_model:
             log_msg = (
                 f"Using {model_source_type} model: {real_model_id} "
@@ -1802,12 +2597,6 @@ class Pipe:
         if not messages:
             return "No messages."
 
-        # Get Chat ID using improved helper
-        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,
@@ -1833,167 +2622,93 @@ class Pipe:
             debug_enabled=effective_debug,
         )
 
-        last_text, attachments = self._process_images(
-            messages, __event_call__, debug_enabled=effective_debug
+        # Retrieve files (support 'copilot_files' from filter override)
+        files = body.get("copilot_files") or body.get("files")
+
+        last_text, attachments = self._process_attachments(
+            messages,
+            cwd=cwd,
+            files=files,
+            __event_call__=__event_call__,
+            debug_enabled=effective_debug,
         )
 
+        # 1. Determine user role and construct guidelines
+        user_data = (
+            __user__[0] if isinstance(__user__, (list, tuple)) else (__user__ or {})
+        )
+        is_admin = user_data.get("role") == "admin"
+
+        system_parts = []
+        if system_prompt_content:
+            system_parts.append(system_prompt_content.strip())
+        system_parts.append(BASE_GUIDELINES)
+        if is_admin:
+            system_parts.append(ADMIN_EXTENSIONS)
+        else:
+            system_parts.append(USER_RESTRICTIONS)
+        final_system_msg = "\n".join(system_parts)
+
         # Determine prompt strategy
         # If we have a chat_id, we try to resume session.
         # If resumed, we assume the session has history, so we only send the last message.
         # If new session, we send full (accumulated) messages.
 
-        # Ensure we have the latest config
-        # 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
+        # 1. Determine model capabilities and BYOK status
         import re
 
-        is_byok_model = False
-        model_display_name = ""
+        m_info = next(
+            (
+                m
+                for m in (self._model_cache or [])
+                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,
+        )
 
-        # Method 1: Get model name from various metadata sources
-        body_metadata = body.get("metadata", {})
-        if not isinstance(body_metadata, dict):
-            body_metadata = {}
+        is_reasoning = (
+            m_info.get("meta", {}).get("capabilities", {}).get("reasoning", False)
+            if m_info
+            else False
+        )
 
-        # 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,
-                        )
+        # Detection priority for BYOK
+        # 1. Check metadata.model.name for multiplier (Standard Copilot format)
+        model_display_name = body.get("metadata", {}).get("model", {}).get(
+            "name", ""
+        ) or (__metadata__.get("model", {}).get("name", "") if __metadata__ else "")
+        has_multiplier = bool(
+            re.search(r"[\(（]\d+(?:\.\d+)?x[\)）]", model_display_name)
+        )
 
+        if m_info and "source" in m_info:
+            is_byok_model = m_info["source"] == "byok"
+        else:
             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,
-                )
+        await self._emit_debug_log(
+            f"Mode: {'BYOK' if is_byok_model else 'Standard'}, Reasoning: {is_reasoning}, Admin: {is_admin}",
+            __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))
+        client = CopilotClient(
+            self._build_client_config(body, user_id=user_id, chat_id=chat_id)
+        )
         should_stop_client = True
         try:
             await client.start()
 
             # Initialize custom tools (Handles caching internally)
             custom_tools = await self._initialize_custom_tools(
-                __user__=__user__, __event_call__=__event_call__
+                body=body, __user__=__user__, __event_call__=__event_call__
             )
             if custom_tools:
                 tool_names = [t.name for t in custom_tools]
@@ -2003,7 +2718,9 @@ class Pipe:
                 )
 
             # Check MCP Servers
-            mcp_servers = self._parse_mcp_servers()
+            mcp_servers = self._parse_mcp_servers(
+                __event_call__, enable_mcp=effective_mcp, enable_cache=effective_cache
+            )
             mcp_server_names = list(mcp_servers.keys()) if mcp_servers else []
             if mcp_server_names:
                 await self._emit_debug_log(
@@ -2048,19 +2765,53 @@ 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
-                        ),
                     }
+
+                    if is_reasoning and effective_reasoning_effort:
+                        # Re-use mapping logic or just pass it through
+                        resume_params["reasoning_effort"] = effective_reasoning_effort
+
+                    mcp_servers = self._parse_mcp_servers(
+                        __event_call__,
+                        enable_mcp=effective_mcp,
+                        enable_cache=effective_cache,
+                    )
                     if mcp_servers:
                         resume_params["mcp_servers"] = mcp_servers
+                        resume_params["available_tools"] = None
+                    else:
+                        resume_params["available_tools"] = (
+                            [t.name for t in custom_tools] if custom_tools else None
+                        )
 
                     # 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)
+
+                    # Calculate and inject path context for resumed session
+                    resolved_cwd = self._get_workspace_dir(
+                        user_id=user_id, chat_id=chat_id
+                    )
+                    path_context = (
+                        f"\n[Session Context]\n"
+                        f"- **Your Isolated Workspace**: `{resolved_cwd}`\n"
+                        f"- **Active User ID**: `{user_id}`\n"
+                        f"- **Active Chat ID**: `{chat_id}`\n"
+                        "**CRITICAL INSTRUCTION**: You MUST use the above workspace for ALL file operations.\n"
+                        "- DO NOT create files in `/tmp` or any other system directories.\n"
+                        "- If a tool output is too large, save it to a file within your workspace, NOT `/tmp`.\n"
+                        "- Always interpret 'current directory' as your Isolated Workspace."
+                    )
+                    system_parts.append(path_context)
+
+                    system_parts.append(BASE_GUIDELINES)
+                    if is_admin:
+                        system_parts.append(ADMIN_EXTENSIONS)
+                    else:
+                        system_parts.append(USER_RESTRICTIONS)
+
                     final_system_msg = "\n".join(system_parts)
 
                     resume_params["system_message"] = {
@@ -2112,10 +2863,17 @@ class Pipe:
                     system_prompt_content,
                     is_streaming,
                     provider_config=provider_config,
+                    reasoning_effort=effective_reasoning_effort,
+                    is_reas_model=is_reasoning,
+                    is_admin=is_admin,
+                    user_id=user_id,
+                    enable_mcp=effective_mcp,
+                    enable_cache=effective_cache,
+                    __event_call__=__event_call__,
                 )
 
                 await self._emit_debug_log(
-                    f"Injecting system prompt into new session (len: {len(system_prompt_content or '') + len(FORMATTING_GUIDELINES)})",
+                    f"Injecting system prompt into new session (len: {len(final_system_msg)})",
                     __event_call__,
                 )
 
@@ -2157,9 +2915,7 @@ class Pipe:
             if body.get("stream", False):
                 init_msg = ""
                 if effective_debug:
-                    init_msg = (
-                        f"> [Debug] Agent working in: {self._get_workspace_dir()}\n"
-                    )
+                    init_msg = f"> [Debug] Agent working in: {self._get_workspace_dir(user_id=user_id, chat_id=chat_id)}\n"
                     if mcp_server_names:
                         init_msg += f"> [Debug] 🔌 Connected MCP Servers: {', '.join(mcp_server_names)}\n"
 
@@ -2169,8 +2925,11 @@ class Pipe:
                     client,
                     session,
                     send_payload,
-                    init_msg,
-                    __event_call__,
+                    chat_id=chat_id,
+                    user_id=user_id,
+                    init_message=init_msg,
+                    __event_call__=__event_call__,
+                    __event_emitter__=__event_emitter__,
                     reasoning_effort=effective_reasoning_effort,
                     show_thinking=show_thinking,
                     debug_enabled=effective_debug,
@@ -2211,8 +2970,11 @@ class Pipe:
         client,
         session,
         send_payload,
+        chat_id: str,
+        user_id: str = None,
         init_message: str = "",
         __event_call__=None,
+        __event_emitter__=None,
         reasoning_effort: str = "",
         show_thinking: bool = True,
         debug_enabled: bool = False,
@@ -2369,7 +3131,11 @@ class Pipe:
 
                 queue.put_nowait(tool_display)
 
-                self._emit_debug_log_sync(f"Tool Start: {tool_name}", __event_call__)
+                self._emit_debug_log_sync(
+                    f"Tool Start: {tool_name}",
+                    __event_call__,
+                    debug_enabled=debug_enabled,
+                )
 
             elif event_type == "tool.execution_complete":
                 tool_call_id = safe_get_data_attr(event, "tool_call_id", "")
@@ -2400,7 +3166,9 @@ class Pipe:
                             )
                 except Exception as e:
                     self._emit_debug_log_sync(
-                        f"Error extracting result: {e}", __event_call__
+                        f"Error extracting result: {e}",
+                        __event_call__,
+                        debug_enabled=debug_enabled,
                     )
                     result_type = "failure"
                     result_content = f"Error: {str(e)}"
@@ -2409,6 +3177,75 @@ class Pipe:
                 if result_content:
                     status_icon = "✅" if result_type == "success" else "❌"
 
+                    # --- TODO Sync Logic (File + DB) ---
+                    if tool_name == "update_todo" and result_type == "success":
+                        try:
+                            # Extract todo content with fallback strategy
+                            todo_text = ""
+
+                            # 1. Try detailedContent (Best source)
+                            if isinstance(result_obj, dict) and result_obj.get(
+                                "detailedContent"
+                            ):
+                                todo_text = result_obj["detailedContent"]
+                            # 2. Try content (Second best)
+                            elif isinstance(result_obj, dict) and result_obj.get(
+                                "content"
+                            ):
+                                todo_text = result_obj["content"]
+                            elif hasattr(result_obj, "content"):
+                                todo_text = result_obj.content
+
+                            # 3. Fallback: If content is just a status message, try to recover from arguments
+                            if (
+                                not todo_text or len(todo_text) < 50
+                            ):  # Threshold to detect "TODO list updated"
+                                if tool_call_id in active_tools:
+                                    args = active_tools[tool_call_id].get(
+                                        "arguments", {}
+                                    )
+                                    if isinstance(args, dict) and "todos" in args:
+                                        todo_text = args["todos"]
+                                        self._emit_debug_log_sync(
+                                            f"Recovered TODO from arguments (Result was too short)",
+                                            __event_call__,
+                                            debug_enabled=debug_enabled,
+                                        )
+
+                            if todo_text:
+                                # Use the explicit chat_id passed to stream_response
+                                target_chat_id = chat_id or "default"
+
+                                # 1. Sync to file
+                                ws_dir = self._get_workspace_dir(
+                                    user_id=user_id, chat_id=target_chat_id
+                                )
+                                todo_path = os.path.join(ws_dir, "TODO.md")
+                                with open(todo_path, "w") as f:
+                                    f.write(todo_text)
+
+                                # 2. Sync to Database & Emit Status
+                                self._save_todo_to_db(
+                                    target_chat_id,
+                                    todo_text,
+                                    __event_emitter__=__event_emitter__,
+                                    __event_call__=__event_call__,
+                                    debug_enabled=debug_enabled,
+                                )
+
+                                self._emit_debug_log_sync(
+                                    f"Synced TODO to file and DB (Chat: {target_chat_id})",
+                                    __event_call__,
+                                    debug_enabled=debug_enabled,
+                                )
+                        except Exception as sync_err:
+                            self._emit_debug_log_sync(
+                                f"TODO Sync Failed: {sync_err}",
+                                __event_call__,
+                                debug_enabled=debug_enabled,
+                            )
+                    # ------------------------
+
                     # Try to detect content type for better formatting
                     is_json = False
                     try:
@@ -2453,7 +3290,9 @@ class Pipe:
                     queue.put_nowait(progress_display)
 
                 self._emit_debug_log_sync(
-                    f"Tool Progress: {tool_name} - {progress}%", __event_call__
+                    f"Tool Progress: {tool_name} - {progress}%",
+                    __event_call__,
+                    debug_enabled=debug_enabled,
                 )
 
             elif event_type == "tool.execution_partial_result":
@@ -2471,7 +3310,9 @@ class Pipe:
                     queue.put_nowait(partial_content)
 
                 self._emit_debug_log_sync(
-                    f"Tool Partial Result: {tool_name}", __event_call__
+                    f"Tool Partial Result: {tool_name}",
+                    __event_call__,
+                    debug_enabled=debug_enabled,
                 )
 
             # === Usage Statistics Events ===
@@ -2489,7 +3330,9 @@ class Pipe:
 
             elif event_type == "session.compaction_complete":
                 self._emit_debug_log_sync(
-                    "Session Compaction Completed", __event_call__
+                    "Session Compaction Completed",
+                    __event_call__,
+                    debug_enabled=debug_enabled,
                 )
 
             elif event_type == "session.idle":
@@ -2512,17 +3355,23 @@ class Pipe:
         unsubscribe = session.on(handler)
 
         self._emit_debug_log_sync(
-            f"Subscribed to events. Sending request...", __event_call__
+            f"Subscribed to events. Sending request...",
+            __event_call__,
+            debug_enabled=debug_enabled,
         )
 
         # Use asyncio.create_task used to prevent session.send from blocking the stream reading
         # if the SDK implementation waits for completion.
         send_task = asyncio.create_task(session.send(send_payload))
-        self._emit_debug_log_sync(f"Prompt sent (async task started)", __event_call__)
+        self._emit_debug_log_sync(
+            f"Prompt sent (async task started)",
+            __event_call__,
+            debug_enabled=debug_enabled,
+        )
 
         # Safe initial yield with error handling
         try:
-            if self.valves.DEBUG and show_thinking:
+            if debug_enabled and show_thinking:
                 yield "<think>\n"
                 if init_message:
                     yield init_message
@@ -2534,7 +3383,11 @@ class Pipe:
                 state["thinking_started"] = True
         except Exception as e:
             # If initial yield fails, log but continue processing
-            self._emit_debug_log_sync(f"Initial yield warning: {e}", __event_call__)
+            self._emit_debug_log_sync(
+                f"Initial yield warning: {e}",
+                __event_call__,
+                debug_enabled=debug_enabled,
+            )
 
         try:
             while not done.is_set():
@@ -2553,6 +3406,7 @@ class Pipe:
                             self._emit_debug_log_sync(
                                 f"Yield error (client disconnected?): {yield_error}",
                                 __event_call__,
+                                debug_enabled=debug_enabled,
                             )
                             break
                 except asyncio.TimeoutError:
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 4ea7ae7..e295f7a 100644
--- a/plugins/pipes/github-copilot-sdk/github_copilot_sdk_cn.py
+++ b/plugins/pipes/github-copilot-sdk/github_copilot_sdk_cn.py
@@ -1,16 +1,15 @@
 """
-title: GitHub Copilot Official SDK Pipe
+title: GitHub Copilot SDK 官方管道
 author: Fu-Jie
 author_url: https://github.com/Fu-Jie/awesome-openwebui
 funding_url: https://github.com/open-webui
-description: 集成 GitHub Copilot SDK。支持动态模型、多轮对话、流式输出、多模态输入、无限会话及前端调试日志。
-version: 0.5.1
+description: 集成 GitHub Copilot SDK。支持动态模型、多选提供商、流式输出、多模态 input、无限会话及前端调试日志。
+version: 0.6.0
 requirements: github-copilot-sdk==0.1.23
 """
 
 import os
 import re
-import time
 import json
 import base64
 import tempfile
@@ -18,14 +17,12 @@ import asyncio
 import logging
 import shutil
 import subprocess
-import sys
 import hashlib
+import aiohttp
 from pathlib import Path
-from typing import Optional, Union, AsyncGenerator, List, Any, Dict, Callable, Tuple, Literal
+from typing import Optional, Union, AsyncGenerator, List, Any, Dict, Literal, Tuple
 from types import SimpleNamespace
 from pydantic import BaseModel, Field, create_model
-from datetime import datetime, timezone
-import contextlib
 
 # 导入 Copilot SDK 模块
 from copilot import CopilotClient, define_tool
@@ -50,36 +47,22 @@ FORMATTING_GUIDELINES = (
     "- **平台**：你在 **OpenWebUI** 托管的 Linux 容器化环境中运行。\n"
     "- **核心引擎**：你由 **GitHub Copilot SDK** 驱动，并通过 **GitHub Copilot CLI** 进行交互。\n"
     "- **访问权限**：你可以直接访问 **OpenWebUI 源代码**。你可以通过文件操作或工具读取、分析和参考你正在运行的平台的内部实现。\n"
-    "- **文件系统访问**：你以 **root** 身份运行。你对 **整个容器文件系统** 拥有 **读取权限**（包括系统文件）。但是，你应 **仅写入** 你指定的持久化工作区目录。\n"
-    "- **原生 Python 环境**：你运行在一个 **丰富的 Python 环境** 中，已经包含了 OpenWebUI 的所有依赖库。你可以直接导入并使用这些已安装的库（例如用于数据处理、工具函数等），而无需安装任何新东西。\n"
-    "- **包管理**：仅当你需要 **额外** 的库时，才应在你的工作区内 **创建一个虚拟环境** 并在那里安装它们。不要搞乱全局 pip。\n"
-    "- **网络**：你有互联网访问权限，并且可以在提供相应工具（例如 Web 搜索、MCP 服务器）的情况下与外部 API 进行交互。\n"
+    "- **文件系统访问**：你以 **root** 身份运行。你对 **整个容器文件系统** 拥有读取权限。但是，你应仅写入工作区目录。\n"
+    "- **原生 Python 环境**：你运行在一个丰富的 Python 环境中，已经包含了 OpenWebUI 的所有依赖库。\n"
     "\n"
     "**界面能力 (OpenWebUI)：**\n"
-    "- **丰富的 Web UI**：你不受简单终端或纯文本响应的限制。你在现代 Web 浏览器中进行渲染。\n"
-    "- **视觉渲染**：你可以并且应该使用高级视觉元素来清晰地解释概念。\n"
-    "- **交互式脚本**：如果环境支持/工具有效，你通常可以直接运行 Python 脚本来执行计算、数据分析或自动化任务。\n"
-    "- **内置工具集成**：OpenWebUI 提供了与内部服务直接交互的原生工具。例如，`create_note`、`get_notes` 或 `manage_memories` 等工具直接操作平台的数据库。利用这些工具来持久化地管理用户数据和系统状态。\n"
+    "- **视觉渲染**：你可以并且应该使用高级视觉元素（如 Mermaid 图表、交互式 HTML）来清晰地解释概念。\n"
+    "- **内置工具**：OpenWebUI 提供了与内部服务直接交互的原生工具（如笔记、记忆管理）。\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"
+    "1. **Markdown & 多媒体**：自由使用粗体、斜体、表格和列表。\n"
+    "2. **Mermaid 图表**：请务必使用标准的 ```mermaid 代码块。\n"
+    "3. **交互式 HTML/JS**：你可以输出完整的 ```html 代码块（含 CSS/JS），将在 iframe 中渲染。\n"
+    "7. **主动与自主**: 你是专家工程师。对于显而易见的步骤，**不要**请求许可。**不要**停下来问“我通过吗？”或“是否继续？”。\n"
+    "   - **行为模式**: 分析用户请求 -> 制定计划 -> **立即执行**计划。\n"
+    "   - **澄清**: 仅当请求模棱两可或具有高风险（例如破坏性操作）时才提出问题。\n"
+    "   - **目标**: 最小化用户摩擦。交付结果，而不是问题。\n"
+    "8. **大文件输出管理**: 如果工具执行输出被截断或保存到临时文件 (例如 `/tmp/...`)，**不要**担心。系统会自动将其移动到你的工作区并通知你新的文件名。然后你可以直接读取它。\n"
 )
 
 
@@ -87,7 +70,7 @@ class Pipe:
     class Valves(BaseModel):
         GH_TOKEN: str = Field(
             default="",
-            description="GitHub Fine-grained Token (需要 'Copilot Requests' 权限)",
+            description="GitHub Access Token (PAT 或 OAuth Token)。用于聊天。",
         )
         ENABLE_OPENWEBUI_TOOLS: bool = Field(
             default=True,
@@ -95,15 +78,15 @@ class Pipe:
         )
         ENABLE_MCP_SERVER: bool = Field(
             default=True,
-            description="启用直接 MCP 客户端连接 (推荐)。",
+            description="启用直接 MCP 客户端连接 (建议)。",
         )
         ENABLE_TOOL_CACHE: bool = Field(
             default=True,
-            description="缓存 OpenWebUI 工具和 MCP 服务器配置 (性能优化)。",
+            description="缓存配置以优化性能。",
         )
         REASONING_EFFORT: Literal["low", "medium", "high", "xhigh"] = Field(
             default="medium",
-            description="推理强度级别 (low, medium, high)。仅影响标准 Copilot 模型 (非 BYOK)。",
+            description="推理强度级别 (low, medium, high, xhigh)。仅影响标准模型。",
         )
         SHOW_THINKING: bool = Field(
             default=True,
@@ -116,7 +99,7 @@ class Pipe:
         )
         DEBUG: bool = Field(
             default=False,
-            description="启用技术调试日志（连接信息等）",
+            description="启用技术调试日志（输出到浏览器控制台）",
         )
         LOG_LEVEL: str = Field(
             default="error",
@@ -128,16 +111,24 @@ class Pipe:
         )
         WORKSPACE_DIR: str = Field(
             default="",
-            description="文件操作的受限工作区目录。为空则使用当前进程目录。",
+            description="文件操作受限目录。为空则使用默认路径。",
         )
         COPILOT_CLI_VERSION: str = Field(
-            default="0.0.405",
-            description="指定安装/强制使用的 Copilot CLI 版本 (例如 '0.0.405')。留空则表示使用最新版。",
+            default="0.0.406",
+            description="指定强制使用的 Copilot CLI 版本 (例如 '0.0.406')。",
+        )
+        PROVIDERS: str = Field(
+            default="OpenAI, Anthropic, Google",
+            description="允许使用的模型提供商 (逗号分隔)。留空则显示所有。",
         )
         EXCLUDE_KEYWORDS: str = Field(
             default="",
             description="排除包含这些关键词的模型（逗号分隔，如：codex, haiku）",
         )
+        MAX_MULTIPLIER: float = Field(
+            default=1.0,
+            description="标准模型允许的最大计费倍率。0 表示仅显示免费模型。",
+        )
         COMPACTION_THRESHOLD: float = Field(
             default=0.8,
             description="后台压缩阈值 (0.0-1.0)",
@@ -148,12 +139,12 @@ class Pipe:
         )
         CUSTOM_ENV_VARS: str = Field(
             default="",
-            description='自定义环境变量（JSON 格式，例如 {"VAR": "value"}）',
+            description="自定义环境变量（JSON 格式）",
         )
 
         BYOK_TYPE: Literal["openai", "anthropic"] = Field(
             default="openai",
-            description="BYOK 提供商类型：openai, anthropic",
+            description="BYOK 供应商类型：openai, anthropic",
         )
         BYOK_BASE_URL: str = Field(
             default="",
@@ -165,25 +156,25 @@ class Pipe:
         )
         BYOK_BEARER_TOKEN: str = Field(
             default="",
-            description="BYOK Bearer 令牌 (全局，优先级高于 API Key)",
+            description="BYOK Bearer 令牌 (优先级高于 API Key)",
         )
         BYOK_MODELS: str = Field(
             default="",
-            description="BYOK 模型列表 (逗号分隔)。留空则尝试从 API 获取。",
+            description="BYOK 模型列表 (逗号分隔)。",
         )
         BYOK_WIRE_API: Literal["completions", "responses"] = Field(
             default="completions",
-            description="BYOK 传输 API 类型：completions, responses",
+            description="BYOK 通信协议：completions, responses",
         )
 
     class UserValves(BaseModel):
         GH_TOKEN: str = Field(
             default="",
-            description="个人 GitHub Fine-grained Token (覆盖全局设置)",
+            description="个人 GitHub Token (覆盖全局设置)",
         )
         REASONING_EFFORT: Literal["", "low", "medium", "high", "xhigh"] = Field(
             default="",
-            description="推理强度级别覆盖。仅影响标准 Copilot 模型。",
+            description="推理强度级别覆盖。",
         )
         SHOW_THINKING: bool = Field(
             default=True,
@@ -191,59 +182,66 @@ class Pipe:
         )
         DEBUG: bool = Field(
             default=False,
-            description="启用技术调试日志（连接信息等）",
+            description="启用技术调试日志",
+        )
+        MAX_MULTIPLIER: Optional[float] = Field(
+            default=None,
+            description="计费倍率覆盖。",
+        )
+        PROVIDERS: str = Field(
+            default="",
+            description="允许的提供商覆盖 (逗号分隔)。",
+        )
+        EXCLUDE_KEYWORDS: str = Field(
+            default="",
+            description="排除关键词 (支持个人覆盖)。",
         )
         ENABLE_OPENWEBUI_TOOLS: bool = Field(
             default=True,
-            description="启用 OpenWebUI 工具 (包括自定义工具和工具服务器工具)。",
+            description="启用 OpenWebUI 工具。",
         )
         ENABLE_MCP_SERVER: bool = Field(
             default=True,
-            description="启用动态 MCP 服务器加载 (覆盖全局设置)。",
+            description="启用动态 MCP 服务器加载。",
         )
         ENABLE_TOOL_CACHE: bool = Field(
             default=True,
-            description="为此用户启用工具/MCP 配置缓存。",
+            description="启用配置缓存。",
+        )
+        COMPACTION_THRESHOLD: Optional[float] = Field(
+            default=None,
+            description="压缩阈值覆盖。",
+        )
+        BUFFER_THRESHOLD: Optional[float] = Field(
+            default=None,
+            description="缓冲区阈值覆盖。",
         )
 
-        # BYOK 用户覆盖
-        BYOK_API_KEY: str = Field(
-            default="",
-            description="BYOK API 密钥 (用户覆盖)",
-        )
+        # 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 模型列表覆盖。",
+            default="", description="BYOK 类型覆盖"
         )
+        BYOK_BASE_URL: str = Field(default="", description="BYOK URL 覆盖")
+        BYOK_BEARER_TOKEN: str = Field(default="", description="BYOK Token 覆盖")
+        BYOK_MODELS: str = Field(default="", description="BYOK 模型列表覆盖")
         BYOK_WIRE_API: Literal["", "completions", "responses"] = Field(
-            default="",
-            description="BYOK 传输 API 覆盖。",
+            default="", description="协议覆盖"
         )
 
+    _model_cache: List[dict] = []
+    _standard_model_ids: set = set()
+    _tool_cache = None
+    _mcp_server_cache = None
+    _env_setup_done = False
+    _last_update_check = 0
+
     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._model_cache = []  # 模型列表缓存
-        self._standard_model_ids = set()  # 追踪标准模型 ID，以区分 BYOK 模型
-        self._env_setup_done = False  # 是否已完成环境初始化环境检查
-        self._tool_cache = None  # 已转换的 OpenWebUI 工具缓存
-        self._mcp_server_cache = None  # MCP 服务器配置缓存
-        self._last_update_check = 0  # Timestamp of last CLI update check
 
     def __del__(self):
         try:
@@ -251,2050 +249,1213 @@ class Pipe:
         except:
             pass
 
-    # ==================== 系统固定入口 ====================
-    # pipe() 是 OpenWebUI 调用的稳定入口。
-    # 将该部分放在前面，便于快速定位与维护。
-    # ======================================================
     async def pipe(
         self,
         body: dict,
-        __metadata__: Optional[dict] = None,
-        __user__: Optional[dict] = None,
+        __metadata__=None,
+        __user__=None,
         __event_emitter__=None,
         __event_call__=None,
     ) -> Union[str, AsyncGenerator]:
         return await self._pipe_impl(
-            body,
-            __metadata__=__metadata__,
-            __user__=__user__,
-            __event_emitter__=__event_emitter__,
-            __event_call__=__event_call__,
+            body, __metadata__, __user__, __event_emitter__, __event_call__
         )
 
-    # ==================== 功能性分区 ====================
-    # 1) 工具加载与转换
-    # 2) 提示词提取与处理
-    # 3) 环境配置与工作区
-    # ======================================================
+    async def _initialize_custom_tools(
+        self, __user__=None, __event_call__=None, body: dict = None
+    ):
+        """基于配置初始化自定义工具"""
+        # 1. 确定有效设置 (用户覆盖 > 全局)
+        uv = self._get_user_valves(__user__)
+        enable_tools = uv.ENABLE_OPENWEBUI_TOOLS
+        enable_openapi = uv.ENABLE_OPENAPI_SERVER
+        enable_cache = uv.ENABLE_TOOL_CACHE
 
-    async def _initialize_custom_tools(self, __user__=None, __event_call__=None):
-        """根据配置初始化自定义工具"""
-        if not self.valves.ENABLE_OPENWEBUI_TOOLS:
+        # 2. 如果所有工具类型都已禁用，立即返回空
+        if not enable_tools and not enable_openapi:
             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
-
-        # 检查缓存
+        # 3. 检查缓存
         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__
+        tools = await self._load_openwebui_tools(
+            __user__=__user__,
+            __event_call__=__event_call__,
+            body=body,
+            enable_tools=enable_tools,
+            enable_openapi=enable_openapi,
         )
 
         # 更新缓存
         if enable_cache:
-            self._tool_cache = openwebui_tools
+            self._tool_cache = tools
             await self._emit_debug_log(
                 "✅ OpenWebUI 工具已缓存，供后续请求使用。", __event_call__
             )
 
-        return openwebui_tools
+        return tools
 
     def _json_schema_to_python_type(self, schema: dict) -> Any:
-        """将 JSON Schema 类型转换为 Pydantic 模型的 Python 类型。"""
         if not isinstance(schema, dict):
             return Any
-
-        # 检查枚举 (Literal)
-        enum_values = schema.get("enum")
-        if enum_values and isinstance(enum_values, list):
-            from typing import Literal
-
-            return Literal[tuple(enum_values)]
-
-        schema_type = schema.get("type")
-        if isinstance(schema_type, list):
-            schema_type = next((t for t in schema_type if t != "null"), schema_type[0])
-
-        if schema_type == "string":
+        e = schema.get("enum")
+        if e and isinstance(e, list):
+            return Literal[tuple(e)]
+        t = schema.get("type")
+        if isinstance(t, list):
+            t = next((x for x in t if x != "null"), t[0])
+        if t == "string":
             return str
-        if schema_type == "integer":
+        if t == "integer":
             return int
-        if schema_type == "number":
+        if t == "number":
             return float
-        if schema_type == "boolean":
+        if t == "boolean":
             return bool
-        if schema_type == "object":
+        if t == "object":
             return Dict[str, Any]
-        if schema_type == "array":
-            items_schema = schema.get("items", {})
-            item_type = self._json_schema_to_python_type(items_schema)
-            return List[item_type]
-
+        if t == "array":
+            return List[self._json_schema_to_python_type(schema.get("items", {}))]
         return Any
 
-    def _convert_openwebui_tool(self, tool_name: str, tool_dict: dict):
-        """将 OpenWebUI 工具定义转换为 Copilot SDK 工具。"""
-        # 净化工具名称以匹配模式 ^[a-zA-Z0-9_-]+$
-        sanitized_tool_name = re.sub(r"[^a-zA-Z0-9_-]", "_", tool_name)
-
-        if not sanitized_tool_name or re.match(r"^[_.-]+$", sanitized_tool_name):
-            hash_suffix = hashlib.md5(tool_name.encode("utf-8")).hexdigest()[:8]
-            sanitized_tool_name = f"tool_{hash_suffix}"
-
-        spec = tool_dict.get("spec", {}) if isinstance(tool_dict, dict) else {}
-        params_schema = spec.get("parameters", {}) if isinstance(spec, dict) else {}
-        properties = params_schema.get("properties", {})
-        required = params_schema.get("required", [])
-
-        if not isinstance(properties, dict):
-            properties = {}
-        if not isinstance(required, list):
-            required = []
-
-        required_set = set(required)
+    def _convert_openwebui_tool(self, n, d, __event_call__=None):
+        sn = re.sub(r"[^a-zA-Z0-9_-]", "_", n)
+        if not sn or re.match(r"^[_.-]+$", sn):
+            sn = f"tool_{hashlib.md5(n.encode()).hexdigest()[:8]}"
+        spec = d.get("spec", {})
+        props = spec.get("parameters", {}).get("properties", {})
+        req = spec.get("parameters", {}).get("required", [])
         fields = {}
-        for param_name, param_schema in properties.items():
-            param_type = self._json_schema_to_python_type(param_schema)
-            description = ""
-            if isinstance(param_schema, dict):
-                description = param_schema.get("description", "")
-
-            # 提取默认值
-            default_value = None
-            if isinstance(param_schema, dict) and "default" in param_schema:
-                default_value = param_schema.get("default")
-
-            if param_name in required_set:
-                if description:
-                    fields[param_name] = (
-                        param_type,
-                        Field(..., description=description),
-                    )
-                else:
-                    fields[param_name] = (param_type, ...)
-            else:
-                optional_type = Optional[param_type]
-                if description:
-                    fields[param_name] = (
-                        optional_type,
-                        Field(default=default_value, description=description),
-                    )
-                else:
-                    fields[param_name] = (optional_type, default_value)
-
-        ParamsModel = (
-            create_model(f"{sanitized_tool_name}_Params", **fields)
-            if fields
-            else create_model(f"{sanitized_tool_name}_Params")
-        )
-
-        tool_callable = tool_dict.get("callable")
-        tool_description = spec.get("description", "") if isinstance(spec, dict) else ""
-        if not tool_description and isinstance(spec, dict):
-            tool_description = spec.get("summary", "")
-
-        # 确定工具来源/组以添加描述前缀
-        tool_id = tool_dict.get("tool_id", "")
-        tool_type = tool_dict.get("type", "")
-
-        if tool_type == "builtin":
-            group_prefix = "[OpenWebUI 内置]"
-        elif tool_type == "external" or tool_id.startswith("server:"):
-            tool_group_name = tool_dict.get("_tool_group_name")
-            tool_group_desc = tool_dict.get("_tool_group_description")
-            server_id = (
-                tool_id.replace("server:", "").split("|")[0]
-                if tool_id.startswith("server:")
-                else tool_id
+        for pn, ps in props.items():
+            pt = self._json_schema_to_python_type(ps)
+            fields[pn] = (
+                pt if pn in req else Optional[pt],
+                Field(
+                    default=ps.get("default") if pn not in req else ...,
+                    description=ps.get("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"[工具服务器: {server_id}]"
-        else:
-            tool_group_name = tool_dict.get("_tool_group_name")
-            tool_group_desc = tool_dict.get("_tool_group_description")
-
-            if tool_group_name:
-                group_prefix = (
-                    f"[用户工具: {tool_group_name} - {tool_group_desc}]"
-                    if tool_group_desc
-                    else f"[用户工具: {tool_group_name}]"
-                )
-            else:
-                group_prefix = f"[用户工具: {tool_id}]" if tool_id else "[用户工具]"
-
-        if sanitized_tool_name != tool_name:
-            tool_description = f"{group_prefix} 函数 '{tool_name}': {tool_description}"
-        else:
-            tool_description = f"{group_prefix} {tool_description}"
-
-        async def _tool(params):
+        async def _tool(p):
             payload = (
-                params.model_dump(exclude_unset=True)
-                if hasattr(params, "model_dump")
-                else {}
+                p.model_dump(exclude_unset=True) if hasattr(p, "model_dump") else {}
             )
-            return await tool_callable(**payload)
-
-        _tool.__name__ = sanitized_tool_name
-        _tool.__doc__ = tool_description
+            return await d.get("callable")(**payload)
 
+        _tool.__name__, _tool.__doc__ = sn, spec.get("description", "") or spec.get(
+            "summary", ""
+        )
         return define_tool(
-            name=sanitized_tool_name,
-            description=tool_description,
-            params_type=ParamsModel,
+            name=sn,
+            description=_tool.__doc__,
+            params_type=create_model(f"{sn}_Params", **fields),
         )(_tool)
 
-    def _build_openwebui_request(self, user_data: Optional[dict] = None):
-        """构建一个最小的 request 模拟对象用于 OpenWebUI 工具加载。"""
+    def _build_openwebui_request(self, user=None, token: str = None):
+        cfg = SimpleNamespace()
+        for i in PERSISTENT_CONFIG_REGISTRY:
+            val = i.value
+            if hasattr(val, "value"):
+                val = val.value
+            setattr(cfg, i.env_name, val)
+
+        if not hasattr(cfg, "TOOL_SERVER_CONNECTIONS"):
+            if hasattr(TOOL_SERVER_CONNECTIONS, "value"):
+                cfg.TOOL_SERVER_CONNECTIONS = TOOL_SERVER_CONNECTIONS.value
+            else:
+                cfg.TOOL_SERVER_CONNECTIONS = TOOL_SERVER_CONNECTIONS
+
         app_state = SimpleNamespace(
-            config=SimpleNamespace(
-                TOOL_SERVER_CONNECTIONS=(
-                    TOOL_SERVER_CONNECTIONS.value
-                    if hasattr(TOOL_SERVER_CONNECTIONS, "value")
-                    else []
-                )
-            ),
+            config=cfg,
             TOOLS={},
+            TOOL_CONTENTS={},
+            FUNCTIONS={},
+            FUNCTION_CONTENTS={},
+            MODELS={},
+            redis=None,
+            TOOL_SERVERS=[],
         )
-        app = SimpleNamespace(state=app_state)
 
         def url_path_for(name: str, **path_params):
-            return f"/mock/path/{name}"
+            if name == "get_file_content_by_id":
+                return f"/api/v1/files/{path_params.get('id')}/content"
+            return f"/mock/{name}"
 
-        app.url_path_for = url_path_for
-
-        request = SimpleNamespace(
-            app=app,
-            cookies={},
-            state=SimpleNamespace(token=SimpleNamespace(credentials="")),
-        )
-        if user_data and user_data.get("token"):
-            request.state.token.credentials = user_data["token"]
-        return request
-
-    async def _load_openwebui_tools(self, __user__=None, __event_call__=None):
-        """加载 OpenWebUI 工具并转换为 Copilot SDK 工具。"""
-        if isinstance(__user__, (list, tuple)):
-            user_data = __user__[0] if __user__ else {}
-        elif isinstance(__user__, dict):
-            user_data = __user__
-        else:
-            user_data = {}
-
-        if not user_data:
-            return []
-
-        user_id = user_data.get("id") or user_data.get("user_id")
-        if not user_id:
-            return []
-
-        try:
-            from open_webui.models.users import Users
-
-            user = Users.get_user_by_id(user_id)
-            if not user:
-                return []
-        except:
-            return []
-
-        # 1. 用户自定义工具
-        tool_items = Tools.get_tools_by_user_id(user_id, permission="read")
-        tool_ids = [tool.id for tool in tool_items] if tool_items else []
-
-        # 2. 工具服务器工具
-        if hasattr(TOOL_SERVER_CONNECTIONS, "value"):
-            for server in TOOL_SERVER_CONNECTIONS.value:
-                if server.get("type") == "openapi":
-                    server_id = server.get("id")
-                    if server_id:
-                        tool_ids.append(f"server:{server_id}")
-
-        request = self._build_openwebui_request(user_data)
-        extra_params = {
-            "__request__": request,
-            "__user__": user_data,
-            "__event_call__": __event_call__,
+        req_headers = {
+            "user-agent": "Copilot-Pipe",
+            "host": "localhost:8080",
+            "accept": "*/*",
         }
+        if token:
+            req_headers["Authorization"] = f"Bearer {token}"
 
-        tools_dict = {}
-        if tool_ids:
-            try:
-                tools_dict = await get_openwebui_tools(
-                    request, tool_ids, user, extra_params
+        return SimpleNamespace(
+            app=SimpleNamespace(state=app_state, url_path_for=url_path_for),
+            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=req_headers,
+            method="POST",
+            cookies={},
+            state=SimpleNamespace(
+                token=SimpleNamespace(credentials=token if token else ""),
+                user=user or {},
+            ),
+        )
+
+    async def _load_openwebui_tools(
+        self,
+        __user__=None,
+        __event_call__=None,
+        body: dict = None,
+        enable_tools: bool = True,
+        enable_openapi: bool = True,
+    ):
+        ud = __user__[0] if isinstance(__user__, (list, tuple)) else (__user__ or {})
+        uid = ud.get("id") or ud.get("user_id")
+        if not uid:
+            return []
+        u = Users.get_user_by_id(uid)
+        if not u:
+            return []
+        tids = []
+        # 1. 获取用户自定义工具 (Python 脚本)
+        if enable_tools:
+            tool_items = Tools.get_tools_by_user_id(uid, permission="read")
+            if tool_items:
+                tids.extend([tool.id for tool in tool_items])
+
+        # 2. 获取 OpenAPI 工具服务器工具
+        if enable_openapi:
+            if hasattr(TOOL_SERVER_CONNECTIONS, "value"):
+                tids.extend(
+                    [
+                        f"server:{s.get('id')}"
+                        for s in TOOL_SERVER_CONNECTIONS.value
+                        if (
+                            s.get("type", "openapi") == "openapi"
+                            or s.get("type") is None
+                        )
+                        and s.get("id")
+                    ]
                 )
-            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,
-                            }
-                        }
-                    }
+        token = None
+        if isinstance(body, dict):
+            token = body.get("token")
+
+        req = self._build_openwebui_request(ud, token)
+        td = {}
+
+        if tids:
+            td = await get_openwebui_tools(
+                req,
+                tids,
+                u,
+                {
+                    "__request__": req,
+                    "__user__": ud,
+                    "__event_emitter__": None,
+                    "__event_call__": __event_call__,
+                    "__chat_id__": None,
+                    "__message_id__": None,
+                    "__model_knowledge__": [],
+                    "__oauth_token__": {"access_token": token} if token else None,
                 },
             )
-            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():
+        # 3. 获取内建工具 (网页搜索、内存等)
+        if enable_tools:
             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)
+                bi = get_builtin_tools(
+                    req,
+                    {
+                        "__user__": ud,
+                        "__chat_id__": None,
+                        "__message_id__": None,
+                    },
+                    model={
+                        "info": {
+                            "meta": {
+                                "capabilities": {
+                                    "web_search": True,
+                                    "image_generation": True,
+                                }
+                            }
+                        }
+                    },
                 )
+                if bi:
+                    td.update(bi)
+            except:
+                pass
+        return [
+            self._convert_openwebui_tool(n, d, __event_call__=__event_call__)
+            for n, d in td.items()
+        ]
+
+    def _get_user_valves(self, __user__: Optional[dict]) -> "Pipe.UserValves":
+        """从 __user__ 上下文中稳健地提取 UserValves。"""
+        if not __user__:
+            return self.UserValves()
+
+        # 处理列表/元组包装
+        user_data = __user__[0] if isinstance(__user__, (list, tuple)) else __user__
+        if not isinstance(user_data, dict):
+            return self.UserValves()
+
+        raw_valves = user_data.get("valves")
+        if isinstance(raw_valves, self.UserValves):
+            return raw_valves
+        if isinstance(raw_valves, dict):
+            try:
+                return self.UserValves(**raw_valves)
             except Exception as e:
-                await self._emit_debug_log(
-                    f"转换 OpenWebUI 工具 '{tool_name}' 失败: {e}",
-                    __event_call__,
-                )
+                logger.warning(f"[Copilot] 解析 UserValves 失败: {e}")
+        return self.UserValves()
 
-        return converted_tools
-
-    def _parse_mcp_servers(self) -> Optional[dict]:
-        """
-        从 OpenWebUI TOOL_SERVER_CONNECTIONS 动态加载 MCP 服务器配置。
-        返回兼容 CopilotClient 的 mcp_servers 字典。
-        """
+    def _parse_mcp_servers(self, __event_call__=None) -> Optional[dict]:
         if not self.valves.ENABLE_MCP_SERVER:
             return None
-
-        # 检查缓存
         if self.valves.ENABLE_TOOL_CACHE and self._mcp_server_cache is not None:
             return self._mcp_server_cache
-
-        mcp_servers = {}
-
-        # 遍历 OpenWebUI 工具服务器连接
-        if hasattr(TOOL_SERVER_CONNECTIONS, "value"):
-            connections = TOOL_SERVER_CONNECTIONS.value
-        else:
-            connections = []
-
-        for conn in connections:
-            if conn.get("type") == "mcp":
-                info = conn.get("info", {})
-                # 使用 info 中的 ID 或自动生成
-                raw_id = info.get("id", f"mcp-server-{len(mcp_servers)}")
-
-                # 净化 server_id (使用与工具相同的逻辑)
-                server_id = re.sub(r"[^a-zA-Z0-9_-]", "_", raw_id)
-                if not server_id or re.match(r"^[_.-]+$", server_id):
-                    hash_suffix = hashlib.md5(raw_id.encode("utf-8")).hexdigest()[:8]
-                    server_id = f"server_{hash_suffix}"
-
-                url = conn.get("url")
-                if not url:
-                    continue
-
-                # 构建 Header (处理认证)
-                headers = {}
-                auth_type = conn.get("auth_type", "bearer")
-                key = conn.get("key", "")
-
-                if auth_type == "bearer" and key:
-                    headers["Authorization"] = f"Bearer {key}"
-                elif auth_type == "basic" and key:
-                    headers["Authorization"] = f"Basic {key}"
-
-                # 合并自定义 headers
-                custom_headers = conn.get("headers", {})
-                if isinstance(custom_headers, dict):
-                    headers.update(custom_headers)
-
-                # 获取过滤配置
-                mcp_config = conn.get("config", {})
-                function_filter = mcp_config.get("function_name_filter_list", "")
-
-                allowed_tools = ["*"]
-                if function_filter:
-                    if isinstance(function_filter, str):
-                        allowed_tools = [
-                            f.strip() for f in function_filter.split(",") if f.strip()
-                        ]
-                    elif isinstance(function_filter, list):
-                        allowed_tools = function_filter
-
-                mcp_servers[server_id] = {
-                    "type": "http",
-                    "url": url,
-                    "headers": headers,
-                    "tools": allowed_tools,
-                }
-
-        # 更新缓存
-        if self.valves.ENABLE_TOOL_CACHE:
-            self._mcp_server_cache = mcp_servers
-
-        return mcp_servers if mcp_servers else None
-
-    def _build_session_config(
-        self,
-        chat_id: Optional[str],
-        real_model_id: str,
-        custom_tools: List[Any],
-        system_prompt_content: Optional[str],
-        is_streaming: bool,
-    ):
-        """构建 Copilot SDK 的 SessionConfig"""
-        # 处理无限会话配置
-        from copilot.types import SessionConfig, InfiniteSessionConfig
-
-        infinite_session_config = None
-        if self.valves.INFINITE_SESSION:
-            infinite_session_config = InfiniteSessionConfig(
-                enabled=True,
-                background_compaction_threshold=self.valves.COMPACTION_THRESHOLD,
-                buffer_exhaustion_threshold=self.valves.BUFFER_THRESHOLD,
+        mcp = {}
+        conns = (
+            getattr(TOOL_SERVER_CONNECTIONS, "value", [])
+            if hasattr(TOOL_SERVER_CONNECTIONS, "value")
+            else (
+                TOOL_SERVER_CONNECTIONS
+                if isinstance(TOOL_SERVER_CONNECTIONS, list)
+                else []
             )
-
-        # 始终包含格式化指南（默认开启）
-        system_parts = []
-        if system_prompt_content:
-            system_parts.append(system_prompt_content)
-        system_parts.append(FORMATTING_GUIDELINES)
-
-        # 始终使用 'replace' 模式以确保完全控制并避免重复
-        system_message_config = {
-            "mode": "replace",
-            "content": "\n".join(system_parts),
-        }
-
-        # 准备基础参数
-        session_params = {
-            "session_id": chat_id if chat_id else None,
-            "model": real_model_id,
-            "streaming": is_streaming,
-            "tools": custom_tools,
-            "system_message": system_message_config,
-            "infinite_sessions": infinite_session_config,
-        }
-
-        # 注入 MCP 转换器
-        mcp_servers = self._parse_mcp_servers()
-        if mcp_servers:
-            session_params["mcp_servers"] = mcp_servers
-
-        return SessionConfig(**session_params)
-
-    def _dedupe_preserve_order(self, items: List[str]) -> List[str]:
-        """去重保序"""
-        seen = set()
-        result = []
-        for item in items:
-            if not item or item in seen:
+        )
+        for c in conns:
+            if not isinstance(c, dict) or c.get("type") != "mcp":
                 continue
-            seen.add(item)
-            result.append(item)
-        return result
-
-    def _apply_formatting_hint(self, prompt: str) -> str:
-        """返回原始提示词（已移除格式化提示）"""
-        return prompt
-
-    def _collect_model_ids(
-        self, body: dict, request_model: str, real_model_id: str
-    ) -> List[str]:
-        """收集可能的模型 ID（来自请求/metadata/body params）"""
-        model_ids: List[str] = []
-        if request_model:
-            model_ids.append(request_model)
-        if request_model.startswith(f"{self.id}-"):
-            model_ids.append(request_model[len(f"{self.id}-") :])
-        if real_model_id:
-            model_ids.append(real_model_id)
-
-        metadata = body.get("metadata", {})
-        if isinstance(metadata, dict):
-            meta_model = metadata.get("model")
-            meta_model_id = metadata.get("model_id")
-            if isinstance(meta_model, str):
-                model_ids.append(meta_model)
-            if isinstance(meta_model_id, str):
-                model_ids.append(meta_model_id)
-
-        body_params = body.get("params", {})
-        if isinstance(body_params, dict):
-            for key in ("model", "model_id", "modelId"):
-                val = body_params.get(key)
-                if isinstance(val, str):
-                    model_ids.append(val)
-
-        return self._dedupe_preserve_order(model_ids)
-
-    async def _extract_system_prompt(
-        self,
-        body: dict,
-        messages: List[dict],
-        request_model: str,
-        real_model_id: str,
-        __event_call__=None,
-        debug_enabled: bool = False,
-    ) -> Tuple[Optional[str], str]:
-        """从 metadata/模型 DB/body/messages 提取系统提示词"""
-        system_prompt_content: Optional[str] = None
-        system_prompt_source = ""
-
-        # 0) body.get("system_prompt") - Explicit Override (Highest Priority)
-        if hasattr(body, "get") and body.get("system_prompt"):
-            system_prompt_content = body.get("system_prompt")
-            system_prompt_source = "body_explicit_system_prompt"
-            await self._emit_debug_log(
-                f"从显式 body 字段提取了系统提示词（长度: {len(system_prompt_content)}）",
-                __event_call__,
-                debug_enabled=debug_enabled,
+            info = c.get("info", {})
+            rid = info.get("id") or c.get("id") or f"mcp-{len(mcp)}"
+            sid = re.sub(r"[^a-zA-Z0-9-]", "-", str(rid)).lower().strip("-")
+            url = c.get("url")
+            if not url:
+                continue
+            mtype = "http"
+            if "/sse" in url.lower() or "sse" in str(c.get("config", {})).lower():
+                mtype = "sse"
+            h = c.get("headers", {})
+            at, key = str(c.get("auth_type", "bearer")).lower(), c.get("key", "")
+            if key and "Authorization" not in h:
+                if at == "bearer":
+                    h["Authorization"] = f"Bearer {key}"
+                elif at == "basic":
+                    h["Authorization"] = (
+                        f"Basic {base64.b64encode(key.encode()).decode()}"
+                    )
+                elif at in ["api_key", "apikey"]:
+                    h["X-API-Key"] = key
+            ff = c.get("config", {}).get("function_name_filter_list", "")
+            allowed = [f.strip() for f in ff.split(",") if f.strip()] if ff else ["*"]
+            self._emit_debug_log_sync(
+                f"🔌 发现 MCP 节点: {sid} ({mtype.upper()}) | URL: {url}"
             )
-
-        # 1) metadata.model.params.system
-        if not system_prompt_content:
-            metadata = body.get("metadata", {})
-            if isinstance(metadata, dict):
-                meta_model = metadata.get("model")
-                if isinstance(meta_model, dict):
-                    meta_params = meta_model.get("params")
-                    if isinstance(meta_params, dict) and meta_params.get("system"):
-                        system_prompt_content = meta_params.get("system")
-                        system_prompt_source = "metadata.model.params"
-                        await self._emit_debug_log(
-                            f"从 metadata.model.params 提取系统提示词（长度: {len(system_prompt_content)}）",
-                            __event_call__,
-                            debug_enabled=debug_enabled,
-                        )
-
-        # 2) 模型 DB
-        if not system_prompt_content:
-            try:
-                from open_webui.models.models import Models
-
-                model_ids_to_try = self._collect_model_ids(
-                    body, request_model, real_model_id
-                )
-                for mid in model_ids_to_try:
-                    model_record = Models.get_model_by_id(mid)
-                    if model_record and hasattr(model_record, "params"):
-                        params = model_record.params
-                        if isinstance(params, dict):
-                            system_prompt_content = params.get("system")
-                            if system_prompt_content:
-                                system_prompt_source = f"model_db:{mid}"
-                                await self._emit_debug_log(
-                                    f"成功！使用 ID 从模型数据库中提取了系统提示词: {mid}（长度: {len(system_prompt_content)}）",
-                                    __event_call__,
-                                    debug_enabled=debug_enabled,
-                                )
-                                break
-            except Exception as e:
-                await self._emit_debug_log(
-                    f"从模型数据库提取系统提示词失败: {e}",
-                    __event_call__,
-                    debug_enabled=debug_enabled,
-                )
-
-        # 3) body.params.system
-        if not system_prompt_content:
-            body_params = body.get("params", {})
-            if isinstance(body_params, dict):
-                system_prompt_content = body_params.get("system")
-                if system_prompt_content:
-                    system_prompt_source = "body_params"
-                    await self._emit_debug_log(
-                        f"从 body.params 提取系统提示词（长度: {len(system_prompt_content)}）",
-                        __event_call__,
-                    )
-
-        # 4) messages (role=system)
-        if not system_prompt_content:
-            for msg in messages:
-                if msg.get("role") == "system":
-                    system_prompt_content = self._extract_text_from_content(
-                        msg.get("content", "")
-                    )
-                    if system_prompt_content:
-                        system_prompt_source = "messages_system"
-                        await self._emit_debug_log(
-                            f"从消息中提取系统提示词（长度: {len(system_prompt_content)}）",
-                            __event_call__,
-                        )
-                    break
-
-        return system_prompt_content, system_prompt_source
+            mcp[sid] = {"type": mtype, "url": url, "headers": h, "tools": allowed}
+        if self.valves.ENABLE_TOOL_CACHE:
+            self._mcp_server_cache = mcp
+        return mcp if mcp else None
 
     async def _emit_debug_log(
         self, message: str, __event_call__=None, debug_enabled: Optional[bool] = None
     ):
-        """在 DEBUG 开启时将日志输出到前端控制台。"""
-        should_log = (
+        is_debug = (
             debug_enabled
             if debug_enabled is not None
             else getattr(self.valves, "DEBUG", False)
         )
-        if not should_log:
-            return
-
-        logger.debug(f"[Copilot Pipe] {message}")
-
-        if not __event_call__:
-            return
-
-        try:
-            js_code = f"""
-                (async function() {{
-                    console.debug("%c[Copilot Pipe] " + {json.dumps(message, ensure_ascii=False)}, "color: #3b82f6;");
-                }})();
-            """
-            await __event_call__({"type": "execute", "data": {"code": js_code}})
-        except Exception as e:
-            logger.debug(f"[Copilot Pipe] 前端调试日志失败: {e}")
+        log_msg = f"[Copilot SDK] {message}"
+        if is_debug:
+            logger.info(log_msg)
+        else:
+            logger.debug(log_msg)
+        if is_debug and __event_call__:
+            try:
+                js = f"console.debug('%c[Copilot SDK] ' + {json.dumps(message, ensure_ascii=False)}, 'color: #3b82f6;');"
+                await __event_call__({"type": "execute", "data": {"code": js}})
+            except:
+                pass
 
     def _emit_debug_log_sync(
         self, message: str, __event_call__=None, debug_enabled: Optional[bool] = None
     ):
-        """在非异步上下文中输出调试日志。"""
-        should_log = (
+        is_debug = (
             debug_enabled
             if debug_enabled is not None
             else getattr(self.valves, "DEBUG", False)
         )
-        if not should_log:
-            return
-
-        try:
-            loop = asyncio.get_running_loop()
-            loop.create_task(
-                self._emit_debug_log(message, __event_call__, debug_enabled=True)
-            )
-        except RuntimeError:
-            logger.debug(f"[Copilot Pipe] {message}")
-
-    async def _emit_native_message(self, message_data: dict, __event_call__=None):
-        """发送原生 OpenAI 格式消息事件用于工具调用/结果。"""
-        if not __event_call__:
-            return
-
-        try:
-            await __event_call__({"type": "message", "data": message_data})
-            await self._emit_debug_log(
-                f"已发送原生消息: {message_data.get('role')} - {list(message_data.keys())}",
-                __event_call__,
-            )
-        except Exception as e:
-            logger.warning(f"发送原生消息失败: {e}")
-            await self._emit_debug_log(
-                f"原生消息发送失败: {e}。回退到文本显示。", __event_call__
-            )
-
-    def _get_user_context(self):
-        """获取用户上下文（占位，预留）。"""
-        return {}
-
-    def _get_chat_context(
-        self,
-        body: dict,
-        __metadata__: Optional[dict] = None,
-        __event_call__=None,
-        debug_enabled: bool = False,
-    ) -> Dict[str, str]:
-        """
-        高度可靠的聊天上下文提取逻辑。
-        优先级：__metadata__ > body['chat_id'] > body['metadata']['chat_id']
-        """
-        chat_id = ""
-        source = "none"
-
-        # 1. 优先从 __metadata__ 获取 (OpenWebUI 注入的最可靠来源)
-        if __metadata__ and isinstance(__metadata__, dict):
-            chat_id = __metadata__.get("chat_id", "")
-            if chat_id:
-                source = "__metadata__"
-
-        # 2. 其次从 body 顶层获取
-        if not chat_id and isinstance(body, dict):
-            chat_id = body.get("chat_id", "")
-            if chat_id:
-                source = "body_root"
-
-        # 3. 最后从 body.metadata 获取
-        if not chat_id and isinstance(body, dict):
-            body_metadata = body.get("metadata", {})
-            if isinstance(body_metadata, dict):
-                chat_id = body_metadata.get("chat_id", "")
-                if chat_id:
-                    source = "body_metadata"
-
-        # 调试：记录 ID 来源
-        if chat_id:
-            self._emit_debug_log_sync(
-                f"提取到 ChatID: {chat_id} (来源: {source})",
-                __event_call__,
-                debug_enabled=debug_enabled,
-            )
+        log_msg = f"[Copilot SDK] {message}"
+        if is_debug:
+            logger.info(log_msg)
         else:
-            # 如果还是没找到，记录一下 body 的键，方便排查
-            keys = list(body.keys()) if isinstance(body, dict) else "not a dict"
-            self._emit_debug_log_sync(
-                f"警告: 未能提取到 ChatID。Body 键: {keys}",
-                __event_call__,
-                debug_enabled=debug_enabled,
-            )
-
-        return {
-            "chat_id": str(chat_id).strip(),
-        }
-
-    async def pipes(self) -> List[dict]:
-        """动态获取模型列表"""
-        # 如果有缓存，直接返回
-        if self._model_cache:
-            return self._model_cache
-
-        await self._emit_debug_log("正在动态获取模型列表...")
-        try:
-            self._setup_env()
-            if not self.valves.GH_TOKEN:
-                return [{"id": f"{self.id}-error", "name": "Error: GH_TOKEN not set"}]
-
-            client_config = {}
-            if os.environ.get("COPILOT_CLI_PATH"):
-                client_config["cli_path"] = os.environ["COPILOT_CLI_PATH"]
-
-            client = CopilotClient(client_config)
+            logger.debug(log_msg)
+        if is_debug and __event_call__:
             try:
-                await client.start()
-                models = await client.list_models()
-
-                # 更新缓存
-                self._model_cache = []
-                exclude_list = [
-                    k.strip().lower()
-                    for k in self.valves.EXCLUDE_KEYWORDS.split(",")
-                    if k.strip()
-                ]
-
-                models_with_info = []
-                for m in models:
-                    # 兼容字典和对象访问方式
-                    m_id = (
-                        m.get("id") if isinstance(m, dict) else getattr(m, "id", str(m))
-                    )
-                    m_name = (
-                        m.get("name")
-                        if isinstance(m, dict)
-                        else getattr(m, "name", m_id)
-                    )
-                    m_policy = (
-                        m.get("policy")
-                        if isinstance(m, dict)
-                        else getattr(m, "policy", {})
-                    )
-                    m_billing = (
-                        m.get("billing")
-                        if isinstance(m, dict)
-                        else getattr(m, "billing", {})
-                    )
-
-                    # 检查策略状态
-                    state = (
-                        m_policy.get("state")
-                        if isinstance(m_policy, dict)
-                        else getattr(m_policy, "state", "enabled")
-                    )
-                    if state == "disabled":
-                        continue
-
-                    # 过滤逻辑
-                    if any(kw in m_id.lower() for kw in exclude_list):
-                        continue
-
-                    # 获取倍率
-                    multiplier = (
-                        m_billing.get("multiplier", 1)
-                        if isinstance(m_billing, dict)
-                        else getattr(m_billing, "multiplier", 1)
-                    )
-
-                    # 格式化显示名称
-                    # 格式化显示名称
-                    clean_id = self._clean_model_id(m_id)
-                    if multiplier == 0:
-                        display_name = f"-🔥 {clean_id} (0x)"
-                    else:
-                        display_name = f"-{clean_id} ({multiplier}x)"
-
-                    models_with_info.append(
-                        {
-                            "id": f"{self.id}-{m_id}",  # Keep original prefix logic for ID
-                            "name": display_name,
-                            "multiplier": multiplier,
-                            "raw_id": m_id,
-                        }
-                    )
-
-                # 排序：倍率升序，然后是原始ID升序
-                models_with_info.sort(key=lambda x: (x["multiplier"], x["raw_id"]))
-                self._model_cache = [
-                    {"id": m["id"], "name": m["name"]} for m in models_with_info
-                ]
-
-                await self._emit_debug_log(
-                    f"成功获取 {len(self._model_cache)} 个模型 (已过滤)"
+                asyncio.get_running_loop().create_task(
+                    self._emit_debug_log(message, __event_call__, True)
                 )
-                return self._model_cache
-            except Exception as e:
-                await self._emit_debug_log(f"获取模型列表失败: {e}")
-                # 失败时返回默认模型
-                return [
-                    {
-                        "id": f"{self.id}-gpt-5-mini",
-                        "name": f"GitHub Copilot (gpt-5-mini)",
-                    }
-                ]
-            finally:
-                await client.stop()
-        except Exception as e:
-            await self._emit_debug_log(f"Pipes Error: {e}")
-            return [
-                {
-                    "id": f"{self.id}-gpt-5-mini",
-                    "name": f"GitHub Copilot (gpt-5-mini)",
-                }
-            ]
-
-    async def _get_client(self):
-        """Helper to get or create a CopilotClient instance."""
-        # 确定工作空间目录
-        cwd = self.valves.WORKSPACE_DIR if self.valves.WORKSPACE_DIR else os.getcwd()
-
-        client_config = {}
-        if os.environ.get("COPILOT_CLI_PATH"):
-            client_config["cli_path"] = os.environ["COPILOT_CLI_PATH"]
-        client_config["cwd"] = cwd
-
-        # 设置日志级别
-        if self.valves.LOG_LEVEL:
-            client_config["log_level"] = self.valves.LOG_LEVEL
-
-        # 添加自定义环境变量
-        if self.valves.CUSTOM_ENV_VARS:
-            try:
-                custom_env = json.loads(self.valves.CUSTOM_ENV_VARS)
-                if isinstance(custom_env, dict):
-                    client_config["env"] = custom_env
             except:
-                pass  # 静默失败，因为这是同步方法且不应影响主流程
+                pass
 
-        client = CopilotClient(client_config)
-        await client.start()
-        return client
+    def _get_provider_name(self, mi: Any) -> str:
+        mid = getattr(mi, "id", str(mi)).lower()
+        if any(k in mid for k in ["gpt", "codex"]):
+            return "OpenAI"
+        if "claude" in mid:
+            return "Anthropic"
+        if "gemini" in mid:
+            return "Google"
+        p = getattr(mi, "policy", None)
+        if p:
+            t = str(getattr(p, "terms", "")).lower()
+            if "openai" in t:
+                return "OpenAI"
+            if "anthropic" in t:
+                return "Anthropic"
+            if "google" in t:
+                return "Google"
+        return "Unknown"
 
-    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 _clean_model_id(self, mid: str) -> str:
+        if "." in mid:
+            mid = mid.split(".", 1)[-1]
+        for p in ["copilot-", "copilot - "]:
+            if mid.startswith(p):
+                mid = mid[len(p) :]
+        return mid
 
     def _setup_env(self, __event_call__=None, debug_enabled: bool = False):
-        """初始化环境变量并验证 Copilot CLI。"""
-        if self._env_setup_done:
+        if self.__class__._env_setup_done:
+            # 即使已完成环境配置，在调试模式下仍同步一次 MCP。
+            if debug_enabled:
+                self._sync_mcp_config(__event_call__, debug_enabled)
             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,
-        )
+        cp = os.environ.get("COPILOT_CLI_PATH", "/usr/local/bin/copilot")
+        target = self.valves.COPILOT_CLI_VERSION.strip()
 
-        # 2. CLI 路径发现
-        cli_path = "/usr/local/bin/copilot"
-        if os.environ.get("COPILOT_CLI_PATH"):
-            cli_path = os.environ["COPILOT_CLI_PATH"]
+        # 记录检查时间
+        from datetime import datetime
 
-        target_version = self.valves.COPILOT_CLI_VERSION.strip()
-        found = False
-        current_version = None
+        self.__class__._last_update_check = datetime.now().timestamp()
 
-        def get_cli_version(path):
+        def gv(p):
             try:
-                output = (
+                return re.search(
+                    r"(\d+\.\d+\.\d+)",
                     subprocess.check_output(
-                        [path, "--version"], stderr=subprocess.STDOUT
-                    )
-                    .decode()
-                    .strip()
-                )
-                import re
-
-                match = re.search(r"(\d+\.\d+\.\d+)", output)
-                return match.group(1) if match else output
-            except Exception:
+                        [p, "--version"], stderr=subprocess.STDOUT
+                    ).decode(),
+                ).group(1)
+            except:
                 return None
 
-        # 检查现有版本
-        if os.path.exists(cli_path):
-            found = True
-            current_version = get_cli_version(cli_path)
-
-        if not found:
-            sys_path = shutil.which("copilot")
-            if sys_path:
-                cli_path = sys_path
-                found = True
-                current_version = get_cli_version(cli_path)
-
-        if not found:
-            pkg_path = os.path.join(os.path.dirname(__file__), "bin", "copilot")
-            if os.path.exists(pkg_path):
-                cli_path = pkg_path
-                found = True
-                current_version = get_cli_version(cli_path)
-
-        # 3. 安装/更新逻辑
-        should_install = not found
-        install_reason = "CLI 未找到"
-        if found and target_version:
-            norm_target = target_version.lstrip("v")
-            norm_current = current_version.lstrip("v") if current_version else ""
-
-            # 只有当目标版本大于当前版本时才安装
-            try:
-                from packaging.version import parse as parse_version
-
-                if parse_version(norm_target) > parse_version(norm_current):
-                    should_install = True
-                    install_reason = f"需要升级 ({current_version} -> {target_version})"
-                elif parse_version(norm_target) < parse_version(norm_current):
-                    self._emit_debug_log_sync(
-                        f"当前版本 ({current_version}) 比指定版本 ({target_version}) 更新。跳过降级。",
-                        __event_call__,
-                        debug_enabled=debug_enabled,
-                    )
-            except Exception as e:
-                # 如果 packaging 不可用，回退到字符串比较
-                if norm_target != norm_current:
-                    should_install = True
-                    install_reason = (
-                        f"版本不匹配 ({current_version} != {target_version})"
-                    )
-
-        if should_install:
+        cv = gv(cp)
+        if not cv:
+            cp = shutil.which("copilot") or os.path.join(
+                os.path.dirname(__file__), "bin", "copilot"
+            )
+        cv = gv(cp)
+        if not cv or (target and target.lstrip("v") > (cv or "")):
             self._emit_debug_log_sync(
-                f"正在安装/更新 Copilot CLI: {install_reason}...",
-                __event_call__,
-                debug_enabled=debug_enabled,
+                f"正在更新 Copilot CLI 至 {target}...", __event_call__, debug_enabled
             )
             try:
-                env = os.environ.copy()
-                if target_version:
-                    env["VERSION"] = target_version
+                ev = os.environ.copy()
+                if target:
+                    ev["VERSION"] = target
                 subprocess.run(
                     "curl -fsSL https://gh.io/copilot-install | bash",
                     shell=True,
                     check=True,
-                    env=env,
-                )
-                # 重新验证
-                current_version = get_cli_version(cli_path)
-            except Exception as e:
-                self._emit_debug_log_sync(
-                    f"CLI 安装失败: {e}",
-                    __event_call__,
-                    debug_enabled=debug_enabled,
+                    env=ev,
                 )
+                cp, cv = "/usr/local/bin/copilot", gv("/usr/local/bin/copilot")
+            except:
+                pass
+        os.environ["COPILOT_CLI_PATH"] = cp
+        self.__class__._env_setup_done = True
+        self._sync_mcp_config(__event_call__, debug_enabled)
 
-        # 4. 完成初始化
-        os.environ["COPILOT_CLI_PATH"] = cli_path
-        self._env_setup_done = True
-        self._emit_debug_log_sync(
-            f"环境设置完成。CLI 路径: {cli_path} (版本: {current_version})",
-            __event_call__,
-            debug_enabled=debug_enabled,
+    def _sync_mcp_config(self, __event_call__=None, debug_enabled: bool = False):
+        if not self.valves.ENABLE_MCP_SERVER:
+            return
+        mcp = self._parse_mcp_servers(__event_call__)
+        if not mcp:
+            return
+        try:
+            path = os.path.expanduser("~/.copilot/config.json")
+            os.makedirs(os.path.dirname(path), exist_ok=True)
+            data = {}
+            if os.path.exists(path):
+                try:
+                    with open(path, "r") as f:
+                        data = json.load(f)
+                except:
+                    pass
+            if json.dumps(data.get("mcp_servers"), sort_keys=True) != json.dumps(
+                mcp, sort_keys=True
+            ):
+                data["mcp_servers"] = mcp
+                with open(path, "w") as f:
+                    json.dump(data, f, indent=4)
+                self._emit_debug_log_sync(
+                    f"已将 {len(mcp)} 个 MCP 节点同步至配置文件",
+                    __event_call__,
+                    debug_enabled,
+                )
+        except:
+            pass
+
+    def _get_workspace_dir(self, user_id: str = None, chat_id: str = None) -> str:
+        """获取具有用户和聊天隔离的有效工作区目录"""
+        d = self.valves.WORKSPACE_DIR
+        base_cwd = (
+            d
+            if d
+            else (
+                "/app/backend/data/copilot_workspace"
+                if os.path.exists("/app/backend/data")
+                else os.path.join(os.getcwd(), "copilot_workspace")
+            )
         )
-        self._sync_mcp_config(__event_call__, debug_enabled=debug_enabled)
+
+        cwd = base_cwd
+        if user_id:
+            safe_user_id = re.sub(r"[^a-zA-Z0-9_-]", "_", str(user_id))
+            cwd = os.path.join(cwd, safe_user_id)
+        if chat_id:
+            safe_chat_id = re.sub(r"[^a-zA-Z0-9_-]", "_", str(chat_id))
+            cwd = os.path.join(cwd, safe_chat_id)
+
+        try:
+            os.makedirs(cwd, exist_ok=True)
+            return cwd
+        except Exception as e:
+            return base_cwd
 
     def _process_images(
         self, messages, __event_call__=None, debug_enabled: bool = False
     ):
-        attachments = []
-        text_content = ""
         if not messages:
             return "", []
-        last_msg = messages[-1]
-        content = last_msg.get("content", "")
-
-        if isinstance(content, list):
-            for item in content:
-                if item.get("type") == "text":
-                    text_content += item.get("text", "")
-                elif item.get("type") == "image_url":
-                    image_url = item.get("image_url", {}).get("url", "")
-                    if image_url.startswith("data:image"):
-                        try:
-                            header, encoded = image_url.split(",", 1)
-                            ext = header.split(";")[0].split("/")[-1]
-                            file_name = f"image_{len(attachments)}.{ext}"
-                            file_path = os.path.join(self.temp_dir, file_name)
-                            with open(file_path, "wb") as f:
-                                f.write(base64.b64decode(encoded))
-                            attachments.append(
-                                {
-                                    "type": "file",
-                                    "path": file_path,
-                                    "display_name": file_name,
-                                }
-                            )
-                            self._emit_debug_log_sync(
-                                f"Image processed: {file_path}",
-                                __event_call__,
-                                debug_enabled=debug_enabled,
-                            )
-                        except Exception as e:
-                            self._emit_debug_log_sync(
-                                f"Image error: {e}",
-                                __event_call__,
-                                debug_enabled=debug_enabled,
-                            )
-        else:
-            text_content = str(content)
-        return text_content, attachments
-
-    # ==================== 内部实现 ====================
-    # _pipe_impl() 包含主请求处理逻辑。
-    # ================================================
-    def _sync_copilot_config(self, reasoning_effort: str, __event_call__=None):
-        """
-        如果设置了 REASONING_EFFORT，则动态更新 ~/.copilot/config.json。
-        这提供了一个回退机制，以防 API 注入被服务器忽略。
-        """
-        if not reasoning_effort:
-            return
-
-        effort = reasoning_effort
-
-        # 检查模型是否支持 xhigh
-        # 目前只有 gpt-5.2-codex 支持 xhigh
-        if effort == "xhigh":
-            # 简单检查，使用默认模型 ID
-            if (
-                "gpt-5.2-codex"
-                not in self._collect_model_ids(
-                    body={},
-                    request_model=self.id,
-                    real_model_id=None,
-                )[0].lower()
-            ):
-                # 如果不支持则回退到 high
-                effort = "high"
+        last = messages[-1].get("content", "")
+        if not isinstance(last, list):
+            return str(last), []
+        text, att = "", []
+        for item in last:
+            if item.get("type") == "text":
+                text += item.get("text", "")
+            elif item.get("type") == "image_url":
+                url = item.get("image_url", {}).get("url", "")
+                if url.startswith("data:image"):
+                    try:
+                        h, e = url.split(",", 1)
+                        ext = h.split(";")[0].split("/")[-1]
+                        path = os.path.join(self.temp_dir, f"img_{len(att)}.{ext}")
+                        with open(path, "wb") as f:
+                            f.write(base64.b64decode(e))
+                        att.append(
+                            {
+                                "type": "file",
+                                "path": path,
+                                "display_name": f"img_{len(att)}",
+                            }
+                        )
+                    except:
+                        pass
+        return text, att
 
+    async def _fetch_byok_models(self) -> List[dict]:
+        if not self.valves.BYOK_BASE_URL:
+            return []
         try:
-            # 目标标准路径 ~/.copilot/config.json
-            config_path = os.path.expanduser("~/.copilot/config.json")
-            config_dir = os.path.dirname(config_path)
+            url, t = (
+                f"{self.valves.BYOK_BASE_URL.rstrip('/')}/models",
+                self.valves.BYOK_TYPE.lower(),
+            )
+            h = {"anthropic-version": "2023-06-01"} if t == "anthropic" else {}
+            if self.valves.BYOK_API_KEY:
+                h["x-api-key" if t == "anthropic" else "Authorization"] = (
+                    self.valves.BYOK_API_KEY
+                    if t == "anthropic"
+                    else f"Bearer {self.valves.BYOK_API_KEY}"
+                )
+            if self.valves.BYOK_BEARER_TOKEN:
+                h["Authorization"] = f"Bearer {self.valves.BYOK_BEARER_TOKEN}"
+            async with aiohttp.ClientSession(
+                timeout=aiohttp.ClientTimeout(total=5)
+            ) as s:
+                async with s.get(url, headers=h) as r:
+                    if r.status == 200:
+                        data = await r.json()
+                        return [
+                            {
+                                "id": m["id"],
+                                "name": f"-{self._clean_model_id(m['id'])}",
+                                "source": "byok",
+                                "provider": self.valves.BYOK_TYPE.capitalize(),
+                            }
+                            for m in data.get("data", [])
+                            if isinstance(m, dict) and "id" in m
+                        ]
+        except:
+            pass
+        return [
+            {
+                "id": m.strip(),
+                "name": f"-{self._clean_model_id(m.strip())}",
+                "source": "byok",
+                "provider": self.valves.BYOK_TYPE.capitalize(),
+            }
+            for m in self.valves.BYOK_MODELS.split(",")
+            if m.strip()
+        ] or [
+            {"id": "gpt-4o", "name": "-gpt-4o", "source": "byok", "provider": "OpenAI"}
+        ]
 
-            # 仅当目录存在时才继续（避免在路径错误时创建垃圾文件）
-            if not os.path.exists(config_dir):
-                return
-
-            data = {}
-            # 读取现有配置
-            if os.path.exists(config_path):
-                try:
-                    with open(config_path, "r") as f:
-                        data = json.load(f)
-                except Exception:
-                    data = {}
-
-            # 如果有变化则更新
-            current_val = data.get("reasoning_effort")
-            if current_val != effort:
-                data["reasoning_effort"] = effort
-                try:
-                    with open(config_path, "w") as f:
-                        json.dump(data, f, indent=4)
-
-                    self._emit_debug_log_sync(
-                        f"已动态更新 ~/.copilot/config.json: reasoning_effort='{effort}'",
-                        __event_call__,
-                    )
-                except Exception as e:
-                    self._emit_debug_log_sync(
-                        f"写入 config.json 失败: {e}", __event_call__
-                    )
-        except Exception as e:
-            self._emit_debug_log_sync(f"配置同步检查失败: {e}", __event_call__)
-
-    async def _update_copilot_cli(
-        self, cli_path, __event_call__=None, debug_enabled: bool = False
+    def _build_session_config(
+        self,
+        cid,
+        rmid,
+        tools,
+        sysp,
+        ist,
+        prov=None,
+        eff="medium",
+        isr=False,
+        cthr=None,
+        bthr=None,
+        ec=None,
+        uid=None,
     ):
-        """如果已配置，则异步检查 Copilot CLI 更新。"""
-        import time
+        from copilot.types import SessionConfig, InfiniteSessionConfig
 
-        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,
+        inf = (
+            InfiniteSessionConfig(
+                enabled=True,
+                background_compaction_threshold=cthr
+                or self.valves.COMPACTION_THRESHOLD,
+                buffer_exhaustion_threshold=bthr or self.valves.BUFFER_THRESHOLD,
             )
-
-            # 我们创建一个子进程来运行更新
-            process = await asyncio.create_subprocess_exec(
-                cli_path,
-                "update",
-                stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.PIPE,
+            if self.valves.INFINITE_SESSION
+            else None
+        )
+        p = {
+            "session_id": cid,
+            "model": rmid,
+            "streaming": ist,
+            "tools": tools,
+            "system_message": {
+                "content": (sysp.strip() + "\n" if sysp else "")
+                + FORMATTING_GUIDELINES
+                + (
+                    f"\n[会话上下文]\n"
+                    f"- **您的隔离工作区**: `{self._get_workspace_dir(uid, cid)}`\n"
+                    f"- **活跃会话 ID**: `{cid}`\n"
+                    "**关键指令**: 所有文件操作必须在这个上述工作区进行。\n"
+                    "- **不要**在 `/tmp` 或其他系统目录创建文件。\n"
+                    "- 始终将“当前目录”理解为您的隔离工作区。"
+                ),
+                "mode": "replace",
+            },
+            "infinite_sessions": inf,
+            "working_directory": self._get_workspace_dir(uid, cid),
+        }
+        if isr and eff:
+            m = next((x for x in self._model_cache if x.get("raw_id") == rmid), None)
+            supp = (
+                m.get("meta", {})
+                .get("capabilities", {})
+                .get("supported_reasoning_efforts", [])
+                if m
+                else []
             )
-
-            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
+            p["reasoning_effort"] = (
+                (eff if eff in supp else ("high" if "high" in supp else "medium"))
+                if supp
+                else eff
             )
+        if self.valves.ENABLE_MCP_SERVER:
+            mcp = self._parse_mcp_servers(ec)
+            if mcp:
+                p["mcp_servers"], p["available_tools"] = mcp, None
+        else:
+            p["available_tools"] = [t.name for t in tools] if tools else None
+        if prov:
+            p["provider"] = prov
+
+        # 注入自动大文件处理钩子
+        wd = p.get("working_directory", "")
+        p["hooks"] = self._build_session_hooks(cwd=wd, __event_call__=ec)
+
+        return SessionConfig(**p)
+
+    def _build_session_hooks(self, cwd: str, __event_call__=None):
+        """
+        构建会话生命周期钩子。
+        当前实现：
+        - on_post_tool_use: 自动将 /tmp 中的大文件复制到工作区
+        """
+
+        async def on_post_tool_use(input_data, invocation):
+            result = input_data.get("result", "")
+
+            # 检测并移动 /tmp 中保存的大文件
+            # 模式: Saved to: /tmp/copilot_result_xxxx.txt
+            import re
+            import shutil
+
+            # 搜索输出中潜在的 /tmp 文件路径
+            # 常见 CLI 模式: "Saved to: /tmp/..." 或仅 "/tmp/..."
+            match = re.search(r"(/tmp/[\w\-\.]+)", str(result))
+            if match:
+                tmp_path = match.group(1)
+                if os.path.exists(tmp_path):
+                    try:
+                        filename = os.path.basename(tmp_path)
+                        target_path = os.path.join(cwd, f"auto_output_{filename}")
+                        shutil.copy2(tmp_path, target_path)
+
+                        self._emit_debug_log_sync(
+                            f"Hook [on_post_tool_use]: 自动将大文件输出从 {tmp_path} 移动到 {target_path}",
+                            __event_call__,
+                        )
+
+                        return {
+                            "additionalContext": (
+                                f"\n[系统自动管理] 输出内容过大，最初保存在 {tmp_path}。\n"
+                                f"我已经自动将其移动到您的工作区，文件名为: `{os.path.basename(target_path)}`。\n"
+                                f"您现在应该对该文件使用 `read_file` 或 `grep` 来访问内容。"
+                            )
+                        }
+                    except Exception as e:
+                        self._emit_debug_log_sync(
+                            f"Hook [on_post_tool_use] 移动文件错误: {e}",
+                            __event_call__,
+                        )
+
+            return {}
+
+        return {
+            "on_post_tool_use": on_post_tool_use,
+        }
 
     async def _pipe_impl(
         self,
-        body: dict,
-        __metadata__: Optional[dict] = None,
-        __user__: Optional[dict] = None,
+        body,
+        __metadata__=None,
+        __user__=None,
         __event_emitter__=None,
         __event_call__=None,
     ) -> Union[str, AsyncGenerator]:
-        # 1. 首先确定有效的调试设置
-        if __user__:
-            raw_valves = __user__.get("valves", {})
-            if isinstance(raw_valves, self.UserValves):
-                user_valves = raw_valves
-            elif isinstance(raw_valves, dict):
-                user_valves = self.UserValves(**raw_valves)
-            else:
-                user_valves = self.UserValves()
-        else:
-            user_valves = self.UserValves()
-
-        effective_debug = self.valves.DEBUG or user_valves.DEBUG
-
-        # 2. 初始化环境
-        self._setup_env(__event_call__, debug_enabled=effective_debug)
-
-        cwd = self._get_workspace_dir()
-        await self._emit_debug_log(
-            f"Agent 工作目录: {cwd}", __event_call__, debug_enabled=effective_debug
-        )
-
-        # 确定有效的 BYOK 设置
-        byok_api_key = user_valves.BYOK_API_KEY or self.valves.BYOK_API_KEY
-        byok_bearer_token = (
-            user_valves.BYOK_BEARER_TOKEN or self.valves.BYOK_BEARER_TOKEN
-        )
-        byok_base_url = user_valves.BYOK_BASE_URL or self.valves.BYOK_BASE_URL
-        byok_active = bool(byok_base_url and (byok_api_key or byok_bearer_token))
-
-        # 检查 GH_TOKEN 或 BYOK 配置
-        gh_token = user_valves.GH_TOKEN or self.valves.GH_TOKEN
-        if not gh_token and not byok_active:
-            return "Error: 请在 Valves 中配置 GH_TOKEN 或 BYOK 设置。"
-
-        # 解析模型
-        request_model = body.get("model", "")
-        real_model_id = request_model
-
-        # 确定推理强度
-        effective_reasoning_effort = (
-            user_valves.REASONING_EFFORT
-            if user_valves.REASONING_EFFORT
-            else self.valves.REASONING_EFFORT
-        )
-
-        # 确定显示思考过程
-        show_thinking = (
-            user_valves.SHOW_THINKING
-            if user_valves.SHOW_THINKING is not None
-            else self.valves.SHOW_THINKING
-        )
-
-        # 1. 确定实际使用的模型 ID
-        resolved_id = request_model
-        model_source_type = "selected"
-
-        if __metadata__ and __metadata__.get("base_model_id"):
-            resolved_id = __metadata__.get("base_model_id", "")
-            model_source_type = "base"
-
-        # 2. 去除前缀 (内联逻辑)
-        real_model_id = resolved_id
-        if "." in real_model_id:
-            real_model_id = real_model_id.split(".", 1)[-1]
-        if real_model_id.startswith(f"{self.id}-"):
-            real_model_id = real_model_id[len(f"{self.id}-") :]
-        if real_model_id.startswith("copilot - "):
-            real_model_id = real_model_id[10:]
-
-        # 3. 记录解析结果
-        if real_model_id != request_model:
-            log_msg = (
-                f"使用 {model_source_type} 模型: {real_model_id} "
-                f"(清洗自 '{resolved_id}')"
+        ud = __user__[0] if isinstance(__user__, (list, tuple)) else (__user__ or {})
+        uid = ud.get("id") or ud.get("user_id") or "default_user"
+        uv = self.UserValves(**(__user__.get("valves", {}) if __user__ else {}))
+        debug = self.valves.DEBUG or uv.DEBUG
+        self._setup_env(__event_call__, debug)
+        byok_active = bool(
+            self.valves.BYOK_BASE_URL
+            and (
+                uv.BYOK_API_KEY
+                or self.valves.BYOK_API_KEY
+                or self.valves.BYOK_BEARER_TOKEN
             )
-            await self._emit_debug_log(
-                log_msg,
-                __event_call__,
-                debug_enabled=effective_debug,
-            )
-
-        messages = body.get("messages", [])
-        if not messages:
-            return "没有消息。"
-
-        # 获取 Chat ID
-        chat_ctx = self._get_chat_context(
-            body, __metadata__, __event_call__, debug_enabled=effective_debug
         )
-        chat_id = chat_ctx.get("chat_id")
-
-        # 提取系统提示词
-        system_prompt_content, system_prompt_source = await self._extract_system_prompt(
+        if not self.valves.GH_TOKEN and not byok_active:
+            return "Error: 配置缺失。"
+        rid = (
+            __metadata__.get("base_model_id")
+            if __metadata__ and __metadata__.get("base_model_id")
+            else body.get("model", "")
+        )
+        rmid = self._clean_model_id(rid)
+        mi = next(
+            (x for x in (self._model_cache or []) if x.get("raw_id") == rmid), None
+        )
+        isr = (
+            mi.get("meta", {}).get("capabilities", {}).get("reasoning", False)
+            if mi
+            else any(k in rmid.lower() for k in ["gpt", "codex"])
+        )
+        isb = (
+            mi.get("source") == "byok"
+            if mi
+            else (
+                not bool(re.search(r"[\(（]\d+(?:\.\d+)?x[\)）]", rid)) and byok_active
+            )
+        )
+        cid = str(
+            (__metadata__ or {}).get("chat_id")
+            or body.get("chat_id")
+            or body.get("metadata", {}).get("chat_id", "")
+        ).strip()
+        sysp, _ = await self._extract_system_prompt(
             body,
-            messages,
-            request_model,
-            real_model_id,
+            body.get("messages", []),
+            body.get("model", ""),
+            rmid,
             __event_call__,
-            debug_enabled=effective_debug,
+            debug,
         )
-
-        if system_prompt_content:
-            preview = system_prompt_content[:60].replace("\n", " ")
-            await self._emit_debug_log(
-                f"系统提示词来源: {system_prompt_source} (长度: {len(system_prompt_content)})",
-                __event_call__,
-                debug_enabled=effective_debug,
-            )
-
-        is_streaming = body.get("stream", False)
-        await self._emit_debug_log(
-            f"流式请求: {is_streaming}",
-            __event_call__,
-            debug_enabled=effective_debug,
+        text, att = self._process_images(
+            body.get("messages", []), __event_call__, debug
         )
-
-        last_text, attachments = self._process_images(
-            messages, __event_call__, debug_enabled=effective_debug
-        )
-
-        # 判断 BYOK 模型逻辑
-        import re
-
-        is_byok_model = False
-        model_display_name = ""
-
-        # 获取模型名称
-        body_metadata = body.get("metadata", {})
-        if not isinstance(body_metadata, dict):
-            body_metadata = {}
-
-        meta_model = body_metadata.get("model", {})
-        if isinstance(meta_model, dict):
-            model_display_name = meta_model.get("name", "")
-
-        if not model_display_name and __metadata__:
-            model_obj = __metadata__.get("model", {})
-            if isinstance(model_obj, dict):
-                model_display_name = model_obj.get("name", "")
-            elif isinstance(model_obj, str):
-                model_display_name = model_obj
-            
-            if not model_display_name:
-                model_display_name = __metadata__.get("model_name", "") or __metadata__.get("name", "")
-
-        if model_display_name:
-            # 这里的正则已更新支持中文括号
-            has_multiplier = bool(re.search(r"[\(（]\d+(?:\.\d+)?x[\)）]", model_display_name))
-            
-            # 逻辑：如果自定义模型名称没有倍率，检查 Base Model 的官方名称
-            if not has_multiplier:
-                # 确保缓存已填充
-                if not self._model_cache:
-                    try:
-                        await self.pipes()
-                    except:
-                        pass
-                
-                # 在缓存中查找 base model 以检查其官方名称
-                cached_model = next(
-                    (m for m in self._model_cache if m.get("raw_id") == real_model_id or m.get("id") == real_model_id or m.get("id") == f"{self.id}-{real_model_id}"), 
-                    None
-                )
-                
-                if cached_model:
-                    cached_name = cached_model.get("name", "")
-                    # 这里的正则也已更新支持中文括号
-                    if re.search(r"[\(（]\d+(?:\.\d+)?x[\)）]", cached_name):
-                        has_multiplier = True
-                        await self._emit_debug_log(
-                            f"修正：在 Base Model 名称 '{cached_name}' 中发现倍率信息 (自定义模型: '{model_display_name}')。视为标准 Copilot 模型。",
-                            __event_call__,
-                            debug_enabled=effective_debug,
-                        )
-
-            is_byok_model = not has_multiplier and byok_active
-            await self._emit_debug_log(
-                f"BYOK 检测 (通过显示名称): '{model_display_name}' -> 有倍率={has_multiplier}, 是BYOK={is_byok_model}",
-                __event_call__,
-                debug_enabled=effective_debug,
-            )
-        else:
-            # 缓存回退逻辑
-            if not self._model_cache:
-                try:
-                    await self.pipes()
-                except:
-                    pass
-
-            base_model_id_from_meta = __metadata__.get("base_model_id", "") if __metadata__ else ""
-            lookup_model_id = base_model_id_from_meta if base_model_id_from_meta else request_model
-
-            model_info = next(
-                (m for m in (self._model_cache or []) if m["id"] == lookup_model_id),
-                None,
-            )
-
-            if model_info:
-                if "source" in model_info:
-                    is_byok_model = model_info["source"] == "byok"
-                else:
-                    model_name = model_info.get("name", "")
-                    has_multiplier = bool(re.search(r"[\(（]\d+(?:\.\d+)?x[\)）]", model_name))
-                    is_byok_model = not has_multiplier and byok_active
-            else:
-                if byok_active:
-                    if not gh_token:
-                        is_byok_model = True
-                    elif real_model_id.startswith("copilot-"):
-                        is_byok_model = False
-                    elif real_model_id not in self._standard_model_ids:
-                        is_byok_model = True
-            
-            await self._emit_debug_log(
-                f"BYOK 检测 (通过启发式): model_id='{real_model_id}', byok_active={byok_active} -> is_byok={is_byok_model}",
-                __event_call__,
-                debug_enabled=effective_debug,
-            )
-
-        # 仅针对标准 Copilot 模型同步配置
-        if not is_byok_model:
-            self._sync_copilot_config(effective_reasoning_effort, __event_call__)
-
-        # 初始化客户端
-        client = CopilotClient(self._build_client_config(body))
-        should_stop_client = True
+        client = CopilotClient(self._build_client_config(body, uid, cid))
         try:
             await client.start()
-
-            custom_tools = await self._initialize_custom_tools(
-                __user__=__user__, __event_call__=__event_call__
+            tools = await self._initialize_custom_tools(__user__, __event_call__, body)
+            prov = (
+                {
+                    "type": (uv.BYOK_TYPE or self.valves.BYOK_TYPE).lower() or "openai",
+                    "wire_api": (uv.BYOK_WIRE_API or self.valves.BYOK_WIRE_API),
+                    "base_url": uv.BYOK_BASE_URL or self.valves.BYOK_BASE_URL,
+                }
+                if isb
+                else None
             )
-            if custom_tools:
-                tool_names = [t.name for t in custom_tools]
-                await self._emit_debug_log(
-                    f"启用 {len(custom_tools)} 个工具 (自定义/内置)",
-                    __event_call__,
-                )
-
-            mcp_servers = self._parse_mcp_servers()
-            mcp_server_names = list(mcp_servers.keys()) if mcp_servers else []
-            if mcp_server_names:
-                await self._emit_debug_log(
-                    f"🔌 MCP 服务器已配置: {mcp_server_names}",
-                    __event_call__,
-                )
-            else:
-                await self._emit_debug_log(
-                    "ℹ️ 未发现 MCP 工具服务器。",
-                    __event_call__,
-                )
-
+            if prov:
+                if uv.BYOK_API_KEY or self.valves.BYOK_API_KEY:
+                    prov["api_key"] = uv.BYOK_API_KEY or self.valves.BYOK_API_KEY
+                if self.valves.BYOK_BEARER_TOKEN:
+                    prov["bearer_token"] = self.valves.BYOK_BEARER_TOKEN
             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:
+            if cid:
                 try:
-                    resume_params = {
-                        "model": real_model_id,
-                        "streaming": is_streaming,
-                        "tools": custom_tools,
-                        "available_tools": ([t.name for t in custom_tools] if custom_tools else None),
+                    rp = {
+                        "model": rmid,
+                        "streaming": body.get("stream", False),
+                        "tools": tools,
+                        "system_message": {
+                            "mode": "replace",
+                            "content": (sysp.strip() + "\n" if sysp else "")
+                            + FORMATTING_GUIDELINES,
+                        },
                     }
-                    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,
+                    if self.valves.ENABLE_MCP_SERVER:
+                        mcp = self._parse_mcp_servers(__event_call__)
+                        if mcp:
+                            rp["mcp_servers"], rp["available_tools"] = mcp, None
+                    else:
+                        rp["available_tools"] = (
+                            [t.name for t in tools] if tools else None
                         )
-
-                    session = await client.resume_session(chat_id, resume_params)
-                    await self._emit_debug_log(
-                        f"成功恢复会话 {chat_id}，模型: {real_model_id}",
+                    if isr:
+                        eff = uv.REASONING_EFFORT or self.valves.REASONING_EFFORT
+                        supp = (
+                            mi.get("meta", {})
+                            .get("capabilities", {})
+                            .get("supported_reasoning_efforts", [])
+                            if mi
+                            else []
+                        )
+                        rp["reasoning_effort"] = (
+                            (
+                                eff
+                                if eff in supp
+                                else ("high" if "high" in supp else "medium")
+                            )
+                            if supp
+                            else eff
+                        )
+                    if prov:
+                        rp["provider"] = prov
+                    session = await client.resume_session(cid, rp)
+                except:
+                    pass
+            if not session:
+                session = await client.create_session(
+                    config=self._build_session_config(
+                        cid,
+                        rmid,
+                        tools,
+                        sysp,
+                        body.get("stream", False),
+                        prov,
+                        uv.REASONING_EFFORT or self.valves.REASONING_EFFORT,
+                        isr,
+                        uv.COMPACTION_THRESHOLD,
+                        uv.BUFFER_THRESHOLD,
                         __event_call__,
+                        uid,
                     )
-                    is_new_session = False
-                except Exception as e:
-                    await self._emit_debug_log(
-                        f"会话 {chat_id} 未找到或恢复失败 ({str(e)})，正在创建新会话。",
-                        __event_call__,
-                    )
-
-            if session is None:
-                is_new_session = True
-                
-                from copilot.types import SessionConfig, InfiniteSessionConfig
-                
-                infinite_session_config = None
-                if self.valves.INFINITE_SESSION:
-                    infinite_session_config = InfiniteSessionConfig(
-                        enabled=True,
-                        background_compaction_threshold=self.valves.COMPACTION_THRESHOLD,
-                        buffer_exhaustion_threshold=self.valves.BUFFER_THRESHOLD,
-                    )
-
-                system_parts = []
-                if system_prompt_content:
-                    system_parts.append(system_prompt_content.strip())
-                system_parts.append(FORMATTING_GUIDELINES)
-                final_system_msg = "\n".join(system_parts)
-
-                session_params = {
-                    "session_id": chat_id if chat_id else None,
-                    "model": real_model_id,
-                    "streaming": is_streaming,
-                    "tools": custom_tools,
-                    "available_tools": [t.name for t in custom_tools] if custom_tools else None,
-                    "system_message": {
-                        "mode": "replace",
-                        "content": final_system_msg,
-                    },
-                    "infinite_sessions": infinite_session_config,
-                    "working_directory": self._get_workspace_dir(),
-                }
-
-                if provider_config:
-                    session_params["provider"] = provider_config
-                
-                if mcp_servers:
-                    session_params["mcp_servers"] = mcp_servers
-
-                session_config = SessionConfig(**session_params)
-
-                await self._emit_debug_log(
-                    f"注入系统提示词到新会话 (长度: {len(final_system_msg)})",
-                    __event_call__,
                 )
-
-                session = await client.create_session(config=session_config)
-
-                model_type_label = "BYOK" if is_byok_model else "Copilot"
-                await self._emit_debug_log(
-                    f"新 {model_type_label} 会话已创建。选择: '{request_model}', 有效 ID: '{real_model_id}'",
-                    __event_call__,
-                    debug_enabled=effective_debug,
-                )
-
-            prompt = last_text
-            await self._emit_debug_log(
-                f"发送提示词 ({len(prompt)} 字符) 给 Agent...",
-                __event_call__,
-            )
-
-            send_payload = {"prompt": prompt, "mode": "immediate"}
-            if attachments:
-                send_payload["attachments"] = attachments
-
             if body.get("stream", False):
-                init_msg = ""
-                if effective_debug:
-                    init_msg = (
-                        f"> [Debug] Agent 工作目录: {self._get_workspace_dir()}\n"
-                    )
-                    if mcp_server_names:
-                        init_msg += f"> [Debug] 🔌 已连接 MCP 服务器: {', '.join(mcp_server_names)}\n"
-
-                should_stop_client = False
                 return self.stream_response(
                     client,
                     session,
-                    send_payload,
-                    init_msg,
+                    {"prompt": text, "mode": "immediate", "attachments": att},
+                    "",
                     __event_call__,
-                    reasoning_effort=effective_reasoning_effort,
-                    show_thinking=show_thinking,
-                    debug_enabled=effective_debug,
+                    uv.REASONING_EFFORT or self.valves.REASONING_EFFORT,
+                    uv.SHOW_THINKING,
+                    debug,
                 )
             else:
-                try:
-                    response = await session.send_and_wait(send_payload)
-                    return response.data.content if response else "无响应。"
-                finally:
-                    if not chat_id:
-                        try:
-                            await session.destroy()
-                        except:
-                            pass
+                r = await session.send_and_wait(
+                    {"prompt": text, "mode": "immediate", "attachments": att}
+                )
+                return r.data.content if r else "空响应。"
         except Exception as e:
-            await self._emit_debug_log(
-                f"请求错误: {e}", __event_call__, debug_enabled=effective_debug
-            )
-            return f"Error: {str(e)}"
+            return f"错误: {e}"
         finally:
-            if should_stop_client:
+            if not body.get("stream"):
+                await client.stop()
+
+    async def pipes(self, __user__: Optional[dict] = None) -> List[dict]:
+        # 清理多余日志，仅在 DEBUG 开启时输出
+        uv = self._get_user_valves(__user__)
+        if uv.DEBUG or self.valves.DEBUG:
+            logger.info(f"[Copilot SDK] 获取模型列表 (用户: {bool(__user__)})")
+
+        token = uv.GH_TOKEN or self.valves.GH_TOKEN
+
+        # 环境防抖检查 (24小时内只检查一次)
+        from datetime import datetime
+
+        now = datetime.now().timestamp()
+        needs_setup = not self.__class__._env_setup_done or (
+            now - self.__class__._last_update_check > 86400
+        )
+
+        if needs_setup:
+            self._setup_env(debug_enabled=uv.DEBUG or self.valves.DEBUG)
+        elif token:
+            os.environ["GH_TOKEN"] = os.environ["GITHUB_TOKEN"] = token
+
+        eff_max = self.valves.MAX_MULTIPLIER
+        if uv.MAX_MULTIPLIER is not None:
+            eff_max = uv.MAX_MULTIPLIER
+
+        ex_kw = [
+            k.strip().lower()
+            for k in (self.valves.EXCLUDE_KEYWORDS + "," + uv.EXCLUDE_KEYWORDS).split(
+                ","
+            )
+            if k.strip()
+        ]
+        allowed_p = [
+            p.strip().lower()
+            for p in (uv.PROVIDERS if uv.PROVIDERS else self.valves.PROVIDERS).split(
+                ","
+            )
+            if p.strip()
+        ]
+        if self._model_cache:
+            res = []
+            for m in self._model_cache:
+                if allowed_p and m.get("provider", "Unknown").lower() not in allowed_p:
+                    continue
+                mid, mname = (m.get("raw_id") or m.get("id", "")).lower(), m.get(
+                    "name", ""
+                ).lower()
+                if any(kw in mid or kw in mname for kw in ex_kw):
+                    continue
+                if m.get("source") == "copilot" and m.get("multiplier", 0) > eff_max:
+                    continue
+                res.append(m)
+            return res
+        try:
+            self._setup_env()
+            byok_models = (
+                await self._fetch_byok_models()
+                if self.valves.BYOK_BASE_URL
+                and (
+                    uv.BYOK_API_KEY
+                    or self.valves.BYOK_API_KEY
+                    or self.valves.BYOK_BEARER_TOKEN
+                )
+                else []
+            )
+            standard_models = []
+            if self.valves.GH_TOKEN:
+                c = CopilotClient({"cli_path": os.environ.get("COPILOT_CLI_PATH")})
                 try:
-                    await client.stop()
+                    await c.start()
+                    auth = await c.get_auth_status()
+                    if getattr(auth, "status", str(auth)) == "authenticated":
+                        raw_models = await c.list_models()
+                        raw = raw_models if isinstance(raw_models, list) else []
+                        processed = []
+                        await self._emit_debug_log(
+                            f"SDK 返回了 {len(raw)} 个原始模型数据。"
+                        )
+                        for m in raw:
+                            try:
+                                m_is_dict = isinstance(m, dict)
+                                mid = (
+                                    m.get("id")
+                                    if m_is_dict
+                                    else getattr(m, "id", str(m))
+                                )
+                                bill = (
+                                    m.get("billing")
+                                    if m_is_dict
+                                    else getattr(m, "billing", None)
+                                )
+                                if bill and not isinstance(bill, dict):
+                                    bill = (
+                                        bill.to_dict()
+                                        if hasattr(bill, "to_dict")
+                                        else vars(bill)
+                                    )
+                                pol = (
+                                    m.get("policy")
+                                    if m_is_dict
+                                    else getattr(m, "policy", None)
+                                )
+                                if pol and not isinstance(pol, dict):
+                                    pol = (
+                                        pol.to_dict()
+                                        if hasattr(pol, "to_dict")
+                                        else vars(pol)
+                                    )
+                                if (pol or {}).get("state") == "disabled":
+                                    continue
+                                cap = (
+                                    m.get("capabilities")
+                                    if m_is_dict
+                                    else getattr(m, "capabilities", None)
+                                )
+                                vis, reas, ctx, supp = False, False, None, []
+                                if cap:
+                                    if not isinstance(cap, dict):
+                                        cap = (
+                                            cap.to_dict()
+                                            if hasattr(cap, "to_dict")
+                                            else vars(cap)
+                                        )
+                                    s = cap.get("supports", {})
+                                    vis, reas = s.get("vision", False), s.get(
+                                        "reasoning_effort", False
+                                    )
+                                    l = cap.get("limits", {})
+                                    ctx = l.get("max_context_window_tokens")
+                                raw_eff = (
+                                    m.get("supported_reasoning_efforts")
+                                    if m_is_dict
+                                    else getattr(m, "supported_reasoning_efforts", [])
+                                ) or []
+                                supp = [str(e).lower() for e in raw_eff if e]
+                                mult = (bill or {}).get("multiplier", 1)
+                                cid = self._clean_model_id(mid)
+                                processed.append(
+                                    {
+                                        "id": f"{self.id}-{mid}",
+                                        "name": (
+                                            f"-{cid} ({mult}x)"
+                                            if mult > 0
+                                            else f"-🔥 {cid} (0x)"
+                                        ),
+                                        "multiplier": mult,
+                                        "raw_id": mid,
+                                        "source": "copilot",
+                                        "provider": self._get_provider_name(m),
+                                        "meta": {
+                                            "capabilities": {
+                                                "vision": vis,
+                                                "reasoning": reas,
+                                                "supported_reasoning_efforts": supp,
+                                            },
+                                            "context_length": ctx,
+                                        },
+                                    }
+                                )
+                            except Exception as pe:
+                                await self._emit_debug_log(f"❌ 解析失败 {mid}: {pe}")
+                        processed.sort(key=lambda x: (x["multiplier"], x["raw_id"]))
+                        standard_models = processed
+                        self._standard_model_ids = {m["raw_id"] for m in processed}
                 except:
                     pass
+                finally:
+                    await c.stop()
+            self._model_cache = standard_models + byok_models
+            if not self._model_cache:
+                return [{"id": "error", "name": "错误：未返回内容。"}]
+            res = []
+            for m in self._model_cache:
+                if allowed_p and m.get("provider", "Unknown").lower() not in allowed_p:
+                    continue
+                mid, mname = (m.get("raw_id") or m.get("id", "")).lower(), m.get(
+                    "name", ""
+                ).lower()
+                if any(kw in mid or kw in mname for kw in ex_kw):
+                    continue
+                if m.get("source") == "copilot" and m.get("multiplier", 0) > eff_max:
+                    continue
+                res.append(m)
+            return res
+        except Exception as e:
+            return [{"id": "error", "name": f"错误: {e}"}]
 
     async def stream_response(
         self,
         client,
         session,
-        send_payload,
-        init_message: str = "",
-        __event_call__=None,
-        reasoning_effort: str = "",
-        show_thinking: bool = True,
-        debug_enabled: bool = False,
+        payload,
+        init_msg,
+        __event_call__,
+        effort="",
+        show_thinking=True,
+        debug=False,
     ) -> AsyncGenerator:
-        """
-        从 Copilot SDK 流式传输响应，处理各种事件类型。
-        遵循官方 SDK 模式进行事件处理和流式传输。
-        """
-        from copilot.generated.session_events import SessionEventType
-
-        queue = asyncio.Queue()
-        done = asyncio.Event()
-        SENTINEL = object()
-        # 使用本地状态来处理并发和跟踪
+        queue, done, sentinel = asyncio.Queue(), asyncio.Event(), object()
         state = {"thinking_started": False, "content_sent": False}
-        has_content = False  # 追踪是否已经输出了内容
-        active_tools = {}  # 映射 tool_call_id 到工具名称
-
-        def get_event_type(event) -> str:
-            """提取事件类型为字符串，处理枚举和字符串类型。"""
-            if hasattr(event, "type"):
-                event_type = event.type
-                # 处理 SessionEventType 枚举
-                if hasattr(event_type, "value"):
-                    return event_type.value
-                return str(event_type)
-            return "unknown"
-
-        def safe_get_data_attr(event, attr: str, default=None):
-            """
-            安全地从 event.data 提取属性。
-            同时处理字典访问和对象属性访问。
-            """
-            if not hasattr(event, "data") or event.data is None:
-                return default
-
-            data = event.data
-
-            # 首先尝试作为字典
-            if isinstance(data, dict):
-                return data.get(attr, default)
-
-            # 尝试作为对象属性
-            return getattr(data, attr, default)
+        has_content = False
 
         def handler(event):
-            """
-            事件处理器，遵循官方 SDK 模式。
-            处理流式增量、推理、工具事件和会话状态。
-            """
-            event_type = get_event_type(event)
+            etype = (
+                event.type.value if hasattr(event.type, "value") else str(event.type)
+            )
 
-            # === 消息增量事件（主要流式内容）===
-            if event_type == "assistant.message_delta":
-                # 官方：Python SDK 使用 event.data.delta_content
-                delta = safe_get_data_attr(
-                    event, "delta_content"
-                ) or safe_get_data_attr(event, "deltaContent")
+            def get_attr(a):
+                if not hasattr(event, "data") or event.data is None:
+                    return None
+                return (
+                    event.data.get(a)
+                    if isinstance(event.data, dict)
+                    else getattr(event.data, a, None)
+                )
+
+            if etype == "assistant.message_delta":
+                delta = (
+                    get_attr("delta_content")
+                    or get_attr("deltaContent")
+                    or get_attr("content")
+                )
                 if delta:
                     state["content_sent"] = True
                     if state["thinking_started"]:
                         queue.put_nowait("\n</think>\n")
                         state["thinking_started"] = False
                     queue.put_nowait(delta)
-
-            # === 完整消息事件（非流式响应） ===
-            elif event_type == "assistant.message":
-                # 处理完整消息（当 SDK 返回完整内容而不是增量时）
-                content = safe_get_data_attr(event, "content") or safe_get_data_attr(
-                    event, "message"
+            elif etype == "assistant.reasoning_delta":
+                delta = (
+                    get_attr("reasoning_text")
+                    or get_attr("reasoningText")
+                    or get_attr("delta_content")
                 )
-                if content:
-                    state["content_sent"] = True
-                    if state["thinking_started"]:
-                        queue.put_nowait("\n</think>\n")
-                        state["thinking_started"] = False
-                    queue.put_nowait(content)
-
-            # === 推理增量事件（思维链流式传输）===
-            elif event_type == "assistant.reasoning_delta":
-                delta = safe_get_data_attr(
-                    event, "delta_content"
-                ) or safe_get_data_attr(event, "deltaContent")
-                if delta:
-                    # 如果内容已经开始，抑制迟到的推理
-                    if state["content_sent"]:
-                        return
-
-                    if not state["thinking_started"] and show_thinking:
+                if delta and not state["content_sent"] and show_thinking:
+                    if not state["thinking_started"]:
                         queue.put_nowait("<think>\n")
                         state["thinking_started"] = True
-                    if state["thinking_started"]:
-                        queue.put_nowait(delta)
-
-            # === 完整推理事件（非流式推理） ===
-            elif event_type == "assistant.reasoning":
-                # 处理完整推理内容
-                reasoning = safe_get_data_attr(event, "content") or safe_get_data_attr(
-                    event, "reasoning"
-                )
-                if reasoning:
-                    # 如果内容已经开始，抑制延迟到达的推理
-                    if state["content_sent"]:
-                        return
-
-                    if not state["thinking_started"] and show_thinking:
-                        queue.put_nowait("<think>\n")
-                        state["thinking_started"] = True
-                    if state["thinking_started"]:
-                        queue.put_nowait(reasoning)
-
-            # === 工具执行事件 ===
-            elif event_type == "tool.execution_start":
-                tool_name = (
-                    safe_get_data_attr(event, "name")
-                    or safe_get_data_attr(event, "tool_name")
-                    or "未知工具"
-                )
-                tool_call_id = safe_get_data_attr(event, "tool_call_id", "")
-
-                # 获取工具参数
-                tool_args = {}
-                try:
-                    args_obj = safe_get_data_attr(event, "arguments")
-                    if isinstance(args_obj, dict):
-                        tool_args = args_obj
-                    elif isinstance(args_obj, str):
-                        tool_args = json.loads(args_obj)
-                except:
-                    pass
-
-                if tool_call_id:
-                    active_tools[tool_call_id] = {
-                        "name": tool_name,
-                        "arguments": tool_args,
+                    queue.put_nowait(delta)
+            elif etype == "assistant.usage":
+                queue.put_nowait(
+                    {
+                        "choices": [{"delta": {}, "finish_reason": "stop", "index": 0}],
+                        "usage": {
+                            "prompt_tokens": get_attr("input_tokens") or 0,
+                            "completion_tokens": get_attr("output_tokens") or 0,
+                            "total_tokens": get_attr("total_tokens") or 0,
+                        },
                     }
-
-                # 在显示工具前关闭思考标签
-                if state["thinking_started"]:
-                    queue.put_nowait("\n</think>\n")
-                    state["thinking_started"] = False
-
-                # 使用改进的格式展示工具调用
-                if tool_args:
-                    tool_args_json = json.dumps(tool_args, indent=2, ensure_ascii=False)
-                    tool_display = f"\n\n<details>\n<summary>🔧 执行工具: {tool_name}</summary>\n\n**参数:**\n\n```json\n{tool_args_json}\n```\n\n</details>\n\n"
-                else:
-                    tool_display = f"\n\n<details>\n<summary>🔧 执行工具: {tool_name}</summary>\n\n*无参数*\n\n</details>\n\n"
-
-                queue.put_nowait(tool_display)
-
-                self._emit_debug_log_sync(f"工具开始: {tool_name}", __event_call__)
-
-            elif event_type == "tool.execution_complete":
-                tool_call_id = safe_get_data_attr(event, "tool_call_id", "")
-                tool_info = active_tools.get(tool_call_id)
-
-                # 处理旧的字符串格式和新的字典格式
-                if isinstance(tool_info, str):
-                    tool_name = tool_info
-                elif isinstance(tool_info, dict):
-                    tool_name = tool_info.get("name", "未知工具")
-                else:
-                    tool_name = "未知工具"
-
-                # 尝试获取结果内容
-                result_content = ""
-                result_type = "success"
-                try:
-                    result_obj = safe_get_data_attr(event, "result")
-                    if hasattr(result_obj, "content"):
-                        result_content = result_obj.content
-                    elif isinstance(result_obj, dict):
-                        result_content = result_obj.get("content", "")
-                        result_type = result_obj.get("result_type", "success")
-                        if not result_content:
-                            # 如果没有 content 字段，尝试序列化整个字典
-                            result_content = json.dumps(
-                                result_obj, indent=2, ensure_ascii=False
-                            )
-                except Exception as e:
-                    self._emit_debug_log_sync(f"提取结果时出错: {e}", __event_call__)
-                    result_type = "failure"
-                    result_content = f"错误: {str(e)}"
-
-                # 使用改进的格式展示工具结果
-                if result_content:
-                    status_icon = "✅" if result_type == "success" else "❌"
-
-                    # 尝试检测内容类型以便更好地格式化
-                    is_json = False
-                    try:
-                        json_obj = (
-                            json.loads(result_content)
-                            if isinstance(result_content, str)
-                            else result_content
-                        )
-                        if isinstance(json_obj, (dict, list)):
-                            result_content = json.dumps(
-                                json_obj, indent=2, ensure_ascii=False
-                            )
-                            is_json = True
-                    except:
-                        pass
-
-                    # 根据内容类型格式化
-                    if is_json:
-                        # JSON 内容：使用代码块和语法高亮
-                        result_display = f"\n<details>\n<summary>{status_icon} 执行结果: {tool_name}</summary>\n\n```json\n{result_content}\n```\n\n</details>\n\n"
-                    else:
-                        # 纯文本：保留格式，不使用代码块
-                        result_display = f"\n<details>\n<summary>{status_icon} 执行结果: {tool_name}</summary>\n\n{result_content}\n\n</details>\n\n"
-
-                    queue.put_nowait(result_display)
-
-            elif event_type == "tool.execution_progress":
-                # 工具执行进度更新（用于长时间运行的工具）
-                tool_call_id = safe_get_data_attr(event, "tool_call_id", "")
-                tool_info = active_tools.get(tool_call_id)
-                tool_name = (
-                    tool_info.get("name", "未知工具")
-                    if isinstance(tool_info, dict)
-                    else "未知工具"
                 )
-
-                progress = safe_get_data_attr(event, "progress", 0)
-                message = safe_get_data_attr(event, "message", "")
-
-                if message:
-                    progress_display = f"\n> 🔄 **{tool_name}**: {message}\n"
-                    queue.put_nowait(progress_display)
-
-                self._emit_debug_log_sync(
-                    f"工具进度: {tool_name} - {progress}%", __event_call__
-                )
-
-            elif event_type == "tool.execution_partial_result":
-                # 流式工具结果（用于增量输出的工具）
-                tool_call_id = safe_get_data_attr(event, "tool_call_id", "")
-                tool_info = active_tools.get(tool_call_id)
-                tool_name = (
-                    tool_info.get("name", "未知工具")
-                    if isinstance(tool_info, dict)
-                    else "未知工具"
-                )
-
-                partial_content = safe_get_data_attr(event, "content", "")
-                if partial_content:
-                    queue.put_nowait(partial_content)
-
-                self._emit_debug_log_sync(f"工具部分结果: {tool_name}", __event_call__)
-
-            # === 使用统计事件 ===
-            elif event_type == "assistant.usage":
-                # 当前助手回合的 token 使用量
-                if self.valves.DEBUG:
-                    input_tokens = safe_get_data_attr(event, "input_tokens", 0)
-                    output_tokens = safe_get_data_attr(event, "output_tokens", 0)
-                    total_tokens = safe_get_data_attr(event, "total_tokens", 0)
-                pass
-
-            elif event_type == "session.usage_info":
-                # 会话累计使用信息
-                pass
-
-            # === 会话状态事件 ===
-            elif event_type == "session.compaction_start":
-                self._emit_debug_log_sync("会话压缩已开始", __event_call__)
-
-            elif event_type == "session.compaction_complete":
-                self._emit_debug_log_sync("会话压缩已完成", __event_call__)
-
-            elif event_type == "session.idle":
-                # 会话处理完成 - 发出完成信号
+            elif etype == "session.idle":
                 done.set()
-                try:
-                    queue.put_nowait(SENTINEL)
-                except:
-                    pass
-
-            elif event_type == "session.error":
-                error_msg = safe_get_data_attr(event, "message", "未知错误")
-                queue.put_nowait(f"\n[错误: {error_msg}]")
+                queue.put_nowait(sentinel)
+            elif etype == "session.error":
+                queue.put_nowait(f"\n[错误: {get_attr('message')}]")
                 done.set()
-                try:
-                    queue.put_nowait(SENTINEL)
-                except:
-                    pass
+                queue.put_nowait(sentinel)
 
         unsubscribe = session.on(handler)
-
-        self._emit_debug_log_sync(f"已订阅事件。正在发送请求...", __event_call__)
-
-        # 使用 asyncio.create_task 防止 session.send 阻塞流读取
-        # 如果 SDK 实现等待完成。
-        send_task = asyncio.create_task(session.send(send_payload))
-        self._emit_debug_log_sync(f"Prompt 已发送 (异步任务已启动)", __event_call__)
-
-        # 安全的初始 yield，带错误处理
+        asyncio.create_task(session.send(payload))
         try:
-            if self.valves.DEBUG:
-                yield "<think>\n"
-                if init_message:
-                    yield init_message
-
-                if reasoning_effort and reasoning_effort != "off":
-                    yield f"> [Debug] 已注入推理强度 (Reasoning Effort): {reasoning_effort.upper()}\n"
-
-                yield "> [Debug] 连接已建立，等待响应...\n"
-                self.thinking_started = True
-        except Exception as e:
-            # 如果初始 yield 失败，记录但继续处理
-            self._emit_debug_log_sync(f"初始 yield 警告: {e}", __event_call__)
-
-        try:
-            while not done.is_set():
+            while not done.is_set() or not queue.empty():
                 try:
                     chunk = await asyncio.wait_for(
                         queue.get(), timeout=float(self.valves.TIMEOUT)
                     )
-                    if chunk is SENTINEL:
+                    if chunk is sentinel:
                         break
                     if chunk:
                         has_content = True
-                        try:
-                            yield chunk
-                        except Exception as yield_error:
-                            # 客户端关闭连接，优雅停止
-                            self._emit_debug_log_sync(
-                                f"Yield 错误（客户端断开连接？）: {yield_error}",
-                                __event_call__,
-                            )
-                            break
+                        yield chunk
                 except asyncio.TimeoutError:
                     if done.is_set():
                         break
-                    if self.thinking_started:
-                        try:
-                            yield f"> [Debug] 等待响应中 (已超过 {self.valves.TIMEOUT} 秒)...\n"
-                        except:
-                            # 如果超时期间 yield 失败，连接已断开
-                            break
                     continue
-
-            while not queue.empty():
-                chunk = queue.get_nowait()
-                if chunk is SENTINEL:
-                    break
-                if chunk:
-                    has_content = True
-                    try:
-                        yield chunk
-                    except:
-                        # 连接关闭，停止 yielding
-                        break
-
-            if self.thinking_started:
-                try:
-                    yield "\n</think>\n"
-                    has_content = True
-                except:
-                    pass  # 连接已关闭
-
-            # 核心修复：如果整个过程没有任何输出，返回一个提示，防止 OpenWebUI 报错
+            if state["thinking_started"]:
+                yield "\n</think>\n"
             if not has_content:
-                try:
-                    yield "⚠️ Copilot 未返回任何内容。请检查模型 ID 是否正确，或尝试在 Valves 中开启 DEBUG 模式查看详细日志。"
-                except:
-                    pass  # 连接已关闭
-
+                yield "⚠️ 未返回内容。"
         except Exception as e:
-            try:
-                yield f"\n[Stream Error: {str(e)}]"
-            except:
-                pass  # 连接已关闭
+            yield f"\n[流错误: {e}]"
         finally:
             unsubscribe()
-            # 销毁会话对象以释放内存，但保留磁盘数据
-            await session.destroy()
+            await client.stop()
+
+    async def _extract_system_prompt(
+        self,
+        body,
+        messages,
+        request_model,
+        real_model_id,
+        __event_call__=None,
+        debug_enabled=False,
+    ):
+        sysp, src = None, ""
+        if body.get("system_prompt"):
+            sysp, src = body.get("system_prompt"), "body_explicit"
+        if not sysp:
+            meta = body.get("metadata", {}).get("model", {}).get("params", {})
+            if meta.get("system"):
+                sysp, src = meta.get("system"), "metadata_params"
+        if not sysp:
+            try:
+                from open_webui.models.models import Models
+
+                for mid in [request_model, real_model_id]:
+                    m_rec = Models.get_model_by_id(mid)
+                    if (
+                        m_rec
+                        and hasattr(m_rec, "params")
+                        and isinstance(m_rec.params, dict)
+                        and m_rec.params.get("system")
+                    ):
+                        sysp, src = m_rec.params.get("system"), f"模型库:{mid}"
+                        break
+            except:
+                pass
+        if not sysp:
+            for msg in messages:
+                if msg.get("role") == "system":
+                    sysp, src = msg.get("content", ""), "消息历史"
+                    break
+        if sysp:
+            await self._emit_debug_log(
+                f"系统提示词来源: {src} ({len(sysp)} 字符)",
+                __event_call__,
+                debug_enabled,
+            )
+        return sysp, src
+
+    def _build_client_config(self, body, user_id=None, chat_id=None):
+        c = {
+            "cli_path": os.environ.get("COPILOT_CLI_PATH"),
+            "cwd": self._get_workspace_dir(user_id, chat_id),
+        }
+        if self.valves.LOG_LEVEL:
+            c["log_level"] = self.valves.LOG_LEVEL
+        if self.valves.CUSTOM_ENV_VARS:
+            try:
+                e = json.loads(self.valves.CUSTOM_ENV_VARS)
+                c.update({"env": e}) if isinstance(e, dict) else None
+            except:
+                pass
+        return c
diff --git a/plugins/pipes/github-copilot-sdk/scripts/sync_to_workspace.py b/plugins/pipes/github-copilot-sdk/scripts/sync_to_workspace.py
new file mode 100644
index 0000000..a4b1a62
--- /dev/null
+++ b/plugins/pipes/github-copilot-sdk/scripts/sync_to_workspace.py
@@ -0,0 +1,103 @@
+import os
+import sys
+import json
+import asyncio
+from typing import List, Dict
+
+# 1. 尝试导入 OpenWebUI 环境
+try:
+    from open_webui.models.models import Models, ModelForm, ModelMeta, ModelParams
+    from open_webui.internal.db import get_session
+except ImportError:
+    print("❌ 错误: 无法导入 OpenWebUI 模块。请确保在 OpenWebUI 环境（如 conda ai）中运行此脚本。")
+    sys.exit(1)
+
+# 2. 导入 Copilot SDK
+try:
+    from copilot import CopilotClient
+except ImportError:
+    print("❌ 错误: 无法导入 copilot SDK。请运行: pip install github-copilot-sdk==0.1.23")
+    sys.exit(1)
+
+async def fetch_real_models() -> List[Dict]:
+    gh_token = os.environ.get("GH_TOKEN")
+    if not gh_token:
+        print("❌ 错误: 未设置 GH_TOKEN 环境变量。")
+        return []
+
+    client = CopilotClient()
+    try:
+        await client.start()
+        raw_models = await client.list_models()
+        processed = []
+        for m in raw_models:
+            m_id = getattr(m, "id", str(m))
+            # 提取倍率
+            billing = getattr(m, "billing", {})
+            if not isinstance(billing, dict): billing = vars(billing)
+            multiplier = billing.get("multiplier", 1)
+            
+            # 提取能力
+            cap = getattr(m, "capabilities", None)
+            vision = False
+            reasoning = False
+            if cap:
+                supports = getattr(cap, "supports", {})
+                if not isinstance(supports, dict): supports = vars(supports)
+                vision = supports.get("vision", False)
+                reasoning = supports.get("reasoning_effort", False)
+
+            processed.append({
+                "id": m_id,
+                "name": f"GitHub Copilot ({m_id})",
+                "vision": vision,
+                "reasoning": reasoning,
+                "multiplier": multiplier
+            })
+        return processed
+    except Exception as e:
+        print(f"❌ 获取模型失败: {e}")
+        return []
+    finally:
+        await client.stop()
+
+async def sync_to_db():
+    models = await fetch_real_models()
+    if not models: return
+
+    print(f"🔄 发现 {len(models)} 个 Copilot 模型，正在同步到工作区...")
+    
+    # 默认管理员 ID
+    admin_user_id = "00000000-0000-0000-0000-000000000000" 
+
+    for m in models:
+        # 对应插件中的 ID 格式
+        full_id = f"copilot-{m['id']}"
+        
+        existing = Models.get_model_by_id(full_id)
+        if existing:
+            print(f"⚠️ 跳过: {full_id} (已存在)")
+            continue
+
+        form_data = ModelForm(
+            id=full_id,
+            base_model_id=None,
+            name=m['name'],
+            meta=ModelMeta(
+                description=f"GitHub Copilot 官方模型。倍率: {m['multiplier']}x。支持推理: {m['reasoning']}。",
+                capabilities={
+                    "vision": m['vision'],
+                    "reasoning": m['reasoning']
+                }
+            ),
+            params=ModelParams()
+        )
+
+        try:
+            if Models.insert_new_model(form_data, admin_user_id):
+                print(f"✅ 成功同步: {m['name']}")
+        except Exception as e:
+            print(f"❌ 同步 {m['id']} 失败: {e}")
+
+if __name__ == "__main__":
+    asyncio.run(sync_to_db())
\ No newline at end of file
diff --git a/plugins/pipes/github-copilot-sdk/scripts/test_sdk.py b/plugins/pipes/github-copilot-sdk/scripts/test_sdk.py
new file mode 100644
index 0000000..bb89856
--- /dev/null
+++ b/plugins/pipes/github-copilot-sdk/scripts/test_sdk.py
@@ -0,0 +1,111 @@
+import asyncio
+import os
+import json
+import time
+from typing import Any
+from datetime import datetime
+from copilot import CopilotClient
+
+# 自定义 JSON 编码器，处理 datetime 等对象
+class SDKEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, datetime):
+            return obj.isoformat()
+        if hasattr(obj, "to_dict"):
+            return obj.to_dict()
+        try:
+            return super().default(obj)
+        except TypeError:
+            return str(obj)
+
+async def run_debug_test(client, model_id, effort, prompt):
+    print(f"\n" + "🔍" * 15)
+    print(f"DEBUGGING: {model_id} | {effort.upper()}")
+    print("🔍" * 15)
+    
+    session_config = {
+        "model": model_id,
+        "reasoning_effort": effort
+    }
+    
+    queue = asyncio.Queue()
+    done = asyncio.Event()
+    SENTINEL = object()
+
+    def handler(event):
+        try:
+            etype = getattr(event, "type", "unknown")
+            if hasattr(etype, "value"): etype = etype.value
+            
+            raw_data = {}
+            # 优先尝试 SDK 自带的 to_dict
+            if hasattr(event, "to_dict"):
+                raw_data = event.to_dict()
+            elif hasattr(event, "data"):
+                data_obj = event.data
+                if isinstance(data_obj, dict):
+                    raw_data = data_obj
+                elif hasattr(data_obj, "to_dict"):
+                    raw_data = data_obj.to_dict()
+                else:
+                    raw_data = {k: v for k, v in vars(data_obj).items() if not k.startswith('_')}
+            else:
+                raw_data = {k: v for k, v in vars(event).items() if not k.startswith('_')}
+            
+            queue.put_nowait((etype, raw_data))
+            
+            if etype in ["session.idle", "session.error"]:
+                done.set()
+                queue.put_nowait(SENTINEL)
+        except Exception as e:
+            print(f"Handler Error: {e}")
+
+    try:
+        session = await client.create_session(config=session_config)
+        unsubscribe = session.on(handler)
+        
+        print(f"Sending prompt...")
+        asyncio.create_task(session.send({"prompt": prompt, "mode": "immediate"}))
+        
+        event_count = 0
+        while True:
+            try:
+                item = await asyncio.wait_for(queue.get(), timeout=180)
+                if item is SENTINEL: break
+                
+                etype, data = item
+                event_count += 1
+                
+                # 打印所有事件，不进行过滤，这样我们可以看到完整的生命周期
+                print(f"\n[#{event_count} EVENT: {etype}]")
+                print(json.dumps(data, indent=2, ensure_ascii=False, cls=SDKEncoder))
+                
+            except asyncio.TimeoutError:
+                print("\n⚠️ Timeout: No events for 180s")
+                break
+
+        unsubscribe()
+        await session.destroy()
+        
+    except Exception as e:
+        print(f"❌ Session Failed: {e}")
+
+async def main():
+    gh_token = os.environ.get("GH_TOKEN")
+    if not gh_token:
+        print("❌ Error: GH_TOKEN not set")
+        return
+
+    client = CopilotClient()
+    await client.start()
+    
+    # 使用一个简单但需要思考的问题
+    prompt = "123 * 456 等于多少？请给出思考过程。"
+    target_model = "gpt-5-mini" 
+    
+    await run_debug_test(client, target_model, "high", prompt)
+    
+    await client.stop()
+
+if __name__ == "__main__":
+    asyncio.run(main())