Add Supplier and Consumer function callback support in function calling

Add support for no-argument Supplier and single-argument Consumer function
callbacks in the Spring AI core module. This enhancement allows:
- Registration of Supplier<O> callbacks with no input (Void) type
- Registration of Consumer<I> callbacks with no output (Void) type
- Support for Kotlin Function0 (equivalent to Java Supplier)
- Handle empty properties for Void input types in schema generation
- Enhance FunctionCallback builder to support Supplier/Consumer patterns

Additional changes:
- Add test coverage for both Supplier and Consumer callbacks in various scenarios
- Enhance TypeResolverHelper to support Consumer input type resolution
- Support lambda-style function declarations for improved ergonomics
- Add test cases for void input/output handling in OpenAI chat model
- Include examples of function calls without return values
- Add support for parameterless functions through Supplier interface

Add comprehensive documentation for the FunctionCallback API:
- Overview of the interface and its key methods
- Builder pattern usage with function and method invocation approaches
- Examples for different function types (Function, BiFunction, Supplier, Consumer)
- Best practices and common pitfalls
- Schema generation and customization options

Resolves #1718 , #1277 , #1118, #860

Author: tzolov

models/spring-ai-openai/src/test/java/org/springframework/ai/openai/audio/speech/OpenAiSpeechModelIT.java

@@ -106,7 +106,8 @@ void shouldStreamNonEmptyResponsesForValidSpeechPrompts() {
 		List<SpeechResponse> responses = responseFlux.collectList().block();
 		assertThat(responses).isNotNull();
 		responses.forEach(response -> {
-			System.out.println("Audio data chunk size: " + response.getResult().getOutput().length);
+			// System.out.println("Audio data chunk size: " +
+			// response.getResult().getOutput().length);
 			assertThat(response.getResult().getOutput()).isNotEmpty();
 		});
 	}

models/spring-ai-openai/src/test/java/org/springframework/ai/openai/chat/OpenAiChatModelFunctionCallingIT.java

@@ -19,6 +19,7 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.BiFunction;
 import java.util.stream.Collectors;
 
@@ -28,6 +29,7 @@
 import org.slf4j.LoggerFactory;
 import reactor.core.publisher.Flux;
 
+import org.springframework.ai.chat.client.ChatClient;
 import org.springframework.ai.chat.messages.AssistantMessage;
 import org.springframework.ai.chat.messages.Message;
 import org.springframework.ai.chat.messages.UserMessage;
@@ -59,6 +61,25 @@ class OpenAiChatModelFunctionCallingIT {
 	@Autowired
 	ChatModel chatModel;
 
+	@Test
+	void functionCallSupplier() {
+
+		Map<String, Object> state = new ConcurrentHashMap<>();
+
+		// @formatter:off
+		String response = ChatClient.create(this.chatModel).prompt()
+				.user("Turn the light on in the living room")
+				.functions(FunctionCallback.builder()
+						.function("turnsLightOnInTheLivingRoom", () -> state.put("Light", "ON"))
+						.build())
+				.call()
+				.content();
+		// @formatter:on
+
+		logger.info("Response: {}", response);
+		assertThat(state).containsEntry("Light", "ON");
+	}
+
 	@Test
 	void functionCallTest() {
 		functionCallTest(OpenAiChatOptions.builder()

spring-ai-core/src/main/java/org/springframework/ai/model/ModelOptionsUtils.java

@@ -340,7 +340,7 @@ private static String toGetName(String name) {
 	 * @return the generated JSON Schema as a String.
 	 * @deprecated use {@link #getJsonSchema(Type, boolean)} instead.
 	 */
-	@Deprecated
+	@Deprecated(since = "1.0 M4")
 	public static String getJsonSchema(Class<?> clazz, boolean toUpperCaseTypeValues) {
 
 		if (SCHEMA_GENERATOR_CACHE.get() == null) {
@@ -395,6 +395,11 @@ public static String getJsonSchema(Type inputType, boolean toUpperCaseTypeValues
 		}
 
 		ObjectNode node = SCHEMA_GENERATOR_CACHE.get().generateSchema(inputType);
+
+		if ((inputType == Void.class) && !node.has("properties")) {
+			node.putObject("properties");
+		}
+
 		if (toUpperCaseTypeValues) { // Required for OpenAPI 3.0 (at least Vertex AI
 			// version of it).
 			toUpperCaseTypeValues(node);

spring-ai-core/src/main/java/org/springframework/ai/model/function/DefaultFunctionCallbackBuilder.java

@@ -1,24 +1,27 @@
 /*
-* Copyright 2024 - 2024 the original author or authors.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-* https://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Copyright 2023-2024 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package org.springframework.ai.model.function;
 
 import java.lang.reflect.Type;
 import java.util.Arrays;
 import java.util.function.BiFunction;
+import java.util.function.Consumer;
 import java.util.function.Function;
+import java.util.function.Supplier;
 
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.DeserializationFeature;
@@ -43,7 +46,7 @@
 
 /**
  * Default implementation of the {@link FunctionCallback.Builder}.
- * 
+ *
  * @author Christian Tzolov
  * @since 1.0.0
  */
@@ -137,6 +140,20 @@ public <I, O> FunctionInvokingSpec<I, O> function(String name, BiFunction<I, Too
 		return new DefaultFunctionInvokingSpec<>(name, biFunction);
 	}
 
+	@Override
+	public <O> FunctionInvokingSpec<Void, O> function(String name, Supplier<O> supplier) {
+		Function<Void, O> function = (input) -> supplier.get();
+		return new DefaultFunctionInvokingSpec<>(name, function).inputType(Void.class);
+	}
+
+	public <I> FunctionInvokingSpec<I, Void> function(String name, Consumer<I> consumer) {
+		Function<I, Void> function = (I input) -> {
+			consumer.accept(input);
+			return null;
+		};
+		return new DefaultFunctionInvokingSpec<>(name, function);
+	}
+
 	@Override
 	public MethodInvokingSpec method(String methodName, Class<?>... argumentTypes) {
 		return new DefaultMethodInvokingSpec(methodName, argumentTypes);

spring-ai-core/src/main/java/org/springframework/ai/model/function/FunctionCallback.java

@@ -17,7 +17,9 @@
 package org.springframework.ai.model.function;
 
 import java.util.function.BiFunction;
+import java.util.function.Consumer;
 import java.util.function.Function;
+import java.util.function.Supplier;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 
@@ -141,6 +143,16 @@ interface Builder {
 		 */
 		<I, O> FunctionInvokingSpec<I, O> function(String name, BiFunction<I, ToolContext, O> biFunction);
 
+		/**
+		 * Builds a {@link Supplier} invoking {@link FunctionCallback} instance.
+		 */
+		<O> FunctionInvokingSpec<Void, O> function(String name, Supplier<O> supplier);
+
+		/**
+		 * Builds a {@link Consumer} invoking {@link FunctionCallback} instance.
+		 */
+		<I> FunctionInvokingSpec<I, Void> function(String name, Consumer<I> consumer);
+
 		/**
 		 * Builds a Method invoking {@link FunctionCallback} instance.
 		 */
@@ -189,14 +201,14 @@ interface MethodInvokingSpec {
 		MethodInvokingSpec name(String name);
 
 		/**
-		 * For non static objects the target object is used to invoke the method.
+		 * For non-static objects the target object is used to invoke the method.
 		 * @param methodObject target object where the method is defined.
 		 */
 		MethodInvokingSpec targetObject(Object methodObject);
 
 		/**
-		 * Target class where the method is defined. Used for static methods. For non
-		 * static methods the target object is used.
+		 * Target class where the method is defined. Used for static methods. For
+		 * non-static methods the target object is used.
 		 * @param targetClass method target class.
 		 */
 		MethodInvokingSpec targetClass(Class<?> targetClass);

spring-ai-core/src/main/java/org/springframework/ai/model/function/FunctionCallbackContext.java

@@ -17,9 +17,12 @@
 package org.springframework.ai.model.function;
 
 import java.util.function.BiFunction;
+import java.util.function.Consumer;
 import java.util.function.Function;
+import java.util.function.Supplier;
 
 import com.fasterxml.jackson.annotation.JsonClassDescription;
+import kotlin.jvm.functions.Function0;
 import kotlin.jvm.functions.Function1;
 import kotlin.jvm.functions.Function2;
 
@@ -30,6 +33,7 @@
 import org.springframework.context.annotation.Description;
 import org.springframework.context.support.GenericApplicationContext;
 import org.springframework.core.KotlinDetector;
+import org.springframework.core.ParameterizedTypeReference;
 import org.springframework.core.ResolvableType;
 import org.springframework.lang.NonNull;
 import org.springframework.lang.Nullable;
@@ -38,9 +42,9 @@
 /**
  * A Spring {@link ApplicationContextAware} implementation that provides a way to retrieve
  * a {@link Function} from the Spring context and wrap it into a {@link FunctionCallback}.
- *
+ * <p>
  * The name of the function is determined by the bean name.
- *
+ * <p>
  * The description of the function is determined by the following rules:
  * <ul>
  * <li>Provided as a default description</li>
@@ -69,24 +73,28 @@ public void setApplicationContext(@NonNull ApplicationContext applicationContext
 
 	@SuppressWarnings({ "unchecked" })
 	public FunctionCallback getFunctionCallback(@NonNull String beanName, @Nullable String defaultDescription) {
-
 		ResolvableType functionType = TypeResolverHelper.resolveBeanType(this.applicationContext, beanName);
-		ResolvableType functionInputType = TypeResolverHelper.getFunctionArgumentType(functionType, 0);
+		ResolvableType functionInputType = (ResolvableType.forType(Supplier.class).isAssignableFrom(functionType))
+				? ResolvableType.forType(Void.class) : TypeResolverHelper.getFunctionArgumentType(functionType, 0);
+
+		String functionDescription = resolveFunctionDescription(beanName, defaultDescription,
+				functionInputType.toClass());
+		Object bean = this.applicationContext.getBean(beanName);
+
+		return buildFunctionCallback(beanName, functionType, functionInputType, functionDescription, bean);
+	}
 
-		Class<?> functionInputClass = functionInputType.toClass();
+	private String resolveFunctionDescription(String beanName, String defaultDescription, Class<?> functionInputClass) {
 		String functionDescription = defaultDescription;
 
 		if (!StringUtils.hasText(functionDescription)) {
-			// Look for a Description annotation on the bean
 			Description descriptionAnnotation = this.applicationContext.findAnnotationOnBean(beanName,
 					Description.class);
-
 			if (descriptionAnnotation != null) {
 				functionDescription = descriptionAnnotation.value();
 			}
 
 			if (!StringUtils.hasText(functionDescription)) {
-				// Look for a JsonClassDescription annotation on the input class
 				JsonClassDescription jsonClassDescriptionAnnotation = functionInputClass
 					.getAnnotation(JsonClassDescription.class);
 				if (jsonClassDescriptionAnnotation != null) {
@@ -95,51 +103,79 @@ public FunctionCallback getFunctionCallback(@NonNull String beanName, @Nullable
 			}
 
 			if (!StringUtils.hasText(functionDescription)) {
-				throw new IllegalStateException("Could not determine function description."
+				throw new IllegalStateException("Could not determine function description. "
 						+ "Please provide a description either as a default parameter, via @Description annotation on the bean "
 						+ "or @JsonClassDescription annotation on the input class.");
 			}
 		}
 
-		Object bean = this.applicationContext.getBean(beanName);
+		return functionDescription;
+	}
+
+	private FunctionCallback buildFunctionCallback(String beanName, ResolvableType functionType,
+			ResolvableType functionInputType, String functionDescription, Object bean) {
 
 		if (KotlinDetector.isKotlinPresent()) {
 			if (KotlinDelegate.isKotlinFunction(functionType.toClass())) {
 				return FunctionCallback.builder()
 					.schemaType(this.schemaType)
 					.description(functionDescription)
 					.function(beanName, KotlinDelegate.wrapKotlinFunction(bean))
-					.inputType(functionInputClass)
+					.inputType(ParameterizedTypeReference.forType(functionInputType.getType()))
 					.build();
 			}
-			else if (KotlinDelegate.isKotlinBiFunction(functionType.toClass())) {
+			if (KotlinDelegate.isKotlinBiFunction(functionType.toClass())) {
 				return FunctionCallback.builder()
 					.description(functionDescription)
 					.schemaType(this.schemaType)
 					.function(beanName, KotlinDelegate.wrapKotlinBiFunction(bean))
-					.inputType(functionInputClass)
+					.inputType(ParameterizedTypeReference.forType(functionInputType.getType()))
+					.build();
+			}
+			if (KotlinDelegate.isKotlinSupplier(functionType.toClass())) {
+				return FunctionCallback.builder()
+					.description(functionDescription)
+					.schemaType(this.schemaType)
+					.function(beanName, KotlinDelegate.wrapKotlinSupplier(bean))
+					.inputType(ParameterizedTypeReference.forType(functionInputType.getType()))
 					.build();
 			}
 		}
+
 		if (bean instanceof Function<?, ?> function) {
 			return FunctionCallback.builder()
 				.schemaType(this.schemaType)
 				.description(functionDescription)
 				.function(beanName, function)
-				.inputType(functionInputClass)
+				.inputType(ParameterizedTypeReference.forType(functionInputType.getType()))
 				.build();
 		}
-		else if (bean instanceof BiFunction<?, ?, ?>) {
+		if (bean instanceof BiFunction<?, ?, ?>) {
 			return FunctionCallback.builder()
 				.description(functionDescription)
 				.schemaType(this.schemaType)
 				.function(beanName, (BiFunction<?, ToolContext, ?>) bean)
-				.inputType(functionInputClass)
+				.inputType(ParameterizedTypeReference.forType(functionInputType.getType()))
+				.build();
+		}
+		if (bean instanceof Supplier<?> supplier) {
+			return FunctionCallback.builder()
+				.description(functionDescription)
+				.schemaType(this.schemaType)
+				.function(beanName, supplier)
+				.inputType(ParameterizedTypeReference.forType(functionInputType.getType()))
 				.build();
 		}
-		else {
-			throw new IllegalStateException();
+		if (bean instanceof Consumer<?> consumer) {
+			return FunctionCallback.builder()
+				.description(functionDescription)
+				.schemaType(this.schemaType)
+				.function(beanName, consumer)
+				.inputType(ParameterizedTypeReference.forType(functionInputType.getType()))
+				.build();
 		}
+
+		throw new IllegalStateException("Unsupported function type");
 	}
 
 	public enum SchemaType {
@@ -148,7 +184,16 @@ public enum SchemaType {
 
 	}
 
-	private static class KotlinDelegate {
+	private static final class KotlinDelegate {
+
+		public static boolean isKotlinSupplier(Class<?> clazz) {
+			return Function0.class.isAssignableFrom(clazz);
+		}
+
+		@SuppressWarnings("unchecked")
+		public static Supplier<?> wrapKotlinSupplier(Object function) {
+			return () -> ((Function0<Object>) function).invoke();
+		}
 
 		public static boolean isKotlinFunction(Class<?> clazz) {
 			return Function1.class.isAssignableFrom(clazz);