test: OpenAiToolExecutor and improve error messages

Author: rpanackal

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

@@ -37,19 +37,19 @@
 public class OpenAiTool<I> {
 
   /** The name of the function. */
-  @Nonnull String name;
+  private @Nonnull String name;
 
   /** The model class for function request. */
-  @Nonnull Class<I> requestClass;
+  private @Nonnull Class<I> requestClass;
 
   /** An optional description of the function. */
-  @Nullable String description;
+  private @Nullable String description;
 
   /** An optional flag indicating whether the function parameters should be treated strictly. */
-  @Nullable Boolean strict;
+  private @Nullable Boolean strict;
 
   /** The function to be called. */
-  @Nullable Function<I, ?> function;
+  private @Nullable Function<I, ?> function;
 
   /**
    * Constructs an {@code OpenAiFunctionTool} with the specified name and a model class that
@@ -65,7 +65,7 @@ public OpenAiTool(@Nonnull final String name, @Nonnull final Class<I> requestCla
   @Nonnull
   Object execute(@Nonnull final I argument) {
     if (getFunction() == null) {
-      throw new IllegalStateException("Callback function is not set");
+      throw new IllegalStateException("Function must not be set to execute the tool.");
     }
     return getFunction().apply(argument);
   }

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

@@ -23,15 +23,17 @@ public class OpenAiToolExecutor {
 
   /**
    * Executes the given tool calls with the provided tools and returns the results as a list of
-   * {@link OpenAiToolMessage}.
+   * {@link OpenAiToolMessage} containing execution results encoded as JSON string.
    *
    * @param tools the list of tools to execute
    * @param toolCalls the list of tool calls with arguments
    * @return the list of tool messages with the results
+   * @throws IllegalArgumentException if the tool results cannot be serialized to JSON
    */
   @Nonnull
   public static List<OpenAiToolMessage> executeTools(
-      @Nonnull final List<OpenAiTool<?>> tools, @Nonnull final List<OpenAiToolCall> toolCalls) {
+      @Nonnull final List<OpenAiTool<?>> tools, @Nonnull final List<OpenAiToolCall> toolCalls)
+      throws IllegalArgumentException {
 
     final var toolMap = tools.stream().collect(Collectors.toMap(OpenAiTool::getName, tool -> tool));
 
@@ -56,11 +58,11 @@ private static <I> Object executeFunction(
   }
 
   @Nonnull
-  private static String serializeObject(@Nonnull final Object obj) {
+  private static String serializeObject(@Nonnull final Object obj) throws IllegalArgumentException {
     try {
       return JACKSON.writeValueAsString(obj);
     } catch (JsonProcessingException e) {
-      throw new IllegalArgumentException(e);
+      throw new IllegalArgumentException("Failed to serialize object to JSON", e);
     }
   }
 }

foundation-models/openai/src/test/java/com/sap/ai/sdk/foundationmodels/openai/OpenAiToolCallTest.java

@@ -0,0 +1,106 @@
+package com.sap.ai.sdk.foundationmodels.openai;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import java.util.List;
+import java.util.function.Function;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+class OpenAiToolTest {
+  private final OpenAiFunctionCall functionCallA =
+      new OpenAiFunctionCall("1", "functionA", "{\"key\":\"value\"}");
+  private final OpenAiFunctionCall functionCallB =
+      new OpenAiFunctionCall("2", "functionB", "{\"key\":\"value\"}");
+  private final OpenAiFunctionCall invalidFunctionCallA =
+      new OpenAiFunctionCall("3", "functionA", "{invalid-json}");
+
+  private static class Dummy {
+    record Request(String key) {}
+
+    record Response(String result) {}
+
+    static final Function<Dummy.Request, Dummy.Response> conCat =
+        request -> new Dummy.Response(request.key());
+  }
+
+  private OpenAiTool<Dummy.Request> toolA;
+
+  @BeforeEach
+  void setUp() {
+    toolA = new OpenAiTool<>("functionA", Dummy.Request.class);
+  }
+
+  @Test
+  void getArgumentsAsMapValid() {
+    final var result = functionCallA.getArgumentsAsMap();
+    assertThat(result).containsEntry("key", "value");
+  }
+
+  @Test
+  void getArgumentsAsMapInvalid() {
+    assertThatThrownBy(invalidFunctionCallA::getArgumentsAsMap)
+        .isInstanceOf(IllegalArgumentException.class)
+        .hasMessageContaining("Failed to parse JSON string");
+  }
+
+  @Test
+  void getArgumentsAsObjectValid() {
+    final Dummy.Request result = functionCallA.getArgumentsAsObject(toolA);
+    assertThat(result).isInstanceOf(Dummy.Request.class);
+    assertThat(result.key()).isEqualTo("value");
+  }
+
+  @Test
+  void getArgumentsAsObjectInvalid() {
+    assertThatThrownBy(() -> invalidFunctionCallA.getArgumentsAsObject(toolA))
+        .isInstanceOf(IllegalArgumentException.class)
+        .hasMessageContaining("Failed to parse JSON string");
+  }
+
+  @Test
+  void executeToolsValid() {
+    toolA.setFunction(Dummy.conCat);
+    final var result = OpenAiToolExecutor.executeTools(List.of(toolA), List.of(functionCallA));
+
+    assertThat(result).hasSize(1);
+    assertThat(result.get(0).toolCallId()).isEqualTo("1");
+    assertThat(((OpenAiTextItem) result.get(0).content().items().get(0)).text())
+        .isEqualTo("{\"result\":\"value\"}");
+  }
+
+  @Test
+  void executeToolsThrowsOnNoFunction() {
+    assertThatThrownBy(
+            () -> OpenAiToolExecutor.executeTools(List.of(toolA), List.of(functionCallA)))
+        .isInstanceOf(IllegalStateException.class)
+        .hasMessageContaining("Function must not be set to execute the tool");
+  }
+
+  @Test
+  void executeToolsNoMatchingCall() {
+    final var toolAWithFunction = toolA.setFunction(Dummy.conCat);
+    final var result =
+        OpenAiToolExecutor.executeTools(List.of(toolAWithFunction), List.of(functionCallB));
+    assertThat(result).isEmpty();
+  }
+
+  @Test
+  void executeToolsThrowsOnSerializationError() {
+    class NonSerializableResponse {
+      private String result;
+
+      NonSerializableResponse(String result) {
+        this.result = result;
+      }
+    }
+
+    toolA.setFunction(request -> new NonSerializableResponse(request.key()));
+
+    assertThatThrownBy(
+            () -> OpenAiToolExecutor.executeTools(List.of(toolA), List.of(functionCallA)))
+        .isInstanceOf(IllegalArgumentException.class)
+        .hasMessageContaining("Failed to serialize object to JSON");
+  }
+}

foundation-models/openai/src/test/java/com/sap/ai/sdk/foundationmodels/openai/OpenAiToolTest.java

@@ -112,7 +112,7 @@ public OpenAiChatCompletionResponse chatCompletionToolExecution(
     final OpenAiAssistantMessage assistantMessage = response.getMessage();
 
     // 3. Execute the tool call for given tools
-    List<OpenAiToolMessage> toolMessages =
+    final List<OpenAiToolMessage> toolMessages =
         OpenAiToolExecutor.executeTools(tools, assistantMessage.toolCalls());
 
     // 4. Send back the results for model will incorporate them into its final response.