[FEATURE] Mistral AI supports function calling

langchain4j-core/src/test/java/dev/langchain4j/model/chat/TestStreamingResponseHandler.java

@@ -29,7 +29,13 @@ public void onComplete(Response<T> response) {
 
         String expectedTextContent = textContentBuilder.toString();
         if (response.content() instanceof AiMessage) {
-            assertThat(((AiMessage) response.content()).text()).isEqualTo(expectedTextContent);
+            AiMessage aiMessage = (AiMessage) response.content();
+            if (aiMessage.hasToolExecutionRequests()){
+                assertThat(aiMessage.toolExecutionRequests().size()).isGreaterThan(0);
+                assertThat(aiMessage.text()).isNull();
+            } else {
+                assertThat(aiMessage.text()).isEqualTo(expectedTextContent);
+            }
         } else if (response.content() instanceof String) {
             assertThat(response.content()).isEqualTo(expectedTextContent);
         } else {

langchain4j-mistral-ai/src/main/java/dev/langchain4j/model/mistralai/DefaultMistralAiClient.java

@@ -3,12 +3,12 @@
 import com.google.gson.FieldNamingPolicy;
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
+import dev.langchain4j.agent.tool.ToolExecutionRequest;
 import dev.langchain4j.data.message.AiMessage;
 import dev.langchain4j.model.StreamingResponseHandler;
 import dev.langchain4j.model.output.FinishReason;
 import dev.langchain4j.model.output.Response;
 import dev.langchain4j.model.output.TokenUsage;
-import lombok.Builder;
 import okhttp3.OkHttpClient;
 import okhttp3.ResponseBody;
 import okhttp3.sse.EventSource;
@@ -20,11 +20,10 @@
 import retrofit2.converter.gson.GsonConverterFactory;
 
 import java.io.IOException;
-import java.time.Duration;
+import java.util.List;
 
-import static dev.langchain4j.internal.Utils.isNullOrBlank;
-import static dev.langchain4j.model.mistralai.DefaultMistralAiHelper.finishReasonFrom;
-import static dev.langchain4j.model.mistralai.DefaultMistralAiHelper.tokenUsageFrom;
+import static dev.langchain4j.internal.Utils.*;
+import static dev.langchain4j.model.mistralai.DefaultMistralAiHelper.*;
 
 class DefaultMistralAiClient extends MistralAiClient {
 
@@ -101,6 +100,7 @@ public MistralAiChatCompletionResponse chatCompletion(MistralAiChatCompletionReq
     public void streamingChatCompletion(MistralAiChatCompletionRequest request, StreamingResponseHandler<AiMessage> handler) {
         EventSourceListener eventSourceListener = new EventSourceListener() {
             final StringBuffer contentBuilder = new StringBuffer();
+            List<ToolExecutionRequest> toolExecutionRequests;
             TokenUsage tokenUsage;
             FinishReason finishReason;
 
@@ -117,8 +117,15 @@ public void onEvent(EventSource eventSource, String id, String type, String data
                     LOGGER.debug("onEvent() {}", data);
                 }
                 if ("[DONE]".equals(data)) {
+                    AiMessage aiMessage;
+                    if (!isNullOrEmpty(toolExecutionRequests)){
+                        aiMessage = AiMessage.from(toolExecutionRequests);
+                    } else {
+                        aiMessage = AiMessage.from(contentBuilder.toString());
+                    }
+
                     Response<AiMessage> response = Response.from(
-                            AiMessage.from(contentBuilder.toString()),
+                            aiMessage,
                             tokenUsage,
                             finishReason
                     );
@@ -127,9 +134,17 @@ public void onEvent(EventSource eventSource, String id, String type, String data
                     try {
                         MistralAiChatCompletionResponse chatCompletionResponse = GSON.fromJson(data, MistralAiChatCompletionResponse.class);
                         MistralAiChatCompletionChoice choice = chatCompletionResponse.getChoices().get(0);
+
                         String chunk = choice.getDelta().getContent();
-                        contentBuilder.append(chunk);
-                        handler.onNext(chunk);
+                        if (isNotNullOrBlank(chunk)) {
+                            contentBuilder.append(chunk);
+                            handler.onNext(chunk);
+                        }
+
+                        List<MistralAiToolCall> toolCalls = choice.getDelta().getToolCalls();
+                        if (!isNullOrEmpty(toolCalls)) {
+                            toolExecutionRequests = toToolExecutionRequests(toolCalls);
+                        }
 
                         MistralAiUsage usageInfo = chatCompletionResponse.getUsage();
                         if (usageInfo != null) {

langchain4j-mistral-ai/src/main/java/dev/langchain4j/model/mistralai/DefaultMistralAiHelper.java

@@ -1,5 +1,8 @@
 package dev.langchain4j.model.mistralai;
 
+import dev.langchain4j.agent.tool.ToolExecutionRequest;
+import dev.langchain4j.agent.tool.ToolParameters;
+import dev.langchain4j.agent.tool.ToolSpecification;
 import dev.langchain4j.data.message.*;
 import dev.langchain4j.model.output.FinishReason;
 import dev.langchain4j.model.output.TokenUsage;
@@ -11,8 +14,10 @@
 import java.util.stream.Collectors;
 import java.util.stream.StreamSupport;
 
-import static dev.langchain4j.model.output.FinishReason.LENGTH;
-import static dev.langchain4j.model.output.FinishReason.STOP;
+import static dev.langchain4j.data.message.AiMessage.aiMessage;
+import static dev.langchain4j.internal.Utils.isNullOrBlank;
+import static dev.langchain4j.internal.Utils.isNullOrEmpty;
+import static dev.langchain4j.model.output.FinishReason.*;
 import static java.util.stream.Collectors.toList;
 
 public class DefaultMistralAiHelper {
@@ -29,41 +34,70 @@ static List<MistralAiChatMessage> toMistralAiMessages(List<ChatMessage> messages
     }
 
     static MistralAiChatMessage toMistralAiMessage(ChatMessage message) {
-        return MistralAiChatMessage.builder()
-                .role(toMistralAiRole(message.type()))
-                .content(toMistralChatMessageContent(message))
-                .build();
-    }
-
-    private static MistralAiRole toMistralAiRole(ChatMessageType chatMessageType) {
-        switch (chatMessageType) {
-            case SYSTEM:
-                return MistralAiRole.SYSTEM;
-            case AI:
-                return MistralAiRole.ASSISTANT;
-            case USER:
-                return MistralAiRole.USER;
-            default:
-                throw new IllegalArgumentException("Unknown chat message type: " + chatMessageType);
-        }
-    }
-
-    private static String toMistralChatMessageContent(ChatMessage message) {
         if (message instanceof SystemMessage) {
-            return ((SystemMessage) message).text();
+            return MistralAiChatMessage.builder()
+                    .role(MistralAiRole.SYSTEM)
+                    .content(((SystemMessage) message).text())
+                    .build();
         }
 
         if (message instanceof AiMessage) {
-            return ((AiMessage) message).text();
+            AiMessage aiMessage = (AiMessage) message;
+
+            if (!aiMessage.hasToolExecutionRequests()) {
+                return MistralAiChatMessage.builder()
+                        .role(MistralAiRole.ASSISTANT)
+                        .content(aiMessage.text())
+                        .build();
+            }
+
+            List<MistralAiToolCall> toolCalls = aiMessage.toolExecutionRequests().stream()
+                    .map(DefaultMistralAiHelper::toMistralAiToolCall)
+                    .collect(toList());
+
+            if (isNullOrBlank(aiMessage.text())){
+                return MistralAiChatMessage.builder()
+                        .role(MistralAiRole.ASSISTANT)
+                        .content(null)
+                        .toolCalls(toolCalls)
+                        .build();
+            }
+
+            return MistralAiChatMessage.builder()
+                    .role(MistralAiRole.ASSISTANT)
+                    .content(aiMessage.text())
+                    .toolCalls(toolCalls)
+                    .build();
         }
 
         if (message instanceof UserMessage) {
-            return message.text(); // MistralAI support Text Content only as String
+            return MistralAiChatMessage.builder()
+                    .role(MistralAiRole.USER)
+                    .content(message.text()) // MistralAI support Text Content only as String
+                    .build();
+        }
+
+        if (message instanceof ToolExecutionResultMessage){
+            return MistralAiChatMessage.builder()
+                    .role(MistralAiRole.TOOL)
+                    .name(((ToolExecutionResultMessage) message).toolName())
+                    .content(((ToolExecutionResultMessage) message).text())
+                    .build();
         }
 
         throw new IllegalArgumentException("Unknown message type: " + message.type());
     }
 
+    static MistralAiToolCall toMistralAiToolCall(ToolExecutionRequest toolExecutionRequest) {
+        return MistralAiToolCall.builder()
+                .id(toolExecutionRequest.id())
+                .function(MistralAiFunctionCall.builder()
+                        .name(toolExecutionRequest.name())
+                        .arguments(toolExecutionRequest.arguments())
+                        .build())
+                .build();
+    }
+
     public static TokenUsage tokenUsageFrom(MistralAiUsage mistralAiUsage) {
         if (mistralAiUsage == null) {
             return null;
@@ -84,12 +118,76 @@ public static FinishReason finishReasonFrom(String mistralAiFinishReason) {
                 return STOP;
             case "length":
                 return LENGTH;
+            case "tool_calls":
+                return TOOL_EXECUTION;
+            case "content_filter":
+                return CONTENT_FILTER;
             case "model_length":
             default:
                 return null;
         }
     }
 
+    public static AiMessage aiMessageFrom(MistralAiChatCompletionResponse response) {
+        MistralAiChatMessage aiMistralMessage = response.getChoices().get(0).getMessage();
+        List<MistralAiToolCall> toolCalls = aiMistralMessage.getToolCalls();
+        if (!isNullOrEmpty(toolCalls)){
+            return AiMessage.from(toToolExecutionRequests(toolCalls));
+        }
+        return  AiMessage.from(aiMistralMessage.getContent());
+    }
+
+    public static List<ToolExecutionRequest> toToolExecutionRequests(List<MistralAiToolCall> mistralAiToolCalls) {
+        return mistralAiToolCalls.stream()
+                .filter(toolCall -> toolCall.getType() == MistralAiToolType.FUNCTION)
+                .map(DefaultMistralAiHelper::toToolExecutionRequest)
+                .collect(toList());
+    }
+
+    public static ToolExecutionRequest toToolExecutionRequest(MistralAiToolCall mistralAiToolCall) {
+        return ToolExecutionRequest.builder()
+                .id(mistralAiToolCall.getId())
+                .name(mistralAiToolCall.getFunction().getName())
+                .arguments(mistralAiToolCall.getFunction().getArguments())
+                .build();
+    }
+
+    static List<MistralAiTool> toMistralAiTools(List<ToolSpecification> toolSpecifications) {
+        return toolSpecifications.stream()
+                .map(DefaultMistralAiHelper::toMistralAiTool)
+                .collect(toList());
+    }
+
+    static MistralAiTool toMistralAiTool(ToolSpecification toolSpecification) {
+        MistralAiFunction function = MistralAiFunction.builder()
+                .name(toolSpecification.name())
+                .description(toolSpecification.description())
+                .parameters(toMistralAiParameters(toolSpecification.parameters()))
+                .build();
+        return MistralAiTool.from(function);
+    }
+
+    static MistralAiParameters toMistralAiParameters(ToolParameters parameters){
+        if (parameters == null) {
+            return MistralAiParameters.builder().build();
+        }
+        return MistralAiParameters.from(parameters);
+    }
+
+    static MistralAiResponseFormat toMistralAiResponseFormat(String responseFormat) {
+        if (responseFormat == null) {
+            return null;
+        }
+        switch (responseFormat) {
+            case "text":
+                return MistralAiResponseFormat.fromType(MistralAiResponseFormatType.TEXT);
+            case "json_object":
+                return MistralAiResponseFormat.fromType(MistralAiResponseFormatType.JSON_OBJECT);
+            default:
+                throw new IllegalArgumentException("Unknown response format: " + responseFormat);
+        }
+    }
+
     static String getHeaders(Headers headers) {
         return StreamSupport.stream(headers.spliterator(), false).map(header -> {
             String headerKey = header.component1();

langchain4j-mistral-ai/src/main/java/dev/langchain4j/model/mistralai/MistralAiChatCompletionRequest.java

@@ -21,4 +21,8 @@ public class MistralAiChatCompletionRequest {
     private Boolean stream;
     private Boolean safePrompt;
     private Integer randomSeed;
+    private List<MistralAiTool> tools;
+    private MistralAiToolChoiceName toolChoice;
+    private MistralAiResponseFormat responseFormat;
+
 }

langchain4j-mistral-ai/src/main/java/dev/langchain4j/model/mistralai/MistralAiChatMessage.java

@@ -5,6 +5,8 @@
 import lombok.Data;
 import lombok.NoArgsConstructor;
 
+import java.util.List;
+
 @Data
 @NoArgsConstructor
 @AllArgsConstructor
@@ -13,4 +15,6 @@ public class MistralAiChatMessage {
 
     private MistralAiRole role;
     private String content;
+    private String name;
+    private List<MistralAiToolCall> toolCalls;
 }