Add Nexus SAA sample (#529)

Author: atol

README.md

@@ -233,22 +233,10 @@ These samples demonstrate some common control flow patterns using Temporal's Go
 
 - [**Worker-specific Task Queues**](./worker-specific-task-queues): Use a unique task queue per Worker to have certain Activities only run on that specific Worker. For instance for a file processing Workflow, where one Activity downloads a file and subsequent Activities need to operate on that file. (If multiple Workers were on the same queue, subsequent Activities may get run on different machines that don't have the downloaded file.)
 
-- [**Nexus**](./nexus): Demonstrates how to use the Nexus APIs to facilitate cross namespace calls.
-
-- [**Nexus Cancelation**](./nexus-cancelation): Demonstrates how to cancel a Nexus operation from a caller workflow.
-
-- [**Nexus Context Propagation**](./nexus-context-propagation): Demonstrates how to propagate context through client calls, workflows, and Nexus headers.
-
-
-
 ### Scenario based examples
 
 - [**Safe Message Handler**](./safe_message_handler): This demonstrates how to safely handle concurrent update and signal requests.
 
-- [**Nexus Messaging**](./nexus-messaging): Demonstrates how send signal, update and query messages through Nexus.
-  This contains two samples, one sending messages to an existing workflow and a second that creates a workflow through Nexus
-  and sends messages to it.
-
 - [**DSL Workflow**](./dsl): Demonstrates how to implement a
   DSL-based Workflow. This sample contains 2 yaml files that each define a custom "workflow" which instructs the
   Temporal Workflow. This is useful if you want to build in a "low code" layer.
@@ -288,6 +276,28 @@ resource waiting for its successful completion
 - [**Worker Versioning**](./worker-versioning):
   Demonstrates how to use worker versioning to manage workflow code changes.
 
+### Nexus examples
+
+- [**Nexus**](./nexus): Demonstrates how to use the Nexus APIs to facilitate cross namespace calls.
+
+- [**Nexus Cancelation**](./nexus-cancelation): Demonstrates how to cancel a Nexus Operation from a caller Workflow.
+
+- [**Nexus Context Propagation**](./nexus-context-propagation): Demonstrates how to propagate context through client 
+  calls, Workflows, and Nexus headers.
+
+- [**Nexus Messaging**](./nexus-messaging): Demonstrates how to send signal, update and query messages through Nexus.
+  This contains two samples, one sending messages to an existing Workflow and a second that creates a Workflow through
+  Nexus and sends messages to it.
+
+- [**Nexus Multiple Arguments**](./nexus-multiple-arguments): Demonstrates how to map a Nexus Operation to a Workflow
+  that takes multiple arguments.
+
+- [**Standalone Nexus Operations**](./nexus-standalone-operations): Demonstrates how to execute Nexus Operations
+  directly from a Temporal Client, without a caller Workflow.
+
+- [**Nexus Standalone Activity**](./nexus-standalone-activity): Demonstrates how to back a Nexus Operation with a
+  Standalone Activity.
+
 ### Serverless
 
 - [**Lambda Worker**](./lambda-worker): Demonstrates how to run a Temporal Worker as an

nexus-standalone-activity/README.md

@@ -0,0 +1,64 @@
+## Nexus Operation Backed by a Standalone Activity
+
+> [!WARNING]
+> Standalone Nexus Operations and Standalone Activities are experimental and may be subject to backwards-incompatible changes. They require a Temporal server that implements and enables them via the dynamic configs shown below. Use the dev server build at https://github.com/temporalio/cli/releases/tag/v1.7.4-standalone-nexus-operations.
+
+This sample shows how to implement a Nexus Operation whose backing execution is a **Standalone Activity**.
+
+### Sample structure
+
+| File                                       | Purpose                                                                                        |
+|--------------------------------------------|------------------------------------------------------------------------------------------------|
+| [`service/api.go`](./service/api.go)       | Nexus service definition shared by caller and handler                                          |
+| [`handler/app.go`](./handler/app.go)       | The standalone Activity, and the operation built with `NewTemporalOperation` + `StartActivity` |
+| [`worker/main.go`](./worker/main.go)       | Worker hosting the Nexus handler and the Activity                                              |
+| [`starter/main.go`](./starter/main.go)     | Executes the Nexus Operation from client code                                                  |
+
+The starter and worker connect to two different namespaces (a "caller" namespace and a "handler" namespace) — this mirrors how Nexus is typically used to cross namespace boundaries. The client is configured via the SDK's [environment configuration](https://docs.temporal.io/develop/environment-configuration) support, which reads `TEMPORAL_NAMESPACE`, `TEMPORAL_ADDRESS`, etc. from the environment (and optionally profiles from `temporal.toml`).
+
+## Run locally against a dev server
+
+1) Start the [Temporal dev server build that supports standalone Nexus Operations](https://docs.temporal.io/standalone-nexus-operation#temporal-cli-support) with the required namespaces pre-created and Activity callbacks enabled:
+
+```bash
+./temporal server start-dev \
+  --dynamic-config-value activity.enableCallbacks=true \
+  --namespace my-caller-namespace \
+  --namespace my-handler-namespace
+```
+
+2) Create a Nexus endpoint that routes to the handler namespace and the worker's task queue:
+
+```bash
+./temporal operator nexus endpoint create \
+  --name my-nexus-endpoint \
+  --target-namespace my-handler-namespace \
+  --target-task-queue nexus-handler-queue
+```
+
+3) In a second terminal, start the worker in the handler namespace:
+
+```bash
+TEMPORAL_NAMESPACE=my-handler-namespace \
+  go run nexus-standalone-activity/worker/main.go
+```
+
+You should see a log line similar to:
+
+```bash
+2026/08/18 13:28:43 INFO  Started Worker Namespace my-handler-namespace TaskQueue nexus-handler-queue WorkerID 53608
+```
+
+4) In a third terminal, run the starter in the caller namespace:
+
+```bash
+TEMPORAL_NAMESPACE=my-caller-namespace \
+  go run nexus-standalone-activity/starter/main.go
+```
+
+You should see something similar to:
+
+```bash
+2026/08/18 13:29:14 Started Greet operation OperationID greeting-afb1ff21-c842-40f7-ba85-28458d0150a6
+2026/08/18 13:29:14 Hello, World!
+```

nexus-standalone-activity/handler/app.go

@@ -0,0 +1,41 @@
+// @@@SNIPSTART samples-go-nexus-standalone-activity-handler
+package handler
+
+import (
+	"context"
+	"time"
+
+	"go.temporal.io/sdk/activity"
+	"go.temporal.io/sdk/client"
+	"go.temporal.io/sdk/temporalnexus"
+
+	"github.com/temporalio/samples-go/nexus-standalone-activity/service"
+)
+
+// CreateGreetingActivity builds the greeting. It runs as a Standalone Activity, so it does not
+// need a backing Workflow.
+func CreateGreetingActivity(ctx context.Context, input service.GreetingInput) (service.GreetingOutput, error) {
+	activity.GetLogger(ctx).Info("CreateGreeting", "name", input.Name)
+	return service.GreetingOutput{Message: "Hello, " + input.Name + "!"}, nil
+}
+
+// GreetOperation is the Nexus Operation backed by CreateGreetingActivity. Start dispatches the
+// Activity and returns its handle, so the caller's Nexus Operation completes when the Activity does.
+var GreetOperation = temporalnexus.MustNewTemporalOperation(
+	temporalnexus.TemporalOperationOptions[service.GreetingInput, service.GreetingOutput]{
+		Name: service.GreetOperationName,
+		Start: func(
+			ctx context.Context,
+			nc temporalnexus.NexusClient,
+			input service.GreetingInput,
+			options temporalnexus.StartTemporalOperationOptions,
+		) (temporalnexus.TemporalOperationResult[service.GreetingOutput], error) {
+			return temporalnexus.StartActivity(ctx, nc, client.StartActivityOptions{
+				ID:                  service.GreetingActivityID(input),
+				StartToCloseTimeout: 10 * time.Second,
+			}, CreateGreetingActivity, input)
+		},
+	},
+)
+
+// @@@SNIPEND

nexus-standalone-activity/handler_test.go

@@ -0,0 +1,91 @@
+package nexus_standalone_activity_test
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/require"
+
+	"github.com/nexus-rpc/sdk-go/nexus"
+
+	nexuspb "go.temporal.io/api/nexus/v1"
+	"go.temporal.io/api/operatorservice/v1"
+	"go.temporal.io/sdk/client"
+	"go.temporal.io/sdk/testsuite"
+	"go.temporal.io/sdk/worker"
+
+	"github.com/temporalio/samples-go/nexus-standalone-activity/handler"
+	"github.com/temporalio/samples-go/nexus-standalone-activity/service"
+)
+
+const (
+	taskQueue    = "nexus-standalone-activity-test"
+	endpointName = "nexus-standalone-activity-test-endpoint"
+)
+
+func Test_NexusOperationStandaloneActivity_Using_DevServer(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
+	defer cancel()
+
+	// Start the dev server with standalone Nexus support and Activity callbacks enabled, which is
+	// what lets a Standalone Activity complete a Nexus Operation.
+	server, err := testsuite.StartDevServer(ctx, testsuite.DevServerOptions{
+		CachedDownload: testsuite.CachedDownload{
+			Version: "v1.7.4-standalone-nexus-operations",
+		},
+		ExtraArgs: []string{
+			"--dynamic-config-value", "activity.enableCallbacks=true",
+		},
+	})
+	require.NoError(t, err)
+	defer func() { _ = server.Stop() }()
+
+	c := server.Client()
+
+	// Create a Nexus endpoint targeting our task queue.
+	_, err = c.OperatorService().CreateNexusEndpoint(ctx, &operatorservice.CreateNexusEndpointRequest{
+		Spec: &nexuspb.EndpointSpec{
+			Name: endpointName,
+			Target: &nexuspb.EndpointTarget{
+				Variant: &nexuspb.EndpointTarget_Worker_{
+					Worker: &nexuspb.EndpointTarget_Worker{
+						Namespace: "default",
+						TaskQueue: taskQueue,
+					},
+				},
+			},
+		},
+	})
+	require.NoError(t, err)
+
+	// Register Nexus operations on the worker.
+	w := worker.New(c, taskQueue, worker.Options{})
+
+	svc := nexus.NewService(service.GreetingServiceName)
+	require.NoError(t, svc.Register(handler.GreetOperation))
+	w.RegisterNexusService(svc)
+	w.RegisterActivity(handler.CreateGreetingActivity)
+	require.NoError(t, w.Start())
+	defer w.Stop()
+
+	// Create a standalone NexusClient.
+	nexusClient, err := c.NewNexusClient(client.NexusClientOptions{
+		Endpoint: endpointName,
+		Service:  service.GreetingServiceName,
+	})
+	require.NoError(t, err)
+
+	handle, err := nexusClient.ExecuteOperation(ctx, service.GreetOperationName, service.GreetingInput{Name: "Test"}, client.StartNexusOperationOptions{
+		ID:                     "greeting-" + uuid.NewString(),
+		ScheduleToCloseTimeout: 10 * time.Second,
+	})
+	require.NoError(t, err)
+	require.NotEmpty(t, handle.GetID())
+
+	var result service.GreetingOutput
+	err = handle.Get(ctx, &result)
+	require.NoError(t, err)
+	require.Equal(t, "Hello, Test!", result.Message)
+}

nexus-standalone-activity/service/api.go

@@ -0,0 +1,25 @@
+// @@@SNIPSTART samples-go-nexus-standalone-activity-service
+package service
+
+import "fmt"
+
+// Nexus service definition shared by the caller and the handler. It declares a single operation
+// whose backing execution is a Standalone Activity.
+
+const GreetingServiceName = "NexusGreetingService"
+
+const GreetOperationName = "greet"
+
+type GreetingInput struct {
+	Name string
+}
+
+type GreetingOutput struct {
+	Message string
+}
+
+func GreetingActivityID(input GreetingInput) string {
+	return fmt.Sprintf("greeting-%s", input.Name)
+}
+
+// @@@SNIPEND

nexus-standalone-activity/starter/main.go

@@ -0,0 +1,57 @@
+// @@@SNIPSTART samples-go-nexus-standalone-activity-starter
+package main
+
+import (
+	"context"
+	"log"
+	"time"
+
+	"github.com/google/uuid"
+
+	"go.temporal.io/sdk/client"
+	"go.temporal.io/sdk/contrib/envconfig"
+
+	"github.com/temporalio/samples-go/nexus-standalone-activity/service"
+)
+
+// Executes the Activity-backed Nexus Operation from client code. The operation is standalone: it is
+// started directly by this client rather than from within a caller Workflow.
+
+const endpointName = "my-nexus-endpoint"
+
+func main() {
+	// The client is a heavyweight object that should be created once per process.
+	c, err := client.Dial(envconfig.MustLoadDefaultClientOptions())
+	if err != nil {
+		log.Fatalln("Unable to create client", err)
+	}
+	defer c.Close()
+
+	// Create a NexusClient bound to the endpoint and service.
+	// The endpoint must be pre-created on the server (see README).
+	nexusClient, err := c.NewNexusClient(client.NexusClientOptions{
+		Endpoint: endpointName,
+		Service:  service.GreetingServiceName,
+	})
+	if err != nil {
+		log.Fatalln("Unable to create Nexus client", err)
+	}
+
+	handle, err := nexusClient.ExecuteOperation(context.Background(), service.GreetOperationName, service.GreetingInput{Name: "World"}, client.StartNexusOperationOptions{
+		ID:                     "greeting-" + uuid.NewString(),
+		ScheduleToCloseTimeout: 10 * time.Second,
+	})
+	if err != nil {
+		log.Fatalln("Unable to execute Greet operation", err)
+	}
+	log.Println("Started Greet operation", "OperationID", handle.GetID())
+
+	var result service.GreetingOutput
+	err = handle.Get(context.Background(), &result)
+	if err != nil {
+		log.Fatalln("Unable to get Greet operation result", err)
+	}
+	log.Println(result.Message)
+}
+
+// @@@SNIPEND

nexus-standalone-activity/worker/main.go

@@ -0,0 +1,43 @@
+// @@@SNIPSTART samples-go-nexus-standalone-activity-worker
+package main
+
+import (
+	"log"
+
+	"github.com/nexus-rpc/sdk-go/nexus"
+
+	"go.temporal.io/sdk/client"
+	"go.temporal.io/sdk/contrib/envconfig"
+	"go.temporal.io/sdk/worker"
+
+	"github.com/temporalio/samples-go/nexus-standalone-activity/handler"
+	"github.com/temporalio/samples-go/nexus-standalone-activity/service"
+)
+
+const taskQueue = "nexus-handler-queue"
+
+func main() {
+	// The client and worker are heavyweight objects that should be created once per process.
+	c, err := client.Dial(envconfig.MustLoadDefaultClientOptions())
+	if err != nil {
+		log.Fatalln("Unable to create client", err)
+	}
+	defer c.Close()
+
+	w := worker.New(c, taskQueue, worker.Options{})
+
+	svc := nexus.NewService(service.GreetingServiceName)
+	err = svc.Register(handler.GreetOperation)
+	if err != nil {
+		log.Fatalln("Unable to register operations", err)
+	}
+	w.RegisterNexusService(svc)
+	w.RegisterActivity(handler.CreateGreetingActivity)
+
+	err = w.Run(worker.InterruptCh())
+	if err != nil {
+		log.Fatalln("Unable to start worker", err)
+	}
+}
+
+// @@@SNIPEND