Skip to content
CAI
Software that uses CAICheck a score

alibaba/nacos

43.3

Weak · 23 October 2026

385.5k

lines of production code

Java

with JavaScript, TypeScript

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

This system is a service discovery and configuration management platform that has been extended to function as an AI resource registry. It manages the lifecycle, discovery, and versioning of AI assets such as agents, skills, prompts, and MCP servers, while retaining core capabilities for service instance registration, health checks, and distributed locking. The platform supports pluggable authentication, external database persistence, and integration with service meshes like Istio and Kubernetes, alongside LLM-based copilot features.

How it got here

2018–2021 — Nacos 3.0 architecture and AI integration

76 changes.

This period focused on the foundational overhaul for Nacos 3.0, introducing a new gRPC-based remote communication protocol, modular authentication, and a plugin-based configuration architecture. It also established the core infrastructure for AI agent management, including the A2A protocol, CMDB integration, and Istio service mesh support, while modernizing the console and client SDKs.

2022–2025 — AI integration and plugin architecture

108 changes.

This period focused on introducing a comprehensive AI subsystem supporting Model Context Protocol (MCP) servers, agents, skills, and prompts, alongside a new distributed locking mechanism. The codebase underwent significant architectural refactoring to adopt a plugin-based design for authentication, data persistence, and configuration, while establishing a robust SPI framework for extensibility. Extensive test coverage was added to validate the new API models, remote communication protocols, and security configurations across the platform.

2026 — AI resource management and plugin infrastructure

86 changes.

This period focused on building a comprehensive AI resource management system, introducing support for Skills, Prompts, AgentSpecs, and Agents with full lifecycle governance, versioning, and search capabilities. The work established a robust plugin architecture for AI pipelines, storage, and imports, while expanding database support to include Oracle and PostgreSQL dialects. Additionally, it integrated OIDC authentication, a new console UI foundation, and a DNS server for service discovery.

Features

AI module integrates with the visibility plugin for resource access control

The AI module now supports the visibility plugin, allowing AI resources to be subject to visibility-based access control. This is implemented via the new AiVisibilityResourceLocator, which resolves AI resources for the visibility system, and the VisibilityAdvisorConverter interface along with its DefaultVisibilityAdvisorConverter implementation, which translates visibility query advisors into repository-level query conditions to enforce access policies.

ai/src/main/java/com/alibaba/nacos/ai/service/visibility · high confidence

AI resource import framework and download tracking

The AI module now supports tracking download counts for prompts and skills via new event classes (PromptDownloadEvent, SkillDownloadEvent) that feed into in-memory counters flushed to the database. Additionally, a new import infrastructure has been introduced, featuring an AiResourceOperatorRegistry to manage pluggable import operators for various AI resource types, laying the groundwork for importing external AI assets into Nacos.

nacos-ai · high confidence

AI resource trace logs are now routed through the trace event system

The Nacos AI trace plugin now includes a new subscriber, AiResourceTraceLogSubscriber, which captures AI resource trace events and writes them as structured JSON logs to the 'com.alibaba.nacos.ai.resource.trace' logger. This change ensures that AI-related operational data (such as resource type, ID, operation, and status) is consistently emitted via the standard trace event infrastructure, making it easier to monitor and analyze AI resource usage alongside other Nacos trace data.

plugin-default-impl/nacos-default-ai-trace-plugin · high confidence

Add A2A 1.0.0 model classes for agent cards and endpoints

The API module now includes a complete set of Java model classes to support the A2A 1.0.0 protocol, enabling users to define and manage agent capabilities, authentication, and endpoints. New types include AgentCard (with legacy field deprecation for A2A 1.0.0 compatibility), AgentEndpoint (supporting protocol version and tenant fields), AgentCapabilities (including extended agent card support), and supporting models like AgentAuthentication, AgentInterface, AgentSkill, and SecurityScheme. These models provide the data structures required for agent registration and interaction under the updated A2A specification.

api/src/main/java/com/alibaba/nacos/api/ai/model/a2a · high confidence

Add AI remote request type constants

The API module now includes \AiRemoteConstants.java\, defining static string constants for AI module request types, specifically \REGISTER\_ENDPOINT\, \BATCH\_REGISTER\_ENDPOINT\, and \DE\_REGISTER\_ENDPOINT\, along with a client UUID label. These constants standardize the request identifiers used in the AI remote communication layer.

api/src/main/java/com/alibaba/nacos/api/ai/remote · high confidence

Add AI resource import form classes

Added five new Java classes in the \ai/src/main/java/com/alibaba/nacos/ai/form/importer\ package to support the AI resource import feature: \AbstractAiResourceImportForm\ (base form with validation and parsing logic), \AiResourceImportExecuteForm\ (for executing imports with options like overwrite/skip invalid), \AiResourceImportSearchForm\ (for searching external import candidates), \AiResourceImportSourceListForm\ (for listing available import sources), and \AiResourceImportValidateForm\ (for validating selected items before execution). These forms handle input validation, JSON parsing of options/selected items, and conversion to corresponding request objects.

ai/src/main/java/com/alibaba/nacos/ai/form/importer · high confidence

Add AI resource version operation tracing

The AI module now emits trace events for AI resource version operations (such as create draft, publish, review, and import), which are logged in JSON format to support ELK/Loki integration for auditing and monitoring.

ai/src/main/java/com/alibaba/nacos/ai/service/trace · high confidence

Add Log4j2 logging adapter for Nacos clients

This change introduces a new Log4j2 adapter module that allows Nacos clients to use Log4j2 for logging. It includes the adapter implementation, a builder, a custom properties lookup plugin, and a default configuration file (nacos-log4j2.xml) that sets up rolling file appenders for config, remote, naming, and AI logs. The adapter uses a non-invasive approach to merge Nacos-specific loggers and appenders into the existing Log4j2 context, avoiding interference with user configurations and preventing class unloading issues during config reloads by using initialize() instead of start(). Tests are added to verify the adapter's behavior.

logger-adapter-impl/log4j2-adapter · high confidence

Add Logback 1.2.x logging adapter module

The \logger-adapter-impl/logback-adapter-12\ module now provides a dedicated logging adapter for applications using Logback versions 1.0.8 to 1.2.x. This includes the \LogbackNacosLoggingAdapter\ implementation, a custom \NacosClientPropertyAction\ to allow logback XML configurations to read properties from NacosClientProperties, and a default \nacos-logback12.xml\ configuration file. The adapter registers itself via \META-INF/services\ and ensures that Nacos configuration does not interfere with user-defined savepoints or URL scanning, while supporting log levels for config, naming, remote, and AI components.

logger-adapter-impl/logback-adapter-12 · high confidence

Add MCP registry protocol data models

The API module now includes a new set of Java classes in the \com.alibaba.nacos.api.ai.model.mcp.registry\ package that model the official MCP registry protocol. These classes—such as \McpRegistryServerDetail\, \McpRegistryServerList\, \Package\, and various transport types (\StdioTransport\, \SseTransport\, \StreamableHttpTransport\)—enable the system to serialize and deserialize registry server metadata, package configurations, and input arguments according to the standard schema.

api/src/main/java/com/alibaba/nacos/api/ai/model/mcp/registry · high confidence

Add OIDC Client Credentials authentication support for Nacos clients

Clients can now authenticate to Nacos using OpenID Connect (OIDC) via the OAuth2 Client Credentials flow. This new capability allows users to configure an OIDC issuer, client ID, and client secret through properties (e.g., \nacos.client.auth.oidc.issuer-uri\). The client automatically performs OIDC discovery to locate the token endpoint, fetches access tokens, and handles proactive token refresh before expiration. The obtained access token is then attached to requests via both the Authorization header and a query parameter, enabling secure access to Nacos resources using external identity providers.

client-basic/src/main/java/com/alibaba/nacos/client/auth/oidc · high confidence

Add RAD physical identity algorithms for Agent identifiers

Introduces the \rad-ascii-v1\ codec and \rad-service-name-v1\ composer to handle physical Agent identity encoding. The new \RadAsciiAgentIdCodec\ ensures Agent names stored in internal Config or Naming identifiers contain only safe ASCII characters (\\[A-Za-z0-9-\]\) by encoding non-safe characters as decimal escapes (e.g., \-123\), while leaving safe names unchanged. The \RadServiceNameComposer\ uses this codec to generate Naming service names by combining the encoded Agent ID with a protocol token, enabling safe internal representation of Agent identities.

ai/src/main/java/com/alibaba/nacos/ai/service/agent/identity · high confidence

Add default application configuration for the address module

The address module now includes an \application.properties\ file that sets the server port to 8080 and configures the servlet context path to \/\. This provides default runtime configuration for the service, allowing it to start with standard HTTP settings out of the box.

address/src/main/resources · high confidence

Add hardened external DNS forwarding capability

Nacos now includes a conditional DNS forwarder that routes queries outside the Nacos domain suffix to configured upstream DNS servers. This new component enforces security by rejecting internal suffix queries, implements a time-budgeted retry strategy across multiple upstreams to prevent blocking, and distinguishes upstream failures from negative responses to avoid poisoning client caches. It also supports periodic re-resolution of upstream server addresses to handle transient network changes.

nacos-dns · high confidence

Add pipeline query and admin API form models

This change introduces the request validation models for the new AI pipeline management APIs. Specifically, it adds PipelineDetailForm to handle detail queries by validating the required pipelineId parameter, and PipelineListForm to handle list queries by validating the required resourceType parameter while supporting optional filters for resourceName, namespaceId, and version. These forms ensure that incoming API requests for pipeline operations are properly validated before processing.

ai/src/main/java/com/alibaba/nacos/ai/form/pipeline · high confidence

Add remote ability models for client and server

Introduced new \ClientRemoteAbility\ and \ServerRemoteAbility\ classes in the API module to model remote connection capabilities. These serializable data structures expose properties such as \supportRemoteConnection\ and, for the server, \grpcReportEnabled\, allowing the system to communicate feature support between client and server components.

api/src/main/java/com/alibaba/nacos/api/remote/ability · high confidence

Add support for Alibaba Cloud RAM STS credentials and credential file watching

The client now supports authentication via Alibaba Cloud Resource Access Management (RAM) Security Token Service (STS) credentials. A new CredentialWatcher component monitors credential files (spas.properties) or environment variables for changes and automatically reloads credentials. The system can fetch temporary STS credentials from the Alibaba Cloud metadata service (http://100.100.100.200) or use static credentials provided via system properties. Additionally, the Credentials model now supports a tenantId field, and the credential loading logic distinguishes between standard and Docker-specific credential paths.

client-basic/src/main/java/com/alibaba/nacos/client/auth/ram/identify · high confidence

Added GraalVM native-image runtime hints for the Nacos Console

The Nacos Console now includes a new \NacosRuntimeHints\ class that registers reflection and serialization hints required for GraalVM native-image compilation. This change enables the console to function correctly when packaged as a native executable by explicitly exposing necessary Java, Hessian, Derby SQL, and JRaft classes to the native image builder, supporting the broader upgrade to Spring Boot 3 and GraalVM compatibility.

nacos-console · high confidence

Added InstanceBuilder for constructing service instances

A new builder class for the Instance model has been introduced in the naming API package. This allows users to construct Instance objects fluently by setting properties such as IP, port, weight, health status, and metadata, rather than relying on constructors or manual field assignment.

api/src/main/java/com/alibaba/nacos/api/naming/pojo/builder · high confidence

Added LocalFileMeta class for snapshot file metadata

A new LocalFileMeta class has been introduced in the consistency module to manage metadata for snapshot files. This class wraps a Java Properties object, allowing users to append key-value pairs and retrieve specific metadata entries associated with snapshot operations.

nacos-consistency · high confidence

Added Maven Wrapper configuration

The project now includes a Maven Wrapper (mvnw) configuration file (.mvn/wrapper/maven-wrapper.properties) that pins the build environment to Maven version 3.9.9. This ensures that all developers and CI systems use a consistent, reproducible version of Maven without requiring a pre-installed global Maven installation.

.mvn · high confidence

Added RdsGenerator for Istio VirtualService route configuration

The nacos-istio module now includes a new RdsGenerator class that generates Route Discovery Service (RDS) configurations for Envoy proxies. This component processes Istio VirtualService resources to build specific route configurations and provides default route configurations for bootstrap clusters, enabling Nacos to push dynamic routing rules to the Istio service mesh.

nacos-istio · high confidence

Added auto-generated gRPC stubs and protobuf classes for Nacos gRPC service

The api module now includes auto-generated Java classes for the Nacos gRPC service, providing the client and server stubs for unary and bidirectional streaming calls. This adds the \BiRequestStream\ service with a \requestBiStream\ method, alongside the existing \Request\ service, enabling clients to communicate with Nacos servers over gRPC using the \Payload\ and \Metadata\ message types defined in the generated protobuf code.

api/src/main/java/com/alibaba/nacos/api/grpc · high confidence

Added client and server config ability models for remote metrics support

New \ClientConfigAbility\ and \ServerConfigAbility\ classes have been introduced in the API module to represent configuration capabilities, specifically adding a \supportRemoteMetrics\ flag to enable remote metrics retrieval. Both classes implement \Serializable\ with explicit \serialVersionUID\ fields to ensure safe serialization, and \ServerConfigAbility\ includes \equals\ and \hashCode\ implementations based on the metrics support flag.

api/src/main/java/com/alibaba/nacos/api/config/ability · high confidence

AgentSpec API form models for versioning, tags, and visibility

The AgentSpec admin API now supports richer management capabilities through new request forms: users can update business tags and labels, manage visibility scope (public/private), and control online/offline status at both the AgentSpec and version levels. Versioning has shifted to semantic versioning with support for user-specified target versions and draft-based creation. The 'latest' label is now managed automatically by the server, and the legacy updateLatestLabel parameter is deprecated. List operations support search (accurate/blur) and ordering by download count.

ai/src/main/java/com/alibaba/nacos/ai/form/agentspecs/admin · high confidence

Centralized AI transport and capability constants

The new AiConstants class introduces a unified set of configuration keys and capability identifiers for the Nacos AI client. It defines transport modes (gRPC, HTTP, auto) and specific overrides for MCP, Agent, Skill, AgentSpec, and Prompt operations, alongside cache update intervals and publication limits. It also standardizes capability strings (radV1, mcp, skill, prompt, agentSpec) and A2A endpoint details, enabling consistent configuration and discovery across AI features.

api/src/main/java/com/alibaba/nacos/api/ai/constant · high confidence

Centralized HTTP client lifecycle management for AI runtime

The AI runtime now uses a dedicated \AiHttpClientLifecycleService\ to manage the creation, binding, renewal, and cleanup of shared HTTP clients for Agent and MCP adapters. This service centralizes identity and namespace binding, liveness renewal, and empty-client cleanup, ensuring that both modules share the same external Client ID without implementing competing lifecycle rules.

ai/src/main/java/com/alibaba/nacos/ai/service/runtime · high confidence

Client-side caching and change notification for AI resources

The Nacos client now maintains local caches for AI resources (agent cards, agent specs, MCP servers, prompts, and skills) with automatic polling and change detection. When a subscribed resource changes, the client publishes specific events (e.g., AgentCardChangedEvent, SkillChangedEvent) that are dispatched to registered listeners via the new AiChangeNotifier. This allows applications to react to updates without manual polling, while the cache holders manage the lifecycle of background update tasks and handle transport-specific queries (HTTP/gRPC) for the respective resource types.

nacos-client · high confidence

Client-side skill query form with MD5-based caching support

A new SkillQueryForm class has been added to the AI skills client package to handle skill retrieval requests. This form allows clients to query skills by namespace, name, version, and label, and introduces an optional MD5 field to support HTTP 304 Not Modified responses, enabling efficient local caching of skill content.

ai/src/main/java/com/alibaba/nacos/ai/form/skills/client · high confidence

Default Nacos control plugin for connection and TPS limits

The \nacos-default-control-plugin\ module now provides the default implementation for Nacos's connection and TPS (transactions per second) control features. It introduces \NacosConnectionControlManager\ to enforce total connection limits (skipping enforcement when the limit is negative) and \NacosTpsControlManager\ to manage TPS barriers and report metrics. The \NacosControlManagerBuilder\ registers these components via the \ControlManagerBuilder\ SPI, making the default control logic available to the Nacos server out of the box.

plugin-default-impl/nacos-default-control-plugin · high confidence

Derby database plugin adds AI resource support and fixes pagination

The Derby datasource plugin now includes mappers for AI resources (AiResourceMapperByDerby and AiResourceVersionMapperByDerby), enabling storage and retrieval of AI-related configuration data. Additionally, pagination queries across config and history tables have been corrected to use standard SQL syntax (OFFSET/FETCH NEXT), and the LIKE escape clause is now explicitly defined for Derby to ensure consistent search behavior.

plugin-default-impl/nacos-default-datasource-plugin/nacos-datasource-plugin-derby · high confidence

Deterministic runtime endpoint revision generation

The fingerprint module now includes a new \RuntimeEndpointRevision\ class that generates a stable, opaque revision token for a set of runtime endpoints. By canonicalizing endpoint properties (URI, transport, priority, weight, metadata, health status, and version bindings) and applying a MurmurHash3 (x64-128) algorithm, the system produces a consistent identifier for the current endpoint configuration. This enables reliable change detection and versioning for agent endpoint discovery, ensuring that revisions are deterministic regardless of input ordering or minor formatting differences.

ai/src/main/java/com/alibaba/nacos/ai/service/agent/fingerprint · high confidence

HTTP 304 support for skill listeners to reduce bandwidth

Clients can now use MD5-based conditional requests to query skills, allowing the server to return HTTP 304 Not Modified when the client's local cache is already up to date. This change introduces a new \SkillClientOperationService\ that resolves the target version via a lightweight \SkillIndexManifest\ and compares the client-supplied MD5 against the stored content digest. If the MD5s match, the server short-circuits without loading the full skill payload. For legacy versions missing the stored MD5, the system automatically back-fills the digest on the first query to ensure future listeners benefit from the optimization.

ai/src/main/java/com/alibaba/nacos/ai/service/skills · high confidence

The shared AI resource search now includes Agents and AgentSpecs. New type handlers (AgentAiResourceSearchTypeHandler, AgentSpecAiResourceSearchTypeHandler) and index projectors (AgentSearchIndexProjector, AgentSpecSearchIndexProjector) build deterministic search documents for the canonical Agent directory and latest online AgentSpec versions, capturing metadata, capabilities, protocols, and representative queries. Source content for Skills and Prompts is loaded via AiResourceIndexContentLoaderImpl to enrich indexing, and an optional AI enhancement service (AiResourceIndexEnhancementService) generates bilingual retrieval text using a built-in prompt (AiResourceIndexEnhancementPrompt) to improve hybrid keyword/vector recall.

ai/src/main/java/com/alibaba/nacos/ai/service/search · high confidence

Initial gRPC API definition for Nacos

A new gRPC service definition file (\nacos\_grpc\_service.proto\) has been added to the API module, establishing the contract for Nacos gRPC communication. This definition introduces a \Request\ service with a unary \request\ method and a \BiRequestStream\ service supporting bidirectional streaming via \requestBiStream\. Both services utilize a \Payload\ message structure that encapsulates request metadata (including client IP and headers) and a generic body, enabling clients to interact with the Nacos server over gRPC.

api/src/main/proto · high confidence

Introduce AI config key encoding and client liveness model

Added the ClientLivenessInfo model to expose HTTP publisher liveness intervals (heartbeat, unhealthy, and expire timeouts) via the Agent Client API. Introduced NacosAiConfigKeyCodec to ensure AI resource storage keys are Nacos-safe by encoding dataId and group segments into ASCII-safe characters, using hex encoding for invalid inputs and SHA-256 hashing for segments exceeding Nacos Config length limits (255 chars for dataId, 128 for group).

api/src/main/java/com/alibaba/nacos/api/ai/model · high confidence

Introduce AI publish pipeline execution framework

Added the core execution engine for the AI publish pipeline, including the PublishPipelineExecutor which asynchronously runs pipeline nodes in serial order, persists execution state via a repository, and notifies callers via a callback. The PublishPipelineManager handles loading and caching PublishPipelineService implementations through Java SPI, filtering them by resource type and plugin state, and sorting by preference order. A PipelineCallback interface defines the completion notification contract for pipeline execution results.

ai/src/main/java/com/alibaba/nacos/ai/pipeline · high confidence

Introduce AI resource and version data models

Added the \AiResource\ and \AiResourceVersion\ entity classes to define the data structure for AI resources and their versions. \AiResource\ extends \VisibilityResource\ to support visibility controls and includes fields for metadata such as name, type, description, status, namespace, business tags, source (\from\), version info, and download count. \AiResourceVersion\ tracks specific version details including author, storage location, and publish pipeline information, also including a download count.

ai/src/main/java/com/alibaba/nacos/ai/model · high confidence

Introduce AI resource constants, storage utilities, and event infrastructure

This change establishes the foundational constants, storage abstractions, and eventing mechanisms for the AI resource module. It adds shared constants for resource types (Skill, Prompt, MCP) and version statuses (draft, online, reviewing, reviewed, offline) in AiResourceConstants, alongside server configuration keys and API paths in Constants. It introduces an event system (AiResourceChangedEvent) to broadcast logical resource mutations (create, update, delete) for invalidation purposes, and provides storage utilities (AiResourceStorageUtils) and an SPI builder (NacosConfigAiResourceStorageBuilder) to resolve and instantiate the Nacos Config-based storage provider. Additionally, it adds an HTTP resource parser for identity-only AI capabilities and constants for MCP server validation.

ai/src/main/java/com/alibaba/nacos/ai/constant · high confidence

Introduce AI resource import manager with plugin-based source orchestration

Added the \AiResourceImportManager\ service to orchestrate AI resource import workflows, including listing enabled sources, searching external candidates, validating selected items, and executing imports. This manager relies on \AiResourceImportPluginManager\ to discover and route requests to specific import plugins via SPI, and \AiResourceImportSecurityGuard\ to enforce artifact type and size limits before validation or execution, ensuring that imported resources are validated against configured policies and security boundaries.

ai/src/main/java/com/alibaba/nacos/ai/importer/manager · high confidence

Introduce AgentSpec management service with HTTP 304 caching support

Added the AgentSpec operation service and its implementation to manage the full lifecycle of AgentSpecs (upload, bootstrap, draft/review/publish workflow, querying, and deletion). The service introduces an HTTP 304 Not Modified response mechanism for AgentSpec queries, allowing clients to cache AgentSpec content and avoid unnecessary data transfer when the content has not changed. It also supports version governance, metadata-only queries to skip resource file I/O, and visibility-based access control.

ai/src/main/java/com/alibaba/nacos/ai/service/agentspecs · high confidence

Introduce AgentSpec model classes for AI agent management

This change adds a new set of API model classes in the \com.alibaba.nacos.api.ai.model.agentspecs\ package to support the management of AI agent specifications (workers). The new models include \AgentSpec\ for full agent details (including business tags and resource maps), \AgentSpecBase\ and \AgentSpecBasicInfo\ for common and list-view fields, \AgentSpecSummary\ for admin list responses (adding governance metadata like owner, scope, and versioning state), and \AgentSpecMeta\ for admin details with version summaries. Additionally, \AgentSpecResource\ replaces the previous \Service\ class to represent individual files within an agent package, and \AgentSpecUtils\ provides helper methods for generating resource IDs and Nacos config group names using the new \NacosAiConfigKeyCodec\.

api/src/main/java/com/alibaba/nacos/api/ai/model/agentspecs · high confidence

Introduce Alibaba Cloud RAM authentication support for Nacos clients

The client-basic module now includes a new Alibaba Cloud RAM authentication implementation (RamClientAuthServiceImpl) that allows Nacos clients to authenticate using Alibaba Cloud RAM credentials (AccessKey/SecretKey or STS tokens). This change adds the core authentication service, context management, and specific resource injectors for Naming, Config, Lock, and AI modules, enabling users to secure their Nacos interactions via Alibaba Cloud RAM identity.

client-basic/src/main/java/com/alibaba/nacos/client/auth/ram, client-basic/src/main/java/com/alibaba/nacos/client/auth/ram/injector · high confidence

Introduce CMDB POJOs for entity and label management

This change adds new data models to the Nacos API to support integration with third-party CMDBs, enabling service providers to be filtered by labels. The diff introduces \EntityEvent\ and \Label\ classes, and repurposes existing client-side classes (\AppenderInfo\, \IConfigRequest\, \ILoggerFactory\) into \Entity\, \EntityEventType\, and \PreservedEntityTypes\ respectively. These classes define the structure for CMDB entities (including type, name, and labels), event types (add/update, remove), and preserved entity types (IP, service), forming the foundational API layer for the new CMDB module.

api/src/main/java/com/alibaba/nacos/api/cmdb/pojo · high confidence

Introduce CMDB module with label query API and configuration options

This change introduces the initial CMDB (Configuration Management Database) module, adding a new REST controller at /nacos/v1/cmdb/ops/label that allows users to query labels for specific service entries. It also adds configuration support via SwitchAndOptions, exposing properties such as nacos.cmdb.dumpTaskInterval, nacos.cmdb.eventTaskInterval, nacos.cmdb.labelTaskInterval, and nacos.cmdb.loadDataAtStart to control module behavior.

cmdb/src/main/java/com/alibaba/nacos/cmdb/controllers · high confidence

Introduce CMDB utility classes for execution, logging, and constants

Added three new utility classes to the CMDB module: CmdbExecutor provides a shared scheduled executor service for background tasks, Loggers defines a main logger for CMDB operations, and UtilsAndCommons exposes the CMDB API context path (/v1/cmdb).

cmdb/src/main/java/com/alibaba/nacos/cmdb/utils · high confidence

Introduce Config Change Plugin framework and SPI

This change adds the \plugin/config\ module, establishing a new SPI-based plugin system for intercepting configuration change events. It introduces the \ConfigChangePluginService\ interface, the \ConfigChangePluginManager\ for loading and ordering plugins via SPI, and the \ConfigChangePluginProvider\ to expose the plugin registry. The framework defines pointcut types (e.g., \PUBLISH\_BY\_HTTP\, \REMOVE\_BY\_RPC\) and execution types (\EXECUTE\_BEFORE\_TYPE\, \EXECUTE\_AFTER\TYPE\) to allow plugins to hook into config operations. It also includes a \ConfigChangePluginTypePolicy\ that manages plugin enablement, supporting both legacy properties (\nacos.core.config.plugin.\\) and standard properties (\nacos.plugin.config-change.\*\), with the standard taking precedence. The \ConfigChangeRequest\ and \ConfigChangeResponse\ models facilitate data exchange between the core and plugins.

plugin/config · high confidence

Introduce Istio module for service mesh integration

Nacos now includes a new Istio module that enables service mesh capabilities by exposing Nacos service registry data to Istio control planes. This change adds the \IstioApp\ entry point and a suite of components including \NacosMcpService\ and \NacosXdsService\ to support the Istio MCP and XDS protocols. The module listens for Nacos naming events via \NacosServiceInfoResourceWatcher\ and processes Istio configuration changes through \IstioConfigProcessor\, pushing updates to connected proxies. It is controlled by the \nacos.extension.naming.istio.enabled\ property and requires the naming function mode.

istio · high confidence

Introduce K8s Sync module to synchronize Kubernetes services and endpoints to Nacos

The k8s-sync module is now available to automatically keep Nacos service registry in sync with Kubernetes services and endpoints. Users can enable this feature by setting nacos.k8s.sync.enabled=true. The module supports both in-cluster and outside-cluster configurations via nacos.k8s.sync.outsideCluster and nacos.k8s.sync.kubeConfig. It starts after the application is ready and listens for changes in Kubernetes services and endpoints, registering or updating them in Nacos accordingly. The module is disabled by default and respects the function mode, only starting in naming or microservice modes.

k8s-sync · high confidence

Introduce MCP model storage classes

Added new data model classes in the MCP AI module to support resource mapping and storage: McpResourceExt for typed schema-versioned content, McpServerIndexData for server indexing, McpServerStorageInfo for server storage details, McpVersionStorageDescriptor for versioned storage descriptors, and UrlPageResult for paginated server listings.

ai/src/main/java/com/alibaba/nacos/ai/model/mcp · high confidence

Introduce Nacos Copilot with AI-powered skill and prompt management

Adds a new Copilot module that enables AI-assisted management of Agent Skills and prompts within the Nacos console. This feature introduces a configurable backend (controlled by the \nacos.copilot.enabled\ property) that integrates with the AgentScope framework and DashScope models to provide capabilities such as generating new skills, optimizing existing skill definitions, and debugging or optimizing prompt templates. Configuration for the AI service (API keys, model selection, and Studio integration) is managed via Nacos Config, and the module exposes its enabled state to the console UI for conditional rendering.

copilot · high confidence

Introduce Nacos Maintainer Client SDK for AI and Configuration Management

The maintainer-client module now provides a dedicated SDK for programmatic administration of Nacos resources. This release adds the NacosMaintainerFactory and DefaultServerListManager for connection handling, alongside comprehensive service interfaces and implementations for AI resources (A2aMaintainerService, AgentMaintainerService, AgentSpecMaintainerService) and configuration management (ConfigMaintainerService). Users can now register, update, and manage agents, agent specs, and configuration data via a structured client API.

maintainer-client · high confidence

Introduce NacosApiException with v2.0 error context

The API module now includes a new NacosApiException class that extends NacosException to support API v2.0 error handling. This exception carries additional fields (detailErrCode and errAbstract) to provide structured error codes and abstract messages specific to the v2.0 API, allowing clients to distinguish between standard Nacos errors and those specific to the newer API version.

api/src/main/java/com/alibaba/nacos/api/exception/api · high confidence

Introduce NacosConfigConverter interface for configuration type conversion

A new NacosConfigConverter interface has been added to the Nacos API module, providing a standardized mechanism to convert raw configuration strings into specific target types. This interface defines two methods: canConvert, which checks if a conversion to a given target type is supported, and convert, which performs the actual transformation from a String config to the desired object type. This enables users and internal components to safely and flexibly handle configuration data across different data types.

api/src/main/java/com/alibaba/nacos/api/config/convert · high confidence

Introduce OIDC authentication plugin for Nacos

This change adds the \nacos-oidc-auth-plugin\ module, providing a new authentication mechanism based on OpenID Connect. The plugin implements the \AuthPluginService\ interface to handle identity validation via JWT tokens (extracted from Authorization headers or parameters) and delegates authorization decisions to an external IdP endpoint. It supports the Authorization Code flow for user login, including secure state handling and nonce validation, and allows configuration of issuer URI, client credentials, token claims, and admin role mapping.

plugin-default-impl/nacos-oidc-auth-plugin · high confidence

Introduce Prometheus Service Discovery API endpoints

Added a new Prometheus-compatible HTTP Service Discovery API under the \/prometheus\ path, allowing Prometheus to scrape Nacos service instances. The implementation includes a \PrometheusController\ exposing endpoints for all instances, instances by namespace, and instances by specific service, along with a \PrometheusUtils\ helper that formats instance metadata as Prometheus labels (converting dots and hyphens to underscores). Security is handled via \PrometheusSecurityConfiguration\ (permitting all access when no auth plugin is present) and \PrometheusAuthFilter\ (enabling basic authentication when Nacos auth is enabled), with a dedicated \PrometheusApiExceptionHandler\ for error responses. Unit tests verify the controller logic, exception handling, and filter registration.

prometheus · high confidence

Introduce Prompt API model classes for versioned AI prompt management

This change adds the core data models for the new Prompt API in the Nacos AI module. The \Prompt\ class defines the main entity with fields for key, version, template, MD5 hash, and variable definitions. Supporting classes include \PromptVariable\ for template placeholders with optional defaults, \PromptMetaSummary\ and \PromptMetaInfo\ for listing and metadata (including bizTags, labels, and version details), and \PromptVersionSummary\ and \PromptVersionInfo\ for version-specific details like status, commit messages, and download counts. \PromptUtils\ provides helper methods for constructing Nacos Config group names for versioned prompt storage.

api/src/main/java/com/alibaba/nacos/api/ai/model/prompt · high confidence

Introduce RAM authentication utilities and refactor SpasAdapter

The client-basic module now includes new utility classes for RAM (Resource Access Management) authentication: CalculateV4SigningKeyUtil for generating V4 signature keys, RamUtil for retrieving access and secret keys with fallback to RAM info parsing, and SignUtil for HMAC-SHA1 signing. Additionally, SpasAdapter has been moved from the client module to client-basic and refactored to return Map-based headers instead of List-based headers, aligning with the new credential service integration.

client-basic/src/main/java/com/alibaba/nacos/client/auth/ram/utils · high confidence

Introduce SPI-based trace plugin discovery and management

The trace module now uses a Service Provider Interface (SPI) mechanism to discover and manage trace event subscribers. A new \NacosTraceSubscriber\ interface defines the contract for handling trace events, and the \NacosTracePluginManager\ automatically loads implementations via \NacosServiceLoader\. A \TracePluginProvider\ exposes these subscribers through the standard plugin API, allowing users to register custom trace handlers that receive \TraceEvent\ callbacks. The implementation includes logic to handle duplicate subscriber names by keeping the first registered instance and supports optional filtering of enabled plugins via a state checker.

plugin/trace · high confidence

Introduce ability negotiation constants for server and client capabilities

The API module now includes a structured set of constants to define and negotiate capabilities between the Nacos server and SDK clients. New enums in the \com.alibaba.nacos.api.ability.constant\ package define \AbilityMode\ (SERVER, SDK\_CLIENT, CLUSTER\_CLIENT) and \AbilityStatus\ (SUPPORTED, NOT\_SUPPORTED, UNKNOWN) to manage feature support states. The \AbilityKey\ enum lists specific capabilities such as gRPC persistent instance registration, fuzzy watch, distributed locks, MCP and Agent registry support, and RAD v1 contracts, allowing clients to check server support before attempting operations.

api/src/main/java/com/alibaba/nacos/api/ability/constant · high confidence

Introduce base datasource plugin with dialect-driven SQL generation

This change adds the base implementation for the Nacos datasource plugin, introducing abstract mapper classes (such as BaseConfigInfoMapper and BaseConfigTagsRelationMapper) that delegate SQL generation to a pluggable DatabaseDialect. This allows the system to generate database-specific SQL (e.g., for pagination and functions) dynamically based on the configured dialect, rather than using hardcoded SQL strings. The update also includes a new AbstractDatabaseDialect with default implementations for common database operations and a TrustedPostgresqFunctionEnum to validate SQL functions and mitigate injection risks. Additionally, a comprehensive set of unit tests is added to verify the correct behavior of these mappers and dialects.

plugin-default-impl/nacos-default-datasource-plugin/nacos-datasource-plugin-base · high confidence

Introduce built-in AI resource importers with hardened network policies

The \nacos-default-ai-importer-plugin\ now provides default implementations for importing AI resources, including MCP Registry servers and Skill well-known endpoints. These importers use a shared HTTP client that enforces strict network security by default: HTTP is blocked, private/local network targets are blocked, and response sizes are capped. Users can configure the source endpoint, enable HTTP or private network access, and set limits for item counts and artifact sizes. Legacy configuration prefixes are deprecated in favor of the new \nacos.plugin.ai-resource-import.\*\ namespace.

plugin-default-impl/nacos-default-ai-importer-plugin · high confidence

Introduce custom environment plugin SPI for extensible property handling

This change adds a new SPI-based plugin system for custom environment properties, allowing users to extend Nacos's environment configuration via the \nacos.custom.environment.enabled\ flag. It introduces the \CustomEnvironmentPluginService\ interface (with methods for property keys, custom values, and ordering), a \CustomEnvironmentPluginManager\ to load and execute these services, and an \EnvironmentPluginProvider\ to discover implementations via Java SPI. The manager filters out invalid plugins (e.g., blank names), sorts them by priority, and applies their custom value transformations to the source properties, while also deprecating the legacy \join()\ method in favor of the new pre-context initialization flow.

plugin/environment · high confidence

Introduce distributed lock API with reentrant support and wait-queue notifications

The \api/src/main/java/com/alibaba/nacos/api/lock\ package now exposes the core interfaces and models for Nacos distributed locking. Users can acquire and release locks via the new \LockService\ (created through \NacosLockFactory\) and define lock behavior using \LockInstance\ with \REENTRANT\ or \NON\_REENTRANT\ types. The API supports structured results via \LockResult\, which provides reentrant counts and wait-queue positions, and introduces server-push notifications (\LockNotificationRequest\) to alert clients when a lock becomes available or a wait entry times out.

api/src/main/java/com/alibaba/nacos/api/lock · high confidence

Introduce distributed reentrant and non-reentrant locks

The lock module now supports distributed locks with reentrant and non-reentrant behaviors, replacing the legacy non-reentrant mutex lock. This change introduces a new \LockManager\ and \NacosLockManager\ that use an SPI-based \LockFactory\ to create \AbstractAtomicLock\ instances. Users can now acquire locks that track ownership and reentrant counts (\ReentrantAtomicLock\) or strictly prevent re-entry (\NonReentrantAtomicLock\). The system also includes a wait queue for lock acquisition, automatic expiration with configurable default and maximum times, and a snapshot persistence mechanism to maintain lock state across server restarts. Metrics are exposed for lock operations, and a legacy migration path ensures backward compatibility with existing \MutexAtomicLock\ snapshots.

lock · high confidence

Introduce legacy console-ui build system and UI components

The legacy Nacos console frontend is now built with React and Webpack 4, featuring a dedicated build configuration (Babel, ESLint, Prettier) and a context-path-aware deployment structure. This update adds several UI components for configuration management, including batch operations, cloning, deletion, and diff editing, along with a copy-to-clipboard utility that handles secure context requirements.

console-ui · high confidence

Introduce naming module readiness check and server status management

The naming module now includes a dedicated readiness check service that verifies the server is fully initialized and ready to handle requests before accepting traffic. This is supported by a new ServerStatus enum and manager that track the server's operational state (UP, DOWN, STARTING, etc.) and integrate with the cluster health system. Additionally, a new ability initializer enables JRaft support for the naming module, and a package scan filter ensures the naming module only loads when the appropriate function mode (naming, microservice, or AI) is active.

naming · high confidence

Introduce new RPC response models for connection and health checks

The \api/src/main/java/com/alibaba/nacos/api/remote/response\ package now includes new response types to support the remote RPC channel: \Response\ (base model with result codes and error info), \ResponseCode\ (enum for success/fail), \ErrorResponse\ (for building error responses from exceptions), \ServerCheckResponse\ (for server health checks with connection ID and ability negotiation support), \ClientDetectionResponse\ (for client active detection), \ConnectResetResponse\ (for connection reset events), \ServerLoaderInfoResponse\ (for server load metrics), \ServerReloadResponse\ (for server reload status), and \SetupAckResponse\ (for connection setup acknowledgment). These classes provide the structured data models required for the new RPC-based communication protocol.

api/src/main/java/com/alibaba/nacos/api/remote/response · high confidence

Introduce new Selector API for service filtering

The \api/src/main/java/com/alibaba/nacos/api/selector\ package now provides a new extensible selector framework for filtering service instances. This includes a generic \Selector\ interface and an \AbstractSelector\ base class that uses Jackson for JSON serialization (annotated with \@JsonTypeInfo\), replacing the previous client-side logging utilities. The package introduces \ExpressionSelector\ for label-based filtering, \NoneSelector\ as a default no-op selector, and \AbstractCmdbSelector\ to support CMDB context-based selection. A \SelectorFactory\ is provided to register and deserialize these subtypes, and \SelectorType\ defines the available filtering modes (none, label, cluster, health, enable).

api/src/main/java/com/alibaba/nacos/api/selector · high confidence

Introduce new auth plugin API and SPI contracts

The \plugin/auth\ module now exposes a new set of API and SPI classes that define the contract for authentication plugins. This includes \AuthResult\ for standardized success/failure responses, \IdentityContext\ and \LoginIdentityContext\ for managing user identity data, and \Resource\/\Permission\ for authorization checks. It also introduces the \AuthPluginService\ interface and \AuthPluginManager\ for server-side plugin discovery, alongside \ClientAuthService\ and \ClientAuthPluginManager\ for client-side authentication. These changes provide the foundational interfaces and data structures required for the new plugin-based authentication architecture.

plugin/auth · high confidence

Introduce new consistency protocol abstraction layer

The consistency module now exposes a new set of core interfaces and implementations to standardize how data consistency is handled across the system. This includes the \ConsistencyProtocol\ interface for initializing and managing cluster state (read/write operations, member changes), along with specialized \APProtocol\ and \CPProtocol\ interfaces for availability and consistency guarantees respectively. The change introduces a pluggable serialization framework via \SerializeFactory\ and \Serializer\, defaulting to Hessian but allowing for alternatives like Jackson, and adds a \ProtocolMetaData\ system for managing cluster metadata with observer-based change notifications. Additionally, new Protobuf definitions (\WriteRequest\, \ReadRequest\, \Response\) and a \ProtoMessageUtil\ for parsing prefixed request types replace older legacy structures, providing a cleaner, type-safe foundation for internal cluster communication.

consistency · high confidence

Introduce next-generation Nacos Console UI with security and build improvements

The console-ui-next directory now contains the foundation for a new console frontend, including a .gitignore, a components.json for Shadcn/ui, an ESLint configuration, and an index.html entry point. A .npmrc file is added to enforce a 3-day minimum release age for installed packages, reducing supply chain risks. The build system includes a copyFile.cjs script to deploy artifacts to the backend static resources directory and a Vitest test (monaco-dompurify.test.ts) that verifies the build correctly bundles the patched DOMPurify package instead of Monaco's embedded copy, addressing a known security advisory.

console-ui-next · high confidence

Introduce persistence layer for AI resources and versions

This change adds the repository implementation for AI resources and their versions, enabling Nacos to store and retrieve AI assets (such as skills and agent specs) in external databases (MySQL, PostgreSQL, etc.) or the embedded Derby store. It introduces \AiResourcePersistService\ and \AiResourceVersionPersistService\ along with their JDBC and embedded implementations, row mappers, and a generic \QueryCondition\ class. Users can now manage AI resource metadata, track download counts, and filter resources by namespace, type, name, and business tags, with support for optimistic locking on metadata updates and scope-based visibility.

ai/src/main/java/com/alibaba/nacos/ai/service/repository · high confidence

Introduce plugin-based datasource persistence architecture

The configuration center now supports external relational databases through a new plugin framework in the datasource module. This introduces a SPI-driven architecture where database dialects (e.g., MySQL, PostgreSQL, Oracle) and SQL mappers are loaded dynamically, replacing the previous hardcoded persistence logic. Users can now configure Nacos to use supported external databases by providing the appropriate dialect plugin, with the system automatically handling SQL generation, pagination, and primary key management via the new \MapperManager\ and \DatabaseDialectManager\ components.

plugin/datasource · high confidence

Introduce serializable ability models for client and server naming capabilities

Added \ClientNamingAbility\ and \ServerNamingAbility\ classes to the naming API to explicitly model and exchange feature capabilities between client and server. \ClientNamingAbility\ tracks support for delta push and remote metrics, while \ServerNamingAbility\ tracks support for SOFA-Jraft persistence. Both classes implement \Serializable\ to ensure safe transmission over the network, addressing serialization constraints in the naming protocol.

api/src/main/java/com/alibaba/nacos/api/naming/ability · high confidence

Introduce shared AI resource search request and response models

Added the client-side form objects \AiResourcePageSearchForm\ and \AiResourceSearchForm\ for validating search parameters (such as namespace, query, tags, and pagination cursors) and the API model classes \AiResourceSearchItem\ and \AiResourceSearchResponse\ to structure the search results. These classes provide the data contracts for the new shared AI resource search capability, handling input normalization and output serialization.

ai/src/main/java/com/alibaba/nacos/ai/form/search, api/src/main/java/com/alibaba/nacos/api/ai/model/search · high confidence

Introduce standalone Nacos Console deployment mode

Nacos now supports deploying the web console as a standalone application that connects to a remote Nacos server cluster, rather than being bundled exclusively with the server. This new mode includes a dedicated Spring Boot entry point (NacosConsole), a startup phase (NacosConsoleStartUp) that configures the environment for console-only operation, and a RemoteServerMemberManager that tracks the remote server cluster topology. It also provides console-specific configuration for CORS, authentication plugin initialization, and security controls such as MCP endpoint access validation, enabling administrators to run the UI independently from the data plane.

console · high confidence

Introduce unified AI resource import and MCP server management services

This change adds the core service layer for importing and managing Model Context Protocol (MCP) servers and AI resources. It introduces a new unified AI resource import framework, including the \McpServerImportService\ for handling validation and execution of imports, and the \McpLegacyImportAdapter\ to route legacy MCP import requests to the new unified APIs. To support the new import sources, \McpExternalDataAdaptor\ is added to fetch and adapt data from official MCP registry URLs, JSON files, and seed files. The update also includes \McpEndpointOperationService\ to manage the underlying Nacos naming services and instances that represent MCP server endpoints, and \McpServerCacheInvalidateService\ to ensure cache consistency when MCP configurations change. Additionally, \SkillDownloadCountManager\ is introduced to track and persist skill download counts asynchronously.

ai/src/main/java/com/alibaba/nacos/ai/service · high confidence

Introduce v2 API response models and error codes

Added the \ErrorCode\ enum, the generic \Result\<T\>\ response wrapper, and the \SupportedLanguage\ enum to the \api.model.v2\ package. These classes provide the standardized structure for API responses, including specific error codes for configuration, naming, and capacity limits, as well as support for localized language handling in announcements.

api/src/main/java/com/alibaba/nacos/api/model/v2 · high confidence

Introduce visibility plugin SPI and model abstractions

The visibility plugin now exposes a Service Provider Interface (SPI) and supporting model classes that allow domain modules to define and enforce resource visibility rules. This includes the VisibilityService interface for validating access and advising queries, a VisibilityResourceLocator bridge for finding resources by identifier, and model classes like VisibilityResource, AuthorizedResources, and BaseVisibilityPredicate to represent scope, ownership, and query predicates. These abstractions enable plugin-owned visibility management without requiring direct compile-time dependencies on specific domain persistence types.

plugin/visibility · high confidence

Introduces Agent Runtime Endpoint Registry and lifecycle management

The Agent Runtime now supports publishing and discovering Agent endpoints via the Nacos Naming service. This change adds a dedicated runtime layer that manages the full lifecycle of Agent HTTP clients, including registration, deregistration, and heartbeat operations, while enforcing publication capacity limits per client. It introduces a mapping mechanism to convert Agent endpoints into Naming instances with version-range binding support, enabling server-aware endpoint discovery and legacy A2A migration compatibility.

ai/src/main/java/com/alibaba/nacos/ai/service/agent/runtime · high confidence

Introduces Agent Version content persistence with integrity verification

The Agent storage layer now persists the complete content of each Agent Version as a distinct object in AI Storage, separate from the resource and version metadata rows. This change adds a dedicated storage service that composes stable, provider-neutral logical keys (e.g., \agent\\\<encoded\name\>\\_\<version\>.json\), serializes content into a strict JSON projection, and computes a SHA-256 digest to ensure data integrity. On read, the system verifies that the stored size and digest match the persisted descriptor before deserializing, and on write, it captures the storage provider and key at preparation time so that draft updates remain anchored to the original storage location even if the server's default provider configuration changes.

ai/src/main/java/com/alibaba/nacos/ai/service/agent/storage · high confidence

Introduces Nacos 3.0 configuration APIs and plugin-based change interception

This change adds the v3 configuration management endpoints (ConfigControllerV3, ConfigOpenApiController, and CapacityControllerV3) to the config module, providing the new admin and client-facing APIs for configuration operations. It also introduces a new plugin-based architecture for config change events via the ConfigChangeAspect, which intercepts publish and delete operations to allow extensible plugin services to handle pre- and post-change logic, alongside a new permission checker for config cloning.

config · high confidence

Introduces SPI-based encryption plugin architecture

The plugin/encryption module now provides a pluggable encryption framework. It introduces the EncryptionPluginService SPI interface, allowing users to register custom encryption algorithms. The EncryptionHandler automatically detects data IDs prefixed with 'cipher-' (e.g., 'cipher-aes-dataId'), extracts the algorithm name, and delegates encryption and decryption operations to the registered plugin service. This enables users to configure and use different encryption implementations without modifying core server code.

plugin/encryption · high confidence

Introduces a neutral JSON adapter SPI for Jackson 2 and Jackson 3 support

The Nacos Java SDK now provides a pluggable JSON abstraction layer in the \api\ module, allowing users to choose between Jackson 2 and Jackson 3 implementations. This change introduces a new \NacosJsonAdapter\ service provider interface (SPI) and a \JsonUtils\ facade that routes serialization and deserialization calls to the selected adapter. Users can explicitly configure the adapter via the \nacos.client.json.adapter\ system property (accepting \jackson2\ or \jackson3\) or allow the SDK to automatically detect and prefer Jackson 3 if available. This architecture decouples the core API from specific JSON libraries, enabling runtime flexibility and resolving compatibility issues when only Jackson 3 is present in the classpath.

api/src/main/java/com/alibaba/nacos/api/utils/json · high confidence

Introduces capability control framework and unified thread pool management in common module

The common module now includes a new capability control system, featuring the \AbstractAbilityControlManager\ and \NacosAbilityManagerHolder\ to manage and negotiate node abilities via SPI, alongside new \@Beta\ and \@NotThreadSafe\ annotations for code metadata. Additionally, a unified thread pool lifecycle management system has been added with \ThreadPoolManager\ and \ExecutorFactory\ to centralize the creation and shutdown of executor services, while HTTP client infrastructure is standardized through new factory classes (\AbstractHttpClientFactory\, \AbstractApacheHttpClientFactory\) and constants (\HttpHeaderConsts\, \ResponseHandlerType\).

common · high confidence

Introduces client-side selector interfaces

Added the \Selector\ and \SelectResult\ interfaces in the \com.alibaba.nacos.api.selector.client\ package. These new API components define the contract for client-side selection logic, allowing users to implement custom strategies for selecting targets based on a provided context.

api/src/main/java/com/alibaba/nacos/api/selector/client · high confidence

Introduces extensible server identity verification for Nacos internal APIs

The auth module now includes a new server identity checking framework located in \com.alibaba.nacos.auth.serveridentity\. This change adds a \ServerIdentityChecker\ interface and a \DefaultChecker\ implementation that validates incoming requests by comparing the server identity value against the configured \server.identity.value\. The system uses an SPI-based holder (\ServerIdentityCheckerHolder\) to load custom checker implementations, falling back to the default if none are found, allowing administrators to extend or replace the default identity validation logic for Nacos inner/admin API access.

auth/src/main/java/com/alibaba/nacos/auth/serveridentity · high confidence

Introduces new remote API abstractions for request/response handling

The \api/src/main/java/com/alibaba/nacos/api/remote\ package now includes foundational interfaces and classes for remote communication, including \Requester\ for sending requests (synchronous, future-based, and async), \RequestFuture\ and \DefaultRequestFuture\ for managing request lifecycle and timeouts, \RequestCallBack\ and \PushCallBack\ for handling responses and push notifications, and \RpcScheduledExecutor\ for managing background threads. Additionally, \RemoteConstants\ defines labels for source and module identification, and the \Payload\ interface has been introduced (renamed from \Synchronizer\) to serve as a marker for payload classes.

api/src/main/java/com/alibaba/nacos/api/remote · high confidence

Introduces schema-versioned data models for Agent resource extensions and version storage

This change adds three new Java classes in the agent model package to support structured persistence of Agent metadata and version content. AgentResourceExt defines a schema-versioned container for agent-level metadata such as display name, icon URL, provider, and version catalog. AgentVersionContent provides a protocol-neutral structure to store call interfaces for a specific agent version. AgentVersionStorageDescriptor introduces a storage descriptor with defined constants for key formats (rad-ascii-v1), media types, and schema versions, enabling consistent serialization and identification of agent version data in storage.

ai/src/main/java/com/alibaba/nacos/ai/model/agent · high confidence

Introduction of CMDB SPI interface for external configuration management integration

The new \CmdbService\ interface in the \api/src/main/java/com/alibaba/nacos/api/cmdb/spi\ package provides a standardized Service Provider Interface (SPI) for integrating with external Configuration Management Database (CMDB) systems. This interface exposes methods to retrieve label names, entity types, specific label information, and entity details, along with a mechanism to listen for label change events via \getEntityEvents\. To maintain backward compatibility during the transition, the methods \getLabelValue\ and \getLabelValues\ are marked as deprecated, indicating they are no longer used by current server flows but remain available for legacy CMDB SPI implementations.

api/src/main/java/com/alibaba/nacos/api/cmdb/spi · high confidence

Introduction of CMDB module with reader/writer interfaces

This change introduces the new CMDB (Configuration Management Database) module, starting with the application entry point (CmdbApp) and core service interfaces. It defines CmdbReader for querying entities and labels, and CmdbWriter for writing data, which was refactored from the previous naming/raft Datum class. This provides the foundational API for integrating with third-party CMDB systems to filter service providers by labels.

cmdb/src/main/java/com/alibaba/nacos/cmdb/service · high confidence

Introduction of Skill Index Manifest for metadata storage

A new \SkillIndexManifest\ class has been added to the AI skills module to structure how skill metadata is stored in Nacos Config. This manifest defines the schema for client-side caching, organizing data into label-to-version mappings (such as 'latest') and version-to-file mappings, stored under specific group and dataId patterns.

ai/src/main/java/com/alibaba/nacos/ai/model/skills · high confidence

Introduction of in-memory CMDB provider with scheduled data synchronization

The CMDB module now includes a new in-memory provider (CmdbProvider) that loads entity and label data from an integrated third-party CMDB service at startup or on a configurable schedule. This component initializes the local entity and label maps, schedules periodic dump, label, and event tasks to keep the in-memory state synchronized with the external CMDB, and exposes query capabilities for entities and labels to support filtering service providers by their labels.

cmdb/src/main/java/com/alibaba/nacos/cmdb/memory · high confidence

MySQL datasource plugin provides dialect-specific SQL mappers and schema

The MySQL datasource plugin now includes a complete set of database-specific SQL mappers (e.g., ConfigInfo, TenantCapacity, AiResource) and a default dialect implementation that registers the MySQL JDBC driver. This ensures that Nacos uses optimized, MySQL-compatible SQL queries for configuration and AI resource storage, backed by the provided MySQL schema definitions.

plugin-default-impl/nacos-default-datasource-plugin/nacos-datasource-plugin-mysql · high confidence

Naming API module introduces batch instance operations and service maintenance interfaces

The naming API module now exposes batch registration and deregistration capabilities for service instances via new methods on the NamingService interface, allowing clients to register or deregister multiple instances in a single call. Additionally, the module introduces the NamingMaintainService interface and its factory, providing administrative operations such as creating, querying, updating, and deleting services, as well as updating instance metadata. The API also adds a NamingResponseCode class for specific naming-related error codes and a CommonParams class to standardize parameter keys used across naming requests.

api/src/main/java/com/alibaba/nacos/api/naming · high confidence

Naming event listener API expanded with fuzzy watch support and metadata access

The naming listener API in the \api\ module now supports fuzzy watch notifications and provides finer-grained metadata access. New types \FuzzyWatchChangeEvent\, \FuzzyWatchEventWatcher\, \FuzzyWatchLoadWatcher\, and their abstract base \AbstractFuzzyWatchEventWatcher\ have been added to allow users to subscribe to fuzzy watch events and handle limit-exceeded scenarios. The existing \NamingEvent\ class has been extended with \groupName\ and \clusters\ fields (including getters/setters and a new constructor), enabling listeners to access service group and cluster information. Additionally, \AbstractEventListener\ was introduced to allow custom executors for event handling, and core interfaces \Event\ and \EventListener\ were moved from the client module to the api module.

api/src/main/java/com/alibaba/nacos/api/naming/listener · high confidence

New AI Registry adaptor module with MCP and ARD protocol support

A new \ai-registry-adaptor\ module has been added to expose AI resource registries via standard protocols. It includes an MCP Registry implementation for listing and retrieving server versions, and an Agentic Resource Discovery (ARD) implementation providing search, catalog, and artifact endpoints. The module introduces a dedicated startup phase, conditional feature switches for MCP and ARD capabilities, and specific HTTP configurations to handle path parameters containing slashes.

ai-registry-adaptor/src/main · high confidence

New AI agent guidance and developer workflow documentation

Added AGENTS.md to provide specific contribution guidelines for AI coding agents (such as Claude Code and GitHub Copilot), including requirements for spec-first coding, mandatory pre-submission checks, and disclosure of AI usage. Introduced a Makefile to simplify build, test, and run workflows for various server modes (config, naming, microservice, AI). Updated CONTRIBUTING.md with detailed steps for issue assignment, pre-submission checks, and code style enforcement. Added REPORTING-BUGS.md to standardize bug report creation. Updated BUILDING to reflect JDK 17+ and Maven 3.6.3+ requirements and added the Maven wrapper (mvnw).

(repo-wide) · high confidence

New AI and fuzzy-watch examples with updated core samples

The example module now includes new demonstration programs: AgentSpecExample and SkillExample show how to subscribe to and poll AI resources using HTTP transport with 304 conditional queries, while ConfigFuzzyWatchExample and NamingFuzzyWatchExample demonstrate fuzzy listening for configuration and service instances. Existing samples have been updated to run against localhost:8848 by default, use the DEFAULT\_GROUP, and provide clearer console output; NamingExample now uses an async executor for event handling, and App.java prints instance lists after registration.

example · high confidence

New AI client API interfaces for MCP, Skills, Prompts, and Agent discovery

The Nacos AI client now exposes a structured set of service interfaces under the \api/src/main/java/com/alibaba/nacos/api/ai\ package, allowing users to manage AI resources through dedicated entry points on the \AiService\. This includes \McpService\ for managing MCP server definitions and endpoints, \SkillService\ for downloading and subscribing to skill ZIP packages, \PromptService\ for retrieving and subscribing to prompt definitions, and \AgentSpecService\ for loading and subscribing to agent specifications. Additionally, \AgentDiscoveryService\ and \AgentService\ provide capabilities for discovering remote agents, subscribing to their status, and publishing agent versions from application code. The \AiFactory\ class serves as the entry point to create these AI service instances, and \AgentTransportMode\ defines the transport strategies (gRPC, HTTP, or auto-negotiation) for agent communication.

api/src/main/java/com/alibaba/nacos/api/ai · high confidence

New AI client capabilities for Agent, MCP, and Skill management

The Nacos client now includes a comprehensive AI module (\NacosAiService\) that enables SDKs to discover, register, and manage AI agents, MCP servers, and skills. This change introduces native support for A2A (Agent-to-Agent) protocol endpoint publication, allowing clients to register agent endpoints and maintain their availability via a shared HTTP heartbeat and redo cycle. It also provides APIs for managing MCP server endpoints, agent specs, prompts, and skills, complete with local caching, listener invokers for change events, and transport routing that abstracts the underlying HTTP/gRPC communication.

client · high confidence

New AI event listener API for agents, skills, prompts, and MCP servers

The Nacos API module now exposes a dedicated event-listener framework for the AI subsystem, allowing applications to subscribe to changes in agent cards, agent discovery snapshots, agent specs, prompts, skills, and MCP servers. This change introduces the core \NacosAiListener\ interface and \NacosAiEvent\ marker, along with abstract listener base classes (\AbstractNacosAgentCardListener\, \AbstractNacosAgentDiscoveryListener\, \AbstractNacosAgentSpecListener\, \AbstractNacosMcpServerListener\, \AbstractNacosPromptListener\, \AbstractNacosSkillListener\) and their corresponding event classes (\NacosAgentCardEvent\, \NacosAgentDiscoveryEvent\, \NacosAgentSpecEvent\, \NacosMcpServerEvent\, \NacosPromptEvent\, \NacosSkillEvent\). Notably, \NacosAgentDiscoveryEvent\ supports both full discovery snapshots and unavailable transitions with error codes, while \NacosSkillEvent\ carries the skill ZIP payload, MD5 fingerprint, and resolved version to enable efficient client-side caching and diffing. These classes were added to \api/src/main/java/com/alibaba/nacos/api/ai/listener\ (with some files repurposed from legacy naming components), providing the contract for downstream SDKs and server-side implementations to push AI state changes to consumers.

api/src/main/java/com/alibaba/nacos/api/ai/listener · high confidence

New AI module configuration and bootstrap infrastructure

This change introduces the core configuration and initialization components for the Nacos AI module. It adds an enabled filter to control module activation based on the \nacos.extension.ai.enabled\ property and function mode, and registers a distro filter to route AI client requests. It also includes a bootstrap initializer to load built-in AgentSpecs on startup, a storage initializer to register SPI-based storage plugins, and a dynamic configuration switch for the AI publish pipeline. Additionally, it provides configuration for MCP cache indexing, lifecycle reconciliation tasks for historical MCP data, and a backfill task to reconcile AI resource search indexes, along with the necessary conditional annotations and validators to ensure correct runtime setup.

ai/src/main/java/com/alibaba/nacos/ai/config · high confidence

New AI plugin providers and type policies for pipeline, storage, vector, and import capabilities

This change introduces the plugin infrastructure for the new AI module by adding specific PluginProvider and PluginTypePolicy implementations for four distinct areas: AI pipelines (AiPipelinePluginProvider), AI resource storage (AiStoragePluginProvider), AI resource vector indexes (AiVectorPluginProvider), and AI resource imports (AiResourceImportPluginProvider). Each provider bridges its respective internal service registry (PublishPipelineManager, AiResourceStorageRouter, AiResourceVectorIndexRegistry, AiResourceImportPluginManager) to the unified Nacos PluginManager. The corresponding type policies enforce activation based on the 'nacos.functionMode' being 'ai' (or unset), the global AI enabled filter, and specific module switches (e.g., nacos.plugin.ai-resource-import.enabled). The storage and import policies also handle migration from deprecated legacy configuration keys to new standard ones, ensuring backward compatibility while warning users to migrate. This provides the foundational wiring for AI-specific features like pipeline processing, persistent storage, vector search, and resource importing to be discoverable and configurable via the standard plugin system.

ai/src/main/java/com/alibaba/nacos/ai/plugin · high confidence

New AI resource import SPI models for search, validation, and execution

This change introduces the API-side data models for the AI resource import feature in Nacos 3.2.1. The new classes in the \com.alibaba.nacos.api.ai.model.importer\ package define the request and response structures for searching external AI resources, validating selected items against existing resources, and executing the import operation. It also includes models for import source information and result statuses, enabling clients to interact with the import workflow.

api/src/main/java/com/alibaba/nacos/api/ai/model/importer · high confidence

New AI resource import operators for MCP and Skills

This change introduces the \AiResourceOperator\ interface and its concrete implementations, \McpResourceOperator\ and \SkillResourceOperator\, within the AI importer module. These components enable the import of MCP server configurations and Skill ZIP artifacts into Nacos. The \McpResourceOperator\ handles validation and import of MCP server details, while the \SkillResourceOperator\ manages Skill uploads, including conflict detection for existing editing or reviewing versions and source synchronization.

ai/src/main/java/com/alibaba/nacos/ai/importer/operator · high confidence

New AI resource management and client discovery APIs

This release introduces a comprehensive set of new HTTP controllers for managing and discovering AI resources. Administrators can now manage AgentSpecs, Agents, MCP servers, and A2A agents via dedicated admin APIs (e.g., \AgentSpecAdminController\, \AgentAdminController\, \McpAdminController\, \A2aAdminController\), supporting CRUD operations, versioning, scope updates, and import management (\AiResourceImportAdminController\). Clients gain access to new discovery and search endpoints (\AgentClientController\, \AgentSpecClientController\, \AiResourceSearchClientController\) for finding and subscribing to AI resources, along with a capability declaration endpoint (\AiCapabilityClientController\) to advertise supported features like RAD, MCP, and Skills.

ai/src/main/java/com/alibaba/nacos/ai/controller · high confidence

New AI resource storage routing and plugin lifecycle management

The nacos-ai-plugin module now includes an \AiResourceStorageRouter\ that acts as a facade for AI resource storage. This router enables upper-layer components (like Skills and Prompts) to delegate read/write operations to specific storage providers identified by a \StorageKey\. It supports runtime registration of storage implementations via a first-wins strategy, manages change listeners across all registered providers, and enforces plugin state checks before routing requests. This change establishes the foundational infrastructure for pluggable AI resource storage within the plugin.

nacos-ai-plugin · high confidence

New AI utility classes for Agent, AgentSpec, and MCP handling

Added a suite of utility classes in the AI module to support Agent, AgentSpec, and MCP resource management. AgentCardUtil and AgentEndpointUtil handle A2A agent card and endpoint conversions, including building interfaces from service instances and transferring endpoints to service instances. AgentRequestUtil and AgentSpecRequestUtil provide request parsing, validation, and response building for Agent and AgentSpec forms, including namespace ID filling and HTTP header management. AgentSpecContentDigestUtils computes canonical content MD5 hashes for AgentSpecs to support efficient change detection. AgentSpecZipParser parses AgentSpec ZIP files with security hardening against Zip Slip, Zip Bomb, and DoS attacks, supporting both single and multi-AgentSpec archives. AiResourceVersionStorageJsonUtil manages JSON storage descriptors for AI resource versions. ExecutorUtils provides configurable async executors for skill and AgentSpec storage IO and AI resource index enhancement. McpConfigUtils and McpRequestUtil handle MCP server configuration formatting, tag building, and request parsing for MCP server details and drafts.

ai/src/main/java/com/alibaba/nacos/ai/utils · high confidence

New API common constants and type definitions

The \api/src/main/java/com/alibaba/nacos/api/common\ package now includes new foundational types and constants for the Nacos API. \ApiType\ defines API categories (Admin, Console, Open, Inner), \NodeState\ enumerates node lifecycle states (Starting, Up, Suspicious, Down, Isolation), and \ResponseCode\ establishes a base response code structure (e.g., OK=10200). \Constants\ provides essential configuration values including the client version (3.0.0), default groups/namespaces, timeout settings, and header names, centralizing these values for use across the API layer.

api/src/main/java/com/alibaba/nacos/api/common · high confidence

New API interfaces and classes for config fuzzy watch events

The \api\ module now exposes the core abstractions for the new fuzzy configuration watching capability. This includes the \FuzzyWatchEventWatcher\ interface and its \AbstractFuzzyWatchEventWatcher\ base class for handling fuzzy change notifications, the \ConfigFuzzyWatchChangeEvent\ data class to carry change details (group, dataId, namespace, type), and the \FuzzyWatchLoadWatcher\ interface to handle limit-exceeded scenarios. Additionally, a \ConfigChangeParser\ interface is introduced to allow pluggable parsing of configuration change diffs, and several existing listener classes (\Listener\, \AbstractListener\, \AbstractSharedListener\) have been moved from the \client\ module to \api\ to support this new event-driven model.

api/src/main/java/com/alibaba/nacos/api/config/listener · high confidence

New API model hierarchy and batch upload support for Skills

The API layer now introduces a structured model hierarchy for Skills, including a new \SkillBase\ class with common fields (namespace, name, description) extended by \Skill\ (containing SKILL.md content and resources), \SkillBasicInfo\, \SkillSummary\, and \SkillMeta\ for various response contexts. This change adds support for batch skill uploads by introducing \BatchUploadResult\ and \BatchUploadItemResult\ models, allowing users to upload multiple skills via a single ZIP archive and receive per-item success or failure details. Additionally, \SkillUploadPrecheckResult\ is added to expose pre-upload validation states (such as version conflicts or permission issues), and \SkillUtils\ provides utilities for converting skills to/from ZIP formats with path safety validation.

api/src/main/java/com/alibaba/nacos/api/ai/model/skills · high confidence

New API models for AI pipeline execution and audit results

The API module now includes a set of data transfer objects to support the AI publish pipeline: \PipelineExecution\ (persisted execution record with status and node details), \PipelineExecutionResult\ (callback result with final status), \PipelineNodeResult\ (individual node execution outcome including audit checkpoints and messages), \Checkpoint\ (individual audit criterion result), and \PipelineExecutionStatus\ (enum for IN\_PROGRESS, APPROVED, REJECTED). These classes define the structure of pipeline execution data exposed by the API.

api/src/main/java/com/alibaba/nacos/api/ai/model/pipeline · high confidence

New API models for MCP server management, versioning, and import

The API module introduces a comprehensive set of data models to support Model Context Protocol (MCP) server operations. This includes canonical version management models (McpServerVersionSummary, McpServerVersionDetail) and legacy compatibility models (McpServerDetailInfo, McpServerVersionInfo) to handle server specifications and lifecycle states. New models enable encrypted resource specifications (McpResourceSpecification with EncryptObject) and flexible endpoint configurations (McpEndpointSpec, FrontEndpointConfig, McpServiceRef) for both direct and Nacos-registered services. Additionally, the API defines request and response structures for server import workflows (McpServerImportRequest, McpServerImportValidationResult) and label updates (McpServerLabelsUpdateRequest), providing the necessary data contracts for server registration, versioning, and secure configuration.

api/src/main/java/com/alibaba/nacos/api/ai/model/mcp · high confidence

New API response models and refactored connection info class

The API module now includes several new response value objects: ConnectionMetaInfo for client connection metadata, IdGeneratorInfo for ID generation details, NacosMember for server node information, Namespace for namespace details, and ServerLoaderMetric/ServerLoaderMetrics for server load metrics. Additionally, the previous JSON utility class (JSONUtils) from the config module has been renamed and refactored into ConnectionInfo, which now represents client connection information including tracing status, ability table, and metadata, rather than serving as a general JSON serialization utility.

api/src/main/java/com/alibaba/nacos/api/model/response · high confidence

New Agent API contract models for discovery, management, and runtime endpoints

This change introduces a comprehensive set of new data models in the \api/src/main/java/com/alibaba/nacos/api/ai/model/agent\ package to support the Agent and RAD (Remote Agent Discovery) capabilities. These models define the contracts for Agent discovery (e.g., \AgentDiscoveryRequest\, \AgentDiscoveryResult\, \AgentDiscoveryFilter\), management (e.g., \AgentOverview\, \AgentSummary\, \AgentVersionDetail\, \AgentVersionSummary\), and runtime endpoint registration (e.g., \Endpoint\, \EndpointSet\, \AgentEndpointRegistrationBatch\). It also includes administrative request models for draft creation and updates (\AgentDraftCreateRequest\, \AgentDraftUpdateRequest\, \AgentLabelsUpdateRequest\) and watch/batch notification structures (\AgentWatchBatchRequest\, \AgentWatchBatchResponse\, \AgentWatchEventType\). These classes form the core serialization layer for the Agent API, enabling clients to search, discover, manage versions, and register endpoints for AI agents within Nacos.

api/src/main/java/com/alibaba/nacos/api/ai/model/agent · high confidence

New Agent Admin and Client API form bindings

This change introduces a comprehensive set of HTTP form classes for the Agent management and client APIs. The admin package adds forms for managing Agent drafts (creation and updates), updating Agent metadata (labels, scope, general fields), and querying Agent lists and version details. The client package adds forms for code-first Agent publication, RAD-based endpoint registration and deregistration, agent discovery and search, and server-aware watch batches. These forms handle input validation, namespace processing, and JSON parsing to build the underlying request models.

ai/src/main/java/com/alibaba/nacos/ai/form/agent · high confidence

New ConfigChangeClusterSyncRequest for cluster config propagation

A new request class, ConfigChangeClusterSyncRequest, has been added to the Nacos API to handle configuration change synchronization across clusters. This class extends AbstractConfigRequest and includes fields for lastModified timestamp, grayName, and deprecated beta/tag support, enabling the system to propagate configuration updates with versioning and gray release context between cluster nodes.

api/src/main/java/com/alibaba/nacos/api/config/remote/request/cluster · high confidence

New DNS server for service discovery with SRV support and hardened forwarding

Nacos now includes an optional DNS server that resolves service names to healthy instances via A, AAAA, and SRV records. Users can enable it via the \nacos.naming.dns\ configuration prefix (defaulting to disabled on port 5353, bound to 127.0.0.1). Queries matching the configured domain suffix (default \nacos\) are resolved against Nacos naming; non-matching queries can be forwarded to upstream DNS servers when \forwardEnabled\ is true. The server exposes Micrometer metrics (total/success/forwarded/failed queries, duration timers) and includes production hardening such as UDP response capping at 512 bytes, separate TCP/UDP/forward worker pools, and connection limits.

dns · high confidence

New HTTP resource parsers for AI, Config, and Naming authorization

The auth module now includes a set of new HTTP resource parsers that define how authorization metadata is extracted from incoming requests for specific subsystems. The new AiHttpResourceParser handles authorization for AI-related endpoints (MCP, A2A, Agents, Skills, Prompts, AgentSpecs, and Resources) by mapping URL paths to specific AI resource types and extracting names from request parameters or JSON payloads. Additionally, ConfigHttpResourceParser and NamingHttpResourceParser provide dedicated logic for extracting namespace, group, and resource identifiers (dataId for configs, service names for naming) from HTTP requests, ensuring consistent authorization checks across these core Nacos features.

auth/src/main/java/com/alibaba/nacos/auth/parser/http · high confidence

New HTTP-based client authentication service with v1/v3 login fallback and TLS support

The client-basic module now includes a new authentication implementation (NacosClientAuthService) that handles user login via HTTP. This service supports both the legacy v1 login endpoint (/v1/auth/users/login) and the newer v3 endpoint (/v3/auth/user/login), automatically falling back to v1 if the v3 endpoint is not available. It also respects the TLS configuration to use HTTPS or HTTP prefixes when constructing the login URL. The implementation manages token TTL and refresh windows to optimize server load and handles re-login logic based on token expiration.

client-basic/src/main/java/com/alibaba/nacos/client/auth/impl · high confidence

New HttpClientManager for centralized HTTP client configuration

A new HttpClientManager class has been added to the client-basic module to serve as a centralized manager for the NacosRestTemplate. This component provides a singleton instance of the HTTP client, configured with default connection (1000ms) and read (3000ms) timeouts, and handles the lifecycle management (initialization and shutdown) of the underlying HTTP resources.

client-basic/src/main/java/com/alibaba/nacos/client/remote · high confidence

New MCP client form objects for resource management and lifecycle operations

This change introduces a set of new form classes in the MCP client package to support managing Model Context Protocol (MCP) resources. McpReleaseForm handles the release of MCP servers with support for server, tool, resource, and endpoint specifications, as well as draft creation. McpEndpointForm manages the registration and deregistration of MCP runtime endpoints. McpQueryForm allows querying for specific or latest MCP versions. McpSearchForm extends the base search form to include MCP-specific filtering by protocols and capabilities. McpClientFormJsonParser provides utility for parsing optional JSON fields within these forms.

ai/src/main/java/com/alibaba/nacos/ai/form/mcp/client · high confidence

New MCP server request forms for lifecycle management

The AI module introduces a comprehensive set of request forms in the \mcp.admin\ package to support the full lifecycle of MCP (Model Context Protocol) servers. These forms enable users to create and update server details (including server, tool, resource, and endpoint specifications), manage server drafts, and handle versioning. The update process now supports an \overrideExisting\ flag to control version replacement. Additional forms allow for importing servers (with pagination and validation options), listing servers with search filters, and managing server metadata such as labels, visibility scope (public/private), and enabled status.

ai/src/main/java/com/alibaba/nacos/ai/form/mcp/admin · high confidence

New Nacos API annotations for configuration injection and version tracking

The \com.alibaba.nacos.api.annotation\ package now includes four new annotations: \@NacosApi\ marks controllers for the Nacos API v2; \@NacosInjected\ allows automatic injection of \ConfigService\ or \NamingService\ instances into beans, with optional \NacosProperties\ configuration; \@NacosProperties\ defines the available configuration properties (such as endpoint, namespace, server-addr, username, password, and enableRemoteSyncConfig) and their default placeholders for use with \@NacosInjected\; and \@Since\ marks the first Nacos version that supports a specific API method or type.

api/src/main/java/com/alibaba/nacos/api/annotation · high confidence

New NamingUtils class for service name parsing and instance validation

A new \NamingUtils\ class has been added to the naming API module to centralize utility functions for service identification and instance validation. This includes methods for constructing and parsing grouped service names (e.g., \groupName@@serviceName\), extracting service keys, and validating instance parameters such as heartbeat intervals, IP deletion timeouts, and cluster name formats. This change introduces new validation logic for instance registration and service name formatting within the API layer.

api/src/main/java/com/alibaba/nacos/api/naming/utils · high confidence

New REST API endpoints for managing address server clusters

The address module now exposes two new controller endpoints to manage service discovery clusters via HTTP. Users can create a cluster by POSTing to /nodes with product, cluster, and IP list parameters, which registers the IPs as instances in Nacos. Users can retrieve the current IP list for a specific product and cluster by GETting /{product}/{cluster}. These endpoints allow external systems to dynamically configure and query the address server's service registry.

address/src/main/java/com/alibaba/nacos/address/controller · high confidence

New RPC request and response types for AI Agent, MCP, and Prompt services

This change introduces a comprehensive set of new gRPC request and response classes in the Nacos AI module API to support Agent, MCP (Model Context Protocol), and Prompt operations. The diff adds abstract base classes for each domain (AbstractAgentClientRpcRequest, AbstractAgentRequest, AbstractMcpRequest, AbstractPromptRequest) and concrete RPC bindings for specific actions, including Agent discovery, search, subscription (watch), endpoint registration/deregistration, and code-first publication. It also includes corresponding request/response structures for MCP server endpoint management and versioned prompt queries, enabling the underlying remote communication layer to handle these new AI capabilities.

api/src/main/java/com/alibaba/nacos/api/ai/remote/request · high confidence

New SPI interface for custom instance ID generation

The Nacos API now exposes the \InstanceIdGenerator\ SPI interface in the \com.alibaba.nacos.api.naming.spi.generator\ package, allowing users to implement and register custom strategies for generating unique instance IDs. This interface defines the \generateInstanceId\ method to produce an ID string from an \Instance\ object and a \type\ method to identify the generator, enabling extensibility in how service instances are identified within the naming registry.

api/src/main/java/com/alibaba/nacos/api/naming/spi · high confidence

New SPI-based plugin configuration and lifecycle contracts

The plugin API now exposes a standardized SPI framework for managing plugin configuration, discovery, and lifecycle. Users can define plugin settings using the new \ConfigItemDefinition\ model, which supports typed items (STRING, NUMBER, BOOLEAN, ENUM), sensitivity flags, and effect modes (RUNTIME or RESTART). Plugin providers can now declare their configuration metadata via the \PluginConfigSpec\ interface, allowing the system to validate and apply settings before instantiation. The \PluginType\ enumeration has been expanded to include new AI-related types (AI\_PIPELINE, AI\_STORAGE, AI\_VECTOR, AI\_RESOURCE\_IMPORT) alongside existing ones like AUTH and VISIBILITY, each with defined execution modes (EXCLUSIVE, CHAIN, ROUTED, BROADCAST) and initialization phases (PRE\_CONTEXT, STANDARD). Additionally, \PluginTypePolicy\ allows domains to control plugin loading and validation based on server configuration, enabling dynamic activation of non-critical plugins while ensuring critical ones remain available.

api/src/main/java/com/alibaba/nacos/api/plugin · high confidence

New SPI-based server list provider architecture in client-basic

The \client-basic\ module now introduces a new, extensible server list management system. It adds an \AbstractServerListManager\ that uses the Java SPI mechanism to dynamically load and select a \ServerListProvider\ implementation based on configuration (e.g., \SERVER\_ADDR\ vs \ENDPOINT\). Two concrete providers are included: \PropertiesListProvider\ for fixed server addresses and \EndpointServerListProvider\ for dynamic discovery via an endpoint. This refactors how the client resolves server addresses, moving from hardcoded logic to a pluggable provider model.

client-basic/src/main/java/com/alibaba/nacos/client/address · high confidence

New SPIs for AI resource import, publish pipeline, and storage

The plugin/ai module introduces three new Service Provider Interfaces (SPIs) that enable extensible AI resource management. The AiResourceImportService SPI allows external sources to be searched and fetched as import artifacts, supporting resource types like MCP and Skill. The PublishPipelineService SPI provides a review and interception mechanism for AI resources (Skill, Prompt, MCP, AgentSpec) before they are published, allowing plugins to validate or reject content. The AiResourceStorage SPI defines a generic storage abstraction for AI resources, supporting pluggable backends (e.g., Nacos config, OSS) with configurable consistency modes and change listeners.

plugin/ai · high confidence

New and refactored naming remote response types

The API module now includes several new response classes for the naming service: NamingFuzzyWatchResponse, NamingFuzzyWatchSyncResponse, NamingFuzzyWatchChangeNotifyResponse, NotifySubscriberResponse, QueryServiceResponse, ServiceListResponse, and SubscribeServiceResponse, which provide structured responses for fuzzy watching, subscription notifications, and service queries. Additionally, InstanceResponse and BatchInstanceResponse have been introduced to handle instance-related operations, with InstanceResponse being a refactored version of the previous ApplicationPublishRecord model.

api/src/main/java/com/alibaba/nacos/api/naming/remote/response · high confidence

New annotation-based configuration binding and listeners

This change introduces a new set of annotations in the Nacos API to simplify configuration management. Users can now use @NacosConfigurationProperties to bind remote configuration to POJOs, with support for specifying a config prefix, auto-refreshing on changes, and ignoring invalid or unknown fields. Individual fields can be mapped using @NacosProperty or excluded with @NacosIgnore. Additionally, @NacosValue allows for auto-refreshable value injection, and @NacosConfigListener enables methods to act as listeners for configuration changes, supporting group, data ID, type, and custom converters.

api/src/main/java/com/alibaba/nacos/api/config/annotation · high confidence

New authentication annotations for protocol errors and resource tagging

The auth module introduces two new annotations to refine authorization behavior. The \ProtocolAuthError\ annotation allows API endpoints to define specific HTTP status codes and error codes for authentication failures, ensuring consistent error responses for external protocol APIs. Additionally, the \Secured\ annotation now supports a \tags\ field, enabling developers to attach custom metadata to secured resources for more granular access control and visibility.

auth/src/main/java/com/alibaba/nacos/auth/annotation · high confidence

New built-in security scanning pipelines for AI resources

The nacos-default-ai-pipeline-plugin now includes two new publish pipeline services: SkillScanner, which integrates the Cisco AI Defense skill-scanner CLI to detect prompt injection, data exfiltration, and malicious code patterns before publishing; and SkillSpector, which integrates the SkillSpector runtime to perform LLM-based semantic analysis and risk scoring. Both pipelines support configurable execution order, command resolution (via PATH or explicit paths), and optional LLM analysis parameters, and they reject publishing when HIGH/CRITICAL findings or risk scores exceed configured thresholds.

plugin-default-impl/nacos-default-ai-pipeline-plugin · high confidence

New client forms for AgentSpec querying and searching

Added AgentSpecQueryForm and AgentSpecSearchForm to the AI client runtime. AgentSpecQueryForm handles retrieval by name, version, and label, defaulting the namespace if omitted and validating that the name is provided. AgentSpecSearchForm extends the shared search base to support keyword-based searches with a 1,024-character limit on the keyword.

ai/src/main/java/com/alibaba/nacos/ai/form/agentspecs/client · high confidence

New cluster sync response type for config changes

A new response class, ConfigChangeClusterSyncResponse, has been added to the API module to handle configuration change synchronization across clusters. This class extends the base Response type and serves as the specific payload for cluster-level config change operations within the remote communication model.

api/src/main/java/com/alibaba/nacos/api/config/remote/response/cluster · high confidence

New common infrastructure for HTTP client handling, JSON serialization, package scanning, and task execution

The nacos-common module now includes several new foundational components that enhance how the client handles HTTP responses, serializes data, scans classes, and executes tasks. The AbstractNacosRestTemplate introduces a pluggable response handler system (supporting String, RestResult, byte\[\], and Bean types) to standardize HTTP response processing. A new Jackson2JsonAdapter provides a robust JSON serialization layer with support for canonical JSON output and subtype registration. Package scanning capabilities are added via a set of Resource implementations (ByteArray, FileSystem, Path, Vfs) and a ClassReader, enabling the application to inspect classes at runtime. Finally, new task execution engines (NacosDelayTaskExecuteEngine and NacosExecuteTaskExecuteEngine) provide structured, concurrent processing for delayed and immediate tasks respectively.

nacos-common · high confidence

New configuration model classes for API responses

The API module introduces a new set of model classes in the \com.alibaba.nacos.api.config.model\ package to structure configuration data returned by the server. These include \ConfigBasicInfo\ (containing metadata like ID, namespace, group, data ID, tags, and description), \ConfigDetailInfo\ (extending basic info with content, encryption keys, and schema), \ConfigHistoryBasicInfo\ and \ConfigHistoryDetailInfo\ (for history records), \ConfigCloneInfo\ (for cloning operations), \ConfigGrayInfo\ (for gray release details), and \ConfigListenerInfo\ (for listener status). Additionally, a \SameConfigPolicy\ enum is added to define import conflict behaviors (Abort, Skip, Overwrite). These models replace previous ad-hoc structures, providing a consistent and typed response format for configuration management APIs.

api/src/main/java/com/alibaba/nacos/api/config/model · high confidence

New core infrastructure for distro sync, plugin persistence, and JRaft security

This update introduces several foundational components within the core module. It adds a new event system for cluster membership changes via \MembersChangeEvent\ and establishes a dedicated task engine (\DistroTaskEngineHolder\) to manage asynchronous distro synchronization, including a processor that treats ADD operations like CHANGE. Plugin management is enhanced with a file-based state persistence implementation (\FilePluginStatePersistenceImpl\) and a Raft-based synchronizer provider (\RaftPluginStateSynchronizerProvider\) to decouple plugin config storage from synchronization. Additionally, JRaft gRPC requests are now secured with authentication credentials (\NacosJRaftCallCredentials\), and a new HTTP filter (\ParamCheckerFilter\) is introduced to validate request parameters before they reach controllers.

nacos-core · high confidence

New gRPC handlers for MCP, A2A, and RAD Agent operations

This change introduces a suite of new gRPC request handlers in the AI module to support MCP server endpoint management, A2A agent card and endpoint operations (including legacy-to-canonical migration routing), and RAD Agent discovery, registration, deregistration, and code-first publishing. These handlers expose the underlying application services over the remote protocol, enabling clients to manage MCP servers, register and query agent endpoints/cards, and publish agent definitions via gRPC.

ai/src/main/java/com/alibaba/nacos/ai/remote · high confidence

New gRPC resource parsers for AI, Config, and Naming services

This change introduces a new set of authentication resource parsers in the \auth\ module to handle gRPC requests for AI (MCP, Agent, Prompt), Config, and Naming services. The \AiGrpcResourceParser\ extracts namespace, group, and resource names from AI-specific request types (such as \AbstractMcpRequest\ and \AbstractAgentRequest\) and tags them with AI subtypes (MCP, Agent, Prompt) for fine-grained access control. The \ConfigGrpcResourceParser\ and \NamingGrpcResourceParser\ similarly parse tenant/namespace, group, and resource identifiers (data ID, service name) from their respective gRPC request classes, enabling the authentication system to correctly identify and authorize gRPC-based operations for these core Nacos features.

auth/src/main/java/com/alibaba/nacos/auth/parser/grpc · high confidence

New gRPC-based config response models for remote communication

The API module introduces a new set of response classes in the \com.alibaba.nacos.api.config.remote.response\ package to support configuration operations over gRPC. These include \ConfigQueryResponse\ (which adds support for 304 Not Modified caching and metadata like tags and beta status), \ConfigPublishResponse\, \ConfigRemoveResponse\, \ConfigChangeBatchListenResponse\, \ConfigChangeNotifyResponse\, and several fuzzy watch responses (\ConfigFuzzyWatchResponse\, \ConfigFuzzyWatchSyncResponse\, \ConfigFuzzyWatchChangeNotifyResponse\), as well as \ClientConfigMetricResponse\ for client-side metrics. These models enable the client and server to exchange configuration data, change notifications, and metrics via the new remote protocol.

api/src/main/java/com/alibaba/nacos/api/config/remote/response · high confidence

New maintainer API value objects for naming service details and client info

The naming maintainer API now exposes a set of new data-transfer objects in the \com.alibaba.nacos.api.naming.pojo.maintainer\ package to support detailed service and client inspection. These include \ServiceDetailInfo\ and \ServiceView\ for service metadata and cluster maps, \ClusterInfo\ for health check configuration, \MetricsInfo\ for system statistics, and \ClientServiceInfo\, \ClientPublisherInfo\, \ClientSubscriberInfo\, and \ClientSummaryInfo\ for granular client connection and heartbeat data. \ClientPublisherInfo\ replaces the previous internal \BeatInfo\ class, standardizing publisher data as a serializable API model.

api/src/main/java/com/alibaba/nacos/api/naming/pojo/maintainer · high confidence

New modularized client configuration and environment abstraction

The \client-basic\ module now introduces a dedicated, modularized infrastructure for client configuration and environment property resolution. This includes a new \NacosClientProperties\ interface and a \SearchableProperties\ implementation that manages a configurable search order across JVM arguments, system environment variables, and explicit properties, allowing users to prioritize sources via the \nacos.env.first\ setting. The change also adds a type-safe conversion layer (supporting Boolean, Integer, and Long) and a \Constants\ class for shared configuration keys, providing a more robust and extensible foundation for client-side property management.

client-basic/src/main/java/com/alibaba/nacos/client/constant, client-basic/src/main/java/com/alibaba/nacos/client/env, nacos-client-basic · high confidence

New naming selector interfaces introduced

The API module now exposes three new interfaces in the \com.alibaba.nacos.api.naming.selector\ package to support service instance selection: \NamingContext\ provides access to service metadata (name, group, clusters) and the current list of instances; \NamingResult\ extends \SelectResult\ to wrap the selected instances; and \NamingSelector\ extends the generic \Selector\ interface to define the contract for selecting instances based on the context. These interfaces form the foundation for pluggable naming selectors within the Nacos client.

api/src/main/java/com/alibaba/nacos/api/naming/selector · high confidence

New network and string utility classes added to API module

The API module now includes two new utility classes: NetUtils, which provides methods to retrieve the local IP address or hostname based on system properties and network interface status, and StringUtils, which offers standard string manipulation methods such as isEmpty, isBlank, trim, and equals. These utilities are now available for use within the Nacos API layer, replacing previous dependencies or implementations for these common tasks.

api/src/main/java/com/alibaba/nacos/api/utils · high confidence

New parameter extractors for AI agent, skill, prompt, and MCP APIs

This change introduces a suite of new HTTP and RPC parameter extractors in the \ai/src/main/java/com/alibaba/nacos/ai/param\ package to support the recently added AI capabilities. Specifically, it adds \AgentAdminHttpParamExtractor\ and \AgentClientHttpParamExtractor\ for agent administration and client watch operations, \AgentHttpParamExtractor\ and \AgentSpecHttpParamExtractor\ for handling agent and agent spec cards, \SkillHttpParamExtractor\ and \SkillListHttpParamExtractor\ for skill management and search, \PromptHttpParamExtractor\ for prompt data ID resolution, \McpHttpParamExtractor\ for MCP server parameters, and \AiResourceSearchHttpParamExtractor\ for generic AI resource searches. These components ensure that request parameters (such as namespace, names, and search criteria) are correctly parsed and validated for the new AI endpoints.

ai/src/main/java/com/alibaba/nacos/ai/param · high confidence

New pipeline execution query service

A new PipelineQueryService has been added to the AI module, enabling users to retrieve individual pipeline executions by ID and list executions with pagination support. This service acts as the backend logic for querying pipeline execution data, integrating with the existing repository to fetch results based on resource type, name, namespace, and version filters.

ai/src/main/java/com/alibaba/nacos/ai/service/pipeline · high confidence

New prompt lifecycle and client query services with MD5-based conditional fetching

The prompt service layer now includes dedicated services for managing the full prompt lifecycle and handling client-side queries. PromptOperationService and its implementation manage the complete governance flow (draft, submit, review, publish, online/offline) and metadata operations, mirroring the existing skill governance model. Additionally, a new PromptClientOperationService provides a client-facing query API that supports MD5-based conditional fetching, allowing SDK clients to efficiently detect updates via long-polling without transferring unchanged data. A background PromptDownloadCountManager also tracks prompt usage by accumulating download events in memory and flushing them to the database periodically.

ai/src/main/java/com/alibaba/nacos/ai/service/prompt · high confidence

New remote request types for connection management and capability negotiation

The API module introduces a new set of remote request classes to support internal communication, connection lifecycle, and feature negotiation. Key additions include ConnectionSetupRequest and SetupAckRequest for establishing connections and exchanging capability tables, ConnectResetRequest for handling connection resets, and ServerCheckRequest/HealthCheckRequest for server health monitoring. Additionally, RequestMeta now exposes client capabilities via an ability table, and new requests like ServerReloadRequest and ServerLoaderInfoRequest enable server-side reload and load information retrieval.

api/src/main/java/com/alibaba/nacos/api/remote/request · high confidence

New request forms for skill administration and lifecycle management

This change introduces a suite of new request-form classes in the AI skills admin module to support updated skill management capabilities. Users can now update business tags and labels, manage skill visibility scopes (public/private), and control skill online/offline status. The forms also enable creating skill drafts (including forking existing versions), publishing specific versions, and submitting skills, while the list form now supports sorting by download count. Additionally, the publish form deprecates the manual 'latest' label update flag, as the server now manages this label automatically.

ai/src/main/java/com/alibaba/nacos/ai/form/skills/admin · high confidence

New resource parser infrastructure in auth module

The auth module now includes a new resource parsing framework located in the \com.alibaba.nacos.auth.parser\ package. This introduces the \ResourceParser\ interface and an \AbstractResourceParser\ base class that standardizes how access requests are converted into \Resource\ objects, extracting namespace, group, name, and action details. A key behavioral addition is the \injectTagsToProperties\ method, which automatically maps tags defined in the \@Secured\ annotation to the resource's properties. The module also provides a \DefaultResourceParser\ that returns an empty resource, serving as a fallback or placeholder for resources that do not require specific parsing logic.

auth/src/main/java/com/alibaba/nacos/auth/parser · high confidence

New runtime exception hierarchy for serialization and loading errors

The API module now introduces a structured runtime exception hierarchy under \com.alibaba.nacos.api.exception.runtime\. \NacosRuntimeException\ serves as the base unchecked exception, carrying a specific error code. Two specialized subclasses have been added: \NacosSerializationException\ for failures during data serialization and \NacosDeserializationException\ for failures during data deserialization, both of which can identify the specific class involved in the error. Additionally, \NacosLoadException\ is provided as a general unchecked exception for service loading failures. This allows callers to catch specific runtime error types rather than generic exceptions.

api/src/main/java/com/alibaba/nacos/api/exception/runtime · high confidence

New sys module infrastructure for bean deduplication and module state

The nacos-sys module now includes core infrastructure classes to support advanced runtime management. A new AbstractNacosDuplicateBeanPostProcessor allows the system to reuse existing Spring beans from the core context instead of rebuilding them, reducing memory usage. Additionally, a NacosTypeExcludeFilter enables configurable exclusion of specific packages and classes during component scanning, while a ModuleState class provides a mechanism to track and retrieve named states for different modules.

nacos-sys · high confidence

New unified bootstrap module for flexible Nacos deployment modes

Nacos now includes a dedicated bootstrap module that introduces a new startup entry point (NacosBootstrap) and a synchronized application.properties file. This change enables three distinct deployment modes—MERGED (default, running server and console together), SERVER (server only), and CONSOLE (console only)—controlled via the nacos.deployment.type system property. The bootstrap logic orchestrates the startup of core, server-web, and console contexts as separate Spring Boot applications sharing a parent context, and conditionally initializes the AI registry based on specific feature flags. A new test ensures the bootstrap configuration remains consistent with the distribution configuration and verifies that authentication is enabled by default.

bootstrap · high confidence

New utility classes for Agent and RAD API validation, canonicalization, and logging

Added a suite of utility classes in the API module to standardize how Agent and RAD (Resource Agent Discovery) data is handled across server and SDK adapters. A2aAgentCardUtils normalizes legacy and current A2A Agent Cards, ensuring required fields are present and mapping old protocol fields to the new supportedInterfaces structure. A2aEndpointUtils converts legacy A2A endpoint addresses into canonical RAD payloads and projects RAD endpoints back to A2A interfaces. AgentDiscoveryCanonicalizer ensures that Discover requests and results are deterministically sorted, deduplicated, and fingerprinted using SHA-256, guaranteeing consistent identity across clients and servers. AgentModelValidator and AgentValidationUtils enforce structural limits (e.g., name lengths, tag counts) and format rules (e.g., namespace patterns, version syntax) for Agent resources. AgentVersion and AgentVersionRange provide strict, case-sensitive parsing and comparison for Agent versions and Maven-style version intervals. Finally, AgentWatchLogUtils generates safe, non-reversible tokens for logging Watch operations without exposing sensitive metadata or selector values.

api/src/main/java/com/alibaba/nacos/api/ai/utils · high confidence

New utility classes for server identity and auth logging

The auth module now includes AuthHeaderUtil to attach server identity headers to HTTP and gRPC requests when server identity support is enabled, and Loggers to provide centralized logging configuration for the auth component.

auth/src/main/java/com/alibaba/nacos/auth/util · high confidence

Oracle database support added

Nacos now supports Oracle as a database backend. This change introduces the \nacos-datasource-plugin-oracle\ module, which provides the Oracle dialect, a trusted SQL function enum to prevent injection, and specific mapper implementations for all core tables (config, history, tenant, group capacity, and AI resources) along with the corresponding Oracle schema definitions.

plugin-default-impl/nacos-default-datasource-plugin/nacos-datasource-plugin-oracle · high confidence

Persist AI pipeline execution records to the database

The system now saves and retrieves AI pipeline execution history using a new JDBC-based repository. This change introduces persistence for pipeline execution records, allowing users to query past executions by resource type, name, namespace, and version with pagination support. The implementation stores execution details, including status and node results, in the \pipeline\_execution\ database table.

ai/src/main/java/com/alibaba/nacos/ai/pipeline/repository · high confidence

PostgreSQL datasource plugin adds dialect support and AI resource mappers

This release introduces the PostgreSQL implementation for Nacos's plugin-based datasource architecture. It adds a dedicated dialect class that handles PostgreSQL-specific behaviors, including correct pagination syntax (OFFSET/LIMIT), default JDBC driver registration, and recognition of PostgreSQL unique constraint violations. The plugin also provides PostgreSQL-specific mapper implementations for core configuration tables (ConfigInfo, TenantInfo, GroupCapacity, etc.) and new AI resource tables (AiResource, AiResourceVersion), ensuring proper SQL generation and timestamp handling. Additionally, it includes the full PostgreSQL schema definition, upgrade scripts for tenant ID constraints and visibility permissions, and a SQL script for granting appropriate database permissions to the Nacos application role.

plugin-default-impl/nacos-default-datasource-plugin/nacos-datasource-plugin-postgresql · high confidence

PostgreSQL pgvector support for AI resource search indexing

Users can now store and search AI resource embeddings in PostgreSQL using the pgvector extension. This change introduces the \PostgresqlAiResourceVectorIndex\ plugin, which manages a dedicated \ai\_resource\_search\_embedding\_pg\ table (schema provided in \pg-ai-vector-schema.sql\) for vector storage, and registers itself via the \AiResourceVectorIndexBuilder\ SPI. It supports full CRUD operations for resource versions, vector similarity search with configurable limits, and transactional updates to ensure consistency. The feature is accompanied by integration and unit tests verifying SPI discovery, schema availability, and transactional rollback behavior.

ai/src/main/java/com/alibaba/nacos/ai/model/search, plugin-default-impl/nacos-default-ai-vector-plugin · high confidence

RAD Agent search and discovery service foundations

The Agent service layer now supports RAD-based search and discovery, introducing a new \AgentDiscoveryApplicationService\ that routes queries to either a shared search index or a legacy scan path based on the \RAD\_SEARCH\_MODE\ configuration. A \AgentClientMigrationGuard\ enforces that RAD operations are only admitted after the historical A2A migration completes, while \AgentArtifactBuilder\ provides version-pinned artifact representations for both A2A and Nacos schemas. The \AgentOperationService\ and \AgentPersistenceService\ have been expanded to handle the full Agent lifecycle, including draft creation, version persistence, and publication workflows via \AgentPublishApplicationService\.

ai/src/main/java/com/alibaba/nacos/ai/service/agent · high confidence

Registration of AI plugin providers, type policies, and parameter extractors

The AI module now registers its core components via Java SPI service files in META-INF/services. This includes four AI plugin providers (Pipeline, Resource Import, Storage, Vector) and their corresponding type policies, enabling the system to discover and manage these plugins. Additionally, HTTP and RPC parameter extractors for MCP, Agent, Skill, and Admin APIs are registered, and the NacosConfig storage builder is exposed for AI resource storage. An enabled filter is also registered to control AI feature availability.

ai/src/main/resources · high confidence

Registration of new remote payload types for service discovery and AI features

The system now explicitly registers a comprehensive set of remote payload classes via the Java SPI mechanism, enabling support for new capabilities. This includes requests and responses for configuration fuzzy watch (e.g., ConfigFuzzyWatchRequest), naming fuzzy watch (e.g., NamingFuzzyWatchRequest), distributed locking (LockOperationRequest), and AI/MCP services (QueryMcpServerRequest, QueryAgentCardRequest, AgentEndpointRequest). Users benefit from the underlying infrastructure required for these new remote communication patterns without needing manual configuration.

api/src/main/resources · high confidence

Remote implementation for user and role management in the Nacos auth plugin

The default authentication plugin now includes remote service implementations for managing users and roles. Specifically, \NacosUserServiceRemoteImpl\ and \NacosRoleServiceRemoteImpl\ handle operations such as creating, updating, and deleting users and roles, as well as querying permissions and role assignments. These changes enable the auth plugin to perform user and role management tasks by making remote HTTP requests to the Nacos server, supporting features like role-based access control and user credential management in distributed or clustered environments.

default-auth-plugin · high confidence

Rolling-upgrade migration for Nacos 3.0-3.2 A2A Agent data

This change introduces a temporary compatibility layer to migrate historical A2A Agent definitions from Nacos 3.0-3.2 to the new canonical model. The \ai/src/main/java/com/alibaba/nacos/ai/service/a2a/migration\ package adds a complete migration subsystem including a scanner to read historical Config data, a reconciler to convert and write canonical Agent definitions, and a control store to manage migration state (SYNCING, QUIESCING) and leases. It also includes a mutation guard to prevent writes to migration-owned Agents during the process, a write-after hook to trigger reconciliation, and a cutover coordinator to manage the transition to the new state. This ensures data continuity during the upgrade window.

ai/src/main/java/com/alibaba/nacos/ai/service/a2a/migration · high confidence

Server-side Agent Watch delivery for gRPC and HTTP transports

The server now supports Agent Watch, allowing clients to subscribe to fingerprint-based change notifications for Agent definitions and versions. This change introduces the server-side implementation for two transport mechanisms: a connection-scoped gRPC Watch service that pushes updates via \AgentDiscoveryNotifyRequest\, and a request-scoped HTTP Batch Long Poll service that returns \AgentWatchBatchResponse\ when watched items change. The implementation includes the admission and lifecycle management for both transports (via \AgentGrpcWatchService\ and \AgentHttpWatchService\), a unified registry system for tracking active watches and projections, and a task engine for merging and scheduling delivery hints to ensure efficient fan-out to waiting clients.

ai/src/main/java/com/alibaba/nacos/ai/service/agent/watch · high confidence

Support for independent console and server deployment modes

The sys module now introduces a DeploymentType enum and associated constants to distinguish between merged, server-only, console-only, and server-with-MCP deployments. This enables the console and server to start with different web containers and ports, supporting independent console deployment. The change includes new module state builders (AbstractConsoleModuleStateBuilder, AbstractServerModuleStateBuilder) that conditionally activate based on the deployment type, and a bean post-processor (NacosDuplicateConfigurationBeanPostProcessor) to reduce duplicate Spring bean rebuilds, thereby lowering memory usage.

sys · high confidence

Architecture

Extract common client utilities to the client-basic module

The Nacos client refactors its codebase by moving shared utility classes into the new \client-basic\ module. This change introduces new utility classes for handling basic parameters (\ClientBasicParamUtil\), context paths (\ContextPathUtil\), template string execution (\TemplateUtils\), and tenant identification (\TenantUtil\). Additionally, the existing \AppNameUtils\ class has been migrated from the \client\ module to \client-basic\, with its implementation updated to use \NacosClientProperties\ for property resolution instead of direct system property access, ensuring consistent configuration handling across the client.

client-basic/src/main/java/com/alibaba/nacos/client/utils · high confidence

Nacos address server is restructured into a standalone module

The address server functionality has been extracted from the console module into its own dedicated module. The main entry point has been renamed from Nacos to AddressServer, and the application now uses a new component-based architecture with AddressServerManager and AddressServerGeneratorManager to handle instance generation and IP parsing. This change also introduces a new constant interface, AddressServerConstants, to centralize configuration values such as default ports and separators, and updates the logging infrastructure to use a dedicated logger for the address server.

address/src/main/java/com/alibaba/nacos/address/component · high confidence

Refactored AI resource management with shared logic and cluster change notifications

The AI resource service layer has been refactored to consolidate duplicated logic from specific resource types (like Skills and AgentSpecs) into a shared \AiResourceManager\ and common data structures (\ResourceVersionInfo\, \PublishPipelineInfo\). This centralization improves maintainability for common operations such as CAS updates, version resolution, and pipeline callbacks. Additionally, the update introduces a new event-driven notification system for AI resource changes, including \AiResourceChangeNotifier\ and \AiResourceClusterChangePublisher\, which allows the server to broadcast logical resource mutations to peer nodes for cluster-wide consistency.

ai/src/main/java/com/alibaba/nacos/ai/service/resource · high confidence

Behavioural changes

Address server now enforces HTTP Basic authentication

The address server module now includes a dedicated security configuration that requires authentication for requests to the /nacos/v1/as/\\ endpoint. This change, part of the broader upgrade to Spring Security 6 (Spring Boot 3), replaces the previous unsecured access model with HTTP Basic authentication, ensuring that only authorized users can interact with the address server's API endpoints.

address/src/main/java/com/alibaba/nacos/address/config · high confidence

Admin API form validation for agent registration and listing

The admin API now enforces stricter validation for agent operations. Registration requires a non-empty agent card and a valid registration type (defaulting to URL if omitted), while updates allow omitting the registration type to preserve the existing value. Agent listing requests now require the search parameter to be explicitly set to either 'accurate' or 'blur'.

ai/src/main/java/com/alibaba/nacos/ai/form/a2a · high confidence

Config API refactored with request/result objects and 304 caching support

The config API in the api module has been refactored to use a Request/Result pattern for configuration operations, introducing new classes such as GetConfigRequest, PublishConfigRequest, and RemoveConfigRequest alongside their corresponding result objects (ConfigQueryResult, PublishConfigResult, RemoveConfigResult). This change enables advanced features like 304-based conditional GET for efficient cache validation and CAS (Compare-And-Swap) publishing for encrypted configurations, while providing detailed error information on failures. The ConfigService interface now exposes these new methods (e.g., getConfig(GetConfigRequest), publishConfig(PublishConfigRequest)) alongside the legacy ones, and the ConfigFactory has been updated to use reflection for service instantiation. Additionally, the ConfigType enum has been expanded to include TOML support, and a new ConfigChangeEvent/ConfigChangeItem structure has been added to support fuzzy watch capabilities.

api/src/main/java/com/alibaba/nacos/api/config · high confidence

Config filter interfaces moved to API module and refined

The config filter interfaces (IConfigFilter, IConfigRequest, IConfigResponse, IConfigContext, IConfigFilterChain) and the AbstractConfigFilter base class have been relocated from the client and naming modules into the api module's com.alibaba.nacos.api.config.filter package. The IConfigFilter interface now requires implementations to extend AbstractConfigFilter, and its init method signature was changed to accept java.util.Properties instead of IFilterConfig. Additionally, IConfigRequest and IConfigResponse now expose putParameter methods, and the getConfigContext methods on both interfaces are marked as deprecated.

api/src/main/java/com/alibaba/nacos/api/config/filter · high confidence

Config module API requests migrated to remote request model

The Nacos config module's remote communication model has been updated to use a new set of request classes in the \api\ module, replacing the previous server-side task and model classes. This change introduces dedicated request types for config operations, including \ConfigQueryRequest\ (which now supports 304 conditional GET via a \localMd5\ field), \ConfigPublishRequest\, \ConfigRemoveRequest\, \ConfigChangeNotifyRequest\, and \ConfigBatchListenRequest\. It also adds support for fuzzy watching of configurations through \ConfigFuzzyWatchRequest\, \ConfigFuzzyWatchSyncRequest\, and \ConfigFuzzyWatchChangeNotifyRequest\, along with a new \ClientConfigMetricRequest\ for client-side metrics. The base \AbstractConfigRequest\ has been moved from the server module to the API module to serve as the common parent for these remote requests.

api/src/main/java/com/alibaba/nacos/api/config/remote/request · high confidence

Deprecated legacy client and server ability containers

The legacy \ClientAbilities\ and \ServerAbilities\ classes in the API module are now marked as deprecated. These classes serve as containers for client and server capabilities (remote, config, and naming abilities) and are intended to be replaced by the new ability API structure.

api/src/main/java/com/alibaba/nacos/api/ability · high confidence

Health checkers now use Jackson for serialization

The health check configuration objects in the API module have been updated to use Jackson instead of Fastjson for JSON serialization and deserialization. This change ensures consistent JSON handling across the Nacos API and allows for the registration of custom health checker types via the HealthCheckerFactory, improving extensibility and reliability when persisting or transmitting health check configurations.

api/src/main/java/com/alibaba/nacos/api/naming/pojo/healthcheck · high confidence

Introduce A2A compatibility layer for legacy-to-canonical migration

This change adds a compatibility routing layer for the A2A service that allows the system to operate in either legacy or canonical definition modes. It introduces a new \A2aCanonicalDefinitionConverter\ to normalize legacy AgentCard data into the canonical Agent model, and an \A2aCompatibilityOperationService\ that routes definition operations (register, update, delete, query) to either the legacy or canonical implementation based on a configurable \nacos.ai.a2a.compatibility.mode\ property or automatic migration state. This ensures that existing A2A clients and data remain functional during the transition to the new canonical Agent runtime.

ai/src/main/java/com/alibaba/nacos/ai/service/a2a · high confidence

Introduce AI resource import configuration properties

The AI resource import module now exposes explicit configuration properties via the new \AiResourceImportProperties\ class. Users can control the module's activation using the standard \nacos.plugin.ai-resource-import.enabled\ property, which takes precedence over the legacy \nacos.ai.resource.import.enabled\ key (now deprecated and scheduled for removal in Nacos 4.0.0). Additionally, the deprecated \nacos.ai.resource.import.allow-user-url\ property allows or restricts user-provided URLs in the legacy MCP import API, with a planned removal in version 3.4.0.

ai/src/main/java/com/alibaba/nacos/ai/importer/config · high confidence

Introduce MCP server indexing with memory caching and database fallback

The AI module now includes a new MCP server indexing layer in the \ai.index\ package to improve lookup performance and consistency. This change introduces a \McpCacheIndex\ interface and a \MemoryMcpCacheIndex\ implementation backed by Guava, which replaces the previous hand-written LRU list to eliminate read-path lock contention. A \CachedMcpServerIndex\ implementation combines this memory cache with database queries via \ConfigQueryChainService\, providing a fallback to the database on cache misses. A legacy-compatible \PlainMcpServerIndex\ is also added for direct database access, while the \McpServerIndex\ interface is marked as deprecated for future removal.

ai/src/main/java/com/alibaba/nacos/ai/index · high confidence

Introduce dedicated health-checker model classes for HTTP, MySQL, and TCP

The API module now includes specific POJO classes for service health-check configurations: \Http\ (with path, headers, and expected response code), \Mysql\ (with user, password, and command), and \Tcp\. These classes extend \AbstractHealthChecker\ and replace the previous generic or misnamed model (such as the old \ConfigInfo4Beta\ file that was repurposed into \Tcp\), providing a structured, type-safe way to define and serialize health-check parameters for these protocols.

api/src/main/java/com/alibaba/nacos/api/naming/pojo/healthcheck/impl · high confidence

Introduces structured prompt management forms with versioning, labels, and tags

The prompt configuration API now uses a set of dedicated form objects to handle prompt lifecycle operations, replacing or supplementing previous ad-hoc input handling. Users can now create drafts (with optional version forking), publish prompts with strict semantic versioning (major.minor.patch), and manage metadata including descriptions, business tags, and semantic labels. The system supports querying prompts by key, label, or version, and allows updating labels and business tags independently of the template content. A key behavioral change is that the 'latest' label is now managed automatically by the server rather than by client flags, with legacy client compatibility maintained via a deprecated parameter.

ai/src/main/java/com/alibaba/nacos/ai/form/prompt · high confidence

MCP lifecycle management cutover and compatibility layer

The MCP service now supports a managed lifecycle state (draft, submit, publish, redraft) alongside the previous direct-release model. A new compatibility layer routes operations to either the legacy service or the new lifecycle engine based on a cluster-wide migration marker, ensuring a safe transition. The update introduces a reconciliation process to migrate historical MCP resources into the new lifecycle rows, a canonical authorization service to validate access for legacy ID-only requests, and a client application service to handle endpoint registration and release operations.

ai/src/main/java/com/alibaba/nacos/ai/service/mcp · high confidence

Move Page model to API module and introduce NacosForm interface

The Page model has been moved from the config server module to the core API module, making it available for broader use across the platform. Additionally, a new NacosForm interface has been added to the API model package to standardize validation for HTTP form API objects.

api/src/main/java/com/alibaba/nacos/api/model · high confidence

Nacos 3.0 distribution overhaul: native startup, unified config, and security hardening

The distribution package has been restructured for Nacos 3.0, introducing a new \startup-native.sh\ script to support GraalVM native image execution alongside the traditional Java startup. The legacy \application.properties.example\ and \schema.sql\ files have been removed in favor of a comprehensive, modernized \application.properties\ that replaces the old \db.\\ properties with the \nacos.plugin.datasource.\\ namespace and enables servlet encoding by default. Security is strengthened by enforcing a Base64-encoded \nacos.core.auth.nacos.token.secret.key\ (minimum 32 bytes) during startup and standardizing plugin configuration keys. The distribution also adds IPv6 migration SQL, console UI disablement guides, and new assembly descriptors (\release-native.xml\) to package native binaries and plugins correctly.

distribution · high confidence

NacosException refactored to support exception chaining and improved error message resolution

The NacosException class has been moved to the api module and significantly refactored to improve how errors are handled and reported. It now supports exception chaining via a new causeThrowable field and additional constructors, allowing underlying causes to be preserved. The getErrMsg() method has been updated to automatically fall back to the cause's message if the primary error message is blank, ensuring users always see meaningful error details. A new error code, CLIENT\_DISCONNECT (-401), has also been added.

api/src/main/java/com/alibaba/nacos/api/exception · high confidence

NacosFactory API expansion and property constants consolidation

The NacosFactory class has been moved to the api module and now exposes factory methods for the distributed lock service (createLockService) and the naming maintain service (createMaintainService, now deprecated in favor of the nacos-maintainer-client artifact). Additionally, the PropertyKeyConst and SystemPropertyKeyConst classes have been introduced to centralize configuration keys, adding support for endpoint parsing rules, RAM info parsing, client metrics, and various naming/config thread and timeout settings.

api/src/main/java/com/alibaba/nacos/api · high confidence

Naming module adopts v2 health-check architecture with extensible processors and SPI-based push hooks

The naming module introduces a v2 health-check infrastructure that replaces the previous single-threaded beat logic with an interceptor-chain model (InstanceBeatCheckTask) and new v2-specific tasks (ClientBeatCheckTaskV2, ClientBeatProcessorV2, ClientBeatUpdateTask). It adds extensible health-check processors for HTTP, TCP, and MySQL (HealthCheckProcessorV2Delegate, HttpHealthCheckProcessor, TcpHealthCheckProcessor, MysqlHealthCheckProcessor) loaded via SPI, along with snapshot persistence support (AbstractSnapshotOperation) and a delegate push executor (PushExecutorDelegate) that routes pushes via SPI implementations and exposes push-result hooks (PushResultHookHolder). Fuzzy-watch support is extended with delay tasks (FuzzyWatchChangeNotifyTask, FuzzyWatchPushDelayTaskEngine). For users, this means more robust and configurable health checks, better extensibility for custom processors and push behaviors, and improved reliability in instance state synchronization and push delivery.

nacos-naming · high confidence

New SPI-based ability initialization interfaces introduced

The API module now exposes two new interfaces for managing feature capabilities: AbilityInitializer, which is marked as deprecated, and AbilityPostProcessor, which is designed to be loaded via SPI. AbilityPostProcessor allows implementations to process ability configurations (such as SDK client, server, or cluster client modes) before the ability controller loads them, enabling extensible initialization logic for system abilities.

api/src/main/java/com/alibaba/nacos/api/ability/initializer · high confidence

New auth configuration model and error codes

The auth module introduces a new configuration model to manage authentication settings. A new \AuthErrorCode\ enum defines specific error codes (50001, 50002) for invalid auth types and empty identity configurations, directing users to updated documentation at nacos.io. The \NacosAuthConfig\ interface standardizes access to auth scope, enabled status, plugin type, and server identity details. \NacosAuthConfigHolder\ implements an SPI-based loader to discover and manage these configurations by scope, providing utilities to check if any auth is enabled across scopes or specific ones, and retrieving the global auth system type.

auth/src/main/java/com/alibaba/nacos/auth/config · high confidence

New identity context builders for HTTP and gRPC requests

The authentication module now includes dedicated builders for extracting identity context from HTTP and gRPC requests. The new \HttpIdentityContextBuilder\ extracts identity parameters from both headers and query parameters, performing case-insensitive matching against names defined by the active auth plugin, and resolves the remote IP via X-Forwarded-For, X-Real-IP, or the socket address. The \GrpcIdentityContextBuilder\ extracts identity parameters from gRPC request headers and sets the remote IP from the X-Real-IP header. Both implementations delegate to the \AuthPluginManager\ to determine which identity fields to recognize based on the configured auth system type.

auth/src/main/java/com/alibaba/nacos/auth/context · high confidence

Protocol-specific authentication service implementations for HTTP and gRPC

Nacos now introduces dedicated authentication services for HTTP and gRPC protocols, replacing the previous monolithic approach. The new \HttpProtocolAuthService\ and \GrpcProtocolAuthService\ handle identity parsing and resource validation specific to their respective protocols, utilizing protocol-aware resource parsers for naming, config, and AI resources. This change ensures that server identity checks and permission validations are correctly applied based on the incoming request type, improving the precision and security of access control for both REST and gRPC APIs.

auth/src/main/java/com/alibaba/nacos/auth · high confidence

Refactor naming API pojo classes and migrate Cluster to api module

The naming API data models in the \api\ module have been refactored and standardized: \Instance\, \Service\, and \ServiceInfo\ are now defined as new POJOs with Jackson serialization support (\@JsonInclude(NON\_NULL)\) and validation logic, while the \Cluster\ class has been moved from the client module to the API module and updated to use the new \Tcp\ health checker implementation and consistent naming conventions. Additionally, the internal \LoggerInfo\ class has been replaced by a generic \ListView\<T\>\ wrapper to standardize paginated list responses across the API.

api/src/main/java/com/alibaba/nacos/api/naming/pojo · high confidence

Refactored control plugin with new manager center and adapter architecture

The control plugin has been restructured to use a centralized \ControlManagerCenter\ that manages a \ControlManagerBundle\ of connection and TPS control managers, replacing the previous direct instantiation pattern. A new \ControlPluginAdapter\ now handles plugin lifecycle and configuration application, delegating to the center. The refactoring introduces dedicated rule parsers (JSON-based via JacksonUtils) for both connection and TPS rules, a \ControlRuleChangeActivator\ to subscribe to rule change events and persist/load rules from local disk or external storage, and a \DefaultConnectionControlManager\ that acts as a no-limit fallback. This change improves modularity, rule handling consistency, and plugin initialization flow.

plugin/control · high confidence

Refactored default authentication plugin with improved security and visibility controls

The built-in Nacos authentication plugin has been restructured into a modular implementation (AbstractNacosAuthPluginService, NacosAuthPluginService) that supports runtime configuration for token secrets, expiration, and caching. A new SafeBcryptPasswordEncoder addresses the Spring Security password length vulnerability ([GHSA redacted]) by rejecting passwords exceeding 72 characters. The plugin now includes a DefaultVisibilityService to manage resource-level visibility permissions and an AnonymousAccessInitializer to asynchronously reconcile anonymous user identities for AI endpoints. Additionally, authentication logic now strictly validates that usernames and passwords are not blank before attempting lookup, and the plugin integrates with the new visibility plugin SPI for fine-grained access control.

plugin-default-impl/nacos-default-auth-plugin · high confidence

Refactored naming remote request types and added fuzzy watch support

The naming module's remote request classes have been reorganized into a new hierarchy under \com.alibaba.nacos.api.naming.remote.request\, introducing base classes \AbstractNamingRequest\ and \AbstractFuzzyWatchNotifyRequest\ to standardize namespace, service, and group handling. New request types have been added to support specific operations, including \BatchInstanceRequest\ for bulk registration, \PersistentInstanceRequest\ for persistent instance management, and \NotifySubscriberRequest\ for service updates. Additionally, the API now includes \NamingFuzzyWatchRequest\, \NamingFuzzyWatchSyncRequest\, and \NamingFuzzyWatchChangeNotifyRequest\ to enable fuzzy watch capabilities, alongside constants in \NamingRemoteConstants\ to define request types for gRPC communication.

api/src/main/java/com/alibaba/nacos/api/naming/remote/request · high confidence

Refactored server authentication and authorization into modular, pluggable components

The core module's authentication and authorization logic has been restructured to support a plugin-based architecture and distinct scopes for different API types. A new \AbstractWebAuthFilter\ serves as the base for \AuthFilter\ (handling SDK/Open APIs) and \AuthAdminFilter\ (handling Admin APIs), allowing for separate configuration and lifecycle management. The system now uses \AuthPluginTypePolicy\ and \AuthPluginTypeResolver\ to dynamically select and initialize the authentication plugin, migrating from legacy configuration keys to standard ones. Additionally, a new \InnerApiAuthEnabled\ component manages a rolling upgrade path from 2.x to 3.x by delaying strict identity checks for internal APIs until all cluster nodes are confirmed to be on the upgraded version, ensuring backward compatibility during upgrades.

core · high confidence

Registration of server list and authentication service providers

The client now automatically discovers and registers specific implementations for server list resolution and authentication via Java SPI configuration files. Users benefit from the inclusion of \EndpointServerListProvider\ and \PropertiesListProvider\ for server address management, and the explicit registration of \NacosClientAuthServiceImpl\, \RamClientAuthServiceImpl\, and \OidcClientAuthServiceImpl\ to support OIDC client-side authentication via the Client Credentials Flow alongside existing auth mechanisms.

client-basic/src/main/resources · high confidence

Separate client and server capability negotiation tables

The ability registry has been refactored to maintain distinct capability tables for SDK clients, cluster clients, and the server itself. SDK clients now explicitly declare support for features such as fuzzy watch, distributed locks, MCP and agent registries, and RAD watch, while the server declares its own capabilities including persistent instance registration via gRPC, fuzzy watch, distributed locks, MCP and agent registries, and RAD support. This separation allows clients to check server support for specific abilities before attempting requests, ensuring compatibility and enabling graceful degradation when a connected server does not support capability negotiation.

api/src/main/java/com/alibaba/nacos/api/ability/register · high confidence

Server startup split into basic and web applications with servlet encoding

The server now starts using two distinct Spring Boot entry points: NacosServerBasicApplication for common non-web beans and NacosServerWebApplication for web container beans, allowing the console and server to potentially run with different web containers and ports. This split is supported by new type filters (NacosWebBeanTypeFilter, NacosNormalBeanTypeFilter) that separate web and non-web components during component scanning. Additionally, the server now explicitly enables UTF-8 servlet encoding via nacos-server.properties, ensuring consistent character handling in HTTP requests and responses.

server · high confidence

Standardize MD5 calculation and improve ConfigInfoBase model

The ConfigInfoBase model now uses the shared MD5Utils from the common module instead of the local MD5 utility, ensuring consistent MD5 generation across the client and server sides. Additionally, the class imports Jackson annotations and updates its structure to support proper serialization and comparison, laying the groundwork for consistent handling of configuration data IDs and content.

nacos-config · high confidence

Standardized datasource configuration and unified persistence module

The persistence module now centralizes datasource configuration and initialization. A new DatasourceConfiguration class determines whether to use embedded (Derby) or external storage based on the platform and standalone mode. Configuration properties have been standardized under the nacos.plugin.datasource.db prefix (with legacy db.\* support), and a DatasourceConfigResolver handles property resolution and deprecation warnings. The DynamicDataSource class now acts as a central adapter, routing to either LocalDataSourceServiceImpl or ExternalDataSourceServiceImpl based on the configuration. External datasource setup now supports multiple data sources, resolves default JDBC drivers from DatabaseDialect plugins, and includes connection health checks.

persistence · high confidence

Stateful Agent HTTP requests are now routed to the correct cluster node

A new \AiDistroFilter\ has been introduced to manage HTTP traffic for AI Agent endpoints. This filter ensures that stateful requests, identified by a client ID header, are proxied to the specific server node responsible for that client's session, rather than being handled by any available node. This change guarantees session consistency for Agent interactions by leveraging the existing Nacos distribution mapping logic.

ai/src/main/java/com/alibaba/nacos/ai/web · high confidence

Strict validation and serialization for Agent resource metadata

The Agent resource metadata layer now enforces strict schema validation and deterministic serialization for persisted extension data. A new serializer validates and serializes Agent resource extensions against a defined schema (version 1), enforcing limits on field lengths, extension counts, and total payload size, while rejecting duplicate JSON keys. Additionally, a version catalog builder ensures that the 'latest' label always points to the highest online version and that version ordering follows strict RAD SemVer precedence, providing consistent and reliable metadata for Agent versions.

ai/src/main/java/com/alibaba/nacos/ai/service/agent/metadata · high confidence

Fixes

Agent name encoding for stable search results

The AI module now encodes agent names into safe ASCII identities before storage to prevent unexpected results during blur searches. This change introduces an \AgentIdCodec\ interface and an \AsciiAgentIdCodec\ implementation that sanitizes agent names by encoding non-alphanumeric characters (except hyphens, dots, and colons) into a standardized format. A dedicated \encodeForSearch\ method ensures that search queries match the stored identity correctly, resolving issues where unencoded names caused inaccurate search outcomes.

ai/src/main/java/com/alibaba/nacos/ai/service/a2a/identity · high confidence

Test coverage

Added OpenAPI integration tests for AI admin APIs; Added integration tests for distributed lock functionality; Added integration tests for the Maintainer SDK; Added mock implementation for AI service client tests; Added mock test utilities for auth plugin and resource parsing; Added test resources for SPAS identity and server list mocking; Added test service provider configuration for MockAuthPluginService; Added tests for AI agent client binding models and RPC requests; Added tests for AI constant status mappings; Added tests for AI resource import model serialization; Added tests for HTTP client manager and request ID interceptor; Added tests for Nacos AI config key encoding and decoding; Added tests for the new JSON adapter abstraction and selector logic; Added unit and integration tests for the address module; Added unit tests for A2A Agent model classes; Added unit tests for AI API service interfaces and remote responses; Added unit tests for AI agent API utility classes; Added unit tests for AI listener event classes; Added unit tests for AI pipeline model DTOs; Added unit tests for AI remote request serialization; Added unit tests for AI resource search models; Added unit tests for API ability registration classes; Added unit tests for API utility classes; Added unit tests for Agent API contract models and requests; Added unit tests for AgentSpec model classes and utilities; Added unit tests for Client and Server remote ability serialization; Added unit tests for ClientAbilities and ServerAbilities serialization and equality; Added unit tests for ClientNamingAbility and ServerNamingAbility; Added unit tests for HTTP resource parsers; Added unit tests for InstanceBuilder; Added unit tests for MCP API model serialization and import logic; Added unit tests for Nacos API config and naming modules; Added unit tests for Nacos API exception classes and CMDB POJOs; Added unit tests for Nacos API factory classes; Added unit tests for Nacos API naming POJOs and listeners; Added unit tests for Nacos API remote components; Added unit tests for Nacos client address resolution components; Added unit tests for Nacos config remote request and response serialization; Added unit tests for NacosProperties placeholder resolution; Added unit tests for NamingUtils service name parsing; Added unit tests for OIDC client authentication components; Added unit tests for RAM client authentication and credential management; Added unit tests for Skill API models and utilities; Added unit tests for auth configuration and utility classes; Added unit tests for client authentication implementation; Added unit tests for client-basic utility and environment classes; Added unit tests for configuration model classes; Added unit tests for gRPC and HTTP identity context builders; Added unit tests for gRPC and HTTP protocol auth services; Added unit tests for health check POJOs and factory; Added unit tests for naming maintainer POJOs; Added unit tests for prompt API model classes; Added unit tests for server identity authentication components; Added unit tests for the AI Registry adaptor module; Added unit tests for the Page model serialization and deserialization; Added unit tests for the distributed lock API models and remote requests; Added unit tests for the plugin API configuration and type models; Expanded unit test coverage for AI module configuration and lifecycle components; New Java SDK integration test suites and documentation for AI, migration, and reliability scenarios.

Dependencies

Introduce new modules and upgrade frontend dependencies

This release adds several new Maven modules to the project structure: \nacos-address\ (an address server), \nacos-ai\ and \nacos-ai-registry-adaptor\ (supporting AI resource discovery and registry integration), \nacos-client-basic\ (a minimal client dependency), and \nacos-dns\ (DNS server support for service discovery). The \nacos-copilot\ module is also introduced, integrating AgentScope Java (version 2.0.3) to enable LLM-based copilot features. On the frontend, the \console-ui-next\ module has been significantly upgraded, moving to React 19, Vite 8, and Tailwind CSS 4, while the legacy \console-ui\ remains on React 16 and Webpack 4. Additionally, the \nacos-bootstrap\ module now includes the \nacos-ai-registry-adaptor\ and \nacos-datasource-plugin-base\ dependencies to support the new AI and plugin architectures.

(dependencies) · high confidence

Housekeeping

Added Apache 2.0 license header resource

A new copyright resource file has been added to the project, containing the standard Apache 2.0 license text and copyright notice for Alibaba Group Holding Ltd. This file serves as a template or reference for applying license headers to source code files.

resources · high confidence

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

How this codebase got here

This is the PUBLIC form of this artifact. Findings are listed in full, but the details of SECURITY findings — which rule fired, in which file, on which line, and how to fix it — are deliberately withheld, and any secret-scanner results are excluded entirely. Where detail is absent here it was REMOVED FOR PUBLICATION; it is not missing from the analysis. The complete artifact is available from the repository owner.

Score

  • CAI 50 → 43 (-6.8)

Lenses

  • Code Health 54 → 53 (-1.2)
  • Architecture 84 → 84 (+0.0)
  • Maturity 71 → 69 (-1.7)
  • Readiness 53 → 41 (-11.5)
  • Security 56 → 38 (-18.1)
  • Accessibility 42 → 42 (+0.2)
  • Performance 80 → 80 (+0.0)

Resolved (507)

  • Base-context workflow trigger runs with an unscoped token
  • Dependency hygiene PARTLY measured — Maven build resolved part of the dependency graph, currency reported but not scored
  • Documentation: no project overview (README.md)
  • Duplicated block (12 lines × 2) (copilot/src/main/java/com/alibaba/nacos/copilot/service/SkillGenerationServiceImpl.java)
  • Duplicated block (12 lines × 3) (copilot/src/main/java/com/alibaba/nacos/copilot/service/PromptDebugServiceImpl.java)
  • Duplicated block (14 lines × 2) (copilot/src/main/java/com/alibaba/nacos/copilot/service/PromptDebugServiceImpl.java)
  • Duplicated block (8 lines × 2) (common/src/main/java/com/alibaba/nacos/common/json/Jackson2JsonAdapter.java)
  • High CVE: [GHSA redacted] (console-ui-next/package-lock.json)
  • High CVE: [GHSA redacted] (console-ui-next/package-lock.json)
  • High CVE: [GHSA redacted] (api/pom.xml)
  • High CVE: [GHSA redacted] (common/pom.xml)
  • High CVE: [GHSA redacted] (api/pom.xml)
  • High CVE: [GHSA redacted] (common/pom.xml)
  • High CVE: [GHSA redacted] (client-basic/pom.xml)
  • High CVE: [GHSA redacted] (sys/pom.xml)
  • High CVE: [GHSA redacted] (client-basic/pom.xml)
  • Hotspot: console-ui-next/src/pages/configdetail/index.tsx (console-ui-next/src/pages/configdetail/index.tsx)
  • Hotspot: console-ui-next/src/pages/newMcpServer/tool-manager/ToolDetail.tsx (console-ui-next/src/pages/newMcpServer/tool-manager/ToolDetail.tsx)
  • Hotspot: console-ui-next/src/pages/serviceManagement/index.tsx (console-ui-next/src/pages/serviceManagement/index.tsx)
  • Hotspot: console-ui-next/src/pages/skillManagement/components/UploadSkillDialog.tsx (console-ui-next/src/pages/skillManagement/components/UploadSkillDialog.tsx)
  • …and 487 more

New (669)

  • AiGrpcClient.requestToServer (cyclomatic 17) (client/src/main/java/com/alibaba/nacos/client/ai/remote/AiGrpcClient.java)
  • AiHttpClientProxy.resolveAgentResponse (cognitive 17) (client/src/main/java/com/alibaba/nacos/client/ai/remote/AiHttpClientProxy.java)
  • Base-context workflow trigger runs with an unscoped token (.github/workflows/pr-e2e-test.yml)
  • Critical vulnerability: [GHSA redacted] (console-ui-next/package.json)
  • Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
  • Duplicated block (11 lines × 2) (common/src/main/java/com/alibaba/nacos/common/json/Jackson2JsonAdapter.java)
  • Duplicated block (16 lines × 2) (common/src/main/java/com/alibaba/nacos/common/json/Jackson2JsonAdapter.java)
  • Duplicated block (22 lines × 2) (copilot/src/main/java/com/alibaba/nacos/copilot/service/PromptOptimizationServiceImpl.java)
  • Duplicated block (8 lines × 2) (client/src/main/java/com/alibaba/nacos/client/ai/watch/AgentWatchListenerDispatcher.java)
  • Duplicated block (8 lines × 2) (common/src/main/java/com/alibaba/nacos/common/json/Jackson2JsonAdapterDelegate.java)
  • Duplicated block (9 lines × 2) (client/src/main/java/com/alibaba/nacos/client/ai/watch/AgentWatchTransportRouter.java)
  • Duplicated block (9 lines × 2) (common/src/main/java/com/alibaba/nacos/common/json/Jackson2JsonAdapter.java)
  • GrpcAgentWatchTransport.reconnect (cognitive 17) (client/src/main/java/com/alibaba/nacos/client/ai/watch/GrpcAgentWatchTransport.java)
  • High CVE: [GHSA redacted] (console-ui-next/package-lock.json)
  • High CVE: [GHSA redacted] (console-ui-next/package-lock.json)
  • High CVE: [GHSA redacted] (console-ui-next/package-lock.json)
  • High CVE: [GHSA redacted] (console-ui-next/package-lock.json)
  • High secret: WD-SECRET-0005 (console/src/main/resources/META-INF/nacos-default.properties)
  • High: security finding (details withheld)
  • High: security finding (details withheld)
  • …and 649 more

Changes since last survey

  • 12 commits — 8 feature/other, 4 fixes

By area

  • client/src — 3 commits
  • bootstrap/src — 2 commits
  • client-basic/src — 2 commits
  • config/src — 1 commit
  • copilot/src — 1 commit
  • dns/src — 1 commit
  • naming/src — 1 commit
  • test/openapi-test — 1 commit

Notable commits

  • fix: For #15788, Fix Jackson 3-only client runtime (#15907)
  • fix: [ISSUE #15837] Fix Native Maven build and distribution packaging (#15934)
  • fix: [ISSUE #15876] Fix ephemeral instance never re-registered after reconnect (#15880)
  • fix: fix: identity-only authorization for independent Console (#15908)
  • change: For #15900, correlate SDK HTTP requests with server context (#15901)
  • change: [Enhancement] Support disabling config snapshots by property (#15871)
  • change: [ISSUE #12834] Verify history cleanup cutoff and batch limit (#15884)
  • change: [ISSUE #14804] Improve Agent SDK discovery and Watch reliability (#15927)
  • change: [ISSUE #15837] Add opt-in multi-context AOT initialization (#15933)
  • change: [ISSUE #15857] Exclude connection-based client from distro snapshot to avoid truncating redo registrations on cluster restart (#15875)
  • change: [ISSUE #15896] Migrate AgentScope stream() to streamEvents() in Copilot (#15898)
  • change: feat(dns): add SRV records, metrics, and hardened external DNS forwarding (#15877)

Architecture

  • Containers 0 added · 0 removed · contexts 1 added · 0 removed · edges 6 added · 5 removed

Added bounded contexts (1)

  • nacos-dns

Added dependency edges (6)

  • nacos-ai → nacos-ai-plugin (coupling)
  • nacos-client → nacos-common
  • nacos-core → nacos-consistency (coupling)
  • nacos-dns → nacos-naming
  • nacos-naming → nacos-common
  • nacos-naming → nacos-consistency (coupling)

Removed dependency edges (was a dependency, now gone) (5)

  • nacos-ai → nacos-ai-plugin
  • nacos-client → nacos-common (coupling)
  • nacos-core → nacos-consistency
  • nacos-naming → nacos-common (coupling)
  • nacos-naming → nacos-consistency

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

Survey your own repository

alibaba/nacos 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 23 October 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit ef52650006d1086bb1007a223e35875cb63ec146 — the exact code this score is about.
  • Scored under rubric-2026.10.5 — the same rubric and the same method as every other entry in this index.
  • Measured by watchdog.canine.dev using codehealth-analyzer measure-2026.10.6+preprod-d36780c2d857.