With purely explicit types

Author: rpanackal

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) {
+  public <I, O> OpenAiChatCompletionRequest withOpenAiTools(
+      @Nonnull final List<OpenAiTool<I, O>> tools) {
     return this.withTools(tools.stream().map(OpenAiTool::createChatCompletionTool).toList());
   }
 

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

@@ -4,7 +4,6 @@
 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.CompletionUsage;
 import com.sap.ai.sdk.foundationmodels.openai.generated.model.CreateChatCompletionResponse;
@@ -99,15 +98,15 @@ public OpenAiAssistantMessage getMessage() {
     return new OpenAiAssistantMessage(new OpenAiMessageContent(contentItems), openAiToolCalls);
   }
 
-  public <T, R> List<OpenAiToolMessage> executeTools(List<OpenAiTool> tools) {
+  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(new TypeReference<T>() {});
-            R response = tool.call(arguments);
+            T arguments = functionCall.getArgumentsAsObject(tool);
+            R response = tool.execute(arguments);
             toolMessages.add(OpenAiMessage.tool(response.toString(), functionCall.getId()));
           }
         }

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

@@ -5,6 +5,7 @@
 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;
@@ -37,17 +38,40 @@ public class OpenAiFunctionCall implements OpenAiToolCall {
    */
   @Nonnull
   public Map<String, Object> getArgumentsAsMap() throws IllegalArgumentException {
-    return getArgumentsAsObject(new TypeReference<>() {});
+    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
+   * @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 {
+    final var typeRef =
+        new TypeReference<T>() {
+          @Override
+          public Type getType() {
+            return tool.getRequestClass();
+          }
+        };
+    return parseArguments(typeRef);
   }
 
   @Nonnull
-  <T> T getArgumentsAsObject(@Nonnull final TypeReference<T> typeReference)
+  private <T> T parseArguments(@Nonnull final TypeReference<T> typeReference)
       throws IllegalArgumentException {
     try {
-      return getOpenAiObjectMapper().readValue(arguments, typeReference);
+      return getOpenAiObjectMapper().readValue(getArguments(), typeReference);
     } catch (JsonProcessingException e) {
       throw new IllegalArgumentException(
-          "Failed to parse JSON string to class " + typeReference, e);
+          "Failed to parse JSON string to class " + typeReference.getType(), e);
     }
   }
 }

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

@@ -16,9 +16,10 @@
 import javax.annotation.Nullable;
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
+import lombok.Data;
 import lombok.Getter;
-import lombok.Value;
-import lombok.With;
+import lombok.Setter;
+import lombok.experimental.Accessors;
 
 /**
  * Represents an OpenAI function tool that can be used to define a function call in an OpenAI Chat
@@ -29,38 +30,67 @@
  * @since 1.7.0
  */
 @Beta
-@Value
-@With
+@Data
 @Getter(AccessLevel.PACKAGE)
+@Accessors(chain = true)
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
 public class OpenAiTool<T, R> {
 
   /** The name of the function. */
   @Nonnull String name;
 
   /** The model class for function request. */
-  @Nonnull Function<T, R> function;
+  @Nonnull Class<T> requestClass;
 
   /** An optional description of the function. */
   @Nullable String description;
 
   /** An optional flag indicating whether the function parameters should be treated strictly. */
   @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);
+  }
+
   /**
    * Constructs an {@code OpenAiFunctionTool} with the specified name and a model class that
    * captures the request to the function.
    *
    * @param name the name of the function
-   * @param function the model class for function request
+   * @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);
+  }
+
+  /**
+   * 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}
    */
-  public OpenAiTool(@Nonnull final String name, @Nonnull final Function<T, R> function) {
-    this(name, function, null, null);
+  @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;
   }
 
   @Nonnull
-  R call(@Nonnull final T request) {
-    return function.apply(request);
+  R execute(@Nonnull final T argument) {
+    return function.apply(argument);
   }
 
   ChatCompletionTool createChatCompletionTool() {
@@ -74,7 +104,6 @@ ChatCompletionTool createChatCompletionTool() {
       throw new IllegalArgumentException("Could not generate schema for " + name, e);
     }
 
-    schema.setId(null);
     final var schemaMap =
         objectMapper.convertValue(schema, new TypeReference<Map<String, Object>>() {});
 

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

@@ -130,8 +130,12 @@ record DummyResponse(String result) {}
         new OpenAiChatCompletionRequest(OpenAiMessage.user("Hello, world"))
             .withOpenAiTools(
                 List.of(
-                    new OpenAiTool("toolA", conCat).withDescription("descA").withStrict(true),
-                    new OpenAiTool("toolB", conCat).withDescription("descB").withStrict(false)));
+                    OpenAiTool.of("toolA", DummyRequest.class)
+                        .setDescription("descA")
+                        .setStrict(true),
+                    OpenAiTool.of("toolB", DummyRequest.class)
+                        .setDescription("descB")
+                        .setStrict(false)));
 
     var lowLevelRequest = request.createCreateChatCompletionRequest();
     assertThat(lowLevelRequest.getTools()).hasSize(2);
@@ -142,31 +146,18 @@ record DummyResponse(String result) {}
     assertThat(toolA.getFunction().getName()).isEqualTo("toolA");
     assertThat(toolA.getFunction().getDescription()).isEqualTo("descA");
     assertThat(toolA.getFunction().isStrict()).isTrue();
-    /// {"id"="urn:jsonschema:com:sap:ai:sdk:foundationmodels:openai:OpenAiTool:1",
-    // "properties"={"type"={"id"="urn:jsonschema:java:lang:reflect:Type",
-    // "properties"={"typeName"={"type"="string"}}, "type"="object"}}, "type"="object"}
+
     assertThat(toolA.getFunction().getParameters())
         .isEqualTo(
             Map.of(
+                "id", "urn:jsonschema:com:sap:ai:sdk:foundationmodels:openai:OpenAiTool:1",
                 "properties",
-                Map.of(
-                    "type",
                     Map.of(
-                        "properties",
-                        Map.of("typeName", Map.of("type", "string")),
                         "type",
-                        "object")),
-                "type",
-                "object"));
-    assertThat(toolA.getFunction().getParameters())
-        .isEqualTo(Map.of("type", "string", "typeName", "java.lang.reflect.Type"));
-
-    var toolB = lowLevelRequest.getTools().get(1);
-    assertThat(toolB).isInstanceOf(ChatCompletionTool.class);
-    assertThat(toolB.getType()).isEqualTo(ChatCompletionTool.TypeEnum.FUNCTION);
-    assertThat(toolB.getFunction().getName()).isEqualTo("toolB");
-    assertThat(toolB.getFunction().getDescription()).isEqualTo("descB");
-    assertThat(toolB.getFunction().isStrict()).isFalse();
-    assertThat(toolB.getFunction().getParameters()).isEqualTo(Map.of("type", "string"));
+                        Map.of(
+                            "id", "urn:jsonschema:java:lang:reflect:Type",
+                            "properties", Map.of("typeName", Map.of("type", "string")),
+                            "type", "object")),
+                "type", "object"));
   }
 }

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

@@ -22,7 +22,7 @@ record Response(String result) {}
   }
 
   private static final OpenAiTool<Dummy.Request, Dummy.Request> TOOL =
-      new OpenAiTool("functionName", Dummy.conCat);
+      OpenAiTool.of("functionName", Dummy.Request.class);
 
   @Test
   void getArgumentsAsMapParsesValidJson() {
@@ -39,15 +39,14 @@ void getArgumentsAsMapThrowsOnInvalidJson() {
 
   @Test
   void getArgumentsAsObjectParsesValidJson() {
-    var result = VALID_FUNCTION_CALL.getArgumentsAsObject(new TypeReference<Dummy.Request>() {});
+    var result = VALID_FUNCTION_CALL.getArgumentsAsObject(TOOL);
     assertThat(result).isInstanceOf(Dummy.Request.class);
     assertThat(result.key()).isEqualTo("value");
   }
 
   @Test
   void getArgumentsAsObjectThrowsOnInvalidJson() {
-    assertThatThrownBy(
-            () -> INVALID_FUNCTION_CALL.getArgumentsAsObject(new TypeReference<Dummy.Request>() {}))
+    assertThatThrownBy(() -> INVALID_FUNCTION_CALL.getArgumentsAsObject(TOOL))
         .isInstanceOf(IllegalArgumentException.class)
         .hasMessageContaining("Failed to parse JSON string");
   }

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

@@ -96,10 +96,12 @@ public OpenAiChatCompletionResponse chatCompletionToolExecution(
     messages.add(OpenAiMessage.user("What's the weather in %s in %s?".formatted(location, unit)));
 
     // 1. Define the function
-    final List<OpenAiTool> tools =
+    final var tools =
         List.of(
-            new OpenAiTool<>("weather", WeatherMethod::getCurrentWeather)
-                .withDescription("Get the weather for the given location"));
+            OpenAiTool.<WeatherMethod.Request, WeatherMethod.Response>of(
+                    "weather", WeatherMethod.Request.class)
+                .setDescription("Get the weather for the given location")
+                .setCallback(WeatherMethod::getCurrentWeather, WeatherMethod.Response.class));
 
     // 2. Assistant calls the function
     final var request = new OpenAiChatCompletionRequest(messages).withOpenAiTools(tools);