xiaodcs-copilot-api 2.4.1-public.1 → 2.5.1-public.2

package/README.md

@@ -65,7 +65,8 @@ From here, jump to the guide for your client: [Claude Code](#using-with-claude-c
 - **Unified API Gateway**: Serve OpenAI-compatible Chat Completions (`/v1/chat/completions`), the OpenAI Responses API (`/v1/responses`), and Anthropic-compatible Messages (`/v1/messages`) from one local endpoint.
 - **Multi-Provider**: Route GitHub Copilot, the built-in `codex` provider, and third-party providers (Kimi, DeepSeek, DashScope, OpenRouter, OpenCode Go, or a custom provider) behind the same gateway. GitHub Copilot is optional — with at least one enabled provider, the server starts in provider-only mode without a GitHub token.
 - **Coding Agent Ready**: First-class setups for Claude Code, OpenCode, and Codex, including the interactive `--claude-code` launcher and a merged model catalog for Codex.
-- **Streaming & WebSocket**: SSE streaming on all three client-facing protocols. Upstream Copilot Responses traffic selects WebSocket or HTTP from each model's advertised endpoints; streamed Responses traffic for the built-in `codex` provider uses WebSocket by default and uses HTTP when `useResponsesApiWebSocket` is disabled.
+- **Streaming & WebSocket**: SSE streaming on all three client-facing protocols. Upstream Copilot Responses traffic selects WebSocket or HTTP from each model's advertised endpoints. The built-in `codex` provider can independently select WebSocket with `useCodexResponsesApiWebSocket`; when omitted, it inherits `useResponsesApiWebSocket`.
+- **Codex quota logs**: Healthy quota snapshots are debug-only (visible with `--verbose`). Warnings remain visible when a window reaches 90% used, `allowed=false`, or `limit_reached=true`. This changes console verbosity only; quota events, usage recording, and request handling are unchanged.
 - **Desktop App**: Electron GUI with GitHub Copilot sign-in, Codex OAuth, provider configuration, token usage, logs, and one-click start/stop.
 
 ## Compatibility
@@ -431,9 +432,12 @@ npx xiaodcs-copilot-api-edge@latest start
 With options:
 
 ```sh
-npx xiaodcs-copilot-api-edge@latest start --port 8080
+npx xiaodcs-copilot-api-edge@latest auth keys --add your-gateway-api-key
+npx xiaodcs-copilot-api-edge@latest start --host 0.0.0.0 --port 8080
 ```
 
+Binding to `0.0.0.0` exposes the gateway to the network, so the server requires at least one gateway API key and restricts CORS to same-origin requests.
+
 For authentication or provider configuration only:
 
 ```sh
@@ -459,15 +463,17 @@ Run the container with a bind mount so auth data survives restarts:
 
 ```sh
 mkdir -p ./copilot-data
+docker run --rm -v $(pwd)/copilot-data:/root/.local/share/copilot-api copilot-api --auth keys --add your-gateway-api-key
 docker run -p 4141:4141 -v $(pwd)/copilot-data:/root/.local/share/copilot-api copilot-api
 ```
 
 This stores GitHub auth data, provider config, and other gateway state in `./copilot-data` on the host, mapped to `/root/.local/share/copilot-api` in the container.
+The image explicitly listens on `0.0.0.0` so Docker port publishing works and refuses to start until at least one gateway API key is configured. Non-loopback listeners also restrict CORS to the request's own origin.
 
 Or pass a GitHub token directly:
 
 ```sh
-docker run -p 4141:4141 -e GH_TOKEN=your_github_token_here copilot-api
+docker run -p 4141:4141 -v $(pwd)/copilot-data:/root/.local/share/copilot-api -e GH_TOKEN=your_github_token_here copilot-api
 ```
 
 ## Electron Desktop App
@@ -653,6 +659,7 @@ The following command line options are available for the `start` command:
 
 | Option         | Description                                                                   | Default    | Alias |
 | -------------- | ----------------------------------------------------------------------------- | ---------- | ----- |
+| --host         | Host to listen on; non-loopback hosts require a configured gateway API key   | 127.0.0.1 | none  |
 | --port         | Port to listen on                                                             | 4141       | -p    |
 | --verbose      | Enable verbose logging                                                        | false      | -v    |
 | --github-token | Provide GitHub token directly (must be generated using the `auth` subcommand) | none       | -g    |
@@ -674,7 +681,7 @@ Use `copilot-api auth login --provider deepseek`, `--provider dashscope`, `--pro
 
 Use `copilot-api auth login --provider custom` to add or update another third-party provider from the CLI. The command prompts for the provider name, supported type (`anthropic`, `openai-compatible`, or `openai-responses`), `baseUrl`, masked `apiKey`, and `authType`; `authType` may be left as the type default or set to `x-api-key` / `authorization`.
 
-Gateway API keys live under `auth.apiKeys` in `config.json`. Manage them with `copilot-api auth keys` (one operation per invocation): add a key with `--add <key>`, remove one with `--remove <key>`, list all with `--list`, or clear them all with `--clear`. Clients authenticate with any configured key via `x-api-key` or `Authorization: Bearer`. When no keys are configured, `copilot-api start` starts with authentication bypassed and prints a startup info message.
+Gateway API keys live under `auth.apiKeys` in `config.json`. Manage them with `copilot-api auth keys` (one operation per invocation): add a key with `--add <key>`, remove one with `--remove <key>`, list all with `--list`, or clear them all with `--clear`. Clients authenticate with any configured key via `x-api-key` or `Authorization: Bearer`. Without keys, loopback listeners start with authentication bypassed and print an info message; non-loopback listeners refuse to start.
 
 ### Debug Command Options
 
@@ -727,7 +734,7 @@ Gateway API keys live under `auth.apiKeys` in `config.json`. Manage them with `c
     "messageApiWebSearchModel": "gpt-5-mini"
   }
   ```
-- **auth.apiKeys:** API keys used for request authentication on non-admin routes. Supports multiple keys for rotation. Requests can authenticate with either `x-api-key: <key>` or `Authorization: Bearer <key>`. If empty or omitted, authentication for non-admin routes is disabled.
+- **auth.apiKeys:** API keys used for request authentication on non-admin routes. Supports multiple keys for rotation. Requests can authenticate with either `x-api-key: <key>` or `Authorization: Bearer <key>`. If empty or omitted, authentication for non-admin routes is disabled only on loopback listeners; non-loopback listeners refuse to start.
 - **auth.adminApiKey:** Single admin key used only for `/admin/*` routes. If missing, the server generates a random key at startup and writes it back to `config.json`. Requests use the same `x-api-key` or `Authorization: Bearer` headers, but regular `auth.apiKeys` never grant access to `/admin/*`.
 - **modelMappings:** Exact `sourceModel -> targetModel` rewrites shared by top-level `POST /v1/messages`, `POST /v1/messages/count_tokens`, `POST /v1/responses`, and `POST /v1/chat/completions` requests. Omit it or leave it as `{}` to disable rewrites. Both the source and target must be non-empty strings. Targets can be regular model IDs or `provider/model` aliases such as `dashscope/qwen3.6-plus`, and the rewrite happens before provider alias parsing. These mappings are not split per interface. The admin endpoints `GET/POST /admin/config/model-mappings` read and update only this field.
 - **extraPrompts:** Map of `model -> prompt` appended to the first system prompt when translating Anthropic-style requests to Responses API. Use this to inject guardrails or guidance per model. Missing default entries are auto-added without overwriting your custom prompts. For GPT-5.3+ models (e.g. `gpt-5.3-codex`, `gpt-5.4`, `gpt-5.5`), a built-in commentary prompt is used as fallback when not explicitly configured. The built-in prompts enable phase-aware commentary, which lets the model emit a short user-facing progress update before tools or deeper reasoning.
@@ -762,7 +769,19 @@ Gateway API keys live under `auth.apiKeys` in `config.json`. Manage them with `c
   - **Configuration values:** `none`, `minimal`, `low`, `medium`, `high`, `xhigh`, and `max`.
 - **useMessagesApi:** When `true`, models that advertise Copilot's native `/v1/messages` endpoint use the Messages API. If Messages is disabled or unavailable for the selected model, the gateway uses Responses when that model advertises a Responses endpoint, then falls back to Chat Completions when supported. Set this to `false` to skip native Messages routing. Defaults to `true`.
 - **useResponsesApiCompactionRecovery (experimental):** When `true`, successful remote Responses compactions enqueue a non-blocking, low-reasoning shadow-summary request and store only that summary under a hash of the opaque compaction item in the private `~/.local/share/copilot-api/compaction-recovery/cache.sqlite` directory. If Copilot later rejects that compaction or connection-bound history, HTTP requests progressively rebuild the request from cached summaries and visible messages. This option defaults to `false` because shadow summaries add one background model request and recovery is lossy. WebSocket errors are recovered on the client's next retry; automatic same-request recovery is HTTP-only.
-- **useResponsesApiWebSocket:** When `true`, Copilot Responses requests use WebSocket for models that advertise `ws:/responses`; models that advertise only `/responses` use HTTP. Streamed Responses requests for the built-in `codex` provider use WebSocket whenever this setting is enabled, while non-streaming Codex requests always use HTTP. Set this to `false` to make Copilot use HTTP `/responses` where the selected model advertises it and to send streamed Codex Responses requests over HTTP. WebSocket failures are not retried automatically over HTTP. Defaults to `true`. If a proxy, VPN, or network blocks or destabilizes WebSocket traffic, disable this setting or switch networks.
+- **useResponsesApiWebSocket:** Controls upstream Copilot Responses WebSocket use for models that advertise `ws:/responses`; HTTP is used where the model advertises `/responses` and WebSocket is disabled or unavailable in its endpoint metadata. Defaults to `true`. Also supplies the legacy default for `codex` when its independent override is omitted. Copilot WebSocket failures are not retried automatically over HTTP.
+- **useCodexResponsesApiWebSocket (optional):** Overrides WebSocket use only for streamed Responses requests to the built-in `codex` (ChatGPT OAuth) provider, including requests translated from Messages. A boolean `false` forces HTTP and `true` selects WebSocket; omission inherits `useResponsesApiWebSocket` for backward compatibility. Non-streaming requests remain HTTP. A Codex WebSocket connection failure **before any send attempt** falls back to HTTP once, unless cancelled or carrying `previous_response_id`/`conversation` state. After send is attempted, no automatic replay occurs—even before the first event—because the upstream may already be executing the request. HTTP fallback failure is surfaced normally. This does not add a client-facing WebSocket endpoint, guarantee uninterrupted streams, or change third-party providers.
+
+To enable WebSocket only between the gateway and ChatGPT while keeping Copilot on HTTP:
+
+```json
+{
+  "useResponsesApiWebSocket": false,
+  "useCodexResponsesApiWebSocket": true
+}
+```
+
+Merge these keys into the intended API Home's existing `config.json`; do not replace the entire file. These are gateway-to-upstream settings. Keep the Codex client's gateway provider at `supports_websockets = false`, since client-facing Responses traffic still uses HTTP/SSE. Configuration is cached; restart the intended gateway instance after changing the file. To disable the Codex override explicitly, set it to `false`; to restore legacy inheritance, remove that key.
 - **useCopilotFastTier:** Controls whether a client request with `service_tier: "fast"` or `"priority"` may route to a paired Copilot `*-fast` model. Defaults to `true`. Set it to `false` to force the standard model even when a Codex task retains a hidden Fast speed-tier selection. When enabled, an explicit upstream Fast 429 falls back once to the paired standard model and temporarily cools Fast routing according to `Retry-After` (30 seconds by default, capped at 5 minutes).
 - **responsesTransport:** Positive integer lifecycle and buffering limits for every upstream Responses transport. Invalid, zero, or negative values fall back to the defaults shown above. `headersTimeoutMsV2` covers connection setup through receipt of HTTP response headers; it is not a total generation deadline. `streamInactivityTimeoutMs` is reset by every HTTP body chunk or WebSocket message, allowing long generations to continue while they remain active. `websocketOpenTimeoutMs` limits the WebSocket handshake, while `websocketPoolIdleTimeoutMs` controls only completed, reusable pooled sockets. The byte and message limits bound queued WebSocket events; exceeding either limit fails that stream and invalidates its socket rather than dropping or reordering events.
 - **useResponsesApiWebSearch:** When `true`, the server keeps Responses API tools with `type: "web_search"` and forwards them upstream. Set to `false` to strip those tools from `/responses` payloads. Defaults to `true`.
@@ -777,7 +796,7 @@ Edit this file to customize prompts or swap in your own fast model. Restart the
 
 ## API Authentication
 
-- **Protected non-admin routes:** All routes except `/`, `/usage-viewer`, and `/usage-viewer/` require authentication when `auth.apiKeys` is configured and non-empty.
+- **Protected non-admin routes:** All routes except `/`, `/usage-viewer`, and `/usage-viewer/` require authentication when `auth.apiKeys` is configured and non-empty. Non-loopback listeners require a non-empty `auth.apiKeys` configuration at startup and continue failing closed if the keys are later cleared.
 - **Admin routes:** All `/admin/*` routes require `auth.adminApiKey`. If it is missing, the server generates one at startup and persists it to `config.json` before serving requests.
 - **Allowed auth headers:**
   - `x-api-key: <your_key>`
@@ -809,7 +828,7 @@ These endpoints mimic the OpenAI API structure.
 
 | Endpoint                    | Method | Description                                                      |
 | --------------------------- | ------ | ---------------------------------------------------------------- |
-| `POST /v1/responses`        | `POST` | OpenAI Most advanced interface for generating model responses. Supports `provider/model` aliases for `openai-responses` providers. |
+| `POST /v1/responses`        | `POST` | OpenAI Most advanced interface for generating model responses. Supports `Content-Encoding: zstd` request bodies and `provider/model` aliases for `openai-responses` providers. Zstd request decompression is limited to Responses routes, including provider-scoped aliases. |
 | `POST /v1/chat/completions` | `POST` | Creates a model response for the given chat conversation. Supports `provider/model` aliases for `openai-compatible` providers and can be used without Copilot when the target provider is configured. |
 | `GET /v1/models`            | `GET`  | Lists Copilot models plus enabled provider models using `provider/model-id` IDs. Requests from Codex clients (`User-Agent` beginning with `codex`) are forwarded to the Codex Models upstream. |
 | `POST /v1/embeddings`       | `POST` | Creates an embedding vector representing the input text.         |
@@ -861,7 +880,8 @@ Common `npx` commands:
 npx xiaodcs-copilot-api-edge@latest start
 
 # Start on a custom port with verbose logging
-npx xiaodcs-copilot-api-edge@latest start --port 8080 --verbose
+npx xiaodcs-copilot-api-edge@latest auth keys --add your-gateway-api-key
+npx xiaodcs-copilot-api-edge@latest start --host 0.0.0.0 --port 8080 --verbose
 
 # Run the auth flow
 npx xiaodcs-copilot-api-edge@latest auth login
@@ -899,3 +919,7 @@ Same reminders as `CLAUDE_PLUGIN_ENABLE_QUESTION_RULES=1` in the `agent-inject`
 - Prohibited from directly asking questions to users, MUST use question tool.
 - Once you can confirm that the task is complete, MUST use question tool to make user confirm. The user may respond with feedback if they are not satisfied with the result, which you can use to make improvements and try again, after try again, MUST use question tool to make user confirm again.
 ```
+
+## Builtin Qoder SDK provider
+
+Run `copilot-api auth login --provider qoder` (Edge: `copilot-api-edge`), enter your Qoder PAT, then start the gateway normally. Credentials use the existing protected `config.json`; no separate sidecar or bridge key is needed. Supports text/image Chat Completions, SSE, model discovery and Credits. See [setup and capability limits](qoder-bridge/README.md). This integration is included in source and awaits npm release.

package/README.zh-CN.md

@@ -68,7 +68,8 @@ curl http://localhost:4141/v1/models
 - **统一 API 网关**：在同一个本地端点上提供 OpenAI 兼容的 Chat Completions（`/v1/chat/completions`）、OpenAI Responses API（`/v1/responses`）和 Anthropic 兼容的 Messages（`/v1/messages`）。
 - **多 Provider 接入**：在同一个网关后面统一路由 GitHub Copilot、内置 `codex` provider 和第三方 provider（Kimi、DeepSeek、DashScope、OpenRouter、OpenCode Go 或自定义 provider）。GitHub Copilot 是可选能力——只要至少有一个启用中的 provider，无需 GitHub token 也能按 provider-only 模式启动。
 - **为 Coding Agent 而生**：为 Claude Code、OpenCode 和 Codex 提供完整的配置指南，包括交互式 `--claude-code` 启动器和面向 Codex 的合并模型目录。
-- **Streaming 与 WebSocket**：三种面向客户端的协议都支持 SSE 流式输出。上游 Copilot Responses 流量会根据每个模型声明的端点选择 WebSocket 或 HTTP；内置 `codex` provider 的流式 Responses 请求默认走 WebSocket，关闭 `useResponsesApiWebSocket` 后改走 HTTP。
+- **Streaming 与 WebSocket**：三种面向客户端的协议都支持 SSE 流式输出。上游 Copilot Responses 流量根据模型声明的端点选择 WebSocket 或 HTTP；内置 `codex` provider 可用 `useCodexResponsesApiWebSocket` 独立选择传输，未设置时继承 `useResponsesApiWebSocket`。
+- **Codex 额度日志**：正常额度快照仅在 debug / `--verbose` 模式显示；窗口已用额度达到 90%、`allowed=false` 或 `limit_reached=true` 时保留警告。只降低控制台噪声，不改变额度事件转发、用量记录或请求处理。
 - **桌面应用**：Electron 图形界面，支持 GitHub Copilot 登录、Codex OAuth、provider 配置、token 用量、日志查看和一键启动 / 停止。
 
 <a id="compatibility"></a>
@@ -457,9 +458,12 @@ npx xiaodcs-copilot-api-edge@latest start
 带参数示例：
 
 ```sh
-npx xiaodcs-copilot-api-edge@latest start --port 8080
+npx xiaodcs-copilot-api-edge@latest auth keys --add your-gateway-api-key
+npx xiaodcs-copilot-api-edge@latest start --host 0.0.0.0 --port 8080
 ```
 
+绑定到 `0.0.0.0` 会将网关暴露到网络，因此服务要求至少配置一个网关 API Key，并将 CORS 限制为同源请求。
+
 如果只想做认证或 provider 配置：
 
 ```sh
@@ -487,15 +491,17 @@ docker build -t copilot-api .
 
 ```sh
 mkdir -p ./copilot-data
+docker run --rm -v $(pwd)/copilot-data:/root/.local/share/copilot-api copilot-api --auth keys --add your-gateway-api-key
 docker run -p 4141:4141 -v $(pwd)/copilot-data:/root/.local/share/copilot-api copilot-api
 ```
 
 这会把宿主机上的 `./copilot-data` 映射到容器内的 `/root/.local/share/copilot-api`，用于持久化 GitHub 认证数据、provider 配置和其他 gateway 状态。
+镜像会显式监听 `0.0.0.0` 以支持 Docker 端口映射，并在未配置网关 API Key 时拒绝启动。非回环监听还会将 CORS 限制为请求自身的同源地址。
 
 也可以直接通过环境变量传入 GitHub token：
 
 ```sh
-docker run -p 4141:4141 -e GH_TOKEN=your_github_token_here copilot-api
+docker run -p 4141:4141 -v $(pwd)/copilot-data:/root/.local/share/copilot-api -e GH_TOKEN=your_github_token_here copilot-api
 ```
 
 <a id="electron-desktop-app"></a>
@@ -693,6 +699,7 @@ Copilot API 现在使用子命令结构，主要命令包括：
 
 | 选项 | 说明 | 默认值 | 别名 |
 | --- | --- | --- | --- |
+| --host | 监听主机；非回环地址要求已配置网关 API Key | 127.0.0.1 | 无 |
 | --port | 监听端口 | 4141 | -p |
 | --verbose | 启用详细日志 | false | -v |
 | --github-token | 直接提供 GitHub token（必须通过 `auth` 子命令生成） | 无 | -g |
@@ -714,7 +721,7 @@ Copilot API 现在使用子命令结构，主要命令包括：
 
 使用 `copilot-api auth login --provider custom` 可以通过 CLI 新增或更新其他第三方 provider。命令会依次提示输入 provider name、项目支持的 type（`anthropic`、`openai-compatible` 或 `openai-responses`）、`baseUrl`、掩码显示的 `apiKey` 和 `authType`；`authType` 可保持 type 默认值，也可选择 `x-api-key` / `authorization`。
 
-网关 API Key 存放在 `config.json` 的 `auth.apiKeys` 中，可通过 `copilot-api auth keys` 管理（每次只执行一种操作）：`--add <key>` 添加、`--remove <key>` 删除、`--list` 列出全部、`--clear` 清空。客户端通过 `x-api-key` 或 `Authorization: Bearer` 使用任意已配置的 Key 认证。未配置任何 Key 时，`copilot-api start` 会以“不校验认证”的方式启动并输出一条 info 级别的启动提示。
+网关 API Key 存放在 `config.json` 的 `auth.apiKeys` 中，可通过 `copilot-api auth keys` 管理（每次只执行一种操作）：`--add <key>` 添加、`--remove <key>` 删除、`--list` 列出全部、`--clear` 清空。客户端通过 `x-api-key` 或 `Authorization: Bearer` 使用任意已配置的 Key 认证。未配置任何 Key 时，回环监听会以“不校验认证”的方式启动并输出一条 info 级别提示；非回环监听则拒绝启动。
 
 ### Debug 命令选项
 
@@ -769,7 +776,7 @@ Copilot API 现在使用子命令结构，主要命令包括：
     "messageApiWebSearchModel": "gpt-5-mini"
   }
   ```
-- **auth.apiKeys：** 用于普通非 admin 路由的 API key。支持多个 key 轮换使用。请求可通过 `x-api-key: <key>` 或 `Authorization: Bearer <key>` 进行认证。若为空或省略，则普通路由的认证会被禁用。
+- **auth.apiKeys：** 用于普通非 admin 路由的 API key。支持多个 key 轮换使用。请求可通过 `x-api-key: <key>` 或 `Authorization: Bearer <key>` 进行认证。若为空或省略，仅回环监听会禁用普通路由认证；非回环监听会拒绝启动。
 - **auth.adminApiKey：** 仅用于 `/admin/*` 路由的单个 admin key。若未配置，服务会在启动时自动生成一个随机 key，并回写到 `config.json`。它同样使用 `x-api-key` 或 `Authorization: Bearer` 这两种头，但普通 `auth.apiKeys` 不能访问 `/admin/*`。
 - **modelMappings：** 用于顶层 `POST /v1/messages`、`POST /v1/messages/count_tokens`、`POST /v1/responses` 和 `POST /v1/chat/completions` 请求的精确 `sourceModel -> targetModel` 重写映射，这几类接口共用同一份规则。省略该字段或保留为 `{}` 时，不会做模型重写。`source` 和 `target` 都必须是非空字符串。`target` 可以是普通模型 ID，也可以是 `provider/model` 形式的别名，例如 `dashscope/qwen3.6-plus`；重写发生在 provider alias 解析之前。这些映射不再按接口区分。`GET/POST /admin/config/model-mappings` 管理接口读写的也只有这个字段。
 - **extraPrompts：** `model -> prompt` 的映射。把 Anthropic 风格请求翻译为 Responses API 时，会将其附加到第一条 system prompt 后面。你可以借此为不同模型注入护栏或指引。缺失的默认项会自动补齐，但不会覆盖你自定义的 prompt。对于 GPT-5.3+ 模型（如 `gpt-5.3-codex`、`gpt-5.4`、`gpt-5.5`），未显式配置时会自动使用内置的 commentary prompt。内置 prompt 会启用带阶段感知的 commentary，让模型在工具调用或更深层推理前先发出简短的用户可见进度说明。
@@ -804,7 +811,19 @@ Copilot API 现在使用子命令结构，主要命令包括：
   - **配置可选值：** `none`、`minimal`、`low`、`medium`、`high`、`xhigh`、`max`。
 - **useMessagesApi：** 当为 `true` 时，声明了 Copilot 原生 `/v1/messages` 端点的模型会使用 Messages API。如果所选模型未声明 Messages 端点或关闭了该配置，网关会在模型声明了 Responses 端点时使用 Responses，否则在模型支持时回退到 Chat Completions。设为 `false` 可跳过原生 Messages 路由。默认值为 `true`。
 - **useResponsesApiCompactionRecovery（实验性）：** 设为 `true` 后，成功的远程 Responses 压缩会异步生成低推理强度的影子摘要，并仅以 opaque compaction 哈希为键保存摘要。当 Copilot 后续拒绝该压缩内容或连接绑定历史时，HTTP 请求会逐步使用缓存摘要与可见消息重建请求。默认关闭，因为影子摘要会增加一次后台模型请求，且恢复过程存在信息损失。WebSocket 错误会在客户端下一次重试时恢复；同一次请求内的自动恢复仅支持 HTTP。
-- **useResponsesApiWebSocket：** 当为 `true` 时，Copilot Responses 请求会对声明了 `ws:/responses` 的模型使用 WebSocket；仅声明 `/responses` 的模型使用 HTTP。内置 `codex` provider 的流式 Responses 请求只要启用了该配置就会使用 WebSocket，非流式 Codex 请求始终使用 HTTP。设为 `false` 后，Copilot 会在所选模型声明了 `/responses` 时使用 HTTP，Codex 的流式 Responses 请求也会改走 HTTP。WebSocket 失败后不会自动通过 HTTP 重试。默认值为 `true`。如果代理、VPN 或网络会阻断或干扰 WebSocket 流量，请关闭该配置或切换网络。
+- **useResponsesApiWebSocket：** 控制上游 Copilot Responses 是否对声明了 `ws:/responses` 的模型使用 WebSocket；关闭或端点元数据不支持 WebSocket 时，在模型声明了 `/responses` 的情况下使用 HTTP。默认 `true`。内置 `codex` 未设置独立开关时也继承此值。Copilot 的 WebSocket 失败后不会自动通过 HTTP 重试。
+- **useCodexResponsesApiWebSocket（可选）：** 仅覆盖内置 `codex`（ChatGPT OAuth）provider 的流式 Responses 传输，包括从 Messages 转换的请求。布尔值 `false` 使用 HTTP，`true` 选择 WebSocket；不填时继承 `useResponsesApiWebSocket`，兼容旧配置。非流式请求仍走 HTTP。Codex WebSocket 在**尚未尝试发送请求**时建连失败，会降级 HTTP 一次；已取消或带有 `previous_response_id` / `conversation` 续接状态时不降级。一旦尝试发送，即使尚未收到首个事件，也不会自动重放，因为上游可能已经开始执行。HTTP 降级也失败时正常返回错误。此功能不增加面向客户端的 WebSocket 接口、不保证永不断流，也不改变第三方 provider。
+
+只让网关到 ChatGPT 使用 WebSocket、Copilot 保持 HTTP 的配置：
+
+```json
+{
+  "useResponsesApiWebSocket": false,
+  "useCodexResponsesApiWebSocket": true
+}
+```
+
+把这两个键合并到目标 API Home 的现有 `config.json`，不要覆盖整份文件。这是网关连接上游的配置；Codex 客户端连接网关的 provider 仍保留 `supports_websockets = false`，使用 HTTP/SSE。配置会缓存，改文件后需重启对应网关实例。要明确关闭 Codex WebSocket，把独立开关设为 `false`；要恢复旧版继承行为，移除该键。
 - **useCopilotFastTier：** 控制客户端请求中的 `service_tier: "fast"` 或 `"priority"` 是否可以路由到配对的 Copilot `*-fast` 模型，默认值为 `true`。设为 `false` 后，即使 Codex 任务保留了界面中不明显的 Fast 速度档位，也会强制使用标准模型。开启时，若 Fast 上游明确返回 429，会自动回退一次到配对标准模型，并按 `Retry-After` 暂停 Fast 路由（默认 30 秒，最长 5 分钟）。
 - **responsesTransport：** 所有上游 Responses transport 共用的生命周期与缓冲区正整数限制。无效值、零或负数会回退到上面列出的默认值。`headersTimeoutMsV2` 从连接建立开始计算，到收到 HTTP 响应头为止，并不是整个生成过程的总时限。每收到一个 HTTP body chunk 或 WebSocket message 都会重置 `streamInactivityTimeoutMs`，因此持续活跃的长推理任务不会被短总时限中断。`websocketOpenTimeoutMs` 限制 WebSocket 握手时间；`websocketPoolIdleTimeoutMs` 只控制已正常完成且可复用的空闲连接。WebSocket 队列同时受字节数和消息数上限约束；超过任一上限时会终止该 stream 并使 socket 失效，而不会丢弃或重排事件。
 - **useResponsesApiWebSearch：** 当为 `true` 时，服务端会保留 Responses API 中 `type: "web_search"` 的工具并透传到上游。设为 `false` 则会从 `/responses` payload 中移除这些工具。默认值为 `true`。
@@ -821,7 +840,7 @@ Copilot API 现在使用子命令结构，主要命令包括：
 
 ## API 认证
 
-- **受保护的普通路由：** 当配置了 `auth.apiKeys` 且非空时，除 `/`、`/usage-viewer` 和 `/usage-viewer/` 以外的普通路由都需要认证。
+- **受保护的普通路由：** 当配置了 `auth.apiKeys` 且非空时，除 `/`、`/usage-viewer` 和 `/usage-viewer/` 以外的普通路由都需要认证。非回环监听要求启动时存在非空的 `auth.apiKeys`，即使运行期间 Key 被清空也会继续以拒绝请求的方式安全失败。
 - **Admin 路由：** 所有 `/admin/*` 路由都要求 `auth.adminApiKey`。如果缺失，服务会在启动时自动生成并在开始提供服务前写回 `config.json`。
 - **允许的认证头：**
   - `x-api-key: <your_key>`
@@ -855,7 +874,7 @@ curl http://localhost:4141/admin/config/model-mappings \
 
 | 端点                        | 方法 | 说明                                                                                                     |
 | --------------------------- | ---- | -------------------------------------------------------------------------------------------------------- |
-| `POST /v1/responses`        | `POST` | OpenAI 中用于生成模型响应的高级接口。支持 `openai-responses` provider 的 `provider/model` 别名。        |
+| `POST /v1/responses`        | `POST` | OpenAI 中用于生成模型响应的高级接口。支持 `Content-Encoding: zstd` 请求体和 `openai-responses` provider 的 `provider/model` 别名。zstd 请求解压仅作用于 Responses 路由，包括 provider-scoped 别名路由。 |
 | `POST /v1/chat/completions` | `POST` | 为给定聊天对话创建模型响应。支持 `openai-compatible` provider 的 `provider/model` 别名；目标 provider 已配置时可在没有 Copilot 的情况下使用。 |
 | `GET /v1/models`            | `GET` | 列出 Copilot 模型以及已启用 provider 的 `provider/model-id` 模型。来自 Codex 客户端（`User-Agent` 以 `codex` 开头）的请求会转发到 Codex Models 上游。 |
 | `POST /v1/embeddings`       | `POST` | 创建表示输入文本的向量嵌入。                                                                             |
@@ -909,7 +928,8 @@ curl http://localhost:4141/admin/config/model-mappings \
 npx xiaodcs-copilot-api-edge@latest start
 
 # 自定义端口并开启详细日志
-npx xiaodcs-copilot-api-edge@latest start --port 8080 --verbose
+npx xiaodcs-copilot-api-edge@latest auth keys --add your-gateway-api-key
+npx xiaodcs-copilot-api-edge@latest start --host 0.0.0.0 --port 8080 --verbose
 
 # 执行认证流程
 npx xiaodcs-copilot-api-edge@latest auth login
@@ -951,3 +971,7 @@ curl http://localhost:4141/dashscope/v1/messages \
 - Prohibited from directly asking questions to users, MUST use question tool.
 - Once you can confirm that the task is complete, MUST use question tool to make user confirm. The user may respond with feedback if they are not satisfied with the result, which you can use to make improvements and try again, after try again, MUST use question tool to make user confirm again.
 ```
+
+## 内置 Qoder SDK provider
+
+运行 `copilot-api auth login --provider qoder`（Edge 包使用 `copilot-api-edge`），输入 Qoder PAT 后正常启动网关即可。凭证沿用受保护的 `config.json`，无需单独运行 bridge 或配置 bridge key。支持文本和图片输入、SSE、模型目录与 Credits 查询，详见 [Qoder 配置说明](qoder-bridge/README.md)。本次适配已进入源码，尚待 npm 发布。

package/dist/{auth-CZhugmTr.js → auth-D-M3qCeV.js}

@@ -1,5 +1,5 @@
-import { F as PATHS, I as ensurePaths, P as setConfiguredApiKeys, a as normalizeProviderBaseUrl, c as setProviderConfig, n as getRawProviderConfig, r as isSupportedProviderType, y as SUPPORTED_PROVIDER_TYPES } from "./config-A1SyzmBJ.js";
-import { A as getConfiguredApiKeys, K as state, M as loginCodex, a as setupGitHubToken, n as persistCodexCredentials } from "./token-CQyKjtuM.js";
+import { L as setConfiguredApiKeys, R as PATHS, a as normalizeProviderBaseUrl, c as setProviderConfig, l as QODER_SDK_BASE_URL, n as getRawProviderConfig, r as isSupportedProviderType, x as SUPPORTED_PROVIDER_TYPES, z as ensurePaths } from "./config-DnMKoKrg.js";
+import { A as getConfiguredApiKeys, K as state, M as loginCodex, a as setupGitHubToken, n as persistCodexCredentials } from "./token-CQftvMU4.js";
 import { defineCommand } from "citty";
 import consola from "consola";
 //#region src/lib/quick-providers.ts
@@ -86,7 +86,7 @@ async function prompt(message, options) {
 const authArgs = {
 	provider: {
 		type: "string",
-		description: "Provider to log in with or configure (copilot, codex, opencode-go, kimi, deepseek, dashscope, openrouter, custom)"
+		description: "Provider to log in with or configure (copilot, codex, qoder, opencode-go, kimi, deepseek, dashscope, openrouter, custom)"
 	},
 	verbose: {
 		alias: "v",
@@ -100,7 +100,11 @@ const authArgs = {
 		description: "Show provider access token on auth"
 	}
 };
-const BUILTIN_PROVIDER_NAMES = ["copilot", "codex"];
+const BUILTIN_PROVIDER_NAMES = [
+	"copilot",
+	"codex",
+	"qoder"
+];
 const QUICK_PROVIDER_NAMES = Object.keys(QUICK_PROVIDER_CONFIGS);
 const AUTH_PROVIDER_NAMES = [
 	...BUILTIN_PROVIDER_NAMES,
@@ -113,6 +117,7 @@ const CUSTOM_PROVIDER_AUTH_TYPES = ["x-api-key", "authorization"];
 const AUTH_PROVIDER_LABELS = {
 	copilot: "GitHub Copilot",
 	codex: "OpenAI Codex",
+	qoder: "Qoder (Personal Access Token)",
 	"opencode-go": "OpenCode Go",
 	kimi: "Kimi",
 	deepseek: "DeepSeek",
@@ -344,6 +349,19 @@ async function loginWithProvider(provider) {
 		await loginWithCodex();
 		return;
 	}
+	if (provider === "qoder") {
+		const apiKey = await promptRequiredSecret("Enter Qoder Personal Access Token", "PAT");
+		const existing = getRawProviderConfig("qoder");
+		setProviderConfig("qoder", {
+			type: "openai-compatible",
+			enabled: true,
+			baseUrl: QODER_SDK_BASE_URL,
+			apiKey,
+			...existing?.models ? { models: existing.models } : {}
+		});
+		consola.success(`Qoder PAT written to ${PATHS.CONFIG_PATH}. Start the gateway normally to use qoder/<model>.`);
+		return;
+	}
 	if (isQuickProviderName(provider)) {
 		await configureQuickProvider(provider);
 		return;
@@ -356,7 +374,7 @@ async function runProviderSetup() {
 	await loginWithProvider(provider);
 }
 async function runAuthLogin(options) {
-	(await import("./tls-Aq1Dd8E2.js")).enableSystemCACompat();
+	(await import("./tls-B5VJAJJM.js")).enableSystemCACompat();
 	if (options.verbose) {
 		consola.level = 5;
 		consola.info("Verbose logging enabled");
@@ -396,7 +414,7 @@ function normalizeAuthKeyValue(value) {
 	return normalizedKey;
 }
 async function runAuthKeys(options) {
-	(await import("./tls-Aq1Dd8E2.js")).enableSystemCACompat();
+	(await import("./tls-B5VJAJJM.js")).enableSystemCACompat();
 	await ensurePaths();
 	const operations = [
 		...options.add !== void 0 ? ["add"] : [],

package/dist/auth-DIGdDJx3.js

@@ -0,0 +1,2 @@
+import { t as auth } from "./auth-D-M3qCeV.js";
+export { auth };

package/dist/{config-A1SyzmBJ.js → config-DnMKoKrg.js}

@@ -1,47 +1,47 @@
-import consola from "consola";
-import { randomBytes } from "node:crypto";
-import fs from "node:fs";
-import path from "node:path";
-import fs$1 from "node:fs/promises";
+import fs from "node:fs/promises";
 import os from "node:os";
+import path from "node:path";
+import { randomBytes } from "node:crypto";
+import consola from "consola";
+import fs$1 from "node:fs";
 //#region src/lib/atomic-file.ts
 const TEMP_FILE_RANDOM_BYTES = 8;
 const fsyncDirectory = (directory) => {
 	if (process.platform === "win32") return;
 	let directoryFd;
 	try {
-		directoryFd = fs.openSync(directory, "r");
-		fs.fsyncSync(directoryFd);
+		directoryFd = fs$1.openSync(directory, "r");
+		fs$1.fsyncSync(directoryFd);
 	} catch (error) {
 		console.warn(`Failed to fsync directory: ${directory}`, error);
 	} finally {
 		if (directoryFd !== void 0) try {
-			fs.closeSync(directoryFd);
+			fs$1.closeSync(directoryFd);
 		} catch {}
 	}
 };
 function writeFileAtomically(filePath, content) {
 	const directory = path.dirname(filePath);
 	const tempPath = path.join(directory, `.${path.basename(filePath)}.${process.pid}.${randomBytes(TEMP_FILE_RANDOM_BYTES).toString("hex")}.tmp`);
-	fs.mkdirSync(directory, { recursive: true });
+	fs$1.mkdirSync(directory, { recursive: true });
 	let fileDescriptor;
 	let tempFileCreated = false;
 	try {
-		fileDescriptor = fs.openSync(tempPath, "wx", 384);
+		fileDescriptor = fs$1.openSync(tempPath, "wx", 384);
 		tempFileCreated = true;
-		fs.writeFileSync(fileDescriptor, content, "utf8");
-		fs.fsyncSync(fileDescriptor);
-		fs.closeSync(fileDescriptor);
+		fs$1.writeFileSync(fileDescriptor, content, "utf8");
+		fs$1.fsyncSync(fileDescriptor);
+		fs$1.closeSync(fileDescriptor);
 		fileDescriptor = void 0;
-		fs.renameSync(tempPath, filePath);
+		fs$1.renameSync(tempPath, filePath);
 		tempFileCreated = false;
 		fsyncDirectory(directory);
 	} catch (error) {
 		if (fileDescriptor !== void 0) try {
-			fs.closeSync(fileDescriptor);
+			fs$1.closeSync(fileDescriptor);
 		} catch {}
 		if (tempFileCreated) try {
-			fs.rmSync(tempPath, { force: true });
+			fs$1.rmSync(tempPath, { force: true });
 		} catch {}
 		throw error;
 	}
@@ -59,16 +59,16 @@ const PATHS = {
 	CONFIG_PATH: path.join(APP_DIR, "config.json")
 };
 async function ensurePaths() {
-	await fs$1.mkdir(path.join(PATHS.APP_DIR, AUTH_APP), { recursive: true });
+	await fs.mkdir(path.join(PATHS.APP_DIR, AUTH_APP), { recursive: true });
 	await ensureFile(PATHS.GITHUB_TOKEN_PATH);
 	await ensureFile(PATHS.CONFIG_PATH);
 }
 async function ensureFile(filePath) {
 	try {
-		await fs$1.access(filePath, fs$1.constants.W_OK);
+		await fs.access(filePath, fs.constants.W_OK);
 	} catch {
-		await fs$1.writeFile(filePath, "");
-		await fs$1.chmod(filePath, 384);
+		await fs.writeFile(filePath, "");
+		await fs.chmod(filePath, 384);
 	}
 }
 //#endregion
@@ -140,11 +140,11 @@ function isNodeError(error) {
 }
 function ensureConfigFile() {
 	try {
-		fs.accessSync(PATHS.CONFIG_PATH, fs.constants.R_OK | fs.constants.W_OK);
+		fs$1.accessSync(PATHS.CONFIG_PATH, fs$1.constants.R_OK | fs$1.constants.W_OK);
 	} catch {
 		writeFileAtomically(PATHS.CONFIG_PATH, `${JSON.stringify(defaultConfig, null, 2)}\n`);
 		try {
-			fs.chmodSync(PATHS.CONFIG_PATH, 384);
+			fs$1.chmodSync(PATHS.CONFIG_PATH, 384);
 		} catch {
 			return;
 		}
@@ -152,7 +152,7 @@ function ensureConfigFile() {
 }
 function readConfigFromDisk() {
 	ensureConfigFile();
-	const raw = fs.readFileSync(PATHS.CONFIG_PATH, "utf8");
+	const raw = fs$1.readFileSync(PATHS.CONFIG_PATH, "utf8");
 	if (!raw.trim()) {
 		writeFileAtomically(PATHS.CONFIG_PATH, `${JSON.stringify(defaultConfig, null, 2)}\n`);
 		return defaultConfig;
@@ -167,7 +167,7 @@ function readConfigFromDisk() {
 }
 function readEditableConfigFromDisk() {
 	try {
-		const raw = fs.readFileSync(PATHS.CONFIG_PATH, "utf8");
+		const raw = fs$1.readFileSync(PATHS.CONFIG_PATH, "utf8");
 		if (!raw.trim()) return {};
 		return JSON.parse(raw);
 	} catch (error) {
@@ -303,6 +303,10 @@ function isMessagesApiEnabled() {
 function isResponsesApiWebSocketEnabled() {
 	return getConfig().useResponsesApiWebSocket ?? true;
 }
+function isCodexResponsesApiWebSocketEnabled() {
+	const config = getConfig();
+	return typeof config.useCodexResponsesApiWebSocket === "boolean" ? config.useCodexResponsesApiWebSocket : isResponsesApiWebSocketEnabled();
+}
 function isCopilotFastTierEnabled() {
 	return getConfig().useCopilotFastTier ?? true;
 }
@@ -444,6 +448,12 @@ function getReasoningEffortForModel(model) {
 	return isGpt53OrAbove(model) ? "xhigh" : "high";
 }
 //#endregion
+//#region src/lib/qoder-config.ts
+const QODER_SDK_BASE_URL = "qoder://sdk";
+function isQoderSdkProvider(provider) {
+	return provider.name === "qoder" && provider.baseUrl === "qoder://sdk";
+}
+//#endregion
 //#region src/lib/provider-config.ts
 const OPENCODE_ANTHROPIC_MODEL_PATTERN = /^(?:qwen|minimax)/iu;
 const OPENCODE_RESPONSES_MODEL_PATTERN = /^(?:gpt|grok|muse-spark)(?:[-_.]|$)/iu;
@@ -502,12 +512,12 @@ function getProviderConfig(name) {
 	const provider = getRawProviderConfig(providerName);
 	if (!provider) return null;
 	if (provider.enabled === false) return null;
-	const type = provider.type ?? "anthropic";
+	const type = provider.type ?? (providerName === "qoder" ? "openai-compatible" : "anthropic");
 	if (!isSupportedProviderType(type)) {
 		consola.warn(`Provider ${providerName} is ignored because type '${type}' is not supported`);
 		return null;
 	}
-	const baseUrl = normalizeProviderBaseUrl(provider.baseUrl ?? "");
+	const baseUrl = normalizeProviderBaseUrl(provider.baseUrl ?? (providerName === "qoder" ? "qoder://sdk" : ""));
 	const authType = resolveProviderAuthType(providerName, provider.authType, type);
 	const apiKey = (provider.apiKey ?? "").trim();
 	const missingFields = [...baseUrl ? [] : ["baseUrl"], ...isProviderApiKeyRequired(providerName, authType) && !apiKey ? ["apiKey"] : []];
@@ -545,4 +555,4 @@ function isReservedProviderName(name) {
 	return name.trim() === "copilot";
 }
 //#endregion
-export { isResponsesApiCompactionRecoveryEnabled as A, getClaudeTokenMultiplier as C, isAlphaSearchCodexPriorityEnabled as D, getResponsesTransportConfig as E, PATHS as F, ensurePaths as I, isResponsesApiWebSocketEnabled as M, mergeConfigWithDefaults as N, isCopilotFastTierEnabled as O, setConfiguredApiKeys as P, getClaudeAutoModel as S, getMessageApiWebSearchModel as T, resolveMappedModel as _, normalizeProviderBaseUrl as a, getAlphaSearchModel as b, setProviderConfig as c, getModelResponsesApiCompactThreshold as d, getReasoningEffortForModel as f, isGpt56OrAbove as g, isContextManagementEnabledForResponses as h, listEnabledProviders as i, isResponsesApiWebSearchEnabled as j, isMessagesApiEnabled as k, getExtraPromptForModel as l, isContextManagementEnabledForMessages as m, getRawProviderConfig as n, resolveEffectiveProviderType as o, getSmallModel as p, isSupportedProviderType as r, resolveProviderAuthType as s, getProviderConfig as t, getModelMappings as u, setModelMappings as v, getConfig as w, getAnthropicApiKey as x, SUPPORTED_PROVIDER_TYPES as y };
+export { isCodexResponsesApiWebSocketEnabled as A, writeFileAtomically as B, getAnthropicApiKey as C, getMessageApiWebSearchModel as D, getConfig as E, isResponsesApiWebSocketEnabled as F, mergeConfigWithDefaults as I, setConfiguredApiKeys as L, isMessagesApiEnabled as M, isResponsesApiCompactionRecoveryEnabled as N, getResponsesTransportConfig as O, isResponsesApiWebSearchEnabled as P, PATHS as R, getAlphaSearchModel as S, getClaudeTokenMultiplier as T, isContextManagementEnabledForResponses as _, normalizeProviderBaseUrl as a, setModelMappings as b, setProviderConfig as c, getExtraPromptForModel as d, getModelMappings as f, isContextManagementEnabledForMessages as g, getSmallModel as h, listEnabledProviders as i, isCopilotFastTierEnabled as j, isAlphaSearchCodexPriorityEnabled as k, QODER_SDK_BASE_URL as l, getReasoningEffortForModel as m, getRawProviderConfig as n, resolveEffectiveProviderType as o, getModelResponsesApiCompactThreshold as p, isSupportedProviderType as r, resolveProviderAuthType as s, getProviderConfig as t, isQoderSdkProvider as u, isGpt56OrAbove as v, getClaudeAutoModel as w, SUPPORTED_PROVIDER_TYPES as x, resolveMappedModel as y, ensurePaths as z };

package/dist/{debug-Dnic5hxU.js → debug-CuLfQpTq.js}

@@ -1,8 +1,8 @@
-import { F as PATHS, i as listEnabledProviders, n as getRawProviderConfig } from "./config-A1SyzmBJ.js";
-import { defineCommand } from "citty";
-import consola from "consola";
+import { R as PATHS, i as listEnabledProviders, n as getRawProviderConfig } from "./config-DnMKoKrg.js";
 import fs from "node:fs/promises";
 import os from "node:os";
+import { defineCommand } from "citty";
+import consola from "consola";
 import { fileURLToPath } from "node:url";
 //#region src/debug.ts
 async function getPackageVersion() {

package/dist/main.js

@@ -2,7 +2,7 @@
 import { t as isMcpFastPath } from "./fast-path-BoMnZCVC.js";
 //#region src/main.ts
 if (isMcpFastPath(process.argv)) {
-	const { runMcpServer } = await import("./mcp-server-DQ4r-fAy.js");
+	const { runMcpServer } = await import("./mcp-server-Byq5DomJ.js");
 	await runMcpServer();
 } else {
 	const { defineCommand, runMain, parseArgs } = await import("citty");
@@ -25,12 +25,12 @@ if (isMcpFastPath(process.argv)) {
 	if (typeof args["oauth-app"] === "string") process.env.COPILOT_API_OAUTH_APP = args["oauth-app"];
 	if (typeof args["enterprise-url"] === "string") process.env.COPILOT_API_ENTERPRISE_URL = args["enterprise-url"];
 	if (process.platform === "win32" && process.stdout.isTTY && !process.env.WT_SESSION) process.env.WT_SESSION = "copilot-api";
-	const { bindElectronFetch } = await import("./electron-fetch-BRX-ug5E.js");
+	const { bindElectronFetch } = await import("./electron-fetch-D5uOld7F.js");
 	bindElectronFetch();
-	const { auth } = await import("./auth-D-Wpolvg.js");
-	const { debug } = await import("./debug-Dnic5hxU.js");
-	const { mcp } = await import("./mcp-fpSlKZxK.js");
-	const { start } = await import("./start-DCKDnLr6.js");
+	const { auth } = await import("./auth-DIGdDJx3.js");
+	const { debug } = await import("./debug-CuLfQpTq.js");
+	const { mcp } = await import("./mcp-DqslOG3W.js");
+	const { start } = await import("./start-WdcRgBSL.js");
 	await runMain(defineCommand({
 		meta: {
 			name: "copilot-api",

package/dist/{mcp-fpSlKZxK.js → mcp-DqslOG3W.js}

@@ -1,4 +1,4 @@
-import { t as runMcpServer } from "./mcp-server-BeNu_Edl.js";
+import { t as runMcpServer } from "./mcp-server-B-_dWuXe.js";
 import { defineCommand } from "citty";
 //#region src/mcp.ts
 const mcp = defineCommand({

package/dist/{mcp-server-BeNu_Edl.js → mcp-server-B-_dWuXe.js}

@@ -1,4 +1,4 @@
-import { n as createMcpToolSearchSentinel } from "./tool-search-Ds1vbmGG.js";
+import { n as createMcpToolSearchSentinel } from "./tool-search-DCb3HbWj.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";

package/dist/mcp-server-Byq5DomJ.js

@@ -0,0 +1,2 @@
+import { t as runMcpServer } from "./mcp-server-B-_dWuXe.js";
+export { runMcpServer };