Nexus Standalone: Start + Describe (#9487)

Add Nexus Standalone Describe and Start handlers.

- [ ] built
- [ ] run locally and tested manually
- [ ] covered by existing tests
- [x] added new unit test(s)
- [x] added new functional test(s)

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: stephanos

chasm/lib/nexusoperation/config.go

@@ -212,7 +212,9 @@ type Config struct {
 	UseSystemCallbackURL                dynamicconfig.BoolPropertyFn
 	UseNewFailureWireFormat             dynamicconfig.BoolPropertyFnWithNamespaceFilter
 	RecordCancelRequestCompletionEvents dynamicconfig.BoolPropertyFn
-	RetryPolicy                         dynamicconfig.TypedPropertyFn[backoff.RetryPolicy]
+	VisibilityMaxPageSize               dynamicconfig.IntPropertyFnWithNamespaceFilter
+	MaxIDLengthLimit                    dynamicconfig.IntPropertyFn
+	RetryPolicy                         func() backoff.RetryPolicy
 }
 
 func configProvider(dc *dynamicconfig.Collection, cfg *config.Persistence) *Config {
@@ -234,6 +236,8 @@ func configProvider(dc *dynamicconfig.Collection, cfg *config.Persistence) *Conf
 		CallbackURLTemplate:                CallbackURLTemplate.Get(dc),
 		UseSystemCallbackURL:               UseSystemCallbackURL.Get(dc),
 		UseNewFailureWireFormat:            UseNewFailureWireFormat.Get(dc),
+		VisibilityMaxPageSize:              dynamicconfig.FrontendVisibilityMaxPageSize.Get(dc),
+		MaxIDLengthLimit:                   dynamicconfig.MaxIDLengthLimit.Get(dc),
 		RetryPolicy:                        RetryPolicy.Get(dc),
 	}
 }

chasm/lib/nexusoperation/frontend.go

@@ -5,8 +5,11 @@ import (
 
 	"go.temporal.io/api/serviceerror"
 	"go.temporal.io/api/workflowservice/v1"
+	nexusoperationpb "go.temporal.io/server/chasm/lib/nexusoperation/gen/nexusoperationpb/v1"
 	"go.temporal.io/server/common/log"
 	"go.temporal.io/server/common/namespace"
+	commonnexus "go.temporal.io/server/common/nexus"
+	"go.temporal.io/server/common/searchattribute"
 )
 
 // FrontendHandler provides the frontend-facing API for standalone Nexus operations.
@@ -24,20 +27,32 @@ type FrontendHandler interface {
 var ErrStandaloneNexusOperationDisabled = serviceerror.NewUnimplemented("Standalone Nexus operation is disabled")
 
 type frontendHandler struct {
+	client            nexusoperationpb.NexusOperationServiceClient
 	config            *Config
 	logger            log.Logger
 	namespaceRegistry namespace.Registry
+	endpointRegistry  commonnexus.EndpointRegistry
+	saMapperProvider  searchattribute.MapperProvider
+	saValidator       *searchattribute.Validator
 }
 
 func NewFrontendHandler(
+	client nexusoperationpb.NexusOperationServiceClient,
 	config *Config,
 	logger log.Logger,
 	namespaceRegistry namespace.Registry,
+	endpointRegistry commonnexus.EndpointRegistry,
+	saMapperProvider searchattribute.MapperProvider,
+	saValidator *searchattribute.Validator,
 ) FrontendHandler {
 	return &frontendHandler{
+		client:            client,
 		config:            config,
 		logger:            logger,
 		namespaceRegistry: namespaceRegistry,
+		endpointRegistry:  endpointRegistry,
+		saMapperProvider:  saMapperProvider,
+		saValidator:       saValidator,
 	}
 }
 
@@ -46,18 +61,57 @@ func (h *frontendHandler) isStandaloneNexusOperationEnabled(namespaceName string
 	return h.config.EnableChasm(namespaceName) && h.config.Enabled(namespaceName)
 }
 
-func (h *frontendHandler) StartNexusOperationExecution(_ context.Context, req *workflowservice.StartNexusOperationExecutionRequest) (*workflowservice.StartNexusOperationExecutionResponse, error) {
+func (h *frontendHandler) StartNexusOperationExecution(
+	ctx context.Context,
+	req *workflowservice.StartNexusOperationExecutionRequest,
+) (*workflowservice.StartNexusOperationExecutionResponse, error) {
 	if !h.isStandaloneNexusOperationEnabled(req.GetNamespace()) {
 		return nil, ErrStandaloneNexusOperationDisabled
 	}
-	return nil, serviceerror.NewUnimplemented("StartNexusOperationExecution not implemented")
+
+	namespaceID, err := h.namespaceRegistry.GetNamespaceID(namespace.Name(req.GetNamespace()))
+	if err != nil {
+		return nil, err
+	}
+
+	if err := validateAndNormalizeStartRequest(req, h.config, h.saMapperProvider, h.saValidator); err != nil {
+		return nil, err
+	}
+
+	// Verify the endpoint exists before creating the operation.
+	if _, err := h.endpointRegistry.GetByName(ctx, namespaceID, req.GetEndpoint()); err != nil {
+		return nil, err
+	}
+
+	resp, err := h.client.StartNexusOperation(ctx, &nexusoperationpb.StartNexusOperationRequest{
+		NamespaceId:     namespaceID.String(),
+		FrontendRequest: req,
+	})
+	return resp.GetFrontendResponse(), err
 }
 
-func (h *frontendHandler) DescribeNexusOperationExecution(_ context.Context, req *workflowservice.DescribeNexusOperationExecutionRequest) (*workflowservice.DescribeNexusOperationExecutionResponse, error) {
+func (h *frontendHandler) DescribeNexusOperationExecution(
+	ctx context.Context,
+	req *workflowservice.DescribeNexusOperationExecutionRequest,
+) (*workflowservice.DescribeNexusOperationExecutionResponse, error) {
 	if !h.isStandaloneNexusOperationEnabled(req.GetNamespace()) {
 		return nil, ErrStandaloneNexusOperationDisabled
 	}
-	return nil, serviceerror.NewUnimplemented("DescribeNexusOperationExecution not implemented")
+
+	namespaceID, err := h.namespaceRegistry.GetNamespaceID(namespace.Name(req.GetNamespace()))
+	if err != nil {
+		return nil, err
+	}
+
+	if err := validateDescribeNexusOperationExecutionRequest(req, h.config); err != nil {
+		return nil, err
+	}
+
+	resp, err := h.client.DescribeNexusOperation(ctx, &nexusoperationpb.DescribeNexusOperationRequest{
+		NamespaceId:     namespaceID.String(),
+		FrontendRequest: req,
+	})
+	return resp.GetFrontendResponse(), err
 }
 
 func (h *frontendHandler) PollNexusOperationExecution(_ context.Context, req *workflowservice.PollNexusOperationExecutionRequest) (*workflowservice.PollNexusOperationExecutionResponse, error) {