finito

Author: CharlesDuboisSAP

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

@@ -123,7 +123,8 @@ public class OpenAiChatCompletionRequest {
   @Nullable CreateChatCompletionRequestAllOfResponseFormat responseFormat;
 
   /** List of tools that the model may invoke during the completion. */
-  @Nullable List<ChatCompletionTool> tools;
+  @Getter(value = AccessLevel.PACKAGE)
+  @Nullable List<OpenAiFunctionTool<?, ?>> tools;
 
   /** Option to control which tool is invoked by the model. */
   @With(AccessLevel.PRIVATE)
@@ -297,7 +298,7 @@ public OpenAiChatCompletionRequest withOpenAiTools(@Nonnull final List<OpenAiToo
             .map(
                 tool -> {
                   if (tool instanceof OpenAiFunctionTool) {
-                    return ((OpenAiFunctionTool) tool).createChatCompletionTool();
+                    return ((OpenAiFunctionTool<?,?>) tool).createChatCompletionTool();
                   } else {
                     throw new IllegalArgumentException(
                         "Unsupported tool type: " + tool.getClass().getName());
@@ -336,7 +337,7 @@ CreateChatCompletionRequest createCreateChatCompletionRequest() {
     request.seed(this.seed);
     request.streamOptions(this.streamOptions);
     request.responseFormat(this.responseFormat);
-    request.tools(this.tools);
+    request.tools(this.tools.createChatCompletionTool());
     request.toolChoice(this.toolChoice);
     request.functionCall(null);
     request.functions(null);

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

@@ -4,18 +4,20 @@
 import static lombok.AccessLevel.NONE;
 import static lombok.AccessLevel.PACKAGE;
 
+import com.fasterxml.jackson.core.type.TypeReference;
 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.CompletionUsage;
 import com.sap.ai.sdk.foundationmodels.openai.generated.model.CreateChatCompletionResponse;
 import com.sap.ai.sdk.foundationmodels.openai.generated.model.CreateChatCompletionResponseChoicesInner;
-
-import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
 import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
 import lombok.RequiredArgsConstructor;
 import lombok.Setter;
 import lombok.Value;
+import lombok.val;
 
 /**
  * Represents the output of an OpenAI chat completion. *
@@ -28,7 +30,9 @@
 @Setter(value = NONE)
 public class OpenAiChatCompletionResponse {
   /** The original response from the OpenAI API. */
-  @Nonnull final CreateChatCompletionResponse originalResponse;
+  @Nonnull CreateChatCompletionResponse originalResponse;
+
+  @Nullable List<ChatCompletionTool> functions;
 
   /**
    * Gets the token usage from the original response.
@@ -99,20 +103,30 @@ public OpenAiAssistantMessage getMessage() {
     return new OpenAiAssistantMessage(new OpenAiMessageContent(contentItems), openAiToolCalls);
   }
 
-  public List<OpenAiToolMessage> executeTools() {
-    var toolMessages = new ArrayList<OpenAiToolMessage>();
-    for (var toolcall : getMessage().toolCalls()) {
-      if (toolcall instanceof OpenAiFunctionCall functionCall) {
-        if (functionCall.getName() == "weather") {
-          final WeatherMethod.Request arguments =
-              functionCall.getArgumentsAsObject(weatherFunction);
-          final WeatherMethod.Response currentWeather = WeatherMethod.getCurrentWeather(arguments);
-          toolMessages.add(currentWeather.toString(), functionCall.getId());
-        }
-      } else {
-        throw new IllegalArgumentException(
-            "Expected a function call, but got: %s".formatted(assistantMessage));
+  public <T, R> List<OpenAiToolMessage> executeTools( List<OpenAiTool> tools ) {
+    return getMessage().toolCalls().stream()
+        .filter(toolCall -> toolCall instanceof OpenAiFunctionCall)
+        .map(toolCall -> (OpenAiFunctionCall) toolCall)
+        .map(
+            functionCall -> {
+              OpenAiFunctionTool<T, R> request = findFunction(tools, functionCall.getName());
+              T arguments = functionCall.parseArguments(new TypeReference<T>() {});
+              R response = request.call(arguments);
+              return OpenAiMessage.tool(response, functionCall.getId());
+            })
+        .toList();
+  }
+
+  @Nullable
+  private <T, R> OpenAiFunctionTool<T, R> findFunction(List<OpenAiTool> tools, String name) {
+    if (functions == null) {
+      return null;
+    }
+    for (OpenAiTool tool : tools) {
+      if (tool instanceof OpenAiFunctionTool<?, ?> function && function.getName().equals(name)) {
+        return (OpenAiFunctionTool<T, R>) function;
       }
     }
+    return null;
   }
 }

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

@@ -159,7 +159,7 @@ public OpenAiChatCompletionResponse chatCompletion(
       @Nonnull final OpenAiChatCompletionRequest request) throws OpenAiClientException {
     warnIfUnsupportedUsage();
     return new OpenAiChatCompletionResponse(
-        chatCompletion(request.createCreateChatCompletionRequest()));
+        chatCompletion(request.createCreateChatCompletionRequest()), request.getTools());
   }
 
   /**

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

@@ -5,8 +5,6 @@
 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;
 import lombok.Value;
@@ -29,49 +27,25 @@ public class OpenAiFunctionCall implements OpenAiToolCall {
   /** The arguments for the function call, encoded as a JSON string. */
   @Nonnull String arguments;
 
-  /**
-   * Parses the arguments, encoded as a JSON string, into a {@code Map<String, Object>}.
-   *
-   * @return a map of the arguments
-   * @throws IllegalArgumentException if parsing fails
-   * @since 1.7.0
-   */
-  @Nonnull
-  public Map<String, Object> getArgumentsAsMap() throws IllegalArgumentException {
-    return parseArguments(new TypeReference<>() {});
-  }
-
   /**
    * 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 <T> the type of the class
+   * @param request 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 OpenAiFunctionTool tool)
-      throws IllegalArgumentException {
-    final var typeRef =
-        new TypeReference<T>() {
-          @Override
-          public Type getType() {
-            return tool.getFunction();
-          }
-        };
-    return parseArguments(typeRef);
-  }
-
-  @Nonnull
-  private <T> T parseArguments(@Nonnull final TypeReference<T> typeReference)
+  <T> T parseArguments(@Nonnull final TypeReference<T> request)
       throws IllegalArgumentException {
     try {
-      return getOpenAiObjectMapper().readValue(getArguments(), typeReference);
+      return getOpenAiObjectMapper().readValue(arguments, request);
     } catch (JsonProcessingException e) {
       throw new IllegalArgumentException(
-          "Failed to parse JSON string to class " + typeReference.getType(), e);
+          "Failed to parse JSON string to class " + request, e);
     }
   }
+
+
 }

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

@@ -41,8 +41,6 @@ public class OpenAiFunctionTool<T, R> implements OpenAiTool {
   /** The model class for function request. */
   @Nonnull Function<T, R> function;
 
-  /** The model class for function response. */
-
   /** An optional description of the function. */
   @Nullable String description;
 
@@ -60,14 +58,19 @@ public OpenAiFunctionTool(@Nonnull final String name, @Nonnull final Function<T,
     this(name, function, null, null);
   }
 
+  @Nonnull
+  R call(@Nonnull final T request) {
+    return function.apply(request);
+  }
+
   ChatCompletionTool createChatCompletionTool() {
     final var objectMapper = new ObjectMapper();
     JsonSchema schema = null;
     try {
-      schema = new JsonSchemaGenerator(objectMapper).generateSchema(Class<T>.class);
+      schema = new JsonSchemaGenerator(objectMapper).generateSchema(new TypeReference<T>() {}.getClass());
     } catch (JsonMappingException e) {
       throw new IllegalArgumentException(
-          "Could not generate schema for " + function.getTypeName(), e);
+          "Could not generate schema for " + name, e);
     }
 
     schema.setId(null);

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

@@ -15,6 +15,7 @@
 import com.sap.ai.sdk.foundationmodels.openai.OpenAiFunctionTool;
 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 java.util.ArrayList;
 import java.util.List;
 import java.util.stream.Stream;
@@ -96,24 +97,20 @@ public OpenAiChatCompletionResponse chatCompletionToolExecution(
     messages.add(OpenAiMessage.user("What's the weather in %s in %s?".formatted(location, unit)));
 
     // 1. Define the function
-    final var weatherFunction =
-        new OpenAiFunctionTool(
-                "weather", WeatherMethod.Request.class, WeatherMethod.Response.class)
-            .withDescription("Get the weather for the given location");
+    final List<OpenAiTool> tools =
+        List.of(
+            new OpenAiFunctionTool<>("weather", WeatherMethod::getCurrentWeather)
+                .withDescription("Get the weather for the given location"));
 
     // 2. Assistant calls the function
-    final var request =
-        new OpenAiChatCompletionRequest(messages).withOpenAiTools(List.of(weatherFunction));
+    final var request = new OpenAiChatCompletionRequest(messages).withOpenAiTools(tools);
     final OpenAiChatCompletionResponse response =
         OpenAiClient.forModel(GPT_4O_MINI).chatCompletion(request);
     final OpenAiAssistantMessage assistantMessage = response.getMessage();
-    
-    // 3. Execute the function
-    
-   
+
     // 4. Send back the results, and the model will incorporate them into its final response.
     messages.add(assistantMessage);
-    messages.add(OpenAiMessage.tool(currentWeather.toString(), functionCall.getId()));
+    messages.addAll(response.executeTools(tools));
     return OpenAiClient.forModel(GPT_4O_MINI).chatCompletion(request.withMessages(messages));
   }