fix: make errInvalidComputeConfig non-retryable in deployment activities (#10127)

## Summary

- Changed `UpdateWorkerControllerInstanceFromDeployment` (activities.go)
and `UpdateWorkerControllerInstance` (version_activities.go) to return
`NewNonRetryableApplicationError` instead of `NewApplicationError` when
wrapping `InvalidArgument` errors from the WCI client
- Added functional test
`TestCreateWorkerDeploymentVersion_InvalidComputeConfig_ReturnsPromptly`
that verifies the error returns promptly when creating a version with
invalid compute config on a busy deployment

## Context

The `TestCreateWorkerDeploymentVersion_Errors` test in the CLI repo
(temporalio/cli) is flaky. When `create-version` is called with invalid
AWS Lambda credentials, the expected `"failed to assume role"` error is
sometimes replaced by `"too many requests"`.

Root cause: both activities wrap `InvalidArgument` errors as
**retryable** `ApplicationError`. The activity retries up to 5 times
(each attempt timing out trying to reach AWS IMDS), keeping the
deployment workflow busy. The deployment client's retry loop then times
out after 1 minute and `convertAndRecordError` masks the actual error as
`"too many requests"`.

The existing unit tests (`workflow_test.go:1543`,
`version_workflow_test.go:2383`) already mock the activity returning
`NewNonRetryableApplicationError` -- the activities just weren't
matching that expectation.

## Test plan

- [x] Existing unit tests pass (`go test
./service/worker/workerdeployment/...`)
- [x] Existing functional tests pass
(`TestCreateWorkerDeploymentVersion_InvalidScalingGroups`,
`TestCreateWorkerDeploymentVersion_InvalidArgs`)
- [x] New functional test passes 5/5 runs, consistently under 3 seconds
- [ ] Verify CLI `TestCreateWorkerDeploymentVersion_Errors` passes after
bumping server dependency

Co-authored-by: Jay Pipes <jaypipes@gmail.com>

Author: chaptersix

service/worker/workerdeployment/activities.go

@@ -285,7 +285,7 @@ func (a *Activities) UpdateWorkerControllerInstanceFromDeployment(ctx context.Co
 	if err != nil {
 		var invalidArgs *serviceerror.InvalidArgument
 		if errors.As(err, &invalidArgs) {
-			return nil, temporal.NewApplicationError(err.Error(), errInvalidComputeConfig)
+			return nil, temporal.NewNonRetryableApplicationError(err.Error(), errInvalidComputeConfig, nil)
 		}
 		return nil, err
 	}

service/worker/workerdeployment/version_activities.go

@@ -205,7 +205,7 @@ func (a *VersionActivities) UpdateWorkerControllerInstance(ctx context.Context,
 	if err != nil {
 		var invalidArgs *serviceerror.InvalidArgument
 		if errors.As(err, &invalidArgs) {
-			return nil, temporal.NewApplicationError(err.Error(), errInvalidComputeConfig)
+			return nil, temporal.NewNonRetryableApplicationError(err.Error(), errInvalidComputeConfig, nil)
 		}
 		return nil, err
 	}

tests/worker_deployment_version_test.go

@@ -3626,6 +3626,52 @@ func (s *DeploymentVersionSuite) TestCreateWorkerDeploymentVersion_MultipleVersi
 	}, 10*time.Second, 500*time.Millisecond)
 }
 
+// TestCreateWorkerDeploymentVersion_InvalidComputeConfig_ReturnsPromptly verifies that
+// creating a version with invalid compute config returns an InvalidArgument error promptly,
+// even when the deployment workflow is busy (e.g., processing a recently polled version).
+// This is a regression test for a bug where the activity error was retryable, causing the
+// deployment workflow to stay busy and the client to time out with "too many requests".
+func (s *DeploymentVersionSuite) TestCreateWorkerDeploymentVersion_InvalidComputeConfig_ReturnsPromptly() {
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+
+	tv := testvars.New(s)
+
+	// Create a version via polling, which auto-creates the deployment and keeps
+	// the deployment workflow active with lazy-creation processing.
+	s.startVersionWorkflow(ctx, tv)
+
+	// Immediately attempt to create another version on the same deployment with
+	// invalid compute config. This should return an InvalidArgument error
+	// promptly (not time out with "too many requests").
+	tv2 := tv.WithBuildIDNumber(2)
+	invalidProvider := computeprovider.TestInvokeComputeProviderInvalidComputeProvider()
+	start := time.Now()
+	_, err := s.FrontendClient().CreateWorkerDeploymentVersion(ctx, &workflowservice.CreateWorkerDeploymentVersionRequest{
+		Namespace: s.Namespace().String(),
+		DeploymentVersion: &deploymentpb.WorkerDeploymentVersion{
+			DeploymentName: tv.DeploymentSeries(),
+			BuildId:        tv2.BuildID(),
+		},
+		RequestId: tv2.Any().String(),
+		ComputeConfig: &computepb.ComputeConfig{
+			ScalingGroups: map[string]*computepb.ComputeConfigScalingGroup{
+				"sg1": {Provider: invalidProvider},
+			},
+		},
+	})
+	elapsed := time.Since(start)
+
+	s.Error(err)
+	var invalidArg *serviceerror.InvalidArgument
+	s.ErrorAs(err, &invalidArg)
+	s.Contains(invalidArg.Message, "illegal_field found in config")
+	// The error should return well before the deployment client's 1-minute
+	// retry timeout. If it takes longer than 30 seconds, the activity error
+	// is likely still retryable (the bug we're testing for).
+	s.Less(elapsed, 30*time.Second, "create-version with invalid compute config should fail promptly, not time out")
+}
+
 func (s *DeploymentVersionSuite) TestCreateWorkerDeploymentVersion_InvalidScalingGroups() {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
 	defer cancel()