Merge branch 'main' into feat(models)_Kimi_Model_Adaptation

Author: Leeaoyin

README.md

@@ -61,6 +61,7 @@ AgentScope Java 2.0 is a production-ready framework for building distributed, en
 - [**Workspace & Sandbox** →](https://java.agentscope.io/v2/en/docs/harness/workspace.html) Run tools in isolated environments — local, Docker, Kubernetes, or AgentRun cloud sandbox.
 - [**Multi-Agent Orchestration** →](https://java.agentscope.io/v2/en/docs/harness/subagent.html) Multiple subagent definition patterns with `agent_spawn` / `agent_send` and real-time event forwarding.
 - [**Distributed Deployment** →](https://java.agentscope.io/v2/en/docs/others/going-to-production.html) True distributed session and memory management (Redis / MySQL / PostgreSQL / OSS / COS) with cross-replica session recovery.
+- [**Agent Evolution** →](https://help.aliyun.com/zh/document_detail/3042583.html) Provides Agent observability and auditing, Agent evaluation and experimentation, and Agent asset management and continuous optimization.
 
 <img src="./docs/imgs/landscape.png" alt="agentscope" width="100%"/>
 

README_zh.md

@@ -61,6 +61,7 @@ AgentScope Java 2.0 是面向企业级、分布式、生产环境的智能体框
 - [**Workspace 与沙箱** →](https://java.agentscope.io/v2/zh/docs/harness/workspace.html) 在隔离环境中执行工具 —— 本地、Docker、Kubernetes 或 AgentRun 云沙箱。
 - [**多智能体编排** →](https://java.agentscope.io/v2/zh/docs/harness/subagent.html) 多种子智能体定义模式，`agent_spawn` / `agent_send` + 事件流实时转发。
 - [**分布式部署** →](https://java.agentscope.io/v2/zh/docs/others/going-to-production.html) 真正的分布式 session 与 memory 管理（Redis / MySQL / PostgreSQL / OSS / COS），跨副本 session 恢复。
+- [**智能体进化** →](https://help.aliyun.com/zh/document_detail/3042583.html) 提供 Agent 全栈观测与审计、Agent 评估与实验、Agent 资产管理与持续优化等能力。
 
 <img src="./docs/imgs/landscape.png" alt="agentscope" width="100%"/>
 

agentscope-core/src/main/java/io/agentscope/core/ReActAgent.java

@@ -2133,13 +2133,31 @@ Flux<AgentEvent> reasoningStream(
             Function<ModelCallInput, Flux<AgentEvent>> modelCallCore =
                     mci -> modelCallStream(context, mci, true);
 
+            StringBuilder transformedText = new StringBuilder();
+            AtomicBoolean sawTransformedTextDelta = new AtomicBoolean(false);
             return MiddlewareChain.build(
                             middlewares,
                             ReActAgent.this,
                             rc,
                             MiddlewareBase::onModelCall,
                             modelCallCore)
-                    .apply(new ModelCallInput(messages, tools, options, modelForCall()));
+                    .apply(new ModelCallInput(messages, tools, options, modelForCall()))
+                    .doOnNext(
+                            event -> {
+                                if (event instanceof TextBlockDeltaEvent textDelta) {
+                                    sawTransformedTextDelta.set(true);
+                                    if (textDelta.getDelta() != null) {
+                                        transformedText.append(textDelta.getDelta());
+                                    }
+                                }
+                            })
+                    .doOnTerminate(
+                            () -> {
+                                if (sawTransformedTextDelta.get()
+                                        || !context.getAccumulatedText().isEmpty()) {
+                                    context.replaceAccumulatedText(transformedText.toString());
+                                }
+                            });
         }
 
         private Flux<AgentEvent> modelCallStream(
@@ -2534,7 +2552,7 @@ private Flux<AgentEvent> runToolBatch(
             for (ToolUseBlock tc : toolCalls) {
                 if (deniedIds.contains(tc.getId())) {
                     ToolResultBlock denied =
-                            ToolResultBlock.text("Permission denied by user")
+                            ToolResultBlock.text("Permission denied by rules")
                                     .withIdAndName(tc.getId(), tc.getName())
                                     .withState(ToolResultState.DENIED);
                     deniedEntries.add(Map.entry(tc, denied));
@@ -2555,7 +2573,7 @@ private Flux<AgentEvent> runToolBatch(
                                                         replyId,
                                                         use.getId(),
                                                         use.getName(),
-                                                        "Permission denied by user"),
+                                                        "Permission denied by rules"),
                                                 new ToolResultEndEvent(
                                                         replyId,
                                                         use.getId(),
@@ -3695,11 +3713,38 @@ public AgentState getAgentState(String userId, String sessionId) {
     public void setPermissionMode(String userId, String sessionId, PermissionMode mode) {
         Objects.requireNonNull(mode, "mode must not be null");
         String sid = (sessionId == null || sessionId.isBlank()) ? defaultSessionId : sessionId;
-        String slot = slotKey(userId, sid);
-        AgentState s = getAgentState(userId, sid);
-        s.setPermissionContext(s.getPermissionContext().withMode(mode));
-        permissionEngineCache.put(slot, new PermissionEngine(s.getPermissionContext()));
-        saveAgentState(userId, sid);
+        AgentState state = getAgentState(userId, sid);
+        installPermissionContext(userId, sid, state, state.getPermissionContext().withMode(mode));
+    }
+
+    /**
+     * Replaces the permission context for one {@code (userId, sessionId)} slot, rebuilds that
+     * slot's permission engine, and persists the updated state.
+     *
+     * <p>An in-flight call keeps the call-scoped engine it started with. The replacement applies
+     * to subsequent calls on this slot and does not affect any other user or session.
+     *
+     * @param userId user identity for the slot (may be {@code null})
+     * @param sessionId session identity (falls back to the default session id when {@code null})
+     * @param permissionContext complete replacement context
+     */
+    public void replacePermissionContext(
+            String userId, String sessionId, PermissionContextState permissionContext) {
+        Objects.requireNonNull(permissionContext, "permissionContext must not be null");
+        String sid = (sessionId == null || sessionId.isBlank()) ? defaultSessionId : sessionId;
+        AgentState state = getAgentState(userId, sid);
+        installPermissionContext(userId, sid, state, permissionContext);
+    }
+
+    private void installPermissionContext(
+            String userId,
+            String sessionId,
+            AgentState state,
+            PermissionContextState permissionContext) {
+        state.setPermissionContext(permissionContext);
+        permissionEngineCache.put(
+                slotKey(userId, sessionId), new PermissionEngine(permissionContext));
+        saveAgentState(userId, sessionId);
     }
 
     /**

agentscope-core/src/main/java/io/agentscope/core/agent/accumulator/ReasoningContext.java

@@ -239,6 +239,16 @@ public String getAccumulatedText() {
         return textAcc.getAccumulated();
     }
 
+    /**
+     * Replace accumulated text after {@code onModelCall} middleware transforms text delta events.
+     *
+     * @hidden
+     * @param text text reconstructed from the transformed event stream
+     */
+    public void replaceAccumulatedText(String text) {
+        textAcc.replace(text);
+    }
+
     /**
      * Get the accumulated thinking content.
      *

agentscope-core/src/main/java/io/agentscope/core/agent/accumulator/TextAccumulator.java

@@ -74,4 +74,16 @@ public void reset() {
     public String getAccumulated() {
         return accumulated.toString();
     }
+
+    /**
+     * Replace the accumulated text with content reconstructed from the model-call event stream.
+     *
+     * @hidden
+     */
+    public void replace(String text) {
+        accumulated.setLength(0);
+        if (text != null) {
+            accumulated.append(text);
+        }
+    }
 }

agentscope-core/src/main/java/io/agentscope/core/agent/accumulator/ToolCallsAccumulator.java

@@ -67,9 +67,16 @@ void merge(ToolUseBlock block) {
                 this.name = block.getName();
             }
 
-            // Merge parameters
+            // Merge parameters. Skip null values so a partial/null map from an early
+            // stream chunk cannot wipe previously accumulated non-null arguments.
             if (block.getInput() != null) {
-                this.args.putAll(block.getInput());
+                for (Map.Entry<String, Object> entry : block.getInput().entrySet()) {
+                    if (entry.getValue() != null) {
+                        this.args.put(entry.getKey(), entry.getValue());
+                    } else if (!this.args.containsKey(entry.getKey())) {
+                        this.args.put(entry.getKey(), null);
+                    }
+                }
             }
 
             // Accumulate raw content (for parsing complete JSON)
@@ -87,17 +94,27 @@ ToolUseBlock build() {
             Map<String, Object> finalArgs = new HashMap<>(args);
             String rawContentStr = this.rawContent.toString();
 
-            // If no parsed arguments but has raw JSON content, try to parse
-            if (finalArgs.isEmpty() && rawContentStr.length() > 0) {
+            // Always attempt to parse the fully accumulated raw JSON. Early stream chunks may
+            // look like complete objects ({...}) but still contain null/incomplete values;
+            // the final raw content is the source of truth for missing or null keys.
+            if (!rawContentStr.isEmpty()) {
                 try {
                     @SuppressWarnings("unchecked")
                     Map<String, Object> parsed =
                             JsonUtils.getJsonCodec().fromJson(rawContentStr, Map.class);
                     if (parsed != null) {
-                        finalArgs.putAll(parsed);
+                        for (Map.Entry<String, Object> entry : parsed.entrySet()) {
+                            if (entry.getValue() == null) {
+                                continue;
+                            }
+                            Object existing = finalArgs.get(entry.getKey());
+                            if (existing == null || !finalArgs.containsKey(entry.getKey())) {
+                                finalArgs.put(entry.getKey(), entry.getValue());
+                            }
+                        }
                     }
                 } catch (Exception ignored) {
-                    // Parsing failed, keep empty args
+                    // Parsing failed, keep previously merged args
                 }
             }
 

agentscope-core/src/main/java/io/agentscope/core/middleware/MiddlewareBase.java

@@ -112,6 +112,10 @@ default Flux<AgentEvent> onActing(
     /**
      * Intercept the raw model API call.
      *
+     * <p>Transformations to {@link io.agentscope.core.event.TextBlockDeltaEvent} instances in the
+     * returned stream are reflected in the final response message. This allows middleware to
+     * normalize model text before consumers, including native structured-output parsing, use it.
+     *
      * @param agent the agent instance
      * @param ctx   per-call runtime context (session, user, attributes)
      * @param input model-call input (messages, tools, options, model)

agentscope-core/src/main/java/io/agentscope/core/model/ModelContextWindows.java

@@ -91,6 +91,18 @@ private ModelContextWindows() {}
                     Map.entry("glm-4-flash-250414", 128_000),
                     Map.entry("glm-4-long", 1_000_000));
 
+    public static final Map<String, Integer> MINIMAX =
+            Map.ofEntries(
+                    Map.entry("minimax-m3", 1_000_000),
+                    Map.entry("minimax-m2.7-highspeed", 204_800),
+                    Map.entry("minimax-m2.7", 204_800),
+                    Map.entry("minimax-m2.5-highspeed", 204_800),
+                    Map.entry("minimax-m2.5", 204_800),
+                    Map.entry("minimax-m2.1-highspeed", 204_800),
+                    Map.entry("minimax-m2.1", 204_800),
+                    Map.entry("minimax-m2", 204_800),
+                    Map.entry("m2-her", 65_536));
+
     public static final Map<String, Integer> ANTHROPIC =
             Map.ofEntries(
                     Map.entry("claude-opus-4", 200_000),

agentscope-core/src/main/java/io/agentscope/core/model/ModelProviderSupport.java

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2024-2026 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
+ *
+ *      http://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 io.agentscope.core.model;
+
+/** Shared helpers for model providers. */
+public final class ModelProviderSupport {
+
+    private ModelProviderSupport() {}
+
+    public static <T> T findAssignableComponent(
+            ModelCreationContext context, Class<T> componentType) {
+        for (Object value : context.getComponents().values()) {
+            if (componentType.isInstance(value)) {
+                return componentType.cast(value);
+            }
+        }
+        return null;
+    }
+
+    public static String firstNonBlank(String... values) {
+        if (values == null) {
+            return null;
+        }
+        for (String value : values) {
+            String normalized = trimToNull(value);
+            if (normalized != null) {
+                return normalized;
+            }
+        }
+        return null;
+    }
+
+    public static String trimToNull(String value) {
+        if (value == null) {
+            return null;
+        }
+        String trimmed = value.trim();
+        return trimmed.isEmpty() ? null : trimmed;
+    }
+
+    public static Integer intOption(ModelCreationContext context, String key) {
+        Object value = context.option(key);
+        if (value == null) {
+            return null;
+        }
+        if (value instanceof Number number) {
+            return number.intValue();
+        }
+        throw new IllegalArgumentException(
+                "ModelCreationContext option " + key + " must be a number");
+    }
+
+    public static Boolean booleanOption(ModelCreationContext context, String key) {
+        Object value = context.option(key);
+        if (value == null) {
+            return null;
+        }
+        if (value instanceof Boolean bool) {
+            return bool;
+        }
+        throw new IllegalArgumentException(
+                "ModelCreationContext option " + key + " must be a boolean");
+    }
+
+    public static String stringOption(ModelCreationContext context, String key) {
+        Object value = context.option(key);
+        if (value == null) {
+            return null;
+        }
+        if (value instanceof String text) {
+            return trimToNull(text);
+        }
+        throw new IllegalArgumentException(
+                "ModelCreationContext option " + key + " must be a string");
+    }
+}