Error "toolInput cannot be null or empty" when calling in stream mode

[MikDanila]

Bug description
Getting error "toolInput cannot be null or empty" while calling .stream() in chatClient

java.lang.IllegalArgumentException: toolInput cannot be null or empty
	at org.springframework.util.Assert.hasText(Assert.java:253) ~[spring-core-6.2.6.jar:6.2.6]
	at org.springframework.ai.tool.method.MethodToolCallback.call(MethodToolCallback.java:99) ~[spring-ai-model-1.0.0.jar:1.0.0]
	at org.springframework.ai.model.tool.DefaultToolCallingManager.lambda$executeToolCall$5(DefaultToolCallingManager.java:224) ~[spring-ai-model-1.0.0.jar:1.0.0]
	at io.micrometer.observation.Observation.observe(Observation.java:564) ~[micrometer-observation-1.14.6.jar:1.14.6]
	at org.springframework.ai.model.tool.DefaultToolCallingManager.executeToolCall(DefaultToolCallingManager.java:221) ~[spring-ai-model-1.0.0.jar:1.0.0]
	at org.springframework.ai.model.tool.DefaultToolCallingManager.executeToolCalls(DefaultToolCallingManager.java:137) ~[spring-ai-model-1.0.0.jar:1.0.0]
	at org.springframework.ai.openai.OpenAiChatModel.lambda$internalStream$10(OpenAiChatModel.java:369) ~[spring-ai-openai-1.0.0.jar:1.0.0]
	at reactor.core.publisher.FluxDefer.subscribe(FluxDefer.java:46) ~[reactor-core-3.7.5.jar:3.7.5]
	at reactor.core.publisher.FluxSubscribeOn$SubscribeOnSubscriber.run(FluxSubscribeOn.java:194) ~[reactor-core-3.7.5.jar:3.7.5]
	at reactor.core.scheduler.WorkerTask.call(WorkerTask.java:84) ~[reactor-core-3.7.5.jar:3.7.5]
	at reactor.core.scheduler.WorkerTask.call(WorkerTask.java:37) ~[reactor-core-3.7.5.jar:3.7.5]
	at java.base/java.util.concurrent.FutureTask.run(FutureTask.java:317) ~[na:na]
	at java.base/java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(ScheduledThreadPoolExecutor.java:304) ~[na:na]
	at java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1144) ~[na:na]
	at java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:642) ~[na:na]
	at java.base/java.lang.Thread.run(Thread.java:1583) ~[na:na]

Environment
Spring AI 1.0.0, Java version temurin-21.0.1, Vllm

Expected behavior
There are no error when invoke .call() method, but have error when invoke .stream()

Minimal Complete Reproducible example
Run Vllm:

docker run --runtime nvidia --gpus all --name Qwen3-8B-AWQ -p 8000:8000 --ipc=host vllm/vllm-openai:latest --model Qwen/Qwen3-8B-AWQ --gpu-memory-utilization 0.75 --max-model-len 8192 --enforce-eager --enable-auto-tool-choice --tool-call-parser hermes

application.properties

spring.ai.openai.base-url=http://localhost:8000
spring.ai.openai.chat.options.model=Qwen/Qwen3-8B-AWQ
spring.ai.openai.api-key=KEY

Create Simple Date Time calling tool

@Component
public class DateTimeTools {
  private static final Logger log = LoggerFactory.getLogger(DateTimeTools.class);

  @Tool(description = "Get date and time user")
  public String getCurrentDateTime() {
    log.info("Called tool getCurrentDateTime()");
    return LocalDateTime.now().toString();
  }
}

Create Simple controller:

@RestController
public class ChatApiController {
  private final ChatClient chatClient;

  public ChatApiController(ChatClient.Builder chatClientBuilder, DateTimeTools dateTimeTools) {
    this.chatClient = chatClientBuilder
        .defaultTools(dateTimeTools)
        .build();
  }

  @PostMapping("/api/stream/v1")
  public Flux<String> sendStreamMessage(@RequestBody MessageRequest message) {
    String userInput = message.message();

    return this.chatClient.prompt()
        .user(userInput)
        .stream()
        .content();
  }
}

Steps to reproduce
Call method:
POST http://localhost:8080/api/stream/v1
Content-Type: application/json

{
"message": "Give me current date"
}

[lolosiax]

You can fix this by temporarily adding dummy arguments to each mcp tool. @tianli-sir
LLM will try to pass a null when there are no arguments.

@mcp.tool(description="Get the system time.")
async def get_time(dummy: str) -> str:
    return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())

@Tool(description = "Get the system time.")
String getTime(String dummy){
    return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
}

This is because even though the function is @NonNull, null is actually passed as an argument.
I tried to intercept the null, but failed.

Java code

package top.lolosia.ai.util.llm;

import top.lolosia.ai.util.event.Event;
import top.lolosia.ai.util.event.EventHandle;
import top.lolosia.ai.util.event.IEventHandle;
import kotlin.jvm.functions.Function0;
import kotlinx.coroutines.BuildersKt;
import kotlinx.coroutines.Dispatchers;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.springframework.ai.chat.model.ToolContext;
import org.springframework.ai.mcp.AsyncMcpToolCallback;
import org.springframework.ai.tool.ToolCallback;
import org.springframework.ai.tool.definition.ToolDefinition;
import org.springframework.ai.tool.metadata.ToolMetadata;

public class MergedToolCallback implements ToolCallback {
    @NotNull ToolCallback callback;

    EventHandle<EntryEvent> entryEventHandle = new EventHandle<>();
    EventHandle<ExitEvent> exitEventHandle = new EventHandle<>();

    public MergedToolCallback(@NotNull ToolCallback callback) {
        this.callback = callback;
    }

    @NotNull
    @Override
    public ToolDefinition getToolDefinition() {
        return callback.getToolDefinition();
    }

    @NotNull
    @Override
    public ToolMetadata getToolMetadata() {
        return callback.getToolMetadata();
    }

    @NotNull
    @Override
    public String call(@Nullable String toolInput) {
        if (toolInput == null) {
            toolInput = "{}";
        }
        entryEventHandle.publish(new EntryEvent(this, toolInput, null));

        @NotNull String finalToolInput = toolInput;
        String result = callOtherDispatcher(() -> callback.call(finalToolInput));
        exitEventHandle.publish(new ExitEvent(this, toolInput, null, result));
        return result;
    }

    @NotNull
    @Override
    public String call(@Nullable String toolInput, ToolContext tooContext) {
        if (toolInput == null) {
            toolInput = "{}";
        }
        entryEventHandle.publish(new EntryEvent(this, toolInput, tooContext));

        @NotNull String finalToolInput = toolInput;
        String result = callOtherDispatcher(() -> callback.call(finalToolInput, tooContext));
        exitEventHandle.publish(new ExitEvent(this, toolInput, tooContext, result));
        return result;
    }
    
    /** fix reactor Mono.block() exception */
    private <T> T callOtherDispatcher(Function0<T> callback0) {
        if (callback instanceof AsyncMcpToolCallback) {
            try {
                return BuildersKt.runBlocking(
                        Dispatchers.getIO(),
                        (cs, co) -> callback0.invoke()
                );
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        } else return callback0.invoke();
    }

    @NotNull
    @Override
    @SuppressWarnings("deprecation")
    public String getName() {
        return callback.getName();
    }

    @NotNull
    @Override
    @SuppressWarnings("deprecation")
    public String getDescription() {
        return callback.getDescription();
    }

    @NotNull
    @Override
    @SuppressWarnings("deprecation")
    public String getInputTypeSchema() {
        return callback.getInputTypeSchema();
    }

    public @NotNull IEventHandle<EntryEvent> getEntryEventHandle() {
        return entryEventHandle;
    }

    public @NotNull IEventHandle<ExitEvent> getExitEventHandle() {
        return exitEventHandle;
    }

    public static class EntryEvent extends Event {
        @NotNull String toolInput;
        @Nullable ToolContext toolContext;

        public EntryEvent(@NotNull Object source, @NotNull String toolInput, @Nullable ToolContext toolContext) {
            super(source);
            this.toolInput = toolInput;
            this.toolContext = toolContext;
        }

        public @NotNull String getToolInput() {
            return toolInput;
        }

        public @Nullable ToolContext getToolContext() {
            return toolContext;
        }

        public @NotNull ToolCallback getTool() {
            return (ToolCallback) getSource();
        }
    }

    public static class ExitEvent extends EntryEvent {
        @NotNull String responseText;

        public ExitEvent(
                @NotNull Object source,
                @NotNull String toolInput,
                @Nullable ToolContext tooContext,
                @NotNull String responseText
        ) {
            super(source, toolInput, tooContext);
            this.responseText = responseText;
        }

        public @NotNull String getResponseText() {
            return responseText;
        }
    }
}

[MikDanila]

@lolosiax Thank you, it work for me