fix(core): inject thinking blocks for DeepSeek anthropic-compatible provider

packages/core/src/core/anthropicContentGenerator/anthropicContentGenerator.test.ts

@@ -494,6 +494,305 @@ describe('AnthropicContentGenerator', () => {
     });
   });
 
+  // https://github.com/QwenLM/qwen-code/issues/3786 — DeepSeek's
+  // anthropic-compatible API rejects subsequent requests when any prior
+  // assistant turn omits a thinking block while thinking mode is on.
+  describe('DeepSeek anthropic-compatible provider', () => {
+    // Helper: tool-use assistant turn missing thinking — the only shape that
+    // actually triggers DeepSeek's HTTP 400.
+    const toolUseConversation = [
+      { role: 'user' as const, parts: [{ text: 'Run tool' }] },
+      {
+        role: 'model' as const,
+        parts: [{ functionCall: { id: 't1', name: 'tool', args: {} } }],
+      },
+      {
+        role: 'user' as const,
+        parts: [
+          {
+            functionResponse: {
+              id: 't1',
+              name: 'tool',
+              response: { output: 'ok' },
+            },
+          },
+        ],
+      },
+    ];
+
+    it('injects empty thinking blocks on tool-use assistant turns when baseUrl is api.deepseek.com', async () => {
+      const { AnthropicContentGenerator } = await importGenerator();
+      anthropicState.createImpl.mockResolvedValue({
+        id: 'msg-1',
+        model: 'deepseek-v4-pro',
+        content: [{ type: 'text', text: 'ok' }],
+      });
+
+      const generator = new AnthropicContentGenerator(
+        {
+          model: 'deepseek-v4-pro',
+          apiKey: 'test-key',
+          baseUrl: 'https://api.deepseek.com/anthropic',
+          timeout: 10_000,
+          maxRetries: 2,
+          samplingParams: { max_tokens: 500 },
+          schemaCompliance: 'auto',
+        },
+        mockConfig,
+      );
+
+      await generator.generateContent({
+        model: 'models/ignored',
+        contents: toolUseConversation,
+      } as unknown as GenerateContentParameters);
+
+      const [anthropicRequest] =
+        anthropicState.lastCreateArgs as AnthropicCreateArgs;
+      const messages = (anthropicRequest as { messages: unknown[] }).messages;
+
+      expect(messages[1]).toEqual({
+        role: 'assistant',
+        content: [
+          { type: 'thinking', thinking: '', signature: '' },
+          { type: 'tool_use', id: 't1', name: 'tool', input: {} },
+        ],
+      });
+    });
+
+    it('detects deepseek by model name even when baseUrl is different', async () => {
+      const { AnthropicContentGenerator } = await importGenerator();
+      anthropicState.createImpl.mockResolvedValue({
+        id: 'msg-1',
+        model: 'deepseek-v4-pro',
+        content: [{ type: 'text', text: 'ok' }],
+      });
+
+      const generator = new AnthropicContentGenerator(
+        {
+          model: 'deepseek-v4-pro',
+          apiKey: 'test-key',
+          baseUrl: 'https://my-proxy.example.com/anthropic',
+          timeout: 10_000,
+          maxRetries: 2,
+          samplingParams: { max_tokens: 500 },
+          schemaCompliance: 'auto',
+        },
+        mockConfig,
+      );
+
+      await generator.generateContent({
+        model: 'models/ignored',
+        contents: toolUseConversation,
+      } as unknown as GenerateContentParameters);
+
+      const [anthropicRequest] =
+        anthropicState.lastCreateArgs as AnthropicCreateArgs;
+      const messages = (anthropicRequest as { messages: unknown[] }).messages;
+
+      expect(messages[1]).toEqual({
+        role: 'assistant',
+        content: [
+          { type: 'thinking', thinking: '', signature: '' },
+          { type: 'tool_use', id: 't1', name: 'tool', input: {} },
+        ],
+      });
+    });
+
+    it('matches regional DeepSeek subdomains (e.g. us.api.deepseek.com)', async () => {
+      const { AnthropicContentGenerator } = await importGenerator();
+      anthropicState.createImpl.mockResolvedValue({
+        id: 'msg-1',
+        model: 'unrelated-model',
+        content: [{ type: 'text', text: 'ok' }],
+      });
+
+      const generator = new AnthropicContentGenerator(
+        {
+          model: 'unrelated-model',
+          apiKey: 'test-key',
+          baseUrl: 'https://us.api.deepseek.com/anthropic',
+          timeout: 10_000,
+          maxRetries: 2,
+          samplingParams: { max_tokens: 500 },
+          schemaCompliance: 'auto',
+        },
+        mockConfig,
+      );
+
+      await generator.generateContent({
+        model: 'models/ignored',
+        contents: toolUseConversation,
+      } as unknown as GenerateContentParameters);
+
+      const [anthropicRequest] =
+        anthropicState.lastCreateArgs as AnthropicCreateArgs;
+      const messages = (anthropicRequest as { messages: unknown[] }).messages;
+
+      expect(messages[1]).toEqual({
+        role: 'assistant',
+        content: [
+          { type: 'thinking', thinking: '', signature: '' },
+          { type: 'tool_use', id: 't1', name: 'tool', input: {} },
+        ],
+      });
+    });
+
+    const toolOnlyAssistant = {
+      role: 'assistant',
+      content: [{ type: 'tool_use', id: 't1', name: 'tool', input: {} }],
+    };
+
+    it('does not inject empty thinking blocks for non-deepseek providers', async () => {
+      const { AnthropicContentGenerator } = await importGenerator();
+      anthropicState.createImpl.mockResolvedValue({
+        id: 'msg-1',
+        model: 'claude-test',
+        content: [{ type: 'text', text: 'ok' }],
+      });
+
+      const generator = new AnthropicContentGenerator(
+        {
+          model: 'claude-test',
+          apiKey: 'test-key',
+          baseUrl: 'https://api.anthropic.com',
+          timeout: 10_000,
+          maxRetries: 2,
+          samplingParams: { max_tokens: 500 },
+          schemaCompliance: 'auto',
+        },
+        mockConfig,
+      );
+
+      await generator.generateContent({
+        model: 'models/ignored',
+        contents: toolUseConversation,
+      } as unknown as GenerateContentParameters);
+
+      const [anthropicRequest] =
+        anthropicState.lastCreateArgs as AnthropicCreateArgs;
+      const messages = (anthropicRequest as { messages: unknown[] }).messages;
+
+      // Non-deepseek provider: even tool_use turns get no injection.
+      expect(messages[1]).toEqual(toolOnlyAssistant);
+    });
+
+    it('does not match spoofed hostnames like api.deepseek.com.evil.com', async () => {
+      const { AnthropicContentGenerator } = await importGenerator();
+      anthropicState.createImpl.mockResolvedValue({
+        id: 'msg-1',
+        model: 'claude-test',
+        content: [{ type: 'text', text: 'ok' }],
+      });
+
+      const generator = new AnthropicContentGenerator(
+        {
+          model: 'claude-test',
+          apiKey: 'test-key',
+          baseUrl: 'https://api.deepseek.com.evil.com/anthropic',
+          timeout: 10_000,
+          maxRetries: 2,
+          samplingParams: { max_tokens: 500 },
+          schemaCompliance: 'auto',
+        },
+        mockConfig,
+      );
+
+      await generator.generateContent({
+        model: 'models/ignored',
+        contents: toolUseConversation,
+      } as unknown as GenerateContentParameters);
+
+      const [anthropicRequest] =
+        anthropicState.lastCreateArgs as AnthropicCreateArgs;
+      const messages = (anthropicRequest as { messages: unknown[] }).messages;
+
+      // Hostname differs from api.deepseek.com — must not inject even on
+      // tool_use turns.
+      expect(messages[1]).toEqual(toolOnlyAssistant);
+    });
+
+    it('does not inject when reasoning is explicitly disabled', async () => {
+      // Even on a confirmed-DeepSeek provider with a tool-use turn, if the
+      // request omits the top-level `thinking` parameter (because
+      // reasoning=false), shipping synthetic thinking blocks would be a
+      // protocol violation.
+      const { AnthropicContentGenerator } = await importGenerator();
+      anthropicState.createImpl.mockResolvedValue({
+        id: 'msg-1',
+        model: 'deepseek-v4-pro',
+        content: [{ type: 'text', text: 'ok' }],
+      });
+
+      const generator = new AnthropicContentGenerator(
+        {
+          model: 'deepseek-v4-pro',
+          apiKey: 'test-key',
+          baseUrl: 'https://api.deepseek.com/anthropic',
+          timeout: 10_000,
+          maxRetries: 2,
+          samplingParams: { max_tokens: 500 },
+          schemaCompliance: 'auto',
+          reasoning: false,
+        },
+        mockConfig,
+      );
+
+      await generator.generateContent({
+        model: 'models/ignored',
+        contents: toolUseConversation,
+      } as unknown as GenerateContentParameters);
+
+      const [anthropicRequest] =
+        anthropicState.lastCreateArgs as AnthropicCreateArgs;
+      const messages = (anthropicRequest as { messages: unknown[] }).messages;
+
+      expect(anthropicRequest).toEqual(
+        expect.not.objectContaining({ thinking: expect.anything() }),
+      );
+      expect(messages[1]).toEqual(toolOnlyAssistant);
+    });
+
+    it('does not inject when request sets thinkingConfig.includeThoughts=false', async () => {
+      // Same concern as above but for the per-request override used by
+      // suggestionGenerator / forkedAgent / ArenaManager.
+      const { AnthropicContentGenerator } = await importGenerator();
+      anthropicState.createImpl.mockResolvedValue({
+        id: 'msg-1',
+        model: 'deepseek-v4-pro',
+        content: [{ type: 'text', text: 'ok' }],
+      });
+
+      const generator = new AnthropicContentGenerator(
+        {
+          model: 'deepseek-v4-pro',
+          apiKey: 'test-key',
+          baseUrl: 'https://api.deepseek.com/anthropic',
+          timeout: 10_000,
+          maxRetries: 2,
+          samplingParams: { max_tokens: 500 },
+          schemaCompliance: 'auto',
+          reasoning: { effort: 'medium' },
+        },
+        mockConfig,
+      );
+
+      await generator.generateContent({
+        model: 'models/ignored',
+        contents: toolUseConversation,
+        config: { thinkingConfig: { includeThoughts: false } },
+      } as unknown as GenerateContentParameters);
+
+      const [anthropicRequest] =
+        anthropicState.lastCreateArgs as AnthropicCreateArgs;
+      const messages = (anthropicRequest as { messages: unknown[] }).messages;
+
+      expect(anthropicRequest).toEqual(
+        expect.not.objectContaining({ thinking: expect.anything() }),
+      );
+      expect(messages[1]).toEqual(toolOnlyAssistant);
+    });
+  });
+
   describe('countTokens', () => {
     it('counts tokens using the request tokenizer', async () => {
       const { AnthropicContentGenerator } = await importGenerator();

packages/core/src/core/anthropicContentGenerator/anthropicContentGenerator.ts

@@ -39,6 +39,33 @@ import {
 
 const debugLogger = createDebugLogger('ANTHROPIC');
 
+/**
+ * DeepSeek's anthropic-compatible API rejects requests in thinking mode that
+ * omit a thinking block on prior assistant turns. Detect by base URL hostname
+ * or model name so the converter can inject empty thinking blocks where
+ * missing. https://github.com/QwenLM/qwen-code/issues/3786
+ */
+function isDeepSeekAnthropicProvider(
+  contentGeneratorConfig: ContentGeneratorConfig,
+): boolean {
+  const baseUrl = contentGeneratorConfig.baseUrl ?? '';
+  if (baseUrl) {
+    try {
+      const hostname = new URL(baseUrl).hostname.toLowerCase();
+      if (
+        hostname === 'api.deepseek.com' ||
+        hostname.endsWith('.api.deepseek.com')
+      ) {
+        return true;
+      }
+    } catch {
+      // Invalid URL — fall through to model-name detection.
+    }
+  }
+  const model = (contentGeneratorConfig.model ?? '').toLowerCase();
+  return model.includes('deepseek');
+}
+
 type StreamingBlockState = {
   type: string;
   id?: string;
@@ -57,6 +84,7 @@ type MessageCreateParamsWithThinking = MessageCreateParamsNonStreaming & {
 export class AnthropicContentGenerator implements ContentGenerator {
   private client: Anthropic;
   private converter: AnthropicContentConverter;
+  private readonly isDeepSeekProvider: boolean;
 
   constructor(
     private contentGeneratorConfig: ContentGeneratorConfig,
@@ -85,6 +113,9 @@ export class AnthropicContentGenerator implements ContentGenerator {
       contentGeneratorConfig.schemaCompliance,
       contentGeneratorConfig.enableCacheControl,
     );
+    this.isDeepSeekProvider = isDeepSeekAnthropicProvider(
+      contentGeneratorConfig,
+    );
   }
 
   async generateContent(
@@ -186,17 +217,27 @@ export class AnthropicContentGenerator implements ContentGenerator {
   private async buildRequest(
     request: GenerateContentParameters,
   ): Promise<MessageCreateParamsWithThinking> {
-    const { system, messages } =
-      this.converter.convertGeminiRequestToAnthropic(request);
+    const sampling = this.buildSamplingParameters(request);
+    const thinking = this.buildThinkingConfig(request);
+    const outputConfig = this.buildOutputConfig();
+
+    // Only ask the converter to inject empty thinking blocks when both the
+    // provider needs them AND this request actually enables thinking mode.
+    // Otherwise we'd ship thinking blocks without the top-level `thinking`
+    // parameter — a protocol violation that DeepSeek rejects with a different
+    // 400. Matters for code paths that pass `includeThoughts: false`
+    // (suggestionGenerator / ArenaManager / forkedAgent).
+    const ensureAssistantThinking = this.isDeepSeekProvider && !!thinking;
+
+    const { system, messages } = this.converter.convertGeminiRequestToAnthropic(
+      request,
+      { ensureAssistantThinking },
+    );
 
     const tools = request.config?.tools
       ? await this.converter.convertGeminiToolsToAnthropic(request.config.tools)
       : undefined;
 
-    const sampling = this.buildSamplingParameters(request);
-    const thinking = this.buildThinkingConfig(request);
-    const outputConfig = this.buildOutputConfig();
-
     return {
       model: this.contentGeneratorConfig.model,
       system,