Change withOpenAiTools to withToolsExecutable; Change OpenAiToolExecutor.executeTools to OpenAiTool.execute; Change mandatory argument value assistantMessage.toolCalls() to assistantMessage; Add intermediate API to optionally extract original execution result objects to getMessages() convenience method

Author: a-d

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

@@ -291,7 +291,8 @@ public OpenAiChatCompletionRequest withToolChoice(@Nonnull final OpenAiToolChoic
    * @since 1.7.0
    */
   @Nonnull
-  public OpenAiChatCompletionRequest withOpenAiTools(@Nonnull final List<OpenAiTool<?>> tools) {
+  @Beta
+  public OpenAiChatCompletionRequest withToolsExecutable(@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/OpenAiFunctionCall.java

@@ -3,9 +3,7 @@
 import static com.sap.ai.sdk.foundationmodels.openai.OpenAiUtils.getOpenAiObjectMapper;
 
 import com.fasterxml.jackson.core.JsonProcessingException;
-import com.fasterxml.jackson.core.type.TypeReference;
 import com.google.common.annotations.Beta;
-import java.lang.reflect.Type;
 import java.util.Map;
 import javax.annotation.Nonnull;
 import lombok.AllArgsConstructor;
@@ -38,40 +36,25 @@ public class OpenAiFunctionCall implements OpenAiToolCall {
    */
   @Nonnull
   public Map<String, Object> getArgumentsAsMap() throws IllegalArgumentException {
-    return parseArguments(new TypeReference<>() {});
+    return getArgumentsAsObject(Map.class);
   }
 
   /**
    * Parses the arguments, encoded as a JSON string, into an object of type expected by a function
    * tool.
    *
-   * @param tool the function tool the arguments are for
+   * @param type the class reference for requested type.
    * @param <T> the type of the class
    * @return the parsed arguments as an object
    * @throws IllegalArgumentException if parsing fails
    * @since 1.7.0
    */
   @Nonnull
-  public <T> T getArgumentsAsObject(@Nonnull final OpenAiTool<T> tool)
-      throws IllegalArgumentException {
-
-    return parseArguments(
-        new TypeReference<>() {
-          @Override
-          public Type getType() {
-            return tool.getRequestClass();
-          }
-        });
-  }
-
-  @Nonnull
-  private <T> T parseArguments(@Nonnull final TypeReference<T> typeReference)
-      throws IllegalArgumentException {
+  public <T> T getArgumentsAsObject(@Nonnull final Class<T> type) throws IllegalArgumentException {
     try {
-      return getOpenAiObjectMapper().readValue(getArguments(), typeReference);
+      return getOpenAiObjectMapper().readValue(getArguments(), type);
     } catch (JsonProcessingException e) {
-      throw new IllegalArgumentException(
-          "Failed to parse JSON string to class " + typeReference.getType(), e);
+      throw new IllegalArgumentException("Failed to parse JSON string to class " + type, e);
     }
   }
 }

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

@@ -1,8 +1,11 @@
 package com.sap.ai.sdk.foundationmodels.openai;
 
 import static com.sap.ai.sdk.foundationmodels.openai.generated.model.ChatCompletionTool.TypeEnum.FUNCTION;
+import static java.util.function.UnaryOperator.identity;
 
+import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import com.github.victools.jsonschema.generator.Option;
 import com.github.victools.jsonschema.generator.OptionPreset;
 import com.github.victools.jsonschema.generator.SchemaGenerator;
@@ -13,15 +16,21 @@
 import com.google.common.annotations.Beta;
 import com.sap.ai.sdk.foundationmodels.openai.generated.model.ChatCompletionTool;
 import com.sap.ai.sdk.foundationmodels.openai.generated.model.FunctionObject;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.function.Function;
+import java.util.stream.Collectors;
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.Getter;
+import lombok.RequiredArgsConstructor;
 import lombok.experimental.Accessors;
+import lombok.extern.slf4j.Slf4j;
 
 /**
  * Represents an OpenAI tool that can be used to define a function call in an OpenAI Chat Completion
@@ -32,13 +41,16 @@
  * @see <a href="https://platform.openai.com/docs/guides/gpt/function-calling"/>OpenAI Function
  * @since 1.7.0
  */
+@Slf4j
 @Beta
 @Data
 @Getter(AccessLevel.PACKAGE)
 @Accessors(chain = true)
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
 public class OpenAiTool<InputT> {
 
+  private static final ObjectMapper JACKSON = new ObjectMapper();
+
   /** The schema generator used to create JSON schemas. */
   @Nonnull private static final SchemaGenerator GENERATOR = createSchemaGenerator();
 
@@ -71,7 +83,8 @@ public OpenAiTool(@Nonnull final String name, @Nonnull final Class<InputT> reque
   @Nonnull
   Object execute(@Nonnull final InputT argument) {
     if (getFunction() == null) {
-      throw new IllegalStateException("No function configured to execute.");
+      throw new IllegalStateException(
+          "Tool " + name + " is missing a method reference to execute.");
     }
     return getFunction().apply(argument);
   }
@@ -102,4 +115,78 @@ private static SchemaGenerator createSchemaGenerator() {
             .with(module)
             .build());
   }
+
+  /**
+   * Executes the given tool calls with the provided tools and returns the results as a list of
+   * {@link OpenAiToolMessage} containing execution results encoded as JSON string.
+   *
+   * @param tools the list of tools to execute
+   * @param msg the assistant message containing a list of tool calls with arguments
+   * @return a result object that contains the list of tool messages with the results
+   * @throws IllegalStateException if a tool is missing a method reference for function execution.
+   */
+  @Beta
+  @Nonnull
+  public static Execution execute(
+      @Nonnull final List<OpenAiTool<?>> tools, @Nonnull final OpenAiAssistantMessage msg)
+      throws IllegalArgumentException {
+    final var result = new LinkedHashMap<OpenAiFunctionCall, Object>();
+
+    final var toolMap = tools.stream().collect(Collectors.toMap(OpenAiTool::getName, identity()));
+    for (final OpenAiToolCall toolCall : msg.toolCalls()) {
+      if (toolCall instanceof OpenAiFunctionCall functionCall) {
+        final var tool = toolMap.get(functionCall.getName());
+        if (tool == null) {
+          log.warn("Tool not found for function call: {}", functionCall.getName());
+          continue;
+        }
+        final var toolResult = executeFunction(tool, functionCall);
+        result.put(functionCall, toolResult);
+      }
+    }
+    return new Execution(result);
+  }
+
+  @Nonnull
+  private static <I> Object executeFunction(
+      @Nonnull final OpenAiTool<I> tool, @Nonnull final OpenAiFunctionCall toolCall) {
+    final I arguments = toolCall.getArgumentsAsObject(tool.getRequestClass());
+    return tool.execute(arguments);
+  }
+
+  @Nonnull
+  private static String serializeObject(@Nonnull final Object obj) throws IllegalArgumentException {
+    try {
+      return JACKSON.writeValueAsString(obj);
+    } catch (JsonProcessingException e) {
+      throw new IllegalArgumentException("Failed to serialize object to JSON", e);
+    }
+  }
+
+  /**
+   * Represents the result of executing a tool call, containing the results of the function calls.
+   */
+  @RequiredArgsConstructor
+  @Beta
+  public static class Execution {
+    @Getter @Beta @Nonnull private final Map<OpenAiFunctionCall, Object> results;
+
+    /**
+     * Creates a new list of serialized OpenAI tool messages.
+     *
+     * @return the list of serialized OpenAI tool messages.
+     * @throws IllegalArgumentException if the tool results cannot be serialized to JSON
+     */
+    @Beta
+    @Nonnull
+    public List<OpenAiToolMessage> getMessages() {
+      final var result = new ArrayList<OpenAiToolMessage>();
+      for (final var entry : getResults().entrySet()) {
+        final var functionCall = entry.getKey().getId();
+        final var serializedValue = serializeObject(entry.getValue());
+        result.add(OpenAiMessage.tool(serializedValue, functionCall));
+      }
+      return result;
+    }
+  }
 }

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

@@ -123,7 +123,7 @@ record DummyRequest(String param1, int param2) {}
 
     var request =
         new OpenAiChatCompletionRequest(OpenAiMessage.user("Hello, world"))
-            .withOpenAiTools(
+            .withToolsExecutable(
                 List.of(
                     new OpenAiTool<>("toolA", DummyRequest.class)
                         .setDescription("descA")