v2.0.0-RC3

Please check the documentation for more details.

Features & Enhancements

• Agent result event — a new event is emitted with the final result immediately before agent-end, so streamEvents() consumers can obtain the result directly from the event stream
• Custom events — generic extensible event type for middleware to push application-level notifications (state changes, team updates, etc.) to front-end subscribers without modifying the core event enum
• Hint block events — one-shot event for delivering complete content such as team messages, background tool results, and user interruptions
• Workspace path normalizer — file paths are now automatically normalized to workspace-relative form based on the active filesystem mode, preventing cross-mode prefix collisions
• Tool name on all tool events — tool call delta, end, and result events now carry the tool name directly, so consumers no longer need to cache the name mapping from the start event

Bugfixes & Improvements

• Unified call / stream core — call() and streamEvents() now share a single implementation, ensuring the middleware chain fires consistently on all invocation paths. Legacy standalone call logic has been removed
• Distributed state always fresh — when a state store is configured, agent state and permissions are reloaded from the store at the start of every call, preventing stale cache reads when sessions drift across machines
• Tool result eviction timing — eviction middleware moved to the correct lifecycle phase where tool results are already persisted, fixing a no-op issue in the previous phase
• Simplified file path resolution logic in local filesystem

v2.0.0-RC2

Please check the documentation for more details.

Features & Enhancements

• Qwen 3.7 model support — added support for Qwen 3.7 series models (e.g. qwen3.7-plus)
• Direct subagent messaging — send messages directly to a spawned subagent and receive its response without going through the parent agent's reasoning loop
• Subagent event stream forwarding — child agent intermediate events (text deltas, tool calls, etc.) are now forwarded in real time, each carrying a source path identifying the originating agent
• Event source tracking — all agent events now carry a source field to distinguish main vs. subagent events within the same stream, enabling consumer-side demuxing
• Custom model and prompt for Compaction / Memory — compaction and memory extraction now support dedicated lightweight models and custom prompts, independent of the agent's primary model
• Channel integration — new extension module family for IM platform integration (DingTalk, Feishu/Lark, WeCom, GitHub, GitLab), with a built-in ChatUI for an out-of-the-box conversational interface
• Unified distributed backend — new single-point configuration that consolidates all distributed storage components (state store, base store, sandbox snapshot) into one setup call. Built-in implementations for Redis, OSS, and MySQL
• Project-writable mode — when enabled, agent file writes are routed by path: workspace metadata goes to the workspace directory; everything else (code, configs) lands in the project directory. Designed for code-generation agents
• Runtime permission mode switching — dynamically adjust the permission mode per session at runtime
• Plan Mode improvements — improved plan file persistence and recovery, smoother tool-chain interaction, more robust approval flow
• Skill self-evolution enhancements — refined the propose → curate → promote closed loop, improved skill matching accuracy and cross-session reuse
• HTTP client timeout and retry policy adjustments
• Model resolution logic improvements
• Agent state records more running statuses

Breaking Changes

• Agent fully stateless — agents no longer hold mutable per-session state, a single agent instance can safely serve multiple concurrent sessions
• Unified state store — removed legacy session interfaces; unified on a new AgentStateStore abstraction with built-in in-memory, JSON file, Redis, and MySQL implementations, auto-partitioned by user and session
• Base store package renamed — base store interfaces for RemoteFilesystem moved to a new package; update your import paths accordingly
• Extension module coordinates refactored — several extension Maven coordinates have been reorganized by capability (e.g. agentscope-extensions-session-redis → agentscope-extensions-redis). Update <artifactId> in your POM
• Sandbox implementations extracted — concrete sandbox backends (Docker, Kubernetes, E2B, Daytona, AgentRun) moved from harness core into standalone extension modules. Add the corresponding extension explicitly if you need sandbox support

Bugfixes

• Fixed permission state losing context during cross-session restoration
• Fixed agentscope-all missing 4 sandbox extension modules

v2.0.0-RC1

AgentScope Java 2.0.0-RC1

AgentScope Java steps up from a "build an agent" toolkit toward a complete platform for running agents in production.

2.0 aims to preserve compatibility with 1.x where possible so that most users can upgrade smoothly — see the Migration Guide below.

Full docs: docs/v2/en, docs/v2/zh · Full changelog: change-log.md

Highlights

🧰 Harness engineering — the harness scaffolding for long-running tasks, layered on top of the ReAct core:

• Self-evolving Markdown skill repository under workspace/skills/, shared across sessions
• Layered memory: in-context conversation / MEMORY.md / append-only fact log, with auto-compaction
• Sub-agents declared in Markdown, spawned sync or in background; completions pushed back via system-reminder
• Plan Mode + persistent workspace/plans/ to decouple intent from action
• Workspace as the single on-disk source of persona, knowledge, skills, sub-agent specs

🏢 Enterprise-grade distributed deployment — stateless horizontal scaling out of the box:

• session / user / agent / org multi-tenant isolation via AbstractFilesystem
• Sandbox execution (local / Docker / remote AgentRun) with snapshot & resume
• Three-state PermissionEngine (allow / approve / deny) with HITL as a first-class concern
• Session abstraction (InMemory / JsonSession / MySQL / Redis) for zero-downtime rolling deploys

⚙️ Foundation framework upgrade — leaner, more orthogonal core:

• agent.streamEvents() → Flux<AgentEvent> covering 28 typed events (model calls, deltas, tool execution, HITL)
• Unified ContentBlock message model with role-strict construction
• Five-stage Middleware (onAgent / onReasoning / onActing / onModelCall / onSystemPrompt) replaces v1 hooks
• ModelRegistry resolves "provider:model" strings; Builder gains .maxRetries(int) / .fallbackModel(...) for auto-retry

Quick start

<dependency>
  <groupId>io.agentscope</groupId>
  <artifactId>agentscope-harness</artifactId>
  <version>2.0.0-RC1</version>
</dependency>

var agent = HarnessAgent.builder()
    .name("coder")
    .model("qwen-max")
    .workspace(Paths.get(".agentscope/workspace"))
    .filesystem(new DockerFilesystemSpec().isolationScope(IsolationScope.USER))
    .build();

agent.call(msg, RuntimeContext.builder().sessionId("demo").userId("alice").build()).block();

Migration Guide

Required — compile errors or runtime exceptions if you don't migrate

• ReActAgent.Builder.memory(...) / .statePersistence(...) removed → .session(...).sessionKey(...); Session auto save/load on every call()
• io.agentscope.core.session.SessionManager removed → configure Session + SessionKey on the builder
• io.agentscope.core.pipeline.* (Pipeline, SequentialPipeline, FanoutPipeline, MsgHub) removed → middleware + sub-agents + event stream
• io.agentscope.core.model.tts.* (14 files) removed → integrate upstream TTS SDK directly
• state package restructure: AgentMetaState → AgentState; StateModule / StatePersistence removed; ToolkitState moved to session.legacy
• Msg content is now validated against role at construction (USER allows only Text/Data/Image/Audio/Video; SYSTEM only Text) → prefer UserMessage / AssistantMessage / SystemMessage / ToolResultMessage

Recommended — @Deprecated(forRemoval = true), removed in the next minor

• SkillBox → AgentSkillRepository via Builder.skillRepository(...)
• Entire io.agentscope.core.hook package → Middleware (old hooks bridged via LegacyHookDispatcher)
• Memory and all implementations → AgentState.getContext() + Session
• All Flux<Event> stream(...) overloads → streamEvents() returning Flux<AgentEvent> (aligns with Python 2.0's reply_stream())
• RAG (Knowledge / KnowledgeRetrievalTools / RAGMode) and long-term memory modules deprecated — being rewritten on the v2 architecture; don't depend on them in new code
• tool.coding.* / tool.file.* deprecated (no workspace/permission isolation) → use the agentscope-harness equivalents

Links

• Quickstart · Harness · Full Changelog
• Issues · Discussions

v1.1.0-RC2

v1.1.0-RC2

Features

• Harness subagents — HarnessAgent can delegate work to ephemeral child agents via agent_spawn / agent_send. Declarations come from SubagentDeclaration, workspace/subagents/*.md, built-in general-purpose, or custom factories; remote HTTP subagents are supported.
• Async subagents — Set timeout_seconds=0 to run subagent tasks in the background. Task state is persisted in the workspace and managed with task_output, task_list, and task_cancel.
• Subagent streaming — When the parent uses stream(), synchronous local subagents forward reasoning, tool, and result events into the parent Flux<Event> with EventSource metadata. Nested subagents are supported; call() keeps the previous blocking behavior.
• Tool strict mode — Tools can be configured with strict JSON-schema validation for more reliable model tool calls.
• MCP protocol versions — McpClientBuilder exposes protocolVersions for explicit MCP protocol negotiation.

Bug Fixes

• DashScope multimodal tool results — Multimodal content parts in tool results are preserved instead of being dropped.
• OpenAI rate-limit retries — Non-standard rate-limit error payloads are parsed correctly so automatic retries can trigger.
• Subagent runtime context — RuntimeContext (e.g. userId) propagates from parent tool calls into child agents for consistent isolation.
• Glob matching — File globs match both workspace-root files and nested paths (e.g. *.md, *.log.jsonl).
• Skill state APIs — Added methods to set skill states programmatically.

Other

• Improved model tool-call handling; E2E support for Qwen 3.5 series models; dependency bumps (PostgreSQL, Micronaut, OpenTelemetry semconv, zstd-jni).

v1.1.0-RC1

Build your own OpenClaw-style agent that keeps evolving inside a workspace, while the same stack scales to enterprise, distributed deployments and can run tools and code in a securely isolated execution environment.

Highlights

This release introduces agentscope-harness, a production-oriented layer on top of agentscope-core’s ReActAgent. The single user-facing entry point is HarnessAgent. Harness does not replace the ReAct loop; it injects hooks and a curated toolkit at the right points so agents can answer: what happens on the next turn, the next day, when context explodes, when state is lost, or when work is too heavy for one agent.

What’s new

1. Workspace as source of truth

A structured workspace directory is the canonical place for persona (AGENTS.md), consolidated long-term memory (MEMORY.md), domain knowledge, skills (skills/), subagent specs (subagents/), and per-agent session data (agents/<agentId>/). Hooks such as WorkspaceContextHook inject workspace content into the system prompt each turn; memory hooks write back so the agent evolves with use, not only within a single chat.

2. Pluggable filesystem (AbstractFilesystem)

All file-oriented behavior goes through one abstraction so the same agent logic can target:

• Local disk + shell (default): full file tools and optional shell when the backend supports it.
• Remote / shared storage: durable memory and session data for multi-replica deployments; execute is intentionally not registered by default to reduce remote execution risk.
• Sandbox: isolated file and command execution on the sandbox side, with workspace projection and configurable isolation scope (e.g. session vs user vs global) for multi-tenant patterns.

3. Session persistence

Stable sessionId (and userId for multi-tenant namespaces) drives:

• Serialized runtime snapshots under agents/<agentId>/context/ for cross-process resume.
• JSONL conversation logs under agents/<agentId>/sessions/ for audit and search, alongside compressed model-facing history.

4. Memory and context management

• Two-layer memory: append-only daily notes under memory/, plus background consolidation into MEMORY.md.
• memory_search / memory_get backed by indexed search (e.g. SQLite FTS) so facts stay retrievable without stuffing everything into context.
• Configurable compaction of long threads; context overflow handling with forced compaction and retry where applicable.
• Large tool-result eviction so oversized tool outputs can be spilled to the filesystem and referenced instead of blowing the context window.

5. Subagent orchestration

Declarative subagents (workspace markdown with front matter, programmatic specs, built-in general-purpose, or custom factories). Synchronous delegation for blocking workflows and asynchronous tasks with IDs and polling via task tools, with safeguards against unbounded subagent recursion.

6. Built-in toolkit

Filesystem tools (read_file, write_file, edit_file, grep_files, glob_files, list_files), memory and session search/list/history, and subagent/task management are wired for you; execute appears only when the configured backend supports the intended isolation model.

Who it’s for

• Local / single-user agents (e.g. personal assistants, coding-style workflows): workspace + optional shell, memory, compaction, skills.
• Enterprise data / analytics agents: sandbox execution, durable sandbox state, shared memory across replicas, subagents for long or parallel work.
• Online business agents: remote filesystem, no shell by default, explicit business tools only, shared session and memory across instances.

Getting started

Add the io.agentscope:agentscope-harness dependency, prepare a workspace with at least AGENTS.md, build HarnessAgent with RuntimeContext (sessionId, and userId when you need tenant isolation). See the agentscope-examples/harness-example module (e.g. QuickstartExample) and the harness documentation under docs/zh/harness/ (overview, workspace, memory, filesystem, sandbox, subagent, session, tool, architecture) for full detail.

v1.0.12

This release introduces Long-term Memory capabilities, bolsters MCP integration, and adds built-in execution tracing mechanisms, alongside an important refactoring of skill metadata and crucial stability improvements across the core framework.

🌟 Key Highlights

Bailian Long-Term Memory

AgentScope-Java v1.0.12 introduces robust support for Bailian long-term memory (#1188). This significantly enhances the ability of agents to maintain context, recall historical interactions, and build continuous relationships over extended operational sessions.

Observability & Tracing Enhancements

This release provides developers with deeper insights into agent execution and messaging.

• JSONL Trace Exporter: Introduced a built-in JSONL trace exporter via Hook (#983), allowing developers to easily persist detailed, file-based execution traces for offline debugging and analysis.
• OpenTelemetry Focus: Renamed and aligned official documentation to better highlight Observability & Studio with OpenTelemetry tracing guides (#1186, #1107).

MCP Capabilities & Skill Refactoring

We have expanded the Model Context Protocol (MCP) integrations and overhauled how skills are structured.

• MCP Elicitation & Schemas: Added support for the elicitation feature in MCP (#798) and exposed MCP output schemas directly within tool definitions for tighter ecosystem integration (#1221).
• Map-based Skill Metadata: Executed a major refactoring (refactor(skill)!) to replace fixed skill metadata with a flexible, map-based metadata system, removing legacy template-based constructors in SkillBox (#1275).

🚀 New Features

• Model Integration & Multimodality:

  • Multimodal Message Blocks: Added native support for image and video block parameters within user message content in the core framework (#1193).
  • Model Family Expansion: Added the Qwen3.6 model family to multimodal API endpoint routing (#1179) and implemented a Kimi model check in DashScopeHttpClient (#1314).
  • Gemini Client Support: Added baseUrl builder support for Gemini connections (#1174).

• Core Automation & Execution:

  • Quartz Initial Messages: Supported passing initial input messages in Quartz scheduler workflows (#1227).
  • Modifiable PreCall Events: Updated PreCallEvent handling to be modifiable, aligning it with PreReasoningEvent patterns (#1155).

🛠️ Refactoring & Fixes

• Agent, Tool & Memory Stability:

  • Tool Execution Guardrails: Sanitized tool call arguments JSON on interrupted streams to prevent 400 bad requests (#1148). Prevented presetParameters from being erroneously overridden by tool-call input (#1172). Allowed null values for optional nested object fields (#1170).
  • Agent Logic Refinements: Optimized schema parameter handling for structured outputs (#1312). Ensured assistant messages containing tool_calls always include the content field (#1283). Prevented SubAgent name collisions via deterministic hashing for unsupported characters (#1141). Removed redundant hasPendingToolUse checks in core execution (#1162) and fixed three core agent/tool management bugs (#1161, #1167, #1177).
  • Memory Management: Preserved ToolUseBlock structure during large message compression strategies (#1311). Resolved a list modification detection bug during incremental session updates (#1228).

• Skill Management & Data Stores:

  • Skill Robustness: Ensured thread-safe file uploads in SkillBox utilizing fine-grained path locks (#1109). Fixed an issue where an existing skill prevented others from being saved (#1049). Ignored complex YAML frontmatter to prevent parsing failures (#1043). Supported custom charsets for ZIP extraction (#1276) and validated resource paths before activating skills (#1308).
  • Session & RAG Fixes: Ensured MySQL sessions commit writes properly when auto-commit is disabled (#1091). Added missing payload structures for ElasticsearchStore in RAG setups (#1048).

• Observability, UI & A2A Ecosystem:

  • AG-UI Alignment: Converted SUMMARY events into valid AG-UI messages (#1168). Fixed AG-UI reasoning/tool event handling (#1231) and patched a stream state leak causing duplicate events upon retry (#1300).
  • Telemetry Corrections: Utilized max instead of sum for streaming token usage aggregation to report accurate telemetry (#1098). Handled Map types safely in getChatUsage() post-deserialization (#1118).
  • A2A Comms: Fixed A2A Agent lifecycle events to properly support TTSHooks and reasoning completions (#1150). Hardened host fallback mechanisms and guarded against schema definition conflicts in A2A Servers (#1191).

• Dependencies & Build Systems:

  • Resolved dependency conflicts by downgrading json-schema-validator (v3.0.1 to v2.0.0) (#1241) and added spring-boot-configuration-processor to annotation paths (#1116).
  • Fixed missing imports breaking test suites (#1313).
  • Bumped critical dependencies including Milvus-SDK (v2.6.17), Jedis (v7.4.1), OpenTelemetry BOM (v1.61.0), Google GenAI (v1.45.0), Spring WebFlux (v7.0.7), and Micronaut (v4.10.12).

❤️ New Contributors

• @miniceM made their first contribution in #798
• @park338 made their first contribution in #983
• @superjvjkdf made their first contribution in #1049
• @Xiaozhiyao made their first contribution in #1091
• @mvanhorn made their first contribution in #1118
• @xichaodong made their first contribution in #1162
• @rrrjqy66 made their first contribution in #1174
• @Fruank4 made their first contribution in #1167
• @lynx009 made their first contribution in #1168
• @RuleViz made their first contribution in #1191

Full Changelog: v1.0.11...v1.0.12

v1.0.11

This release focuses on expanding Multi-Agent Orchestration, strengthening Persistent Storage, and introducing Graceful Agent Shutdown mechanisms, alongside crucial stability improvements across the core framework.

🌟 Key Highlights

Graceful Agent Shutdown

AgentScope-Java v1.0.11 implements comprehensive support for graceful agent shutdown (#909). Developers can now safely terminate agent, ensuring that all running tasks, tool executions, and state saving complete reliably without data loss or corrupted lifecycles.

Multi-Agent Patterns & Robust Messaging

AgentScope-Java v1.0.11 introduces advanced patterns and components to facilitate complex multi-agent workflows.

• Multi-Agent Practices: Introduced comprehensive multi-agent pattern practices and documentation to guide developers in building scalable agent networks (#910).
• RocketMQ A2A Component: Added a new RocketMQ component for Agent-to-Agent (A2A) communication, enabling reliable, high-throughput asynchronous messaging between agents (#990).

Persistent Storage & Ecosystem Integration

We have significantly broadened the ecosystem for managing skills and agent sessions across different database architectures and registries.

• Continued Nacos Support: Following the major Nacos registry integration in v1.0.10, we have updated the NacosSkillRepository extension module version (#1080). This ensures continued stability, compatibility, and seamless operations for your dynamic cloud-native agent orchestration.
• MySQL Skill Repository: Introduced MysqlSkillRepository to allow centralized, relational database management of agent skills (#600).
• Redis Session Client: Added a unified Redis session client supporting seamless switching between underlying Redis implementations for distributed session management (#611).

🚀 New Features

• Model, Streaming & Reasoning:

  • Dynamic Structured Output: Added support for stream(List<Msg>, StreamOptions, JsonNode) to enable dynamic structured outputs during streaming responses (#931).
  • Prompt Caching: Introduced cache_control support for OpenAI and DashScope protocols, allowing developers to optimize costs and latency (#985).
  • Reasoning Tokens Tracking: Assigned token consumption values to ChatUsage in ReasoningChunkEvent.accumulated to track usage during model reasoning processes (#935).
  • Reasoning Deserialization: Supported both reasoning_content and reasoning fields for better compatibility with varying model formatter schemas (#1086).

• Tools & Vector DBs:

  • Multimodal Tools: Introduced new video multimodal tools for enhanced media processing capabilities (#921).
  • Milvus & Mem0: Added support to configure database names in Milvus (#978) and resolved self-hosted authentication headers for Mem0 (#1035).
  • Shell Tool Charsets: Added custom charset support for ShellCommandTool to better handle diverse OS environments (#950).

🛠️ Refactoring & Fixes

• Agent & Memory Stability:

  • AutoContext Fixes: Resolved an infinite loop and strategy starvation in AutoContextMemory (#994), and preserved tool_calls/tool_result pairing during large message offloading (#1042).
  • ReAct & Tool Execution: Fixed an issue in ReActAgent to preserve the user chunk callback when using a copied toolkit (#894). Handled tool execution timeouts and errors that previously caused IllegalStateException (#956). Fixed NPE in Toolkit.getTool when the tool name is null (#982).
  • RAG Context: Ensured RAG-retrieved chunks use the USER role and added missing retrieveConfig in Agentic RAG mode (#949).

• OpenAI & Core Infrastructure:

  • Stream Error Handling: Fixed a NullPointerException when OpenAIClient stream calls encounter errors (#800), and handled null statusCode in HttpTransportException to prevent cascading failures (#928).
  • Schema Resolution: Hoisted $defs to the schema root for proper nested object $ref resolution (#1077).
  • HTTP Configuration: Made the core HTTP version configurable for broader environment compatibility (#972).
  • Ollama Streaming: Ensured stable message IDs for Ollama streaming responses (#1008).

• Skill Management & File System:

  • Path & Character Fixes: Removed Windows reserved characters from FileSystemSkillRepository sources (#1031) and fixed MediaUtils path extension parsing (#981).
  • Hidden Files: Core loader now properly ignores hidden files when loading skill resources (#1002).
  • Prompt Optimization: Optimized code execution prompts and added an E2E benchmark (#1056).

• Dependencies & CI:

  • Bumped essential dependencies to their latest stable versions, including Spring Boot (v4.0.4), OpenAI-Java (v4.28.0), OpenTelemetry, Elasticsearch, Milvus-SDK, and MCP-SDK for better security and performance.
  • Improved Windows CI stability (#939) and standardized imports for qualified names (#953).

❤️ New Contributors

• @benym made their first contribution in #611
• @liwenshen2000 made their first contribution in #950
• @hangweizhang made their first contribution in #968
• @lichen782 made their first contribution in #1035
• @zk-drizzle made their first contribution in #990
• @jujn made their first contribution in #994
• @xuhuafeifei made their first contribution in #1011
• @huangxinchuan made their first contribution in #1031
• @MrYang-Jia made their first contribution in #935
• @chensk0601 made their first contribution in #956

Full Changelog: v1.0.10...v1.0.11

v1.0.10

This release focuses on strengthening Skill & Prompt Management with upgraded Nacos integrations, expanding Model & Voice capabilities, and improving the stability of agent execution flows and OpenAI model interactions.

🌟 Key Highlights

Full Integration with Nacos AI Registry (v3.2.0-BETA)

AgentScope-Java v1.0.10 now fully supports the Nacos AI Registry, enabling seamless runtime access to centrally managed Prompts and Skills — empowering dynamic, cloud-native agent orchestration without redeployment.

• Prompt Runtime Binding via NacosPromptListener: Agents can dynamically fetch and render prompts from Nacos Config Center using variable substitution. Supports real-time updates — modify your prompt template in Nacos console, and agents automatically reflect changes on next call.

• Dual Skill Loading Strategies:

  • Offline Mode (FileSystemSkillRepository): Use nacos-cli skill-sync to sync skills locally, then load via file system — ideal for CI/CD or air-gapped environments.
  • Online Mode (NacosSkillRepository): Directly pull or subscribe to skills from Nacos at runtime via AiService, supporting hot-swapping and versioned skill management.

2. Enhanced Agent & Tool Execution

Agent workflows and tool calling mechanisms have been refined for better reliability and control.

• Completions Tool Schema: Added support for tool schema in the completions chat API, bridging the gap for complex tool definitions (#508).
• ReActAgent Improvements: Fixed an issue in ReActAgent to ensure tool calls can properly reach the acting phase for correct error handling (#850), and updated it to explicitly output MAX_ITERATIONS messages when the iteration limit is reached (#839).
• Sorted Hooks: Introduced sorting capabilities for agent hooks, allowing developers to precisely control the execution order of custom lifecycle hooks (#793).

🚀 New Features

• Model & Voice:

  • TTS Support: Added a Text-to-Speech (TTS) voice enum and integrated TTS capabilities into the Werewolf game example (#749).
  • Qwen & Endpoints: Allowed manual endpoint type configuration and added official support for the qwen3.5-plus model (#824).
  • Format Parsing: Updated response parsing to support the new v1.1 format (#854).

• Interaction & Examples:

  • HITL UI Example: Added a new Human-in-the-Loop (HITL) interactive UI example featuring a virtual fitness coach (#832).

🛠️ Refactoring & Fixes

• OpenAI & Core Models:

  • Token Configuration: Fixed an issue where max_tokens and max_completion_tokens were set simultaneously, which caused conflicts in OpenAI requests (#906).
  • Streaming: Fixed an issue where OpenAIChatModel stream responses would fail (#886).
  • Conversation History: Ensured that all messages are correctly included in the conversation history for the OpenAI formatter (#844).

• Skill Management Fixes:

  • Multi-module Projects: Resolved a bug where ClasspathSkillRepository failed to load skills in multi-module Java projects (#837).
  • SkillBox Prompts: Fixed an issue to ensure skillBox prompts are properly merged into system prompts (#895).
  • File System Repositories: Corrected an issue where skill fileSystem base repository sources improperly contained colons (:) (#896).

• Protocol & Infrastructure:

  • MCP Conversion: Fixed Model Context Protocol (MCP) JSON schema conversion to properly preserve $defs and definitions fields (#903).
  • Code Formatting: Standardized code formatting across the repository using the Spotless plugin (#822).
  • Dependencies: Bumped various dependencies including Spring Boot, Jackson, Mockito, and Qdrant to their latest stable versions for improved security and performance.

❤️ New Contributors

• @azhsmesos made their first contribution in #793
• @luoxiner made their first contribution in #850
• @qiacheng7 made their first contribution in #902
• @wandering4 made their first contribution in #886
• @darkwu made their first contribution in #906

Full Changelog: v1.0.9...v1.0.10

v1.0.9

This release marks a milestone with the introduction of Online Training capabilities, empowering agents to learn and adapt continuously. It also significantly enhances the Skill & Tool System with broader compatibility (Spring Boot Fat JAR, Nacos, Git), and improves Streaming & Observability for enterprise-grade deployments.

🌟 Key Highlights

1. Online Training

Introduces foundational support for Online Training , enabling dynamic model fine-tuning at runtime and laying the groundwork for self-evolving agents (#703).

• Documentation: For implementation details, please refer to the Online Training Documentation.

2. Advanced Skill & Tool Integration

We have extensively upgraded the skill and tool ecosystem to support more dynamic and complex deployment scenarios.

• Flexible Skill Loading: Now supports loading skills directly from Spring Boot Fat JARs (#668), Git repositories (#690), and Zip files (#694), greatly simplifying plugin management and distribution.
• Nacos Integration: Added support for dynamically loading ReActAgent system prompts from Nacos, enabling real-time configuration updates without redeployment (#760).
• Tooling Enhancements: Introduced ToolSchemaModule to support parsing of the @ToolParam annotation (#783) and added support for relative paths in built-in file tools (#747).

3. Streaming & Observability

We have optimized the data flow and monitoring capabilities for clearer insights and better user experiences.

• Fanout Streaming: Added full streaming support for FanoutPipeline, enabling real-time feedback in parallel processing scenarios (#664, #700).
• Distributed Tracing: Fixed OpenTelemetry trace context propagation, ensuring complete visibility across subagent calls (#704).

🚀 New Features

• Planning:

  • Human-in-the-Loop (HITL): Added HITL support and changeHook management APIs to the PlanNotebook. Developers can now intervene, review, and modify agent plans during execution for greater control (#687).

• Model & RAG:

  • ID Generation: Auto-generate ChatResponse.id when the underlying LLM does not provide one, ensuring consistency (#721).
  • Dify RAG: Fixed the reranking_model JSON key in Dify RAG retrieval requests (#766).
  • DashScope: Updated to use requiresMultimodalApi for better multimodal support (#670).

• Infrastructure & Storage:

  • MySQL: Added support for hyphens (-) in MySQL database and table names (#706).
  • Elasticsearch: Bumped elasticsearch-java client to version 9.3.0 (#713).

🛠️ Refactoring & Fixes

• Core Stability:

  • Concurrency: Optimized AgentBase lock management to resolve concurrency conflicts (#733) and refactored ToolMethodInvoker to be stateless for better thread safety (#661).
  • Performance: Optimized the response handling of finishSubtask in planning (#673).

• Bug Fixes:

  • Hooks: Fixed the execution order ensuring SkillHook triggers later than StructuredOutputHook (#722).
  • Async Tools: Properly handled ToolSuspendException for synchronous throws within asynchronous tool branches (#791).
  • Generics: Fixed an issue where generic type information was lost in ToolMethodInvoker (#730).

❤️ New Contributors

• @xseruer made their first contribution in #664
• @lifl00001 made their first contribution in #706
• @aihai made their first contribution in #735
• @Willam2004 made their first contribution in #756
• @Sunrisea made their first contribution in #760

Full Changelog: v1.0.8...v1.0.9

v1.0.8

This release introduces multimodal capabilities with Qwen TTS integration, significantly expands the RAG ecosystem with PostgreSQL and Elasticsearch support, and empowers agents with robust Code Execution capabilities.

🌟 Key Highlights

1. Qwen TTS Integration

We have officially expanded the multimodal capabilities of the framework by integrating Qwen (Tongyi Qianwen) Text-to-Speech.

• Voice Generation: Agents can now generate high-quality speech output using Qwen's TTS models, enabling richer, voice-based interactions for your applications (#541).

2. Expanded RAG & Vector Storage

We have greatly broadened the storage options for Retrieval-Augmented Generation (RAG), allowing for more flexible and production-ready deployments.

• PostgreSQL & pgvector: Added native support for using PostgreSQL with pgvector as a vector store (#525).
• Elasticsearch: Introduced Elasticsearch as a backend for RAG storage, offering powerful full-text search and vector capabilities (#503).
• Documentation: Added documentation for the Tika reader to assist with diverse document parsing (#654).

3. Secure Code Execution (SkillBox)

The Skill system has been empowered with secure code execution capabilities, allowing agents to generate and run code dynamically.

• Code Execution: Added support for executing code within the SkillBox environment (#614).
• Developer Experience: Refactored the code execution API with a Builder pattern for easier configuration and usage (#646), and simplified the skill lifecycle (#615).

🚀 New Features

• Model & AG-UI:

  • Thinking Mode: Added support for visualizing "Thinking mode" outputs (e.g., from reasoning models) in AG-UI (#574).
  • DashScope: Added support for the response_format parameter (#564).
  • Custom Events: AG-UI now supports custom events for more flexible frontend interactions (#605).
  • Spring Boot: Improved auto-configuration for AG-UI (#653).

• Agent Core & ReAct:

  • Hooks: Added summary phase hook support for ReActAgent (#577).
  • Planning: Enforced strict maxSubtasks limits in PlanNotebook and ReActAgent to prevent infinite loops (#645, #656).

• Memory:

  • Mem0: Added support for metadata recording and filtering in Mem0 storage (#563).
  • Structured Output: Optimized structured output to preserve ThinkingBlock content after memory compression (#655).

🛠️ Refactoring & Fixes

• Concurrency & Stability:

  • Shell Tool: Fixed a pipe buffer deadlock issue in ShellCommandTool (#619).
  • Tool Execution: Used mergeSequential to strictly preserve the order of parallel tool calls (#652).
  • Non-blocking: Standardized non-blocking behavior for all ChatModelBase implementations (#642).

• Compatibility:

  • JDK 25: Excluded lombok dependency to ensure forward compatibility with JDK 25 (#604).
  • WebFlux: Fixed Jakarta Servlet compatibility issues in A2A communication (#587).

• Bug Fixes:

  • ReAct: Fixed logic ensuring agents only execute tools that lack results when resuming (#650).
  • Ollama: Handled edge cases where tool calls have empty parameters (#572).
  • Observability: Fixed callTool pipeline observability and tracing (#576).

❤️ New Contributors

• @fangxiu-wf made their first contribution in #576
• @xingmengxian made their first contribution in #560
• @B18150228NJUPT made their first contribution in #587
• @ShenJunkun made their first contribution in #503
• @feelshana made their first contribution in #606
• @mengnankkkk made their first contribution in #591
• @Hipple made their first contribution in #652
• @tcsp made their first contribution in #645

Full Changelog: v1.0.7...v1.0.8