dsh-codex-ws 1.3.0 → 1.3.1

package/README.md

@@ -8,11 +8,13 @@
   - **WS 模式**：`wss://<baseURL>/responses`，发送 `{ "type": "response.create", ... }` 后接收与 SSE 完全相同的 Responses 事件流；连接按池复用（干净结束后保留 3 分钟，50 分钟强制换新）。
   - **SSE 模式**：Fast 关闭时不拦截，走 DSH 原有 openai 渠道的流式请求（auto 模式下的回退则是普通 `POST /responses` + `stream: true` 打到同一中转站）。
   - 拦截层复刻了适配器边界的投影（文件 → 可读路径句柄、图片 → 文本占位、developer 消息丢弃、deferLoading 工具声明展开），WS 路径目前仅发送文本，不会把图片原始内容发送给模型；不能视为与原生多模态适配器完全等价。
-- 接口地址与 Key 的解析顺序（`lib/config.js`）：
-  1. 插件配置里的 `baseURL` / `apiKey`
-  2. `envFile`（.env）或环境变量 `apiKeyEnv`（默认 `OPENAI_API_KEY`）
-  3. **`~/.codex/config.toml`** 中 `supports_websockets = true` 的 `[model_providers.*]`（取其 `base_url` 与 `experimental_bearer_token`）
-  4. 内置默认（`https://sub.cxc2.cn/v1`）
+- **默认继承 DSH 当前 OpenAI 渠道的接口地址与凭据**：通过 `llm/listConfigurableProviders` 定位 openai 路由的设置命名空间与 profile 路径，读取其 `baseURL`（缺省用渠道默认地址），`apiKeyEnv` 凭据引用经 credentials 服务解析——与 llm-pi-ai 适配器自身的解析方式一致。每次请求重新读取，渠道配置改动即时生效；不读取本地 Codex CLI 配置，也没有写死的中转地址。
+- 插件的 `baseURL` / `apiKey` / `apiKeyEnv` / `envFile` 留空即可继承。显式填写任意一项会进入独立覆盖模式，必须同时提供接口地址和 Key，不会与 DSH 的地址或凭据混用。
+  - 覆盖模式 Key 顺序：`apiKey` → `envFile` 中对应变量 → 显式指定的 `apiKeyEnv` 环境变量。
+  - `apiKeyEnv` 默认留空；仅配置 `envFile` 时默认读取文件中的 `OPENAI_API_KEY`。不会自动使用进程中的 `OPENAI_API_KEY`。
+  - 不再自动沿用 `~/.codex/config.toml`；若要使用同一服务，请在 DSH OpenAI 渠道中配置，或显式提供插件覆盖配置。
+  - 升级后若旧配置保存了 `apiKeyEnv: OPENAI_API_KEY`，请清空该字段及其他覆盖项以启用继承。
+  - 继承模式下渠道未配置或凭据无法解析时请求明确报错（`INVALID_CONFIGURATION`），不会退回其他端点或凭据。
 - 输入框右侧、模型选择器旁的 **WS / SSE** 小按钮实时切换传输模式（下一次模型请求生效），选择持久化在 `$DSH_HOME/codex-ws/state.json`。**按钮只在该会话当前模型位于 openai 渠道时出现**，其他模型旁不存在。
 
 ### Fast 模式
@@ -20,13 +22,20 @@
 WS / SSE 按钮旁新增独立 **Fast** 按钮，默认关闭，开启后高亮。开关与传输模式分别保存，全局影响 OpenAI 请求，从下一次模型请求生效，重启后保留。
 
 - 开启时发送 `service_tier: "priority"`，不改变模型、推理强度或输出长度；是否支持、实际速度和额外费用由服务端决定。
-- WS / auto 及 auto 回退 SSE 均保留该参数。**SSE + Fast 使用插件配置的 Responses 端点与凭据，而非原生适配器**，并继承插件的仅文本投影限制。关闭 Fast 后 SSE 恢复原样放行。
-- 开启 Fast 但缺少插件凭据时明确报错，不静默丢弃优先处理参数。切换 Fast 后增量 WS 请求配置指纹改变，自动全量发送。
+- WS / auto 及 auto 回退 SSE 均保留该参数。**SSE + Fast 由插件发起 Responses 请求，默认继承 DSH OpenAI 端点与凭据**，并继承插件的仅文本投影限制。关闭 Fast 后 SSE 恢复原样放行。
+- WS / auto / SSE + Fast 配置不完整时明确报错，不静默丢弃优先处理参数。切换 Fast 后增量 WS 请求配置指纹改变，自动全量发送。
 - 离线验证：`node test/fast.mjs`（不调用真实 API）。
 
 ## 安装
 
-npm 发布完成后，可运行 `npm pack dsh-codex-ws@1.3.0 --registry=https://registry.npmjs.org` 获取安装包，在 DSH 插件管理中安装本地包；或克隆仓库后从本地目录安装。安装后刷新插件和界面。
+可运行 `npm pack dsh-codex-ws@1.3.1 --registry=https://registry.npmjs.org` 获取安装包，在 DSH 插件管理中安装本地包；或克隆仓库后从本地目录安装。安装后刷新插件和界面。
+
+### v1.3.1 升级说明
+
+- 默认继承 DSH OpenAI 渠道的接口地址和凭据，每次请求重新读取渠道配置。
+- 移除本地 Codex CLI 配置与内置中转地址回退；显式覆盖必须成对提供地址和 Key，避免混用端点与凭据。
+- **从旧版升级**：若插件中保存了 `apiKeyEnv: OPENAI_API_KEY`，请清空它及其他覆盖项以启用继承；如需独立覆盖，请同时配置 `baseURL` 和 Key。
+- 配置不完整时，WS / auto / SSE + Fast 明确报错；SSE 且 Fast 关闭仍由原生 OpenAI 适配器处理。
 
 ## npm 发布维护
 
@@ -48,7 +57,7 @@ npm 发布完成后，可运行 `npm pack dsh-codex-ws@1.3.0 --registry=https://
 
 1. 确认 openai 渠道（llm-pi-ai 的 `openai`）已配置好 Key；模型选择器里选任意 GPT 模型。
 2. 模型选择器旁会出现 WS / SSE 按钮：默认即 WS 模式（可配置）；点一下切回 SSE 流式，再点切回 WS。
-3. 插件配置（设置 → 插件 → Codex WS → 配置）可改：`transport`（websocket / sse / auto，auto = WS 连接失败自动回退流式）、`baseURL`、`apiKey`、`apiKeyEnv`、`envFile`、超时等。
+3. 默认无需重复填写地址和 Key。插件配置（设置 → 插件 → Codex WS → 配置）可改：`transport`（websocket / sse / auto，auto = WS 连接失败自动回退流式）、`baseURL`、`apiKey`、`apiKeyEnv`、`envFile`、超时等。
 
 ## 说明
 

package/cordis.patch.yml

@@ -1,6 +1,6 @@
 # GPT (Codex backend) WebSocket mode for the OpenAI channel.
-# Every field is optional; empty values fall back to ~/.codex/config.toml
-# (model_providers.* with supports_websockets = true), then to the plugin defaults.
+# Leave endpoint/credential fields empty to inherit the DSH OpenAI provider.
+# Explicit overrides require both an endpoint and credentials; no Codex CLI fallback.
 - insert:
     - id: codex-ws
       name: 'dsh-codex-ws'

package/index.js

@@ -5,8 +5,8 @@
  * harness `llm/stream` waterfall for the existing `openai` provider: while the
  * transport toggle is on (websocket / auto), those requests speak the Responses
  * protocol over WebSocket ("WS 模式", Codex CLI `supports_websockets`) against the
- * relay the local Codex CLI uses (base URL + bearer token resolved from this
- * plugin's config, then ~/.codex/config.toml, then defaults). SSE mode passes the
+ * current DSH OpenAI endpoint and credentials (or a complete explicit plugin
+ * override). No Codex CLI configuration is read. SSE mode passes the
  * request through to the normal openai adapter untouched, so OpenAI models stay a
  * single channel and non-OpenAI models never see the toggle at all.
  *
@@ -19,12 +19,12 @@
 import { readFileSync, writeFileSync, mkdirSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
-import { Config, resolveSettings, TARGET_PROVIDER, TRANSPORTS } from './lib/config.js'
+import { Config, resolveSettings, hasOverride, TARGET_PROVIDER, TRANSPORTS } from './lib/config.js'
 import { ResponseStreamMapper, buildCreateBody, projectOptions, abortedFinish, errorFinish } from './lib/responses.js'
 import { runTransport, closeIdleSockets, TransportError } from './lib/transport.js'
 
 export const name = 'codex-ws'
-export const inject = ['llm', 'webServer', 'connection']
+export const inject = ['llm', 'webServer', 'connection', 'settings']
 export { Config }
 
 const STATE_PATH = '/codex-ws/state'
@@ -57,16 +57,16 @@ function writeState(state) {
 // ---------------------------------------------------------------------------------------------
 
 /** One openai-provider request over the Codex-style transport; yields harness chunks. */
-async function* interceptedStream(options, runtime, resolvePath) {
-  const { settings, transport } = runtime
-  if (settings.apiKey.length === 0) {
+async function* interceptedStream(options, resolveRuntime, resolvePath) {
+  const { settings, transport } = await resolveRuntime()
+  if (settings.configurationError) {
     yield {
       type: 'finish',
       reason: {
         kind: 'error',
         failure: {
-          message: `codex-ws: no API key for the plugin Responses transport; set the key on the plugin's config page (or ${settings.apiKeyEnv} / ~/.codex/config.toml), or disable Fast and switch to SSE`,
-          code: 'MISSING_CREDENTIAL',
+          message: settings.configurationError,
+          code: 'INVALID_CONFIGURATION',
         },
       },
     }
@@ -117,11 +117,86 @@ export function apply(ctx, config) {
   }
   loadState()
 
-  /** Live settings plus the effective transport for the next request. */
-  const runtime = () => {
-    const settings = { ...resolveSettings(config), fast: state.fast }
-    const transport = state.override ?? settings.transport
-    return { settings, transport }
+  /**
+   * The DSH OpenAI provider's live endpoint and bearer credential, resolved the
+   * same way the pi-ai adapter resolves them: the configurable-provider
+   * directory names the settings namespace and profile path; the profile holds
+   * an optional baseURL (falling back to the route's catalog default) and an
+   * apiKeyEnv credential reference resolved through the credentials service
+   * (with the launch environment as a secondary source). Re-read per request
+   * so channel edits apply without a restart; every failure is contained and
+   * surfaces as the inherited-mode configuration error.
+   */
+  const inheritedProvider = async () => {
+    try {
+      const entry = ctx.llm.listConfigurableProviders().find((provider) => provider.provider === TARGET_PROVIDER)
+      if (!entry) return {}
+      let profile = {}
+      try {
+        const namespace = ctx.settings
+          ?.describe({ redactSecrets: true })
+          .find((candidate) => candidate.ns === entry.settingsNs)
+        let value = namespace?.value
+        for (const key of entry.settingsPath ?? []) value = value?.[key]
+        profile = value !== null && typeof value === 'object' ? value : {}
+      } catch {
+        /* settings service unavailable: fall back to the catalog default */
+      }
+      const baseURL = typeof profile.baseURL === 'string' ? profile.baseURL.trim() : ''
+      const reference = typeof profile.apiKeyEnv === 'string' ? profile.apiKeyEnv.trim() : ''
+      let apiKey = ''
+      if (reference) {
+        // Bare `ctx.credentials` throws on the Cordis context proxy when the
+        // service is not in this plugin's inject list ("cannot get property
+        // without inject"); ctx.get is the supported inject-free accessor and
+        // matches how llm-pi-ai itself reaches the credentials service.
+        let credentials
+        try {
+          credentials = typeof ctx.get === 'function' ? ctx.get('credentials') : undefined
+        } catch {
+          /* this composition mounts no credential plane */
+        }
+        try {
+          const resolved = credentials === undefined ? undefined : await credentials.resolve?.(reference)
+          if (typeof resolved?.value === 'string') apiKey = resolved.value.trim()
+        } catch {
+          /* an unresolvable reference surfaces as the inherited-mode error */
+        }
+        if (apiKey.length === 0) {
+          // Ambient fallback mirrors the adapter: the launch-environment
+          // snapshot (process / project .env / user .env layers), with raw
+          // process.env as the last resort for compositions without either.
+          let ambient
+          try {
+            const environment = typeof ctx.get === 'function' ? ctx.get('launchEnvironment') : undefined
+            ambient = environment?.get?.(reference)?.value
+          } catch {
+            /* optional service */
+          }
+          apiKey = (ambient ?? process.env[reference] ?? '').trim()
+        }
+      }
+      return {
+        baseURL: baseURL || (typeof entry.defaultBaseURL === 'string' ? entry.defaultBaseURL.trim() : ''),
+        apiKey,
+      }
+    } catch {
+      return {}
+    }
+  }
+
+  /** Sync transport/fast decision for the next request; never touches credentials. */
+  const runtimeSync = () => {
+    const { transport } = resolveSettings(config, {})
+    return { transport: state.override ?? transport, fast: state.fast }
+  }
+
+  /** Live settings plus the effective transport; the inherited endpoint and
+   * credential resolve asynchronously through the DSH services. */
+  const runtime = async () => {
+    const provider = hasOverride(config) ? {} : await inheritedProvider()
+    const settings = { ...resolveSettings(config, provider), fast: state.fast }
+    return { settings, transport: state.override ?? settings.transport }
   }
 
   const persistState = (patch) => {
@@ -152,15 +227,15 @@ export function apply(ctx, config) {
    */
   ctx.on('llm/stream', (options, next) => {
     if (options?.provider !== TARGET_PROVIDER) return next()
-    const { settings, transport } = runtime()
-    if (transport === 'sse' && !settings.fast) return next()
-    // Do not silently drop an explicitly requested priority tier when credentials are missing.
-    if (settings.apiKey.length === 0 && !settings.fast) return next()
-    return interceptedStream(options, { settings, transport }, fileReadPath)
+    const { transport, fast } = runtimeSync()
+    if (transport === 'sse' && !fast) return next()
+    // Fail closed for incomplete overrides or unavailable inherited configuration.
+    // Never silently change endpoint, account, or requested transport.
+    return interceptedStream(options, runtime, fileReadPath)
   })
 
-  const publicState = () => {
-    const { settings, transport } = runtime()
+  const publicState = async () => {
+    const { settings, transport } = await runtime()
     let providerAvailable = true
     try {
       providerAvailable = ctx.llm.listProviders().some((provider) => provider.id === TARGET_PROVIDER)
@@ -230,7 +305,7 @@ export function apply(ctx, config) {
           try {
             if (rejected(req, res)) return
             if (req.method === 'GET') {
-              sendJson(res, 200, publicState())
+              sendJson(res, 200, await publicState())
               return
             }
             if (req.method !== 'POST') {
@@ -262,7 +337,7 @@ export function apply(ctx, config) {
               patch.fast = body.fast
             }
             persistState(patch)
-            sendJson(res, 200, publicState())
+            sendJson(res, 200, await publicState())
           } catch (error) {
             if (!res.headersSent) sendJson(res, 400, { error: error?.message ?? 'bad request' })
             else res.end()

package/lib/config.js

@@ -3,13 +3,11 @@
  * normalizer the plugin reads them through (same inline-schemastery pattern as the
  * other local bundles — a profile-installed bundle cannot import DSH's own packages).
  *
- * Endpoint resolution mirrors the local Codex CLI setup this plugin adapts:
- *   plugin config  →  ~/.codex/config.toml [model_providers.*] (supports_websockets)  →  defaults.
+ * Endpoints and credentials are inherited together from the DSH OpenAI provider.
+ * Explicit plugin overrides must supply their own endpoint and credential pair.
  */
 
 import { readFileSync } from 'node:fs'
-import { homedir } from 'node:os'
-import { join } from 'node:path'
 
 // ---------------------------------------------------------------------------------------------
 // Schema (serialized schemastery document; generated shape, do not hand-edit refs' uids)
@@ -23,7 +21,7 @@ const SCHEMA = {
       meta: {
         default: '',
         description:
-          '中转站 / 接口地址（Codex CLI 的 base_url，如 https://sub.cxc2.cn/v1）。请求实际访问 <baseURL>/responses（WS 为 wss://…/responses）。留空读取 ~/.codex/config.toml 中 supports_websockets = true 的模型渠道，再回退默认值。',
+          '接口地址。默认与 Key 一起继承 DSH 的 OpenAI 渠道。显式覆盖时须同时提供本插件的 Key（或环境变量引用），不会混用 DSH 凭据。请求访问 <baseURL>/responses。',
       },
     },
     5: {
@@ -32,10 +30,10 @@ const SCHEMA = {
         role: 'secret',
         default: '',
         description:
-          'Bearer API Key（sk-…）。留空依次读取：envFile / 环境变量 apiKeyEnv / ~/.codex/config.toml 的 experimental_bearer_token。Key 只在 Host 侧使用，不会发送到浏览器。',
+          'Bearer API Key。默认沿用 DSH OpenAI 渠道；显式覆盖须同时填写 baseURL。覆盖模式下可通过 envFile / apiKeyEnv 提供 Key。Key 仅在 Host 使用。',
       },
     },
-    7: { type: 'string', meta: { default: 'OPENAI_API_KEY', description: 'API Key 的环境变量 / 凭据引用名。' } },
+    7: { type: 'string', meta: { default: '', description: '显式覆盖 Key 的环境变量名；留空不自动读取 OPENAI_API_KEY。使用 envFile 时留空默认读取其中的 OPENAI_API_KEY。' } },
     9: { type: 'string', meta: { default: '', description: '可选的 .env 文件绝对路径（KEY=VALUE，每行一条）。' } },
     11: {
       type: 'string',
@@ -110,7 +108,6 @@ export const Config = {
 // ---------------------------------------------------------------------------------------------
 
 export const TARGET_PROVIDER = 'openai'
-export const DEFAULT_BASE_URL = 'https://sub.cxc2.cn/v1'
 export const TRANSPORTS = ['websocket', 'sse', 'auto']
 
 function text(value) {
@@ -147,76 +144,40 @@ function readEnvFile(file) {
   return result
 }
 
-/**
- * Minimal TOML reader for the one thing this plugin needs from the Codex CLI config:
- * `[model_providers.<id>]` tables with string/boolean values. Ignores everything else
- * (arrays, nested tables, multiline strings), which is exactly the shape config.toml uses.
- */
-function readCodexModelProviders(file) {
-  let raw
-  try {
-    raw = readFileSync(file, 'utf8')
-  } catch {
-    return []
-  }
-  const providers = []
-  let current = null
-  for (const line of raw.split(/\r?\n/)) {
-    const trimmed = line.trim()
-    if (!trimmed || trimmed.startsWith('#')) continue
-    const header = /^\[\s*([^\]]+?)\s*\]$/.exec(trimmed)
-    if (header) {
-      const path = header[1].split('.').map((p) => (p.startsWith('"') || p.startsWith("'") ? p.slice(1, -1) : p.trim()))
-      current = path.length === 2 && path[0] === 'model_providers' ? { id: path[1] } : null
-      if (current) providers.push(current)
-      continue
-    }
-    if (!current) continue
-    const eq = trimmed.indexOf('=')
-    if (eq <= 0) continue
-    const key = trimmed.slice(0, eq).trim()
-    let value = trimmed.slice(eq + 1).trim()
-    if (/^".*"$/.test(value)) {
-      try {
-        value = JSON.parse(value)
-      } catch {
-        value = value.slice(1, -1)
-      }
-    } else if (/^'.*'$/.test(value)) value = value.slice(1, -1)
-    else if (value === 'true' || value === 'false') value = value === 'true'
-    else if (/^-?\d+$/.test(value)) value = Number(value)
-    if (typeof value === 'string' || typeof value === 'boolean') current[key] = value
-  }
-  return providers.filter((p) => typeof p.base_url === 'string' && p.base_url.length > 0)
-}
-
-/** The WebSocket-capable provider the local Codex CLI uses, when there is one. */
-export function localCodexProvider(codexHome) {
-  const providers = readCodexModelProviders(join(codexHome ?? join(homedir(), '.codex'), 'config.toml'))
-  return (
-    providers.find((p) => p.supports_websockets === true) ??
-    providers.find((p) => typeof p.experimental_bearer_token === 'string' && p.experimental_bearer_token.length > 0) ??
-    null
-  )
+/** True when any explicit endpoint/credential field opts out of inheritance. */
+export function hasOverride(config) {
+  const cfg = config !== null && typeof config === 'object' ? config : {}
+  return ['baseURL', 'apiKey', 'apiKeyEnv', 'envFile'].some((key) => text(cfg[key]))
 }
 
-/**
- * Fully-defaulted settings for one request. Precedence per value: row config, then
- * `envFile`, then the process environment, then ~/.codex/config.toml, then built-in default.
- * Resolved on every read so an edited .env or config.toml applies without a restart.
+/** Resolve one request without mixing endpoint and credentials from different sources.
+ * `provider` is the current, Host-only DSH OpenAI transport configuration
+ * ({ baseURL, apiKey }); inherited mode never reads local Codex files or
+ * ambient credentials.
  */
-export function resolveSettings(config) {
+export function resolveSettings(config, provider = {}) {
   const cfg = config !== null && typeof config === 'object' ? config : {}
-  const envFile = text(cfg.envFile)
-  const fileEnv = envFile ? readEnvFile(envFile) : {}
-  const env = (key) => text(fileEnv[key]) || text(process.env[key])
-
-  const codex = localCodexProvider()
-
-  const baseURL = (text(cfg.baseURL) || text(codex?.base_url) || DEFAULT_BASE_URL).replace(/\/+$/, '')
-
+  const override = hasOverride(config)
   const apiKeyEnv = text(cfg.apiKeyEnv) || 'OPENAI_API_KEY'
-  const apiKey = text(cfg.apiKey) || env(apiKeyEnv) || text(codex?.experimental_bearer_token)
+  const envFile = text(cfg.envFile)
+  const fileEnv = override && envFile ? readEnvFile(envFile) : {}
+  const baseURL = text(override ? cfg.baseURL : provider?.baseURL).replace(/\/+$/, '')
+  const apiKey = override
+    ? text(cfg.apiKey) || text(fileEnv[apiKeyEnv]) || (text(cfg.apiKeyEnv) ? text(process.env[apiKeyEnv]) : '')
+    : text(provider?.apiKey)
+  let configurationError = ''
+  if (!baseURL || !apiKey) {
+    configurationError = override
+      ? 'codex-ws: plugin overrides require both baseURL and an API key (apiKey, envFile or apiKeyEnv); DSH credentials are never mixed with overrides'
+      : 'codex-ws: DSH OpenAI endpoint or credential is unavailable — configure the openai channel in DSH settings (an API-key credential with baseURL), or supply a complete plugin override (baseURL and key together)'
+  } else {
+    try {
+      const url = new URL(baseURL)
+      if (!['https:', 'http:'].includes(url.protocol) || url.username || url.password || url.search || url.hash) throw new Error('invalid endpoint')
+    } catch {
+      configurationError = 'codex-ws: baseURL must be an HTTP(S) URL without userinfo, query or fragment'
+    }
+  }
 
   const rawTransport = text(cfg.transport).toLowerCase()
   const transport = TRANSPORTS.includes(rawTransport) ? rawTransport : 'websocket'
@@ -224,6 +185,8 @@ export function resolveSettings(config) {
   const verbosity = text(cfg.verbosity).toLowerCase()
 
   return {
+    configurationError,
+    source: override ? 'plugin' : 'dsh',
     baseURL,
     sseUrl: baseURL.endsWith('/responses') ? baseURL : `${baseURL}/responses`,
     wsUrl: (baseURL.endsWith('/responses') ? baseURL : `${baseURL}/responses`)

package/locale/en.json

@@ -1,6 +1,6 @@
 {
   "meta": {
     "title": "Codex WS",
-    "description": "GPT models over the Codex-style Responses WebSocket transport (Codex CLI's supports_websockets): no extra model channel — the openai provider is intercepted in place, with the endpoint and key resolved from the local Codex CLI config (~/.codex/config.toml). The composer WS/SSE button appears only while the current model is an OpenAI one."
+    "description": "GPT models over the Codex-style Responses WebSocket transport (Codex CLI's supports_websockets): no extra model channel — the openai provider is intercepted in place, with the endpoint and key inherited from the DSH OpenAI provider by default. Explicit plugin overrides require both an endpoint and credentials; local Codex CLI config is not read. The composer WS/SSE button appears only while the current model is an OpenAI one."
   }
 }

package/locale/zh.json

@@ -1,6 +1,6 @@
 {
   "meta": {
     "title": "Codex WS",
-    "description": "GPT 模型走 Codex 风格的 Responses WebSocket 传输（对应 Codex CLI 的 supports_websockets）：不注册额外渠道，直接在 openai 渠道上拦截生效，接口地址与 Key 自动沿用本地 Codex CLI 配置（~/.codex/config.toml）；输入框模型选择器旁的 WS/SSE 按钮仅在当前模型为 OpenAI 时出现。"
+    "description": "GPT 模型走 Codex 风格的 Responses WebSocket 传输（对应 Codex CLI 的 supports_websockets）：不注册额外渠道，直接在 openai 渠道上拦截生效，接口地址与 Key 默认沿用 DSH 的 OpenAI 渠道配置，插件可显式成对覆盖，不自动读取 Codex CLI 配置；输入框模型选择器旁的 WS/SSE 按钮仅在当前模型为 OpenAI 时出现。"
   }
 }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "dsh-codex-ws",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "GPT models over the Codex-style Responses WebSocket transport (like Codex CLI 'supports_websockets'), toggled in place on the openai channel with an in-composer WS/SSE button shown only for OpenAI models.",
   "publishConfig": { "access": "public", "registry": "https://registry.npmjs.org/" },
   "scripts": {
-    "test": "node test/client.mjs && node test/fast.mjs && node test/projection.mjs && node test/continuation.mjs && DSH_HOME=$(mktemp -d) OPENAI_API_KEY=test-only node test/intercept.mjs"
+    "test": "node test/config.mjs && node test/client.mjs && node test/fast.mjs && node test/projection.mjs && node test/continuation.mjs && DSH_HOME=$(mktemp -d) node test/intercept.mjs"
   },
   "repository": { "type": "git", "url": "https://github.com/kiritoko1029/dsh-codex-ws.git" },
   "homepage": "https://github.com/kiritoko1029/dsh-codex-ws#readme",