From b508d12350beb43a0a48a9ec2a97671e7d19a8bb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9B=B9=E5=BD=A6=E7=92=9010192537?= Date: Mon, 3 Aug 2026 11:48:43 +0800 Subject: [PATCH] fix(dispatch): handle structured UNKNOWN_FIELD errors in strip-and-retry MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Some upstream providers (e.g. Alibaba Cloud DashScope) reject an unrecognized request field with a structured error body instead of the English "Unsupported parameter: X" text that the reactive auto-compat loop matches on: {"code":"UNKNOWN_FIELD", "message":"未知请求字段:reasoning.effort", "data":{"field":"reasoning.effort"}} Because matchUnsupportedParameter only recognized the free-text "Unsupported parameter" phrasing, these structured unknown-field 400s bypassed the strip-and-retry mechanism entirely and the request failed outright instead of dropping the offending field and retrying the same target. Extend matchUnsupportedParameter to also parse structured error bodies that carry an unknown/unexpected-field code (UNKNOWN_FIELD, INVALID_PARAMETER, UNEXPECTED_PARAMETER) with the offending path in data.field / data.field_path / data.fieldPath, returning the canonical dotted path so the existing deleteDottedPath + strip-and-retry flow handles them identically to the text-based errors. Fixes #783 --- .../__tests__/dispatcher-auto-compat.test.ts | 62 +++++++++++++++++++ .../dispatch/dispatcher-auto-compat.ts | 43 +++++++++++++ 2 files changed, 105 insertions(+) diff --git a/packages/backend/src/services/__tests__/dispatcher-auto-compat.test.ts b/packages/backend/src/services/__tests__/dispatcher-auto-compat.test.ts index 87eec407c..6770eadc4 100644 --- a/packages/backend/src/services/__tests__/dispatcher-auto-compat.test.ts +++ b/packages/backend/src/services/__tests__/dispatcher-auto-compat.test.ts @@ -255,6 +255,56 @@ describe('matchUnsupportedParameter', () => { test('returns undefined for an empty body', () => { expect(matchUnsupportedParameter('')).toBeUndefined(); }); + + // Structured unknown-field errors (e.g. Alibaba Cloud DashScope) name the + // offending field in a machine-readable `data.field` member with a + // localized message and a `code` of UNKNOWN_FIELD, instead of the English + // "Unsupported parameter: X" text. See issue #783. + test('extracts the field from a structured UNKNOWN_FIELD body (#783)', () => { + const body = JSON.stringify({ + code: 'UNKNOWN_FIELD', + message: '未知请求字段:reasoning.effort', + data: { field: 'reasoning.effort' }, + traceId: 'trace_92b98af4-b0f9-4742-b50b-31f3ac25e824', + }); + expect(matchUnsupportedParameter(body)).toBe('reasoning.effort'); + }); + + test('extracts the field from a structured UNKNOWN_FIELD body with a dotted path', () => { + expect( + matchUnsupportedParameter( + '{"code":"UNKNOWN_FIELD","message":"unknown field","data":{"field":"text.verbosity"}}' + ) + ).toBe('text.verbosity'); + }); + + test('normalizes bracket notation in a structured UNKNOWN_FIELD field', () => { + expect( + matchUnsupportedParameter('{"code":"UNKNOWN_FIELD","data":{"field":"messages[0].name"}}') + ).toBe('messages.0.name'); + }); + + test('accepts data.field_path as an alternative key', () => { + expect( + matchUnsupportedParameter('{"code":"UNKNOWN_FIELD","data":{"field_path":"reasoning.effort"}}') + ).toBe('reasoning.effort'); + }); + + test('returns undefined for a structured body without the unknown-field code', () => { + expect( + matchUnsupportedParameter('{"code":"RATE_LIMITED","data":{"field":"reasoning.effort"}}') + ).toBeUndefined(); + }); + + test('returns undefined for a structured body without a data.field', () => { + expect( + matchUnsupportedParameter('{"code":"UNKNOWN_FIELD","message":"bad request"}') + ).toBeUndefined(); + }); + + test('returns undefined for a non-JSON body', () => { + expect(matchUnsupportedParameter('not json at all')).toBeUndefined(); + }); }); describe('deleteDottedPath', () => { @@ -598,6 +648,18 @@ describe('planUnsupportedParamStrip', () => { expect(state.attempts).toBe(0); }); + test('strips a field named by a structured UNKNOWN_FIELD body (#783)', () => { + const state = createUnsupportedParamStripState(); + const body = JSON.stringify({ + code: 'UNKNOWN_FIELD', + message: '未知请求字段:reasoning.effort', + data: { field: 'reasoning.effort' }, + }); + expect(planUnsupportedParamStrip(body, state)).toBe('reasoning.effort'); + expect(state.attempts).toBe(1); + expect(state.strippedParams.has('reasoning.effort')).toBe(true); + }); + test('structural guard: refuses to strip the whole messages/input/model field, consuming no budget', () => { // Deleting any of these wholesale guarantees a malformed request — every // retry would 400 on a missing-conversation/missing-model error instead, diff --git a/packages/backend/src/services/dispatch/dispatcher-auto-compat.ts b/packages/backend/src/services/dispatch/dispatcher-auto-compat.ts index fa9887445..a56db769c 100644 --- a/packages/backend/src/services/dispatch/dispatcher-auto-compat.ts +++ b/packages/backend/src/services/dispatch/dispatcher-auto-compat.ts @@ -456,10 +456,53 @@ function normalizeBracketSegments(path: string): string { */ export function matchUnsupportedParameter(responseBody: string): string | undefined { if (!responseBody) return undefined; + + // Structured error formats that name an unsupported/unknown field in a + // machine-readable location rather than a free-text "Unsupported + // parameter: X" message. Example (Alibaba Cloud DashScope): + // {"code":"UNKNOWN_FIELD","message":"未知请求字段:reasoning.effort","data":{"field":"reasoning.effort"}} + // Without this, a provider returning a localized/structured unknown-field + // error bypasses the strip-and-retry loop and the request fails outright. + const structured = matchStructuredUnknownField(responseBody); + if (structured) return structured; + const paramName = UNSUPPORTED_PARAMETER_PATTERN.exec(responseBody)?.[1]; return paramName === undefined ? undefined : normalizeBracketSegments(paramName); } +/** + * Matches structured upstream error bodies that report an unknown/unrecognized + * request field via a `data.field` (or `data.field_path`) member rather than an + * English "Unsupported parameter" message. Covers Alibaba Cloud DashScope + * ({"code":"UNKNOWN_FIELD",...,"data":{"field":"reasoning.effort"}}), + * which is the shape reported in #783. + * + * Returns the canonical (dotted) field path, or `undefined` when the body is + * not one of these structured shapes. + */ +function matchStructuredUnknownField(responseBody: string): string | undefined { + let parsed: any; + try { + parsed = JSON.parse(responseBody); + } catch { + return undefined; + } + if (!parsed || typeof parsed !== 'object') return undefined; + + // DashScope-style: { "code": "UNKNOWN_FIELD", "data": { "field": "..." } } + const code = typeof parsed.code === 'string' ? parsed.code.toUpperCase() : undefined; + const isUnknownField = + code === 'UNKNOWN_FIELD' || code === 'INVALID_PARAMETER' || code === 'UNEXPECTED_PARAMETER'; + if (!isUnknownField) return undefined; + + const data = parsed.data; + if (!data || typeof data !== 'object') return undefined; + const raw = data.field ?? data.field_path ?? data.fieldPath; + if (typeof raw !== 'string' || !raw) return undefined; + + return normalizeBracketSegments(raw); +} + /** Segment names that must never be traversed — see `deleteDottedPath`. */ const DANGEROUS_PATH_SEGMENTS = new Set(['__proto__', 'constructor', 'prototype']);