fix(tool): handle empty tool publisher results (#1498)

## AgentScope-Java Version

1.1.0-SNAPSHOT

## Description

This PR fixes an edge case where a tool returns `Mono.empty()`.

Previously, when a tool publisher completed without emitting a result,
`ToolExecutor.executeAll()` collected fewer `ToolResultBlock`s than tool
calls. `ReActAgent.executeToolCalls()` then paired tool calls and
results by index, which could throw `IndexOutOfBoundsException`.

Changes made:

- Convert empty tool publishers into an error `ToolResultBlock`.
- Keep one result per tool call so `ReActAgent` can safely pair tool
calls and results.
- Add a regression test for a tool that returns `Mono.empty()`.

Minimal reproduction tool:

```java
@tool(
        name = "empty_result_tool",
        description = "Simulate a tool that completes without returning a result")
public Mono<String> emptyResultTool() {
    return Mono.empty();
}
```

Test command:
```bash
mvn -pl agentscope-core -Dtest=ToolExecutorTest test
```

Local result:
```text
Tests run: 9, Failures: 0, Errors: 0, Skipped: 0
BUILD SUCCESS
```

Fixes #1497

## Checklist
Please check the following items before code is ready to be reviewed.

- [x] Code has been formatted with `mvn spotless:apply`
- [ ] All tests are passing (`mvn test`)
- [ ] Javadoc comments are complete and follow project conventions
- [ ] Related documentation has been updated (e.g. links, examples,
etc.)
- [x] Code is ready for review

Co-authored-by: LearningGp <learninggp4.74@gmail.com>

Author: java-lbb

agentscope-core/src/main/java/io/agentscope/core/tool/ToolExecutor.java

@@ -260,7 +260,12 @@ private Mono<ToolResultBlock> executeCore(ToolCallParam param) {
                                             : e.getClass().getSimpleName();
                             return Mono.just(
                                     ToolResultBlock.error("Tool execution failed: " + errorMsg));
-                        });
+                        })
+                .switchIfEmpty(
+                        Mono.just(
+                                ToolResultBlock.error(
+                                        "Tool execution failed: Tool completed without returning a"
+                                                + " result")));
     }
 
     // ==================== Batch Tool Execution ====================

agentscope-core/src/test/java/io/agentscope/core/tool/ToolExecutorTest.java

@@ -126,6 +126,53 @@ void shouldReturnErrorWhenToolThrows() {
                 "Error message should be wrapped by executor");
     }
 
+    @Test
+    @DisplayName("Should convert empty tool publishers to error responses")
+    void shouldReturnErrorWhenToolCompletesEmpty() {
+        toolkit.registerTool(
+                new AgentTool() {
+                    @Override
+                    public String getName() {
+                        return "empty_tool";
+                    }
+
+                    @Override
+                    public String getDescription() {
+                        return "Tool that completes without a result";
+                    }
+
+                    @Override
+                    public Map<String, Object> getParameters() {
+                        return Map.of("type", "object", "properties", Map.of());
+                    }
+
+                    @Override
+                    public Mono<ToolResultBlock> callAsync(ToolCallParam param) {
+                        return Mono.empty();
+                    }
+                });
+
+        Map<String, Object> emptyInput = Map.of();
+        ToolUseBlock emptyCall =
+                ToolUseBlock.builder()
+                        .id("call-empty")
+                        .name("empty_tool")
+                        .input(emptyInput)
+                        .content(JsonUtils.getJsonCodec().toJson(emptyInput))
+                        .build();
+
+        List<ToolResultBlock> responses =
+                toolkit.callTools(List.of(emptyCall), null, null, null).block(TIMEOUT);
+
+        assertNotNull(responses, "Executor should return an error response");
+        assertEquals(1, responses.size(), "Empty completion should still yield one response");
+        assertEquals("call-empty", responses.get(0).getId(), "Response should keep tool call id");
+        assertEquals("empty_tool", responses.get(0).getName(), "Response should keep tool name");
+        assertEquals(
+                "Error: Tool execution failed: Tool completed without returning a result",
+                extractFirstText(responses.get(0)));
+    }
+
     @Test
     @DisplayName("Should NOT specially handle InterruptedException in error path")
     void testToolErrorWithoutInterruptSpecialCase() {