CR fixes: place tool call adding logic on the level above

Author: aozherelyeva

agents/agents-core/src/commonMain/kotlin/ai/koog/agents/core/dsl/extension/AIAgentNodes.kt

@@ -450,21 +450,6 @@ public fun AIAgentSubgraphBuilderBase<*, *>.nodeExecuteMultipleToolsAndSendResul
         }
 
         llm.writeSession {
-            /*
-            Ensure all originating tool-call messages exist in the prompt before adding results.
-            This is important when providers concatenate tool names/args and we normalize/split them,
-            producing synthesized calls that were not part of the original prompt history.
-             */
-            val existingCallIds = prompt.messages.filterIsInstance<Message.Tool.Call>().map { it.id }.toSet()
-            val missingCalls = toolCalls.filter { it.id !in existingCallIds }
-            if (missingCalls.isNotEmpty()) {
-                appendPrompt {
-                    tool {
-                        missingCalls.forEach { call(it) }
-                    }
-                }
-            }
-
             appendPrompt {
                 tool {
                     results.forEach { result(it) }
@@ -486,14 +471,8 @@ public fun AIAgentSubgraphBuilderBase<*, *>.nodeLLMSendMultipleToolResults(
 ): AIAgentNodeDelegate<List<ReceivedToolResult>, List<Message.Response>> =
     node(name) { results ->
         llm.writeSession {
-            /*
-            Ensure corresponding tool-call messages are present before adding results.
-             */
-            val existingCallIds = prompt.messages.filterIsInstance<Message.Tool.Call>().map { it.id }.toSet()
-            val missingCalls = results.filter { it.id !in existingCallIds }
             appendPrompt {
                 tool {
-                    missingCalls.forEach { call(it.id, it.tool, it.toolArgs.toString()) }
                     results.forEach { result(it) }
                 }
             }

prompt/prompt-executor/prompt-executor-clients/prompt-executor-openai-client/src/commonMain/kotlin/ai/koog/prompt/executor/clients/openai/OpenAILLMClient.kt

@@ -56,6 +56,9 @@ import io.github.oshai.kotlinlogging.KotlinLogging
 import io.ktor.client.HttpClient
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.filterNotNull
 import kotlinx.coroutines.withContext
@@ -371,16 +374,20 @@ public open class OpenAILLMClient(
             is OpenAIChatParams -> super.executeMultipleChoices(prompt, model, tools)
 
             is OpenAIResponsesParams -> {
-                // Responses API does not currently expose a native "n" parameter,
-                // so we issue multiple independent responses and aggregate them.
-                // This path is required for models like gpt-5.1-codex that only
-                // support the Responses endpoint and return 404 on Chat Completions.
+                /*
+                Responses API does not currently expose a native "n" parameter,
+                 so we issue multiple independent responses and aggregate them.
+                 This path is required for models like gpt-5.1-codex that only
+                 support the Responses endpoint and return 404 on Chat Completions.
+                 */
                 val choices = (params.numberOfChoices ?: 1).coerceAtLeast(1)
-                buildList {
-                    repeat(choices) {
-                        val response = getResponseWithResponsesAPI(prompt, params, model, tools)
-                        add(processResponsesAPIResponse(response))
-                    }
+                coroutineScope {
+                    List(choices) {
+                        async {
+                            val response = getResponseWithResponsesAPI(prompt, params, model, tools)
+                            processResponsesAPIResponse(response)
+                        }
+                    }.awaitAll()
                 }
             }
         }
@@ -769,7 +776,10 @@ public open class OpenAILLMClient(
                         add(InputContent.File(fileData = fileData, fileUrl = fileUrl, filename = part.fileName))
                     }
 
-                    else -> throw LLMClientException(clientName, "Unsupported attachment type: $part, for model: $model with Responses API")
+                    else -> throw LLMClientException(
+                        clientName,
+                        "Unsupported attachment type: $part, for model: $model with Responses API"
+                    )
                 }
             }
         }
@@ -811,7 +821,10 @@ public open class OpenAILLMClient(
                         metaInfo = metaInfo
                     )
 
-                    else -> throw LLMClientException(clientName, "Unexpected response from $clientName: no tool calls and no content")
+                    else -> throw LLMClientException(
+                        clientName,
+                        "Unexpected response from $clientName: no tool calls and no content"
+                    )
                 }
             }
     }

prompt/prompt-model/src/commonMain/kotlin/ai/koog/prompt/dsl/PromptBuilder.kt

@@ -259,14 +259,39 @@ public class PromptBuilder internal constructor(
          *
          * Tool results represent the output from executing a tool.
          *
+         * This method ensures that the corresponding tool call message exists in the prompt
+         * before adding the result. If the tool call is missing, it will be synthesized and
+         * added to maintain proper conversation flow.
+         *
+         * Problematic cases could potentially occur, when:
+         * 1. LLM providers concatenate tool names/args and normalize/split them, producing
+         *    synthesized calls that were not part of the original prompt history
+         * 2. Tool calls with null IDs get processed separately
+         * 3. Parallel tool execution results arrive before calls are recorded in prompt
+         *
          * @param result The tool result message to add
          */
         public fun result(result: Message.Tool.Result) {
-            this@PromptBuilder.messages
+            val existingCallIndex = this@PromptBuilder.messages
                 .indexOfLast { it is Message.Tool.Call && it.id == result.id }
-                .takeIf { it != -1 }
-                ?.let { index -> this@PromptBuilder.messages.add(index + 1, result) }
-                ?: throw IllegalStateException("Failed to add tool result: no call message with id ${result.id}")
+
+            if (existingCallIndex != -1) {
+                // Normal case: a corresponding tool call exists, so we just add its result after it
+                this@PromptBuilder.messages.add(existingCallIndex + 1, result)
+            } else {
+                // Missing tool call case: synthesize the call message and ensure all originating tool-call messages exist in the prompt before adding results
+                if (result.id != null) {
+                    val synthesizedCall = Message.Tool.Call(
+                        id = result.id,
+                        tool = result.tool,
+                        content = "Synthesized call for result",
+                        metaInfo = ResponseMetaInfo.create(clock)
+                    )
+                    this@PromptBuilder.messages.add(synthesizedCall)
+                }
+                // Add the result message at the end after a synthetic tool call
+                this@PromptBuilder.messages.add(result)
+            }
         }
 
         /**