Skip to content
CAI
Software that uses CAICheck a score

agentscope-ai/agentscope

62.0

Adequate · 16 November 2026

161.7k

lines of production code

Python

with TypeScript

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add DashScope TTS backend with CosyVoice and Qwen3 models

Users can now generate speech using the DashScope backend, which includes support for the CosyVoice models (v3-Flash and v3-Plus) and the Qwen3-TTS-Flash models (including a new realtime streaming variant). This change introduces the necessary model definitions, voice configurations, and streaming utilities to enable text-to-speech capabilities via these specific DashScope APIs.

_src/agentscope/tts/\dashscope · high confidence

Add DashScope and Gemini realtime voice model support

Users can now connect to DashScope (Qwen-Omni and Qwen-Audio) and Gemini Live APIs for real-time voice conversations. This adds new model implementations (\DashScopeRealtimeModel\, \DashScopeAudioRealtimeModel\, \GeminiRealtimeModel\) and corresponding model cards, enabling features like text input, tool calling, and configurable voice/endpointing parameters for these specific providers.

_src/agentscope/realtime/\dashscope · high confidence

Add Gemini TTS model support

This change introduces the Gemini TTS module, exposing the \GeminiTTSModel\ class for text-to-speech generation. It includes configuration files for the \gemini-2.5-flash-preview-tts\ and \gemini-2.5-pro-preview-tts\ models, both of which accept plain text input and produce WAV audio output. These models support a wide range of voices, including Zephyr, Puck, Charon, Kore, and others.

_src/agentscope/embedding/\ollama · high confidence

Add GoalPipeline example demonstrating multi-agent goal verification

The examples/pipeline directory now includes a new 'goal' example that demonstrates the GoalPipeline class. This example shows how to configure an Executor agent and a Verifier agent to share a LocalWorkspace, allowing the Verifier to independently check the Executor's work against a specific goal. The demo highlights the loop mechanism where the Verifier provides structured feedback (passed/failed with messages) to the Executor, enabling iterative refinement up to a maximum number of iterations. It also illustrates how to handle human-in-the-loop interruptions via reply\_stream resumption.

examples/pipeline · high confidence

Add OpenAI Realtime API support

This change introduces a new OpenAI Realtime model implementation within the Agentscope framework, enabling low-latency, bidirectional voice conversations via WebSocket. The new \OpenAIRealtimeModel\ class handles session management, audio streaming (PCM 24kHz), and text input, while exposing configurable parameters for voice selection, turn detection (VAD), and input transcription. Additionally, model cards for GPT Realtime 1.5, 2.1, 2.1 Mini, and 2 are added to define capabilities such as tool support and context limits for these specific models.

_src/agentscope/realtime/\openai · high confidence

Add local audio transport for real-time voice agents

Users can now connect real-time voice agents to local hardware (microphone and speaker) via a new \LocalAudioTransport\ class. This transport uses the \sounddevice\ library to handle audio capture and playback, allowing for low-latency, bidirectional voice interaction without requiring external network services for the audio stream itself.

_src/agentscope/realtime/\transport · high confidence

Add support for xAI Grok voice realtime models

Users can now initiate real-time voice conversations with xAI's Grok models (specifically 'grok-voice-latest' and 'grok-voice-think-fast-2.0') via a new WebSocket-based implementation. This change introduces the \XAIRealtimeModel\ class, which handles audio streaming (PCM), text input, and tool calls, while exposing configuration options for voice selection, turn detection, and reasoning effort.

_src/agentscope/realtime/\xai · high confidence

Add terminal console for trying and debugging agents

A new \console\ module has been added to provide a lightweight, interactive terminal interface for testing and debugging agents. It includes a \ConsoleRenderer\ class for streaming agent events into line-based terminal output and a \launch\_console\ function that sets up an interactive chat loop. This loop handles user input, renders agent responses with configurable verbosity, manages human-in-the-loop tool call confirmations, and supports Ctrl+C interruption to cancel ongoing replies.

src/agentscope/console · high confidence

Expanded model support and configuration for Anthropic, DashScope, DeepSeek, Gemini, MiniMax, Moonshot, Ollama, and OpenAI

This update adds YAML model cards and provider modules for a wide range of LLMs, enabling users to select and configure these models directly. New or updated model cards include Anthropic Claude (Fable 5/5.1, Haiku 4.5, Opus 4.5/4.6/4.7/4.8, Sonnet 4.5/4.6/5), DashScope (DeepSeek V4 Pro, GLM 5.2/5.3, Qwen Flash/Long/Plus/3.5-Flash/Plus/Omni-Plus/3.6-Flash/Plus/Max-Preview/3.7-Flash/Plus/Max/3.8-Flash/Plus/Max/Omni-Flash), DeepSeek (Chat, Flash, Reasoner, V4 Flash/Pro), Gemini (2.5 Flash/Lite/Pro, 3 Flash/3.1 Flash-Lite/Pro-Preview/3.5 Flash-Lite/Flash/3.6 Flash/3.7 Flash/3.8 Flash), MiniMax (M2.7, M2.7 Highspeed, M3), Moonshot (Kimi K2.5, K2.6, K2.7 Code, K2.7 Code Highspeed, K3, Moonshot v1 8K/32K/128K), Ollama (DeepSeek R1 14B, Gemma 4, Llama 3.2 3B, Llama 4 Scout, Phi-4 Mini, Qwen3 8B/14B, Qwen3.5 9B, Qwen3.8 27B), and OpenAI (GPT-4.1, GPT-4.1 Mini, GPT-4.1 Nano, GPT-4o, GPT-4o Mini, GPT-5.4, GPT-5.5, GPT-5.6 Luna/Sol). The cards define context/output sizes, supported input/output types (text, images, audio, video, PDF), and parameter overrides like max tokens, thinking modes, and voice settings for omni models. Also in this area: 6 commits (4 fixes) fixing src/agentscope; 2 commits (0 fixes) modifying src/agentscope/model.

_src/agentscope/model/\gemini · medium confidence · unverified

Introduce AGUI protocol middleware for SSE event conversion

Added a new middleware layer in \src/agentscope/app/middleware/\_protocol\ that intercepts Server-Sent Event (SSE) streams and converts internal AgentScope events into the AGUI protocol format. This includes a base \ProtocolMiddlewareBase\ class for handling SSE frame parsing and a specific \AGUIProtocolMiddleware\ implementation that maps internal events (such as text blocks, tool calls, and reasoning steps) to corresponding AGUI events, enabling compatibility with AGUI-based clients.

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

Introduce Agent Service example with multi-tenant support and Web UI

Adds a new example demonstrating a FastAPI-based Agent Service that supports multi-tenant and multi-session operations. The service uses Redis for storage and includes a companion Web UI for a chat-style interface. Key capabilities include human-in-the-loop interactions with a permission system, scheduled tasks, long-term memory via middleware, and integration with various channels (DingTalk, Discord, Feishu) and resource hubs (GitHub MCP, ClawSkill).

_examples/agent\service · high confidence

Introduce AgentScope middleware system with built-in capabilities

AgentScope now includes a new middleware system that allows intercepting and modifying the agent lifecycle at seven key points (reply, reasoning, acting, permission, model call, context compression, and system prompt). This release ships with several built-in middleware implementations: ReplyBudgetControlMiddleware for enforcing token budgets per reply, RAGMiddleware for knowledge-base search in both agentic and static injection modes, Mem0Middleware for long-term memory backed by the mem0 library, TracingMiddleware for OpenTelemetry-based tracing, TTSMiddleware for text-to-speech synthesis, and ModelRouterMiddleware for routing replies to different chat models based on classification. The system is exposed via the agentscope.middleware package.

src/agentscope/middleware · high confidence

Introduce DingTalk channel with interactive credential binding and agent tools

Users can now connect AgentScope agents to DingTalk via a new channel adapter. This change adds a dedicated DingTalk implementation that supports long-lived inbound connections, interactive credential binding (allowing operators to authenticate via QR code or consent screens rather than pasting secrets), and a suite of agent tools for discovering conversations and users, and sending text, images, and files to DingTalk targets. It also introduces a stateless tool-approval mechanism using DingTalk interactive cards, enabling users to approve or deny tool calls directly within the DingTalk interface.

src/agentscope/app/channel · high confidence

Introduce FastAPI-based agent service with configurable app factory

The agent service is now built on FastAPI, providing a \create\_app\ factory in \src/agentscope/app\ that allows embedding AgentScope into existing services or running it standalone. This new service layer introduces a decoupled message bus for cross-session delivery, a background task manager with a \ToolStop\ tool for canceling long-running operations, and a \CancelDispatcher\ for cross-process task cancellation. It also adds support for custom sub-agent templates, custom agent classes, and configurable resource access policies, while managing the lifecycle of storage, workspaces, and knowledge bases through a centralized lifespan context.

src/agentscope/app · high confidence

Introduce Mem0Middleware for long-term memory in AgentScope agents

The example directory now demonstrates a new middleware-based approach to long-term memory using the mem0 library. The previous standalone \\Mem0LongTermMemory\\ example has been replaced by \\oss\_demo.py\\, which integrates \\Mem0Middleware\\ directly into an \\Agent\\. This middleware automatically injects retrieved memory facts into the agent's context and handles writing new facts back after each turn, supporting both static and agent-controlled memory modes. The demo uses the open-source mem0 backend with a local Qdrant vector store and separate LLM instances for the agent and the middleware to avoid event-loop conflicts.

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

Introduce RAG module with document parsing, chunking, and vector store integration

The RAG module is now available, providing a complete pipeline for indexing and retrieving documents. Users can parse various file formats (PDF, PPT, Word, Excel, images, text) into sections and chunks, embed them using configured models, and store/retrieve them via vector stores such as Elasticsearch, Milvus Lite, Qdrant, and MongoDB. The module exposes a KnowledgeBase class to manage collections, supporting search, insert, delete, and list operations with optional metadata filtering for multi-tenant scoping.

src/agentscope/rag · high confidence

Introduce RAG service-layer components for document storage and knowledge base management

This change adds the core service-layer building blocks for the RAG module, introducing a pluggable blob storage system with local filesystem and S3-compatible backends to handle document uploads without keeping bytes in memory, a knowledge base manager that supports a one-collection-per-knowledge-base isolation strategy for vector stores, and an out-of-process index worker entry point to handle the parse-chunk-embed pipeline asynchronously.

src/agentscope/app/rag · high confidence

Introduce Standard Operating Procedures (SOP) module for structured agent workflows

A new \sop\ package has been added to AgentScope, providing a framework for defining and executing fixed sequences of milestones. Users can now define procedures using \SOP\ and \SOPStep\ classes, where each step specifies an executor and a verifier. The \SOPEngine\ manages the execution lifecycle, handling state persistence, resumption from parked states (e.g., awaiting user confirmation), and routing handovers between steps. This allows for complex, multi-stage agent interactions with built-in verification and retry logic.

src/agentscope/sop · high confidence

Introduce agent state management module

A new state management module has been added to expose core state and context classes for agents and tasks. Users can now import AgentState, A2AAgentState, Task, TaskContext, ReplyContext, and ToolContext from agentscope.state to manage agent lifecycle, task execution, and inter-agent communication contexts.

src/agentscope/state · high confidence

Introduce agent-driven cron scheduling via new tools

Agents can now create, view, list, and delete recurring scheduled tasks using the new ScheduleCreate, ScheduleView, ScheduleList, and ScheduleDelete tools. Each schedule runs the agent at a specified cron interval, optionally sharing session context (stateful) or starting fresh, and delivers execution results to the session inbox via the message bus. Schedules are persisted in storage and managed by a single node's in-memory APScheduler instance, with periodic reconciliation to keep the owner in sync.

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

Introduce dedicated message bus module with in-memory and Redis implementations

A new \message\_bus\ module has been added to provide a structured, live transport layer for cross-session messaging. This includes an abstract base class defining three consumption modes (drain queue, replay log, and transient broadcast), a pure-Python \InMemoryMessageBus\ for single-process development and testing, and a \RedisMessageBus\ for production distributed deployments. The module also introduces a centralized \MessageBusKeys\ registry to standardize key naming conventions for session events, inboxes, and distributed locks, decoupling business logic from the transport layer.

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

Introduce dedicated service layer for AgentScope app

The application now exposes a structured service layer under \src/agentscope/app/\_service\ that centralizes core capabilities. This includes \ChannelService\ for managing channel lifecycle and status, \KnowledgeBaseService\ for orchestrating document indexing and vector store operations, and \SessionService\ for session management. The layer also introduces \SOPService\ for standard operating procedures, \RealtimeService\ for voice conversations, and \WorkspaceService\ for file operations. Security and reliability are enhanced with signed download tokens, robust error classification for UI feedback, and background indexing workers with a sweeper for stuck tasks.

_src/agentscope/app/\service · high confidence

Introduce local skill loading with SKILL.md support

Users can now load agent skills from local directories using the new \LocalSkillLoader\. This feature parses \SKILL.md\ files (including those with UTF-8 BOMs) to extract skill metadata, supports optional subdirectory scanning, and caches results based on file modification times for efficient repeated access.

src/agentscope/skill · high confidence

Introduce new FastAPI-based HTTP API routers for the AgentScope application

The application now exposes a comprehensive set of REST endpoints via a new router package, replacing or supplementing previous interface mechanisms. This includes dedicated routers for managing agents, channels (with interactive credential binding), chat sessions (fire-and-forget triggers with SSE streaming), credentials, embedding and chat models, health checks, hub-based MCP and skill installation, knowledge bases (with chunking and middleware configuration), MCP libraries, scheduled tasks, sessions, skills, and workspaces. Users can now interact with these resources through standard HTTP calls, enabling programmatic management of agents, credentials, knowledge bases, and scheduled tasks, as well as real-time chat interactions via the new chat and session streaming endpoints.

_src/agentscope/app/\router · high confidence

Introduce new builtin tool suite and backend abstraction

This change introduces a new set of builtin tools (AskUser, Bash, Edit, Glob, Grep, PowerShell, Read, Write, ResetTools, SkillViewer) and a backend abstraction layer (BackendBase, LocalBackend) that enables these tools to operate consistently across local, Docker, and E2B workspaces. The AskUser tool allows agents to pose multiple-choice questions to users, while the new backend system standardizes file I/O and shell execution primitives, allowing tools like Bash and PowerShell to respect the target environment's OS and path conventions rather than the host machine's.

_src/agentscope/tool/\builtin · high confidence

Introduce new web UI example with backend and frontend scaffolding

This change adds a new example web UI located in examples/web\_ui, providing a complete scaffold for a React + TypeScript + Vite frontend and an Express backend. The frontend is configured with Tailwind CSS, shadcn/ui components, and ESLint, while the backend exposes a basic health check API. The setup includes a pnpm workspace to manage both packages, a pre-commit hook for linting, and configuration files for TypeScript, Vite, and Prettier.

_examples/web\ui · high confidence

Introduce unified workspace manager with multiple backend support

The application now includes a new workspace management layer in \src/agentscope/app/workspace\_manager\ that standardizes how agent workspaces are created, cached, and isolated. This change introduces a base \WorkspaceManagerBase\ with an \IsolationPolicy\ (supporting per-user, per-agent, and per-session grains) and provides concrete managers for various execution environments: Local, Docker, E2B, K8s, Daytona, Apple Container, and Bubblewrap. Users can now select their preferred backend to manage workspace lifecycles, with features like TTL-based idle eviction, background sweeper tasks, and consistent public APIs (\get\_workspace\, \close\, \close\_all\) across all backends.

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

Introduction of Realtime Voice API support with multi-provider models

AgentScope now supports realtime voice conversations by introducing a new \realtime\ module that exposes models for OpenAI, Gemini, xAI (Grok), and DashScope backends. This update provides the underlying infrastructure for voice sessions, including transport layers, voice activity detection (VAD), and specific event handling for audio streams, enabling users to build voice-enabled agents using these providers.

src/agentscope/realtime · high confidence

Introduction of a new event-driven architecture for agent interactions

The \src/agentscope/event\ module has been added, introducing a comprehensive set of event classes to handle agent lifecycle and interaction states. This includes events for reply start/end, model call progress, and granular content blocks (text, data, thinking, hints). It also introduces specific events for tool usage (start, delta, end, results), external execution, user confirmation requirements, and user interruptions. This change provides a structured way for users to observe and react to detailed agent behaviors and state transitions.

src/agentscope/event · high confidence

Introduction of the TTS module with multiple backend support

The TTS (Text-to-Speech) module is now available, exposing a unified interface for text-to-speech generation. Users can now utilize models from DashScope (including CosyVoice, standard TTS, and Realtime TTS), Gemini, and OpenAI through dedicated model classes (DashScopeCosyVoiceTTSModel, DashScopeTTSModel, DashScopeRealtimeTTSModel, GeminiTTSModel, OpenAITTSModel) alongside base abstractions like TTSModelBase and TTSModelCard.

src/agentscope/tts · high confidence

New A2A 1.0 example demonstrating remote agent interaction

The \examples/a2a\ directory now includes a complete end-to-end example for the A2A 1.0 protocol. It provides a \server.py\ that exposes an AgentScope agent via JSON-RPC/SSE and a \client.py\ that uses the new \A2AAgent\ class to interact with it. This allows users to chat with a remote agent using the same console interface as a local one, handling streaming artifacts and context management automatically.

examples/a2a · high confidence

New DashScope and Gemini embedding model implementations

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

New RAG chunking module with approximate token splitting

The RAG indexing pipeline now includes a new chunker module (\src/agentscope/rag/\_chunker\) that splits document sections into chunks for embedding. It introduces \ApproxTokenChunker\, which uses a lightweight UTF-8 byte approximation (\len(text) // 4\) to estimate token counts, allowing users to configure \chunk\_size\ and \overlap\ without requiring external tokenizer libraries. The implementation enforces strict boundaries: it never merges content across input sections, passes multimodal \DataBlock\ content through unchanged, and drops empty or whitespace-only text to prevent blank entries from reaching the embedding step.

_src/agentscope/rag/\chunker · high confidence

New RAG library-mode examples with multiple vector store backends

The examples/rag directory now includes two walk-through scripts (index\_and\_search.py and integrate\_with\_agent.py) that demonstrate the agentscope.rag module without requiring the FastAPI service. These examples show how to wire up the parser, chunker, embedding model, and vector store end-to-end, and how to attach a KnowledgeBase to an Agent via RAGMiddleware in both static (auto-inject) and agentic (tool-driven) modes. The documentation and code 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) and updating the store construction.

examples/rag · high confidence

New ReMe long-term memory middleware example

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

New Realtime Voice Agent example with local microphone and TUI

Added a new example in \examples/realtime/\ that demonstrates a voice conversation with DashScope models via the local microphone. The \local\_mic.py\ script integrates \LocalAudioTransport\ for audio capture/playback, \RealtimeAgent\ for turn-taking and tool handling, and \launch\_realtime\_ui\ for a terminal-based interface. It supports models like \qwen-audio-3.0-realtime-plus\ and \qwen3.8-omni-flash-realtime\, allows tool usage (Bash, Edit, Write, Read) with permission prompts, and handles barge-in and session reconnection.

examples/realtime · high confidence

New SQLAlchemy-based async storage backend

A new async SQLAlchemy storage backend (AsyncSQLAlchemyStorage) is introduced for the Agentscope app, allowing users to persist agents, sessions, credentials, SOPs, and other records to relational databases such as SQLite, PostgreSQL, or MySQL. The implementation uses a dialect-neutral schema with a JSON payload column and promoted indexed columns, handles naive UTC timestamps for consistent cross-node comparisons, and supports both automatic table creation and Alembic-based migrations.

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

New Terminal UI example with chat and voice support

Added a new Textual-based Terminal UI example (\examples/tui\) that allows users to run an AgentScope agent with a rich textual chat interface and voice session support. The example includes a standalone launcher (\launch\_tui\) for standard chat interactions and a real-time UI launcher (\launch\_realtime\_ui\) for voice sessions, along with documentation on embedding the UI widgets into custom applications.

examples/tui · high confidence

New TypeSafe Jev classifier model and credential support

Users can now classify text using the TypeSafe Jev System One API. This change introduces a new \classifier\ module with a \JevClassifierModel\ that accepts typed questions (binary, choice, or score) and returns probabilistic answers. A corresponding \TypeSafeCredential\ has been added to the credential system to manage the required API key and base URL, and the \CredentialFactory\ has been updated to recognize and deserialize this new credential type.

src/agentscope/credential · high confidence

New agentic memory middleware example using file-based Markdown storage

Added an 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 a local \demo\_workspace/Memory\ directory and recalling it in subsequent turns, illustrating how memory is scoped to the workspace and persisted on disk.

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

New app lifecycle and concurrency management components

The application now includes a new \\_manager\ package that introduces core infrastructure for managing the agent service lifecycle and concurrency. This includes a \ChatRunRegistry\ to track in-flight chat tasks per session, a \WakeupDispatcher\ to serially handle session triggers and prevent race conditions, a \CancelDispatcher\ to manage cross-process cancellations for sessions and background tasks, and a \BackgroundTaskManager\ for handling distributed background work. These components work together to ensure robust session management, graceful shutdown, and safe concurrent execution within the FastAPI-based agent service. Also in this area: 6 commits (4 fixes) fixing src/agentscope; 2 commits (1 fix) modifying src/agentscope.

_src/agentscope/app/\manager · medium confidence · unverified

New formatters for MiniMax, Moonshot, xAI, Volcengine, and OpenAI Responses APIs

This change introduces dedicated formatters for several new and existing model providers, significantly expanding multimodal and reasoning support. New formatters include MiniMax (supporting video input), Moonshot (handling base64 conversion for remote images/videos and preserving reasoning content for thinking models), xAI (converting messages to protobuf objects for the gRPC client), Volcengine Ark (supporting images and videos), and OpenAI Responses API (mapping content types like input\_image and input\_file while warning that audio is unsupported). Existing formatters for Anthropic, DashScope, and DeepSeek have been refactored to use a common base, improving consistency in handling data blocks, thinking blocks, and tool calls.

src/agentscope/formatter · high confidence

New framework-builtin tools for team coordination and standard operating procedures

The application now includes a new set of built-in tools in the app layer to support multi-agent teams and structured workflows. For team collaboration, agents can use TeamCreate to form a team, AgentCreate to spawn new worker members, AgentInvite to borrow existing user-owned agents into the team, TeamSay to coordinate via messaging, and TeamDelete to dissolve the team. Additionally, Standard Operating Procedure (SOP) steps can now use SubmitHandover to pass results to subsequent steps and SubmitVerdict to accept or reject work, enabling structured, multi-stage agent procedures.

_src/agentscope/app/\tool · high confidence

New interactive terminal UI for AgentScope

Users can now interact with agents directly in the terminal using a rich, keyboard-driven chat interface. This change introduces the \agentscope.tui\ module, which provides \launch\_tui\ for standard text-based conversations and \launch\_realtime\_ui\ for voice sessions. The interface features a composable chat widget with support for multiline input, human-in-the-loop tool confirmations, and real-time message streaming, all built on the Textual framework.

src/agentscope/tui · high confidence

New long-term memory middleware backends

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. Also in this area: 2 commits (2 fixes) fixing src/agentscope/middleware.

_src/agentscope/middleware/\_longterm\memory · medium confidence · unverified

New model example scripts and unified test runner

A new \scripts/model\_examples\ directory has been added, providing a comprehensive set of example scripts and a unified test runner (\run\_tests.py\) for verifying AgentScope's chat model components. The examples cover major LLM providers including OpenAI, Anthropic, MiniMax, DashScope, DeepSeek, Gemini, Moonshot, Volcengine, xAI, and Ollama. Each provider is represented by scripts demonstrating basic text calls, multi-agent conversations (using specific formatters like \AnthropicMultiAgentFormatter\), and multimodal inputs (images, video, audio via \DataBlock\). The unified runner allows users to quickly check provider availability and execute these tests across different scenarios.

scripts · high confidence

New modular storage backend with Redis and optional SQLAlchemy support

The application now uses a dedicated storage module (\src/agentscope/app/storage\) that provides a unified interface for persisting agent data, sessions, credentials, and team configurations. This change introduces a \RedisStorage\ implementation for high-performance caching and state management, alongside an optional \AsyncSQLAlchemyStorage\ backend for relational data persistence. The module exposes a comprehensive set of data models (e.g., \SessionRecord\, \TeamRecord\, \SOPRecord\) and handles lazy loading of the SQL dependency to keep the core import lightweight. Users benefit from more robust, scalable, and structured data storage for their agent interactions and team workflows.

src/agentscope/app/storage · high confidence

New scripts for issue triage and model usage examples

Added \scripts/claim\_intent.py\ and \scripts/issue\_triage.py\ to automate GitHub issue classification and verification using AgentScope agents, and introduced a suite of \scripts/model\_examples/\ scripts demonstrating streaming, tool calling, and structured output for Anthropic, DashScope, DeepSeek, Gemini, MiniMax, Moonshot, Ollama, and OpenAI models.

agentscope · high confidence

New storage model definitions for the AgentScope application

This change introduces a new package of Pydantic-based storage models for the AgentScope application, defining the data structures for agents, sessions, knowledge bases, schedules, credentials, MCPs, skills, teams, and users. These models serve as the schema layer for the new SQLAlchemy-based storage backend, enabling the persistence of agent configurations (including chat and invite settings), knowledge base metadata, scheduled tasks, and installed resources.

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

New vector store backends for RAG: Elasticsearch, MongoDB, Milvus Lite, and Qdrant

The RAG module now supports four new vector database backends, allowing users to store and retrieve embeddings using Elasticsearch, MongoDB, Milvus Lite, or Qdrant. These implementations are exposed via the \src/agentscope/rag/\_vdb\ package, which provides a unified \VectorStoreBase\ interface and specific store classes (\ElasticsearchStore\, \MongoDBStore\, \MilvusLiteStore\, \QdrantStore\) for managing collections, indexing documents, and performing similarity searches. Also in this area: 1 commit (1 fix) fixing src/agentscope/rag; Fixes for console stability, file URL handling, tracing serialization, and RAG limits.

_src/agentscope/rag/\vdb · medium confidence · unverified

New web UI frontend scaffolding and API client layer

The web UI frontend has been restructured with a new entry point (App.tsx) that establishes the core routing, layout, and onboarding tour, alongside a comprehensive API client layer. This layer introduces a typed HTTP client with built-in error handling, timeout support, and XHR-based upload progress tracking for large file transfers. It exposes dedicated API modules for agents, sessions, chat, credentials, knowledge bases, hubs (MCP and skills), channels, schedules, and workspace management, providing the frontend with the necessary interfaces to interact with the backend services.

_examples/web\ui/frontend · high confidence

New workspace backends for Apple Container, Bubblewrap, and Daytona

Agents can now run in sandboxed workspaces backed by Apple Container (macOS 26+ with Apple silicon), Linux Bubblewrap, and Daytona cloud sandboxes. These new backends, alongside the existing Docker, E2B, and OpenSandbox options, provide isolated environments with built-in tools and MCP gateway support, giving users more flexibility in choosing where and how their agents execute. Also in this area: 6 commits (4 fixes) fixing src/agentscope.

_src/agentscope/workspace, src/agentscope/workspace/\_mcp\gateway · medium confidence

OpenTelemetry tracing is now available as an agent middleware

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 attributes such as conversation IDs, provider names, model parameters, input/output messages, and tool definitions. It supports multimodal content conversion, handles external tool execution and human-in-the-loop events, and ensures correct context management across async boundaries to prevent OTel context detach errors.

_src/agentscope/middleware/\tracing · high confidence

SQL storage backend now includes Alembic migration infrastructure

The SQL storage backend now ships with a complete Alembic migration setup (alembic.ini, env.py, and version scripts) to manage database schema evolution. This includes an initial migration creating core tables (agents, credentials, knowledge\_bases, messages, schedules, sessions) and subsequent migrations adding support for MCPs, skills, channels, and Standard Operating Procedures (SOPs). Users can now run schema upgrades automatically via the provided Alembic configuration, ensuring the database structure stays in sync with the application's storage models.

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

Standalone glob helper script for remote workspaces

A new standalone Python script (\_glob\_helper.py) has been added to the builtin tools package to support file globbing in remote Docker and E2B workspaces. This script is deployed to the workspace environment at initialization and invoked via exec\shell by the Glob tool, allowing it to operate without the agentscope package being installed on the remote host. It implements custom glob matching logic (supporting \, ?, and \\) and outputs results as a sorted JSON array.

_src/agentscope/tool/\_builtin/\scripts · high confidence

Removals

Removal of ACEBench evaluation example

The ACEBench example, which demonstrated agent-oriented evaluation using a ReAct agent and Ray-based distributed evaluation, has been removed from the examples directory. Users can no longer run this specific benchmark integration via the provided \main.py\ script.

examples/evaluation · high confidence

Removal of AgentScope Studio integration hooks

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

Removal of Python and Shell execution tools

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 environment, affecting any workflows that relied on these specific code-execution capabilities.

_src/agentscope/tool/\coding · high confidence

Removal of ReAct Agent example

The ReAct Agent example, including its main Python script and documentation, has been removed from the examples directory. Users can no longer run this specific interactive assistant demonstration which previously showcased tool integration (shell, Python, file viewing) and streaming responses using the AgentScope framework.

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

Removal of browser and structured output examples

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.

_examples/agent\browser · high confidence

Removal of legacy memory module components

The \src/agentscope/memory\ package has removed its legacy memory implementation files, including the \\_\init\\_.py\ module, the \MemoryBase\ and \LongTermMemoryBase\ abstract classes, the \InMemoryMemory\ concrete class, and the \Mem0LongTermMemory\ integration along with its utility wrappers. This deletion indicates that these specific memory classes and their public exports are no longer part of the codebase, likely replaced by a refactored memory architecture.

src/agentscope/memory · high confidence

Removal of multi-agent debate example and state module

The multi-agent debate workflow example in examples/workflows has been removed, along with the internal StateModule implementation in src/agentscope/module. Users can no longer run the specific multi-agent debate scenario or utilize the nested state serialization/deserialization capabilities provided by the deleted StateModule class.

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

Removal of multi-modal tool implementations

The multi-modal tool implementations for DashScope and OpenAI have been removed from the library. This deletes the \\_multi\modality\ module, including the \\\init\\_.py\ re-exports and the specific tool functions for image generation, text-to-audio, and image-to-text (such as \dashscope\_text\_to\_image\, \openai\_edit\_image\, and \openai\_audio\_to\_text\). Users relying on these specific multi-modal capabilities will no longer have access to them through this package.

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

Removal of synchronous JSON session implementation

The synchronous JSON-based session storage mechanism has been removed from the \src/agentscope/session\ module. Specifically, the \JSONSession\ class, its \SessionBase\ abstract class, and the module's public exports (\\_\init\\_.py\) have been deleted. This eliminates the ability to save and load session states using standard synchronous JSON file I/O, aligning with the project's move toward asynchronous session handling or alternative storage backends.

src/agentscope/session · high confidence

Removal of text file tools module

The text file tools module (\src/agentscope/tool/\_text\_file\) has been removed, eliminating the \view\_text\_file\, \insert\_text\_file\, and \write\_text\_file\ capabilities from the product.

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

Removal of the evaluation module

The entire evaluation module located at src/agentscope/evaluate has been removed. This deletion eliminates the public API for running evaluations, including the base classes for benchmarks and evaluators, the specific ACEBench implementation (with its associated metrics and simulation tools), and the storage mechanisms for evaluation results.

src/agentscope/evaluate · high confidence

Removal of the standalone tracing module

The \src/agentscope/tracing\ package, which previously provided standalone decorators and setup functions for OpenTelemetry tracing (including \setup\_tracing\, \trace\, \trace\_llm\, and related span attributes), has been completely removed. This eliminates the previous mechanism for manually instrumenting agent components with OpenTelemetry spans via these specific decorators and configuration utilities.

src/agentscope/tracing · high confidence

Removal of the token counting module

The \src/agentscope/token\ module has been removed, deleting the \TokenCounterBase\ class and all provider-specific implementations (OpenAI, Anthropic, Gemini, and HuggingFace). Users can no longer use these classes to estimate token usage for API calls or local models within this package.

src/agentscope/token · high confidence

Behavioural changes

1 commit (0 fixes) modifying src/agentscope/agent, src/agentscope/credential, src/agentscope/realtime

A change to existing behaviour in src/agentscope/agent, src/agentscope/credential, src/agentscope/realtime — 1 commit, 6 files: “feat(realtime): add GPT Live Voice Integration with Chat Agent Delegation (\#3272)” (refs \#3272).

_src/agentscope/realtime/\_openai\live · low confidence · unverified

1 commit (0 fixes) modifying src/agentscope/tts/\_minimax

A change to existing behaviour in src/agentscope/tts/\_minimax — 1 commit, 9 files: “feat(tts): add MiniMax speech synthesis (\#2298)” (refs \#2298).

_src/agentscope/tts/\minimax · medium confidence · unverified

10 commits (2 fixes) modifying src/agentscope/workspace/\_docker

A change to existing behaviour in src/agentscope/workspace/\_docker — 10 commits (2 fixs), 7 files: “feat(workspace): add workspace root to permission context (\#1823)”; “fix(deps): upgrade certifi, pip, uv and node to drop distrusted CAs (\#3410)”; “feat(workspace): add OpenSandbox-based backend, workspace and manager (\#1953)”; and 7 more (refs \#1823, \#3410, \#1953, \#1650, \#1971, …).

_src/agentscope/workspace/\docker · medium confidence · unverified

2 commits (0 fixes) modifying src/agentscope/tts/\_gemini

A change to existing behaviour in src/agentscope/tts/\_gemini — 2 commits, 5 files: “feat(tts): implement Gemini TTS API (\#1879)”; “feat(tts): support Gemini 3.8 Flash and Flash-Lite TTS (\#3677)” (refs \#1879, \#3677).

_src/agentscope/tts/\gemini · medium confidence · unverified

2 commits (1 fix) modifying examples/web\_ui/frontend

A change to existing behaviour in examples/web\_ui/frontend — 2 commits (1 fix), 22 files: “fix(webui): re-measure the chat composer when its width changes (\#3953)”; “feat(app): add client-declared external tools and interactive user input (\#2394)” (refs \#3953, \#2394). Also in this area: New terminal console example for agent debugging.

examples/console · medium confidence · unverified

4 commits (0 fixes) modifying src/agentscope/model/\_volcengine

A change to existing behaviour in src/agentscope/model/\_volcengine — 4 commits, 6 files: “feat(formatter): add audio input support for Volcengine (\#3706)”; “feat(model): add Volcengine Ark chat model support (\#2532)”; “feat(model): add model cards for the latest models (\#2727)”; and 1 more (refs \#3706, \#2532, \#2727, \#3488).

_src/agentscope/model/\volcengine · medium confidence · unverified

40 commits (16 fixes) modifying src/agentscope/model

A change to existing behaviour in src/agentscope/model — 40 commits (16 fixs), 11 files: “refactor(tool): refactor the tool module, including providing new base class and toolkit logic (\#1493)”; “feat(agent): implement permission checking logic within the agent class (\#1518)”; “fix(model): unify \client\_kwargs\ in ollama and dashscope chat model classes (\#986)”; and 37 more (refs \#1493, \#1518, \#986, \#677, \#1142, …).

(repo-wide) · medium confidence · unverified

5 commits (2 fixes) modifying src/agentscope/workspace/\_bubblewrap

A change to existing behaviour in src/agentscope/workspace/\_bubblewrap — 5 commits (2 fixs), 4 files: “fix(deps): upgrade certifi, pip, uv and node to drop distrusted CAs (\#3410)”; “feat(workspace): share workspace across different agents (\#1951)”; “feat(workspace): add bubblewrap workspace backend (\#2051)”; and 2 more (refs \#3410, \#1951, \#2051, \#2197, \#3550).

_src/agentscope/workspace/\bubblewrap · medium confidence · unverified

7 commits (1 fix) modifying src/agentscope/model/\_anthropic

A change to existing behaviour in src/agentscope/model/\_anthropic — 7 commits (1 fix), 45 files: “feat(model): add model cards for the latest models (\#2727)”; “feat(models): add latest chat, TTS, and realtime model configs (\#3488)”; “fix(model): mark the retiring Claude Sonnet 4.5 model card deprecated (\#3429)”; and 4 more (refs \#2727, \#3488, \#3429, \#2114, \#1564, …).

(repo-wide) · medium confidence · unverified

Agent architecture refactored to unified class with structured output and A2A support

The agent module has been restructured: the legacy \AgentBase\ and \ReActAgent\ classes (along with their metaclass and base classes) are removed and replaced by a new unified \Agent\ class that handles the reasoning-acting loop, context compression, and structured output via a dedicated \GenerateStructuredOutput\ tool. The new \Agent\ class also introduces a stateful \A2AAgent\ adapter for remote A2A 1.0 agents, enabling inter-agent communication. Configuration is now centralized in \ContextConfig\, \ModelConfig\, \ReActConfig\, and \InjectionConfig\, supporting features like context compression triggers, tool result limits, and runtime state injection.

src/agentscope/agent · high confidence

AgentScope 2.0 release with Python 3.11 requirement and new documentation

AgentScope has been updated to version 2.0, raising the minimum Python requirement from 3.10 to 3.11. The project has migrated its build system from setup.py to pyproject.toml, updated its pre-commit configuration (including a pyroma version bump to 5.0), and introduced a formal CONTRIBUTING.md guide with specific policies for AI-assisted coding. The README files have been revamped to reflect the 2.0 release, featuring new badges, updated documentation links, and a news section highlighting recent features like SOP, TeamPipeline, and A2A protocol support.

(repo-wide) · high confidence

AgentScope v2.0.10dev: Major API overhaul with new configuration and factory functions

This release introduces significant breaking changes to the AgentScope core API. The \agentscope.init()\ function and the internal \\_config\ module have been removed, replacing the previous project/run initialization pattern with new factory functions \set\_id\_factory()\ and \set\_timestamp\_factory()\ exposed in the main package. The public API surface has been streamlined, removing exports for many legacy modules (e.g., \exception\, \module\, \message\, \model\, \tool\, \formatter\, \memory\, \agent\, \session\, \embedding\, \token\, \evaluate\, \pipeline\, \tracing\) while retaining core logging utilities. Additionally, the \setup\_logger\ function now strictly validates the logging level argument, raising a \ValueError\ for invalid inputs instead of accepting arbitrary strings. The package version has been bumped to 2.0.10dev.

src/agentscope · high confidence

Audio streaming support and configurable ID factories

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

Embedding models refactored with unified base class, model cards, and improved caching

The embedding module has been refactored to introduce a generic \EmbeddingModelBase\ that handles batching, concurrency, and retry logic, requiring subclasses to implement only the single-batch API call. Provider-specific implementations (DashScope, OpenAI, Gemini, Ollama) have been renamed and updated to use a new \CredentialBase\ for authentication and a new \EmbeddingModelCard\ for declarative model metadata (dimensions, input/output types, parameter schemas). The \FileEmbeddingCache\ now supports a \max\_file\_number=0\ to disable caching entirely and prevents caching individual files that exceed the \max\_cache\_size\ limit on their own, avoiding cache eviction of older entries for oversized vectors.

src/agentscope/embedding · high confidence

Introduce structured permission system with mode-based enforcement and safety controls

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

MCP client API refactored to unified MCPClient with configuration models

The AgentScope MCP module has been refactored to replace the previous fragmented client hierarchy (including StdIOStatefulClient, HttpStatefulClient, HttpStatelessClient, and their base classes) with a single unified MCPClient class. Configuration for MCP servers is now handled via dedicated Pydantic models: StdioMCPConfig for STDIO-based servers and HttpMCPConfig for HTTP-based servers. This change simplifies the public API by consolidating client management and configuration into a cleaner, more maintainable structure.

src/agentscope/mcp · high confidence

New middleware layer for session management, state updates, and team coordination

The application introduces a new middleware module that enhances agent behavior through several specialized components. InboxMiddleware now drains pending HintBlock payloads from the session inbox before each reasoning step, ensuring real-time updates reach the front-end. SOPStepSubmitMiddleware enforces standard operating procedures by requiring agents to explicitly submit handovers or verdicts, preventing indefinite hangs. StateChangeMiddleware detects modifications to task and permission contexts, pushing notifications to the session event stream for UI synchronization. TeamMemberLoopMiddleware ensures team members report back to the leader via the TeamSay tool, managing iteration limits and nudges. Finally, ToolOffloadMiddleware offloads long-running tool calls to background tasks, allowing the agent loop to remain responsive while waiting for results. Also in this area: 7 commits (4 fixes) fixing src/agentscope/app.

src/agentscope/app/middleware · medium confidence · unverified

Pipeline module refactored to support Team and Goal workflows

The pipeline module has been restructured to replace the previous sequential and message-hub abstractions with new team-based and goal-oriented execution models. The old \MsgHub\, \SequentialPipeline\, and \sequential\_pipeline\ components have been removed, and the public API now exposes \PipelineProtocol\, \GoalPipeline\, and \TeamPipeline\ (along with \TeamMember\). This change shifts the user-facing capability from simple linear agent chaining and manual message broadcasting to structured multi-agent collaboration patterns where agents can be organized into teams or assigned specific goals.

src/agentscope/pipeline · high confidence

Refactor message module to use specialized message classes and new block types

The message module has been restructured to replace the monolithic \Msg\ class with specialized subclasses (\UserMsg\, \AssistantMsg\, \SystemMsg\) and introduce a new \Usage\ class for tracking token consumption. The internal content block definitions have been renamed and expanded: \ToolUseBlock\ is now \ToolCallBlock\, and new types such as \HintBlock\, \DataBlock\, \ToolCallState\, and \ToolResultState\ have been added to the public API, while older block types like \ImageBlock\, \AudioBlock\, and \VideoBlock\ have been removed or consolidated into the new \ContentBlock\ structure.

src/agentscope/message · high confidence

Tool module refactored with new base classes, builtin tools, and task planning capabilities

The tool module has been significantly restructured to introduce a new \ToolBase\ interface and \ToolMiddlewareBase\ for execution control, replacing the previous \RegisteredToolFunction\ dataclass and async wrapper system. This refactor introduces a suite of new builtin tools including \AskUser\ for external user interaction, \Bash\, \PowerShell\, \Edit\, \Glob\, \Grep\, \Read\, and \Write\ for file and command operations, and a new set of task planning tools (\TaskCreate\, \TaskGet\, \TaskList\, \TaskUpdate\) for agent-driven workflow management. The \Toolkit\ class now manages tools via \ToolGroup\ objects, supporting activation/deactivation of tool sets, and integrates with MCP clients and agent skills. Additionally, the module now includes a permission system with dangerous file/command protection constants and middleware support for tool execution control.

src/agentscope/tool · high confidence

Fixes

3 commits (2 fixes) fixing src/agentscope/workspace/\_applecontainer

A fix in src/agentscope/workspace/\_applecontainer — 3 commits (2 fixs), 4 files: “fix(deps): upgrade certifi, pip, uv and node to drop distrusted CAs (\#3410)”; “feat(workspace): support apple container as workspace backend (\#2068)”; “fix(mcp): support mcp 2.x Python SDK, unpin mcp\<2.0.0 (\#2216)” (refs \#3410, \#2068, \#2216).

_src/agentscope/workspace/\applecontainer · medium confidence · unverified

5 commits (3 fixes) fixing src/agentscope/workspace/\_opensandbox

A fix in src/agentscope/workspace/\_opensandbox — 5 commits (3 fixs), 4 files: “fix(deps): upgrade certifi, pip, uv and node to drop distrusted CAs (\#3410)”; “feat(workspace): add OpenSandbox-based backend, workspace and manager (\#1953)”; “perf(prompt): improve instructions for workspace, context compression and the CreateTask tool (\#2111)”; and 2 more (refs \#3410, \#1953, \#2111, \#3062, \#2046).

_src/agentscope/workspace/\opensandbox · medium confidence · unverified

6 commits (4 fixes) fixing src/agentscope

A fix in src/agentscope — 6 commits (4 fixs), 116 files: “fix(app): keep failed steering items out of the queue pump (\#3747)”; “fix(workspace): accept workdirs under a filesystem-root basedir (\#3966)”; “feat(model): update model catalog and sort by release date (\#3997)”; and 3 more (refs \#3747, \#3966, \#3997, \#3838, \#2298, …). Also in this area: 40 commits (16 fixes) modifying src/agentscope/model.

_src/agentscope/model/\_minimax, src/agentscope/rag/\parser · medium confidence · unverified

6 commits (5 fixes) fixing src/agentscope/app/hub

A fix in src/agentscope/app/hub — 6 commits (5 fixs), 8 files: “fix(hub): parse BOM-prefixed skill frontmatter (\#3119)”; “fix(hub): reject timestamp skill versions carrying an invalid time (\#3873)”; “fix(hub): preserve GitHub MCP environment inputs (\#2230)”; and 3 more (refs \#3119, \#3873, \#2230, \#2197, \#2214, …).

src/agentscope/app/hub · medium confidence · unverified

Test coverage

Expanded test coverage for agent core, A2A integration, and application services

Added comprehensive test suites for the Agent class (basic configuration, runtime state injection, interruption handling, and structured output), the A2A agent adapter (unit tests and end-to-end harness), the AGUI protocol middleware, and application-level features including Standard Operating Procedures (SOP) and dedicated-deployment knowledge-base uploads via the message bus. Also in this area: 7 commits adding/updating tests in tests; Added tests for console renderer, formatters, MongoDB RAG, TUI, and workspace offloading; Updated tests for MCP 2.x SDK and partial function annotation handling; Added tests for agent interruption, ASR models, and TUI navigation; Added tests for embedding cache isolation, WAV header accuracy, stream cleanup, and nested media offloading.

tests · high confidence · unverified

Dependencies

Introduce web UI example and restructure Python dependencies

The repository now includes a new web UI example under \examples/web\_ui/\, featuring a frontend built with React, Tailwind CSS, and shadcn/ui, and a backend using Express, along with a \pnpm-lock.yaml\ to manage these JavaScript dependencies. In the core Python package (\pyproject.toml\), dependencies have been reorganized into granular optional extras (such as \model-gemini\, \storage-sql\, \workspace-docker\, \vdb-milvus\, and \memory-mem0\) to allow users to install only the components they need. Additionally, specific version constraints have been applied to ensure stability: \mcp\ is pinned below version 2.0.0, \ripgrep\ is restricted to the 14.x range to maintain cross-platform compatibility, and \mem0ai\ is pinned to version 2.0.0 or higher to align with the middleware's API requirements.

(dependencies) · high confidence

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

How this codebase got here

Score

  • CAI 67 → 62 (-4.8)
  • Rubric changed (rubric-2026.11.2 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 73 → 71 (-2.6)
  • Architecture 89 → 99 (+9.4)
  • Maturity 61 → 62 (+0.3)
  • Readiness 61 → 50 (-10.6)
  • Security 82 → 82 (+0.0)
  • Domain Modelling 100 → 100 (+0.0)
  • Performance 100 → 100 (+0.0)

Resolved (30)

  • AnthropicMultiAgentFormatter._format_agent_message (cyclomatic 16) (src/agentscope/formatter/_anthropic_formatter.py)
  • Duplicated block (10 lines × 2) (src/agentscope/app/storage/_sql/_alembic/versions/0004_sops.py)
  • Duplicated block (10 lines × 2) (src/agentscope/formatter/_xai_formatter.py)
  • Duplicated block (12–13 lines × 2) (.github/scripts/update_news.py)
  • Duplicated block (13–14 lines × 3) (src/agentscope/formatter/_xai_formatter.py)
  • Duplicated block (14–16 lines × 2) (src/agentscope/formatter/_xai_formatter.py)
  • Duplicated block (16 lines × 5) (src/agentscope/model/_dashscope/_model.py)
  • Duplicated block (17 lines × 4) (src/agentscope/model/_deepseek/_model.py)
  • Duplicated block (17–18 lines × 2) (src/agentscope/embedding/_embedding_base.py)
  • Duplicated block (23–24 lines × 2) (src/agentscope/formatter/_anthropic_formatter.py)
  • Duplicated block (27–40 lines × 2) (src/agentscope/embedding/_gemini/_model.py)
  • Duplicated block (2–7 lines × 4) (src/agentscope/app/storage/_sql/_alembic/versions/0002_mcps_skills.py)
  • Duplicated block (6 lines × 7) (src/agentscope/model/_dashscope/_model.py)
  • Duplicated block (6–8 lines × 6) (src/agentscope/model/_dashscope/_model.py)
  • Duplicated block (9 lines × 2) (src/agentscope/tts/_openai/_voice_cloning_client.py)
  • Hotspot: examples/web_ui/frontend/src/components/chat/ConfirmCard.tsx (examples/web_ui/frontend/src/components/chat/ConfirmCard.tsx)
  • Hotspot: src/agentscope/app/_tool/_agent_invite.py (src/agentscope/app/_tool/_agent_invite.py)
  • Hotspot: src/agentscope/app/middleware/_protocol/_agui.py (src/agentscope/app/middleware/_protocol/_agui.py)
  • Hotspot: src/agentscope/embedding/_file_cache.py (src/agentscope/embedding/_file_cache.py)
  • Hotspot: src/agentscope/tool/_toolkit.py (src/agentscope/tool/_toolkit.py)
  • …and 10 more

New (237)

  • ChatModelBase.call (cognitive 19) (src/agentscope/model/_base.py)
  • Critical CVE: [GHSA redacted] (examples/web_ui/pnpm-lock.yaml)
  • Critical CVE: [GHSA redacted] (examples/web_ui/pnpm-lock.yaml)
  • Critical CVE: [GHSA redacted] (examples/web_ui/pnpm-lock.yaml)
  • Critical vulnerability: [GHSA redacted] (examples/web_ui/pnpm-lock.yaml)
  • DeepSeekChatModel._parse_completion_response (cognitive 16) (src/agentscope/model/_deepseek/_model.py)
  • Duplicated block (11 lines × 2) (src/agentscope/app/_lifespan.py)
  • Duplicated block (11 lines × 4) (src/agentscope/model/_dashscope/_model.py)
  • Duplicated block (11–14 lines × 5) (src/agentscope/app/storage/_sql/_alembic/versions/0001_initial.py)
  • Duplicated block (13 lines × 2) (src/agentscope/model/_model_card.py)
  • Duplicated block (13 lines × 7) (src/agentscope/formatter/_dashscope_formatter.py)
  • Duplicated block (15 lines × 7) (src/agentscope/app/storage/_sql/_alembic/versions/0001_initial.py)
  • Duplicated block (17 lines × 5) (src/agentscope/model/_dashscope/_model.py)
  • Duplicated block (19 lines × 6) (src/agentscope/app/storage/_sql/_alembic/versions/0001_initial.py)
  • Duplicated block (21 lines × 4) (src/agentscope/formatter/_dashscope_formatter.py)
  • Duplicated block (21–22 lines × 2) (src/agentscope/formatter/_anthropic_formatter.py)
  • Duplicated block (21–25 lines × 2) (src/agentscope/app/_service/_chat.py)
  • Duplicated block (28–41 lines × 2) (src/agentscope/embedding/_gemini/_model.py)
  • Duplicated block (2–7 lines × 9) (src/agentscope/app/storage/_sql/_alembic/versions/0001_initial.py)
  • Duplicated block (5 lines × 2) (examples/realtime/local_mic.py)
  • …and 217 more

Changes since last survey

  • 84 commits — 14 feature/other, 70 fixes

By area

  • src/agentscope — 76 commits
  • examples/web_ui — 3 commits
  • (root) — 1 commit
  • examples/long_term_memory — 1 commit
  • scripts/model_examples — 1 commit
  • tests/background_task_endpoint_test.py — 1 commit
  • tests/builtin_grep_test.py — 1 commit

Notable commits

  • fix: fix(_utils): keep nested arguments that schema-guided repair drops (#2712)
  • fix: fix(agent): copy the context config before applying the deprecated buffer override (#3681)
  • fix: fix(app): allow WebRTC sessions to close during startup (#3190)
  • fix: fix(app): answer 422 when a session patch cannot be represented (#2745)
  • fix: fix(app): clean up background tasks after registration faults (#3387)
  • fix: fix(app): clean up source blob when document registration is cancelled (#3657)
  • fix: fix(app): fail wakeup dispatcher startup when subscription dies early (#3632)
  • fix: fix(app): ignore duplicate index tasks for ready documents (#3658)
  • fix: fix(app): keep failed steering items out of the queue pump (#3747)
  • fix: fix(app): reject unusable saved context ratios (#3357)
  • fix: fix(app): stop cancelled background renewal workers (#3968)
  • fix: fix(app): validate channel updates instead of copying nulls into storage (#2744)
  • fix: fix(asr): join recognised sentences without inventing spaces (#3762)
  • fix: fix(embedding): isolate OpenAI caches by API endpoint (#3142)
  • fix: fix(embedding): join sibling batches after failure (#3148)
  • fix: fix(embedding): make the file cache key independent of dict order (#2936)
  • fix: fix(embedding): reject nonpositive batch sizes (#3451)
  • fix: fix(formatter): keep media carried by assistant messages (#3892)
  • fix: fix(formatter): keep parallel Ollama tool calls on one assistant message (#3910)
  • fix: fix(formatter): preserve HintBlock in multi-agent requests (#3321)
  • …and 64 more

Architecture

  • Unchanged — 0 containers · 1 contexts · 0 edges

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

Survey your own repository

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.

About this page

  • The score is its most recent published measurement, taken on 16 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 27d8359300f16e44f9d4d7184620480427e067af — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.73+preprod-52de90b74216.