Introduce OpenAiToolExecutor

Author: rpanackal

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

@@ -291,8 +291,7 @@ public OpenAiChatCompletionRequest withToolChoice(@Nonnull final OpenAiToolChoic
    * @since 1.7.0
    */
   @Nonnull
-  public <I, O> OpenAiChatCompletionRequest withOpenAiTools(
-      @Nonnull final List<OpenAiTool<I, O>> tools) {
+  public OpenAiChatCompletionRequest withOpenAiTools(@Nonnull final List<OpenAiTool<?>> tools) {
     return this.withTools(tools.stream().map(OpenAiTool::createChatCompletionTool).toList());
   }
 

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

@@ -99,27 +99,5 @@ public OpenAiAssistantMessage getMessage() {
     return new OpenAiAssistantMessage(new OpenAiMessageContent(contentItems), openAiToolCalls);
   }
 
-  public <T, R> List<OpenAiToolMessage> executeTools(List<OpenAiTool<T, R>> tools) {
-    var toolMessages = new ArrayList<OpenAiToolMessage>();
-
-    for (var toolCall : getMessage().toolCalls()) {
-      if (toolCall instanceof OpenAiFunctionCall functionCall) {
-        for (OpenAiTool<T, R> tool : tools) {
-          if (tool.getName().equals(functionCall.getName())) {
-            T arguments = functionCall.getArgumentsAsObject(tool);
-            R response = tool.execute(arguments);
-
-            String serializedResponse;
-            try {
-              serializedResponse = OpenAiUtils.getOpenAiObjectMapper().writeValueAsString(response);
-            } catch (JsonProcessingException e) {
-              throw new IllegalArgumentException(e);
-            }
-            toolMessages.add(OpenAiMessage.tool(serializedResponse, functionCall.getId()));
-          }
-        }
-      }
-    }
-    return toolMessages;
-  }
+  
 }

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

@@ -52,16 +52,16 @@ public Map<String, Object> getArgumentsAsMap() throws IllegalArgumentException {
    * @since 1.7.0
    */
   @Nonnull
-  public <T> T getArgumentsAsObject(@Nonnull final OpenAiTool<T, ?> tool)
+  public <T> T getArgumentsAsObject(@Nonnull final OpenAiTool<T> tool)
       throws IllegalArgumentException {
-    final var typeRef =
-        new TypeReference<T>() {
+
+    return parseArguments(
+        new TypeReference<>() {
           @Override
           public Type getType() {
             return tool.getRequestClass();
           }
-        };
-    return parseArguments(typeRef);
+        });
   }
 
   @Nonnull

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

@@ -34,33 +34,22 @@
 @Getter(AccessLevel.PACKAGE)
 @Accessors(chain = true)
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
-public class OpenAiTool<T, R> {
+public class OpenAiTool<I> {
 
   /** The name of the function. */
   @Nonnull String name;
 
   /** The model class for function request. */
-  @Nonnull Class<T> requestClass;
+  @Nonnull Class<I> requestClass;
 
   /** An optional description of the function. */
-  @Nullable String description;
+  @Setter @Nullable String description;
 
   /** An optional flag indicating whether the function parameters should be treated strictly. */
-  @Nullable Boolean strict;
+  @Setter @Nullable Boolean strict;
 
   /** The function to be called. */
-  @Setter(AccessLevel.NONE)
-  @Nullable
-  Function<T, R> function;
-
-  /** The response class for the function. */
-  @Setter(AccessLevel.NONE)
-  @Nullable
-  Class<R> responseClass;
-
-  public static <I, O> OpenAiTool<I, O> of(@Nonnull String name, @Nonnull Class<I> requestClass) {
-    return new OpenAiTool<>(name, requestClass);
-  }
+  @Setter @Nullable Function<I, ?> function;
 
   /**
    * Constructs an {@code OpenAiFunctionTool} with the specified name and a model class that
@@ -69,28 +58,21 @@ public static <I, O> OpenAiTool<I, O> of(@Nonnull String name, @Nonnull Class<I>
    * @param name the name of the function
    * @param requestClass the model class for function request
    */
-  private OpenAiTool(@Nonnull final String name, @Nonnull final Class<T> requestClass) {
-    this(name, requestClass, null, null, null, null);
+  public OpenAiTool(@Nonnull final String name, @Nonnull final Class<I> requestClass) {
+    this(name, requestClass, null, null, null);
   }
 
-  /**
-   * Sets the function to be called and the response class for the function.
-   *
-   * @param function the function to be called
-   * @param responseClass the response class for the function
-   * @return this instance of {@code OpenAiFunctionTool}
-   */
   @Nonnull
-  public OpenAiTool<T, R> setCallback(
-      @Nonnull final Function<T, R> function, @Nonnull final Class<R> responseClass) {
-    this.function = function;
-    this.responseClass = responseClass;
-    return this;
+  Object execute(@Nonnull final I argument) {
+    if (getFunction() == null) {
+      throw new IllegalStateException("Callback function is not set");
+    }
+    return getFunction().apply(argument);
   }
 
-  @Nonnull
-  R execute(@Nonnull final T argument) {
-    return function.apply(argument);
+  public OpenAiTool<I> setCallback(Function<I, ?> function) {
+    this.function = function;
+    return this;
   }
 
   ChatCompletionTool createChatCompletionTool() {

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

@@ -0,0 +1,64 @@
+package com.sap.ai.sdk.foundationmodels.openai;
+
+import static lombok.AccessLevel.PRIVATE;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.Beta;
+import java.util.List;
+import java.util.stream.Collectors;
+import javax.annotation.Nonnull;
+import lombok.AllArgsConstructor;
+
+/**
+ * A class for OpenAI tool execution.
+ *
+ * @since 1.7.0
+ */
+@Beta
+@AllArgsConstructor(access = PRIVATE)
+public class OpenAiToolExecutor {
+
+  private static final ObjectMapper JACKSON = new ObjectMapper();
+
+  /**
+   * Executes the given tool calls with the provided tools and returns the results as a list of
+   * {@link OpenAiToolMessage}.
+   *
+   * @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
+   */
+  @Nonnull
+  public static List<OpenAiToolMessage> executeTools(
+      List<OpenAiTool<?>> tools, List<OpenAiToolCall> toolCalls) {
+
+    final var toolMap = tools.stream().collect(Collectors.toMap(OpenAiTool::getName, tool -> tool));
+
+    return toolCalls.stream()
+        .filter(OpenAiFunctionCall.class::isInstance)
+        .map(OpenAiFunctionCall.class::cast)
+        .filter(functionCall -> toolMap.containsKey(functionCall.getName()))
+        .map(
+            functionCall -> {
+              var tool = toolMap.get(functionCall.getName());
+              var result = executeFunction(tool, functionCall);
+              return OpenAiMessage.tool(serializeObject(result), functionCall.getId());
+            })
+        .toList();
+  }
+
+  private static <I> Object executeFunction(OpenAiTool<I> tool, OpenAiFunctionCall toolCall) {
+    I arguments = toolCall.getArgumentsAsObject(tool);
+    return tool.execute(arguments);
+  }
+
+  @Nonnull
+  private static String serializeObject(@Nonnull final Object obj) {
+    try {
+      return JACKSON.writeValueAsString(obj);
+    } catch (JsonProcessingException e) {
+      throw new IllegalArgumentException(e);
+    }
+  }
+}

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

@@ -11,7 +11,6 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
-import java.util.function.Function;
 import org.junit.jupiter.api.Test;
 
 class OpenAiChatCompletionRequestTest {
@@ -121,19 +120,15 @@ void messageListExternallyUnmodifiable() {
   @Test
   void withOpenAiTools() {
     record DummyRequest(String param1, int param2) {}
-    record DummyResponse(String result) {}
-
-    Function<DummyRequest, DummyResponse> conCat =
-        (request) -> new DummyResponse(request.param1 + request.param2);
 
     var request =
         new OpenAiChatCompletionRequest(OpenAiMessage.user("Hello, world"))
             .withOpenAiTools(
                 List.of(
-                    OpenAiTool.of("toolA", DummyRequest.class)
+                    new OpenAiTool<>("toolA", DummyRequest.class)
                         .setDescription("descA")
                         .setStrict(true),
-                    OpenAiTool.of("toolB", DummyRequest.class)
+                    new OpenAiTool<>("toolB", DummyRequest.class)
                         .setDescription("descB")
                         .setStrict(false)));
 

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

@@ -3,7 +3,6 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
-import com.fasterxml.jackson.core.type.TypeReference;
 import java.util.function.Function;
 import org.junit.jupiter.api.Test;
 
@@ -21,8 +20,8 @@ record Response(String result) {}
     static Function<Request, Response> conCat = request -> new Response(request.key());
   }
 
-  private static final OpenAiTool<Dummy.Request, Dummy.Request> TOOL =
-      OpenAiTool.of("functionName", Dummy.Request.class);
+  private static final OpenAiTool<Dummy.Request> TOOL =
+      new OpenAiTool<>("functionName", Dummy.Request.class);
 
   @Test
   void getArgumentsAsMapParsesValidJson() {
@@ -39,7 +38,7 @@ void getArgumentsAsMapThrowsOnInvalidJson() {
 
   @Test
   void getArgumentsAsObjectParsesValidJson() {
-    var result = VALID_FUNCTION_CALL.getArgumentsAsObject(TOOL);
+    Dummy.Request result = VALID_FUNCTION_CALL.getArgumentsAsObject(TOOL);
     assertThat(result).isInstanceOf(Dummy.Request.class);
     assertThat(result.key()).isEqualTo("value");
   }

sample-code/spring-app/src/main/java/com/sap/ai/sdk/app/services/OpenAiServiceV2.java

@@ -15,6 +15,8 @@
 import com.sap.ai.sdk.foundationmodels.openai.OpenAiImageItem;
 import com.sap.ai.sdk.foundationmodels.openai.OpenAiMessage;
 import com.sap.ai.sdk.foundationmodels.openai.OpenAiTool;
+import com.sap.ai.sdk.foundationmodels.openai.OpenAiToolExecutor;
+import com.sap.ai.sdk.foundationmodels.openai.OpenAiToolMessage;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.stream.Stream;
@@ -83,7 +85,8 @@ public OpenAiChatCompletionResponse chatCompletionImage(@Nonnull final String li
   }
 
   /**
-   * Executes a chat completion request to OpenAI with a tool that calculates the weather.
+   * Chat request to OpenAI with tool that gets the weather for a given location and unit. The tool
+   * executed and the result is sent back to the assistant.
    *
    * @param location The location to get the weather for.
    * @param unit The unit of temperature to use.
@@ -96,22 +99,25 @@ public OpenAiChatCompletionResponse chatCompletionToolExecution(
     messages.add(OpenAiMessage.user("What's the weather in %s in %s?".formatted(location, unit)));
 
     // 1. Define the function
-    final var tools =
+    final List<OpenAiTool<?>> tools =
         List.of(
-            OpenAiTool.<WeatherMethod.Request, WeatherMethod.Response>of(
-                    "weather", WeatherMethod.Request.class)
+            new OpenAiTool<>("weather", WeatherMethod.Request.class)
                 .setDescription("Get the weather for the given location")
-                .setCallback(WeatherMethod::getCurrentWeather, WeatherMethod.Response.class));
+                .setCallback(WeatherMethod::getCurrentWeather));
 
     // 2. Assistant calls the function
     final var request = new OpenAiChatCompletionRequest(messages).withOpenAiTools(tools);
     final OpenAiChatCompletionResponse response =
         OpenAiClient.forModel(GPT_4O_MINI).chatCompletion(request);
     final OpenAiAssistantMessage assistantMessage = response.getMessage();
 
-    // 4. Send back the results, and the model will incorporate them into its final response.
+    // 3. Execute the tool call for given tools
+    List<OpenAiToolMessage> toolMessages =
+        OpenAiToolExecutor.executeTools(tools, assistantMessage.toolCalls());
+
+    // 4. Send back the results for model will incorporate them into its final response.
     messages.add(assistantMessage);
-    messages.addAll(response.executeTools(tools));
+    messages.addAll(toolMessages);
 
     return OpenAiClient.forModel(GPT_4O_MINI).chatCompletion(request.withMessages(messages));
   }