@huai_xin/dsh-workbuddy 0.1.10 → 0.1.12

package/package.json

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

package/src/adapter.js

@@ -13,6 +13,7 @@
  *   X-Product-Code: workbuddy, X-Agent-Purpose/Name/Type/Version, UA.
  */
 
+import { createHash, randomUUID } from 'node:crypto'
 import { writeFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
@@ -321,7 +322,7 @@ export class WorkBuddyAdapter {
   constructor(ctx, region) {
     this.ctx = ctx
     this.region = region
-    this.sessionId = crypto.randomUUID().replace(/-/g, '')
+    this.sessionId = randomUUID().replace(/-/g, '')
     this.catalog = undefined
     this.catalogAt = 0
     /** Where the current catalog came from: 'scoped' | 'config' | 'cache' | 'none'. */
@@ -358,7 +359,7 @@ export class WorkBuddyAdapter {
 
   /** A fresh conversation identity, used when the gateway rejects the old one. */
   rotateIdentity() {
-    this.sessionId = crypto.randomUUID().replace(/-/g, '')
+    this.sessionId = randomUUID().replace(/-/g, '')
   }
 
   /**
@@ -692,7 +693,24 @@ export class WorkBuddyAdapter {
     return chatRoutes(this.region)
   }
 
-  headers(token, route) {
+  /**
+   * Request headers, aligned with the official CodeBuddy CLI.
+   *
+   * The gateway validates them: a request without `X-Agent-Purpose` /
+   * `X-Conversation-*` / `X-IDE-*` is rejected with `400 code 11128 request illegal`
+   * (measured 2026-10-23), so these are not decoration. Three details come from the
+   * official bundle and were previously missing or wrong here:
+   *
+   * - `X-Agent-Intent` defaults to `craft` ("do the work" mode) there; omitting it
+   *   leaves the deployment to choose, which is the difference between an agent that
+   *   acts and one that only narrates.
+   * - `X-Conversation-Message-ID` / `X-Request-ID` identify *the message being
+   *   answered*, so they are derived from that message and stay stable when the same
+   *   step is retried, instead of a fresh random UUID per attempt.
+   * - `X-Agent-Runtime` / `X-Session-ID` / `X-Model-ID` say which runtime and model
+   *   the route is on.
+   */
+  headers(token, route, model, messageId) {
     return {
       Authorization: `Bearer ${token}`,
       Accept: 'text/event-stream',
@@ -701,21 +719,42 @@ export class WorkBuddyAdapter {
       'X-Product': 'SaaS',
       'X-Product-Code': route.productCode,
       'X-Agent-Purpose': 'conversation',
+      'X-Agent-Intent': 'craft',
+      'X-Agent-Runtime': 'local-agent',
       'X-IDE-Name': route.ideName,
       'X-IDE-Type': route.ideName,
       'X-IDE-Version': route.ideVersion,
       'User-Agent': route.userAgent,
+      'X-Session-ID': this.sessionId,
+      'X-Model-ID': model,
       'X-Conversation-ID': this.sessionId,
-      'X-Conversation-Message-ID': crypto.randomUUID(),
-      'X-Conversation-Request-ID': crypto.randomUUID()
+      'X-Conversation-Message-ID': messageId,
+      'X-Conversation-Request-ID': messageId,
+      'X-Request-ID': messageId
     }
   }
 
-  async send(token, body, signal, route) {
+  /**
+   * A stable id for the message being answered.
+   *
+   * The official client sends the message's own id in `X-Conversation-Message-ID` /
+   * `X-Request-ID`; a fresh random UUID per attempt (what this did before) tells the
+   * gateway every retry is a different message. Hashing the last user turn keeps the
+   * id stable across retries of one step and changes when the conversation moves on.
+   */
+  messageIdFor(options) {
+    const last = [...(options.messages ?? [])].reverse().find((message) => message.role === 'user')
+    const text = typeof last?.content === 'string'
+      ? last.content
+      : (Array.isArray(last?.content) ? last.content.map((block) => String(block?.text ?? '')).join('') : '')
+    return createHash('sha1').update(`${this.sessionId}:${text}`).digest('hex').slice(0, 32)
+  }
+
+  async send(token, body, signal, route, model, messageId) {
     try {
       return await fetch(`${route.endpoint}/v2/chat/completions`, {
         method: 'POST',
-        headers: this.headers(token, route),
+        headers: this.headers(token, route, model, messageId),
         body,
         signal
       })
@@ -734,10 +773,13 @@ export class WorkBuddyAdapter {
     }
     const imageUrls = await this.resolveImages(options.messages)
     const payload = () => JSON.stringify(this.buildBody(options, model, entry, imageUrls))
+    // The message being answered, hashed so every retry of the same step carries the
+    // same id (the official client uses the message's own id here).
+    const messageId = this.messageIdFor(options)
     const routes = this.routes()
     let route = routes[0]
 
-    let response = await this.send(token, payload(), options.signal, route)
+    let response = await this.send(token, payload(), options.signal, route, model, messageId)
     let rejection = ''
     if (!response.ok) {
       rejection = await response.text().catch(() => '')
@@ -750,12 +792,12 @@ export class WorkBuddyAdapter {
         dumpRejectedRequest(this.region, model, route, payload(), rejection)
         this.rotateIdentity()
         this.ctx.logger.warn(`[workbuddy] ${this.region.id}: 网关判为未获批渠道，已换会话标识重试一次`)
-        response = await this.send(token, payload(), options.signal, route)
+        response = await this.send(token, payload(), options.signal, route, model, messageId)
         rejection = response.ok ? '' : await response.text().catch(() => '')
         if (!response.ok && routes[1] !== undefined && isUnapprovedChannel(rejection)) {
           this.ctx.logger.warn(`[workbuddy] ${this.region.id}: 主通道仍被拒，改走 ${routes[1].endpoint}`)
           route = routes[1]
-          response = await this.send(token, payload(), options.signal, route)
+          response = await this.send(token, payload(), options.signal, route, model, messageId)
           rejection = response.ok ? '' : await response.text().catch(() => '')
         }
       } else if (response.status === 401 || response.status === 403) {
@@ -763,7 +805,7 @@ export class WorkBuddyAdapter {
         if (rotated.refreshed) {
           token = await readToken(this.ctx, this.region)
           if (token.length > 0) {
-            response = await this.send(token, payload(), options.signal, route)
+            response = await this.send(token, payload(), options.signal, route, model, messageId)
             rejection = response.ok ? '' : await response.text().catch(() => '')
           }
         }
@@ -975,19 +1017,22 @@ export class WorkBuddyAdapter {
     }
 
     const argsTruncated = [...toolCalls.values()].some((block) => isTruncatedArguments(block.text))
-    // A step that ends with prose and no tool call *looks* like the model choosing to
-    // stop, so nothing else records it — and "it stopped mid-answer" arrives as a bug
-    // report with no evidence. These two shapes are the ones seen in practice:
-    // an announcement that expects a next action ("……：" / "………") and a statement of
-    // inability ("我需要先读取…" / "我无法…"). Logging them with the raw reason and the
-    // text turns the next report into a fact.
-    if (streamEnded === true && toolOrder.length === 0 && (finishReason === 'stop' || finishReason === undefined)) {
-      const prose = blocks.find((block) => block.kind === 'text')?.text ?? ''
-      const tail = prose.trim()
-      const suspicious = /[:：…]$/.test(tail) || /(我需要|我没有|我无法|先读取|无法直接|不能直接)/.test(tail)
-      if (suspicious) {
-        this.ctx.logger.warn(`[workbuddy] ${this.region.id}: ${options.model} 疑似提前收尾（finish_reason=${finishReason ?? '(无)'}，输出 ${outputTokens ?? '未知'} tokens，无工具调用）：「${tail.slice(0, 60)}」`)
-      }
+    // A tool-call fragment whose name never arrived cannot be announced, so it never
+    // reaches `toolOrder` — and when upstream then ends with `stop`, the step reads as
+    // "the model chose to stop" while a call was in fact in flight. That is a silent
+    // drop, so it is reported instead: the harness keeps an honest failure, and the
+    // log names what happened.
+    const orphanCalls = [...toolCalls.values()].filter((block) => !hasUsableToolName(block.name) && block.text.trim().length > 0)
+    if (orphanCalls.length > 0) {
+      this.ctx.logger.warn(`[workbuddy] ${this.region.id}: ${options.model} 收到 ${orphanCalls.length} 个工具调用分片但始终没有工具名（finish_reason=${finishReason ?? '(无)'}），按传输错误上报，可自动重试`)
+      yield finishChunk({
+        kind: 'error',
+        failure: {
+          message: `${this.region.provider}: 上游发送了工具调用但没有给出工具名（finish_reason=${finishReason ?? '(无)'}；可重试的传输错误）`,
+          code: 'TRANSPORT'
+        }
+      })
+      return
     }
     // A stream that stops without the `[DONE]` sentinel was cut, not finished:
     // upstream closed the connection mid-answer. Reporting that as a normal stop