Temporal Go SDK

https://pkg.go.dev/go.temporal.io/sdk
Admin
Temporal is a task orchestrator for building scalable and fault-tolerant distributed applications in...
Tokens:111,809
Snippets:1,465
Trust Score:9.6
Update:2 months ago
Show doc for...
Tokens:
Raw
### Start DevServer

Source: https://pkg.go.dev/go.temporal.io/sdk/testsuite

Starts a Temporal CLI dev server process, potentially downloading the binary if necessary.

```go
func StartDevServer(ctx context.Context, options DevServerOptions) (*DevServer, error)
```

--------------------------------

### Install Stream Server

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/googleadk

Installs the workflow-side stream server to handle model output chunks.

```go
func StreamServer(ctx workflow.Context) error
```

--------------------------------

### Install workflowcheck

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/tools/workflowcheck

Command to install the tool using the Go CLI.

```bash
go install go.temporal.io/sdk/contrib/tools/workflowcheck@latest
```

--------------------------------

### Define start operation options

Source: https://pkg.go.dev/go.temporal.io/sdk/temporalnexus

Options provided to the Start callback of a Nexus operation. Mirrors nexus.StartOperationOptions.

```go
type StartTemporalOperationOptions struct {
	// Header contains the request header fields received by the server.
	//
	// Header keys with the "content-" prefix are reserved for [nexus.Serializer] headers and are not
	// available here.
	Header nexus.Header
	// CallbackURL is used to deliver completion of async operations.
	CallbackURL string
	// CallbackHeader contains header fields set by the client that are required to be attached to the
	// callback request when an asynchronous operation completes.
	CallbackHeader nexus.Header
	// RequestID may be used by the server handler to dedupe a start request.
	RequestID string
	// Links contain arbitrary caller information. Handlers may use these links as metadata on
	// resources associated with an operation.
	Links []nexus.Link
}
```

--------------------------------

### Compression Example Output

Source: https://pkg.go.dev/go.temporal.io/sdk/converter

Example output demonstrating payload size changes after compression.

```text
Output:
Uncompressed payload size: 1202 (encoding: json/plain)
Compressed payload size: 57 (encoding: binary/zlib)
Uncompressed payload back to original? true
Compressed payload back to original? true
```

--------------------------------

### StartDevServer

Source: https://pkg.go.dev/go.temporal.io/sdk/testsuite

Starts a new Temporal development server instance with the provided options.

```APIDOC
## func StartDevServer(ctx context.Context, options DevServerOptions) (*DevServer, error)

### Description
Starts a local Temporal development server. Returns a DevServer instance that can be used to interact with the server or stop it.

### Parameters
- **ctx** (context.Context) - Required - The context for the operation.
- **options** (DevServerOptions) - Required - Configuration options for the development server.
```

--------------------------------

### Define StartNexusOperationOptions

Source: https://pkg.go.dev/go.temporal.io/sdk/client

Configuration parameters for starting a Nexus operation execution.

```go
type StartNexusOperationOptions = internal.ClientStartNexusOperationOptions
```

--------------------------------

### Define StartWorkflowOptions

Source: https://pkg.go.dev/go.temporal.io/sdk/client

Configuration parameters for starting a workflow execution.

```go
type StartWorkflowOptions = internal.StartWorkflowOptions
```

--------------------------------

### StartDevServer

Source: https://pkg.go.dev/go.temporal.io/sdk/testsuite

Starts a Temporal CLI dev server process, optionally downloading the binary if required.

```APIDOC
## func StartDevServer(ctx context.Context, options DevServerOptions) (*DevServer, error)

### Description
Starts a Temporal CLI dev server process. This may download the server if not already downloaded.

### Parameters
- **ctx** (context.Context) - Required - The context for the process lifecycle.
- **options** (DevServerOptions) - Required - Configuration options for the dev server.
```

--------------------------------

### Define StartActivityOptions

Source: https://pkg.go.dev/go.temporal.io/sdk/client

Configuration parameters for starting an activity execution from the client. ID and TaskQueue are required.

```go
type StartActivityOptions = internal.ClientStartActivityOptions
```

--------------------------------

### StartUpdateWorkflow[R any](...)

Source: https://pkg.go.dev/go.temporal.io/sdk/temporalnexus

Starts an update workflow operation.

```APIDOC
## func StartUpdateWorkflow

### Description
Starts an update workflow operation.

### Signature
`func StartUpdateWorkflow[R any](ctx context.Context, nc NexusClient, updateWorkflowOptions client.UpdateWorkflowOptions) (TemporalOperationResult[R], error)`
```

--------------------------------

### ExecuteActivity

Source: https://pkg.go.dev/go.temporal.io/sdk/client

Starts a standalone activity execution.

```APIDOC
## ExecuteActivity

### Description
Starts a standalone activity execution and returns an ActivityHandle. Standalone activities are not associated with a workflow execution and are scheduled directly on a task queue.
```

--------------------------------

### Get FakeMCPServer Name

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/googleadk

Implements the tool.Toolset interface.

```go
func (s *FakeMCPServer) Name() string
```

--------------------------------

### Start Worker Plugin Options

Source: https://pkg.go.dev/go.temporal.io/sdk/worker

Options for StartWorker on a worker plugin.

```go
type PluginStartWorkerOptions = internal.WorkerPluginStartWorkerOptions
```

--------------------------------

### Example Workflow Definition

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/tools/workflowcheck

A sample Go file containing a non-deterministic Workflow definition.

```go
package myworkflow

import (
	"fmt"
	"time"

	"go.temporal.io/sdk/worker"
	"go.temporal.io/sdk/workflow"
)

func Register(w worker.WorkflowRegistry) {
	w.RegisterWorkflow(MyWorkflow)
}

func MyWorkflow(workflow.Context) error {
	now := time.Now()
	fmt.Printf("Now: %v\n", now)
	return nil
}
```

--------------------------------

### Install Google ADK Temporal SDK

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/googleadk

Command to add the Google ADK Temporal integration to your Go project.

```bash
go get go.temporal.io/sdk/contrib/googleadk@latest
```

--------------------------------

### NewWithStartWorkflowOperation Mock

Source: https://pkg.go.dev/go.temporal.io/sdk/mocks

Provides a mock function for starting a workflow operation with specific options.

```go
func (_m *Client) NewWithStartWorkflowOperation(options client.StartWorkflowOptions, workflow interface{}, args ...interface{}) client.WithStartWorkflowOperation
```

--------------------------------

### Install OpenTelemetry integration

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/opentelemetry

Command to add the OpenTelemetry contribution module to your Go project.

```bash
go get go.temporal.io/sdk/contrib/opentelemetry@latest
```

--------------------------------

### Workflowcheck Configuration

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/tools/workflowcheck

Example configuration file to allow specific function calls.

```yaml
decls:
  fmt.Printf: false
```

--------------------------------

### Define WithStartWorkflowOperation type

Source: https://pkg.go.dev/go.temporal.io/sdk/client

Defines how to start a workflow when using UpdateWithStartWorkflow.

```go
type WithStartWorkflowOperation = internal.WithStartWorkflowOperation
```

--------------------------------

### Install AWS SDK v2 Driver dependencies

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/aws/s3driver/awssdkv2

Use these commands to add the necessary S3 driver and adapter packages to your Go module.

```bash
go get go.temporal.io/sdk/contrib/aws/s3driver@latest
go get go.temporal.io/sdk/contrib/aws/s3driver/awssdkv2@latest
```

--------------------------------

### Workflowcheck output example

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/tools/workflowcheck

Sample output showing a non-deterministic error reported by the tool.

```text
/path/to/worker/main.go:29:2: path/to/package.MyWorkflow is non-deterministic, reason: calls non-deterministic function path/to/package.MetricSum
  path/to/package.MetricSum is non-deterministic, reason: iterates over map
```

--------------------------------

### Get Topic Handle

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/workflowstreams

Retrieves a handle for publishing to a specific topic name.

```go
func (s *WorkflowStream) Topic(name string) *WorkflowTopicHandle
```

--------------------------------

### Get deterministic workflow time

Source: https://pkg.go.dev/go.temporal.io/sdk/workflow

Retrieves the wall clock time when the workflow task started, ensuring consistency during replay.

```go
func Now(ctx Context) time.Time
```

--------------------------------

### Get topic handle

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/workflowstreams

Returns a handle for publishing to and subscribing from a specific topic.

```go
func (c *Client) Topic(name string) *TopicHandle
```

--------------------------------

### Initialize WorkflowStream in Workflow

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/workflowstreams

Construct a WorkflowStream at the start of a workflow to register signal, update, and query handlers.

```go
type MyInput struct {
	ItemsProcessed int // your own workflow state
	StreamState    *workflowstreams.WorkflowStreamState
}

func MyWorkflow(ctx workflow.Context, input MyInput) error {
	stream, err := workflowstreams.NewWorkflowStream(ctx, input.StreamState)
	if err != nil {
		return err
	}
	// Optionally publish from workflow code:
	_ = stream.Topic("events").Publish("hello")
	// ... run your workflow; the stream serves external publishers/subscribers.
	// Block until your workflow's exit condition is met (here, a done flag
	// set elsewhere, e.g. by a signal).
	return workflow.Await(ctx, func() bool { return done })
}
```

--------------------------------

### Initialize FakeMCPServer

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/googleadk

Creates a new empty FakeMCPServer instance.

```go
func NewFakeMCPServer(name string) *FakeMCPServer
```

--------------------------------

### Monotonic Counter Workflow Update Handler

Source: https://pkg.go.dev/go.temporal.io/sdk/workflow

Example of a workflow using SetUpdateHandlerWithOptions to manage a counter with input validation.

```go
func MyWorkflow(ctx workflow.Context) (int, error) {
	counter := 0
	err := workflow.SetUpdateHandlerWithOptions(
		ctx,
		"add",
		func(ctx workflow.Context, val int) (int, error) { // Calls
			counter += val // note that this mutates workflow state
			return counter, nil
		},
		UpdateHandlerOptions{
			Validator: func(val int) error {
				if val < 0 { // reject attempts to add negative values
					return fmt.Errorf("invalid addend: %v", val)
				}
				return nil
			},
		})
	if err != nil {
		return 0, err
	}
	_ = ctx.Done().Receive(ctx, nil)
	return counter, nil
}
```

--------------------------------

### Initialize Client from Activity

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/workflowstreams

Creates a client targeting the current activity's parent workflow.

```go
func NewClientFromActivity(ctx context.Context, opts Options) (*Client, error)
```

--------------------------------

### Get DevServer Client

Source: https://pkg.go.dev/go.temporal.io/sdk/testsuite

Retrieves a client configured to interact with the dev server.

```go
func (s *DevServer) Client() client.Client
```

--------------------------------

### Define Activity Structure

Source: https://pkg.go.dev/go.temporal.io/sdk/workflow

Example structure definition for activities that will be invoked within a workflow.

```go
type Activities struct {
  ... // members
}

func (a *Activities) Activity1() (string, error) {
   ...
}
```

--------------------------------

### Define ScheduleWorkflowAction

Source: https://pkg.go.dev/go.temporal.io/sdk/client

Implementation of ScheduleAction to start a workflow.

```go
type ScheduleWorkflowAction = internal.ScheduleWorkflowAction
```

--------------------------------

### Initialize ResourceController

Source: https://pkg.go.dev/go.temporal.io/sdk/worker

Creates a controller with provided options; ensure only one InfoSupplier instance is created to avoid conflicts.

```go
func NewResourceController(options ResourceControllerOptions) *ResourceController
```

--------------------------------

### Get FakeModel Name

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/googleadk

Implements the model.LLM interface.

```go
func (m *FakeModel) Name() string
```

--------------------------------

### Configure streaming agent workflow

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/googleadk

Initialize the stream server and configure the model with streaming enabled to publish chunks to a topic.

```go
func StreamingAgentWorkflow(ctx workflow.Context, q string) (string, error) {
	if err := googleadk.StreamServer(ctx); err != nil { // required when streaming
		return "", err
	}
	topic := "run-" + workflow.GetInfo(ctx).WorkflowExecution.ID
	root, _ := llmagent.New(llmagent.Config{
		Model: googleadk.NewModel("gemini-2.0-flash", googleadk.WithStreaming(topic, 0)),
		// ...
	})
	// ... build runner, set agent.RunConfig{StreamingMode: agent.StreamingModeSSE}, drive r.Run as above
}
```

--------------------------------

### Now

Source: https://pkg.go.dev/go.temporal.io/sdk/workflow

Returns the deterministic time when the workflow task was first started.

```APIDOC
## func Now(ctx Context) time.Time

### Description
Now returns the time when the workflow task was first started, even during replay. Workflows must use this Now() to get the wall clock time, instead of Go's time.Now().
```

--------------------------------

### Create a simple plugin

Source: https://pkg.go.dev/go.temporal.io/sdk/temporal

Creates a new SimplePlugin with the given options.

```go
func NewSimplePlugin(options SimplePluginOptions) (*SimplePlugin, error)
```

--------------------------------

### Initialize Workflow Stream

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/workflowstreams

Construct a WorkflowStream at the start of a workflow to register signal, update, and query handlers.

```go
type MyInput struct {
	ItemsProcessed int // your own workflow state
	StreamState    *workflowstreams.WorkflowStreamState
}

func MyWorkflow(ctx workflow.Context, input MyInput) error {
	stream, err := workflowstreams.NewWorkflowStream(ctx, input.StreamState)
	if err != nil {
		return err
	}

	// Optionally publish from workflow code:
	if err := stream.Topic("events").Publish("hello from the workflow"); err != nil {
		return err
	}

	// Run your workflow; the stream serves external publishers and subscribers
	// for as long as the workflow is running. Block until your workflow's exit
	// condition is met (here, a `done` flag set elsewhere, e.g. by a signal).
	return workflow.Await(ctx, func() bool { return done })
}
```

--------------------------------

### Load default client options

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/envconfig

Loads client options using default configuration settings.

```go
func LoadDefaultClientOptions() (client.Options, error)
```

--------------------------------

### Define WorkflowRun

Source: https://pkg.go.dev/go.temporal.io/sdk/client

Represents a started non-child workflow execution.

```go
type WorkflowRun = internal.WorkflowRun
```

--------------------------------

### SignalWorkflow Mocks

Source: https://pkg.go.dev/go.temporal.io/sdk/mocks

Provides mock functions for signaling workflows, including combined signal and start operations.

```go
func (_m *Client) SignalWithStartWorkflow(ctx context.Context, workflowID string, signalName string, signalArg interface{}, options client.StartWorkflowOptions, workflow interface{}, workflowArgs ...interface{}) (client.WorkflowRun, error)
```

```go
func (_m *Client) SignalWorkflow(ctx context.Context, workflowID string, runID string, signalName string, arg interface{}) error
```

--------------------------------

### SignalWithStartWorkflow

Source: https://pkg.go.dev/go.temporal.io/sdk/client

Sends a signal to a workflow, starting it if it is not currently running.

```APIDOC
## SignalWithStartWorkflow

### Description
Sends a signal to a running workflow. If the workflow is not running or not found, it starts the workflow and then sends the signal in a single transaction.

### Signature
`SignalWithStartWorkflow(ctx context.Context, workflowID string, signalName string, signalArg interface{}, options StartWorkflowOptions, workflow interface{}, workflowArgs ...interface{}) (WorkflowRun, error)`

### Parameters
- **ctx** (context.Context) - The context for the request.
- **workflowID** (string) - The ID of the workflow.
- **signalName** (string) - The name of the signal.
- **signalArg** (interface{}) - The signal argument.
- **options** (StartWorkflowOptions) - Configuration options for the workflow.
- **workflow** (interface{}) - The workflow function reference or type name.
- **workflowArgs** (...interface{}) - Arguments for the workflow.
```

--------------------------------

### SetUpdateHandler

Source: https://pkg.go.dev/go.temporal.io/sdk/workflow

Registers an update handler using default options.

```go
func SetUpdateHandler(ctx Context, updateName string, handler interface{}) error
```

--------------------------------

### Load client options

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/envconfig

Loads client options from a file and applies environment variable overrides.

```go
func LoadClientOptions(options LoadClientOptionsRequest) (client.Options, error)
```

--------------------------------

### ProtoPayloadConverter Options

Source: https://pkg.go.dev/go.temporal.io/sdk/converter

Configuration options for initializing a new ProtoPayloadConverter.

```go
type ProtoPayloadConverterOptions struct {
	// ExcludeProtobufMessageTypes prevents the message type (`my.package.MyMessage`)
	// from being included in the Payload.
	ExcludeProtobufMessageTypes bool
}
```

--------------------------------

### Initialize S3 Driver with AWS SDK v2

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/aws/s3driver/awssdkv2

Configure the S3 driver by wrapping an AWS SDK v2 client instance.

```go
import (
    "context"

    "github.com/aws/aws-sdk-go-v2/config"
    "github.com/aws/aws-sdk-go-v2/service/s3"
    "go.temporal.io/sdk/contrib/aws/s3driver"
    "go.temporal.io/sdk/contrib/aws/s3driver/awssdkv2"
)

cfg, err := config.LoadDefaultConfig(context.Background())
if err != nil {
    // handle error
}

driver, err := s3driver.NewDriver(s3driver.Options{
    Client: awssdkv2.NewClient(s3.NewFromConfig(cfg)),
    Bucket: s3driver.StaticBucket("my-temporal-payloads"),
})
```

--------------------------------

### Define ScheduleWorkflowExecution

Source: https://pkg.go.dev/go.temporal.io/sdk/client

Contains details on a workflow execution started by a schedule.

```go
type ScheduleWorkflowExecution = internal.ScheduleWorkflowExecution
```

--------------------------------

### List Tools from FakeMCPServer

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/googleadk

Implements the tool.Toolset interface to list available tools.

```go
func (s *FakeMCPServer) Tools(ctx agent.ReadonlyContext) ([]tool.Tool, error)
```

--------------------------------

### Define ChildWorkflowExecutionAlreadyStartedError

Source: https://pkg.go.dev/go.temporal.io/sdk/temporal

Indicates failure because the child workflow has already started.

```go
type ChildWorkflowExecutionAlreadyStartedError = internal.ChildWorkflowExecutionAlreadyStartedError
```

--------------------------------

### Define ErrMockStartChildWorkflowFailed

Source: https://pkg.go.dev/go.temporal.io/sdk/testsuite

Indicates that a mocked child workflow should fail to start.

```go
var ErrMockStartChildWorkflowFailed = internal.ErrMockStartChildWorkflowFailed
```

--------------------------------

### Create Client from Existing Connection

Source: https://pkg.go.dev/go.temporal.io/sdk/client

Creates a new client sharing the connection of an existing client, ignoring host and connection options.

```go
func NewClientFromExisting(existingClient Client, options Options) (Client, error)
```

```go
func NewClientFromExistingWithContext(ctx context.Context, existingClient Client, options Options) (Client, error)
```

--------------------------------

### Rebuild session on workflow restart

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/googleadk

Import a session snapshot into an in-memory service at the start of a new workflow run.

```go
svc := session.InMemoryService()
if snap != nil {
	if _, err := googleadk.ImportSession(adkCtx, svc, snap); err != nil {
		return err
	}
}
```

--------------------------------

### Define ClientConfigToTOMLOptions

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/envconfig

Options for serializing client configuration to TOML format.

```go
type ClientConfigToTOMLOptions struct {
	// Defaults to two-space indent.
	OverrideIndent *string
	// If non-nil, these additional fields will be serialized with each profile.
	// Key is profile name, value is map of field name to field value.
	AdditionalProfileFields map[string]map[string]any
}
```

--------------------------------

### Get Default ResourceControllerOptions

Source: https://pkg.go.dev/go.temporal.io/sdk/worker

Returns default configuration values for a ResourceController.

```go
func DefaultResourceControllerOptions() ResourceControllerOptions
```

--------------------------------

### Continue-As-New Versioning Behavior Constants

Source: https://pkg.go.dev/go.temporal.io/sdk/workflow

Specifies versioning behavior for workflows started via Continue-As-New, including inheritance of previous overrides.

```go
const (
	// ContinueAsNewVersioningBehaviorUnspecified - Workflow versioning policy unknown.
	// If the source workflow was AutoUpgrade, the new workflow will start as AutoUpgrade.
	// If the source workflow was Pinned, the new workflow will start Pinned to the same Build ID.
	// If the source workflow had a Pinned Versioning Override, the new workflow will inherit that Versioning Override.
	ContinueAsNewVersioningBehaviorUnspecified = internal.ContinueAsNewVersioningBehaviorUnspecified

	// ContinueAsNewVersioningBehaviorAutoUpgrade - Start the new workflow with AutoUpgrade versioning behavior.
	// Like all AutoUpgrade workflows, use the Target Version of the workflow's task queue at start-time. After the
	// first workflow task completes, use whatever Versioning Behavior the workflow is annotated with in the workflow
	// code.
	//
	// Note that if the previous workflow had a Pinned override, that override will be inherited by the new workflow
	// run regardless of the ContinueAsNewVersioningBehavior specified in the continue-as-new command.
	ContinueAsNewVersioningBehaviorAutoUpgrade = internal.ContinueAsNewVersioningBehaviorAutoUpgrade

	// ContinueAsNewVersioningBehaviorUseRampingVersion - Use the Ramping Version of the workflow's task queue at start time,
	// regardless of the workflow's Target Version. After the first workflow task completes, the workflow will use whatever
	// Versioning Behavior it is annotated with. If there is no Ramping Version by the time that the first workflow task is
	// dispatched, it will be sent to the Current Version.
	//
	// It is highly discouraged to use this if the workflow is annotated with AutoUpgrade behavior, because
	// this setting ONLY applies to the first task of the workflow. If, after the first task, the workflow
	// is AutoUpgrade, it will behave like a normal AutoUpgrade workflow and go to the Target Version, which
	// may be the Current Version instead of the Ramping Version.
	//
	// Note that if the workflow being continued has a Pinned override, that override will be inherited by the
	// new workflow run regardless of the ContinueAsNewVersioningBehavior specified in the continue-as-new
	// command. Versioning Override always takes precedence until it's removed manually via UpdateWorkflowExecutionOptions.
	ContinueAsNewVersioningBehaviorUseRampingVersion = internal.ContinueAsNewVersioningBehaviorUseRampingVersion
)
```

--------------------------------

### Register Activities

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/googleadk

Wires InvokeModel, ListMcpTools, and CallMcpTool onto the worker. Primarily used for test environments or manual setups.

```go
func (a *Activities) Register(r worker.Registry)
```

--------------------------------

### Get Topic Name

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/workflowstreams

Retrieves the name of the topic associated with the handle.

```go
func (h *TopicHandle) Name() string
```

--------------------------------

### Initialize Mock Client

Source: https://pkg.go.dev/go.temporal.io/sdk/mocks

Creates a new instance of the mock Client, registering a testing interface and cleanup function for expectation assertions.

```go
func NewClient(t interface {
	mock.TestingT
	Cleanup(func())
}) *Client
```

--------------------------------

### Get default configuration file path

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/envconfig

Returns the default path for the configuration file, typically located in the user's config directory.

```go
func DefaultConfigFilePath() string
```

--------------------------------

### ExtractMetricsHandler

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/opentelemetry

Gets the underlying Open Telemetry MetricsHandler from a MetricsHandler if any is present.

```APIDOC
## func ExtractMetricsHandler(handler client.MetricsHandler) *MetricsHandler

### Description
Gets the underlying Open Telemetry MetricsHandler from a MetricsHandler if any is present.
```

--------------------------------

### ApplyDefaultsWithProviders for Custom OTel Setup

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/aws/lambdaworker/otel

Configures OTel metrics and tracing using provided MeterProvider and TracerProvider instances. Use this when full control over OTel provider configuration is needed. It also registers a per-invocation ForceFlush hook.

```go
func ApplyDefaultsWithProviders(
	ctx ShutdownRegistrar,
	opts *client.Options,
	meterProvider *otelsdkmetric.MeterProvider,
	tracerProvider *otelsdktrace.TracerProvider,
) error
```

--------------------------------

### Example non-deterministic function

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/tools/workflowcheck

A function that iterates over a map, which is inherently non-deterministic in Go.

```go
func MetricSum(metrics map[string]*Metric) (count int) {
  for _, metric := range metrics {
    count += metric.Value
  }
  return
}
```

--------------------------------

### StartUntypedWorkflow[R any](...)

Source: https://pkg.go.dev/go.temporal.io/sdk/temporalnexus

Starts a workflow run for a Nexus operation by function reference or string name, linking the execution chain to the Nexus operation.

```APIDOC
## func StartUntypedWorkflow

### Description
Starts a workflow run for a Nexus operation by function reference or string name, linking the execution chain to the Nexus operation (callbacks, links, request ID). It always returns an async result with a workflow-run operation token.

### Signature
`func StartUntypedWorkflow[R any](ctx context.Context, nc NexusClient, workflowOpts client.StartWorkflowOptions, workflow any, args ...any) (TemporalOperationResult[R], error)`
```

--------------------------------

### Initialize New Client

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/workflowstreams

Creates a new client targeting a specific workflow ID.

```go
func NewClient(c client.Client, workflowID string, opts Options) *Client
```

--------------------------------

### Workflowcheck Output Example

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/tools/workflowcheck

The output generated by the tool when analyzing the sample workflow.

```text
/path/to/workflow.go:12:2: example.com/myworkflow.MyWorkflow is non-deterministic, reason: calls non-deterministic function time.Now
  time.Now is non-deterministic, reason: declared non-deterministic
/path/to/workflow.go:12:2: example.com/myworkflow.MyWorkflow is non-deterministic, reason: calls non-deterministic function fmt.Printf
  fmt.Printf is non-deterministic, reason: accesses non-deterministic var os.Stdout
```

--------------------------------

### NewPollerBehaviorSimpleMaximum

Source: https://pkg.go.dev/go.temporal.io/sdk/worker

Creates a PollerBehavior that allows the worker to start up to a maximum number of pollers.

```APIDOC
## func NewPollerBehaviorSimpleMaximum(options PollerBehaviorSimpleMaximumOptions) PollerBehavior

### Description
Creates a PollerBehavior that allows the worker to start up to a maximum number of pollers.

### Parameters
- **options** (PollerBehaviorSimpleMaximumOptions) - Required - Configuration options for the simple maximum behavior.
```

--------------------------------

### Define simple plugin run context before options

Source: https://pkg.go.dev/go.temporal.io/sdk/temporal

Options for RunContextBefore on a simple plugin.

```go
type SimplePluginRunContextBeforeOptions = internal.SimplePluginRunContextBeforeOptions
```

--------------------------------

### Subscribe to Topic

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/workflowstreams

Returns an iterator over items on the topic starting from a specific offset.

```go
func (h *TopicHandle) Subscribe(ctx context.Context, fromOffset int64) iter.Seq2[WorkflowStreamItem, error]
```

--------------------------------

### Create channel

Source: https://pkg.go.dev/go.temporal.io/sdk/workflow

Initializes a new unbuffered channel instance.

```go
func NewChannel(ctx Context) Channel
```

--------------------------------

### Define TracerStartSpanOptions

Source: https://pkg.go.dev/go.temporal.io/sdk/interceptor

Configuration options for starting a span within a tracer implementation.

```go
type TracerStartSpanOptions struct {
	// Parent is the optional parent reference of the span.
	Parent TracerSpanRef
	// Operation is the general operation name without the specific name.
	Operation string

	// Name is the specific activity, workflow, etc for the operation.
	Name string

	// Time indicates the start time of the span.
	//
	// For RunWorkflow and RunActivity operation types, this will match workflow.Info.WorkflowStartTime and
	// activity.Info.StartedTime respectively. All other operations use time.Now().
	Time time.Time

	// DependedOn is true if the parent depends on this span or false if it just
	// is related to the parent. In OpenTracing terms, this is true for "ChildOf"
	// reference types and false for "FollowsFrom" reference types.
	DependedOn bool

	// Tags are a set of span tags.
	Tags map[string]string

	// FromHeader is used internally, not by tracer implementations, to determine
	// whether the parent span can be retrieved from the Temporal header.
	FromHeader bool

	// ToHeader is used internally, not by tracer implementations, to determine
	// whether the span should be placed on the Temporal header.
	ToHeader bool

	// IdempotencyKey may optionally be used by tracing implementations to generate
	// deterministic span IDs.
	//
	// This is useful in workflow contexts where spans may need to be "resumed" before
	// ultimately being reported. Generating a deterministic span ID ensures that any
	// child spans created before the parent span is resumed do not become orphaned.
	//
	// IdempotencyKey is not guaranteed to be set for all operations; Tracer
	// implementations MUST therefore ignore zero values for this field.
	//
	// IdempotencyKey should be treated as opaque data by Tracer implementations.
	// Do not attempt to parse it, as the format is subject to change.
	IdempotencyKey string
}
```

--------------------------------

### Load client configuration

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/envconfig

Loads the client configuration structure from a TOML source.

```go
func LoadClientConfig(options LoadClientConfigOptions) (ClientConfig, error)
```

--------------------------------

### Define simple plugin run context after options

Source: https://pkg.go.dev/go.temporal.io/sdk/temporal

Options for RunContextAfter on a simple plugin.

```go
type SimplePluginRunContextAfterOptions = internal.SimplePluginRunContextAfterOptions
```

--------------------------------

### Define simple plugin options

Source: https://pkg.go.dev/go.temporal.io/sdk/temporal

Options for NewSimplePlugin.

```go
type SimplePluginOptions = internal.SimplePluginOptions
```

--------------------------------

### Get Current Workflow Details

Source: https://pkg.go.dev/go.temporal.io/sdk/workflow

Retrieves details about the current workflow context.

```go
func GetCurrentDetails(ctx Context) string
```

--------------------------------

### CountWorkflow

Source: https://pkg.go.dev/go.temporal.io/sdk/client

Gets the number of workflow executions based on a provided SQL-like query.

```APIDOC
## CountWorkflow

### Description
Gets the number of workflow executions based on a query. The query is basically the SQL WHERE clause.

### Parameters
- **ctx** (context.Context) - Required - The context for the request.
- **request** (*workflowservice.CountWorkflowExecutionsRequest) - Required - The request object containing the query.

### Response
- **Returns** (*workflowservice.CountWorkflowExecutionsResponse, error) - The count of workflow executions or an error.
```

--------------------------------

### ContextOption and Sequential Tool Fanout

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/googleadk

Defines context customization options and the sequential tool fanout mode for deterministic execution.

```go
type ContextOption func(*contextConfig)
```

```go
func WithSequentialToolFanout() ContextOption
```

--------------------------------

### Convert profile to client options

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/envconfig

Converts a specific configuration profile into SDK client options.

```go
func (c *ClientConfig) ToClientOptions(profile string, options ToClientOptionsRequest) (client.Options, error)
```

--------------------------------

### Convert Profile to Client Options

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/envconfig

Converts a configuration profile into client options suitable for creating an SDK client.

```go
func (c *ClientConfigProfile) ToClientOptions(options ToClientOptionsRequest) (client.Options, error)
```

--------------------------------

### Get current stream offset

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/workflowstreams

Queries the current global offset of the stream.

```go
func (c *Client) GetOffset(ctx context.Context) (int64, error)
```

--------------------------------

### Configure DevServerOptions

Source: https://pkg.go.dev/go.temporal.io/sdk/testsuite

Configuration options for the dev server process.

```go
type DevServerOptions struct {
	// Existing path on the filesystem for the executable.
	ExistingPath string
	// Download the executable if not already there.
	CachedDownload CachedDownload
	// Client options used to create a client for the dev server.
	// The provided Namespace or the "default" namespace is automatically registered on startup.
	// If HostPort is provided, the host and port will be used to bind the server, otherwise the server will bind to
	// localhost and obtain a free port.
	ClientOptions *client.Options
	// SQLite DB filename if persisting or non-persistent if none.
	DBFilename string
	// Whether to enable the UI.
	EnableUI bool
	// Override UI port if EnableUI is true.
	// If not provided, a free port will be used.
	UIPort string
	// Log format - defaults to "pretty".
	LogFormat string
	// Log level - defaults to "warn".
	LogLevel string
	// Search Attributes to register with the dev server.
	SearchAttributes temporal.SearchAttributes
	// Additional arguments to the dev server.
	ExtraArgs []string
	// Where to redirect stdout and stderr, if nil they will be redirected to the current process.
	Stdout io.Writer
	Stderr io.Writer
}
```

--------------------------------

### Create a Timer with Options

Source: https://pkg.go.dev/go.temporal.io/sdk/workflow

Creates a timer with additional configuration options. Available since v1.29.0.

```go
func NewTimerWithOptions(ctx Context, d time.Duration, options TimerOptions) Future
```

--------------------------------

### Create a New Worker Instance

Source: https://pkg.go.dev/go.temporal.io/sdk/worker

Initializes a new worker instance using a client, task queue name, and configuration options.

```go
func New(
	client client.Client,
	taskQueue string,
	options Options,
) Worker
```

--------------------------------

### Implement a Simple Activity

Source: https://pkg.go.dev/go.temporal.io/sdk/activity

A basic activity implementation that accepts a string parameter and returns a processed result.

```go
import (
	"context"

	"go.temporal.io/sdk/activity"
)

func SimpleActivity(ctx context.Context, value string) (string, error) {
	activity.GetLogger(ctx).Info("SimpleActivity called.", "Value", value)
	return "Processed: ” + value, nil
}
```

--------------------------------

### CompleteActivityByActivityID

Source: https://pkg.go.dev/go.temporal.io/sdk/client

Reports a standalone activity as completed. This method is used for activities not started by a workflow.

```APIDOC
## CompleteActivityByActivityID(ctx context.Context, namespace, activityID, activityRunID string, result interface{}, err error) error

### Description
Reports a standalone activity as completed. This method is used for activities not started by a workflow. Requires namespace and activityID.

### Parameters
- **ctx** (context.Context) - Required - The context for the request.
- **namespace** (string) - Required - The namespace of the activity.
- **activityID** (string) - Required - The ID of the activity.
- **activityRunID** (string) - Optional - The run ID of the activity.
- **result** (interface{}) - Optional - The result of the activity.
- **err** (error) - Optional - The error encountered, if any.
```

--------------------------------

### Must load default client options

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/envconfig

Loads default client options, panicking if an error occurs.

```go
func MustLoadDefaultClientOptions() client.Options
```

--------------------------------

### RunWorker Function Signature

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/aws/lambdaworker

The signature for the RunWorker function used to start the worker process.

```go
func RunWorker(version worker.WorkerDeploymentVersion, configure func(ctx *Options) error)
```

--------------------------------

### Configure OpenTelemetry interceptors and metrics

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/opentelemetry

Initialize the tracing interceptor and metrics handler, then attach them to the Temporal client options.

```go
tracingInterceptor, err := temporalotel.NewTracingInterceptor(
	temporalotel.TracerOptions{},
)
if err != nil {
	return err
}

options := client.Options{
	MetricsHandler: temporalotel.NewMetricsHandler(
		temporalotel.MetricsHandlerOptions{},
	),
}
options.Interceptors = append(options.Interceptors, tracingInterceptor)

c, err := client.Dial(options)
```

--------------------------------

### Retrieve Update Information

Source: https://pkg.go.dev/go.temporal.io/sdk/workflow

Function to get information about a currently running update from the context.

```go
func GetCurrentUpdateInfo(ctx Context) *UpdateInfo
```

--------------------------------

### Initialize WaitGroup

Source: https://pkg.go.dev/go.temporal.io/sdk/workflow

Creates a new instance of a WaitGroup.

```go
func NewWaitGroup(ctx Context) WaitGroup
```

--------------------------------

### Get Stream State

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/workflowstreams

Returns a snapshot of the stream state for persistence across continue-as-new.

```go
func (s *WorkflowStream) GetState(publisherTTL time.Duration) (*WorkflowStreamState, error)
```

--------------------------------

### Subscription options

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/workflowstreams

Configuration for stream subscriptions.

```go
type SubscribeOptions struct {
	// Topics filters the subscription. Empty or nil means all topics.
	Topics []string
	// FromOffset is the global offset to start from. Zero means the beginning.
	FromOffset int64
	// PollCooldown is the minimum interval between polls when no more items are
	// immediately ready. Default: 100ms.
	PollCooldown time.Duration
}
```

--------------------------------

### Get activity metrics handler

Source: https://pkg.go.dev/go.temporal.io/sdk/activity

Provides a metrics handler for tracking activity-specific metrics.

```go
func GetMetricsHandler(ctx context.Context) metrics.Handler
```

--------------------------------

### NewClientFromExisting

Source: https://pkg.go.dev/go.temporal.io/sdk/client

Creates a new client using the same gRPC connection as an existing client.

```APIDOC
## func NewClientFromExisting(existingClient Client, options Options) (Client, error)

### Description
Creates a new client using the same connection as the existing client. This means all options.ConnectionOptions are ignored and options.HostPort is ignored.
```

--------------------------------

### Get activity logger

Source: https://pkg.go.dev/go.temporal.io/sdk/activity

Provides a logger instance configured for use within an activity.

```go
func GetLogger(ctx context.Context) log.Logger
```

--------------------------------

### Deployment Client Mock

Source: https://pkg.go.dev/go.temporal.io/sdk/mocks

Mocks the retrieval of a deployment client.

```go
func (_m *Client) DeploymentClient() client.DeploymentClient
```

--------------------------------

### Get DevServer Frontend HostPort

Source: https://pkg.go.dev/go.temporal.io/sdk/testsuite

Returns the host and port for the running dev server.

```go
func (s *DevServer) FrontendHostPort() string
```

--------------------------------

### func StreamServer

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/googleadk

Installs the workflow-side stream server to handle incoming model output chunks.

```APIDOC
## func StreamServer

### Description
Installs the workflow-side stream server that streamed model output lands in. Call it once near the top of the workflow when using streaming.

### Signature
`func StreamServer(ctx workflow.Context) error`
```

--------------------------------

### Client configuration options

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/workflowstreams

Configuration struct for the Client, including batching intervals and payload converters.

```go
type Options struct {
	// BatchInterval is the interval between automatic flushes. Default: 2s.
	BatchInterval time.Duration
	// MaxBatchSize triggers a flush once the buffer reaches this many items.
	// Zero disables size-based flushing.
	MaxBatchSize int
	// MaxRetryDuration is the maximum time to retry a failed flush before
	// returning a FlushTimeoutError. Must be less than the workflow's publisher
	// TTL (default 15m) to preserve exactly-once delivery. Default: 10m.
	MaxRetryDuration time.Duration
	// PayloadConverters customize how published values are serialized into the
	// per-item Payloads carried inside each batch. They are combined into a
	// CompositeDataConverter in the order given (as with
	// converter.NewCompositeDataConverter), so the last one should be a
	// catch-all such as converter.NewJSONPayloadConverter.
	//
	// Only payload conversion happens here — never a payload codec
	// (encryption, compression). The codec chain configured on the Temporal
	// client runs once on the signal/update envelope that carries each batch,
	// so encoding items here too would double-encode them; the
	// []PayloadConverter type makes that mistake impossible. To decode
	// subscribed items, use a converter built from the same PayloadConverters.
	//
	// Default: the converters from converter.GetDefaultDataConverter().
	PayloadConverters []converter.PayloadConverter
}
```

--------------------------------

### ExecuteWorkflow

Source: https://pkg.go.dev/go.temporal.io/sdk/client

Starts a new workflow execution using a function reference or workflow type name.

```APIDOC
## ExecuteWorkflow

### Description
Starts a workflow execution and returns a WorkflowRun instance. This method can be used with a function reference or a workflow type name.

### Signature
`ExecuteWorkflow(ctx context.Context, options StartWorkflowOptions, workflow interface{}, args ...interface{}) (WorkflowRun, error)`

### Parameters
- **ctx** (context.Context) - The context for the request.
- **options** (StartWorkflowOptions) - Configuration options for the workflow.
- **workflow** (interface{}) - The workflow function reference or workflow type name.
- **args** (...interface{}) - Arguments to pass to the workflow.

### Returns
- **WorkflowRun** - An instance to track the workflow execution.
- **error** - Returns errors such as NamespaceNotFound, InvalidArgument, Internal, Unavailable, or WorkflowExecutionAlreadyStarted.
```

--------------------------------

### Define a simple plugin

Source: https://pkg.go.dev/go.temporal.io/sdk/temporal

Implements both client and worker plugins from a given set of options.

```go
type SimplePlugin = internal.SimplePlugin
```

--------------------------------

### Config Structure

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/googleadk

Defines worker-side registries for models and MCP toolsets. Construct this once at worker start.

```go
type Config struct {
	// Models maps a model name (the string the user sets on their model.LLM and
	// that ADK copies into LLMRequest.Model) to a factory that rebuilds it
	// worker-side. The InvokeModel Activity looks the factory up by name. It is
	// optional: when a name is absent here, InvokeModel falls back to ADK's
	// name-based model registry (model.NewLLM) — which stays application-owned;
	// this package never registers into it — and gemini-* names the registry
	// does not know resolve via a built-in zero-config Gemini fallback. Use
	// Models to supply custom credentials, disable SDK retries, or override
	// what the fallbacks would otherwise build.
	Models map[string]ModelFactory

	// MCPToolsets maps the logical name passed to NewMCPToolset to a factory that
	// builds the live stateless MCP toolset worker-side. The ListMcpTools and
	// CallMcpTool Activities use it. Each factory runs at most once per name —
	// its toolset is cached on the Activities value and shared across calls; see
	// MCPFactory for the full lifecycle contract.
	MCPToolsets map[string]MCPFactory
}
```

--------------------------------

### Configure S3 Driver with Temporal Client

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/aws/s3driver

Initialize the S3 driver using the AWS SDK v2 and register it with the Temporal client's ExternalStorage configuration.

```go
import (
    "context"

    "github.com/aws/aws-sdk-go-v2/config"
    "github.com/aws/aws-sdk-go-v2/service/s3"
    "go.temporal.io/sdk/client"
    "go.temporal.io/sdk/contrib/aws/s3driver"
    "go.temporal.io/sdk/contrib/aws/s3driver/awssdkv2"
    "go.temporal.io/sdk/converter"
)

cfg, err := config.LoadDefaultConfig(context.Background())
if err != nil {
    // handle error
}

driver, err := s3driver.NewDriver(s3driver.Options{
    Client: awssdkv2.NewClient(s3.NewFromConfig(cfg)),
    Bucket: s3driver.StaticBucket("my-temporal-payloads"),
})
if err != nil {
    // handle error
}

c, err := client.Dial(client.Options{
    HostPort:  "localhost:7233",
    ExternalStorage: converter.ExternalStorage{
        Drivers: []converter.StorageDriver{driver},
    },
})
```

--------------------------------

### Client Interface Methods

Source: https://pkg.go.dev/go.temporal.io/sdk/client

Methods available on the Client interface for managing schedules, deployments, and resource cleanup.

```go
ScheduleClient() ScheduleClient

	// DeploymentClient create a new deployment client with the same gRPC connection as this client.
	//
	// Deprecated: use [WorkerDeploymentClient]
	DeploymentClient() DeploymentClient

	// WorkerDeploymentClient create a new worker deployment client with the same gRPC connections as this client.
	//
	// NOTE: Experimental
	WorkerDeploymentClient() WorkerDeploymentClient

	// Close client and clean up underlying resources.
	//
	// If this client was created via NewClientFromExisting or this client has
	// been used in that call, Close() on may not necessarily close the
	// underlying connection. Only the final close of all existing clients will
	// close the underlying connection.
	Close()
```

--------------------------------

### Get current operation information

Source: https://pkg.go.dev/go.temporal.io/sdk/temporalnexus

Retrieves information about the currently executing Nexus operation from the context.

```go
func GetOperationInfo(ctx context.Context) OperationInfo
```

--------------------------------

### Configure CachedDownload

Source: https://pkg.go.dev/go.temporal.io/sdk/testsuite

Configuration for downloading the dev server binary.

```go
type CachedDownload struct {
	// Which version to download, by default the latest version compatible with the SDK will be downloaded.
	// Acceptable values are specific release versions (e.g v0.3.0), "default", and "latest".
	Version string
	// Destination directory or the user temp directory if unset.
	DestDir string
}
```

--------------------------------

### Initialize ResourceBasedSlotSupplier

Source: https://pkg.go.dev/go.temporal.io/sdk/worker

Creates a new supplier instance; all instances must share the same ResourceController.

```go
func NewResourceBasedSlotSupplier(
	controller *ResourceController,
	options ResourceBasedSlotSupplierOptions,
) (*ResourceBasedSlotSupplier, error)
```

--------------------------------

### Worker Interface Definition

Source: https://pkg.go.dev/go.temporal.io/sdk/worker

The Worker interface defines methods for starting, running, and stopping a worker process.

```go
type Worker interface {
	Registry

	// Start the worker in a non-blocking fashion.
	//
	// Note, this will only return errors on start. To catch errors during run,
	// use Run() instead or set Options.OnFatalError.
	Start() error

	// Run the worker in a blocking fashion. Stop the worker when interruptCh receives signal.
	// Pass worker.InterruptCh() to stop the worker with SIGINT or SIGTERM.
	// Pass nil to stop the worker with external Stop() call.
	// Pass any other `<-chan interface{}` and Run will wait for signal from that channel.
	// Returns error if the worker fails to start or there is a fatal error
	// during execution.
	//
	// Users are encouraged to use Start() instead of this call if they plan to
	// manually Stop(). Otherwise a race can occur if shutdown occurs before the
	// worker is started. This Run() call is only best if shutdown is initiated
	// via the interrupt channel.
	Run(interruptCh <-chan interface{}) error

	// Stop the worker.
	//
	// This may panic if called a second time.
	Stop()
}
```

--------------------------------

### Define temporal operation options

Source: https://pkg.go.dev/go.temporal.io/sdk/temporalnexus

Configuration for a Temporal Nexus operation, including start and cancellation handlers.

```go
type TemporalOperationOptions[I, O any] struct {
	// Name of the operation. Required.
	Name string
	// Start handles the operation start. It receives the operation context, a [NexusClient] scoped
	// to this invocation, the operation input, and the start operation options.
	// Required.
	Start func(ctx context.Context, nc NexusClient, input I, options StartTemporalOperationOptions) (TemporalOperationResult[O], error)
	// CancelWorkflowRun handles cancel for workflow-run operation tokens.
	// It receives the Temporal client, the workflow-run options extracted from the token, and the
	// Nexus cancel options. If nil, defaults to cancelling the workflow via the Temporal client.
	CancelWorkflowRun func(ctx context.Context, c client.Client, options CancelTemporalWorkflowRunOptions, cancelOptions nexus.CancelOperationOptions) error
	// CancelWorkflowUpdate handles cancel for UpdateWorkflow operation tokens.
	// It receives the Temporal client, the update-workflow options extracted from the token, and the
	// Nexus cancel options. If nil, will error out with [ErrCannotCancelWorkflowUpdate] as there is no default behavior for cancelling an UpdateWorkflow.
}
```

--------------------------------

### client.Dial

Source: https://pkg.go.dev/go.temporal.io/sdk/client

Initializes a new Temporal client using the provided options.

```APIDOC
## func Dial(options Options) (Client, error)

### Description
Creates a new Temporal client instance to communicate with the Temporal service.

### Parameters
- **options** (Options) - Required - Configuration options for the client connection.
```

--------------------------------

### Initialize S3 Storage Driver

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/aws/s3driver

Creates a new S3 StorageDriver instance using the provided configuration options.

```go
func NewDriver(opts Options) (converter.StorageDriver, error)
```

--------------------------------

### Nexus client structure

Source: https://pkg.go.dev/go.temporal.io/sdk/temporalnexus

Wraps the Temporal client with Nexus-aware context. Should not be stored beyond the Start callback.

```go
type NexusClient struct {
	// contains filtered or unexported fields
}
```

--------------------------------

### Execute an Activity with Options

Source: https://pkg.go.dev/go.temporal.io/sdk/workflow

Configures ActivityOptions via a child context and executes an activity, blocking for the result using a Future.

```go
ao := workflow.ActivityOptions{
	TaskQueue:              "sampleTaskQueue",
	ScheduleToCloseTimeout: time.Second * 60,
	ScheduleToStartTimeout: time.Second * 60,
	StartToCloseTimeout:    time.Second * 60,
	HeartbeatTimeout:       time.Second * 10,
	WaitForCancellation:    false,
}
ctx = workflow.WithActivityOptions(ctx, ao)

future := [workflow.ExecuteActivity](ctx, SimpleActivity, value)
var result string
if err := future.Get(ctx, &result); err != nil {
	return err
}
```

--------------------------------

### Define LoadClientConfigOptions

Source: https://pkg.go.dev/go.temporal.io/sdk/contrib/envconfig

Configuration options for loading a Temporal client, supporting file paths, raw TOML data, and custom environment lookups.

```go
type LoadClientConfigOptions struct {
	// Override the file path to use to load the TOML file for config. Defaults to TEMPORAL_CONFIG_FILE environment
	// variable or if that is unset/empty, defaults to [os.UserConfigDir]/temporalio/temporal.toml. If ConfigFileData is
	// set, this cannot be set and no file loading from disk occurs.
	ConfigFilePath string

	// TOML data to load for config. If set, this overrides any file loading. Cannot be set if ConfigFilePath is set.
	ConfigFileData []byte

	// If true, will error if there are unrecognized keys.
	ConfigFileStrict bool

	// Override the environment variable lookup (only used to determine which config file to load). If nil,
	// defaults to [EnvLookupOS].
	EnvLookup EnvLookup
}
```

--------------------------------

### SetUpdateHandlerWithOptions

Source: https://pkg.go.dev/go.temporal.io/sdk/workflow

Registers an update handler with custom options, including an optional validator function.

```go
func SetUpdateHandlerWithOptions(ctx Context, updateName string, handler interface{}, opts UpdateHandlerOptions) error
```

--------------------------------

### Get Default Slot Supplier Options

Source: https://pkg.go.dev/go.temporal.io/sdk/worker

Retrieves default configuration for activity or workflow slot suppliers.

```go
func DefaultActivityResourceBasedSlotSupplierOptions() ResourceBasedSlotSupplierOptions
```

```go
func DefaultWorkflowResourceBasedSlotSupplierOptions() ResourceBasedSlotSupplierOptions
```

--------------------------------

### DescribeVersion Mock Method

Source: https://pkg.go.dev/go.temporal.io/sdk/mocks

Provides a mock implementation for describing a worker deployment version.

```go
func (_m *WorkerDeploymentHandle) DescribeVersion(ctx context.Context, options client.WorkerDeploymentDescribeVersionOptions) (client.WorkerDeploymentVersionDescription, error)
```
Tokens:
Raw