From 026cf8870667ba4e508610abf1aa9d1a89ab631a Mon Sep 17 00:00:00 2001
From: yorha9e <hzw2559099601@gmail.com>
Date: Wed, 22 Jul 2026 20:09:49 +0800
Subject: [PATCH 1/2] fix(kosong): conservative max_tokens fallback for custom
 Anthropic-compatible endpoints

Custom Anthropic-compatible endpoints (e.g., Volcano Ark, DeepSeek) often
enforce a lower output token limit than the 128000 FALLBACK_MAX_TOKENS
designed for official Claude models. This causes immediate 400 rejections
for any non-Claude model on these endpoints.

Two-layer fix:

1. Conservative fallback: resolveDefaultMaxTokens now accepts an optional
   baseUrl parameter. When the endpoint is custom (non-Anthropic) and the
   model is not a recognized Claude, the fallback drops from 128000 to
   32768 (the most common ceiling among compatible providers).

2. Error-driven recovery: when a 400 response mentions a max_tokens limit,
   parseMaxTokensLimit extracts the provider's declared ceiling, and the
   v2 request loop clamps the completion budget and retries once. The
   discovered limit is cached per model so subsequent requests start
   pre-clamped.

Closes #2062
---
 .changeset/anthropic-max-tokens-fallback.md   |  5 +
 .../agent/llmRequester/llmRequesterService.ts | 43 ++++++++-
 .../src/kosong/contract/errors.ts             | 30 ++++++
 .../provider/bases/anthropic/anthropic.ts     | 19 +++-
 .../llmRequester/llmRequesterService.test.ts  | 92 +++++++++++++++++++
 .../test/kosong/contract/errors.test.ts       | 23 +++++
 .../test/kosong/provider/composition.test.ts  | 35 +++++++
 packages/kosong/src/errors.ts                 | 30 ++++++
 packages/kosong/src/providers/anthropic.ts    | 21 ++++-
 packages/kosong/test/anthropic.test.ts        | 26 ++++++
 packages/kosong/test/errors.test.ts           | 33 +++++++
 11 files changed, 344 insertions(+), 13 deletions(-)
 create mode 100644 .changeset/anthropic-max-tokens-fallback.md

diff --git a/.changeset/anthropic-max-tokens-fallback.md b/.changeset/anthropic-max-tokens-fallback.md
new file mode 100644
index 0000000000..71c9e64db6
--- /dev/null
+++ b/.changeset/anthropic-max-tokens-fallback.md
@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": patch
+---
+
+Fix 400 rejections from Anthropic-compatible providers that enforce a lower max_tokens output limit than the default 128000 fallback. Custom endpoints now use a conservative 32768 default, and a rejected request is automatically retried with the provider's declared limit.
diff --git a/packages/agent-core-v2/src/agent/llmRequester/llmRequesterService.ts b/packages/agent-core-v2/src/agent/llmRequester/llmRequesterService.ts
index e8589fdd74..07c2d0e8c0 100644
--- a/packages/agent-core-v2/src/agent/llmRequester/llmRequesterService.ts
+++ b/packages/agent-core-v2/src/agent/llmRequester/llmRequesterService.ts
@@ -8,8 +8,10 @@
  * params, then drives a bounded request chain through the `ModelRequester`
  * resolved from `IModelCatalog`: one primary `requester.request(input, signal,
  * params)` attempt plus projection rebuilds for request structure or media
- * compatibility; general retry policy remains in the loop's `stepRetry`
- * plugin. Before each request the projected messages pass through `media`'s
+ * compatibility and a one-shot completion-budget clamp when the provider
+ * rejects `max_tokens` (the server-declared ceiling is remembered per model,
+ * so each model pays for at most one rejected-and-resent request); general
+ * retry policy remains in the loop's `stepRetry` plugin. Before each request the projected messages pass through `media`'s
  * video resolver, which rewrites every `kimi-file://` prompt-video reference
  * to a provider-acceptable part (uploaded `ms://`, inline base64, or a
  * `<video path>` tag) so the internal reference never reaches the wire. When a
@@ -53,6 +55,7 @@ import {
   isImageFormatError,
   isRecoverableRequestStructureError,
   isRetryableGenerateError,
+  parseMaxTokensLimit,
 } from '#/kosong/contract/errors';
 import { type Message } from '#/kosong/contract/message';
 import { type ThinkingEffort } from '#/kosong/contract/provider';
@@ -147,6 +150,8 @@ export class AgentLLMRequesterService implements IAgentLLMRequesterService {
   private readonly mediaDegradedTurns = new Set<number>();
   private readonly mediaStrippedTurns = new Map<number, MediaStripSnapshot>();
   private readonly emittedThinkingEffortWarnings = new Set<string>();
+  /** Server-declared `max_tokens` ceilings learned from a rejected request, keyed by wire model name. */
+  private readonly maxTokensClamps = new Map<string, number>();
 
   constructor(
     @IAgentContextMemoryService private readonly context: IAgentContextMemoryService,
@@ -284,6 +289,7 @@ export class AgentLLMRequesterService implements IAgentLLMRequesterService {
   ): Promise<AgentLLMRequestFinish> {
     const shaped = this.toolSelect.shapeHistory(request.messages);
     let mediaStripSnapshot = this.mediaStripSnapshotForTurn(request.source);
+    let params = this.applyMaxTokensClamp(request.model.name, request.params);
     const requestInput = (projection: RequestProjection) => {
       return {
         systemPrompt: request.systemPrompt,
@@ -325,7 +331,7 @@ export class AgentLLMRequesterService implements IAgentLLMRequesterService {
         modelName: request.model.name,
         modelAlias: request.modelAlias,
         thinkingEffort: request.thinkingEffort,
-        maxTokens: effectiveMaxCompletionTokens(request.params),
+        maxTokens: effectiveMaxCompletionTokens(params),
         systemPrompt: input.systemPrompt,
         tools: input.tools,
         messages: input.messages,
@@ -350,7 +356,7 @@ export class AgentLLMRequesterService implements IAgentLLMRequesterService {
       };
 
       for await (const event of request.requester.request(input, signal, {
-        ...request.params,
+        ...params,
         onTraceId: setTraceId,
       })) {
         switch (event.type) {
@@ -457,6 +463,26 @@ export class AgentLLMRequesterService implements IAgentLLMRequesterService {
           projection = 'strict';
           continue;
         }
+        if (raw instanceof APIStatusError && raw.statusCode === 400) {
+          const maxTokensLimit = parseMaxTokensLimit(raw.message);
+          if (
+            maxTokensLimit !== null &&
+            maxTokensLimit < (params.maxCompletionTokens ?? Number.POSITIVE_INFINITY)
+          ) {
+            signal?.throwIfAborted();
+            this.log.warn(
+              'provider rejected the completion-token budget; resending with clamped max tokens',
+              {
+                model: request.model.name,
+                maxTokens: maxTokensLimit,
+                ...request.logFields,
+              },
+            );
+            this.maxTokensClamps.set(request.model.name, maxTokensLimit);
+            params = { ...params, maxCompletionTokens: maxTokensLimit };
+            continue;
+          }
+        }
         throw error;
       }
     }
@@ -526,6 +552,15 @@ export class AgentLLMRequesterService implements IAgentLLMRequesterService {
     set.add(source.turnId);
   }
 
+  private applyMaxTokensClamp(modelName: string, params: ModelRequestParams): ModelRequestParams {
+    const clamp = this.maxTokensClamps.get(modelName);
+    if (clamp === undefined) return params;
+    return {
+      ...params,
+      maxCompletionTokens: Math.min(clamp, params.maxCompletionTokens ?? clamp),
+    };
+  }
+
   private resolveRequest(overrides: AgentLLMRequestOverrides): ResolvedLLMRequest {
     const turnConfig = this.resolveTurnConfig(overrides.source);
     const resolved = turnConfig?.resolved ?? this.profile.resolveModelContext();
diff --git a/packages/agent-core-v2/src/kosong/contract/errors.ts b/packages/agent-core-v2/src/kosong/contract/errors.ts
index 43b9ee5dd7..b157003659 100644
--- a/packages/agent-core-v2/src/kosong/contract/errors.ts
+++ b/packages/agent-core-v2/src/kosong/contract/errors.ts
@@ -255,6 +255,36 @@ const CONTEXT_OVERFLOW_MESSAGE_PATTERNS = [
   /request.*exceed(?:ed|s|ing)?.*model token limit/,
 ] as const;
 
+/**
+ * Messages from providers that reject `max_tokens` above their actual output
+ * ceiling. Matched against the full error message text (which includes the
+ * provider's JSON body). Each pattern should anchor on `max_tokens` to avoid
+ * false positives from context-overflow messages.
+ */
+const MAX_TOKENS_LIMIT_MESSAGE_PATTERNS: readonly RegExp[] = [
+  // volcano / ark: "expected a value <= 32768"
+  /max_tokens[\s\S]{0,200}expected a value\s*<=\s*(\d+)/i,
+  // generic: "max_tokens must be at most N" / "max_tokens cannot exceed N"
+  /max_tokens[\s\S]{0,200}(?:must be at most|cannot exceed|maximum value[^\d]*)\s*(\d+)/i,
+  // anthropic native: "max_tokens: <model> max output tokens is N"
+  /max_tokens[\s\S]{0,200}max output tokens is\s*(\d+)/i,
+];
+
+/**
+ * Parse the provider's actual max_tokens ceiling from a 400 error message.
+ * Returns the parsed limit, or null if no max_tokens limit pattern matched.
+ */
+export function parseMaxTokensLimit(message: string): number | null {
+  for (const pattern of MAX_TOKENS_LIMIT_MESSAGE_PATTERNS) {
+    const match = pattern.exec(message);
+    if (match?.[1]) {
+      const limit = parseInt(match[1], 10);
+      if (Number.isFinite(limit) && limit > 0) return limit;
+    }
+  }
+  return null;
+}
+
 const PROVIDER_RATE_LIMIT_MESSAGE_PATTERNS = [
   /(?:apistatuserror.*429|429.*apistatuserror)/,
   /429.*too many requests/,
diff --git a/packages/agent-core-v2/src/kosong/provider/bases/anthropic/anthropic.ts b/packages/agent-core-v2/src/kosong/provider/bases/anthropic/anthropic.ts
index fc276bb066..29e4810fcb 100644
--- a/packages/agent-core-v2/src/kosong/provider/bases/anthropic/anthropic.ts
+++ b/packages/agent-core-v2/src/kosong/provider/bases/anthropic/anthropic.ts
@@ -207,6 +207,8 @@ const CEILING_BY_FAMILY_VERSION: Readonly<Record<string, number>> = {
 };
 
 const FALLBACK_MAX_TOKENS = 128000;
+/** Conservative fallback for custom endpoints whose actual output ceiling is unknown. */
+const CUSTOM_ENDPOINT_FALLBACK_MAX_TOKENS = 32768;
 
 function lookupClaudeCeiling(version: AnthropicModelVersion): number | undefined {
   const { family, major, minor } = version;
@@ -219,11 +221,18 @@ function lookupClaudeCeiling(version: AnthropicModelVersion): number | undefined
   return CEILING_BY_FAMILY_VERSION[`${family}-${major}`];
 }
 
-export function resolveDefaultMaxTokens(model: string, override?: number): number {
+export function resolveDefaultMaxTokens(model: string, override?: number, baseUrl?: string): number {
   const parsed = parseAnthropicModelVersion(model, true);
   const ceiling = parsed === null ? undefined : lookupClaudeCeiling(parsed);
   if (ceiling === undefined) {
-    return override ?? FALLBACK_MAX_TOKENS;
+    if (override !== undefined) return override;
+    // Custom endpoint + unrecognized model: the 128k Claude-4 fallback is too
+    // aggressive for most Anthropic-compatible providers (32768 is the most
+    // common ceiling). Use the conservative value; the user can still override
+    // via defaultMaxTokens (max_output_size in config).
+    const isCustomEndpoint =
+      baseUrl !== undefined && baseUrl !== '' && !baseUrl.includes('api.anthropic.com');
+    return isCustomEndpoint ? CUSTOM_ENDPOINT_FALLBACK_MAX_TOKENS : FALLBACK_MAX_TOKENS;
   }
   return override === undefined ? ceiling : Math.min(override, ceiling);
 }
@@ -821,7 +830,9 @@ export class AnthropicChatProvider implements ChatProvider {
     this._client = this._apiKey === undefined ? undefined : this._buildClient(this._apiKey);
     this._explicitMaxTokens = options.defaultMaxTokens !== undefined;
     this._generationKwargs = {
-      max_tokens: options.defaultMaxTokens ?? resolveDefaultMaxTokens(options.model),
+      max_tokens:
+        options.defaultMaxTokens ??
+        resolveDefaultMaxTokens(options.model, undefined, options.baseUrl),
       betaFeatures: options.betaFeatures ?? [INTERLEAVED_THINKING_BETA],
     };
   }
@@ -927,7 +938,7 @@ export class AnthropicChatProvider implements ChatProvider {
         cap = Math.min(cap, options.maxContextTokens - options.usedContextTokens);
       }
       cap = Math.max(1, cap);
-      const requestedCap = resolveDefaultMaxTokens(this._model, cap);
+      const requestedCap = resolveDefaultMaxTokens(this._model, cap, this._baseUrl);
       const existingCap = kwargs.max_tokens;
       kwargs = {
         ...kwargs,
diff --git a/packages/agent-core-v2/test/agent/llmRequester/llmRequesterService.test.ts b/packages/agent-core-v2/test/agent/llmRequester/llmRequesterService.test.ts
index a91ddfb3df..3fb0e5ba17 100644
--- a/packages/agent-core-v2/test/agent/llmRequester/llmRequesterService.test.ts
+++ b/packages/agent-core-v2/test/agent/llmRequester/llmRequesterService.test.ts
@@ -51,6 +51,7 @@ import { IModelCatalog, type Model } from '#/kosong/model/catalog';
 import {
   type ModelRequestEvent,
   type ModelRequestInput,
+  type ModelRequestParams,
   type ModelRequester,
 } from '#/kosong/model/modelRequester';
 import { ITelemetryService } from '#/app/telemetry/telemetry';
@@ -616,6 +617,97 @@ describe('AgentLLMRequesterService media-degraded resend', () => {
   });
 });
 
+describe('AgentLLMRequesterService max-tokens clamp resend', () => {
+  // The harness budget is the stub model's 1000-token context window, so the
+  // server-declared ceiling must sit below it for the clamp to lower anything.
+  const MAX_TOKENS_400 = new APIStatusError(400, 'max_tokens: 128000, expected a value <= 512');
+
+  function createMaxTokensRequester(
+    calls: { value: number },
+    capturedParams: Array<ModelRequestParams | undefined>,
+    errors: readonly (Error | undefined)[],
+  ): ModelRequester {
+    const model: Model = {
+      id: 'm',
+      name: 'wire-model',
+      aliases: [],
+      protocol: 'anthropic',
+      baseUrl: 'https://example.test',
+      headers: {},
+      capabilities,
+      maxContextSize: 1000,
+      alwaysThinking: false,
+      providerName: 'p',
+      authProvider: { getAuth: async () => undefined },
+    };
+    return {
+      model,
+      request: async function* (_input, _signal, params) {
+        const index = calls.value;
+        calls.value += 1;
+        capturedParams.push(params);
+        const error = errors[index];
+        if (error !== undefined) throw error;
+        yield {
+          type: 'finish',
+          message: { role: 'assistant', content: [{ type: 'text', text: 'ok' }], toolCalls: [] },
+          providerFinishReason: 'completed',
+          rawFinishReason: 'stop',
+          id: 'resp-1',
+        };
+      },
+    };
+  }
+
+  it('resends once with the server-declared max_tokens ceiling', async () => {
+    const calls = { value: 0 };
+    const capturedParams: Array<ModelRequestParams | undefined> = [];
+    const requester = createMaxTokensRequester(calls, capturedParams, [
+      MAX_TOKENS_400,
+      undefined,
+    ]);
+    const { service } = createService(requester, undefined);
+
+    const result = await service.request();
+
+    expect(result.message.content).toEqual([{ type: 'text', text: 'ok' }]);
+    expect(calls.value).toBe(2);
+    expect(capturedParams[0]?.maxCompletionTokens).toBeGreaterThan(512);
+    expect(capturedParams[1]?.maxCompletionTokens).toBe(512);
+  });
+
+  it('stops after one clamp resend when the clamped request is rejected again', async () => {
+    const calls = { value: 0 };
+    const capturedParams: Array<ModelRequestParams | undefined> = [];
+    const requester = createMaxTokensRequester(calls, capturedParams, [
+      MAX_TOKENS_400,
+      MAX_TOKENS_400,
+    ]);
+    const { service } = createService(requester, undefined);
+
+    await expect(service.request()).rejects.toMatchObject({ statusCode: 400 });
+    expect(calls.value).toBe(2);
+  });
+
+  it('applies the remembered clamp to later requests for the same model', async () => {
+    const calls = { value: 0 };
+    const capturedParams: Array<ModelRequestParams | undefined> = [];
+    const requester = createMaxTokensRequester(calls, capturedParams, [
+      MAX_TOKENS_400,
+      undefined,
+      undefined,
+    ]);
+    const { service } = createService(requester, undefined);
+
+    await service.request({ source: { type: 'turn', turnId: 1, step: 1 } });
+    expect(calls.value).toBe(2);
+
+    await service.request({ source: { type: 'turn', turnId: 2, step: 1 } });
+    expect(calls.value).toBe(3);
+    expect(capturedParams[2]?.maxCompletionTokens).toBe(512);
+  });
+});
+
 describe('AgentLLMRequesterService fault injection (experimental)', () => {
   it('raises an armed request-too-large fault before the provider and recovers via the degraded resend', async () => {
     const calls = { value: 0 };
diff --git a/packages/agent-core-v2/test/kosong/contract/errors.test.ts b/packages/agent-core-v2/test/kosong/contract/errors.test.ts
index b4ba79cef8..e6dd669533 100644
--- a/packages/agent-core-v2/test/kosong/contract/errors.test.ts
+++ b/packages/agent-core-v2/test/kosong/contract/errors.test.ts
@@ -23,6 +23,7 @@ import {
   isAbortError,
   isRetryableGenerateError,
   normalizeAPIStatusError,
+  parseMaxTokensLimit,
   throwIfAbortError,
 } from '#/kosong/contract/errors';
 
@@ -183,3 +184,25 @@ describe('classifyApiError', () => {
     expect(classifyApiError('boom').kind).toBe('other');
   });
 });
+
+describe('parseMaxTokensLimit', () => {
+  it('parses the "expected a value <= N" form', () => {
+    expect(parseMaxTokensLimit('max_tokens: 128000, expected a value <= 8192')).toBe(8192);
+  });
+
+  it('parses the "must be at most", "cannot exceed", and "maximum value" forms', () => {
+    expect(parseMaxTokensLimit('max_tokens: value must be at most 32768')).toBe(32768);
+    expect(parseMaxTokensLimit('max_tokens cannot exceed 16384 for this model')).toBe(16384);
+    expect(parseMaxTokensLimit('max_tokens: maximum value is 64000')).toBe(64000);
+  });
+
+  it('parses the "max output tokens is N" form case-insensitively', () => {
+    expect(parseMaxTokensLimit('Max_Tokens: 99999 but max output tokens is 12000')).toBe(12000);
+  });
+
+  it('returns null when no recognizable positive limit is present', () => {
+    expect(parseMaxTokensLimit('max_tokens must be positive')).toBeNull();
+    expect(parseMaxTokensLimit('some unrelated validation problem')).toBeNull();
+    expect(parseMaxTokensLimit('max_tokens: expected a value <= 0')).toBeNull();
+  });
+});
diff --git a/packages/agent-core-v2/test/kosong/provider/composition.test.ts b/packages/agent-core-v2/test/kosong/provider/composition.test.ts
index e6293bd978..a312f074c5 100644
--- a/packages/agent-core-v2/test/kosong/provider/composition.test.ts
+++ b/packages/agent-core-v2/test/kosong/provider/composition.test.ts
@@ -949,6 +949,28 @@ describe('Anthropic max-tokens profile', () => {
     expect(resolveDefaultMaxTokens('totally-unknown-model')).toBe(128000);
   });
 
+  it('defaults unknown models on custom endpoints to a conservative ceiling', () => {
+    expect(
+      resolveDefaultMaxTokens('totally-unknown-model', undefined, 'https://proxy.example.test/v1'),
+    ).toBe(32768);
+  });
+
+  it('keeps the 128000 fallback for unknown models on the official endpoint or no endpoint', () => {
+    expect(
+      resolveDefaultMaxTokens('totally-unknown-model', undefined, 'https://api.anthropic.com'),
+    ).toBe(128000);
+    expect(resolveDefaultMaxTokens('totally-unknown-model', undefined, '')).toBe(128000);
+  });
+
+  it('does not let a custom endpoint displace an explicit override or a known ceiling', () => {
+    expect(resolveDefaultMaxTokens('unknown-model', 12345, 'https://proxy.example.test/v1')).toBe(
+      12345,
+    );
+    expect(
+      resolveDefaultMaxTokens('claude-opus-4-7', undefined, 'https://proxy.example.test/v1'),
+    ).toBe(128000);
+  });
+
   it('sends the profile default as max_tokens when no explicit defaultMaxTokens is set', async () => {
     const provider = new AnthropicChatProvider({
       model: 'claude-opus-4-7',
@@ -999,6 +1021,19 @@ describe('Anthropic max-tokens profile', () => {
 
     expect(params['max_tokens']).toBe(999999);
   });
+
+  it('seeds the conservative fallback for unknown models on custom endpoints', async () => {
+    const provider = new AnthropicChatProvider({
+      model: 'totally-unknown-model',
+      apiKey: 'sk-probe',
+      baseUrl: 'https://proxy.example.test/v1',
+      stream: false,
+    });
+
+    const { params } = await captureAnthropicBody(provider);
+
+    expect(params['max_tokens']).toBe(32768);
+  });
 });
 
 describe('OpenAI reasoning_effort path (issue #1616)', () => {
diff --git a/packages/kosong/src/errors.ts b/packages/kosong/src/errors.ts
index 0bdb54b96c..06efe0d796 100644
--- a/packages/kosong/src/errors.ts
+++ b/packages/kosong/src/errors.ts
@@ -323,6 +323,36 @@ const CONTEXT_OVERFLOW_MESSAGE_PATTERNS = [
   /request.*exceed(?:ed|s|ing)?.*model token limit/,
 ] as const;
 
+/**
+ * Messages from providers that reject `max_tokens` above their actual output
+ * ceiling. Matched against the full error message text (which includes the
+ * provider's JSON body). Each pattern should anchor on `max_tokens` to avoid
+ * false positives from context-overflow messages.
+ */
+const MAX_TOKENS_LIMIT_MESSAGE_PATTERNS: readonly RegExp[] = [
+  // volcano / ark: "expected a value <= 32768"
+  /max_tokens[\s\S]{0,200}expected a value\s*<=\s*(\d+)/i,
+  // generic: "max_tokens must be at most N" / "max_tokens cannot exceed N"
+  /max_tokens[\s\S]{0,200}(?:must be at most|cannot exceed|maximum value[^\d]*)\s*(\d+)/i,
+  // anthropic native: "max_tokens: <model> max output tokens is N"
+  /max_tokens[\s\S]{0,200}max output tokens is\s*(\d+)/i,
+];
+
+/**
+ * Parse the provider's actual max_tokens ceiling from a 400 error message.
+ * Returns the parsed limit, or null if no max_tokens limit pattern matched.
+ */
+export function parseMaxTokensLimit(message: string): number | null {
+  for (const pattern of MAX_TOKENS_LIMIT_MESSAGE_PATTERNS) {
+    const match = pattern.exec(message);
+    if (match?.[1]) {
+      const limit = parseInt(match[1], 10);
+      if (Number.isFinite(limit) && limit > 0) return limit;
+    }
+  }
+  return null;
+}
+
 const PROVIDER_RATE_LIMIT_MESSAGE_PATTERNS = [
   /(?:apistatuserror.*429|429.*apistatuserror)/,
   /429.*too many requests/,
diff --git a/packages/kosong/src/providers/anthropic.ts b/packages/kosong/src/providers/anthropic.ts
index 6b34aa5343..9bf46006c2 100644
--- a/packages/kosong/src/providers/anthropic.ts
+++ b/packages/kosong/src/providers/anthropic.ts
@@ -222,6 +222,8 @@ const CEILING_BY_FAMILY_VERSION: Readonly<Record<string, number>> = {
 };
 
 const FALLBACK_MAX_TOKENS = 128000;
+/** Conservative fallback for custom endpoints whose actual output ceiling is unknown. */
+const CUSTOM_ENDPOINT_FALLBACK_MAX_TOKENS = 32768;
 
 function lookupClaudeCeiling(version: AnthropicModelVersion): number | undefined {
   const { family, major, minor } = version;
@@ -252,13 +254,22 @@ function lookupClaudeCeiling(version: AnthropicModelVersion): number | undefined
  *      the override is clamped to the documented Messages-API ceiling
  *      so we never send a value the server would reject.
  *   3. With no override and no recognized version, fall back to
- *      {@link FALLBACK_MAX_TOKENS}.
+ *      {@link FALLBACK_MAX_TOKENS} — or the conservative
+ *      {@link CUSTOM_ENDPOINT_FALLBACK_MAX_TOKENS} when `baseUrl` points at a
+ *      custom (non-Anthropic) endpoint, whose actual output ceiling is unknown
+ *      and is most commonly 32768.
  */
-export function resolveDefaultMaxTokens(model: string, override?: number): number {
+export function resolveDefaultMaxTokens(model: string, override?: number, baseUrl?: string): number {
   const parsed = parseAnthropicModelVersion(model, true);
   const ceiling = parsed === null ? undefined : lookupClaudeCeiling(parsed);
   if (ceiling === undefined) {
-    return override ?? FALLBACK_MAX_TOKENS;
+    if (override !== undefined) return override;
+    // Custom endpoint + unrecognized model: the 128k Claude-4 fallback is too
+    // aggressive for most Anthropic-compatible providers (32768 is the most
+    // common ceiling). Use the conservative value; the user can still override
+    // via defaultMaxTokens (max_output_size in config).
+    const isCustomEndpoint = baseUrl !== undefined && baseUrl !== '' && !baseUrl.includes('api.anthropic.com');
+    return isCustomEndpoint ? CUSTOM_ENDPOINT_FALLBACK_MAX_TOKENS : FALLBACK_MAX_TOKENS;
   }
   return override === undefined ? ceiling : Math.min(override, ceiling);
 }
@@ -920,7 +931,7 @@ export class AnthropicChatProvider implements ChatProvider {
     this._client = this._apiKey === undefined ? undefined : this._buildClient(this._apiKey);
     this._explicitMaxTokens = options.defaultMaxTokens !== undefined;
     this._generationKwargs = {
-      max_tokens: options.defaultMaxTokens ?? resolveDefaultMaxTokens(options.model),
+      max_tokens: options.defaultMaxTokens ?? resolveDefaultMaxTokens(options.model, undefined, options.baseUrl),
       betaFeatures: options.betaFeatures ?? [INTERLEAVED_THINKING_BETA],
     };
   }
@@ -1270,7 +1281,7 @@ export class AnthropicChatProvider implements ChatProvider {
   }
 
   withMaxCompletionTokens(maxCompletionTokens: number): AnthropicChatProvider {
-    const requestedCap = resolveDefaultMaxTokens(this._model, maxCompletionTokens);
+    const requestedCap = resolveDefaultMaxTokens(this._model, maxCompletionTokens, this._baseUrl);
     const existingCap = this._generationKwargs.max_tokens;
     const clone = this._withGenerationKwargs({
       max_tokens:
diff --git a/packages/kosong/test/anthropic.test.ts b/packages/kosong/test/anthropic.test.ts
index 6b079a75a6..22a8e37d9a 100644
--- a/packages/kosong/test/anthropic.test.ts
+++ b/packages/kosong/test/anthropic.test.ts
@@ -3408,6 +3408,32 @@ describe('resolveDefaultMaxTokens', () => {
     expect(resolveDefaultMaxTokens('vendor-opus-4-7-preview')).toBe(128000);
     expect(resolveDefaultMaxTokens('vendor-opus-4-7-preview', 8000)).toBe(8000);
   });
+
+  it('uses the conservative 32k fallback for a custom endpoint with an unrecognized model', () => {
+    expect(
+      resolveDefaultMaxTokens('some-custom-model', undefined, 'https://ark.cn-beijing.volces.com/api/v3'),
+    ).toBe(32768);
+    expect(resolveDefaultMaxTokens('gpt-5', undefined, 'https://my-proxy.example.test')).toBe(32768);
+  });
+
+  it('keeps the 128k fallback for the official Anthropic endpoint with an unrecognized model', () => {
+    expect(resolveDefaultMaxTokens('gpt-5', undefined, 'https://api.anthropic.com')).toBe(128000);
+    expect(resolveDefaultMaxTokens('totally-unknown-model', undefined, undefined)).toBe(128000);
+  });
+
+  it('still applies the documented ceiling for a Claude model on a custom endpoint', () => {
+    expect(resolveDefaultMaxTokens('claude-opus-4-7', undefined, 'https://my-proxy.example.test')).toBe(
+      128000,
+    );
+    expect(resolveDefaultMaxTokens('claude-3-opus', undefined, 'https://my-proxy.example.test')).toBe(4096);
+  });
+
+  it('honors the user override over the custom-endpoint fallback', () => {
+    expect(resolveDefaultMaxTokens('some-custom-model', 16000, 'https://my-proxy.example.test')).toBe(
+      16000,
+    );
+    expect(resolveDefaultMaxTokens('some-custom-model', 8192, undefined)).toBe(8192);
+  });
 });
 
 describe('AnthropicChatProvider constructor max_tokens', () => {
diff --git a/packages/kosong/test/errors.test.ts b/packages/kosong/test/errors.test.ts
index 2e39e971ed..5d7391c698 100644
--- a/packages/kosong/test/errors.test.ts
+++ b/packages/kosong/test/errors.test.ts
@@ -13,6 +13,7 @@ import {
   isRetryableGenerateError,
   isToolExchangeAdjacencyError,
   normalizeAPIStatusError,
+  parseMaxTokensLimit,
 } from '#/errors';
 import { describe, expect, it } from 'vitest';
 
@@ -678,3 +679,35 @@ describe('isImageFormatError', () => {
     ).toBe(false);
   });
 });
+
+describe('parseMaxTokensLimit', () => {
+  it('parses the volcano / ark "expected a value <= N" wording', () => {
+    expect(
+      parseMaxTokensLimit(
+        '400 {"error":{"code":"InvalidParameter","message":"The parameter max_tokens expected a value <= 32768, got 128000."}}',
+      ),
+    ).toBe(32768);
+  });
+
+  it('parses the generic "must be at most N" wording', () => {
+    expect(parseMaxTokensLimit('400 Bad Request: max_tokens must be at most 8192')).toBe(8192);
+  });
+
+  it('parses the generic "cannot exceed N" wording', () => {
+    expect(parseMaxTokensLimit('400 Bad Request: max_tokens cannot exceed 4096')).toBe(4096);
+  });
+
+  it('parses the Anthropic native "max output tokens is N" wording', () => {
+    expect(
+      parseMaxTokensLimit('max_tokens: claude-3-haiku-20240307 max output tokens is 4096'),
+    ).toBe(4096);
+  });
+
+  it('returns null for messages without a max_tokens limit', () => {
+    expect(parseMaxTokensLimit('400 Bad Request: invalid api key')).toBeNull();
+    // A context-overflow message must not be mistaken for a max_tokens ceiling.
+    expect(
+      parseMaxTokensLimit('prompt is too long: the maximum context length is 200000 tokens'),
+    ).toBeNull();
+  });
+});

From ab120cdafa9809a4ba34370c2027a2a67bb59a26 Mon Sep 17 00:00:00 2001
From: yorha9e <hzw2559099601@gmail.com>
Date: Wed, 22 Jul 2026 20:33:19 +0800
Subject: [PATCH 2/2] fix(kosong): recognize less-than-or-equal max_tokens
 ceilings in parseMaxTokensLimit

---
 .../agent-core-v2/src/kosong/contract/errors.ts  | 16 +++++++---------
 .../test/kosong/contract/errors.test.ts          |  5 +++++
 packages/kosong/src/errors.ts                    |  2 ++
 packages/kosong/test/errors.test.ts              |  5 +++++
 4 files changed, 19 insertions(+), 9 deletions(-)

diff --git a/packages/agent-core-v2/src/kosong/contract/errors.ts b/packages/agent-core-v2/src/kosong/contract/errors.ts
index b157003659..2651d46803 100644
--- a/packages/agent-core-v2/src/kosong/contract/errors.ts
+++ b/packages/agent-core-v2/src/kosong/contract/errors.ts
@@ -255,24 +255,22 @@ const CONTEXT_OVERFLOW_MESSAGE_PATTERNS = [
   /request.*exceed(?:ed|s|ing)?.*model token limit/,
 ] as const;
 
-/**
- * Messages from providers that reject `max_tokens` above their actual output
- * ceiling. Matched against the full error message text (which includes the
- * provider's JSON body). Each pattern should anchor on `max_tokens` to avoid
- * false positives from context-overflow messages.
- */
 const MAX_TOKENS_LIMIT_MESSAGE_PATTERNS: readonly RegExp[] = [
-  // volcano / ark: "expected a value <= 32768"
   /max_tokens[\s\S]{0,200}expected a value\s*<=\s*(\d+)/i,
-  // generic: "max_tokens must be at most N" / "max_tokens cannot exceed N"
   /max_tokens[\s\S]{0,200}(?:must be at most|cannot exceed|maximum value[^\d]*)\s*(\d+)/i,
-  // anthropic native: "max_tokens: <model> max output tokens is N"
+  /max_tokens[\s\S]{0,200}(?:less than or equal to|<=)\s*(\d+)/i,
   /max_tokens[\s\S]{0,200}max output tokens is\s*(\d+)/i,
 ];
 
 /**
  * Parse the provider's actual max_tokens ceiling from a 400 error message.
  * Returns the parsed limit, or null if no max_tokens limit pattern matched.
+ * Patterns are matched against the full error message text (which includes
+ * the provider's JSON body) and each anchors on `max_tokens` to avoid false
+ * positives from context-overflow messages. Recognized wordings: volcano/ark
+ * "expected a value <= N"; "must be at most N" / "cannot exceed N" /
+ * "maximum value … N"; "must be less than or equal to N" and the bare "<= N"
+ * form; Anthropic-native "max output tokens is N".
  */
 export function parseMaxTokensLimit(message: string): number | null {
   for (const pattern of MAX_TOKENS_LIMIT_MESSAGE_PATTERNS) {
diff --git a/packages/agent-core-v2/test/kosong/contract/errors.test.ts b/packages/agent-core-v2/test/kosong/contract/errors.test.ts
index e6dd669533..20e3d49128 100644
--- a/packages/agent-core-v2/test/kosong/contract/errors.test.ts
+++ b/packages/agent-core-v2/test/kosong/contract/errors.test.ts
@@ -200,6 +200,11 @@ describe('parseMaxTokensLimit', () => {
     expect(parseMaxTokensLimit('Max_Tokens: 99999 but max output tokens is 12000')).toBe(12000);
   });
 
+  it('parses the "less than or equal to" and bare "<=" forms', () => {
+    expect(parseMaxTokensLimit('max_tokens must be less than or equal to 4096')).toBe(4096);
+    expect(parseMaxTokensLimit('max_tokens <= 2048')).toBe(2048);
+  });
+
   it('returns null when no recognizable positive limit is present', () => {
     expect(parseMaxTokensLimit('max_tokens must be positive')).toBeNull();
     expect(parseMaxTokensLimit('some unrelated validation problem')).toBeNull();
diff --git a/packages/kosong/src/errors.ts b/packages/kosong/src/errors.ts
index 06efe0d796..fa5b6ee7e0 100644
--- a/packages/kosong/src/errors.ts
+++ b/packages/kosong/src/errors.ts
@@ -334,6 +334,8 @@ const MAX_TOKENS_LIMIT_MESSAGE_PATTERNS: readonly RegExp[] = [
   /max_tokens[\s\S]{0,200}expected a value\s*<=\s*(\d+)/i,
   // generic: "max_tokens must be at most N" / "max_tokens cannot exceed N"
   /max_tokens[\s\S]{0,200}(?:must be at most|cannot exceed|maximum value[^\d]*)\s*(\d+)/i,
+  // "must be less than or equal to N" / bare "<= N" form
+  /max_tokens[\s\S]{0,200}(?:less than or equal to|<=)\s*(\d+)/i,
   // anthropic native: "max_tokens: <model> max output tokens is N"
   /max_tokens[\s\S]{0,200}max output tokens is\s*(\d+)/i,
 ];
diff --git a/packages/kosong/test/errors.test.ts b/packages/kosong/test/errors.test.ts
index 5d7391c698..e02101784d 100644
--- a/packages/kosong/test/errors.test.ts
+++ b/packages/kosong/test/errors.test.ts
@@ -703,6 +703,11 @@ describe('parseMaxTokensLimit', () => {
     ).toBe(4096);
   });
 
+  it('parses the "less than or equal to" and bare "<=" wordings', () => {
+    expect(parseMaxTokensLimit('400 Bad Request: max_tokens must be less than or equal to 4096')).toBe(4096);
+    expect(parseMaxTokensLimit('400 Bad Request: max_tokens <= 2048')).toBe(2048);
+  });
+
   it('returns null for messages without a max_tokens limit', () => {
     expect(parseMaxTokensLimit('400 Bad Request: invalid api key')).toBeNull();
     // A context-overflow message must not be mistaken for a max_tokens ceiling.