opencode-copilot-account-switcher 0.2.6 → 0.2.7

package/README.md

@@ -4,43 +4,43 @@
 [![npm downloads](https://img.shields.io/npm/dw/opencode-copilot-account-switcher.svg)](https://www.npmjs.com/package/opencode-copilot-account-switcher)
 [![License: MPL-2.0](https://img.shields.io/badge/License-MPL--2.0-brightgreen.svg)](LICENSE)
 
-[English](#english) | [中文](#中文)
+[中文](#中文) | [English](#english)
 
 ---
 
-<a name="english"></a>
+<a name="中文"></a>
 
-## English
+## 中文
 
-Manage and switch between multiple **GitHub Copilot** accounts in **OpenCode**. This plugin adds account switching, quota checks, an optional **Guided Loop Safety** mode that can keep a single premium request productive for hours with fewer report interruptions before it truly needs user input, and an optional **Copilot Network Retry** switch for retryable network and certificate failures. It **uses the official `github-copilot` provider** and does **not** require model reconfiguration.
+在 **OpenCode** 中管理并切换多个 **GitHub Copilot** 账号。本插件提供**账号切换、配额查询**、默认开启的 **Guided Loop Safety** 模式，以及默认关闭的 **Copilot Network Retry** 开关；前者帮助一次 premium request 更容易连续工作好几个小时、减少真正需要你输入之前的汇报打断，后者用于处理可重试的网络与证书类失败。**完全依赖官方 `github-copilot` provider**，无需修改模型配置。
 
-## What You Get
+## 功能一览
 
-- **Multi-account support** — add multiple Copilot accounts and switch anytime
-- **Quota check** — view remaining quota per account
-- **Auth import** — import Copilot tokens from OpenCode auth storage
-- **Guided Loop Safety** — a stricter Copilot-only question-first policy designed to keep non-blocked work moving, keep one premium request productive for hours, and cut avoidable quota burn by replacing repeated interruption turns with `question`-based waiting
-- **Copilot Network Retry** — optional and off by default; normalizes retryable Copilot network or TLS failures so OpenCode's native retry path can handle them
-- **Zero model config** — no model changes required (official provider only)
+- **多账号管理** — 添加多个 Copilot 账号，随时切换
+- **配额查询** — 查看每个账号的剩余额度
+- **导入认证** — 可从 OpenCode 认证存储导入
+- **Guided Loop Safety** — 默认开启；仅对 Copilot 生效的更严格 question-first 提示词策略，推动非阻塞工作持续执行、让一次 premium request 更容易连续工作好几个小时，并通过减少反复中断来降低无谓配额消耗
+- **Copilot Network Retry** — 默认关闭；把可重试的 Copilot 网络或 TLS 失败归一化成 OpenCode 原生重试链路可识别的形态
+- **无需模型配置** — 使用官方 provider，无需改模型
 
 ---
 
-## Installation
+## 安装
 
 <details open>
-<summary><b>For Humans</b></summary>
+<summary><b>面向人类用户</b></summary>
 
-**Option A: Let an LLM do it**
+**选项 A：让 LLM 帮你安装**
 
-Paste this into any LLM agent (OpenCode, Claude Code, Cursor, etc.):
+把下面这段话丢给任意 LLM（OpenCode / Claude Code / Cursor 等）：
 
 ```
-Install the opencode-copilot-account-switcher plugin by following: https://raw.githubusercontent.com/jiwangyihao/opencode-copilot-account-switcher/master/README.md
+请按以下说明安装 opencode-copilot-account-switcher 插件：https://raw.githubusercontent.com/jiwangyihao/opencode-copilot-account-switcher/master/README.md
 ```
 
-**Option B: Manual setup**
+**选项 B：手动安装**
 
-1. **Add the plugin** to `~/.config/opencode/opencode.json`:
+1. **在配置文件中添加插件** `~/.config/opencode/opencode.json`：
 
    ```json
    {
@@ -49,9 +49,9 @@ Install the opencode-copilot-account-switcher plugin by following: https://raw.g
    }
    ```
 
-2. **Restart OpenCode** (it will auto-download the plugin from npm).
+2. **重启 OpenCode**（会自动从 npm 下载插件）。
 
-3. **Login** to GitHub Copilot:
+3. **登录 GitHub Copilot**：
 
    ```bash
    opencode auth login --provider github-copilot
@@ -60,15 +60,15 @@ Install the opencode-copilot-account-switcher plugin by following: https://raw.g
 </details>
 
 <details>
-<summary><b>For LLM Agents</b></summary>
+<summary><b>面向 LLM 智能体</b></summary>
 
-### Step-by-Step Instructions
+### 步骤指引
 
-1. Edit the OpenCode configuration file at `~/.config/opencode/opencode.json`
+1. 打开 OpenCode 配置文件 `~/.config/opencode/opencode.json`
 
-   > **Note**: This path works on all platforms. On Windows, `~` resolves to your user home directory (e.g., `C:\Users\YourName`).
+   > **说明**：该路径在所有平台通用；Windows 上 `~` 会解析为用户目录（例如 `C:\Users\YourName`）。
 
-2. Add the plugin to the `plugin` array:
+2. 在 `plugin` 数组中添加插件：
 
    ```json
    {
@@ -77,9 +77,9 @@ Install the opencode-copilot-account-switcher plugin by following: https://raw.g
    }
    ```
 
-3. Restart OpenCode so it fetches the plugin automatically from npm.
+3. 重启 OpenCode，使其自动拉取 npm 包。
 
-### Verification
+### 验证
 
 ```bash
 opencode auth login --provider github-copilot
@@ -89,55 +89,55 @@ opencode auth login --provider github-copilot
 
 ---
 
-## Usage
+## 使用方式
 
-Run inside the GitHub Copilot auth flow:
+在 Copilot 认证流程中运行：
 
 ```bash
 opencode auth login --provider github-copilot
 ```
 
-You will see an interactive menu (arrow keys + enter) with actions:
+会出现交互式菜单（方向键 + 回车）：
 
-- **Add account**
-- **Import from auth.json**
-- **Check quotas**
-- **Guided Loop Safety** — prompt-guided question-first reporting that requires `question` for user-facing reports when available, keeps non-blocked work moving, reduces repeated interruptions, and avoids unnecessary subagent calls
-- **Copilot Network Retry** — off by default; only affects the Copilot request `fetch` path and only for retryable network/certificate-style failures
-- **Switch account**
-- **Remove account**
-- **Remove all**
+- **添加账号**
+- **从 auth.json 导入**
+- **检查配额**
+- **Guided Loop Safety 开关** — 通过提示词引导模型在可用时必须使用 `question` 做用户可见汇报、继续完成非阻塞工作、减少反复中断，并避免不必要的子代理调用
+- **Copilot Network Retry 开关** — 默认关闭；仅影响 Copilot 请求的 `fetch` 路径，只处理可重试的网络/证书类失败
+- **切换账号**
+- **删除账号**
+- **全部删除**
 
-If you want GitHub Copilot sessions to stay in a single premium request longer, enable Guided Loop Safety from the account menu. In practice, this can keep one request productive for hours: when `question` is available and permitted, user-facing reports must go through it, so waiting for your reply does not keep burning extra quota the way repeated direct-status interruptions do. Fewer interruptions also means less avoidable quota burn. If safe non-blocked work remains, Copilot should keep going instead of pausing early; only when no safe action remains should it use `question` to ask for the next task or clarification, while also reducing unnecessary subagent calls.
+Guided Loop Safety 现在默认开启。实际使用中，它可以让一次 request 更容易连续工作好几个小时：当 `question` 工具在当前会话中可用且被允许时，用户可见汇报必须通过它完成，因此等待你的回复本身不会像反复插入直接状态消息那样继续额外消耗配额；少一次中断，本身就少一次无谓的配额消耗。只要还有安全的非阻塞工作可做，Copilot 就应继续执行而不是提前暂停；只有在当前确实没有可安全执行的动作时，才应通过 `question` 询问下一项任务或所需澄清，同时也会减少不必要的子代理调用。
 
-If you hit transient Copilot TLS or network failures, you can enable Copilot Network Retry from the same menu. It is off by default. When enabled, the plugin keeps the official Copilot header/baseURL behavior from the upstream loader, only wraps the final Copilot `fetch` path, and converts retryable network-like failures into a shape that OpenCode already treats as retryable. This keeps request retry policy aligned with OpenCode instead of re-implementing a second retry system inside the plugin.
+如果你在切换 Copilot 账号后遇到瞬时 TLS/网络失败，或者遇到由旧 session item ID 残留引起的 `input[*].id too long` 错误，也可以在同一菜单中开启 Copilot Network Retry。它默认关闭。开启后，插件会先保留 upstream 官方 loader 生成的 `baseURL`、认证头和 `fetch` 行为，只在最后一跳 Copilot `fetch` 路径上做最小包装，把可重试的网络类失败归一化成 OpenCode 已有重试链路能识别的形态；对于明确命中的 `input[*].id too long` 400，还会回写命中的 session part，避免旧 item ID 持续污染后续重试。
 
 ## Copilot Network Retry
 
-- Default: **disabled**
-- Scope: only the official Copilot request `fetch` path returned by `auth.loader`
-- Purpose: limited handling for retryable network and certificate-style failures such as `failed to fetch`, `ECONNRESET`, `unknown certificate`, or `self signed certificate`
-- Strategy: preserve official loader behavior, then normalize retryable failures so OpenCode's native retry pipeline can decide whether and when to retry
-- Risk: because the plugin still wraps the official fetch path, upstream internal behavior may change over time and drift is possible
+- 默认：**关闭**
+- 作用范围：仅影响 `auth.loader` 返回的官方 Copilot 请求 `fetch` 路径
+- 用途：有限处理 `failed to fetch`、`ECONNRESET`、`unknown certificate`、`self signed certificate` 等可重试网络/证书类失败
+- 实现策略：尽量保留官方 loader 行为，再把可重试失败归一化给 OpenCode 原生重试链路判断是否重试
+- 风险提示：因为插件仍然包裹了官方 fetch 路径，若 upstream 后续内部实现变化，仍可能产生行为漂移
 
-## Upstream Sync
+## Upstream 同步机制
 
-The repository includes a committed upstream snapshot at `src/upstream/copilot-plugin.snapshot.ts` plus a sync/check script at `scripts/sync-copilot-upstream.mjs`.
+仓库中提交了一份 upstream 快照 `src/upstream/copilot-plugin.snapshot.ts`，并提供同步/校验脚本 `scripts/sync-copilot-upstream.mjs`。
 
-Useful commands:
+常用命令：
 
 ```bash
 npm run sync:copilot-snapshot -- --source <file-or-url> --upstream-commit <sha> --sync-date <YYYY-MM-DD>
 npm run check:copilot-sync -- --source <file-or-url> --upstream-commit <sha> --sync-date <YYYY-MM-DD>
 ```
 
-The script generates or checks the committed snapshot, requires upstream metadata for repository snapshot updates, and helps catch drift from the official `opencode` `copilot.ts` implementation.
+该脚本会生成或校验仓库中提交的 snapshot，并要求在更新正式 snapshot 时显式提供 upstream commit 与同步日期，用来尽早发现与官方 `opencode` `copilot.ts` 的行为漂移。
 
 ---
 
-## Storage
+## 存储位置
 
-Accounts are stored in:
+账号信息保存于：
 
 ```
 ~/.config/opencode/copilot-accounts.json
@@ -145,52 +145,52 @@ Accounts are stored in:
 
 ---
 
-## FAQ
+## 常见问题
 
-**Do I need to change model configurations?**
-No. This plugin only manages accounts and works with the official `github-copilot` provider.
+**需要改模型配置吗？**
+不需要。本插件只做账号管理，继续使用官方 `github-copilot` provider。
 
-**Does it replace the official provider?**
-No. It uses the official provider and only adds account switching + quota checks.
+**会替换官方 provider 吗？**
+不会。它只是在官方 provider 基础上增加账号切换和配额查询。
 
-**Does Copilot Network Retry replace OpenCode's retry logic?**
-No. The plugin keeps retry policy inside OpenCode by normalizing retryable Copilot network/TLS failures into a shape that OpenCode already recognizes as retryable.
+**Copilot Network Retry 会替代 OpenCode 自己的重试逻辑吗？**
+不会。插件的目标是把可重试的 Copilot 网络/TLS 失败归一化成 OpenCode 已识别的可重试错误形态，真正的是否重试与如何退避仍由 OpenCode 原生链路决定。
 
 ---
 
-<a name="中文"></a>
+<a name="english"></a>
 
-## 中文
+## English
 
-在 **OpenCode** 中管理并切换多个 **GitHub Copilot** 账号。本插件提供**账号切换、配额查询**、可选的 **Guided Loop Safety** 模式，以及默认关闭的 **Copilot Network Retry** 开关；前者帮助一次 premium request 更容易连续工作好几个小时、减少真正需要你输入之前的汇报打断，后者用于处理可重试的网络与证书类失败。**完全依赖官方 `github-copilot` provider**，无需修改模型配置。
+Manage and switch between multiple **GitHub Copilot** accounts in **OpenCode**. This plugin adds account switching, quota checks, a default-on **Guided Loop Safety** mode that can keep a single premium request productive for hours with fewer report interruptions before it truly needs user input, and an optional **Copilot Network Retry** switch for retryable network and certificate failures. It **uses the official `github-copilot` provider** and does **not** require model reconfiguration.
 
-## 功能一览
+## What You Get
 
-- **多账号管理** — 添加多个 Copilot 账号，随时切换
-- **配额查询** — 查看每个账号的剩余额度
-- **导入认证** — 可从 OpenCode 认证存储导入
-- **Guided Loop Safety** — 仅对 Copilot 生效的更严格 question-first 提示词策略，推动非阻塞工作持续执行、让一次 premium request 更容易连续工作好几个小时，并通过减少反复中断来降低无谓配额消耗
-- **Copilot Network Retry** — 默认关闭；把可重试的 Copilot 网络或 TLS 失败归一化成 OpenCode 原生重试链路可识别的形态
-- **无需模型配置** — 使用官方 provider，无需改模型
+- **Multi-account support** — add multiple Copilot accounts and switch anytime
+- **Quota check** — view remaining quota per account
+- **Auth import** — import Copilot tokens from OpenCode auth storage
+- **Guided Loop Safety** — enabled by default; a stricter Copilot-only question-first policy designed to keep non-blocked work moving, keep one premium request productive for hours, and cut avoidable quota burn by replacing repeated interruption turns with `question`-based waiting
+- **Copilot Network Retry** — optional and off by default; normalizes retryable Copilot network or TLS failures so OpenCode's native retry path can handle them
+- **Zero model config** — no model changes required (official provider only)
 
 ---
 
-## 安装
+## Installation
 
 <details open>
-<summary><b>面向人类用户</b></summary>
+<summary><b>For Humans</b></summary>
 
-**选项 A：让 LLM 帮你安装**
+**Option A: Let an LLM do it**
 
-把下面这段话丢给任意 LLM（OpenCode / Claude Code / Cursor 等）：
+Paste this into any LLM agent (OpenCode, Claude Code, Cursor, etc.):
 
 ```
-请按以下说明安装 opencode-copilot-account-switcher 插件：https://raw.githubusercontent.com/jiwangyihao/opencode-copilot-account-switcher/master/README.md
+Install the opencode-copilot-account-switcher plugin by following: https://raw.githubusercontent.com/jiwangyihao/opencode-copilot-account-switcher/master/README.md
 ```
 
-**选项 B：手动安装**
+**Option B: Manual setup**
 
-1. **在配置文件中添加插件** `~/.config/opencode/opencode.json`：
+1. **Add the plugin** to `~/.config/opencode/opencode.json`:
 
    ```json
    {
@@ -199,9 +199,9 @@ No. The plugin keeps retry policy inside OpenCode by normalizing retryable Copil
    }
    ```
 
-2. **重启 OpenCode**（会自动从 npm 下载插件）。
+2. **Restart OpenCode** (it will auto-download the plugin from npm).
 
-3. **登录 GitHub Copilot**：
+3. **Login** to GitHub Copilot:
 
    ```bash
    opencode auth login --provider github-copilot
@@ -210,15 +210,15 @@ No. The plugin keeps retry policy inside OpenCode by normalizing retryable Copil
 </details>
 
 <details>
-<summary><b>面向 LLM 智能体</b></summary>
+<summary><b>For LLM Agents</b></summary>
 
-### 步骤指引
+### Step-by-Step Instructions
 
-1. 打开 OpenCode 配置文件 `~/.config/opencode/opencode.json`
+1. Edit the OpenCode configuration file at `~/.config/opencode/opencode.json`
 
-   > **说明**：该路径在所有平台通用；Windows 上 `~` 会解析为用户目录（例如 `C:\Users\YourName`）。
+   > **Note**: This path works on all platforms. On Windows, `~` resolves to your user home directory (e.g., `C:\Users\YourName`).
 
-2. 在 `plugin` 数组中添加插件：
+2. Add the plugin to the `plugin` array:
 
    ```json
    {
@@ -227,9 +227,9 @@ No. The plugin keeps retry policy inside OpenCode by normalizing retryable Copil
    }
    ```
 
-3. 重启 OpenCode，使其自动拉取 npm 包。
+3. Restart OpenCode so it fetches the plugin automatically from npm.
 
-### 验证
+### Verification
 
 ```bash
 opencode auth login --provider github-copilot
@@ -239,55 +239,46 @@ opencode auth login --provider github-copilot
 
 ---
 
-## 使用方式
+## Usage
 
-在 Copilot 认证流程中运行：
+Run inside the GitHub Copilot auth flow:
 
 ```bash
 opencode auth login --provider github-copilot
 ```
 
-会出现交互式菜单（方向键 + 回车）：
-
-- **添加账号**
-- **从 auth.json 导入**
-- **检查配额**
-- **Guided Loop Safety 开关** — 通过提示词引导模型在可用时必须使用 `question` 做用户可见汇报、继续完成非阻塞工作、减少反复中断，并避免不必要的子代理调用
-- **Copilot Network Retry 开关** — 默认关闭；仅影响 Copilot 请求的 `fetch` 路径，只处理可重试的网络/证书类失败
-- **切换账号**
-- **删除账号**
-- **全部删除**
+You will see an interactive menu. Use the built-in language switch action if you want to swap between Chinese and English labels.
 
-如果你希望 GitHub Copilot 会话在一次 premium request 中尽量持续工作、更少被汇报打断，可以在账号菜单中开启 Guided Loop Safety。实际使用中，它可以让一次 request 更容易连续工作好几个小时：当 `question` 工具在当前会话中可用且被允许时，用户可见汇报必须通过它完成，因此等待你的回复本身不会像反复插入直接状态消息那样继续额外消耗配额；少一次中断，本身就少一次无谓的配额消耗。只要还有安全的非阻塞工作可做，Copilot 就应继续执行而不是提前暂停；只有在当前确实没有可安全执行的动作时，才应通过 `question` 询问下一项任务或所需澄清，同时也会减少不必要的子代理调用。
+Guided Loop Safety is enabled by default. In practice, this can keep one request productive for hours: when `question` is available and permitted, user-facing reports must go through it, so waiting for your reply does not keep burning extra quota the way repeated direct-status interruptions do. Fewer interruptions also means less avoidable quota burn. If safe non-blocked work remains, Copilot should keep going instead of pausing early; only when no safe action remains should it use `question` to ask for the next task or clarification, while also reducing unnecessary subagent calls.
 
-如果你遇到 Copilot 的瞬时 TLS 或网络失败，也可以在同一菜单中开启 Copilot Network Retry。它默认关闭。开启后，插件会先保留 upstream 官方 loader 生成的 `baseURL`、认证头和 `fetch` 行为，只在最后一跳 Copilot `fetch` 路径上做最小包装，把可重试的网络类失败归一化成 OpenCode 已有重试链路能识别的形态，而不是在插件内部重新定义一套独立的请求重试策略。
+If you switch Copilot accounts and then hit transient TLS/network failures or `input[*].id too long` errors caused by stale session item IDs, enable Copilot Network Retry from the same menu. It is off by default. When enabled, the plugin keeps the official Copilot header/baseURL behavior from the upstream loader, only wraps the final Copilot `fetch` path, and converts retryable network-like failures into a shape that OpenCode already treats as retryable. It also repairs the matched session part after an `input[*].id too long` 400 so later retries can recover instead of repeatedly failing on stale item IDs.
 
 ## Copilot Network Retry
 
-- 默认：**关闭**
-- 作用范围：仅影响 `auth.loader` 返回的官方 Copilot 请求 `fetch` 路径
-- 用途：有限处理 `failed to fetch`、`ECONNRESET`、`unknown certificate`、`self signed certificate` 等可重试网络/证书类失败
-- 实现策略：尽量保留官方 loader 行为，再把可重试失败归一化给 OpenCode 原生重试链路判断是否重试
-- 风险提示：因为插件仍然包裹了官方 fetch 路径，若 upstream 后续内部实现变化，仍可能产生行为漂移
+- Default: **disabled**
+- Scope: only the official Copilot request `fetch` path returned by `auth.loader`
+- Purpose: limited handling for retryable network and certificate-style failures such as `failed to fetch`, `ECONNRESET`, `unknown certificate`, or `self signed certificate`
+- Strategy: preserve official loader behavior, then normalize retryable failures so OpenCode's native retry pipeline can decide whether and when to retry
+- Risk: because the plugin still wraps the official fetch path, upstream internal behavior may change over time and drift is possible
 
-## Upstream 同步机制
+## Upstream Sync
 
-仓库中提交了一份 upstream 快照 `src/upstream/copilot-plugin.snapshot.ts`，并提供同步/校验脚本 `scripts/sync-copilot-upstream.mjs`。
+The repository includes a committed upstream snapshot at `src/upstream/copilot-plugin.snapshot.ts` plus a sync/check script at `scripts/sync-copilot-upstream.mjs`.
 
-常用命令：
+Useful commands:
 
 ```bash
 npm run sync:copilot-snapshot -- --source <file-or-url> --upstream-commit <sha> --sync-date <YYYY-MM-DD>
 npm run check:copilot-sync -- --source <file-or-url> --upstream-commit <sha> --sync-date <YYYY-MM-DD>
 ```
 
-该脚本会生成或校验仓库中提交的 snapshot，并要求在更新正式 snapshot 时显式提供 upstream commit 与同步日期，用来尽早发现与官方 `opencode` `copilot.ts` 的行为漂移。
+The script generates or checks the committed snapshot, requires upstream metadata for repository snapshot updates, and helps catch drift from the official `opencode` `copilot.ts` implementation.
 
 ---
 
-## 存储位置
+## Storage
 
-账号信息保存于：
+Accounts are stored in:
 
 ```
 ~/.config/opencode/copilot-accounts.json
@@ -295,16 +286,16 @@ npm run check:copilot-sync -- --source <file-or-url> --upstream-commit <sha> --s
 
 ---
 
-## 常见问题
+## FAQ
 
-**需要改模型配置吗？**
-不需要。本插件只做账号管理，继续使用官方 `github-copilot` provider。
+**Do I need to change model configurations?**
+No. This plugin only manages accounts and works with the official `github-copilot` provider.
 
-**会替换官方 provider 吗？**
-不会。它只是在官方 provider 基础上增加账号切换和配额查询。
+**Does it replace the official provider?**
+No. It uses the official provider and only adds account switching + quota checks.
 
-**Copilot Network Retry 会替代 OpenCode 自己的重试逻辑吗？**
-不会。插件的目标是把可重试的 Copilot 网络/TLS 失败归一化成 OpenCode 已识别的可重试错误形态，真正的是否重试与如何退避仍由 OpenCode 原生链路决定。
+**Does Copilot Network Retry replace OpenCode's retry logic?**
+No. The plugin keeps retry policy inside OpenCode by normalizing retryable Copilot network/TLS failures into a shape that OpenCode already recognizes as retryable.
 
 ---
 

package/dist/copilot-network-retry.d.ts

@@ -1,6 +1,41 @@
-type FetchLike = (request: Request | URL | string, init?: RequestInit) => Promise<Response>;
-export declare function isRetryableCopilotFetchError(error: unknown): boolean;
-export declare function createCopilotRetryingFetch(baseFetch: FetchLike, options?: {
+export type FetchLike = (request: Request | URL | string, init?: RequestInit) => Promise<Response>;
+type JsonRecord = Record<string, unknown>;
+export type CopilotRetryContext = {
+    client?: {
+        session?: {
+            messages?: (input: {
+                path: {
+                    id: string;
+                };
+            }) => Promise<{
+                data?: Array<{
+                    info?: {
+                        id?: string;
+                        role?: string;
+                    };
+                    parts?: Array<JsonRecord>;
+                }>;
+            }>;
+            message?: (input: {
+                path: {
+                    id: string;
+                    messageID: string;
+                };
+            }) => Promise<{
+                data?: {
+                    parts?: Array<JsonRecord>;
+                };
+            }>;
+        };
+    };
+    directory?: string;
+    serverUrl?: URL;
     wait?: (ms: number) => Promise<void>;
-}): (request: Request | URL | string, init?: RequestInit) => Promise<Response>;
+    patchPart?: (request: {
+        url: string;
+        init: RequestInit;
+    }) => Promise<unknown>;
+};
+export declare function isRetryableCopilotFetchError(error: unknown): boolean;
+export declare function createCopilotRetryingFetch(baseFetch: FetchLike, options?: CopilotRetryContext): (request: Request | URL | string, init?: RequestInit) => Promise<Response>;
 export {};

package/dist/copilot-network-retry.js

@@ -13,6 +13,8 @@ const RETRYABLE_MESSAGES = [
     "unable to verify the first certificate",
     "self-signed certificate in certificate chain",
 ];
+const MAX_INPUT_ID_REPAIR_ATTEMPTS = 3;
+const INTERNAL_SESSION_HEADER = "x-opencode-session-id";
 const defaultDebugLogFile = (() => {
     const tmp = process.env.TEMP || process.env.TMP || "/tmp";
     return `${tmp}/opencode-copilot-retry-debug.log`;
@@ -47,11 +49,39 @@ function isInputIdTooLongErrorBody(payload) {
         return false;
     const error = payload.error;
     const message = String(error?.message ?? "").toLowerCase();
-    return message.includes("invalid 'input[") && message.includes(".id'") && message.includes("string too long");
+    return message.includes("string too long") && (message.includes("input id") || message.includes(".id'"));
 }
 function isInputIdTooLongMessage(text) {
     const message = text.toLowerCase();
-    return message.includes("invalid 'input[") && message.includes(".id'") && message.includes("string too long");
+    return message.includes("string too long") && (message.includes("input id") || message.includes(".id'"));
+}
+function parseInputIdTooLongDetails(text) {
+    const matched = isInputIdTooLongMessage(text);
+    if (!matched)
+        return { matched };
+    const index = text.match(/input\[(\d+)\]\.id/i);
+    const length = text.match(/got a string with length\s+(\d+)/i) ?? text.match(/length\s+(\d+)/i);
+    return {
+        matched,
+        serverReportedIndex: index ? Number(index[1]) : undefined,
+        reportedLength: length ? Number(length[1]) : undefined,
+    };
+}
+function buildIdPreview(id) {
+    return `${id.slice(0, 12)}...`;
+}
+function getPayloadCandidates(payload) {
+    const input = payload.input;
+    if (!Array.isArray(input))
+        return [];
+    return input.flatMap((item, payloadIndex) => {
+        const id = item?.id;
+        if (typeof id !== "string" || id.length <= 64)
+            return [];
+        const content = item?.content;
+        const itemKind = Array.isArray(content) && typeof content[0]?.type === "string" ? String(content[0].type) : "unknown";
+        return [{ payloadIndex, idLength: id.length, itemKind, idPreview: buildIdPreview(id) }];
+    });
 }
 function hasLongInputIds(payload) {
     const input = payload.input;
@@ -59,22 +89,43 @@ function hasLongInputIds(payload) {
         return false;
     return input.some((item) => typeof item?.id === "string" && (item.id?.length ?? 0) > 64);
 }
-function stripLongInputIds(payload) {
+function getTargetedLongInputId(payload, reportedLength) {
     const input = payload.input;
     if (!Array.isArray(input))
+        return undefined;
+    const matches = input.filter((item) => typeof item?.id === "string" && (item.id?.length ?? 0) > 64);
+    if (matches.length === 0)
+        return undefined;
+    const lengthMatches = reportedLength
+        ? matches.filter((item) => String(item.id ?? "").length === reportedLength)
+        : matches;
+    if (lengthMatches.length === 1)
+        return lengthMatches[0];
+    if (lengthMatches.length > 1)
+        return lengthMatches[0];
+    if (matches.length === 1)
+        return matches[0];
+    return matches.reduce((best, item) => {
+        const bestLength = String(best.id ?? "").length;
+        const itemLength = String(item.id ?? "").length;
+        return itemLength > bestLength ? item : best;
+    }, matches[0]);
+}
+function stripTargetedLongInputId(payload, reportedLength) {
+    const input = payload.input;
+    if (!Array.isArray(input))
+        return payload;
+    const target = getTargetedLongInputId(payload, reportedLength);
+    if (!target)
         return payload;
     let changed = false;
     const nextInput = input.map((item) => {
-        if (!item || typeof item !== "object")
+        if (item !== target)
             return item;
-        const id = item.id;
-        if (typeof id === "string" && id.length > 64) {
-            changed = true;
-            const clone = { ...item };
-            delete clone.id;
-            return clone;
-        }
-        return item;
+        changed = true;
+        const clone = { ...item };
+        delete clone.id;
+        return clone;
     });
     if (!changed)
         return payload;
@@ -98,6 +149,7 @@ function parseJsonBody(init) {
 }
 function buildRetryInit(init, payload) {
     const headers = new Headers(init?.headers);
+    headers.delete(INTERNAL_SESSION_HEADER);
     if (!headers.has("content-type")) {
         headers.set("content-type", "application/json");
     }
@@ -107,13 +159,118 @@ function buildRetryInit(init, payload) {
         body: JSON.stringify(payload),
     };
 }
-async function maybeRetryInputIdTooLong(request, init, response, baseFetch) {
+function stripInternalSessionHeaderFromRequest(request) {
+    if (!(request instanceof Request))
+        return request;
+    if (!request.headers.has(INTERNAL_SESSION_HEADER))
+        return request;
+    const headers = new Headers(request.headers);
+    headers.delete(INTERNAL_SESSION_HEADER);
+    return new Request(request, { headers });
+}
+function getHeader(request, init, name) {
+    const initHeaders = new Headers(init?.headers);
+    const initValue = initHeaders.get(name);
+    if (initValue)
+        return initValue;
+    if (request instanceof Request)
+        return request.headers.get(name) ?? undefined;
+    return undefined;
+}
+function getTargetedInputId(payload, reportedLength) {
+    const target = getTargetedLongInputId(payload, reportedLength);
+    const id = target?.id;
+    if (typeof id !== "string")
+        return undefined;
+    return id;
+}
+function stripOpenAIItemId(part) {
+    const metadata = part.metadata;
+    if (!metadata || typeof metadata !== "object")
+        return part;
+    const openai = metadata.openai;
+    if (!openai || typeof openai !== "object")
+        return part;
+    if (!Object.hasOwn(openai, "itemId"))
+        return part;
+    const nextOpenai = { ...openai };
+    delete nextOpenai.itemId;
+    return {
+        ...part,
+        metadata: {
+            ...metadata,
+            openai: nextOpenai,
+        },
+    };
+}
+async function repairSessionPart(sessionID, failingId, ctx) {
+    const messages = await ctx?.client?.session?.messages?.({
+        path: { id: sessionID },
+    });
+    const matches = (messages?.data ?? []).flatMap((message) => {
+        if (message.info?.role !== "assistant")
+            return [];
+        return (message.parts ?? []).flatMap((part) => {
+            const itemId = part.metadata?.openai?.itemId;
+            if (itemId !== failingId || typeof message.info?.id !== "string" || typeof part.id !== "string")
+                return [];
+            return [{ messageID: message.info.id, partID: part.id, partType: String(part.type ?? "unknown") }];
+        });
+    });
+    debugLog("input-id retry session candidates", {
+        sessionID,
+        count: matches.length,
+        candidates: matches,
+    });
+    if (matches.length !== 1)
+        return false;
+    const match = matches[0];
+    debugLog("input-id retry session match", match);
+    const latest = await ctx?.client?.session?.message?.({
+        path: {
+            id: sessionID,
+            messageID: match.messageID,
+        },
+    });
+    const part = latest?.data?.parts?.find((item) => item.id === match.partID);
+    if (!part)
+        return false;
+    const body = stripOpenAIItemId(part);
+    const url = new URL(`/session/${sessionID}/message/${match.messageID}/part/${match.partID}`, ctx?.serverUrl);
+    if (ctx?.directory)
+        url.searchParams.set("directory", ctx.directory);
+    const init = {
+        method: "PATCH",
+        headers: {
+            "content-type": "application/json",
+        },
+        body: JSON.stringify(body),
+    };
+    if (ctx?.patchPart) {
+        await ctx.patchPart({ url: url.href, init });
+        debugLog("input-id retry session repair", {
+            partID: match.partID,
+            messageID: match.messageID,
+            sessionID,
+        });
+        return true;
+    }
+    const response = await fetch(url, init);
+    debugLog("input-id retry session repair", {
+        partID: match.partID,
+        messageID: match.messageID,
+        sessionID,
+        ok: response.ok,
+    });
+    return response.ok;
+}
+async function maybeRetryInputIdTooLong(request, init, response, baseFetch, ctx, sessionID) {
     if (response.status !== 400)
-        return response;
+        return { response, retried: false, nextInit: init };
     const requestPayload = parseJsonBody(init);
     if (!requestPayload || !hasLongInputIds(requestPayload)) {
         debugLog("skip input-id retry: request has no long ids");
-        return response;
+        return { response, retried: false, nextInit: init };
     }
     debugLog("input-id retry candidate", {
         status: response.status,
@@ -125,13 +282,16 @@ async function maybeRetryInputIdTooLong(request, init, response, baseFetch) {
         .catch(() => "");
     if (!responseText) {
         debugLog("skip input-id retry: empty response body");
-        return response;
+        return { response, retried: false, nextInit: init };
     }
-    let matched = isInputIdTooLongMessage(responseText);
+    let parsed = parseInputIdTooLongDetails(responseText);
+    let matched = parsed.matched;
     if (!matched) {
         try {
             const bodyPayload = JSON.parse(responseText);
-            matched = isInputIdTooLongErrorBody(bodyPayload);
+            const error = bodyPayload.error;
+            parsed = parseInputIdTooLongDetails(String(error?.message ?? ""));
+            matched = parsed.matched || isInputIdTooLongErrorBody(bodyPayload);
         }
         catch {
             matched = false;
@@ -139,25 +299,56 @@ async function maybeRetryInputIdTooLong(request, init, response, baseFetch) {
     }
     debugLog("input-id retry detection", {
         matched,
+        serverReportedIndex: parsed.serverReportedIndex,
+        reportedLength: parsed.reportedLength,
         bodyPreview: responseText.slice(0, 200),
     });
+    debugLog("input-id retry parsed", {
+        serverReportedIndex: parsed.serverReportedIndex,
+        reportedLength: parsed.reportedLength,
+    });
     if (!matched)
-        return response;
-    const sanitized = stripLongInputIds(requestPayload);
+        return { response, retried: false, nextInit: init };
+    if (parsed.serverReportedIndex === undefined) {
+        debugLog("skip input-id retry: missing server input index", {
+            reportedLength: parsed.reportedLength,
+        });
+        return { response, retried: false, nextInit: init };
+    }
+    const payloadCandidates = getPayloadCandidates(requestPayload);
+    debugLog("input-id retry payload candidates", {
+        serverReportedIndex: parsed.serverReportedIndex,
+        candidates: payloadCandidates,
+    });
+    const failingId = getTargetedInputId(requestPayload, parsed.reportedLength);
+    const targetedPayload = payloadCandidates.find((item) => item.idLength === parsed.reportedLength) ?? payloadCandidates[0];
+    if (targetedPayload) {
+        debugLog("input-id retry payload target", {
+            targetedPayloadIndex: targetedPayload.payloadIndex,
+            itemKind: targetedPayload.itemKind,
+            idLength: targetedPayload.idLength,
+            idPreview: targetedPayload.idPreview,
+        });
+    }
+    if (sessionID && failingId) {
+        await repairSessionPart(sessionID, failingId, ctx).catch(() => false);
+    }
+    const sanitized = stripTargetedLongInputId(requestPayload, parsed.reportedLength);
     if (sanitized === requestPayload) {
         debugLog("skip input-id retry: sanitize made no changes");
-        return response;
+        return { response, retried: false, nextInit: init };
     }
     debugLog("input-id retry triggered", {
         removedLongIds: true,
         hadPreviousResponseId: typeof requestPayload.previous_response_id === "string",
     });
-    const retried = await baseFetch(request, buildRetryInit(init, sanitized));
+    const nextInit = buildRetryInit(init, sanitized);
+    const retried = await baseFetch(request, nextInit);
     debugLog("input-id retry response", {
         status: retried.status,
         contentType: retried.headers.get("content-type") ?? undefined,
     });
-    return retried;
+    return { response: retried, retried: true, nextInit };
 }
 function toRetryableSystemError(error) {
     const base = error instanceof Error ? error : new Error(String(error));
@@ -229,19 +420,37 @@ export function isRetryableCopilotFetchError(error) {
 export function createCopilotRetryingFetch(baseFetch, options) {
     void options;
     return async function retryingFetch(request, init) {
+        const sessionID = getHeader(request, init, INTERNAL_SESSION_HEADER);
+        const safeRequest = stripInternalSessionHeaderFromRequest(request);
+        const initHeaders = new Headers(init?.headers);
+        initHeaders.delete(INTERNAL_SESSION_HEADER);
+        const effectiveInit = init
+            ? {
+                ...init,
+                headers: initHeaders,
+            }
+            : undefined;
         debugLog("fetch start", {
-            url: request instanceof Request ? request.url : request instanceof URL ? request.href : String(request),
-            isCopilot: isCopilotUrl(request),
+            url: safeRequest instanceof Request ? safeRequest.url : safeRequest instanceof URL ? safeRequest.href : String(safeRequest),
+            isCopilot: isCopilotUrl(safeRequest),
         });
         try {
-            const response = await baseFetch(request, init);
+            const response = await baseFetch(safeRequest, effectiveInit);
             debugLog("fetch resolved", {
                 status: response.status,
                 contentType: response.headers.get("content-type") ?? undefined,
             });
-            if (isCopilotUrl(request)) {
-                const retried = await maybeRetryInputIdTooLong(request, init, response, baseFetch);
-                return withStreamDebugLogs(retried, request);
+            if (isCopilotUrl(safeRequest)) {
+                let currentResponse = response;
+                let currentInit = effectiveInit;
+                for (let attempt = 0; attempt < MAX_INPUT_ID_REPAIR_ATTEMPTS; attempt += 1) {
+                    const result = await maybeRetryInputIdTooLong(safeRequest, currentInit, currentResponse, baseFetch, options, sessionID);
+                    currentResponse = result.response;
+                    currentInit = result.nextInit;
+                    if (!result.retried)
+                        break;
+                }
+                return withStreamDebugLogs(currentResponse, safeRequest);
             }
             return response;
         }
@@ -250,7 +459,7 @@ export function createCopilotRetryingFetch(baseFetch, options) {
                 message: getErrorMessage(error),
                 retryableByMessage: isRetryableCopilotFetchError(error),
             });
-            if (!isCopilotUrl(request) || !isRetryableCopilotFetchError(error)) {
+            if (!isCopilotUrl(safeRequest) || !isRetryableCopilotFetchError(error)) {
                 throw error;
             }
             throw toRetryableSystemError(error);

package/dist/loop-safety-plugin.d.ts

@@ -1,6 +1,6 @@
 import type { Hooks } from "@opencode-ai/plugin";
 import { type StoreFile } from "./store.js";
-export declare const LOOP_SAFETY_POLICY = "Guided Loop Safety Policy\n- Continue working on any remaining non-blocked task before stopping to report or wait for more instructions.\n- If you are not fully blocked, do not stop just because you feel ready to pause; finish the work that can still be done safely.\n- MANDATORY: When the question tool is available and permitted in the current session, ALL user-facing reports MUST be delivered through the question tool.\n- MANDATORY: Treat progress updates, status reports, summaries, explanations, completion notes, and next-step choices as user-facing reports.\n- MANDATORY: In this workflow, the question tool is both the question channel and the report channel for user-visible communication.\n- MANDATORY: Do not reinterpret \"keep working unless blocked\" as permission to send direct assistant text. If you need to report, report through the question tool.\n- MANDATORY: Do not reinterpret \"don't ask unnecessary questions\" as permission to skip the question tool. Use fewer question batches, not a different reporting channel.\n- MANDATORY: If the user says a report was sent the wrong way, first check whether you used the wrong channel before analyzing verbosity, timing, or wording.\n- MANDATORY: When reflecting on mistakes, check report-channel violations before any secondary critique.\n- MANDATORY: Do not turn a pure report into a preference question, permission question, or route-selection question just to satisfy the question tool requirement.\n- MANDATORY: When no user decision is needed, use the question tool as a report container with the smallest sensible option set.\n- NO EXCEPTIONS: Do not switch to direct assistant text just because the report is long, detailed, complex, or contains multiple related items.\n- The question tool is considered available and permitted when it appears in the active tool list and the current session has not denied its use.\n- Direct assistant text is allowed only when the question tool is unavailable, denied, or absent from the current session.\n- If a report would otherwise be sent as direct text, convert it into one question batch or a short sequence of question batches instead.\n- IMPORTANT: A report-mode violation usually means the wrong tool was used, not that the report was too long.\n- IMPORTANT: Do not reinterpret a tool-usage violation as a verbosity problem.\n- Long reports are allowed. Use pagination or sequential question batches when needed; do not fall back to direct assistant text.\n- A single question tool call may contain multiple well-grouped questions. Prefer that over multiple small interruptions when it keeps the report clear.\n- Group related items into explicit batches such as current progress, key findings, decisions, and next-step choices.\n- Present the highest-priority information first and defer secondary details to later question batches when needed.\n- Even when no explicit decision is required, use brief question-tool status updates instead of direct assistant text whenever the tool is available.\n- Avoid unnecessary question frequency; combine small related updates when a single question call can cover them clearly.\n- When no further action can be taken safely and no non-blocked work remains, use the question tool to ask for the next task or clarification instead of ending with direct assistant text.\n- When the user says \"stop\", do not send assistant text to acknowledge the stop. Use the question tool only if more user-visible communication is still required by policy.\n- Dispatching task or subagent work is expensive and should be avoided unless it materially improves the result.\n- Materially improves the result means clearly beneficial cases such as parallel analysis of independent areas; it does not include routine local searches, small file reads, or straightforward edits.\n- If task or subagent delegation is used, keep the number minimal and explain the reason briefly through the question tool when available.";
+export declare const LOOP_SAFETY_POLICY = "Guided Loop Safety Policy\n- Continue working on any remaining non-blocked task before stopping to report or wait for more instructions.\n- If you are not fully blocked, do not stop just because you feel ready to pause; finish the work that can still be done safely.\n- MANDATORY: When the question tool is available and permitted in the current session, ALL user-facing reports MUST be delivered through the question tool.\n- MANDATORY: Treat progress updates, status reports, summaries, explanations, completion notes, and next-step choices as user-facing reports.\n- MANDATORY: In this workflow, the question tool is both the question channel and the report channel for user-visible communication.\n- MANDATORY: Do not reinterpret \"keep working unless blocked\" as permission to send direct assistant text. If you need to report, report through the question tool.\n- MANDATORY: Do not reinterpret \"don't ask unnecessary questions\" as permission to skip the question tool. Use fewer question batches, not a different reporting channel.\n- MANDATORY: If the user says a report was sent the wrong way, first check whether you used the wrong channel before analyzing verbosity, timing, or wording.\n- MANDATORY: When reflecting on mistakes, check report-channel violations before any secondary critique.\n- MANDATORY: Do not turn a pure report into a preference question, permission question, or route-selection question just to satisfy the question tool requirement.\n- MANDATORY: When no user decision is needed, use the question tool as a report container with the smallest sensible option set.\n- NO EXCEPTIONS: Do not switch to direct assistant text just because the report is long, detailed, complex, or contains multiple related items.\n- The question tool is considered available and permitted when it appears in the active tool list and the current session has not denied its use.\n- Direct assistant text is allowed only when the question tool is unavailable, denied, or absent from the current session.\n- If a report would otherwise be sent as direct text, convert it into one question batch or a short sequence of question batches instead.\n- IMPORTANT: A report-mode violation usually means the wrong tool was used, not that the report was too long.\n- IMPORTANT: Do not reinterpret a tool-usage violation as a verbosity problem.\n- Long reports are allowed. Use pagination or sequential question batches when needed; do not fall back to direct assistant text.\n- A single question tool call may contain multiple well-grouped questions. Prefer that over multiple small interruptions when it keeps the report clear.\n- Group related items into explicit batches such as current progress, key findings, decisions, and next-step choices.\n- Present the highest-priority information first and defer secondary details to later question batches when needed.\n- Even when no explicit decision is required, use brief question-tool status updates instead of direct assistant text whenever the tool is available.\n- Avoid unnecessary question frequency; combine small related updates when a single question call can cover them clearly.\n- MANDATORY: After any successful question-tool report, immediately choose between (a) continue unfinished non-blocked work, or (b) issue a question-tool wait-for-instruction message when no such work remains.\n- MANDATORY: Never send assistant text as a post-report fallback in either branch.\n- MANDATORY: If a post-report branch has no content, suppress assistant output and re-enter question-tool flow.\n- When no further action can be taken safely and no non-blocked work remains, use the question tool to ask for the next task or clarification instead of ending with direct assistant text.\n- When the user says \"stop\", do not send assistant text to acknowledge the stop. Use the question tool only if more user-visible communication is still required by policy.\n- Dispatching task or subagent work is expensive and should be avoided unless it materially improves the result.\n- Materially improves the result means clearly beneficial cases such as parallel analysis of independent areas; it does not include routine local searches, small file reads, or straightforward edits.\n- If task or subagent delegation is used, keep the number minimal and explain the reason briefly through the question tool when available.";
 export type ExperimentalChatSystemTransformHook = (input: {
     sessionID: string;
     model: {

package/dist/loop-safety-plugin.js

@@ -23,6 +23,9 @@ export const LOOP_SAFETY_POLICY = `Guided Loop Safety Policy
 - Present the highest-priority information first and defer secondary details to later question batches when needed.
 - Even when no explicit decision is required, use brief question-tool status updates instead of direct assistant text whenever the tool is available.
 - Avoid unnecessary question frequency; combine small related updates when a single question call can cover them clearly.
+- MANDATORY: After any successful question-tool report, immediately choose between (a) continue unfinished non-blocked work, or (b) issue a question-tool wait-for-instruction message when no such work remains.
+- MANDATORY: Never send assistant text as a post-report fallback in either branch.
+- MANDATORY: If a post-report branch has no content, suppress assistant output and re-enter question-tool flow.
 - When no further action can be taken safely and no non-blocked work remains, use the question tool to ask for the next task or clarification instead of ending with direct assistant text.
 - When the user says "stop", do not send assistant text to acknowledge the stop. Use the question tool only if more user-visible communication is still required by policy.
 - Dispatching task or subagent work is expensive and should be avoided unless it materially improves the result.

package/dist/plugin-hooks.d.ts

@@ -1,7 +1,27 @@
 import { type CopilotPluginHooks } from "./loop-safety-plugin.js";
-import { createCopilotRetryingFetch } from "./copilot-network-retry.js";
+import { type CopilotRetryContext, type FetchLike } from "./copilot-network-retry.js";
 import { type StoreFile } from "./store.js";
 import { type CopilotAuthState, type CopilotProviderConfig, type OfficialCopilotConfig } from "./upstream/copilot-loader-adapter.js";
+type ChatHeadersHook = (input: {
+    sessionID: string;
+    agent: string;
+    model: {
+        providerID: string;
+    };
+    provider: {
+        source: string;
+        info: object;
+        options: object;
+    };
+    message: {
+        id: string;
+    };
+}, output: {
+    headers: Record<string, string>;
+}) => Promise<void>;
+type CopilotPluginHooksWithChatHeaders = CopilotPluginHooks & {
+    "chat.headers"?: ChatHeadersHook;
+};
 export declare function buildPluginHooks(input: {
     auth: NonNullable<CopilotPluginHooks["auth"]>;
     loadStore?: () => Promise<StoreFile | undefined>;
@@ -9,5 +29,9 @@ export declare function buildPluginHooks(input: {
         getAuth: () => Promise<CopilotAuthState | undefined>;
         provider?: CopilotProviderConfig;
     }) => Promise<OfficialCopilotConfig | undefined>;
-    createRetryFetch?: typeof createCopilotRetryingFetch;
-}): CopilotPluginHooks;
+    createRetryFetch?: (fetch: FetchLike, ctx?: CopilotRetryContext) => FetchLike;
+    client?: CopilotRetryContext["client"];
+    directory?: CopilotRetryContext["directory"];
+    serverUrl?: CopilotRetryContext["serverUrl"];
+}): CopilotPluginHooksWithChatHeaders;
+export {};

package/dist/plugin-hooks.js

@@ -1,5 +1,5 @@
-import { createLoopSafetySystemTransform } from "./loop-safety-plugin.js";
-import { createCopilotRetryingFetch } from "./copilot-network-retry.js";
+import { createLoopSafetySystemTransform, isCopilotProvider, } from "./loop-safety-plugin.js";
+import { createCopilotRetryingFetch, } from "./copilot-network-retry.js";
 import { readStoreSafe } from "./store.js";
 import { loadOfficialCopilotConfig, } from "./upstream/copilot-loader-adapter.js";
 export function buildPluginHooks(input) {
@@ -19,15 +19,25 @@ export function buildPluginHooks(input) {
         }
         return {
             ...config,
-            fetch: createRetryFetch(config.fetch),
+            fetch: createRetryFetch(config.fetch, {
+                client: input.client,
+                directory: input.directory,
+                serverUrl: input.serverUrl,
+            }),
         };
     };
+    const chatHeaders = async (hookInput, output) => {
+        if (!isCopilotProvider(hookInput.model.providerID))
+            return;
+        output.headers["x-opencode-session-id"] = hookInput.sessionID;
+    };
     return {
         auth: {
             ...input.auth,
             provider: input.auth.provider ?? "github-copilot",
             loader,
         },
+        "chat.headers": chatHeaders,
         "experimental.chat.system.transform": createLoopSafetySystemTransform(loadStore),
     };
 }

package/dist/plugin.js

@@ -443,7 +443,10 @@ async function switchAccount(client, entry) {
         body: payload,
     });
 }
-export const CopilotAccountSwitcher = async ({ client }) => {
+export const CopilotAccountSwitcher = async (input) => {
+    const client = input.client;
+    const directory = input.directory;
+    const serverUrl = input.serverUrl;
     const methods = [
         {
             type: "oauth",
@@ -700,6 +703,7 @@ export const CopilotAccountSwitcher = async ({ client }) => {
                 store.active = name;
                 store.accounts[name].lastUsed = now();
                 await writeStore(store);
+                console.log("Switched account. If a later Copilot session hits input[*].id too long after switching, enable Copilot Network Retry from the menu.");
                 continue;
             }
         }
@@ -709,5 +713,8 @@ export const CopilotAccountSwitcher = async ({ client }) => {
             provider: "github-copilot",
             methods,
         },
+        client,
+        directory,
+        serverUrl,
     });
 };

package/dist/store.js

@@ -16,8 +16,8 @@ export function parseStore(raw) {
     const data = raw ? JSON.parse(raw) : { accounts: {} };
     if (!data.accounts)
         data.accounts = {};
-    if (data.loopSafetyEnabled !== true)
-        data.loopSafetyEnabled = false;
+    if (data.loopSafetyEnabled !== false)
+        data.loopSafetyEnabled = true;
     if (data.networkRetryEnabled !== true)
         data.networkRetryEnabled = false;
     for (const [name, entry] of Object.entries(data.accounts)) {

package/dist/ui/menu.d.ts

@@ -53,6 +53,8 @@ export type MenuAction = {
     type: "toggle-refresh";
 } | {
     type: "set-interval";
+} | {
+    type: "toggle-language";
 } | {
     type: "toggle-loop-safety";
 } | {
@@ -68,6 +70,31 @@ export type MenuAction = {
 } | {
     type: "cancel";
 };
+export type MenuLanguage = "zh" | "en";
+export declare function getMenuCopy(language?: MenuLanguage): {
+    menuTitle: string;
+    menuSubtitle: string;
+    switchLanguageLabel: string;
+    actionsHeading: string;
+    addAccount: string;
+    addAccountHint: string;
+    importAuth: string;
+    checkQuotas: string;
+    refreshIdentity: string;
+    checkModels: string;
+    enableRefresh: string;
+    disableRefresh: string;
+    setRefresh: string;
+    enableLoopSafety: string;
+    disableLoopSafety: string;
+    loopSafetyHint: string;
+    enableRetry: string;
+    disableRetry: string;
+    retryHint: string;
+    accountsHeading: string;
+    dangerHeading: string;
+    removeAll: string;
+};
 export declare function buildMenuItems(input: {
     accounts: AccountInfo[];
     refresh?: {
@@ -77,9 +104,10 @@ export declare function buildMenuItems(input: {
     lastQuotaRefresh?: number;
     loopSafetyEnabled: boolean;
     networkRetryEnabled: boolean;
+    language?: MenuLanguage;
 }): MenuItem<MenuAction>[];
 export declare function showMenu(accounts: AccountInfo[], refresh?: {
     enabled: boolean;
     minutes: number;
-}, lastQuotaRefresh?: number, loopSafetyEnabled?: boolean, networkRetryEnabled?: boolean): Promise<MenuAction>;
+}, lastQuotaRefresh?: number, loopSafetyEnabled?: boolean, networkRetryEnabled?: boolean, language?: MenuLanguage): Promise<MenuAction>;
 export declare function showAccountActions(account: AccountInfo): Promise<"switch" | "remove" | "back">;

package/dist/ui/menu.js

@@ -1,6 +1,58 @@
 import { ANSI } from "./ansi.js";
 import { select } from "./select.js";
 import { confirm } from "./confirm.js";
+export function getMenuCopy(language = "zh") {
+    if (language === "en") {
+        return {
+            menuTitle: "GitHub Copilot accounts",
+            menuSubtitle: "Select an action or account",
+            switchLanguageLabel: "切换到中文",
+            actionsHeading: "Actions",
+            addAccount: "Add account",
+            addAccountHint: "device login or manual",
+            importAuth: "Import from auth.json",
+            checkQuotas: "Check quotas",
+            refreshIdentity: "Refresh identity",
+            checkModels: "Check models",
+            enableRefresh: "Enable auto refresh",
+            disableRefresh: "Disable auto refresh",
+            setRefresh: "Set refresh interval",
+            enableLoopSafety: "Enable guided loop safety",
+            disableLoopSafety: "Disable guided loop safety",
+            loopSafetyHint: "Prompt-guided: fewer report interruptions, fewer unnecessary subagents",
+            enableRetry: "Enable Copilot network retry",
+            disableRetry: "Disable Copilot network retry",
+            retryHint: "Overrides official fetch path; may drift from upstream",
+            accountsHeading: "Accounts",
+            dangerHeading: "Danger zone",
+            removeAll: "Remove all accounts",
+        };
+    }
+    return {
+        menuTitle: "GitHub Copilot 账号",
+        menuSubtitle: "请选择操作或账号",
+        switchLanguageLabel: "Switch to English",
+        actionsHeading: "操作",
+        addAccount: "添加账号",
+        addAccountHint: "设备登录或手动录入",
+        importAuth: "从 auth.json 导入",
+        checkQuotas: "检查配额",
+        refreshIdentity: "刷新身份信息",
+        checkModels: "检查模型",
+        enableRefresh: "开启自动刷新",
+        disableRefresh: "关闭自动刷新",
+        setRefresh: "设置刷新间隔",
+        enableLoopSafety: "开启 Guided Loop Safety",
+        disableLoopSafety: "关闭 Guided Loop Safety",
+        loopSafetyHint: "提示词引导：减少汇报打断与不必要子代理",
+        enableRetry: "开启 Copilot Network Retry",
+        disableRetry: "关闭 Copilot Network Retry",
+        retryHint: "包装官方 fetch；可能随 upstream 产生漂移",
+        accountsHeading: "账号",
+        dangerHeading: "危险操作",
+        removeAll: "删除全部账号",
+    };
+}
 function formatRelativeTime(timestamp) {
     if (!timestamp)
         return "never";
@@ -26,35 +78,37 @@ function getStatusBadge(status) {
     return "";
 }
 export function buildMenuItems(input) {
+    const copy = getMenuCopy(input.language);
     const quotaHint = input.lastQuotaRefresh ? `last ${formatRelativeTime(input.lastQuotaRefresh)}` : undefined;
     return [
-        { label: "Actions", value: { type: "cancel" }, kind: "heading" },
-        { label: "Add account", value: { type: "add" }, color: "cyan", hint: "device login or manual" },
-        { label: "Import from auth.json", value: { type: "import" }, color: "cyan" },
-        { label: "Check quotas", value: { type: "quota" }, color: "cyan", hint: quotaHint },
-        { label: "Refresh identity", value: { type: "refresh-identity" }, color: "cyan" },
-        { label: "Check models", value: { type: "check-models" }, color: "cyan" },
+        { label: copy.actionsHeading, value: { type: "cancel" }, kind: "heading" },
+        { label: copy.switchLanguageLabel, value: { type: "toggle-language" }, color: "cyan" },
+        { label: copy.addAccount, value: { type: "add" }, color: "cyan", hint: copy.addAccountHint },
+        { label: copy.importAuth, value: { type: "import" }, color: "cyan" },
+        { label: copy.checkQuotas, value: { type: "quota" }, color: "cyan", hint: quotaHint },
+        { label: copy.refreshIdentity, value: { type: "refresh-identity" }, color: "cyan" },
+        { label: copy.checkModels, value: { type: "check-models" }, color: "cyan" },
         {
-            label: input.refresh?.enabled ? "Disable auto refresh" : "Enable auto refresh",
+            label: input.refresh?.enabled ? copy.disableRefresh : copy.enableRefresh,
             value: { type: "toggle-refresh" },
             color: "cyan",
             hint: input.refresh ? `${input.refresh.minutes}m` : undefined,
         },
-        { label: "Set refresh interval", value: { type: "set-interval" }, color: "cyan" },
+        { label: copy.setRefresh, value: { type: "set-interval" }, color: "cyan" },
         {
-            label: input.loopSafetyEnabled ? "Disable guided loop safety" : "Enable guided loop safety",
+            label: input.loopSafetyEnabled ? copy.disableLoopSafety : copy.enableLoopSafety,
             value: { type: "toggle-loop-safety" },
             color: "cyan",
-            hint: "Prompt-guided: fewer report interruptions, fewer unnecessary subagents",
+            hint: copy.loopSafetyHint,
         },
         {
-            label: input.networkRetryEnabled ? "Disable Copilot network retry" : "Enable Copilot network retry",
+            label: input.networkRetryEnabled ? copy.disableRetry : copy.enableRetry,
             value: { type: "toggle-network-retry" },
             color: "cyan",
-            hint: "Overrides official fetch path; may drift from upstream",
+            hint: copy.retryHint,
         },
         { label: "", value: { type: "cancel" }, separator: true },
-        { label: "Accounts", value: { type: "cancel" }, kind: "heading" },
+        { label: copy.accountsHeading, value: { type: "cancel" }, kind: "heading" },
         ...input.accounts.map((account) => {
             const statusBadge = getStatusBadge(account.status);
             const currentBadge = account.isCurrent ? ` ${ANSI.cyan}*${ANSI.reset}` : "";
@@ -78,26 +132,33 @@ export function buildMenuItems(input) {
             };
         }),
         { label: "", value: { type: "cancel" }, separator: true },
-        { label: "Danger zone", value: { type: "cancel" }, kind: "heading" },
-        { label: "Remove all accounts", value: { type: "remove-all" }, color: "red" },
+        { label: copy.dangerHeading, value: { type: "cancel" }, kind: "heading" },
+        { label: copy.removeAll, value: { type: "remove-all" }, color: "red" },
     ];
 }
-export async function showMenu(accounts, refresh, lastQuotaRefresh, loopSafetyEnabled = false, networkRetryEnabled = false) {
-    const items = buildMenuItems({
-        accounts,
-        refresh,
-        lastQuotaRefresh,
-        loopSafetyEnabled,
-        networkRetryEnabled,
-    });
+export async function showMenu(accounts, refresh, lastQuotaRefresh, loopSafetyEnabled = false, networkRetryEnabled = false, language = "zh") {
+    let currentLanguage = language;
     while (true) {
+        const copy = getMenuCopy(currentLanguage);
+        const items = buildMenuItems({
+            accounts,
+            refresh,
+            lastQuotaRefresh,
+            loopSafetyEnabled,
+            networkRetryEnabled,
+            language: currentLanguage,
+        });
         const result = await select(items, {
-            message: "GitHub Copilot accounts",
-            subtitle: "Select an action or account",
+            message: copy.menuTitle,
+            subtitle: copy.menuSubtitle,
             clearScreen: true,
         });
         if (!result)
             return { type: "cancel" };
+        if (result.type === "toggle-language") {
+            currentLanguage = currentLanguage === "zh" ? "en" : "zh";
+            continue;
+        }
         if (result.type === "remove-all") {
             const ok = await confirm("Remove ALL accounts? This cannot be undone.");
             if (!ok)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-copilot-account-switcher",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "description": "GitHub Copilot account switcher plugin for OpenCode",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",