全部类All Classes

A stateful client-side adapter for an A2A 1.0 agent.

The A2A agent state.

An additional directory included in permission scope.

The agent class.

The settings that apply when the agent talks in text.

The agent data model.

The agentic memory, where the LLM decides when and what to save, together with an asyncio retrieval task in each reply. The memory is stored and retrieval based on the Markdown files.

What a step needs of whatever does its work or judges it.

The base class for all agent-oriented exceptions. These exceptions are expect to the captured and exposed to the agent during runtime, so that agents can handle the error appropriately during the runtime.

The agent ORM model.

The agent state that should be saved and loaded from storage.

A verifier that is itself an agent.

The middleware that converts the AgentScope events into AGUI protocol.

The Anthropic formatter class for chatbot scenario, where only a user and an agent are involved. We use the `role` field to identify different entities in the conversation.

The Anthropic chat model.

The Anthropic credential model.

Anthropic formatter for multi-agent conversations, where more than a user and an agent are involved.

Backend that delegates to a running Apple container via the ``container`` CLI.

Workspace backed by Apple's ``container`` CLI.

Manages :class:`AppleContainerWorkspace` instances with TTL-based caching.

A chunker based on an approximate token counting strategy.

The tool to collect information from the user via multiple-choice questions.

One question's answer, as the caller must return it.

What the caller must put in ``ToolResultBlock.metadata``.

What a caller asks for — the questions, and their options.

Base class for batch and realtime speech recognition models.

A model and its supported audio input types.

The text produced by an ASR model.

Minimal async-read protocol returned by :meth:`BlobStoreBase.open`.

Async SQLAlchemy-backed :class:`StorageBase` implementation.

A chunk of assistant speech.

A chunk of upstream user audio.

Filesystem + subprocess interface consumed by builtin tools.

The base64 source.

The bash tool.

The probability of a positive answer to a binary question.

Optional descriptions for the two outcomes of a binary question.

A question whose answer is a probability between zero and one.

Where a binding session is in its lifecycle.

What one call to a provider produced.

Abstract base class for blob storage backends.

Backend that executes commands inside Bubblewrap sandboxes.

Workspace backed by Linux Bubblewrap.

Manage Bubblewrap workspaces with TTL caching.

Abstract base for platform channels.

One routing rule: match an inbound event, then decide which agent handles it and how its session is grouped.

Platform capability declaration for gateway degradation decisions.

Builds and caches unconnected channel instances by channel id.

A user's decision on a pending tool-approval, delivered inbound.

A channel operation failed.

A normalised inbound message from an external platform.

Route inbound channel events into runs; resume on card clicks.

One node's report of a channel's status, stamped with the time it was written.

Reconciles this node's channel instances against storage.

A session an inbound platform message opened.

Persistent record for a channel instance — the single source of truth. Running adapter instances are a projection of this record.

Live connection status of a running channel adapter — owned and updated by the adapter itself; read by the dispatcher's status API.

The channel types a service allows, keyed by ``channel_type``.

Frontend-facing metadata for one channel type.

A chat's audience shape, used to tailor the agent's context.

The base class for chat models.

A named chat model and the criteria for selecting it.

The model configuration class.

The response of chat models.

Messages, composer and HITL controls without an Agent dependency.

The usage of a chat model API invocation.

The selected alternative and its probability distribution.

A question that selects one named alternative.

A final indexable chunk produced by a :class:`ChunkerBase`.

Abstract base class for chunkers.

Chunker configuration persisted alongside a knowledge base.

Base class for models that return typed probabilistic decisions.

The normalized response of a classifier model.

The usage of a classifier model API invocation.

A skill hub backed by the ClawHub registry.

One-collection-per-KB knowledge base manager.

Confirm result for a tool call.

Render :class:`~agentscope.event.AgentEvent` streams as line-based terminal output. Consume :meth:`Agent.reply_stream` and reset the renderer if the stream fails:

The context related configuration in AgentScope

One upstream control event.

The non-audio things a remote client can say.

The credential base class.

Base for a channel type's interactive credential flow.

Registry and deserializer for :class:`CredentialBase` subclasses.

The credential model used for storing credentials.

Generic extensible event for signals that don't fit a specific ``AgentEvent`` subtype.

The Qwen-Audio-Realtime API over WebSocket.

The DashScope formatter class for chatbot scenario (OpenAI-compatible format), where only a user and an agent are involved. We use the ``role`` field to identify different entities in the conversation.

The DashScope chat model (OpenAI-compatible implementation).

DashScope CosyVoice TTS model using the WebSocket SpeechSynthesizer.

The credential for DashScope API.

Unified DashScope embedding model.

DashScope formatter for multi-agent conversations (OpenAI-compatible format), where more than a user and an agent are involved.

The Qwen-Omni realtime API over WebSocket.

DashScope Realtime TTS model using the QwenTtsRealtime WebSocket API.

DashScope TTS model implementation using the MultiModalConversation API. For more details please see the `official document <https://bailian.console.aliyun.com/?tab=doc#/doc/?type=model&url=2879134>`_.

The data block for binary content (images, audio, video, etc.).

Data block delta event.

Data block end event.

Data block start event.

Backend that delegates to a running Daytona sandbox.

Workspace backed by a Daytona sandbox.

Manages :class:`DaytonaWorkspace` instances with TTL caching.

The DeepSeek formatter class for chatbot scenario, where only a user and an agent are involved. We use the `role` field to identify different entities in the conversation.

The DeepSeek chat model.

The DeepSeek credential model.

DeepSeek formatter for multi-agent conversations, where more than a user and an agent are involved.

Default policy that denies all cross-owner resource access.

The exception should be raised to the developers.

The dimension policy a manager exposes to the front-end.

Raised when a create-time embedding model violates the manager's dimension policy.

The kind of dimension policy the manager publishes.

DingTalk enterprise application robot channel.

One entry from :meth:`BackendBase.scandir`.

Discord platform channel.

Backend that delegates to a running Docker container.

Workspace backed by a Docker container.

Manages :class:`DockerWorkspace` instances with TTL-based caching.

A lightweight description of one source document inside a collection.

Backend that delegates to a running E2B sandbox.

Workspace backed by an E2B cloud sandbox.

Manages :class:`E2BWorkspace` instances with TTL-based caching.

The edit tool for performing exact string replacements in files.

Vector store backed by Elasticsearch dense-vector indexes.

Base class for embedding caches, which is responsible for storing and retrieving embeddings.

Base class for embedding models.

A card describing an embedding model's capabilities.

Configuration for constructing an embedding model from a credential.

The embedding response class.

The usage of an embedding model API invocation.

Structured, UI-facing description of a fatal reply error.

Classification of a fatal error that terminated a reply.

Base event class.

Event type enumeration.

Deprecated exceeded max iteration event, still emitted for backward compatibility without semantics; use ``ReplyEndEvent.finished_reason``.

Parser for Excel ``.xlsx`` / ``.xls`` files.

Result of running a shell command via a backend.

External execution result event.

Feishu platform channel (SDK long-connection mode).

The embedding cache class that stores each embeddings vector in binary files.

The finished reason of the model response.

The base class for formatters.

Adapter to convert a Python function to ToolProtocol.

The Gemini formatter class for chatbot scenario, where only a user and an agent are involved. We use the `role` field to identify different entities in the conversation.

The Google Gemini chat model.

The Google Gemini credential model.

Unified Google Gemini embedding model.

The multi-agent formatter for Google Gemini API, where more than a user and an agent are involved.

The Gemini Live API over WebSocket.

Gemini TTS model implementation using the ``generateContent`` API with ``responseModalities: ["AUDIO"]``. For more details please see the `official document <https://ai.google.dev/gemini-api/docs/speech-generation>`_.

An MCP hub backed by GitHub's MCP registry.

The glob tool for fast file pattern matching.

The goal pipeline class that run an executor and verifier in a loop until the goal is achieved.

The grep tool for searching file contents using ripgrep.

A block used to provide instructions or hints to the LLM during the reasoning-acting loop. When passed to the LLM API, the hint block is converted into a user message.

One-shot hint block event.

The HTTP MCP server configuration.

The identity and lifecycle shared by every hub implementation.

Raised when a hub's upstream registry returns a failure.

A verifier that asks a person and waits for the answer.

Parser for image files.

Drain the session's inbox and inject HintBlocks before each reasoning step.

The state injection related configuration in AgentScope.

In-memory implementation of :class:`MessageBus`.

The settled transcript of one user turn.

The provider could not transcribe one committed user turn.

User-editable invite settings for :class:`AgentData`.

Workspace isolation grain for :meth:`WorkspaceManagerBase.assign_workspace_id`.

A classifier backed by TypeSafe's Jev System One API.

Backend that delegates to a running Kubernetes Pod.

Workspace backed by a Kubernetes Pod with PVC persistence.

Manages :class:`K8sWorkspace` instances with TTL-based caching.

Runtime handle for one knowledge base.

The mutable payload of a knowledge base record.

Base class for knowledge base manager errors.

Abstract base for knowledge base managers.

Raised when a knowledge base record cannot be located.

A persisted knowledge base record.

The mutable payload of a knowledge document record.

A persisted knowledge document record.

Microphone in, speaker out, via ``sounddevice``.

Host-local :class:`BackendBase` implementation.

Store blobs as files beneath a configurable root directory.

The skill loader that loads skills from a local directory.

Local-directory workspace.

Manages LocalWorkspace instances with TTL-based lazy lifecycle.

A single MCP listing on a hub.

The unified MCP client in AgentScope.

The base class for MCP hub implementations.

One page of MCP cards.

One MCP a user has installed, at the user level rather than in any one workspace.

Adapter to convert an MCP tool to ToolProtocol.

AgentScope middleware that adds long-term memory backed by `mem0 <https://github.com/mem0ai/mem0>`_.

Abstract base class for live message transport.

Application-layer key conventions for the message bus.

Render authoritative message snapshots without consuming events.

Base class for all middleware implementations.

Vector store backend backed by Milvus Lite.

The MiniMax formatter for chatbot scenario.

Chat model for MiniMax's Anthropic-compatible API.

The MiniMax credential model.

The MiniMax formatter for multi-agent conversations.

Model call end event.

Model call start event.

The model card class.

The model related configuration.

The provider closed the session; the next user audio reconnects.

An error reported by the provider.

Common base class, for type hinting only.

Select the chat model of each reply by classifying the user input.

Vector store backend backed by `MongoDB Vector Search <https://www.mongodb.com/docs/atlas/atlas-vector-search/vector-search-overview/>`_.

The Moonshot AI formatter for chatbot scenario.

The Moonshot AI chat model.

The Moonshot AI credential model.

Formatter for the Moonshot AI API in multi-agent conversations.

The message class in AgentScope, responsible for information storage and transmission among different agents.

The offloader protocol.

The Ollama formatter class for chatbot scenario, where only a user and an agent are involved. We use the `role` field to identify different participants in the conversation.

The Ollama chat model.

The Ollama credential model (connection settings).

Ollama text embedding model.

Ollama formatter for multi-agent conversations, where more than a user and an agent are involved.

Batch speech recognition using OpenAI's Audio Transcriptions API.

The OpenAI formatter class for chatbot scenario, where only a user and an agent are involved. We use the `name` field in OpenAI API to identify different entities in the conversation.

The OpenAI Chat Completions model.

A classifier backed by the OpenAI Decisions API.

The OpenAI credential model.

OpenAI text embedding model.

OpenAI formatter for multi-agent conversations, where more than a user and an agent are involved.

The OpenAI Realtime API over WebSocket.

Formatter for the OpenAI Responses API in chat (single-agent) mode.

The OpenAI Responses API chat model.

Formatter for the OpenAI Responses API in multi-agent mode.

OpenAI TTS model implementation using the Audio Speech API. For more details please see the `official document <https://platform.openai.com/docs/guides/text-to-speech>`_.

Backend that delegates to a running OpenSandbox sandbox.

Workspace backed by an OpenSandbox sandbox.

Manages OpenSandbox workspaces with TTL-based caching.

A base class for tool parameters that remove the title field from the exported JSON schema.

Abstract base class for file-format parsers.

Parser for PDF files.

The behavior of permission.

Context for permission checking.

Decision result from permission checking.

Engine for checking and enforcing permission rules.

The mode of permission.

Permission rule for tool usage.

What a pipeline has to offer to go where an agent goes.

How much assistant audio actually left the speaker — the only sound basis for truncating a barge-in.

Execute PowerShell commands through a workspace backend.

Parser for PowerPoint ``.pptx`` files.

How many workspaces a manager keeps built ahead of demand.

Base middleware for converting AgentEvent stream to protocol format.

Vector store backend backed by `Qdrant <https://qdrant.tech>`_.

Middleware that integrates knowledge-base search into the agent.

The reasoning related configuration

The read tool.

A voice agent: a realtime model on one side, a transport on the other, and the turn-taking state machine in between.

A bidirectional realtime model: audio in, audio and tool calls out.

Describes one realtime model. Everything here varies with the model name; what the adapter implements lives on :class:`RealtimeModelBase`.

The realtime voice model configuration class.

Redis-backed implementation of :class:`MessageBus`.

The Redis storage implementation.

A refusal to answer one question, independent of other answers.

The registered tool function class, used to store the tool function and its registration information.

AgentScope middleware that adds long-term memory backed by `ReMe <https://github.com/agentscope-ai/ReMe>`_.

Middleware that enforces a weighted token budget per reply.

The context of the current agent reply.

Reply end event.

Deprecated alias of :class:`~agentscope.types.ReplyFinishedReason`, kept for backward compatibility. Value-compatible (both ``StrEnum``), so existing code that constructs or compares against it keeps working.

The reason a reply finished.

Reply start event.

Require external execution event.

Require user confirm event.

A meta tool allows agent to self-manage its equipped tools by activating or deactivating tool groups dynamically.

Base class for cross-owner resource access policies.

Resource kinds that can be resolved through the access policy.

Permission level granted for a referenced resource.

Reference to a resource owned by a specific user.

The provider started producing a reply.

The provider finished producing a reply.

Ordered routing rules for a channel.

Store blobs in an S3-compatible bucket.

The schedule configuration data.

A session a schedule opened on its due date.

Persisted schedule record.

The source that created the schedule.

An expected score and its probability distribution.

A question that assigns an expected score using an ordered rubric.

A single natural section produced by a :class:`ParserBase`.

Session configuration — set at creation, updatable via PATCH.

The provider session is gone; no further events will arrive.

Session-level knowledge base attachment.

How :attr:`SessionConfig.name` is maintained.

The session record.

How inbound messages are grouped into agent sessions.

Settings for a session a channel or SOP run opens for a user.

The kinds a session's source used to come in.

The agent skill class

A skill archive as the hub serves it.

A single skill listing on a hub.

The base class for skill hub implementations.

One page of skill cards.

The base class for skill loader.

One skill a user has installed, at the user level rather than in any one workspace — the skill counterpart of :class:`MCPRecord`.

A fixed sequence of milestones, each verified before the next.

Which agent does something, and in which conversation.

A procedure: its milestones, in order.

One run of a :class:`~._schema.SOP`, shaped like an agent.

A session a SOP run opened to hold one of its conversations.

Where a step, or a whole run, stands.

A stored procedure.

One run of a procedure.

One execution of a SOP, and the whole of what is worth saving.

The usual shape: someone does the work, someone else judges it.

One milestone: a name, what it must prove, and how many tries.

One milestone, as :class:`~agentscope.sop.SOPStep` runs it. An incompatible change becomes a new model discriminated on :attr:`version`.

What one step did in one run.

Require a step's agent to end its turn through its submit tool.

How many workspaces a run gets. Always minted for the run, never shared with another run.

The provider's own VAD detected the user stopping.

The provider's own VAD detected the user starting to speak.

A transition in voice activity, as detected by a VAD. Not an event class; the model-side ``SpeechStartedEvent`` is what a provider reports.

Detect state / team changes after each tool call and push notifications to the session event stream.

The STDIO MCP server configuration.

The storage abstract base class.

Raised when the model fails to produce a valid structured output, e.g. it does not call the structured-output tool, returns an empty response, or the returned arguments fail JSON/schema validation.

The structured response of chat models.

A reusable blueprint for sub-agent creation within a team.

The agent task.

The task context.

Create a task for the agent to perform.

Retrieve a task by its ID from the task list.

List tasks for the agent to perform.

The tool to update the agent task.

The team data model.

An entry in a team's member roster.

A member of the team: an existing agent plus the description the leader reads to decide when to assign a task to it.

The team member loop engineering middleware, that requires:

A session a team minted for one of its members.

A leader agent that assigns tasks to team members through tool calls.

The team ORM model.

The text block.

Text block delta event.

Text block end event.

Text block start event.

Parser for plain-text file formats.

The thinking block.

Thinking block delta event.

Thinking block end event.

Thinking block start event.

The tool protocol.

The tool call block.

Tool call delta event.

Tool call end event.

A complete tool call requested by the provider.

Tool call start event.

The state of the tool call.

The tool choice configuration.

The tool result chunk from a tool execution.

The tool context, e.g. tool cache

A group of related tools, mcps, and skills that an agent can activate, deactivate and use together. The tool group is activated by the meta tool `ResetTools`.

Exception raised when a tool group is inactive.

Exception raised when a tool calling was interrupted by the user.

Exception raised when tool arguments fail JSON decoding or repair.

Toolkit is the core module to register, manage and delete tool functions, MCP clients, Agent skills in AgentScope.

Base class for tool middlewares.

Exception raised when a tool was not found.

Middleware that offloads timed-out tool calls to background tasks.

The tool response from a tool execution, which contains the completed tool result (compared to ToolChunk).

The tool result block.

Tool result data delta event.

Tool result end event.

Tool result start event.

The tool result state.

Tool result text delta event.

Agent middleware that adds OpenTelemetry tracing to the reply, model-call and tool-execution lifecycles.

A chunk of the assistant's spoken text.

Connects a :class:`RealtimeAgent` to where audio comes from and goes to.

Synthesize speech for every text block produced during reasoning and inject the audio as ``DATA_BLOCK_*`` events into the stream.

Base class for TTS models in AgentScope.

The model card class for TTS models.

The TTS model configuration class.

The response of TTS models.

The usage of a TTS model API invocation.

Collapses the transcripts a provider emits into clean user turns.

The four timestamps of one turn, and the delays derived from them.

The credential used by TypeSafe System One models.

The URL source.

The token usage information of a message.

User confirm result event.

User-initiated interrupt targeting a parked reply.

A session a person opened themselves.

The user record.

Voice activity detection over a stream of PCM16 mono audio.

A single record to insert into a vector store collection.

A single result returned by a similarity search.

Abstract base class for vector store backends.

One settled verdict on one attempt.

The Volcengine Ark formatter for a chatbot conversation.

The Volcengine Ark chat model.

The Volcengine credential model.

Volcengine formatter for multi-agent conversations, where more than a user and an agent are involved.

Parser for Word ``.docx`` files.

Abstract base class for all workspace implementations.

Abstract base for workspace managers.

The write tool.

Formatter for the xAI chat model.

The xAI chat model using the official ``xai_sdk`` gRPC client.

The xAI credential model.

Formatter for the xAI chat model in multi-agent conversations.

The Grok voice speech-to-speech API over WebSocket.