fix(core,a2a): group cancelled tool responses and coalesce consecutive roles to prevent 400 Bad Request

[luisfelipe-alt]

Summary

This PR fixes the severe 400 Bad Request error that occurs when a user sends a subsequent prompt after rejecting/cancelling tool calls in a chat session. This issue was highly disruptive as it completely broke chat continuity, forcing users to start a new chat session and lose all context.

Details

The 400 Bad Request error was caused by two distinct history corruption bugs that violated the Gemini API's strict conversation history schema:

1. Issue A (Parallel Tool Rejections): In packages/a2a-server/src/agent/task.ts, the addToolResponsesToHistory method looped over completed (cancelled) tools and added each one as a separate user turn. This violated the Gemini API requirement that all parallel tool responses must be grouped within a single user turn.

   • Fix: Refactored addToolResponsesToHistory to group all cancelled tool responses into a single user turn with multiple functionResponse parts.

2. Issue B (Consecutive User Turns): Even for a single tool rejection, a user turn is added for the rejection, and the next prompt adds another consecutive user turn. Because contextManagement is disabled by default, these consecutive user turns were sent directly to the Gemini API, violating its strict role-alternation protocol.

   • Fix: Added a lightweight coalesceConsecutiveRoles helper function and integrated it into makeApiCallAndProcessStream in packages/core/src/core/geminiChat.ts to always merge consecutive turns of the same role before sending history to the Gemini API. This ensures consecutive user turns are always coalesced, while perfectly preserving thoughts and binary injections when context management is disabled.

Related Issues

How to Validate

1. Install Dependencies & Build:

   npm install && npm run build

2. Run A2A Server Tests:

   npx vitest run packages/a2a-server

   Verify that all 140 tests pass successfully.

3. Run Core Chat Tests:

   npx vitest run packages/core/src/core/geminiChat.test.ts --test-timeout=15000

   Verify that all 60 tests pass successfully (including the complex binary injection tests).

4. Run Linter:

   npm run lint

   Verify that the linter passes with 0 warnings and 0 errors.

Pre-Merge Checklist

• Updated relevant documentation and README (if needed)
• Added/updated tests (if needed)
• Noted breaking changes (if any)
• Validated on required platforms/methods:
  • MacOS
    • npm run
    • npx
    • Docker
    • Podman
    • Seatbelt
  • Windows
    • npm run
    • npx
    • Docker
  • Linux
    • npm run
    • npx
    • Docker

[gemini-code-assist]

Summary of Changes

Hello, I'm Gemini Code Assist¹! I'm currently reviewing this pull request and will post my feedback shortly. In the meantime, here's a summary to help you and other reviewers quickly get up to speed!

This pull request addresses critical API communication failures that caused 400 Bad Request errors during chat sessions. By ensuring that tool responses are correctly grouped and that consecutive user turns are coalesced before being sent to the Gemini API, the changes restore chat continuity and ensure strict adherence to the API's conversation history schema.

Highlights

• Parallel Tool Response Grouping: Refactored the tool response handling in the agent task to aggregate all cancelled tool responses into a single user turn, satisfying the Gemini API requirement for grouped tool responses.
• Consecutive Role Coalescing: Introduced a new helper function to merge consecutive turns with the same role, preventing 400 Bad Request errors caused by invalid role-alternation sequences.

Using Gemini Code Assist

The full guide for Gemini Code Assist can be found on our documentation page, here are some quick tips.

Invoking Gemini

You can request assistance from Gemini at any point by creating a comment using either /gemini <command> or @gemini-code-assist <command>. Below is a summary of the supported commands on the current page.

Feature	Command	Description
Code Review	/gemini review	Performs a code review for the current pull request in its current state.
Pull Request Summary	/gemini summary	Provides a summary of the current pull request in its current state.
Comment	@gemini-code-assist	Responds in comments when explicitly tagged, both in pull request comments and review comments.
Help	/gemini help	Displays a list of available commands.

Customization

To customize the Gemini Code Assist for GitHub experience, repository maintainers can create a configuration file and/or provide a custom code review style guide (such as PEP-8 for Python) by creating and adding files to a .gemini/ folder in the base of the repository. Detailed instructions can be found here.

Limitations & Feedback

Gemini Code Assist may make mistakes. Please leave feedback on any instances where its feedback is incorrect or counterproductive. You can react with 👍 and 👎 on @gemini-code-assist comments. If you're interested in giving your feedback about your experience with Gemini Code Assist for GitHub and other Google products, sign up here.

Footnotes

1. Review the Privacy Notices, Generative AI Prohibited Use Policy, Terms of Service, and learn how to configure Gemini Code Assist in GitHub here. Gemini can make mistakes, so double check it and use code with caution. ↩

[github-actions]

📊 PR Size: size/M

• Lines changed: 112
• Additions: +102
• Deletions: -10
• Files changed: 3

[gemini-code-assist]

Code Review

This pull request refactors how tool responses are collected and added to history in task.ts, and introduces a new utility coalesceConsecutiveRoles in geminiChat.ts to merge consecutive history turns with the same role. The review feedback highlights two critical issues: first, a potential TypeError in task.ts if toolCall.response is undefined or nullish; second, an issue in coalesceConsecutiveRoles where consecutive turns with undefined roles could be incorrectly coalesced. Both comments provide actionable code suggestions to resolve these issues.

[luisfelipe-alt]

/gemini review

[gemini-code-assist]

Code Review

This pull request refactors tool response aggregation in the a2a-server agent task to safely batch history updates, and introduces a coalesceConsecutiveRoles utility in GeminiChat to merge consecutive turns with the same role and prevent 400 Bad Request errors. The feedback recommends shallow-cloning history turns within coalesceConsecutiveRoles to avoid accidental mutations of the underlying chat history.

[luisfelipe-alt]

/gemini review

[gemini-code-assist]

Code Review

This pull request refactors the tool response handling in packages/a2a-server to aggregate response parts and perform a single history update. It also introduces a coalesceConsecutiveRoles utility in packages/core to merge consecutive history turns with the same role, preventing potential 400 Bad Request errors from the Gemini API. There are no review comments, so I have no feedback to provide.

[DavidAPierce]

Overall the changes LGTM, and the checks are passing. These changes should be accompanied by unit tests however, so a formal LGTM should wait on their implementation. See below:

1. Add unit tests for role coalescing

To ensure the new coalesceConsecutiveRoles function remains correct as the
project evolves, we recommend adding unit tests to
packages/core/src/core/geminiChat.test.ts.

Below is a complete test suite that can be pasted directly into
packages/core/src/core/geminiChat.test.ts inside the GeminiChat describe block:

  describe('coalesceConsecutiveRoles', () => {
    it('should return empty history if empty array is passed', () => {
      expect(coalesceConsecutiveRoles([])).toEqual([]);
    });

    it('should not modify history when roles alternate correctly', () => {
      const history: HistoryTurn[] = [
        { id: '1', content: { role: 'user', parts: [{ text: 'hello' }] } },
        { id: '2', content: { role: 'model', parts: [{ text: 'hi' }] } },
        { id: '3', content: { role: 'user', parts: [{ text: 'how are you?' }] } },
      ];
      expect(coalesceConsecutiveRoles(history)).toEqual(history);
    });

    it('should coalesce consecutive user turns', () => {
      const history: HistoryTurn[] = [
        { id: '1', content: { role: 'user', parts: [{ text: 'hello' }] } },
        { id: '2', content: { role: 'user', parts: [{ text: 'world' }] } },
      ];
      expect(coalesceConsecutiveRoles(history)).toEqual([
        {
          id: '1',
          content: {
            role: 'user',
            parts: [{ text: 'hello' }, { text: 'world' }],
          },
        },
      ]);
    });

    it('should handle undefined or missing parts gracefully', () => {
      const history: HistoryTurn[] = [
        { id: '1', content: { role: 'user' } },
        { id: '2', content: { role: 'user', parts: [{ text: 'world' }] } },
      ];
      expect(coalesceConsecutiveRoles(history)).toEqual([
        {
          id: '1',
          content: {
            role: 'user',
            parts: [{ text: 'world' }],
          },
        },
      ]);
    });

    it('should not coalesce turns if roles are undefined', () => {
      const history: HistoryTurn[] = [
        { id: '1', content: { parts: [{ text: 'hello' }] } },
        { id: '2', content: { parts: [{ text: 'world' }] } },
      ];
      expect(coalesceConsecutiveRoles(history)).toEqual(history);
    });
  });

2. Verify behavior in integration tests

Since this PR targets a high-impact crash, verifying this specific scenario in the
end-to-end (E2E) integration tests would ensure high confidence. Running the E2E
suite via npm run test:e2e can confirm that cancelling a tool call followed by
another message does not crash the chat flow.

[luisfelipe-alt]

/gemini review

[gemini-code-assist]

Code Review

This pull request introduces a mechanism to coalesce consecutive history turns with the same role in GeminiChat to prevent API errors, and refactors how tool responses are added to history in Task by aggregating parts into a single history entry. It also adds unit tests for the new coalesceConsecutiveRoles function. The review feedback points out a critical issue in coalesceConsecutiveRoles where merging turns with missing or undefined parts results in an empty parts array, which would trigger a 400 Bad Request error from the Gemini API. A code suggestion is provided to ensure parts remains undefined if no parts are present.

[luisfelipe-alt]

/gemini review

[gemini-code-assist]

Code Review

This pull request introduces a mechanism to coalesce consecutive history turns with the same role in GeminiChat to prevent 400 Bad Request errors from the Gemini API. It also refactors how tool responses are added to history in the agent task runner to handle response parts more robustly and efficiently. Comprehensive unit tests have been added for the new coalesceConsecutiveRoles function. No review comments were provided, so there is no additional feedback to address.

[luisfelipe-alt]

Overall the changes LGTM, and the checks are passing. These changes should be accompanied by unit tests however, so a formal LGTM should wait on their implementation. See below:

1. Add unit tests for role coalescing

To ensure the new coalesceConsecutiveRoles function remains correct as the project evolves, we recommend adding unit tests to packages/core/src/core/geminiChat.test.ts.

Below is a complete test suite that can be pasted directly into packages/core/src/core/geminiChat.test.ts inside the GeminiChat describe block:

  describe('coalesceConsecutiveRoles', () => {
    it('should return empty history if empty array is passed', () => {
      expect(coalesceConsecutiveRoles([])).toEqual([]);
    });

    it('should not modify history when roles alternate correctly', () => {
      const history: HistoryTurn[] = [
        { id: '1', content: { role: 'user', parts: [{ text: 'hello' }] } },
        { id: '2', content: { role: 'model', parts: [{ text: 'hi' }] } },
        { id: '3', content: { role: 'user', parts: [{ text: 'how are you?' }] } },
      ];
      expect(coalesceConsecutiveRoles(history)).toEqual(history);
    });

    it('should coalesce consecutive user turns', () => {
      const history: HistoryTurn[] = [
        { id: '1', content: { role: 'user', parts: [{ text: 'hello' }] } },
        { id: '2', content: { role: 'user', parts: [{ text: 'world' }] } },
      ];
      expect(coalesceConsecutiveRoles(history)).toEqual([
        {
          id: '1',
          content: {
            role: 'user',
            parts: [{ text: 'hello' }, { text: 'world' }],
          },
        },
      ]);
    });

    it('should handle undefined or missing parts gracefully', () => {
      const history: HistoryTurn[] = [
        { id: '1', content: { role: 'user' } },
        { id: '2', content: { role: 'user', parts: [{ text: 'world' }] } },
      ];
      expect(coalesceConsecutiveRoles(history)).toEqual([
        {
          id: '1',
          content: {
            role: 'user',
            parts: [{ text: 'world' }],
          },
        },
      ]);
    });

    it('should not coalesce turns if roles are undefined', () => {
      const history: HistoryTurn[] = [
        { id: '1', content: { parts: [{ text: 'hello' }] } },
        { id: '2', content: { parts: [{ text: 'world' }] } },
      ];
      expect(coalesceConsecutiveRoles(history)).toEqual(history);
    });
  });

2. Verify behavior in integration tests

Since this PR targets a high-impact crash, verifying this specific scenario in the end-to-end (E2E) integration tests would ensure high confidence. Running the E2E suite via npm run test:e2e can confirm that cancelling a tool call followed by another message does not crash the chat flow.

Hi @DavidAPierce , I have applied the changes. The code is ready for next round of code review.