agentscope-ai/agentscope

AgentScope is a Python framework for building, orchestrating, and deploying autonomous AI agents with support for multi-modal inputs, real-time voice interactions, and long-term memory. It provides a comprehensive service layer for managing agent lifecycles, sessions, and knowledge bases via REST APIs, while enabling complex workflows through pipelines, standard operating procedures, and team-based collaboration. The system integrates with a wide range of LLM providers and vector databases, offering extensible middleware for tracing, budgeting, and RAG, alongside sandboxed execution environments for secure tool use.

31 changes.

This period centered on the AgentScope 2.0 release, executing a comprehensive architectural rewrite of the core library to enforce Python 3.11 compatibility and modernize the codebase. The work involved replacing legacy modules with unified, Pydantic-based interfaces for agents, models, messages, and tools, while removing deprecated features and legacy examples. Concurrently, new capabilities such as A2A protocol support, RAG, TTS, and middleware-based memory were introduced to establish the new framework's foundation.

60 changes.

This period focused on establishing a production-ready application layer with FastAPI, REST APIs, and robust storage and messaging backends. It simultaneously expanded the framework's capabilities by introducing a comprehensive suite of LLM, embedding, and TTS integrations, alongside new modules for real-time voice, long-term memory, and structured agent workflows.

Users can now synthesize speech using DashScope's TTS capabilities, including the standard DashScope TTS model (e.g., qwen3-tts-flash) and the CosyVoice models (e.g., cosyvoice-v3-flash, cosyvoice-v3-plus). The update introduces a new Realtime TTS model that supports streaming input via WebSocket, allowing incremental text pushing for low-latency synthesis. All models support configurable voices, streaming output, and are exposed through the standard TTS interface.

_src/agentscope/tts/\dashscope · high confidence

This change introduces a new \DeepSeekChatModel\ implementation within the Agentscope framework, enabling users to interact with DeepSeek's LLM APIs. The module includes a dedicated credential class, a chat model wrapper that supports streaming, configurable parameters (such as \thinking\_enable\ and \reasoning\_effort\), and a specific formatter for message handling. Additionally, model configuration files are added for \deepseek-chat\, \deepseek-reasoner\, \deepseek-v4-flash\, and \deepseek-v4-pro\, defining their capabilities, context sizes, and deprecation statuses.

_src/agentscope/model/\deepseek · high confidence

Users can now generate text embeddings using locally-hosted Ollama models (such as nomic-embed-text or mxbai-embed-large) via the new OllamaEmbeddingModel class. This feature integrates with the existing embedding framework, supporting configurable model dimensions, context size, batching, retries, and optional embedding caching.

_src/agentscope/embedding/\ollama · high confidence

Users can now generate speech from text using OpenAI's Audio Speech API. This change introduces the OpenAI TTS model implementation, supporting models tts-1, tts-1-hd, and gpt-4o-mini-tts with configurable voices (e.g., alloy, echo, nova) and output formats (mp3, opus, aac, flac, wav, pcm). It also adds model-specific configuration files to manage available voices and hide unsupported parameters like 'instructions' for models that do not support them.

_src/agentscope/tts/\openai · high confidence

The OpenAI embedding module now includes the \OpenAIEmbeddingModel\ class, enabling integration with OpenAI's \text-embedding-3-small\ and \text-embedding-3-large\ models. This update introduces a \pass\_dimensions\ parameter (defaulting to \True\) to control whether the output vector dimensions are sent to the API, allowing compatibility with providers that may not support this parameter. Configuration files for both models are added, specifying their supported dimension options and context sizes.

_src/agentscope/embedding/\openai · high confidence

Users can now integrate with xAI models (such as grok-3 and grok-3-mini) using the official xai\_sdk. This new XAIChatModel implementation supports native xAI-specific features including server-side agentic tools (web search, X search, code execution) and configurable reasoning effort levels (low, medium, high) for extended thinking. The model also allows passing extra client arguments via client\_kwargs and handles gRPC-based communication with built-in retry logic.

_src/agentscope/model/\xai · high confidence

A new \console\ module has been added to provide a lightweight, interactive terminal interface for testing and debugging agents without writing custom UI code. It includes a \launch\_console\ function that starts an interactive chat loop bound to a single agent, handling user input from stdin, rendering streamed agent events via a \ConsoleRenderer\, and managing human-in-the-loop tool call confirmations. The renderer supports three verbosity levels (\quiet\, \default\, \debug\) to control the detail of output, and the console loop supports Ctrl+C interruption to cancel ongoing replies.

src/agentscope/console · high confidence

This release introduces AgentScope 2.0, shifting the minimum Python version requirement from 3.10 to 3.11. The project documentation has been restructured with a new \CONTRIBUTING.md\ guide that enforces responsible AI-assisted coding practices and atomic pull requests, while the \README\ files have been updated to reflect the new version, updated installation instructions (preferring \uv\), and a new news section highlighting features like Realtime voice agents, A2A protocol support, and Pipeline execution. The legacy \setup.py\ has been removed in favor of modern packaging standards.

(repo-wide) · high confidence

Added two new scripts, \scripts/claim\_intent.py\ and \scripts/issue\_triage.py\, to automate GitHub issue handling. \issue\_triage.py\ uses an AgentScope agent to first classify incoming issues as bug reports and then verify the validity of bug claims against the local codebase, outputting a structured verdict. \scripts/claim\_intent.py\ classifies issue comments to determine if a user is volunteering to work on an issue, enabling automated assignment. Both scripts read input from files to prevent shell injection and use structured outputs for reliable integration.

scripts · high confidence

This change introduces a new, fully functional web-based user interface for AgentScope, located in the \examples/web\_ui\ directory. The UI is built with a modern React and TypeScript stack, utilizing Vite for the frontend build, Tailwind CSS for styling, and shadcn/ui for component primitives. It features a dedicated backend server (Express) to handle API requests, with the frontend proxying API calls to the backend during development. The interface includes a dark-mode toggle that respects the user's system preferences and provides a scaffold for interacting with the AgentScope application.

_examples/web\ui · high confidence

A new middleware layer has been added to the application to translate internal AgentScope events into the AGUI protocol format. This change introduces a base protocol middleware that intercepts Server-Sent Events (SSE) streams, deserializes the internal event payloads, and converts them into AGUI-specific events (such as run start/finish, text blocks, tool calls, and reasoning steps) before sending them to the client. This enables clients using the AGUI protocol to consume the agent's output stream directly without needing to implement their own event translation logic.

_src/agentscope/app/middleware/\protocol · high confidence

The application now includes a dedicated service layer under \src/agentscope/app/\_service\ that provides the core backend capabilities for the AgentScope app. This new module introduces a \ChatService\ to manage agent execution and session persistence, a \ChannelService\ for managing platform channel lifecycles, and a \ResourceAccessService\ to handle cross-owner resource visibility and permissions. It also adds support for interactive credential binding via \CredentialBindingService\, background indexing management through \IndexSweeper\ and \IndexTaskConsumer\, and secure file access using signed download tokens. Additionally, the service layer exposes model and embedding model construction, workspace status tracking, and structured error classification to ensure consistent and user-friendly error reporting.

_src/agentscope/app/\service · high confidence

The \src/agentscope/tts\ package is introduced, providing a unified Text-to-Speech interface for AgentScope. This new module exposes a base class (\TTSModelBase\) and concrete implementations for three providers: Google Gemini (using the \generateContent\ API with audio output), DashScope (including CosyVoice and realtime streaming models), and OpenAI. The package includes a model card system (\TTSModelCard\) that loads provider-specific configurations from YAML files (e.g., \gemini-2.5-flash-preview-tts.yaml\) to define available voices and parameters, and standard response structures (\TTSResponse\, \TTSUsage\) for handling synthesized audio chunks and usage metadata.

src/agentscope/tts · high confidence

Users can now interact with Alibaba Cloud's DashScope models (such as qwen-plus) through a new DashScopeChatModel implementation that leverages the OpenAI Python SDK against DashScope's OpenAI-compatible endpoint. This addition supports streaming responses, multimodal inputs (images and video), and advanced configuration options including parallel tool calls, voice output for omni-style models, and configurable client parameters. The model also includes built-in retry logic for connection and rate-limit errors, context compression for large conversations, and a dedicated formatter to handle message structures specific to the DashScope API.

_src/agentscope/model/\dashscope · high confidence

Users can now connect AgentScope agents to DingTalk via a new channel adapter that supports interactive credential binding (e.g., QR code/consent flows) and provides platform-specific agent tools for discovery and messaging. The channel exposes tools to list observed conversations and enterprise users, send Markdown text, images, and files to specified DingTalk targets, and access DingTalk Wiki workspaces and nodes. It also supports tool-approval cards for user confirmation and streams replies using DingTalk AI cards when configured, with long-lived connections managed separately from run execution to allow scaling across nodes.

src/agentscope/app/channel · high confidence

The AgentScope application now provides a new \src/agentscope/app\ module that exposes a \create\_app\ factory to build a FastAPI application. This service integrates core components including a decoupled message bus, workspace management, and knowledge base handling, while supporting extensibility through custom agent classes, sub-agent templates, and additional middlewares or tools. The entry point manages the full application lifespan, wiring up background task management, session scheduling, and channel workers, and exposes a health check endpoint for operational monitoring.

src/agentscope/app · high confidence

The application now exposes a comprehensive set of HTTP endpoints via a new FastAPI router structure under \src/agentscope/app/\_router\. This change introduces dedicated routers for managing agents, channels, chat sessions, credentials, embedding and chat models, health status, hubs (MCP and skills), knowledge bases, scheduled tasks, sessions, skills, and workspaces. Users can now interact with the AgentScope service through a standardized REST API, enabling programmatic creation and management of agents, secure credential binding, knowledge base operations with chunking and embedding support, and real-time chat interactions via fire-and-forget triggers and SSE streaming.

_src/agentscope/app/\router · high confidence

Added a new GeminiChatModel implementation for the Google Gemini API, including credential handling and parameter configuration. The model automatically sanitizes JSON schemas sent to Gemini by stripping unsupported constructs such as $schema, additionalProperties, const, and nullable type arrays, ensuring compatibility with the Gemini API's strict schema requirements.

_src/agentscope/model/\gemini · high confidence

The \src/agentscope/app/hub\ module now provides a unified hub system that allows users to browse and install Model Context Protocol (MCP) servers and skills from external registries. This change introduces \GitHubMCPHub\ to connect to the GitHub MCP Registry and \ClawSkillHub\ to connect to the ClawHub registry. Users can now discover available resources via paginated catalogs, view detailed card information (including descriptions, versions, and input schemas for MCPs), and install these resources directly into their agent workspace.

src/agentscope/app/hub · high confidence

Added the MoonshotChatModel class to support the Moonshot AI API (formerly Kimi). This new model implementation allows users to interact with Moonshot models (such as kimi-k2.6 and kimi-k3) using an OpenAI-compatible client, featuring support for streaming, configurable reasoning effort, and structured output handling with compression fallbacks.

_src/agentscope/model/\moonshot · high confidence

Added a new Ollama chat model implementation that allows users to connect to local or remote Ollama instances. The integration supports configurable parameters such as max tokens, temperature, and a new 'thinking' mode for models like qwen3 and deepseek-r1. It also includes retry logic for transient network errors and allows passing extra keyword arguments to the underlying HTTP client.

_src/agentscope/model/\_anthropic, src/agentscope/model/\ollama · high confidence

Added a new \OpenAIResponseModel\ implementation that integrates with the OpenAI Responses API, enabling support for advanced features such as structured reasoning (thinking) with configurable effort levels, audio output handling, and prompt cache creation/input token tracking. This model also includes specific formatters for the Responses API format, deterministic stream closing, and retry logic tailored to the API's error types.

_src/agentscope/model/\_openai\response · high confidence

The new OpenAIChatModel implementation adds support for reasoning models (e.g., o3, o4-mini) via \thinking\_enable\ and \reasoning\_effort\ parameters, enables audio output for omni-style models through the \voice\ parameter, and handles structured output with fallback logic. It also includes configuration options for client kwargs, extra body fields, and integrates with the existing formatter and credential systems.

_src/agentscope/model/\_openai\chat · high confidence

The AgentScope platform now includes a Retrieval-Augmented Generation (RAG) module, enabling users to ingest, index, and search documents using vector databases. This update adds support for parsing various file formats, including PDF, Word, Excel, PowerPoint, images, and text, which are processed into sections and chunks for embedding. Users can now leverage multiple vector store backends such as Elasticsearch, Milvus Lite, Qdrant, and MongoDB to manage knowledge bases, allowing for structured document retrieval and citation within agentic workflows.

src/agentscope/rag · high confidence

This change introduces the \agentscope.realtime\ module, providing a new capability for building bidirectional voice agents with real-time audio streaming. The module includes a \RealtimeAgent\ (referenced in the package docstring) that orchestrates sessions using provider-specific adapters for OpenAI (\OpenAIRealtimeModel\), DashScope (\DashScopeRealtimeModel\, \DashScopeAudioRealtimeModel\), Gemini (\GeminiRealtimeModel\), and xAI (\XAIRealtimeModel\). It defines a unified event system (\\_events.py\) for audio and transcript deltas, a transport layer (\\_transport\) for handling audio frames and control signals, and a VAD system (\\_vad\) for turn-taking. Model capabilities and parameters are managed via YAML-based model cards (\\_model\_card.py\), allowing users to configure voice, turn detection, and other provider-specific settings.

src/agentscope/realtime · high confidence

A new RealtimeAgent class is introduced in the \_realtime module to handle continuous, bidirectional voice conversations, distinct from the standard request/reply Agent. This component manages the lifecycle of a realtime model session and integrates with audio transports, allowing clients to drop and reconnect without losing the model state. It includes a TurnAggregator to clean up speech transcripts by merging split sentences and filtering backchannels, and exposes TurnMetrics to track per-turn latency (endpointing, backend TTFB, transport delay, and end-to-end latency).

_src/agentscope/agent/\realtime · high confidence

A new \sop\ package has been added to AgentScope, providing a framework for defining and executing fixed sequences of milestones. This module introduces \SOP\ definitions composed of \SOPStep\ objects (each containing an executor and a verifier), an \SOPEngine\ to orchestrate the step-by-step execution and handle resumption from parked states, and \SOPRunState\ classes to persist the progress and verdicts of each run. Users can now structure complex agent interactions into reliable, verifiable workflows with built-in support for retry limits and state recovery.

src/agentscope/sop · high confidence

The application now supports recurring scheduled tasks via a new SchedulerManager and a set of agent-facing tools (ScheduleCreate, ScheduleDelete, ScheduleList, ScheduleView). Agents can define cron expressions, timezones, and stateful or stateless execution modes; schedules are persisted to storage and managed by a single node in a deployment to avoid duplicate firing. When a schedule triggers, the agent is notified in a new session (or the same session if stateful) via the message bus, allowing automated, time-based workflows without manual user intervention.

_src/agentscope/app/\_manager/\scheduler · high confidence

The application now includes a new \message\_bus\ module that provides a structured, live transport layer for cross-session messaging, decoupled from persistent storage. This module exposes an abstract \MessageBus\ interface supporting three consumption modes: drain queues (single-consumer, ack-on-read), replay logs (multi-consumer, append-only), and transient broadcast (pub/sub). It ships with two concrete implementations: \InMemoryMessageBus\ for single-process development and testing, and \RedisMessageBus\ for production distributed deployments, which uses Redis Streams for queues/logs and Pub/Sub for broadcasts. Additionally, a centralized \MessageBusKeys\ registry defines standard key conventions for session events, inboxes, and projections, ensuring consistent naming across the application.

_src/agentscope/app/message\bus · high confidence

AgentScope now supports an extensible middleware architecture that allows intercepting and transforming the agent lifecycle at seven key points (reply, reasoning, acting, permission checks, model calls, context compression, and system prompts). This release ships with several built-in middleware implementations: ReplyBudgetControlMiddleware for enforcing weighted token budgets per reply, RAGMiddleware for knowledge-base search in both agentic and static injection modes with LLM reranking, long-term memory middlewares (AgenticMemory, Mem0, ReMe), TracingMiddleware for OpenTelemetry-based observability, and TTSMiddleware for streaming or non-realtime text-to-speech synthesis. The base MiddlewareBase class provides the hook interface and runtime detection, enabling users to compose custom logic into the agent pipeline.

src/agentscope/middleware · high confidence

Added a new set of built-in tools (TeamCreate, AgentCreate, AgentInvite, TeamSay, TeamDelete) that enable agents to form and manage teams. Leaders can create teams, spawn new worker agents, or borrow existing user-owned agents into the team. Team members communicate via TeamSay, and the leader can dissolve the entire team with TeamDelete. Tool visibility is determined by the session's team role (leader vs. worker) rather than the agent's source, allowing invited agents to participate correctly.

_src/agentscope/app/\tool · high confidence

The \src/agentscope/skill\ module now provides the core classes for discovering and loading agent skills from local directories. This includes a \Skill\ data class to represent skill metadata (name, description, directory, markdown content, and update time) and a \LocalSkillLoader\ that scans a specified directory for \SKILL.md\ files. The loader supports optional subdirectory scanning, caches loaded skills based on file modification times, and parses frontmatter metadata to expose skill details to the agent.

src/agentscope/skill · high confidence

The example directory now demonstrates a new \Mem0Middleware\ component that integrates the mem0 library directly into the AgentScope agent lifecycle. This middleware automatically injects retrieved memory context into agent conversations and persists new facts after each turn, supporting both open-source (self-hosted Qdrant) and hosted mem0 Platform backends. The previous \Mem0LongTermMemory\ class and its associated standalone examples have been removed in favor of this middleware-based approach, which allows for seamless cross-session memory retention with minimal configuration.

_examples/long\_term\memory/mem0 · high confidence

The builtin tool module has been restructured with a new backend abstraction (BackendBase) that allows tools to operate identically across local, Docker, and E2B workspaces. New tools include AskUser for collecting user input via multiple-choice questions, PowerShell for executing commands on Windows workspaces, and ResetTools for dynamically managing tool groups. Existing tools like Bash, Read, Write, Edit, Glob, and Grep have been updated to use the new backend and include improved permission checks, output bounding, and Windows compatibility.

_src/agentscope/tool/\builtin · high confidence

A new credential module has been added to centralize and standardize how API keys and connection settings are stored and validated. It provides typed credential classes for Anthropic, DashScope, DeepSeek, Gemini, Moonshot, Ollama, OpenAI, Volcengine, and xAI, each exposing the specific configuration fields (such as API keys, base URLs, and organization IDs) required by their respective models. A central CredentialFactory handles the registration and deserialization of these credentials, allowing the application to dynamically load and validate provider configurations from storage.

src/agentscope/credential · high confidence

The \src/agentscope/event\ module has been added to provide a comprehensive, structured event system for tracking agent activities. This introduces a hierarchy of Pydantic-based event classes (exported via \\_\init\\_.py\) covering the full lifecycle of agent replies, including start/end events, model call metrics (input/output/cache tokens), and granular streaming blocks for text, data, thinking, and tool calls. It also includes events for user interactions (confirmations, interruptions, external execution) and custom events, enabling detailed observability and real-time monitoring of agent behavior.

src/agentscope/event · high confidence

The application now includes a new workspace manager subsystem that provides a consistent interface for provisioning and managing isolated execution environments. This change introduces a base class and a set of concrete managers supporting multiple backends: local filesystem, Docker, E2B, Kubernetes, Daytona, Apple Container, and Bubblewrap. Users can now select their preferred isolation backend via configuration, benefiting from features like TTL-based idle eviction, background resource sweeping, and deterministic workspace reattachment across process restarts.

_src/agentscope/app/workspace\manager · high confidence

This change establishes the formal request and response contracts for the AgentScope application router by adding a new schema package. It defines Pydantic models for all core service domains, including agents (with a new v2 JSON Schema endpoint for frontend form rendering), sessions (supporting team details, status tracking, and interrupt handling), knowledge bases (with chunking and document lifecycle views), channels (for interactive credential binding and routing), credentials, hubs (MCP and skill installation), workspaces (directory listings and tool info), and model/TTS listing. These schemas serve as the single source of truth for the API surface, ensuring consistent validation and structured responses across the service.

_src/agentscope/app/\_router/\schema · high confidence

The new \src/agentscope/state\ module introduces core state management capabilities for agents, including the \AgentState\ class which manages tool contexts with a file read cache (supporting LRU eviction and size limits), task contexts, and reply contexts. It also adds \A2AAgentState\ for agent-to-agent communication session tracking and a \Task\ model for defining and tracking task lifecycles (pending, in\_progress, completed) with metadata and dependency blocking.

src/agentscope/state · high confidence

The examples/a2a directory now includes a complete client-server demonstration of the A2A 1.0 protocol. The server.py script exposes an AgentScope agent as an A2A 1.0 server using JSON-RPC/SSE, while client.py connects to it via the new A2AAgent class, allowing users to chat with the remote agent through the standard launch\_console interface. This example illustrates how to bridge AgentScope's local agent model with the A2A protocol for remote execution.

examples/a2a · high confidence

This change introduces a new example application (\examples/agent\_service\) that demonstrates a FastAPI-based, multi-tenant, and multi-session agent service. The example includes a companion Web UI and is configured to use Redis for storage and an in-memory Qdrant instance for vector search. It showcases advanced features such as custom subagent templates (e.g., read-only 'explorer' agents), long-term memory via middleware, integration with MCP hubs (GitHub, Claw), skill hubs, and support for multiple communication channels including DingTalk, Discord, and Feishu. The service also includes a permission system and supports schedule tasks.

_examples/agent\service · high confidence

Added new embedding model providers for Alibaba Cloud DashScope and Google Gemini. The DashScope implementation supports both text-only models (text-embedding-v3, text-embedding-v4) and multimodal models (qwen\-vl-embedding, multimodal-embedding-\, tongyi-embedding-vision-\*) with content-aware batching for images and videos. The Gemini implementation supports text-only (gemini-embedding-001) and multimodal (gemini-embedding-2) models, with the latter handling images, videos, audio, and PDFs. Both implementations include model-specific configuration files defining input types, context sizes, and supported dimensions.

_src/agentscope/embedding/\_dashscope, src/agentscope/embedding/\gemini · high confidence

Added a new example in the pipeline module that demonstrates the \GoalPipeline\ class. This example shows how to configure two agents—an Executor and a Verifier—sharing a local workspace to iteratively complete a task until the Verifier confirms the goal is met, including support for resuming interrupted runs.

examples/pipeline · high confidence

The RAG indexing pipeline now supports parsing Microsoft Word (.docx), Excel (.xlsx/.xls), and PowerPoint (.pptx) files. WordParser extracts paragraphs, tables, and embedded images while preserving blank lines and handling merged cells. ExcelParser renders sheet data as Markdown or JSON and can include embedded images. PPTParser walks slides to extract text, tables, and images, correctly reading text inside grouped shapes. All parsers output structured Section objects for downstream chunking.

_src/agentscope/rag/\parser · high confidence

Added a runnable demo (\reme\_demo.py\) and documentation for the new \ReMeMiddleware\, which integrates the embedded ReMe memory toolkit directly into an AgentScope agent. The example demonstrates how to configure the middleware for cross-session memory persistence using a shared workspace, showing both automatic background retrieval (static control) and explicit agent-driven search (agent control) modes, as well as how to inject custom chat and embedding models to enable semantic vector search.

_examples/long\_term\memory/reme · high confidence

The examples/tui directory now includes a standalone Textual terminal UI application (main.py) and comprehensive documentation (README.md). This example demonstrates a rich textual chat interface featuring keyboard-driven Human-in-the-Loop (HITL) approvals, AskUser forms, and tool execution confirmation. It also introduces a new launch\_realtime\_ui function specifically designed for voice sessions with RealtimeAgents, handling continuous audio streams and dual-side transcripts alongside standard text interactions.

examples/tui · high confidence

Added a new example demonstrating the \AgenticMemoryMiddleware\, which enables long-term memory persistence via human-readable Markdown files without requiring a vector database. The demo (\main.py\) shows an agent persisting user profile information to disk in the first turn and recalling it in a subsequent turn, illustrating how memory is scoped to a workspace directory and indexed via a \MEMORY.md\ file.

_examples/long\_term\_memory/agentic\memory · high confidence

The RAG indexing pipeline now includes a new chunking module that splits text into configurable chunks using an approximate token-counting strategy (UTF-8 byte length divided by 4), eliminating the need for external tokenizer libraries. Users can configure the maximum chunk size (default 512) and overlap (default 50) via a Pydantic-driven schema, and the chunker ensures that multimodal data blocks are passed through unchanged while preserving section boundaries and metadata.

_src/agentscope/rag/\chunker · high confidence

The formatter module now includes dedicated formatters for Moonshot AI, xAI, Volcengine Ark, and the OpenAI Responses API. The Moonshot formatter handles local file downloads and base64 encoding for images, while preserving reasoning content for multi-turn conversations. The xAI formatter converts messages into protobuf objects for the xai\_sdk client. The Volcengine formatter supports image and video inputs. The OpenAI Responses formatter adapts content blocks to the Responses API schema (e.g., input\_image, input\_file) and explicitly skips unsupported audio inputs. Additionally, the legacy TruncatedFormatterBase has been removed, and existing formatters like Anthropic, DashScope, and DeepSeek have been refactored to use the new FormatterBase, improving consistency and block handling.

src/agentscope/formatter · high confidence

AgentScope now includes a new terminal-based user interface (TUI) built on the Textual framework, accessible via the \agentscope\[tui\]\ extra. This feature introduces a rich textual chat interface with keyboard-first controls, including a composer for sending messages (Enter to send, Shift+Enter for newlines) and the ability to interrupt running replies with Ctrl+C. It also supports human-in-the-loop interactions, allowing users to respond to tool calls and 'AskUser' prompts directly within the terminal. The UI handles streaming responses, displaying thinking blocks and multimodal attachments, and provides standalone launch functions (\launch\_tui\, \launch\_realtime\_ui\) for interactive sessions.

src/agentscope/tui · high confidence

The \examples/rag\ directory now includes two walk-through scripts (\index\_and\_search.py\ and \integrate\_with\_agent.py\) that demonstrate how to wire the RAG module components (parser, chunker, embedding, vector store, and \KnowledgeBase\) without the FastAPI service. These examples support swapping the default in-memory Qdrant store for Milvus Lite, MongoDB, or Elasticsearch by installing the corresponding optional extras (\vdb-milvus\, \vdb-mongodb\, \vdb-elasticsearch\). The \integrate\_with\_agent.py\ script further shows how to attach a \KnowledgeBase\ to an agent via \RAGMiddleware\ in both static (auto-inject) and agentic (tool-driven) modes.

examples/rag · high confidence

AgentScope now includes a new long-term memory middleware package that provides three distinct backends: a file-based memory system (AgenticMemoryMiddleware) that stores memories as local Markdown files, a mem0-backed middleware (Mem0Middleware) that integrates with the mem0 library for vector-based memory, and a ReMe-backed middleware (ReMeMiddleware) that embeds the ReMe application for conversation-based memory. These middlewares enable agents to persist and retrieve information across conversations, with configurable retrieval modes and automatic memory write-back capabilities.

_src/agentscope/middleware/\_longterm\memory · high confidence

The application introduces a new middleware layer in \src/agentscope/app/middleware\ that enhances session handling, team agent coordination, and tool execution. \InboxMiddleware\ now drains pending messages from the session inbox and injects them into the agent's context before each reasoning step, ensuring no payloads are stranded. \StateChangeMiddleware\ detects modifications to task or permission contexts and team membership changes, pushing real-time updates to the session's event stream. \TeamMemberLoopMiddleware\ enforces a reporting loop for team members, requiring them to use the \TeamSay\ tool to report to the leader and preventing infinite loops by nudging or failing agents that do not comply. Additionally, \ToolOffloadMiddleware\ offloads long-running tool calls to background tasks, allowing the agent loop to remain responsive while the tool executes asynchronously.

src/agentscope/app/middleware · high confidence

A new \scripts/model\_examples\ directory has been added, containing a unified test runner (\run\_tests.py\) and a suite of example scripts for major LLM providers including OpenAI, Anthropic, DashScope, DeepSeek, Gemini, Moonshot, Volcengine, xAI, and Ollama. The runner auto-detects available providers based on environment variables and executes four test types per provider: basic text calls, multi-agent conversations, multimodal inputs (images, video, audio), and combined multi-agent multimodal scenarios. A shared utility (\\_utils.py\) handles streaming output, including real-time text, thinking blocks, and audio chunk progress. This provides a standardized way to verify AgentScope's chat model components across different providers and input modalities.

_scripts/model\examples · high confidence

Added a new example in \examples/realtime\ that demonstrates a voice-enabled agent using DashScope models and local audio transport. The \local\_mic.py\ script connects a \RealtimeAgent\ to a \LocalAudioTransport\ for microphone input/output and a \launch\_realtime\_ui\ terminal interface for conversation display and tool permission handling. Users can run this example to interact with DashScope speech-to-speech models via voice, supporting features like barge-in, tool calls with approval prompts, and configurable input/output devices.

examples/realtime · high confidence

Agents can now run in isolated, sandboxed environments beyond the existing Docker and E2B options. This change introduces three new workspace backends: Apple Container (for macOS 26+ with Apple silicon), Bubblewrap (for Linux sandboxing), and Daytona (for cloud sandboxes). These backends provide the same core workspace capabilities—such as MCP server integration, skill management, and tool execution—as the existing implementations, but offer different isolation and deployment characteristics tailored to specific host environments.

src/agentscope/workspace · high confidence

Agents now have access to a new set of built-in tools for managing structured task lists within their session. The \TaskCreate\ tool allows agents to generate new tasks with subjects, descriptions, and metadata, while \TaskList\ provides a summary of all current tasks including their status and dependencies. Agents can retrieve full details for specific tasks using \TaskGet\ and modify existing tasks via \TaskUpdate\, which supports changing status (pending, in\_progress, completed, deleted), updating ownership, and managing dependencies (blocking/blocked-by relationships). These tools are designed to help agents organize complex, multi-step work and track progress transparently.

_src/agentscope/tool/\task · high confidence

Added a new \examples/console\ directory containing a \main.py\ script and documentation that demonstrates how to run and debug an AgentScope agent directly in the terminal. This example uses \launch\_console\ to provide an interactive interface with features like streamed output, tool-call confirmation, and interruption handling, backed by a \DashScopeChatModel\ and a \LocalWorkspace\ for persistent memory and file tools.

examples/console · high confidence

The application now uses a comprehensive set of Pydantic-based storage models to persist and manage all core app resources. This change introduces structured records for Agents (including invite configurations), Channels (with routing and session settings), Knowledge Bases and Documents (with explicit chunker configs and lifecycle states), Teams (supporting both created and invited members), Schedules, MCPs, Skills, Credentials, and Users. The models enforce validation rules, handle legacy data migration for knowledge bases and documents, and provide a consistent schema-driven interface for the storage backend and frontend.

_src/agentscope/app/storage/\model · high confidence

The \src/agentscope/app/storage\ package introduces a new storage layer for AgentScope, providing a unified \StorageBase\ interface with two concrete implementations: \RedisStorage\ for in-memory/caching scenarios and \AsyncSQLAlchemyStorage\ for persistent relational storage. This change adds support for storing and managing a wide range of records including agents, sessions, credentials, MCPs, skills, teams, and knowledge bases. The SQLAlchemy backend supports multiple databases (SQLite, Postgres, MySQL) via async SQLAlchemy, with automatic table creation or Alembic migration options. The Redis backend uses configurable key templates and supports sliding TTLs. Both backends handle complex data structures like team members, session origins, and knowledge documents, with lazy loading of the SQLAlchemy dependency to keep the base package lightweight.

src/agentscope/app/storage · high confidence

The RAG module now supports three additional vector database backends alongside the existing Milvus Lite and Qdrant options. Users can now store and retrieve vector embeddings using Elasticsearch (via the async client with cosine similarity and HNSW search), MongoDB (using Atlas Vector Search or self-hosted deployments with configurable distance metrics), and Qdrant (supporting in-memory, local disk, and remote server modes). These implementations share a common abstract base class and data models (VectorRecord, VectorSearchResult), allowing seamless integration into the existing knowledge base workflow.

_src/agentscope/rag/\vdb · high confidence

The web UI frontend has been restructured with a new entry point (App.tsx) that establishes a React Router-based navigation system, including a setup flow, a chat page, and dedicated pages for credentials, knowledge bases, channels, and MCP/skill hubs. A comprehensive API client layer has been added, featuring a centralized HTTP client with error handling, timeout support, and SSE streaming capabilities, along with typed API modules for agents, sessions, channels, credentials, hubs, and workspaces. This provides a robust foundation for the frontend to interact with the backend services.

_examples/web\ui/frontend · high confidence

The tracing capability has been refactored from a standalone module into a \TracingMiddleware\ that can be attached to agents. This middleware automatically instruments agent replies, model calls, and tool executions with OpenTelemetry spans, capturing detailed GenAI attributes (such as provider, model, tokens, and tool definitions) and supporting multimodal content blocks. It is designed to be opt-in and adds near-zero overhead when tracing is not configured.

_src/agentscope/middleware/\tracing · high confidence

The SQL storage backend now ships with a complete Alembic configuration (alembic.ini, env.py, and migration templates) to manage database schema changes. This includes an initial migration creating core tables (agents, credentials, knowledge\_bases, messages, schedules, sessions) and subsequent migrations adding support for MCPs, skills, and channels. Users can now run schema upgrades automatically via Alembic instead of relying on manual table creation or ORM create\_all calls, ensuring consistent schema evolution across different database backends.

_src/agentscope/app/storage/\_sql/\alembic · high confidence

The ACEBench example, including its documentation and the main execution script, has been removed from the examples/evaluation directory. Users can no longer run this specific agent-oriented evaluation example using the Ray-based evaluator.

examples/evaluation · high confidence

The built-in hooks that connected agents to the AgentScope Studio have been removed. Specifically, the \as\_studio\_forward\_message\_pre\_print\_hook\ and the \\_equip\_as\_studio\_hooks\ registration logic are no longer available, meaning agents will no longer automatically forward messages to the Studio UI upon printing.

src/agentscope/hooks · high confidence

The \execute\_python\_code\ and \execute\_shell\_command\ tools have been removed from the \src/agentscope/tool/\_coding\ module. This deletion eliminates the ability to execute arbitrary Python scripts and shell commands within the AgentScope framework, affecting any workflows that relied on these specific code-execution capabilities.

_src/agentscope/tool/\coding · high confidence

The ReAct Agent example, including its main script and documentation, has been removed from the examples directory. Users can no longer run this specific demonstration of an AI assistant named 'Friday' that uses DashScope models and tools like shell command execution and Python code execution via the \examples/react\_agent\ path.

_examples/multi\_agent\_conversation, examples/react\agent · high confidence

The browser automation example (including the custom BrowserAgent implementation, main entry point, and documentation) and the structured output example (including Pydantic model definitions and main entry point) have been removed from the examples directory. Users can no longer run these specific demonstration scripts for web automation via Playwright MCP or for generating constrained Pydantic-structured outputs.

_examples/agent\browser · high confidence

The \src/agentscope/memory\ package has been cleaned up by deleting the legacy \MemoryBase\, \InMemoryMemory\, \LongTermMemoryBase\, and \Mem0LongTermMemory\ classes, along with their associated utility wrappers (\\_mem0\_utils.py\). This change removes the old in-memory and mem0-based long-term memory implementations from the public API, indicating a shift toward the newer memory architecture (such as the recently added database memory and compression features) while eliminating deprecated code paths.

src/agentscope/memory · high confidence

The multi-agent debate workflow example (examples/workflows/multiagent\_debate/main.py) has been removed, meaning users can no longer run this specific demonstration of collaborative agent reasoning. Additionally, the internal StateModule class (src/agentscope/module/\_state\_module.py), which provided nested state serialization and deserialization capabilities, has been deleted, affecting any code that relied on this specific state management infrastructure.

examples/workflows, src/agentscope/module · high confidence

The multi-modal tool implementations for DashScope and OpenAI have been removed from the library. This deletes the \src/agentscope/tool/\_multi\modality\ module, including the \\\init\\_.py\ file and the specific tool modules (\\_dashscope\_tools.py\ and \\_openai\_tools.py\) that provided functions for image generation, text-to-audio, and image-to-text capabilities via these providers. Users relying on these specific multi-modal tools will no longer have access to them through this package path.

_src/agentscope/tool/\_multi\modality · high confidence

The synchronous JSON-based session storage mechanism has been removed from the Agentscope session module. Specifically, the \JSONSession\ class, its \SessionBase\ abstract class, and the module's public exports have been deleted. This eliminates the ability to save and load session states using standard synchronous JSON file I/O operations.

src/agentscope/session · high confidence

The \src/agentscope/tool/\_text\_file\ module, which provided tools for viewing, writing, and inserting text into files (including \view\_text\_file\, \write\_text\_file\, and \insert\_text\_file\), has been completely removed. Users can no longer use these specific file manipulation capabilities within the AgentScope framework.

_src/agentscope/tool/\_text\file · high confidence

The evaluation module's ACEBench integration has been removed, deleting the \ACEBenchmark\ class, its associated metrics (\ACEAccuracy\, \ACEProcessAccuracy\), and the \ACEPhone\ simulation tools (including Message, Reminder, Food Platform, and Travel APIs). This change eliminates the ability to run evaluations against the ACEBench dataset within the AgentScope evaluation framework.

src/agentscope/evaluate · high confidence

The \src/agentscope/token\ module has been removed, deleting the \TokenCounterBase\ class and all provider-specific implementations (OpenAI, Anthropic, Gemini, and HuggingFace). Users relying on these classes for token estimation will need to migrate to the new memory or token management system introduced in recent updates.

src/agentscope/token · high confidence

The \src/agentscope/tracing\ directory, including \\_\init\\_.py\, \\_setup.py\, \\_trace.py\, and \\_types.py\, has been completely removed. This eliminates the previous standalone tracing interface and decorators (such as \setup\_tracing\, \trace\, and \trace\_llm\) that were used to configure OpenTelemetry exporters and wrap agent/model calls. Users relying on these specific module-level functions for manual tracing setup or decoration will need to adopt the new tracing approach provided by the refactored agent middleware system.

src/agentscope/tracing · high confidence

A change to existing behaviour in examples — 2 commits, 1 file.

examples · medium confidence · unverified

The agent module has been significantly restructured: the legacy \AgentBase\ and \ReActAgent\ classes have been removed and replaced by a new unified \Agent\ class that natively supports structured output, context compression, and runtime state injection. Additionally, a new \A2AAgent\ class has been added to enable stateful client-side interaction with remote A2A 1.0 agents, and a new \\_GenerateStructuredOutput\ tool has been introduced to handle structured output validation and generation within the agent loop.

src/agentscope/agent · high confidence

This release updates the library version to 2.0.8 and introduces several internal improvements. The runtime configuration module has been removed, and the public API now exposes \set\_id\_factory\ and \set\_timestamp\_factory\ utilities for customizing ID and timestamp generation. Additionally, the \setup\_logger\ function now validates the logging level input, raising a \ValueError\ for invalid levels, and the package includes a \py.typed\ file to enable static type checking support.

src/agentscope · high confidence

This update introduces audio utilities for streaming PCM data, including a new WAV header builder that enables immediate playback in the frontend without buffering the full response. It also adds configurable global ID and timestamp factories via \set\_id\_factory()\ and \set\_timestamp\_factory()\, allowing users to customize how entity identifiers are generated. Additionally, the \DictMixin\ class now properly raises \AttributeError\ for missing attributes instead of silently returning \None\ or raising \KeyError\, and the JSON repair logic for tool arguments has been enhanced to support schema-guided repair and stricter validation.

_src/agentscope/\utils · high confidence

The chat model implementation has been refactored to use a new base class (ChatModelBase) that standardizes initialization with credential objects, parameter schemas, and retry logic, replacing the previous provider-specific base classes. This change introduces a new ModelCard system for loading model metadata from YAML files and improves streaming performance by replacing O(n²) string concatenation with efficient fragment joining. Additionally, support for the Volcengine Ark chat model has been added, while the old provider-specific model files (Anthropic, DashScope, Gemini, Ollama, OpenAI) have been removed in favor of the new unified structure.

src/agentscope/model · high confidence

The embedding module has been restructured to use a new generic base class (EmbeddingModelBase) that standardizes initialization via a CredentialBase, enforces explicit dimension configuration, and handles batching and retries automatically. All provider-specific implementations (OpenAI, DashScope, Gemini, Ollama) have been renamed (e.g., OpenAITextEmbedding to OpenAIEmbeddingModel) and updated to inherit from this new base. A new EmbeddingModelCard class has been introduced to describe model capabilities, input/output types, and configurable parameters via YAML, enabling better frontend integration and model discovery.

src/agentscope/embedding · high confidence

The permission subsystem has been refactored to use a new engine-based architecture that evaluates tool execution against configurable allow, deny, and ask rules. The system now supports five distinct modes—DEFAULT, ACCEPT\_EDITS, EXPLORE, BYPASS, and DONT\_ASK—each defining specific behaviors for file operations, bash commands, and read-only checks. A key behavioral change is the introduction of 'bypass-immune' safety checks, which ensure that dangerous operations (like writes to critical paths or command injection patterns) always require explicit user confirmation and cannot be silently overridden by allow rules, even in permissive modes. Additionally, the system now provides human-readable decision messages and suggested rules to help users configure their permissions effectively.

src/agentscope/permission · high confidence

The message system in \src/agentscope/message\ has been rewritten from a plain class with TypedDict blocks to a Pydantic-based architecture. The \Msg\ class now uses a \Usage\ model to record token consumption (input, output, and cache tokens) and enforces role-specific content validation (e.g., user messages only allow text or data blocks). Content is now stored as a list of structured \ContentBlock\ types (such as \TextBlock\, \ThinkingBlock\, \ToolCallBlock\, \DataBlock\, and \HintBlock\) replacing the previous flat dictionary-based blocks like \ImageBlock\ and \ToolUseBlock\. This change introduces a more robust, type-safe message structure with built-in serialization and validation.

src/agentscope/message · high confidence

The pipeline module has been restructured to replace the previous sequential and message-hub abstractions with a new goal-oriented execution model. The new \GoalPipeline\ class allows users to define a loop where an executor agent attempts to achieve a goal while a verifier agent checks the result, supporting context resets and iteration limits. This change removes the previously available \MsgHub\, \SequentialPipeline\, and \sequential\_pipeline\ utilities, meaning workflows relying on those specific patterns must be migrated to the new pipeline protocol or the goal-based approach.

src/agentscope/pipeline · high confidence

The types module now exposes structured error handling and reply status information to support better frontend feedback. New types include ReplyFinishedReason (completed, interrupted, exceed\_max\_iters, error), ErrorType (authentication, permission, rate\_limit, invalid\_request, upstream, connection, internal, setup, unknown), and ErrorInfo, which provides a stable classification key and human-readable message for fatal reply errors. This enables the frontend to localize and display specific error contexts (e.g., 401/403/429/5xx) rather than generic failures. Additionally, the legacy ToolFunction type has been removed from exports, and JSONPrimitive/JSONSerializableObject have been modernized to use Python 3.10+ union syntax (TypeAlias).

src/agentscope/types · high confidence

The tool module has been restructured to introduce a new \ToolBase\ protocol and \ToolMiddlewareBase\ for onion-style execution wrapping, allowing middlewares to intercept and modify tool calls. \FunctionTool\ now adapts Python functions to this protocol, automatically extracting schemas and handling streaming via \ToolChunk\. The response model has shifted from \ToolResponse\ to \ToolChunk\ for streaming, with \ToolResponse\ now accumulating chunks and properly merging base64 data. A new \ToolGroup\ class manages collections of tools, skills, and MCP clients, supporting activation/deactivation. Dangerous file and command lists are now explicitly defined in \\_constants.py\ for permission checking. The \Toolkit\ class has been simplified to use these new components, removing legacy async wrappers and registered tool function dataclasses in favor of the new \RegisteredTool\ type.

src/agentscope/tool · high confidence

The MCP module has been refactored to replace the previous class hierarchy (StdIOStatefulClient, HttpStatefulClient, HttpStatelessClient) with a single, unified MCPClient class. This new client supports both stateful and stateless connections and introduces configuration models (StdioMCPConfig, HttpMCPConfig) that allow users to pass runtime HTTP headers, enabling dynamic authentication or metadata injection for HTTP-based MCP servers. The change simplifies the API by consolidating connection management into one entry point while maintaining support for both STDIO and HTTP transports.

src/agentscope/mcp · high confidence

Added comprehensive test coverage for the A2A agent adapter, including end-to-end streaming and multi-turn context tests using a local harness, as well as unit tests for agent construction and reply handling. Added tests for the agent's runtime state injection feature, verifying time and context updates. Added tests for agent interruption handling, ensuring proper cleanup of pending tool calls and correct event emission during cancellation or user interrupts. Added tests for the AGUI protocol middleware, verifying stream conversion and lifecycle event handling. Added tests for the Daytona workspace live integration utilities.

tests · high confidence

The web UI example is now managed via pnpm, introducing a monorepo structure with separate frontend and backend package.json files and a pnpm-lock.yaml. The frontend dependencies include React 19, Tailwind CSS 4, shadcn/ui, and the @agentscope-ai/agentscope client package. On the Python side, pyproject.toml has been reorganized into granular optional dependency groups (e.g., model-gemini, storage-sql, workspace-docker, vdb-milvus, memory-mem0) and pins MCP below 2.0.0 and ripgrep below 15.x to ensure compatibility.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 63.

• Code Health 83
• Architecture 99
• Maturity 54
• Readiness 55
• Security 76
• Domain Modelling 100

• 300 commits — 144 feature/other, 156 fixes

• src/agentscope — 230 commits
• examples/web_ui — 33 commits
• (root) — 16 commits
• .github/workflows — 7 commits
• examples/long_term_memory — 3 commits
• examples/agent_service — 2 commits
• .github/ISSUE_TEMPLATE — 1 commit
• examples/realtime — 1 commit
• examples/workspace — 1 commit
• tests/builtin_read_test.py — 1 commit
• tests/hitl_mixed_test.py — 1 commit
• tests/mcp_runtime_headers_test.py — 1 commit
• tests/mcp_sse_client_test.py — 1 commit
• tests/storage_redis_test.py — 1 commit
• tests/workspace_daytona_test.py — 1 commit

• fix: ci(issue-triage): verify new bug reports with an agent (#2678)
• fix: ci(storage): add regression test for explicit Redis session id (#1786)
• fix: fix(agent): avoid duplicate external tool start event (#2167)
• fix: fix(agent): avoid shared default configs in the Agent class (#1906)
• fix: fix(agent): continue the agent loop after thinking-only responses (#2120)
• fix: fix(agent): count reasoning-acting rounds once (#2217)
• fix: fix(agent): emit ThinkingBlockEnd before TextBlockStart at reasoning→answer boundary (#1887)
• fix: fix(agent): guard against empty or interrupted streaming responses (#1861)
• fix: fix(agent): hint after repeated tool errors (#1816)
• fix: fix(agent): include paths in tool validation errors (#2584)
• fix: fix(agent): keep prompt cache tokens in usage (#2318)
• fix: fix(agent): preserve middleware kwargs across next handlers (#1966)
• fix: fix(agent): preserve multi-tool pairs during context compression (#2093)
• fix: fix(agent): preserve reply usage in final messages (#2562)
• fix: fix(agent): record compression usage in context (#2433)
• fix: fix(agent-team): inherit permission context from the team leader (#1815)
• fix: fix(anthropic): preserve redacted_thinking blocks in message round-trip (#2139)
• fix: fix(app): assign unique AG-UI message IDs to tool results (#2555)
• fix: fix(app): clean up index worker tasks on cancellation (#2220)
• fix: fix(app): clear inbox consumer on session delete (#2519)
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

agentscope-ai/agentscope was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.