fix: preserve idless Gemini tool cycles

* fix: preserve idless Gemini tool cycles

* fix: count idless tool responses

Author: superdav42

includes/Core/AbilityFunctionResolver.php

@@ -61,7 +61,10 @@ public function __construct( ...$abilities ) {
 	 */
 	public function execute_ability( FunctionCall $call ): FunctionResponse {
 		$function_name = $call->getName() ?? 'unknown';
-		$function_id   = $call->getId() ?? 'unknown';
+		// Older Gemini models omit function call IDs. Keep an empty internal ID
+		// so the response pairs with the idless call in conversation history;
+		// the Google provider omits empty IDs when serializing the next request.
+		$function_id = $call->getId() ?? '';
 
 		if ( ! $this->is_ability_call( $call ) ) {
 			return new FunctionResponse(

includes/Core/ConversationTrimmer.php

@@ -1239,8 +1239,6 @@ public static function validate_tool_pairs( array $history ): array {
 				}
 				++$call_end;
 			}
-			$tool_call_ids = array_values( array_unique( $tool_call_ids ) );
-
 			// Collect the tool-response messages that follow the entire call cluster.
 			$response_ids   = [];
 			$response_start = $call_end;
@@ -1258,10 +1256,10 @@ public static function validate_tool_pairs( array $history ): array {
 				}
 			}
 
-			// Check if ALL tool_call IDs have matching responses.
-			$missing = array_diff( $tool_call_ids, $response_ids );
-
-			if ( empty( $missing ) ) {
+			// Check if every tool call has its own matching response. Counts matter
+			// because older Gemini models may omit IDs from parallel calls, causing
+			// multiple calls and responses to share the empty-string compatibility ID.
+			if ( self::has_matching_tool_responses( $tool_call_ids, $response_ids ) ) {
 				// All tool calls have responses — keep the entire split cycle.
 				for ( $j = $call_start; $j < $call_end; $j++ ) {
 					$result[] = $history[ $j ];
@@ -1279,6 +1277,26 @@ public static function validate_tool_pairs( array $history ): array {
 		return self::strip_orphan_tool_responses( $result );
 	}
 
+	/**
+	 * Determine whether each tool call ID has a distinct matching response ID.
+	 *
+	 * @param string[] $tool_call_ids Tool call IDs, including duplicate empty IDs.
+	 * @param string[] $response_ids  Tool response IDs, including duplicate empty IDs.
+	 */
+	private static function has_matching_tool_responses( array $tool_call_ids, array $response_ids ): bool {
+		$response_counts = array_count_values( $response_ids );
+
+		foreach ( $tool_call_ids as $tool_call_id ) {
+			if ( empty( $response_counts[ $tool_call_id ] ) ) {
+				return false;
+			}
+
+			--$response_counts[ $tool_call_id ];
+		}
+
+		return true;
+	}
+
 	/**
 	 * Strip FunctionResponse parts whose tool_use_id has no matching tool_use.
 	 *

tests/SdAiAgent/Core/AbilityFunctionResolverTest.php

@@ -15,8 +15,13 @@
 use SdAiAgent\Abilities\KnowledgeAbilities;
 use SdAiAgent\Core\AbilityRegistry;
 use SdAiAgent\Core\AbilityFunctionResolver;
+use SdAiAgent\Core\ConversationTrimmer;
 use SdAiAgent\Core\IdenticalFailureTracker;
+use WordPress\AiClient\Messages\DTO\MessagePart;
+use WordPress\AiClient\Messages\DTO\ModelMessage;
+use WordPress\AiClient\Messages\DTO\UserMessage;
 use WordPress\AiClient\Tools\DTO\FunctionCall;
+use WordPress\AiClient\Tools\DTO\FunctionResponse;
 use WP_UnitTestCase;
 
 final class ThrowingValidationAbility extends \WP_Ability {
@@ -128,6 +133,60 @@ public function test_empty_arguments_return_schema_guidance_without_dispatching(
 		$this->assertStringContainsString( 'Do not retry with empty arguments', $payload['hint'] );
 	}
 
+	/**
+	 * Test that an idless Gemini call and response survive history validation.
+	 */
+	public function test_idless_function_call_response_remains_in_gemini_history(): void {
+		$this->skip_if_resolver_unavailable();
+
+		$ability = $this->register_schema_thrower_ability();
+		$this->assertNotNull( $ability );
+
+		$function_name = \WP_AI_Client_Ability_Function_Resolver::ability_name_to_function_name( 'test-plugin/schema-thrower' );
+		$call          = new FunctionCall( null, $function_name, array( 'query' => 'trigger callback validation exception' ) );
+		$resolver      = new AbilityFunctionResolver( $ability );
+		$response      = $resolver->execute_ability( $call );
+
+		$this->assertNull( $call->getId() );
+		$this->assertSame( '', $response->getId() );
+
+		$history = array(
+			new ModelMessage( array( new MessagePart( $call ) ) ),
+			new UserMessage( array( new MessagePart( $response ) ) ),
+		);
+
+		$validated = ConversationTrimmer::validate_tool_pairs( $history );
+		$this->assertCount( 2, $validated );
+		$this->assertSame( $history[0], $validated[0] );
+		$this->assertSame( $history[1], $validated[1] );
+	}
+
+	/**
+	 * Test parallel idless calls require one response per call.
+	 */
+	public function test_parallel_idless_calls_require_distinct_responses(): void {
+		$first_user_message = new UserMessage( array( new MessagePart( 'Do two things' ) ) );
+		$first_call         = new FunctionCall( null, 'tool-a', array() );
+		$second_call        = new FunctionCall( null, 'tool-b', array() );
+		$call_message       = new ModelMessage(
+			array(
+				new MessagePart( $first_call ),
+				new MessagePart( $second_call ),
+			)
+		);
+		$response_message = new UserMessage(
+			array( new MessagePart( new FunctionResponse( '', 'tool-a', '{"success":true}' ) ) )
+		);
+		$next_user_message = new UserMessage( array( new MessagePart( 'What happened?' ) ) );
+		$history           = array( $first_user_message, $call_message, $response_message, $next_user_message );
+
+		$validated = ConversationTrimmer::validate_tool_pairs( $history );
+
+		$this->assertCount( 2, $validated );
+		$this->assertSame( $first_user_message, $validated[0] );
+		$this->assertSame( $next_user_message, $validated[1] );
+	}
+
 	public function test_public_knowledge_search_hydrates_empty_args_from_customer_query(): void {
 		$this->skip_if_resolver_unavailable();
 		$this->ensure_knowledge_search_registered();