fix: fall back to the model default for thinking efforts outside support_efforts

.changeset/thinking-effort-fallback-declared-efforts.md

@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": patch
+---
+
+Models with a declared support_efforts list now fall back to their default thinking effort when the configured effort is not in the list.

packages/agent-core-v2/src/agent/llmRequester/llmRequesterService.ts

@@ -336,7 +336,7 @@ export class AgentLLMRequesterService implements IAgentLLMRequesterService {
           signal,
         ),
       };
-      this.warnAboutAnthropicThinkingEffort(request);
+      this.warnAboutThinkingEffortNotListed(request);
       const logInput: LLMRequestLogInput = {
         protocol: request.model.protocol,
         providerType: request.model.providerType,
@@ -514,21 +514,15 @@ export class AgentLLMRequesterService implements IAgentLLMRequesterService {
     return assigned === part.id ? part : { ...part, id: assigned };
   }
 
-  private warnAboutAnthropicThinkingEffort(request: ResolvedLLMRequest): void {
-    if (request.model.protocol !== 'anthropic') return;
+  private warnAboutThinkingEffortNotListed(request: ResolvedLLMRequest): void {
     const effort = request.thinkingEffort;
     if (effort === 'on' || effort === 'off') return;
-
-    let code: string;
-    let message: string;
-    let knownEfforts: string | undefined;
     const supportEfforts = request.model.supportEfforts?.filter((value) => value.length > 0);
     if (supportEfforts === undefined || supportEfforts.length === 0) return;
     if (supportEfforts.includes(effort)) return;
-    code = 'anthropic-thinking-effort-not-listed';
-    knownEfforts = supportEfforts.join(',');
-    message = `Thinking effort "${effort}" is not listed for model "${request.model.name}" (known: ${supportEfforts.join(', ')}). The configured value will be sent unchanged to the Anthropic-compatible backend.`;
-
+    const code = 'thinking-effort-not-listed';
+    const knownEfforts = supportEfforts.join(',');
+    const message = `Thinking effort "${effort}" is not listed for model "${request.model.name}" (known: ${supportEfforts.join(', ')}). The value will be sent unchanged to the backend.`;
     const key = [code, request.modelAlias, request.model.name, effort, knownEfforts].join('\u0000');
     if (this.emittedThinkingEffortWarnings.has(key)) return;
     this.emittedThinkingEffortWarnings.add(key);

packages/agent-core-v2/src/agent/profile/profileService.ts

@@ -14,6 +14,7 @@ import {
   normalizeRequestedThinkingEffort,
   resolveForcedThinkingEffort,
   resolveThinkingEffortForModel,
+  resolveThinkingEffortForModelWithFallback,
   resolveThinkingKeep,
   requiresStrictThinkingValidation,
   type ThinkingConfig,
@@ -202,6 +203,12 @@ export class AgentProfileService extends Disposable implements IAgentProfileServ
         }
       }),
     );
+    this._register(
+      this.dispatcher.hooks.onDidRestore.register('profile', async (_ctx, next) => {
+        this.warnAboutThinkingEffortFallback(this.profileState.thinkingLevel);
+        await next();
+      }),
+    );
   }
 
   private get activeToolNamesOverlay(): readonly string[] | undefined {
@@ -247,8 +254,13 @@ export class AgentProfileService extends Disposable implements IAgentProfileServ
       this.activeProfile = undefined;
     }
     if (Object.keys(configChanged).length > 0) {
-      void this.dispatcher.dispatch(new ConfigUpdate(this.resolveConfigPayload(configChanged)));
-      this.afterConfigDispatch(configChanged);
+      const thinkingRequested =
+        configChanged.thinkingLevel ??
+        (this.modelAlias === undefined ? undefined : this.thinkingLevel);
+      void this.dispatcher.dispatch(
+        new ConfigUpdate(this.resolveConfigPayload(configChanged, thinkingRequested)),
+      );
+      this.afterConfigDispatch(configChanged, thinkingRequested);
     }
     if (activeToolNames !== undefined) {
       this.setActiveTools(activeToolNames);
@@ -283,7 +295,7 @@ export class AgentProfileService extends Disposable implements IAgentProfileServ
       environmentDisclosure: snapshot.environmentDisclosure,
       agentsMdPaths,
       disallowedTools: snapshot.disallowedTools ?? [],
-    });
+    }, snapshot.thinkingLevel);
     this.agentsMdReminder.seedInjected(agentsMdPaths, this.sessionContext.cwd);
   }
 
@@ -324,10 +336,9 @@ export class AgentProfileService extends Disposable implements IAgentProfileServ
     this.activeProfile = profile;
     this.cacheAgentsMdWarning(context);
 
-    const thinkingLevel = this.resolveThinkingEffort(
-      input.thinking ?? (currentProfileName !== undefined ? this.thinkingLevel : undefined),
-      model,
-    );
+    const thinkingRequested =
+      input.thinking ?? (currentProfileName !== undefined ? this.thinkingLevel : undefined);
+    const thinkingLevel = this.resolveThinkingEffort(thinkingRequested, model);
 
     this.activeToolNamesOverlay = undefined;
     await this.dispatcher.dispatch(new ProfileBind({
@@ -348,7 +359,7 @@ export class AgentProfileService extends Disposable implements IAgentProfileServ
       thinkingLevel,
       systemPrompt: rendered.text,
       disallowedTools: profile.disallowedTools ?? [],
-    });
+    }, thinkingRequested);
     this.seedAgentsMdReminder(context);
 
     this.publishAgentsMdWarning();
@@ -568,15 +579,14 @@ export class AgentProfileService extends Disposable implements IAgentProfileServ
 
   private resolveConfigPayload(
     changed: Omit<ProfileUpdateData, 'activeToolNames'>,
+    thinkingRequested: string | undefined,
   ): ConfigUpdatePayload {
     const payload: ConfigUpdatePayload = { agentId: this.scopeContext.agentId };
     if (changed.modelAlias !== undefined) payload.modelAlias = changed.modelAlias;
     if (changed.profileName !== undefined) payload.profileName = changed.profileName;
     if (changed.thinkingLevel !== undefined || changed.modelAlias !== undefined) {
       const model = this.resolveModelForThinking(changed.modelAlias ?? this.modelAlias);
-      const requested =
-        changed.thinkingLevel ?? (this.modelAlias === undefined ? undefined : this.thinkingLevel);
-      payload.thinkingEffort = this.resolveThinkingEffort(requested, model);
+      payload.thinkingEffort = this.resolveThinkingEffort(thinkingRequested, model);
     }
     if (changed.systemPrompt !== undefined) {
       payload.systemPrompt = changed.systemPrompt;
@@ -593,7 +603,10 @@ export class AgentProfileService extends Disposable implements IAgentProfileServ
     return payload;
   }
 
-  private afterConfigDispatch(changed: Omit<ProfileUpdateData, 'activeToolNames'>): void {
+  private afterConfigDispatch(
+    changed: Omit<ProfileUpdateData, 'activeToolNames'>,
+    thinkingRequested: string | undefined,
+  ): void {
     if (changed.modelAlias !== undefined) {
       const model = this.tryResolveRawModel();
       this.telemetryContext.set({
@@ -602,30 +615,36 @@ export class AgentProfileService extends Disposable implements IAgentProfileServ
       });
     }
     if (changed.modelAlias !== undefined || changed.thinkingLevel !== undefined) {
-      this.warnAboutAnthropicThinkingEffort();
+      this.warnAboutThinkingEffortFallback(thinkingRequested);
     }
     this.emitStatusUpdated(
       changed.modelAlias !== undefined || changed.thinkingLevel !== undefined,
     );
   }
 
-  private warnAboutAnthropicThinkingEffort(): void {
+  private warnAboutThinkingEffortFallback(requested: string | undefined): void {
     try {
       const model = this.tryResolveRawModel();
-      if (model?.protocol !== 'anthropic') return;
-      const effort = this.getEffectiveThinkingLevel();
-      if (effort === 'on' || effort === 'off') return;
-
-      let code: string;
-      let message: string;
-      let knownEfforts = '';
-      const efforts = model.supportEfforts?.filter((value) => value.length > 0);
-      if (efforts === undefined || efforts.length === 0 || efforts.includes(effort)) return;
-      knownEfforts = efforts.join(',');
-      code = 'anthropic-thinking-effort-not-listed';
-      message = `Thinking effort "${effort}" is not listed for model "${model.name}" (known: ${efforts.join(', ')}). The configured value will be sent unchanged to the Anthropic-compatible backend.`;
-
-      const key = [code, model.id, model.name, effort, knownEfforts].join('\u0000');
+      if (model === undefined) return;
+      const thinking = this.config.get<ThinkingConfig>(THINKING_SECTION);
+      const { effort, fallback } = resolveThinkingEffortForModelWithFallback(
+        requested,
+        thinking,
+        model,
+        this.strictThinkingValidation(model),
+      );
+      if (fallback === undefined) return;
+      const forced = resolveForcedThinkingEffort(
+        thinking?.forcedEffort,
+        effort,
+        drivesThinkingThroughTraits(model.providerType),
+      );
+      if (forced !== undefined) return;
+      const efforts = model.supportEfforts?.filter((value) => value.length > 0) ?? [];
+      const knownEfforts = efforts.join(',');
+      const code = 'thinking-effort-not-listed';
+      const message = `Thinking effort "${fallback.configured}" is not listed for model "${model.name}" (known: ${efforts.join(', ')}). Falling back to the model's default effort "${fallback.resolved}".`;
+      const key = [code, model.id, model.name, fallback.configured, knownEfforts].join('\u0000');
       if (this.emittedThinkingEffortWarnings.has(key)) return;
       this.emittedThinkingEffortWarnings.add(key);
       void this.dispatcher.dispatch(new WarningIssued({ agentId: this.scopeContext.agentId, code, message }));
@@ -696,11 +715,7 @@ export class AgentProfileService extends Disposable implements IAgentProfileServ
   }
 
   private get thinkingLevel(): ThinkingEffort {
-    const stored = this.profileState.thinkingLevel;
-    if (stored === 'off' && this.alwaysThinkingModel) {
-      return this.resolveThinkingEffort(stored, this.tryResolveRawModel());
-    }
-    return stored;
+    return this.resolveThinkingEffort(this.profileState.thinkingLevel, this.tryResolveRawModel());
   }
 
   private resolveThinkingState(model: Model | undefined): {
@@ -741,10 +756,6 @@ export class AgentProfileService extends Disposable implements IAgentProfileServ
     return modelSupportsThinkingEffort(effort, model, this.strictThinkingValidation(model));
   }
 
-  private get alwaysThinkingModel(): boolean {
-    return this.tryResolveRawModel()?.alwaysThinking === true;
-  }
-
   private tryResolveRawModel(): Model | undefined {
     const alias = this.modelAlias;
     return this.resolveModelForThinking(alias);

packages/agent-core-v2/src/kosong/contract/errors.ts

@@ -316,7 +316,7 @@ function appendThinkingEffortConfigHint(statusCode: number, message: string): st
   if (message.includes(THINKING_EFFORT_CONFIG_DOCS_URL)) return message;
   return `${message}
 
-The provider rejected the configured thinking effort. Non-Kimi providers receive effort strings without client-side mapping; choose an effort supported by the selected model. For Kimi models, check support_efforts and default_effort. See ${THINKING_EFFORT_CONFIG_DOCS_URL}`;
+The provider rejected the configured thinking effort. Efforts outside a model's declared support_efforts fall back to the model default, except a forced effort (forced_effort or KIMI_MODEL_THINKING_EFFORT), which is always sent unchanged; models without a declared list pass efforts to non-Kimi providers unchanged. Choose an effort supported by the selected model. See ${THINKING_EFFORT_CONFIG_DOCS_URL}`;
 }
 
 export function isContextOverflowErrorCode(code: string | null | undefined): boolean {

packages/agent-core-v2/src/kosong/model/thinking.ts

@@ -101,6 +101,16 @@ function effortsFor(model: ModelThinkingMetadata | undefined): readonly string[]
   return model?.supportEfforts?.map(nonEmpty).filter((v): v is string => v !== undefined) ?? [];
 }
 
+function declaredDefaultEffortFor(
+  model: ModelThinkingMetadata | undefined,
+  efforts: readonly string[],
+): ThinkingEffort {
+  const declaredDefault = nonEmpty(model?.defaultEffort);
+  return (declaredDefault !== undefined && efforts.includes(declaredDefault)
+    ? declaredDefault
+    : middleOf(efforts)) as ThinkingEffort;
+}
+
 export function modelSupportsThinking(model: ModelThinkingMetadata | undefined): boolean {
   if (model === undefined) return false;
   return (
@@ -116,12 +126,7 @@ export function defaultThinkingEffortForModel(
 ): ThinkingEffort {
   if (model === undefined || !modelSupportsThinking(model)) return 'off';
   const efforts = effortsFor(model);
-  if (efforts.length > 0) {
-    const declaredDefault = nonEmpty(model.defaultEffort);
-    return (declaredDefault !== undefined && efforts.includes(declaredDefault)
-      ? declaredDefault
-      : middleOf(efforts)) as ThinkingEffort;
-  }
+  if (efforts.length > 0) return declaredDefaultEffortFor(model, efforts);
   return 'on';
 }
 
@@ -144,9 +149,11 @@ function normalizeThinkingEffortForModel(
   if (effort === 'off' && model?.alwaysThinking !== true) return 'off';
   const efforts = effortsFor(model);
   if (!strictValidation) {
-    return effort === 'on' && efforts.length > 0
-      ? defaultThinkingEffortForModel(model)
-      : effort;
+    if (efforts.length === 0) return effort;
+    if (effort === 'on' || !efforts.includes(effort)) {
+      return declaredDefaultEffortFor(model, efforts);
+    }
+    return effort;
   }
   if (!modelSupportsThinking(model)) return 'off';
   if (efforts.length === 0) return 'on';
@@ -156,12 +163,17 @@ function normalizeThinkingEffortForModel(
   return effort;
 }
 
-export function resolveThinkingEffortForModel(
+export interface ThinkingEffortFallback {
+  readonly configured: ThinkingEffort;
+  readonly resolved: ThinkingEffort;
+}
+
+export function resolveThinkingEffortForModelWithFallback(
   requested: string | undefined,
   defaults: ThinkingDefaults | undefined,
   model: ModelThinkingMetadata | undefined,
   strictValidation = false,
-): ThinkingEffort {
+): { readonly effort: ThinkingEffort; readonly fallback: ThinkingEffortFallback | undefined } {
   const configured = normalizeRequestedThinkingEffort(defaults?.effort);
   const normalized = normalizeRequestedThinkingEffort(requested);
   let effort: ThinkingEffort;
@@ -179,7 +191,23 @@ export function resolveThinkingEffortForModel(
         ? configured
         : defaultThinkingEffortForModel(model);
   }
-  return normalizeThinkingEffortForModel(effort, model, strictValidation);
+  const resolved = normalizeThinkingEffortForModel(effort, model, strictValidation);
+  const efforts = effortsFor(model);
+  const fallback: ThinkingEffortFallback | undefined =
+    effort !== 'on' && effort !== 'off' && efforts.length > 0 && !efforts.includes(effort)
+      ? { configured: effort, resolved }
+      : undefined;
+  return { effort: resolved, fallback };
+}
+
+export function resolveThinkingEffortForModel(
+  requested: string | undefined,
+  defaults: ThinkingDefaults | undefined,
+  model: ModelThinkingMetadata | undefined,
+  strictValidation = false,
+): ThinkingEffort {
+  return resolveThinkingEffortForModelWithFallback(requested, defaults, model, strictValidation)
+    .effort;
 }
 
 const KEEP_OFF_VALUES = new Set(['0', 'false', 'no', 'off', 'none', 'null']);

packages/agent-core-v2/test/agent/llmRequester/llmRequesterService.test.ts

@@ -298,7 +298,7 @@ describe('AgentLLMRequesterService measured anchors', () => {
   });
 });
 
-describe('AgentLLMRequesterService Anthropic effort diagnostics', () => {
+describe('AgentLLMRequesterService thinking effort diagnostics', () => {
   it('warns and sends when the effort is not listed by the model', async () => {
     const calls = { value: 0 };
     const requester = createRequester(calls, null);
@@ -312,9 +312,28 @@ describe('AgentLLMRequesterService Anthropic effort diagnostics', () => {
     expect(events.filter((event) => event.type === 'warning')).toEqual([
       expect.objectContaining({
         type: 'warning',
-        code: 'anthropic-thinking-effort-not-listed',
+        code: 'thinking-effort-not-listed',
         message:
-          'Thinking effort "high" is not listed for model "wire-model" (known: max). The configured value will be sent unchanged to the Anthropic-compatible backend.',
+          'Thinking effort "high" is not listed for model "wire-model" (known: max). The value will be sent unchanged to the backend.',
+      }),
+    ]);
+  });
+
+  it('warns for unlisted efforts on any protocol', async () => {
+    const calls = { value: 0 };
+    const requester = createRequester(calls, null);
+    Object.defineProperty(requester.model, 'protocol', { value: 'openai' });
+    Object.defineProperty(requester.model, 'supportEfforts', { value: ['max'] });
+    const { service, events } = createService(requester, undefined, { thinkingLevel: 'high' });
+
+    await service.request();
+
+    expect(events.filter((event) => event.type === 'warning')).toEqual([
+      expect.objectContaining({
+        type: 'warning',
+        code: 'thinking-effort-not-listed',
+        message:
+          'Thinking effort "high" is not listed for model "wire-model" (known: max). The value will be sent unchanged to the backend.',
       }),
     ]);
   });