@feng0531/dsh-code-review 0.85.0 → 0.85.1

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 本文件介绍对使用者有意义的变化。安装与参数见 [README](README.md)，本次发布正文见 [发布说明](RELEASE-NOTES.md)。历史提交和安装包保留在 [GitHub Releases](https://github.com/f-e-n-g-0531/dsh-code-review/releases)；本文不把开发日志当作功能介绍。
 
+## 0.85.1 — 模型失败诊断与定向纠正
+
+- 修复宿主 error 终态详情读取位置，保留实际 `finish.reason.failure` 中的已知错误码、HTTP 状态和有效重试间隔，便于区分服务失败类别；不新增对鉴权、额度或取消的盲目重试。
+- 非法 JSON 记录固定语法分类、可用的行列位置及响应指纹，按最近一次分类定向请求重新生成；不回放错误原文，不自动修补 JSON，最多两次纠正且继续遵循原调用预算。
+- 新增诊断不保存模型响应片段或提供方原始 message，未知错误码和请求 ID 仅保留哈希；隔离进度回调对纠正诊断的修改，保持异常身份和 CR/LF/CRLF 定位一致。
+- 当前宿主没有原生 JSON mode／response schema 接口，本版不声称保证模型始终输出合法 JSON，也不以离线验证替代真实模型失败率复测。
+
 ## 0.85.0 — 审查失败恢复与全项目提速
 
 - 全项目独立批次默认 3 路并行，插件配置 projectConcurrency 支持 1～8；预览/报告显示并发数，结果仍按原批次顺序合并，保持共享调用上限和取消后等待全部清理。批内主审与复核不跳过，预算竞争时未完成文件仍待处理。

package/DEVELOPMENT.md

@@ -24,6 +24,16 @@
 
 运行 `node scripts/review-speed-benchmark.mjs` 比较相同 12 个 mock 批次在串行与 3 路并发下的耗时；脚本模拟每次模型调用 40ms 延迟，不访问网络、不证明真实模型速度或质量。核对工作量、调用数、完成数和输出顺序一致，不把降低覆盖作为加速。
 
+## 模型响应失败与诊断
+
+当前核验的 DSH `llm.stream` 接口没有原生 JSON mode／response schema 参数；插件不发送会被忽略的 `responseFormat`，也不把工具参数 schema 当作结构化输出保证。先要求纯 JSON，再做本地解析和阶段 schema、证据校验。
+
+正常 stop 后的非法 JSON 最多重新生成两次，共享原调用预算与取消信号；纠正请求只带固定语法分类和可用的行列位置，不回放错误响应、不自动修补 JSON、不删减发现来换取通过。语法位置相对于去掉外层空白及完整代码围栏后的 JSON 正文，偏移单位为 UTF-16 code unit；未知运行时错误文本回退到通用分类，不推测位置。
+
+失败结果的 `protocolDiagnostic` 保留语法分类、行列位置（可用时）和响应 SHA-256 指纹，不存储响应片段或原生解析异常文本。宿主服务错误从 `finish.reason.failure` 读取，保留已知错误码、HTTP 状态、有效重试间隔和请求 ID 的哈希；未知码只存分类及哈希，不存提供方 message、原始 ID、URL、headers 或 body。已有工具链直接抛出的异常仍保持身份，不新增自动网络重试；AUTH、QUOTA、取消及 error 终态不能按格式错误重发。指纹只是对照线索，不是原文备份，也不构成跨模型确定性保证。
+
+执行 `node --test test/model-diagnostics.test.mjs test/model-json-correction.test.mjs test/model-protocol-diagnostics.test.mjs test/dsh-model.test.mjs` 可验证本地纠正、失败归类和脱敏；宿主检查另覆盖真实 ToolRuntime 的纠正和服务失败事件，均为受控离线模型，不证明真实服务失败率下降。
+
 ## 审查预算
 
 除 README 中的文件和输入上限外：

package/RELEASE-NOTES.md

@@ -1,20 +1,19 @@
-# v0.85.0 发布说明
+# v0.85.1 发布说明
 
-## 全项目审核提速
+## 更可定位的模型失败
 
-全项目模式默认最多 3 个独立批准批次并行；批内主审、检索、复核仍按依赖顺序执行，不跳过文件或降低证据校验要求。插件配置 `projectConcurrency` 支持 1～8，设为 1 回退串行；预览与结构化报告展示实际配置。最终报告仍按原批次、文件顺序合并。共享模型调用上限覆盖检索、复核和纠正；取消或致命检查点失败后等待在途调用清理再释放会话锁，未发送文件保持待处理。
+修复宿主服务错误详情读取位置：从实际的 `finish.reason.failure` 取得已知错误码、HTTP 状态及有效重试间隔，不再因读取错字段而只留下 `Model did not complete: error`。提供方没有返回的细节仍不可推断；本版不新增自动网络重试。
 
-离线延迟模拟显示并行调度收益，但不是生产模型速度承诺，也不证明质量提升。实际速度取决于提供方并发、限流、批次均衡及检查点持久化；并行不减少模型调用量或保证 token 成本下降。并发上限按单次执行生效，不是跨会话 RPM/TPM 限流器；遇到 429 应降低配置。
+## 针对语法问题的有界纠正
 
-## 审查失败的有界恢复
+正常 stop 后的非法 JSON 现在记录固定语法分类、可用的正文行列位置和 SHA-256 响应指纹，并根据最近一次分类给出定向重新生成提示。偏移使用 JSON 正文的 UTF-16 单位，支持 CR、LF、CRLF；运行时未提供位置时明确不填，不虚构错误位置。
 
-- 模型正常结束但 JSON 无效时，最多两次显式重新生成；不正则修补损坏响应，不回灌无效输出，不重试取消、提供方错误、截断结束或超限输出。记录每次尝试的脱敏诊断和预算计数，不往阶段响应注入可能破坏 schema 的元数据。
-- 主审文件身份、严重性、必填字段或行证据校验失败时，最多请求一次完整响应纠正，仍执行严格校验，不自动更改身份、映射严重性或编造证据。
-- 全项目行号错位仅在同文件当前侧存在唯一精确文本时修正，保留原候选供审计；不跨文件、跨版本或模糊匹配，窗口限制继续生效。
-- 模型可见共享检索预算余量；整批动态范围与预算先预检，实际输出超限不部分发布结果或审计。预算耗尽后只允许一次最终答复，不扩大读取权限；已有有效候选保留，文件仍未完成，不以空 findings 视为通过。
+仍最多重新生成两次，继续共享原调用预算和取消信号；不回放错误响应，不正则修补 JSON，不删除发现来换取格式通过，最终结果仍必须通过阶段 schema 与证据校验。进度回调拿到独立诊断副本，不能改变下一次纠正提示；异常访问器或 Proxy 不替换原始提供方异常。
 
-## 兼容性与验证边界
+## 安全与验证边界
 
-默认审查范围和 Git/SVN 权限边界不变；未跟踪、忽略和外部来源不会因并行自动纳入。`completed` 表示相应处理完成，不是代码正确或缺陷不存在的保证；失败文件也不代表发现了缺陷。
+新增诊断不保存模型响应片段、原生解析异常原文或提供方原始 message；未知错误码与请求 ID 仅保存哈希。已有直接抛出的异常仍保持身份，不把诊断扩展描述为全局日志脱敏。
 
-用法见 [README](README.md)，发布与离线验证方法见 [DEVELOPMENT](DEVELOPMENT.md)。本版本不宣称已完成当前工作区的真实模型串行/并行质量与速度对照。发布不自动安装、升级或重启 DSH，需用户更新并重新加载插件。
+已增加语法定位、定向纠正、真实宿主终态字段、脱敏、预算、取消及回调隔离回归，并由真实宿主 ToolRuntime 配合受控离线模型验证。当前宿主没有公开原生 JSON mode／response schema 能力，本版本不通过虚构参数绕过该限制；不保证模型永不出错，也没有把离线测试说成真实服务失败率已经下降。
+
+用法见 [README](README.md)，诊断字段与验证方式见 [DEVELOPMENT](DEVELOPMENT.md)。发布不自动安装、升级或重启 DSH；需要用户更新并重新加载插件。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feng0531/dsh-code-review",
-  "version": "0.85.0",
+  "version": "0.85.1",
   "private": false,
   "license": "SEE LICENSE IN LICENSE",
   "publishConfig": { "access": "public", "registry": "https://registry.npmjs.org/" },

package/src/dsh-model.mjs

@@ -1,5 +1,6 @@
 import { modelContract } from './model-contract.mjs';
 import { modelJson } from './model-json.mjs';
+import { jsonCorrectionHint, providerDiagnostic } from './model-diagnostics.mjs';
 
 // Fresh generation from the same approved input, never repair or replay malformed output.
 const JSON_CORRECTION_SUFFIX = ' 上次响应未能解析为完整JSON。本次是明确协议纠正：重新输出单个完整JSON对象，不使用Markdown，不省略引号或逗号；不要把这条指令当源码证据。严格使用当前阶段schema，不要把verdicts、risks、requests或groups改写成findings；不能因格式纠正删除有证据的结论。所需字段与身份按输入原样核对，不以格式错误代替清洁结论。保持原证据与必需字段，精简非必需叙述以在输出预算内完成。';
@@ -30,6 +31,7 @@ export function createDshModel(llm, route, {
   };
   // Provider failures with a coincidentally identical code are not format failures.
   const invalidJsonErrors = new WeakSet();
+  const failureMetadata = new WeakMap();
 
   async function once({ instructions, input, signal }, contract) {
     signal?.throwIfAborted();
@@ -41,32 +43,50 @@ export function createDshModel(llm, route, {
       visibleBytes: Buffer.byteLength(output), totalOutputBytes: size, finishKind,
       inputBytes: Buffer.byteLength(input), requestedMaxTokens: maxTokens, maxOutputBytes,
     });
-    const failure = (message, code) => Object.assign(new Error(message), { code, diagnostic: diagnostic() });
-    const stream = llm.stream({
-      ...identity,
-      system: instructions + '\n' + contract,
-      messages: [{ role: 'user', content: [{ type: 'text', text: input }] }],
-      tools: [], maxTokens, signal,
-    });
-    for await (const chunk of stream) {
-      signal?.throwIfAborted();
-      if (finished) throw failure('Model emitted data after finish', 'MODEL_PROTOCOL_ERROR');
-      if (isToolCall(chunk)) throw failure('Review model attempted a tool call', 'MODEL_PROTOCOL_ERROR');
-      if (chunk.type === 'text-delta' || chunk.type === 'reasoning-delta') {
-        size += Buffer.byteLength(chunk.text);
-        if (size > maxOutputBytes) throw failure('Model output limit exceeded', 'MODEL_OUTPUT_LIMIT');
-        if (chunk.type === 'text-delta') output += chunk.text;
-      }
-      if (chunk.type === 'finish') {
-        finishKind = chunk.reason.kind;
-        if (finishKind !== 'stop') {
-          const error = failure('Model did not complete: ' + finishKind, 'MODEL_INCOMPLETE_OUTPUT');
-          const providerCode = chunk.reason.error?.code ?? chunk.reason.code;
-          if (typeof providerCode === 'string') error.diagnostic.providerCode = providerCode;
-          throw error;
+    const failure = (message, code) => {
+      const error = Object.assign(new Error(message), { code, diagnostic: diagnostic() });
+      failureMetadata.set(error, { code, diagnostic: error.diagnostic });
+      return error;
+    };
+    try {
+      const stream = llm.stream({
+        ...identity,
+        system: instructions + '\n' + contract,
+        messages: [{ role: 'user', content: [{ type: 'text', text: input }] }],
+        tools: [], maxTokens, signal,
+      });
+      for await (const chunk of stream) {
+        signal?.throwIfAborted();
+        if (finished) throw failure('Model emitted data after finish', 'MODEL_PROTOCOL_ERROR');
+        if (isToolCall(chunk)) throw failure('Review model attempted a tool call', 'MODEL_PROTOCOL_ERROR');
+        if (chunk.type === 'text-delta' || chunk.type === 'reasoning-delta') {
+          size += Buffer.byteLength(chunk.text);
+          if (size > maxOutputBytes) throw failure('Model output limit exceeded', 'MODEL_OUTPUT_LIMIT');
+          if (chunk.type === 'text-delta') output += chunk.text;
+        }
+        if (chunk.type === 'finish') {
+          finishKind = chunk.reason.kind;
+          if (finishKind !== 'stop') {
+            const error = failure('Model did not complete: ' + finishKind, 'MODEL_INCOMPLETE_OUTPUT');
+            Object.assign(error.diagnostic, providerDiagnostic(chunk.reason));
+            throw error;
+          }
+          finished = true;
         }
-        finished = true;
       }
+    } catch (error) {
+      // Keep thrown provider/cancellation identity, including frozen and primitive values.
+      // Only add safe structured metadata when the error permits it.
+      if (error && (typeof error === 'object' || typeof error === 'function') && !failureMetadata.has(error)) {
+        const safeDiagnostic = { ...diagnostic(), ...providerDiagnostic(error) };
+        failureMetadata.set(error, { code: safeDiagnostic.providerCode, diagnostic: safeDiagnostic });
+        try {
+          if (Object.isExtensible(error) && !Object.hasOwn(error, 'diagnostic')) {
+            Object.defineProperty(error, 'diagnostic', { value: structuredClone(safeDiagnostic), configurable: true, enumerable: true, writable: true });
+          }
+        } catch { /* Diagnostic accessors/proxies must not replace the primary failure. */ }
+      }
+      throw error;
     }
     // Cancellation during iterator cleanup/end must not become an invalid-JSON correction.
     signal?.throwIfAborted();
@@ -76,6 +96,7 @@ export function createDshModel(llm, route, {
     } catch (error) {
       error.diagnostic = { ...diagnostic(), ...error.diagnostic };
       invalidJsonErrors.add(error);
+      failureMetadata.set(error, { code: error.code, diagnostic: error.diagnostic });
       throw error;
     }
   }
@@ -90,24 +111,28 @@ export function createDshModel(llm, route, {
       let result;
       try {
         result = await once({ ...original, instructions: original.instructions +
-          (attempt > 1 ? JSON_CORRECTION_SUFFIX + ' 纠正次数：' + (attempt - 1) + '/' + correctionLimit + '。' : '') }, contract);
+          (attempt > 1 ? JSON_CORRECTION_SUFFIX + jsonCorrectionHint(attempts.at(-1)?.diagnostic) + ' 纠正次数：' + (attempt - 1) + '/' + correctionLimit + '。' : '') }, contract);
       } catch (error) {
-        attempts.push({ attempt, code: error?.code, diagnostic: error?.diagnostic });
+        const metadata = failureMetadata.get(error) ?? {};
+        failureMetadata.delete(error);
+        attempts.push({ attempt, ...structuredClone(metadata) });
         const invalidJson = invalidJsonErrors.delete(error);
         if (!invalidJson || attempt > correctionLimit) {
-          if (attempts.length > 1 && error && typeof error === 'object' && Object.isExtensible(error)) {
-            error.attempts = attempts;
-            if (invalidJson) {
-              error.message = 'Model response is not complete JSON after ' + (attempt - 1) +
-                ' explicit JSON correction(s) (' + attempt + ' model calls); correction budget exhausted; no malformed output accepted';
+          try {
+            if (attempts.length > 1 && error && typeof error === 'object' && Object.isExtensible(error)) {
+              Object.defineProperty(error, 'attempts', { value: structuredClone(attempts), configurable: true, enumerable: true, writable: true });
+              if (invalidJson) {
+                error.message = 'Model response is not complete JSON after ' + (attempt - 1) +
+                  ' explicit JSON correction(s) (' + attempt + ' model calls); correction budget exhausted; no malformed output accepted';
+              }
             }
-          }
+          } catch { /* Preserve provider identity even with hostile accessors/proxies. */ }
           throw error;
         }
         original.signal?.throwIfAborted();
         // Exactly one reservation per extra call; a thrown budget/cancellation veto is final.
         await request.onProtocolCorrection?.({
-          code: error.code, diagnostic: error.diagnostic, attempts: [...attempts],
+          ...structuredClone(metadata), attempts: structuredClone(attempts),
           action: 'explicit-json-correction', attempt: attempt + 1,
           correction: attempt, maxJsonCorrections: correctionLimit,
           notice: 'Additional model response requested; original output not repaired or accepted.',
@@ -119,7 +144,7 @@ export function createDshModel(llm, route, {
         // Out-of-band audit only: never inject metadata into stage-specific model schemas.
         await request.onProtocolEvent?.({
           action: 'json-correction-complete', attempt, corrections: attempt - 1,
-          attempts: [...attempts, { attempt, diagnostic: result.diagnostic }],
+          attempts: structuredClone([...attempts, { attempt, diagnostic: result.diagnostic }]),
           notice: 'Fresh complete JSON accepted; malformed outputs discarded; extra model calls occurred.',
         });
         original.signal?.throwIfAborted();

package/src/model-diagnostics.mjs

@@ -0,0 +1,62 @@
+import { createHash } from 'node:crypto';
+
+// Never persist provider messages, response excerpts, headers, URLs or raw request IDs.
+const digest = text => createHash('sha256').update(text).digest('hex');
+const own = (value, key) => {
+  try { const d = value != null ? Object.getOwnPropertyDescriptor(value, key) : undefined; return d && 'value' in d ? d.value : undefined; }
+  catch { return undefined; }
+};
+const PROVIDER_CODES = new Set(['RATE_LIMIT','CONTEXT_WINDOW_EXCEEDED','QUOTA','ACCOUNT_QUOTA','AUTH','AUTHENTICATION','INVALID_CREDENTIAL','MISSING_CREDENTIAL','PERMISSION','TIMEOUT','NETWORK','SERVER_ERROR','SERVER','SERVICE_UNAVAILABLE','INVALID_ARGS','INVALID_REQUEST','BAD_REQUEST','EMPTY_RESPONSE','UNKNOWN','NO_ADAPTER','ABORTED','CANCELLED']);
+export function providerDiagnostic(value) {
+  const carried = own(value, 'failure');
+  const code = own(carried, 'code') ?? own(value, 'code');
+  const status = own(carried, 'status') ?? own(value, 'status');
+  const retry = own(carried, 'providerRetryAfterMs') ?? own(value, 'providerRetryAfterMs');
+  const requestId = own(carried, 'requestId') ?? own(value, 'requestId');
+  return {
+    ...(typeof code === 'string' && code.length > 0 && code.length <= 256 ? { providerCode: PROVIDER_CODES.has(code) ? code : 'UNRECOGNIZED', ...(PROVIDER_CODES.has(code) ? {} : { providerCodeHash: digest(code) }) } : {}),
+    ...(Number.isInteger(status) && status >= 100 && status <= 599 ? { providerStatus: status } : {}),
+    ...(Number.isFinite(retry) && retry > 0 && retry <= 86400000 ? { providerRetryAfterMs: retry } : {}),
+    ...(typeof requestId === 'string' && requestId.length > 0 && requestId.length <= 512 ? { providerRequestIdHash: digest(requestId) } : {}),
+  };
+}
+
+const SYNTAX_HINTS = {
+  'property-name': '对象属性名必须使用双引号，不允许单引号、裸键或尾逗号。',
+  colon: '属性名与值之间必须有冒号。',
+  separator: '相邻属性或数组元素之间必须有逗号，结束处不可多加逗号。',
+  'invalid-escape': 'JSON 字符串中的反斜杠必须合法转义；换行、引号和路径须按 JSON 编码。',
+  'control-character': 'JSON 字符串中不能包含裸换行或控制字符，必须正确转义。',
+  'unterminated-string': '字符串必须闭合；不要用多行裸文本或截断字符串。',
+  'unexpected-end': '只输出一个语法完整且闭合的对象，不省略结尾。',
+  'trailing-content': 'JSON 对象结束后不得附加解释、第二个对象或 Markdown。',
+  syntax: '逐项检查双引号、转义、冒号、逗号和括号，输出完整严格 JSON。',
+};
+export function jsonSyntaxDiagnostic(body, error) {
+  const message = error instanceof SyntaxError ? error.message : '';
+  let category = 'syntax';
+  if (/^Expected (?:property name|double-quoted property name)/.test(message)) category = 'property-name';
+  else if (/^Expected ':'/.test(message)) category = 'colon';
+  else if (/^Expected ','/.test(message)) category = 'separator';
+  else if (/^Bad (?:escaped character|Unicode escape)/.test(message)) category = 'invalid-escape';
+  else if (/^Bad control character/.test(message)) category = 'control-character';
+  else if (/^Unterminated string/.test(message)) category = 'unterminated-string';
+  else if (/^Unexpected end of JSON input/.test(message)) category = 'unexpected-end';
+  else if (/^Unexpected non-whitespace character after JSON/.test(message)) category = 'trailing-content';
+  const match = / at position ([0-9]+)(?: \(line [0-9]+ column [0-9]+\))?$/.exec(message);
+  const offset = match ? Number(match[1]) : category === 'unexpected-end' ? body.length : undefined;
+  let location = {};
+  if (Number.isSafeInteger(offset) && offset >= 0 && offset <= body.length) {
+    const before = body.slice(0, offset);
+    const lines = before.split(/\r\n|\r|\n/);
+    location = { offset, line: lines.length, column: lines.at(-1).length + 1 };
+  }
+  return { syntaxCategory: category, ...location, offsetUnit: 'utf16-code-unit-in-json-body', responseHash: digest(body) };
+}
+export function jsonCorrectionHint(diagnostic) {
+  const category = diagnostic?.syntaxCategory;
+  if (typeof category !== 'string' || !Object.hasOwn(SYNTAX_HINTS, category)) return '';
+  const { line, column } = diagnostic;
+  const location = Number.isSafeInteger(line) && line > 0 && Number.isSafeInteger(column) && column > 0 ? '，JSON正文第' + line + '行第' + column + '列' : '';
+  return ' 本地解析诊断（不含原响应）：' + category + location + '。' + SYNTAX_HINTS[category];
+}

package/src/model-json.mjs

@@ -1,3 +1,5 @@
+import { jsonSyntaxDiagnostic } from './model-diagnostics.mjs';
+
 // Accept one complete JSON value, optionally inside one exact Markdown fence.
 // This parser never repairs bytes or invokes a model; orchestration owns corrections.
 export function modelJson(text) {
@@ -7,12 +9,12 @@ export function modelJson(text) {
   const body = fence ? fence[1] : trimmed;
   try {
     JSON.parse(body);
-  } catch {
+  } catch (parseError) {
     const envelope = fence ? 'json-fence' : 'plain';
     const shape = !trimmed ? 'empty' : trimmed.startsWith('```') && !fence ? 'non-exact-fence' : /^[{\[]/.test(body) ? 'json-like-invalid' : 'non-json-leading';
     const error = new Error('Model response is not complete JSON (bytes=' + bytes + ', envelope=' + envelope + ', shape=' + shape + '); no repair or retry performed by JSON parser');
     error.code = 'MODEL_INVALID_JSON';
-    error.diagnostic = { jsonBytes: bytes, envelope, shape };
+    error.diagnostic = { jsonBytes: bytes, envelope, shape, ...jsonSyntaxDiagnostic(body, parseError) };
     throw error;
   }
   return body;