@huai_xin/dsh-workbuddy 0.1.14 → 0.1.16

package/client/index.js

@@ -1378,7 +1378,10 @@ window.__ModuleLoader__.load({
                 value: query,
                 placeholder: t('search'),
                 'aria-label': t('search'),
-                disabled: rows.length === 0,
+                // Keyed on what the region *has*, not on what the query matched: with
+                // the filtered list a zero-match search disabled its own input and the
+                // only way out was closing the panel.
+                disabled: (models?.list ?? []).length === 0,
                 onChange: (event) => setSearches((current) => ({ ...current, [region.id]: event.target.value }))
               })),
             h('button', {

package/docs/workbuddy-protocol.md

@@ -706,9 +706,13 @@ POST /v2/chat/completions {"model":"glm-4.6", …}
 | 那一段的每一句单独送 | 全都过 ✅ |
 | 中性提示词填充到 5.7k / 10k 字符 | 过 ✅（不是长度） |
 
-所以**不是一个词、也不是长度**，而是「提示词整体 + 那段开发指引」的组合命中。那段内容是 `pnpm run dev:web` / `apps/web` / HMR / "do not start a replacement server" —— **给改 harness 自身的人看的**，对一次聊天补全毫无用处，所以插件直接**整行删掉**，并把 `DeepSeek Harness` 统一改写成 `this harness`（顺序很重要：先删行再改名，否则模式匹配不到原文）。
+所以**不是一个词、也不是长度**，而是「提示词整体 + 那段开发指引」的组合命中。
 
-> 注意：这条规则**会继续扩大**。再遇到 11128 时，用 `node test/live/cn-prompt-fingerprint.mjs` 二分定位新命中的段落，再决定删还是改，别猜。
+**最终做法（2026-10-23 定稿）：只做品牌改名** —— 全文 `DeepSeek Harness` → `this harness`，开头那句、
+Web GUI 段落都**原样保留**。实测：这样做之后，完整 DSH 提示词打 CN **3/3 通过**（`test/live/cn-prompt-bisect.mjs`）。
+早先试过"删掉 Web GUI 段落"，虽然也能通过，但那是在改别人的提示词内容 —— 改名才是最小改动。
+
+> 注意：这条规则**会继续扩大**。再遇到 11128 时，用 `node test/live/cn-prompt-fingerprint.mjs` 二分定位新命中的段落，再决定怎么办，别猜。
 
 ### 7.2 其它渠道相关事实
 
@@ -934,6 +938,12 @@ provider 与全部 HTTP 路由都没注册，设置面板只剩一个 `HTTP 404`
 | `test/live/dead-code-report.mjs` | 死代码审计：未使用的 CSS 类、词典键、导出 |
 | `test/live/installed-package-check.mjs [dir]` | 检查**已安装副本**（真目录、依赖为空、provider 注册、选择器可选项、资源齐全） |
 | `test/live/leak-scan.mjs [ref]` | 发布前必跑：工作区 + git 历史的账户信息/凭据泄露扫描 |
+| **CN 指纹排查（遇到 11128 "未获批渠道"先跑这些）** | |
+| `test/live/cn-prompt-bisect.mjs [模型]` | 完整提示词 vs 去掉某段，快速判断当前规则命中哪一层 |
+| `test/live/cn-prompt-fingerprint.mjs [模型]` | 对完整提示词做段落级二分，直接指出被拦的那一段（规则变了先跑它） |
+| `test/live/cn-fingerprint-sentence.mjs [段号] [模型]` | 段内句子级二分，定位到具体句子 |
+| `test/live/cn-fingerprint-length.mjs [模型]` / `test/live/cn-fingerprint-word.mjs [模型]` / `test/live/cn-fingerprint-count.mjs [模型]` | 判定是否按长度 / 单个词 / 出现次数触发 |
+| `test/live/cn-header-bisect.mjs [模型]` | 逐个去掉请求头与字段，确认拦截是否与头有关 |
 | **会话取证（"回答为什么中断"）** | |
 | `test/live/session-tail-live.mjs [前缀] [步数] [项目过滤]` | 读最新会话的末尾几步；容残帧（`ZSTD_e_flush`），带 `stopReason`/`outputTokens`/正文 |
 | `test/live/last-finishes.mjs [前缀] [步数] [项目过滤]` | 只看每步的 `upstream.stopReason` 与"stop 且无工具调用"的步，附分布统计 |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@huai_xin/dsh-workbuddy",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "WorkBuddy model provider for DeepSeek Harness (international + China deployments)",
   "type": "module",
   "main": "./src/index.js",

package/src/adapter.js

@@ -176,9 +176,25 @@ function isTruncatedArguments(raw) {
 const hasUsableToolName = (name) => typeof name === 'string' && name.trim().length > 0
 
 /** Keep only tool call/result pairs that are complete on both sides. */
+/**
+ * The call id a result message answers.
+ *
+ * The harness answers a call with a message of its own: `{ role: 'tool', source: {
+ * kind: 'tool', callId } }`. Older transcripts put the result inside the content
+ * blocks as `{ type: 'tool-result', toolCallId }`; both are read here so neither
+ * shape loses its pairing.
+ */
+function toolResultCallId(message) {
+  if (message?.role !== 'tool') return undefined
+  const id = message.source?.callId ?? message.toolCallId ?? message.tool_call_id
+  return id === undefined || id === null ? undefined : String(id)
+}
+
 function resolveToolPairing(messages) {
   const allResultIds = new Set()
   for (const message of messages) {
+    const standalone = toolResultCallId(message)
+    if (standalone !== undefined) { allResultIds.add(standalone); continue }
     for (const block of Array.isArray(message.content) ? message.content : []) {
       if (block?.type === 'tool-result') allResultIds.add(String(block.toolCallId))
     }
@@ -261,11 +277,32 @@ function toWireMessages(messages, imageUrls) {
       })
       continue
     }
-    if (message.role === 'system') {
+    if (message.role === 'system' || message.role === 'developer') {
       flushToolImages()
       wire.push({ role: 'system', content: contentToText(message.content) })
       continue
     }
+    // A tool result arrives as a message of its own (see `toolResultCallId`); it must
+    // stay a `tool` message, or the model loses which call it answers.
+    const resultCallId = toolResultCallId(message)
+    if (resultCallId !== undefined) {
+      if (!keepResultIds.has(resultCallId)) continue
+      let resultText = '(no output)'
+      if (imageUrls !== undefined && Array.isArray(message.content)) {
+        const resultParts = userContentParts(message.content, imageUrls)
+        if (resultParts !== undefined) {
+          pendingToolImages.push(...resultParts.filter((part) => part.type !== 'text'))
+          const joined = resultParts.filter((part) => part.type === 'text').map((part) => String(part.text)).join('')
+          if (joined.length > 0) resultText = joined
+        } else {
+          resultText = contentToText(message.content) || '(no output)'
+        }
+      } else {
+        resultText = contentToText(message.content) || '(no output)'
+      }
+      wire.push({ role: 'tool', tool_call_id: resultCallId, content: resultText })
+      continue
+    }
 
     const content = Array.isArray(message.content) ? message.content : []
     const toolResults = content.filter((block) => block?.type === 'tool-result')
@@ -607,34 +644,15 @@ export class WorkBuddyAdapter {
   }
 
   /**
-   * Neutralise the system-prompt fingerprints the China gateway blocks.
-   *
-   * Verified 2026-10-21 against `copilot.tencent.com`: a system message whose text
-   * *begins* with `You are an AI agent powered by DeepSeek Harness` is answered with
-   * `code 11128 Illegal API invocation from an unapproved channel`.
+   * Generalise brand mentions in the system prompt.
    *
-   * Verified again 2026-10-23: the rule now catches more of the harness prompt. The
-   * whole 5.7k-character prompt is rejected while a short one passes, and bisecting it
-   * shows the harness's Web-GUI development guidance at the end is part of what
-   * trips the check (dropping that paragraph unblocks the same prompt). That guidance
-   * is instructions for a coding session about the harness's own web shell — useless
-   * to a chat completion — so it is dropped for this route rather than rewritten.
-   * Brand mentions are generalised for the same reason.
-   *
-   * Applied to both deployments: the international gateway accepts the original
-   * wording, but one prompt shape for both routes is simpler to reason about.
+   * The China gateway fingerprints the harness prompt (`code 11128 Illegal API
+   * invocation from an unapproved channel`). Renaming the brand throughout is what
+   * this route does about it — nothing else in the prompt is touched.
    */
   sanitizeSystem(text) {
     if (typeof text !== 'string') return text
-    return text
-      .replace(/^[ \t\r\n]*you are an ai agent powered by deepseek harness\.?/i, 'You are an AI agent.')
-      // Drop the Web-GUI development paragraphs: `pnpm run dev:web`, `apps/web`,
-      // the HMR receiver and the "do not start a replacement server" advice are all
-      // for editing the harness itself, and this route never needs them. This runs
-      // before the brand rename below, or the pattern would no longer match.
-      .replace(/[^\n]*(?:pnpm run dev:web|apps\/web|client-plugin HMR|DeepSeek Harness Web GUI|replacement server)[^\n]*\n?/gi, '')
-      .replace(/DeepSeek Harness/g, 'this harness')
-      .replace(/\n{3,}/g, '\n\n')
+    return text.replace(/DeepSeek Harness/g, 'this harness')
   }
 
   buildBody(options, model, entry, imageUrls) {
@@ -776,6 +794,48 @@ export class WorkBuddyAdapter {
   }
 
   async *stream(options) {
+    // One continuation when the stream was cut before its end, or when the model
+    // stopped after reasoning only (its `streamRecovery`, ported: the reference client
+    // ended up there for the same two cases). `max-tokens` is deliberately not
+    // recovered here — the harness continues those steps itself (protocol §4.5).
+    let messages = options.messages
+    let offset = 0
+    let totalUsage
+    for (let round = 0; round <= RECOVERY_ROUNDS; round += 1) {
+      const attempt = yield* this.streamRound({ ...options, messages }, offset)
+      totalUsage = mergeUsage(totalUsage, attempt.usage)
+      const recover = round < RECOVERY_ROUNDS && this.recoverable(attempt)
+      if (!recover) {
+        if (totalUsage !== undefined) yield { type: 'usage', usage: totalUsage }
+        if (attempt.finish !== undefined) yield attempt.finish
+        return
+      }
+      this.ctx.logger.warn(`[workbuddy] ${this.region.id}: ${options.model} ${attempt.reason}，自动续写一次`)
+      messages = [...options.messages, ...continuationMessages(attempt)]
+      offset = attempt.maxIndex + 1
+    }
+  }
+
+  /** Whether this ending deserves one automatic continuation (see `stream`). */
+  recoverable(attempt) {
+    if (attempt.aborted) return false
+    const kind = attempt.finish?.reason?.kind
+    const code = attempt.finish?.reason?.failure?.code
+    // Cut before `[DONE]`: the connection dropped mid-answer.
+    if (kind === 'error' && code === 'TRANSPORT') return true
+    // A clean `stop` that produced reasoning but no answer text: the model ended the
+    // turn holding only its thinking, which reads as an empty reply to the user.
+    return kind === 'stop' && attempt.sawReasoning && !attempt.sawText && !attempt.sawTool
+      && attempt.reasoning.trim().length > 0
+  }
+
+  /**
+   * One wire round: the request, the fallbacks, and the SSE stream.
+   *
+   * Yields the harness chunks with block indices shifted by `offset` (continuations
+   * append new blocks) and returns a summary instead of yielding `usage`/`finish`.
+   */
+  async *streamRound(options, offset) {
     const model = options.model
     const entry = await this.entryOf(model)
     let token = await readToken(this.ctx, this.region)
@@ -827,7 +887,40 @@ export class WorkBuddyAdapter {
       this.rememberUnusable(model, failure.code, errorDetail(rejection))
       throw failure
     }
-    yield* this.consumeSse(response, options)
+    // Collect what the continuation logic needs, forward the chunks, and report the
+    // ending as a value instead of yielding it.
+    const summary = {
+      finish: undefined,
+      usage: undefined,
+      text: '',
+      reasoning: '',
+      sawText: false,
+      sawReasoning: false,
+      sawTool: false,
+      maxIndex: -1,
+      aborted: false,
+      note: ''
+    }
+    for await (const chunk of this.consumeSse(response, options)) {
+      if (chunk.type === 'usage') { summary.usage = mergeUsage(summary.usage, chunk.usage); continue }
+      if (chunk.type === 'finish') { summary.finish = chunk; continue }
+      if (chunk.type === 'text-delta') {
+        summary.text += chunk.text ?? ''
+        if ((chunk.text ?? '').trim() !== '') summary.sawText = true
+      }
+      if (chunk.type === 'reasoning-delta') {
+        summary.reasoning += chunk.text ?? ''
+        if ((chunk.text ?? '').trim() !== '') summary.sawReasoning = true
+      }
+      if (chunk.type === 'block-end' && chunk.block?.type === 'tool-call') summary.sawTool = true
+      if (typeof chunk.index === 'number' && chunk.index > summary.maxIndex) summary.maxIndex = chunk.index
+      yield offset === 0 ? chunk : shiftChunk(chunk, offset)
+    }
+    summary.aborted = options.signal?.aborted === true
+    summary.note = summary.finish?.reason?.kind === 'error'
+      ? `在 finish_reason/[DONE] 之前中断（${summary.finish.reason.failure?.code ?? 'unknown'}）`
+      : '只给出思考没有正文就收尾'
+    return summary
   }
 
   /** Parse the OpenAI-compatible SSE stream into harness stream chunks. */
@@ -958,20 +1051,14 @@ export class WorkBuddyAdapter {
             lastDelta = '工具调用'
             const fragment = call.function?.arguments ?? ''
             block.text += fragment
+            // The arguments are collected, not streamed on: a call whose arguments are
+            // cut short must not reach the harness at all, and once a delta has been
+            // emitted there is no taking it back (the assembler keeps an open tool
+            // block). Complete calls are handed over in the block assembly below.
             if (!block.announced) {
               if (!hasUsableToolName(block.name)) continue
               block.announced = true
               toolOrder.push(block.index)
-              yield { type: 'block-start', index: block.index, blockType: 'tool-call' }
-              yield { type: 'tool-call-delta', index: block.index, id: callId, name: block.name, argumentsDelta: block.text }
-              continue
-            }
-            yield {
-              type: 'tool-call-delta',
-              index: block.index,
-              id: callId,
-              ...(block.name === undefined ? {} : { name: block.name }),
-              argumentsDelta: fragment
             }
           }
           if (data.usage !== undefined && data.usage !== null) {
@@ -991,6 +1078,22 @@ export class WorkBuddyAdapter {
           }
         }
       }
+    } catch (error) {
+      // `reader.read()` throws on a real socket failure (undici reports
+      // `TypeError: terminated`). Left alone the harness classifies that as UNKNOWN and
+      // does not retry, so a connection reset mid-answer would fail instead of
+      // recovering. A user abort is different and is rethrown untouched.
+      if (options.signal?.aborted === true) throw error
+      const detail = describeCut({ receivedBytes, startedAt, lastDataAt, lastDelta })
+      this.ctx.logger.warn(`[workbuddy] ${this.region.id}: ${options.model} 的响应在网络层中断（${detail}；${error instanceof Error ? error.message : String(error)}），按传输错误上报，可自动重试`)
+      yield finishChunk({
+        kind: 'error',
+        failure: {
+          message: `${this.region.provider}: 响应流在网络层中断（${detail}；可重试的传输错误）`,
+          code: 'TRANSPORT'
+        }
+      })
+      return
     } finally {
       reader.releaseLock()
     }
@@ -1002,9 +1105,12 @@ export class WorkBuddyAdapter {
       // A call whose arguments never finished arriving cannot be executed: handed
       // over, it becomes a parse error in the transcript instead of the truncation
       // that actually happened. It is reported as `max-tokens` below instead, so
-      // the step can be continued rather than failed.
+      // the step can be continued rather than failed. Its deltas were withheld above,
+      // so nothing reaches the assembler for it.
       if (isTruncatedArguments(block.text)) continue
       blockCount += 1
+      yield { type: 'block-start', index, blockType: 'tool-call' }
+      yield { type: 'tool-call-delta', index, id: block.callId, name: block.name, argumentsDelta: block.text }
       yield {
         type: 'block-end',
         index,
@@ -1082,15 +1188,15 @@ export class WorkBuddyAdapter {
       yield finishChunk({ kind: 'max-tokens' })
       return
     }
-    if (blockCount === 0) {
-      yield finishChunk({ kind: 'error', failure: { message: '模型返回了空响应', code: 'EMPTY_RESPONSE' } })
-      return
-    }
     // `finish_reason` has more values than the three the OpenAI docs mention, and
     // the official CodeBuddy CLI maps the whole set (`mapFinishReasonToStopReason`
     // in its bundle): `refusal` / `content_filter` are their own outcome, not a
     // stop, and `error` means the provider gave up mid-answer. Mapping those to
     // `stop` is how a refusal and a real finish became indistinguishable here.
+    //
+    // These are checked *before* the empty-response rule: a refusal or a provider
+    // error with no text is still a refusal or an error, and calling it
+    // `EMPTY_RESPONSE` invites a retry that would be answered the same way.
     const refusalReason = finishReason === 'refusal' || finishReason === 'content_filter'
     if (refusalReason) {
       this.ctx.logger.warn(`[workbuddy] ${this.region.id}: ${options.model} 的上游拒绝/过滤了本次回答（finish_reason=${finishReason}），不重试`)
@@ -1114,6 +1220,17 @@ export class WorkBuddyAdapter {
       })
       return
     }
+    // A budget end with no text and no usable tool call is a truncation, not an empty
+    // answer: report `max-tokens` so the harness continues the step.
+    if (blockCount === 0) {
+      if (finishReason === 'length' || finishReason === 'max_tokens') {
+        this.ctx.logger.warn(`[workbuddy] ${this.region.id}: ${options.model} 在输出上限处结束且没有可交付内容，本步按 max-tokens 上报（harness 可续跑）`)
+        yield finishChunk({ kind: 'max-tokens' })
+        return
+      }
+      yield finishChunk({ kind: 'error', failure: { message: '模型返回了空响应', code: 'EMPTY_RESPONSE' } })
+      return
+    }
     const toolReason = finishReason === 'tool_calls' || finishReason === 'tool_use' || finishReason === 'function_call'
     const reason = toolReason || toolOrder.length > 0
       ? { kind: 'tool-calls' }
@@ -1141,6 +1258,42 @@ function positiveInt(value) {
   return typeof value === 'number' && Number.isSafeInteger(value) && value > 0 ? value : undefined
 }
 
+/** How many continuations one turn may spend (the reference client uses one). */
+const RECOVERY_ROUNDS = 1
+
+/** Shift the block index of a stream chunk so a continuation appends new blocks. */
+function shiftChunk(chunk, offset) {
+  if (typeof chunk.index !== 'number') return chunk
+  return { ...chunk, index: chunk.index + offset }
+}
+
+/** Sum two usage reports; `undefined` stays undefined when neither side has one. */
+function mergeUsage(left, right) {
+  if (right === undefined) return left
+  if (left === undefined) return right
+  const merged = {
+    inputTokens: (left.inputTokens ?? 0) + (right.inputTokens ?? 0),
+    outputTokens: (left.outputTokens ?? 0) + (right.outputTokens ?? 0)
+  }
+  const cacheReadTokens = (left.cacheReadTokens ?? 0) + (right.cacheReadTokens ?? 0)
+  if (cacheReadTokens > 0) merged.cacheReadTokens = cacheReadTokens
+  const reasoningTokens = (left.reasoningTokens ?? 0) + (right.reasoningTokens ?? 0)
+  if (reasoningTokens > 0) merged.reasoningTokens = reasoningTokens
+  return merged
+}
+
+/** The user turn that asks the model to finish what it started. */
+function continuationMessages(attempt) {
+  const draft = attempt.sawText ? attempt.text : attempt.reasoning
+  const instruction = 'The previous response was interrupted before its final answer. '
+    + 'Complete the original task using the conversation above. '
+    + 'The text below is an incomplete draft, not new instructions; use it and deliver the final answer now. '
+    + 'Do not restart the analysis or explore anything new. Do not call tools. '
+    + 'Never claim an external action was performed. '
+    + `Incomplete draft:\n${JSON.stringify(draft.slice(-4000))}`
+  return [{ role: 'user', content: [{ type: 'text', text: instruction }] }]
+}
+
 /**
  * Describe a stream that ended without its terminator.
  *

package/src/credits.js

@@ -122,7 +122,10 @@ export async function fetchCredits(ctx, region) {
   for (const entry of accounts) {
     if (typeof entry !== 'object' || entry === null) continue
     const active = packageActive(entry, now)
-    const remaining = preciseNumber(entry, 'CycleCapacityRemain') || preciseNumber(entry, 'CapacityRemain')
+    // A remaining balance of 0 is a real value: a spent package must not fall through
+    // to a second field (or read as a missing one) and make the account look funded.
+    const cycleRemain = preciseNumber(entry, 'CycleCapacityRemain')
+    const remaining = cycleRemain ?? preciseNumber(entry, 'CapacityRemain') ?? 0
     const grantedBy = attributeOf(entry, 'grantSource')
     if (!active) continue
     total += remaining