--> still having testToolCallingWithoutExecution() in SpringAiOpenAiTest.java failing.

--> still fix of null of message.getText() in toAssistantMessage() method in OpenAiChatModel.java pending.

Author: n-o-u-r-h-a-n

foundation-models/openai/src/main/java/com/sap/ai/sdk/foundationmodels/openai/spring/OpenAiChatModel.java

@@ -1,5 +1,6 @@
 package com.sap.ai.sdk.foundationmodels.openai.spring;
 
+import static com.sap.ai.sdk.foundationmodels.openai.OpenAiMessage.tool;
 import static org.springframework.ai.model.tool.ToolCallingChatOptions.isInternalToolExecutionEnabled;
 
 import com.sap.ai.sdk.foundationmodels.openai.OpenAiAssistantMessage;
@@ -11,17 +12,18 @@
 import com.sap.ai.sdk.foundationmodels.openai.OpenAiMessageContent;
 import com.sap.ai.sdk.foundationmodels.openai.OpenAiTextItem;
 import com.sap.ai.sdk.foundationmodels.openai.OpenAiToolCall;
+import com.sap.ai.sdk.foundationmodels.openai.generated.model.ChatCompletionMessageToolCall;
 import com.sap.ai.sdk.foundationmodels.openai.generated.model.ChatCompletionResponseMessage;
-import io.vavr.control.Option;
+
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
-import java.util.stream.Stream;
+import java.util.function.Function;
 import javax.annotation.Nonnull;
 import lombok.RequiredArgsConstructor;
 import lombok.val;
-import org.springframework.ai.chat.messages.AssistantMessage;
+import org.springframework.ai.chat.messages.*;
 import org.springframework.ai.chat.messages.AssistantMessage.ToolCall;
-import org.springframework.ai.chat.messages.ToolResponseMessage;
 import org.springframework.ai.chat.model.ChatModel;
 import org.springframework.ai.chat.model.ChatResponse;
 import org.springframework.ai.chat.model.Generation;
@@ -47,10 +49,13 @@ public ChatResponse call(@Nonnull final Prompt prompt) {
       throw new IllegalArgumentException(
           "Please add OpenAiChatOptions to the Prompt: new Prompt(\"message\", new OpenAiChatOptions(config))");
     }
+    System.out.println("I entered OpenAiChatModel.call() with tools: " + options.getTools());
+    val openAiRequest = toOpenAiRequest(prompt);
+    val request = new OpenAiChatCompletionRequest(openAiRequest).withTools(options.getTools());
+    val result = client.chatCompletion(request);
+    val response = new ChatResponse(toGenerations(result));
 
-    val request =
-        new OpenAiChatCompletionRequest(toOpenAiRequest(prompt)).withTools(options.getTools());
-    val response = new ChatResponse(toGenerations(client.chatCompletion(request)));
+    System.out.println("I entered OpenAiChatModel.call() with response: " + response);
 
     if (isInternalToolExecutionEnabled(prompt.getOptions()) && response.hasToolCalls()) {
       val toolExecutionResult = toolCallingManager.executeToolCalls(prompt, response);
@@ -61,44 +66,33 @@ public ChatResponse call(@Nonnull final Prompt prompt) {
   }
 
   private List<OpenAiMessage> toOpenAiRequest(final Prompt prompt) {
-    return prompt.getInstructions().stream()
-        .flatMap(
-            message ->
-                switch (message.getMessageType()) {
-                  case USER ->
-                      Stream.of(
-                          OpenAiMessage.user(
-                              Option.of(message.getText()).getOrElse(message.getText())));
-                  case ASSISTANT -> {
-                    val assistantMessage = (AssistantMessage) message;
-                    yield Stream.of(
-                        assistantMessage.hasToolCalls()
-                            ? new OpenAiAssistantMessage(
-                                new OpenAiMessageContent(
-                                    List.of(
-                                        new OpenAiTextItem(
-                                            Option.of(message.getText())
-                                                .getOrElse(message.getText())))),
-                                assistantMessage.getToolCalls().stream()
-                                    .map(
-                                        toolCall ->
-                                            (OpenAiToolCall)
-                                                new OpenAiFunctionCall(
-                                                    toolCall.id(),
-                                                    toolCall.name(),
-                                                    toolCall.arguments()))
-                                    .toList())
-                            : new OpenAiAssistantMessage(
-                                Option.of(message.getText()).getOrElse(message.getText())));
-                  }
-                  case SYSTEM -> Stream.of(OpenAiMessage.system(message.getText()));
-                  case TOOL -> {
-                    val responses = ((ToolResponseMessage) message).getResponses();
-                    yield responses.stream()
-                        .map(resp -> OpenAiMessage.tool(resp.responseData(), resp.id()));
-                  }
-                })
-        .toList();
+    final List<OpenAiMessage> result = new ArrayList<>();
+    for (final Message message : prompt.getInstructions()) {
+      //if(((message.getMessageType() == MessageType.USER || message.getMessageType() ==MessageType.ASSISTANT || message.getMessageType() ==MessageType.SYSTEM ) && message.getText() != null) || (message.getMessageType() == MessageType.TOOL)) {
+      switch (message.getMessageType()) {
+        case USER -> result.add(OpenAiMessage.user(message.getText()));
+        case ASSISTANT -> result.add(toAssistantMessage((AssistantMessage) message));
+        case SYSTEM -> result.add(OpenAiMessage.system(message.getText()));
+        case TOOL -> result.addAll(toToolMessages((ToolResponseMessage) message));
+      }
+      //}
+    }
+    return result;
+  }
+
+  private static OpenAiAssistantMessage toAssistantMessage(AssistantMessage message) {
+    if (!message.hasToolCalls()) {
+      return OpenAiMessage.assistant(message.getText());
+    }
+    final Function<ToolCall, OpenAiToolCall> callTranslate =
+        toolCall -> new OpenAiFunctionCall(toolCall.id(), toolCall.name(), toolCall.arguments());
+    val content = new OpenAiMessageContent(List.of(new OpenAiTextItem(message.getText())));
+    val calls = message.getToolCalls().stream().map(callTranslate).toList();
+    return new OpenAiAssistantMessage(content, calls);
+  }
+
+  private static List<? extends OpenAiMessage> toToolMessages(ToolResponseMessage message) {
+    return message.getResponses().stream().map(r -> tool(r.responseData(), r.id())).toList();
   }
 
   @Nonnull