dsh-scnet-connect 1.0.1 → 1.1.0

package/README.md

@@ -9,6 +9,8 @@
 - **零客户端**：不装 SCNet 桌面客户端，用手机短信登录即可使用
 - **零配置**：装了客户端的话，自动读凭据、自动发现免费模型
 - **设置页管理**：账号、登录、模型开关都在 DSH 设置里
+- **1M 上下文**：`SCNet-Max` 按平台真实能力声明 `contextWindow: 1048576` / `maxTokens: 131072`（实测 104.5 万 token 输入通过、1.06M 被拒，见 [docs/scnet-api.md](docs/scnet-api.md)）
+- **抖动自愈**：平台偶发的 `503 + 10008`（路由切换）会被归一化成可重试错误，自动退避重试而不是整轮失败
 
 ![设置页](.github/assets/settings.png)
 
@@ -194,9 +196,32 @@ dsh plugin --profile desktop add link:.
 | `inputImages` | `true` | 是否声明接受图片 |
 | `reasoning` | `true` | 是否声明支持思考等级 |
 | `verifyWithGateway` | `true` | 刷新时用 `GET /models` 校验 |
+| `retryOnTransientErrors` | `true` | 把 SCNet「5xx 却标成 `invalid_request_error`」的瞬时抖动改写成可重试的服务端错误（见下） |
 
 </details>
 
+### 关于 `retryOnTransientErrors`
+
+SCNet 在推理实例切换/回收时会返回这种响应：
+
+```json
+HTTP 503
+{"error":{"message":"The model's routing or availability changed while processing the request. Please try again.","type":"invalid_request_error","code":"10008"}}
+```
+
+状态码是 5xx，但响应体 `type` 写的是 `invalid_request_error`。DSH 的错误归类按正则顺序扫描文本，`invalid.?request` 排在 `5xx → SERVER` 前面，于是把它判成 **`INVALID_REQUEST`（不可重试）**，一次退避都不做，本轮直接失败。
+
+插件默认把这层归一化打开：只针对「状态码 ≥ 500 且 `type` 是 `invalid_request_error`」的响应，把 `type` 改写为 `api_error`（状态码与 message 原样保留），让归类落到 `SERVER`，交给 DSH 的 5 次指数退避重试。
+
+刻意不碰的：真正的 `400`（如参数错误 `10013`）、`401/403/402/429`、以及 2xx 流式响应。
+
+实测（本地假网关，前 2 次返回上述 503）：
+
+| 配置 | chat 请求数 | 结果 |
+| --- | --- | --- |
+| `retryOnTransientErrors: false` | 2（无重试） | 失败，`code: INVALID_REQUEST` |
+| `retryOnTransientErrors: true`（默认） | 4（2 次 503 后成功） | 正常完成 |
+
 ---
 
 ## 故障排查
@@ -210,6 +235,7 @@ dsh plugin --profile desktop add link:.
 | 提示「平台会话已过期」 | 在设置页重新登录一次 |
 | 短信收不到 | 确认手机号正确、图形验证码没填错；平台有 60 秒与每小时次数限制 |
 | 上游 429 | 插件不屏蔽限流，降低并发或稍等重试 |
+| 报 `503` + `code: 10008` / `10009` | 平台侧路由抖动。默认会自动重试；若已被手动关掉 `retryOnTransientErrors`，打开它或稍后重发 |
 
 ---
 

package/lib/index.js

@@ -39,6 +39,7 @@ import path from 'node:path';
 
 import { maskKey, readClientAccount, resolveApiKey } from './scnet-credential.js';
 import { createModelCatalog } from './scnet-catalog.js';
+import { createRetryFriendlyFetch, withRetryFriendlyFetch } from './scnet-fetch.js';
 import { createLoginManager } from './scnet-login.js';
 import { DEFAULT_BASE_URL, DEFAULT_MODEL_ID, buildModel, modelLabel } from './scnet-models.js';
 
@@ -112,6 +113,12 @@ export const Config = z.object({
     .boolean()
     .default(true)
     .description('刷新模型时用网关 GET /models 校验可用性（关闭后只读本地客户端目录）'),
+  retryOnTransientErrors: z
+    .boolean()
+    .default(true)
+    .description(
+      '把 SCNet「5xx 但响应体标成 invalid_request」的瞬时抖动改写成可重试的服务端错误，交给 DSH 退避重试（关闭后这类 503 会直接失败）',
+    ),
   freeOnly: z
     .boolean()
     .default(true)
@@ -197,6 +204,7 @@ export async function apply(ctx, config) {
     inputImages: config?.inputImages !== false,
     reasoning: config?.reasoning !== false,
     verifyWithGateway: config?.verifyWithGateway !== false,
+    retryOnTransientErrors: config?.retryOnTransientErrors !== false,
     freeOnly: config?.freeOnly !== false,
   };
 
@@ -408,6 +416,22 @@ export async function apply(ctx, config) {
     );
   };
 
+  /**
+   * 上游「5xx 却自称 invalid_request」的归一化 fetch（见 `lib/scnet-fetch.js`）。
+   *
+   * SCNet 在推理实例切换时返回 503 + `type:"invalid_request_error"` +
+   * `code:"10008"`，DSH 的归类器会先命中 `invalid.?request` 把它判成
+   * `INVALID_REQUEST`（不可重试），于是一次本可自愈的抖动直接让本轮失败。
+   * 这里把它改写成 `api_error`，落到 `SERVER` 分支，交给 DSH 的退避重试。
+   */
+  const retryFriendlyFetch = createRetryFriendlyFetch({
+    onNormalize: ({ status, code, message }) => {
+      logger.warn(
+        `上游返回 ${status}（code=${code ?? '-'}），已按可重试的服务端错误处理：${message ?? ''}`.trim(),
+      );
+    },
+  });
+
   const buildProfile = () => {
     const models = buildModels();
     const provider = {
@@ -445,7 +469,9 @@ export async function apply(ctx, config) {
           },
         },
         models,
-        api: openAICompletionsApi(),
+        api: options.retryOnTransientErrors
+          ? withRetryFriendlyFetch(openAICompletionsApi(), retryFriendlyFetch)
+          : openAICompletionsApi(),
       }),
       // 模型目录可能随客户端目录更新，每次读取都重建。
       getModels: () => buildModels(),

package/lib/scnet-fetch.js

@@ -0,0 +1,153 @@
+/**
+ * 上游错误归一化
+ * ------------------------------------------------------------------
+ * 目的：让 SCNet 的「瞬时路由抖动」能被 DSH 的重试策略接住。
+ *
+ * 问题形状
+ * --------
+ * SCNet 网关在推理实例被回收/切换时会返回：
+ *
+ *   HTTP 503
+ *   {"error":{"message":"The model's routing or availability changed while
+ *    processing the request. Please try again.","type":"invalid_request_error",
+ *    "code":"10008"}}
+ *
+ * 即：**状态码是 5xx，但响应体里的 `type` 写的是 `invalid_request_error`**。
+ *
+ * DSH 侧的错误归类（`dsh-llm-pi-ai` 的 `classifyPiAiError`）按正则顺序扫描
+ * 错误文本，`invalid.?request` 那条规则排在 `5xx → SERVER` **前面**：
+ *
+ *   /\b400\b|invalid.?request/i  → INVALID_REQUEST   ← 先命中
+ *   /\b5\d\d\b/                  → SERVER            ← 永远轮不到
+ *
+ * 而 `INVALID_REQUEST` 不在默认可重试集合
+ * （`[EMPTY_RESPONSE, RATE_LIMIT, SERVER, TIMEOUT, TRANSPORT]`）里，
+ * 于是 DSH 把一次本可自愈的抖动判成本轮失败，一次都不重试。
+ *
+ * 做法
+ * ----
+ * 在 provider 的 fetch 上包一层：**只**针对「状态码 >= 500 且 body.type 是
+ * `invalid_request_error`」的响应，把 `type` 改写成 `api_error`（保持状态码与
+ * message 不变），让归类落到 `SERVER`，交给 DSH 的指数退避重试。
+ *
+ * 刻意**不**碰的：
+ *   - 真正的 400（如 `10013` 参数非法）——那确实不该重试；
+ *   - 401/403/402/429 —— 各自有明确语义，改写会误导上层；
+ *   - 2xx 响应 —— 原样透传，连 body 都不读，不影响流式。
+ */
+
+/** 会被改写的上游错误码（`code` 字段是字符串）。 */
+export const RETRYABLE_UPSTREAM_CODES = Object.freeze(['10008', '10009']);
+
+/**
+ * 判断一个上游错误是否应当被归一化成可重试的 `SERVER`。
+ *
+ * @param {number} status HTTP 状态码
+ * @param {any} body 已解析的响应体（可能不是 JSON）
+ * @returns {boolean}
+ */
+export function shouldNormalizeUpstreamError(status, body) {
+  if (!(status >= 500)) return false;
+  const error = body?.error;
+  if (!error || typeof error !== 'object') return false;
+  // 只处理「5xx 却自称 invalid_request」这种自相矛盾的形状。
+  if (error.type !== 'invalid_request_error') return false;
+  // 有 code 时只认已知的抖动码，避免把未知的 5xx 也一并改写。
+  if (typeof error.code === 'string' && error.code.length > 0) {
+    return RETRYABLE_UPSTREAM_CODES.includes(error.code);
+  }
+  return true;
+}
+
+/**
+ * 把错误体改写成 `api_error`（其余字段原样保留）。
+ *
+ * 保留原始 `code` 与 `message`，只是把 `type` 换成 DSH 归类器认得的服务端错误，
+ * 这样错误信息在 UI 上仍然可读、可搜。
+ *
+ * @param {any} body
+ * @returns {any}
+ */
+export function normalizeUpstreamErrorBody(body) {
+  return {
+    ...body,
+    error: { ...body.error, type: 'api_error' },
+  };
+}
+
+/**
+ * 构造一个「重试友好」的 fetch。
+ *
+ * 只在非 2xx 且命中 {@link shouldNormalizeUpstreamError} 时介入；其它情况原样
+ * 返回原始 Response（不读取 body，流式响应不受影响）。
+ *
+ * @param {{ fetchImpl?: typeof fetch, onNormalize?: (info: { status: number, code?: string, message?: string }) => void }} [options]
+ * @returns {typeof fetch}
+ */
+export function createRetryFriendlyFetch(options = {}) {
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+  if (typeof fetchImpl !== 'function') {
+    throw new Error('dsh-scnet-connect: no fetch implementation available');
+  }
+  return async function retryFriendlyFetch(input, init) {
+    const response = await fetchImpl(input, init);
+    if (response.ok) return response;
+
+    let raw;
+    try {
+      raw = await response.clone().text();
+    } catch {
+      return response;
+    }
+
+    let body;
+    try {
+      body = JSON.parse(raw);
+    } catch {
+      // 不是 JSON（例如 HTML 网关错误页）：保持原样，交给上层按状态码处理。
+      return response;
+    }
+
+    if (!shouldNormalizeUpstreamError(response.status, body)) return response;
+
+    const rewritten = normalizeUpstreamErrorBody(body);
+    try {
+      options.onNormalize?.({
+        status: response.status,
+        code: typeof body?.error?.code === 'string' ? body.error.code : undefined,
+        message: typeof body?.error?.message === 'string' ? body.error.message : undefined,
+      });
+    } catch {
+      // 日志回调失败不影响请求。
+    }
+
+    const headers = new Headers(response.headers);
+    headers.delete('content-length');
+    headers.set('content-type', 'application/json; charset=utf-8');
+    return new Response(JSON.stringify(rewritten), {
+      status: response.status,
+      statusText: response.statusText,
+      headers,
+    });
+  };
+}
+
+/**
+ * 用「重试友好」的 fetch 包一层 pi-ai 的 api 实现。
+ *
+ * pi-ai 的 `openai-completions` 会把 `options.fetch` 直接交给 OpenAI SDK
+ * （`createClient(..., fetch, ...)`），因此在这里注入即可覆盖整条请求链，
+ * 不需要改 DSH 或 pi-ai 本身。
+ *
+ * @param {{ stream: Function, streamSimple: Function }} api `openAICompletionsApi()` 的返回值
+ * @param {typeof fetch} fetchImpl
+ * @returns {{ stream: Function, streamSimple: Function }}
+ */
+export function withRetryFriendlyFetch(api, fetchImpl) {
+  const withFetch = (options) => ({ ...options, fetch: fetchImpl });
+  return {
+    ...api,
+    stream: (model, context, options) => api.stream(model, context, withFetch(options)),
+    streamSimple: (model, context, options) => api.streamSimple(model, context, withFetch(options)),
+  };
+}

package/lib/scnet-models.js

@@ -10,9 +10,15 @@
  *   2. SCNet 客户端自己的模型目录 `~/.sclaw/agent/models.json`
  *   3. 内置默认值
  *
- * 客户端对 `scnet-max` 有一条特殊上限（见其主进程代码
- * `if ("scnet-max" === id.toLowerCase()) contextWindow = min(ctx, 262144)`），
- * 插件跟随这条限制，避免声明了实际会被网关拒绝的上下文长度。
+ * 上下文/输出上限以**平台真实能力**为准，而不是客户端主进程里那条旧特判
+ * （`if ("scnet-max" === id.toLowerCase()) contextWindow = min(ctx, 262144)`）。
+ *
+ * 2026-11-09 直连实测（`tools/repro/` 同款调用方式）：
+ *   - 输入 ~973k tokens（2,000,000 中文字符）→ HTTP 200，`prompt_tokens: 972977`；
+ *   - 输入 ~1.07M tokens（2,200,000 中文字符）→ HTTP 400 `10013`；
+ *   → 真实上下文就是 1,048,576（1M），客户端的 262,144 只是它自己保守取值。
+ *   - `max_tokens: 131072` 流式请求被接受（客户端目录同样标 131072）。
+ * 若沿用 262144，DSH 会在 1/4 处就开始压缩上下文，白白浪费 3/4 的窗口。
  */
 
 /** 客户端目录里标记「免费」的 priceLabel 值。 */
@@ -24,6 +30,17 @@ export const DEFAULT_MODEL_ID = 'SCNet-Max';
 /** SCNet OpenAI 兼容网关根地址。 */
 export const DEFAULT_BASE_URL = 'https://api.scnet.cn/api/llm/v1';
 
+/**
+ * 兜底上下文窗口（1M）。
+ *
+ * 客户端模型目录不可用时的默认值；与平台实测能力一致（见文件头）。
+ * 客户端目录存在时仍以目录里的 `contextWindow` 为准。
+ */
+export const DEFAULT_CONTEXT_WINDOW = 1_048_576;
+
+/** 兜底最大输出（131072，平台实测接受该值）。 */
+export const DEFAULT_MAX_TOKENS = 131_072;
+
 /** node 侧无计费概念，全 0。 */
 export const NO_COST = Object.freeze({ input: 0, output: 0, cacheRead: 0, cacheWrite: 0 });
 
@@ -46,22 +63,6 @@ export const THINKING_LEVEL_MAP = Object.freeze({
   max: 'max',
 });
 
-/**
- * 客户端对 SCNet-Max 的有效上限（与客户端主进程一致）。
- * 其它模型只做「输出不超过上下文」的一致性约束。
- *
- * @param {string} modelId
- * @param {number} contextWindow
- * @param {number} maxTokens
- */
-function clampForModel(modelId, contextWindow, maxTokens) {
-  if (modelId.trim().toLowerCase() !== DEFAULT_MODEL_ID.toLowerCase()) {
-    return { contextWindow, maxTokens: Math.min(maxTokens, contextWindow) };
-  }
-  const ctx = Math.min(contextWindow, 262144);
-  return { contextWindow: ctx, maxTokens: Math.min(maxTokens, ctx, 32768) };
-}
-
 /**
  * 构造 pi-ai 的模型描述符。
  *
@@ -81,9 +82,8 @@ export function buildModel(options) {
   const meta = options.meta;
   const signedContextWindow = options.contextWindow && options.contextWindow > 0 ? options.contextWindow : undefined;
   const signedMaxTokens = options.maxTokens && options.maxTokens > 0 ? options.maxTokens : undefined;
-  const contextWindow = signedContextWindow ?? meta?.contextWindow ?? 262144;
-  const maxTokens = signedMaxTokens ?? meta?.maxTokens ?? 32768;
-  const clamped = clampForModel(modelId, contextWindow, maxTokens);
+  const contextWindow = signedContextWindow ?? meta?.contextWindow ?? DEFAULT_CONTEXT_WINDOW;
+  const maxTokens = signedMaxTokens ?? meta?.maxTokens ?? DEFAULT_MAX_TOKENS;
   const input = options.inputImages === false ? ['text'] : meta?.input?.length ? [...meta.input] : ['text', 'image'];
 
   return {
@@ -96,8 +96,10 @@ export function buildModel(options) {
     reasoning: options.reasoning !== false,
     ...(options.reasoning === false ? {} : { thinkingLevelMap: { ...THINKING_LEVEL_MAP } }),
     cost: { ...NO_COST },
-    contextWindow: clamped.contextWindow,
-    maxTokens: clamped.maxTokens,
+    contextWindow,
+    // 只保证「输出不超过上下文」这一条一致性；不再按模型 id 打 262144/32768 的补丁
+    // （那是客户端主进程的保守特判，实测网关支持 1M / 131072，见文件头）。
+    maxTokens: Math.min(maxTokens, contextWindow),
     compat: {
       // SCNet 网关是 vLLM/OpenAI 传统拼写：`max_tokens` 而不是 `max_completion_tokens`。
       maxTokensField: 'max_tokens',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-scnet-connect",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "把 SCNet 模型接入 DeepSeek Harness，可免客户端登录，使用免费模型（SCNet-Max，基座基本可确定为 DeepSeek Flash）",
   "type": "module",
   "main": "./lib/index.js",
@@ -46,7 +46,8 @@
     "@earendil-works/pi-ai": ">=1.0.0 <2.0.0"
   },
   "scripts": {
-    "check": "node tools/check.mjs"
+    "check": "node tools/check.mjs",
+    "check:fetch": "node tools/check-fetch.mjs && node tools/check-classify.mjs"
   },
   "repository": {
     "type": "git",