With purely generics

Author: rpanackal

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

@@ -3,6 +3,7 @@
 import com.google.common.annotations.Beta;
 import com.google.common.collect.Lists;
 import com.sap.ai.sdk.foundationmodels.openai.generated.model.ChatCompletionStreamOptions;
+import com.sap.ai.sdk.foundationmodels.openai.generated.model.ChatCompletionTool;
 import com.sap.ai.sdk.foundationmodels.openai.generated.model.ChatCompletionToolChoiceOption;
 import com.sap.ai.sdk.foundationmodels.openai.generated.model.CreateChatCompletionRequest;
 import com.sap.ai.sdk.foundationmodels.openai.generated.model.CreateChatCompletionRequestAllOfResponseFormat;
@@ -122,9 +123,7 @@ public class OpenAiChatCompletionRequest {
   @Nullable CreateChatCompletionRequestAllOfResponseFormat responseFormat;
 
   /** List of tools that the model may invoke during the completion. */
-  @Getter(value = AccessLevel.PACKAGE)
-  @Nullable
-  List<OpenAiFunctionTool<?, ?>> tools;
+  @Nullable List<ChatCompletionTool> tools;
 
   /** Option to control which tool is invoked by the model. */
   @With(AccessLevel.PRIVATE)
@@ -293,18 +292,7 @@ public OpenAiChatCompletionRequest withToolChoice(@Nonnull final OpenAiToolChoic
    */
   @Nonnull
   public OpenAiChatCompletionRequest withOpenAiTools(@Nonnull final List<OpenAiTool> tools) {
-    return this.withTools(
-        tools.stream()
-            .map(
-                tool -> {
-                  if (tool instanceof OpenAiFunctionTool) {
-                    return ((OpenAiFunctionTool<?, ?>) tool).createChatCompletionTool();
-                  } else {
-                    throw new IllegalArgumentException(
-                        "Unsupported tool type: " + tool.getClass().getName());
-                  }
-                })
-            .toList());
+    return this.withTools(tools.stream().map(OpenAiTool::createChatCompletionTool).toList());
   }
 
   /**
@@ -337,7 +325,7 @@ CreateChatCompletionRequest createCreateChatCompletionRequest() {
     request.seed(this.seed);
     request.streamOptions(this.streamOptions);
     request.responseFormat(this.responseFormat);
-    request.tools(this.tools.createChatCompletionTool());
+    request.tools(this.tools);
     request.toolChoice(this.toolChoice);
     request.functionCall(null);
     request.functions(null);

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

@@ -6,14 +6,13 @@
 
 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;
@@ -31,8 +30,6 @@ public class OpenAiChatCompletionResponse {
   /** The original response from the OpenAI API. */
   @Nonnull CreateChatCompletionResponse originalResponse;
 
-  @Nullable List<ChatCompletionTool> functions;
-
   /**
    * Gets the token usage from the original response.
    *
@@ -103,29 +100,19 @@ public OpenAiAssistantMessage getMessage() {
   }
 
   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();
-  }
+    var toolMessages = new ArrayList<OpenAiToolMessage>();
 
-  @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;
+    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);
+            toolMessages.add(OpenAiMessage.tool(response.toString(), functionCall.getId()));
+          }
+        }
       }
     }
-    return null;
+    return toolMessages;
   }
 }

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()), request.getTools());
+        chatCompletion(request.createCreateChatCompletionRequest()));
   }
 
   /**

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.util.Map;
 import javax.annotation.Nonnull;
 import lombok.AllArgsConstructor;
 import lombok.Value;
@@ -28,20 +29,25 @@ public class OpenAiFunctionCall implements OpenAiToolCall {
   @Nonnull String arguments;
 
   /**
-   * Parses the arguments, encoded as a JSON string, into an object of type expected by a function
-   * tool.
+   * Parses the arguments, encoded as a JSON string, into a {@code Map<String, Object>}.
    *
-   * @param request the type of the class
-   * @return the parsed arguments as an object
+   * @return a map of the arguments
    * @throws IllegalArgumentException if parsing fails
    * @since 1.7.0
    */
   @Nonnull
-  <T> T parseArguments(@Nonnull final TypeReference<T> request) throws IllegalArgumentException {
+  public Map<String, Object> getArgumentsAsMap() throws IllegalArgumentException {
+    return getArgumentsAsObject(new TypeReference<>() {});
+  }
+
+  @Nonnull
+  <T> T getArgumentsAsObject(@Nonnull final TypeReference<T> typeReference)
+      throws IllegalArgumentException {
     try {
-      return getOpenAiObjectMapper().readValue(arguments, request);
+      return getOpenAiObjectMapper().readValue(arguments, typeReference);
     } catch (JsonProcessingException e) {
-      throw new IllegalArgumentException("Failed to parse JSON string to class " + request, e);
+      throw new IllegalArgumentException(
+          "Failed to parse JSON string to class " + typeReference, e);
     }
   }
 }

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

@@ -1,8 +1,89 @@
 package com.sap.ai.sdk.foundationmodels.openai;
 
+import static com.sap.ai.sdk.foundationmodels.openai.generated.model.ChatCompletionTool.TypeEnum.FUNCTION;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.module.jsonSchema.JsonSchema;
+import com.fasterxml.jackson.module.jsonSchema.JsonSchemaGenerator;
+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.Map;
+import java.util.function.Function;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.Value;
+import lombok.With;
+
 /**
- * Represents a tool that can be integrated into an OpenAI Chat Completion request.
+ * Represents an OpenAI function tool that can be used to define a function call in an OpenAI Chat
+ * Completion request. This tool generates a JSON schema based on the provided class representing
+ * the function's request structure.
  *
+ * @see <a href="https://platform.openai.com/docs/guides/gpt/function-calling"/>OpenAI Function
  * @since 1.7.0
  */
-public sealed interface OpenAiTool permits OpenAiFunctionTool {}
+@Beta
+@Value
+@With
+@Getter(AccessLevel.PACKAGE)
+@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;
+
+  /** An optional description of the function. */
+  @Nullable String description;
+
+  /** An optional flag indicating whether the function parameters should be treated strictly. */
+  @Nullable Boolean strict;
+
+  /**
+   * 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
+   */
+  public OpenAiTool(@Nonnull final String name, @Nonnull final Function<T, R> function) {
+    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(new TypeReference<T>() {}.getClass());
+    } catch (JsonMappingException e) {
+      throw new IllegalArgumentException("Could not generate schema for " + name, e);
+    }
+
+    schema.setId(null);
+    final var schemaMap =
+        objectMapper.convertValue(schema, new TypeReference<Map<String, Object>>() {});
+
+    final var function =
+        new FunctionObject()
+            .name(getName())
+            .description(getDescription())
+            .parameters(schemaMap)
+            .strict(getStrict());
+    return new ChatCompletionTool().type(FUNCTION).function(function);
+  }
+}