Merge remote-tracking branch 'origin/chatcompletion-for-springopenai2' into chatcompletion-for-springopenai2

# Conflicts:
#	foundation-models/openai/src/main/java/com/sap/ai/sdk/foundationmodels/openai/spring/OpenAiChatModel.java

Author: n-o-u-r-h-a-n

.github/workflows/continuous-integration.yaml

@@ -15,6 +15,8 @@ jobs:
 
   continuous-integration:
     runs-on: ubuntu-latest
+    permissions:
+      contents: write
     steps:
 
       - name: "Checkout repository"

.github/workflows/dependency-test.yaml

@@ -10,6 +10,8 @@ env:
 jobs:
   fetch-dependency-versions:
     runs-on: ubuntu-latest
+    permissions:
+      contents: none
     outputs:
       versions: ${{ steps.fetch-versions.outputs.VERSIONS }}
 
@@ -39,6 +41,8 @@ jobs:
     runs-on: ubuntu-latest
     outputs:
       cache-key: ${{ steps.cache-build.outputs.cache-key }}
+    permissions:
+      contents: read
     steps:
       - name: "Checkout repository"
         uses: actions/checkout@v4
@@ -75,6 +79,8 @@ jobs:
       matrix:
         version: ${{ fromJson(needs.fetch-dependency-versions.outputs.versions) }}
     continue-on-error: true
+    permissions:
+      contents: read
     steps:
       - name: "Checkout repository"
         uses: actions/checkout@v4

.github/workflows/deploy-snapshot.yaml

@@ -7,9 +7,11 @@ on:
 
 jobs:
   deploy-snapshot:
-    name: Deploy Snapshot
+    name: "Deploy Snapshot"
     runs-on: ubuntu-latest
     timeout-minutes: 15
+    permissions:
+      contents: read
     steps:
       - name: "Checkout Repository"
         uses: actions/checkout@v4

.github/workflows/e2e-test.yaml

@@ -10,6 +10,8 @@ env:
 
 jobs:
   end-to-end-tests:
+    permissions:
+      contents: read
     strategy:
       fail-fast: false
       matrix:
@@ -41,6 +43,12 @@ jobs:
       - name: "Run tests"
         id: run_tests
         run: |
+          if [ "${{ matrix.environment }}" = "canary" ]; then
+              export AICORE_SERVICE_KEY="${{ secrets.AI_CORE_CANARY }}"
+          else
+              export AICORE_SERVICE_KEY="${{ secrets.AI_CORE_PRODUCTION }}"
+          fi
+          
           MVN_ARGS="${{ env.MVN_MULTI_THREADED_ARGS }} surefire:test -pl :spring-app -DskipTests=false"
           mvn $MVN_ARGS "-Daicore.landscape=${{ matrix.environment }}" | tee mvn_output.log # tee writes to both the console and a file
 
@@ -60,10 +68,17 @@ jobs:
           fi
         env:
           # See "End-to-end test application instructions" on the README.md to update the secret
-          AICORE_SERVICE_KEY: ${{ secrets[matrix.secret-name] }}
+          AI_CORE_PRODUCTION: ${{ secrets.production }}
+          AI_CORE_CANARY: ${{ secrets.canary }}
 
       - name: "Start Application Locally"
         run: |
+          if [ "${{ matrix.environment }}" = "canary" ]; then
+              export AICORE_SERVICE_KEY="${{ secrets.AI_CORE_CANARY }}"
+          else
+              export AICORE_SERVICE_KEY="${{ secrets.AI_CORE_PRODUCTION }}"
+          fi
+          
           cd sample-code/spring-app
           mvn spring-boot:run &
           timeout=15
@@ -77,7 +92,8 @@ jobs:
           done
         env:
           # See "End-to-end test application instructions" on the README.md to update the secret
-          AICORE_SERVICE_KEY: ${{ secrets[matrix.secret-name] }}
+          AI_CORE_PRODUCTION: ${{ secrets.production }}
+          AI_CORE_CANARY: ${{ secrets.canary }}
 
       - name: "Health Check"
         # print response body with headers to stdout.  q:body only  O:print  -:stdout  S:headers

.github/workflows/fosstars-report.yml

@@ -13,8 +13,10 @@ env:
 
 jobs:
   create_fosstars_report:
-    runs-on: ubuntu-latest
     name: "Security rating"
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
     steps:
       - name: "Checkout repository"
         uses: actions/checkout@v4

.github/workflows/prepare-release.yaml

@@ -28,6 +28,8 @@ jobs:
       release-commit: ${{ steps.prepare-release.outputs.RELEASE_COMMIT_ID }}
       release-tag: ${{ steps.prepare-release.outputs.TAG_NAME }}
     runs-on: ubuntu-latest
+    permissions:
+      contents: write
     steps:
       - name: "Checkout Repository"
         uses: actions/checkout@v4
@@ -155,6 +157,9 @@ jobs:
     outputs:
       pr-url: ${{ steps.create-release-notes-pr.outputs.PR_URL }}
     runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
     steps:
       - name: "Checkout Code Repository"
         uses: actions/checkout@v4
@@ -233,6 +238,9 @@ jobs:
     outputs:
       pr-url: ${{ steps.create-code-pr.outputs.PR_URL }}
     runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
     steps:
       - name: "Checkout Repository"
         uses: actions/checkout@v4

.github/workflows/weekly-spec-update.yaml

@@ -7,6 +7,9 @@ on:
 jobs:
   update-all-specs:
     runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
 
     strategy:
       matrix:

foundation-models/openai/pom.xml

@@ -38,10 +38,10 @@
   </scm>
   <properties>
     <project.rootdir>${project.basedir}/../../</project.rootdir>
-    <coverage.complexity>83%</coverage.complexity>
-    <coverage.line>92%</coverage.line>
-    <coverage.instruction>90%</coverage.instruction>
-    <coverage.branch>81%</coverage.branch>
+    <coverage.complexity>81%</coverage.complexity>
+    <coverage.line>91%</coverage.line>
+    <coverage.instruction>89%</coverage.instruction>
+    <coverage.branch>79%</coverage.branch>
     <coverage.method>90%</coverage.method>
     <coverage.class>92%</coverage.class>
   </properties>

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

@@ -12,10 +12,11 @@
 import com.sap.ai.sdk.foundationmodels.openai.OpenAiMessage;
 import com.sap.ai.sdk.foundationmodels.openai.OpenAiToolCall;
 import com.sap.ai.sdk.foundationmodels.openai.generated.model.ChatCompletionMessageToolCall;
-import com.sap.ai.sdk.foundationmodels.openai.generated.model.ChatCompletionResponseMessage;
 import com.sap.ai.sdk.foundationmodels.openai.generated.model.ChatCompletionTool;
+import com.sap.ai.sdk.foundationmodels.openai.generated.model.CreateChatCompletionResponseChoicesInner;
 import com.sap.ai.sdk.foundationmodels.openai.generated.model.FunctionObject;
 import io.vavr.control.Option;
+import java.math.BigDecimal;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
@@ -27,12 +28,14 @@
 import org.springframework.ai.chat.messages.AssistantMessage.ToolCall;
 import org.springframework.ai.chat.messages.Message;
 import org.springframework.ai.chat.messages.ToolResponseMessage;
+import org.springframework.ai.chat.metadata.ChatGenerationMetadata;
 import org.springframework.ai.chat.model.ChatModel;
 import org.springframework.ai.chat.model.ChatResponse;
 import org.springframework.ai.chat.model.Generation;
+import org.springframework.ai.chat.prompt.ChatOptions;
 import org.springframework.ai.chat.prompt.Prompt;
-import org.springframework.ai.model.tool.DefaultToolCallingChatOptions;
 import org.springframework.ai.model.tool.DefaultToolCallingManager;
+import org.springframework.ai.model.tool.ToolCallingChatOptions;
 import reactor.core.publisher.Flux;
 
 /**
@@ -50,34 +53,40 @@ public class OpenAiChatModel implements ChatModel {
   @Override
   @Nonnull
   public ChatResponse call(@Nonnull final Prompt prompt) {
-    val openAiRequest = toOpenAiRequest(prompt);
-    var request = new OpenAiChatCompletionRequest(openAiRequest);
+    val options = prompt.getOptions();
+    var request = new OpenAiChatCompletionRequest(extractMessages(prompt));
 
-    if ((prompt.getOptions() instanceof DefaultToolCallingChatOptions options)) {
-      request = request.withTools(extractTools(options));
+    if (options != null) {
+      request = extractOptions(request, options);
+    }
+    if ((options instanceof ToolCallingChatOptions toolOptions)) {
+      request = request.withTools(extractTools(toolOptions));
     }
 
     val result = client.chatCompletion(request);
     val response = new ChatResponse(toGenerations(result));
 
-    if (prompt.getOptions() != null
-        && isInternalToolExecutionEnabled(prompt.getOptions())
-        && response.hasToolCalls()) {
+    if (options != null && isInternalToolExecutionEnabled(options) && response.hasToolCalls()) {
       val toolExecutionResult = toolCallingManager.executeToolCalls(prompt, response);
       // Send the tool execution result back to the model.
-      return call(new Prompt(toolExecutionResult.conversationHistory(), prompt.getOptions()));
+      return call(new Prompt(toolExecutionResult.conversationHistory(), options));
     }
     return response;
   }
 
   @Override
   @Nonnull
   public Flux<ChatResponse> stream(@Nonnull final Prompt prompt) {
-    val openAiRequest = toOpenAiRequest(prompt);
-    var request = new OpenAiChatCompletionRequest(openAiRequest);
-    if ((prompt.getOptions() instanceof DefaultToolCallingChatOptions options)) {
-      request = request.withTools(extractTools(options));
+    val options = prompt.getOptions();
+    var request = new OpenAiChatCompletionRequest(extractMessages(prompt));
+
+    if (options != null) {
+      request = extractOptions(request, options);
+    }
+    if ((options instanceof ToolCallingChatOptions toolOptions)) {
+      request = request.withTools(extractTools(toolOptions));
     }
+
     val stream = client.streamChatCompletionDeltas(request);
     final Flux<OpenAiChatCompletionDelta> flux =
         Flux.generate(
@@ -90,36 +99,16 @@ public Flux<ChatResponse> stream(@Nonnull final Prompt prompt) {
               }
               return iterator;
             });
-    return flux.map(OpenAiChatModel::toChatResponse);
-  }
-
-  private List<ChatCompletionTool> extractTools(final DefaultToolCallingChatOptions options) {
-    val tools = new ArrayList<ChatCompletionTool>();
-    for (val toolCallback : options.getToolCallbacks()) {
-      val toolDefinition = toolCallback.getToolDefinition();
-      try {
-        final Map<String, Object> params =
-            new ObjectMapper().readValue(toolDefinition.inputSchema(), new TypeReference<>() {});
-        val toolType = ChatCompletionTool.TypeEnum.FUNCTION;
-        val toolFunction =
-            new FunctionObject()
-                .name(toolDefinition.name())
-                .description(toolDefinition.description())
-                .parameters(params);
-        val tool = new ChatCompletionTool().type(toolType).function(toolFunction);
-        tools.add(tool);
-      } catch (JsonProcessingException ignored) {
-      }
-    }
-    return tools;
+    return flux.map(
+        delta -> {
+          val assistantMessage = new AssistantMessage(delta.getDeltaContent(), Map.of());
+          val metadata =
+              ChatGenerationMetadata.builder().finishReason(delta.getFinishReason()).build();
+          return new ChatResponse(List.of(new Generation(assistantMessage, metadata)));
+        });
   }
 
-  private static ChatResponse toChatResponse(final OpenAiChatCompletionDelta delta) {
-    val assistantMessage = new AssistantMessage(delta.getDeltaContent(), Map.of());
-    return new ChatResponse(List.of(new Generation(assistantMessage)));
-  }
-
-  private List<OpenAiMessage> toOpenAiRequest(final Prompt prompt) {
+  private List<OpenAiMessage> extractMessages(final Prompt prompt) {
     final List<OpenAiMessage> result = new ArrayList<>();
     for (final Message message : prompt.getInstructions()) {
       switch (message.getMessageType()) {
@@ -152,24 +141,73 @@ private static void addToolMessages(
   }
 
   @Nonnull
-  static List<Generation> toGenerations(@Nonnull final OpenAiChatCompletionResponse result) {
+  private static List<Generation> toGenerations(
+      @Nonnull final OpenAiChatCompletionResponse result) {
     return result.getOriginalResponse().getChoices().stream()
-        .map(message -> toGeneration(message.getMessage()))
+        .map(OpenAiChatModel::toGeneration)
         .toList();
   }
 
   @Nonnull
-  static Generation toGeneration(@Nonnull final ChatCompletionResponseMessage choice) {
-    // no metadata for now
+  private static Generation toGeneration(
+      @Nonnull final CreateChatCompletionResponseChoicesInner choice) {
+    val metadata =
+        ChatGenerationMetadata.builder().finishReason(choice.getFinishReason().getValue());
+    metadata.metadata("index", choice.getIndex());
+    if (choice.getLogprobs() != null && !choice.getLogprobs().getContent().isEmpty()) {
+      metadata.metadata("logprobs", choice.getLogprobs().getContent());
+    }
+    val message = choice.getMessage();
     val calls = new ArrayList<ToolCall>();
-    if (choice.getToolCalls() != null) {
-      for (final ChatCompletionMessageToolCall c : choice.getToolCalls()) {
+    if (message.getToolCalls() != null) {
+      for (final ChatCompletionMessageToolCall c : message.getToolCalls()) {
         val fnc = c.getFunction();
         calls.add(
             new ToolCall(c.getId(), c.getType().getValue(), fnc.getName(), fnc.getArguments()));
       }
     }
-    val message = new AssistantMessage(choice.getContent(), Map.of(), calls);
-    return new Generation(message);
+
+    val assistantMessage = new AssistantMessage(message.getContent(), Map.of(), calls);
+    return new Generation(assistantMessage, metadata.build());
+  }
+
+  private OpenAiChatCompletionRequest extractOptions(
+      @Nonnull OpenAiChatCompletionRequest request, @Nonnull final ChatOptions options) {
+    request = request.withStop(options.getStopSequences()).withMaxTokens(options.getMaxTokens());
+    if (options.getTemperature() != null) {
+      request = request.withTemperature(BigDecimal.valueOf(options.getTemperature()));
+    }
+    if (options.getTopP() != null) {
+      request = request.withTopP(BigDecimal.valueOf(options.getTopP()));
+    }
+    if (options.getPresencePenalty() != null) {
+      request = request.withPresencePenalty(BigDecimal.valueOf(options.getPresencePenalty()));
+    }
+    if (options.getFrequencyPenalty() != null) {
+      request = request.withFrequencyPenalty(BigDecimal.valueOf(options.getFrequencyPenalty()));
+    }
+    return request;
+  }
+
+  private List<ChatCompletionTool> extractTools(final ToolCallingChatOptions options) {
+    val tools = new ArrayList<ChatCompletionTool>();
+    for (val toolCallback : options.getToolCallbacks()) {
+      val toolDefinition = toolCallback.getToolDefinition();
+      try {
+        final Map<String, Object> params =
+            new ObjectMapper().readValue(toolDefinition.inputSchema(), new TypeReference<>() {});
+        val tool =
+            new ChatCompletionTool()
+                .type(ChatCompletionTool.TypeEnum.FUNCTION)
+                .function(
+                    new FunctionObject()
+                        .name(toolDefinition.name())
+                        .description(toolDefinition.description())
+                        .parameters(params));
+        tools.add(tool);
+      } catch (JsonProcessingException ignored) {
+      }
+    }
+    return tools;
   }
 }

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

@@ -114,6 +114,12 @@ void testStreamCompletion() throws IOException {
       assertThat(deltaList.get(3).getResult().getOutput().getText()).isEqualTo("!");
       assertThat(deltaList.get(4).getResult().getOutput().getText()).isEqualTo("");
 
+      assertThat(deltaList.get(0).getResult().getMetadata().getFinishReason()).isEqualTo(null);
+      assertThat(deltaList.get(1).getResult().getMetadata().getFinishReason()).isEqualTo(null);
+      assertThat(deltaList.get(2).getResult().getMetadata().getFinishReason()).isEqualTo(null);
+      assertThat(deltaList.get(3).getResult().getMetadata().getFinishReason()).isEqualTo(null);
+      assertThat(deltaList.get(4).getResult().getMetadata().getFinishReason()).isEqualTo("stop");
+
       Mockito.verify(inputStream, times(1)).close();
     }
   }