Update Typescript Nexus Details (#4441)

* WIP nexus typescript public preview changes

* remove experimental notice

* fix broken link

* replace a couple more usages of old createNexusClient function

---------

Co-authored-by: Jwahir Sundai <jwahir.sundai@temporal.io>

Author: VegetarianOrc

docs/develop/typescript/nexus/feature-guide.mdx

@@ -190,10 +190,14 @@ export const helloServiceHandler = nexus.serviceHandler(helloService, {
 A common pattern is to use the Temporal Client from within a sync handler to Signal, Query, or Update a Workflow.
 You can also use Signal-With-Start or Update-With-Start to ensure the Workflow is started and send it a Signal or Update.
 All calls must complete within the [Nexus request timeout](/cloud/limits#nexus-operation-request-timeout).
-The handler receives an AbortSignal via options.signal that is triggered when the deadline is exceeded 
+The handler receives an AbortSignal via `ctx.abortSignal` that is triggered when the deadline is exceeded 
 — pass it to Temporal Client calls to ensure they are canceled if the timeout is reached.
 Updates should be short-lived to stay within this deadline.
 
+The handler context also exposes `ctx.requestDeadline` as an optional `Date`, representing the time by which the current request must complete.
+Note that this is the deadline for the current _request_, not the overall operation.
+Use it to make decisions about whether to start work that may not finish in time, or to set timeouts on downstream calls.
+
 ### Develop an Asynchronous Nexus Operation handler to start a Workflow
 
 Use `@temporalio/nexus`'s `WorkflowRunOperationHandler` helper class to easily expose a Temporal Workflow as a Nexus Operation.
@@ -269,7 +273,7 @@ import { helloServiceHandler } from './handler';
 
 ## Develop a caller Workflow that uses the Nexus Service {#develop-caller-workflow-nexus-service}
 
-To execute a Nexus Operation from a Workflow, import the necessary service definition types, then use `@temporalio/workflow`'s `createNexusClient` to create a Nexus client for that service.
+To execute a Nexus Operation from a Workflow, import the necessary service definition types, then use `@temporalio/workflow`'s `createNexusServiceClient` to create a Nexus client for that service.
 You will need to provide the Nexus Endpoint name, which you registered previously in [Create a Nexus Endpoint to route requests from caller to handler](#create-nexus-endpoint).
 
 <!--SNIPSTART typescript-nexus-hello-service-caller-workflow {"selectedLines": ["1-5","21-34"]}-->
@@ -283,7 +287,7 @@ import { helloService, LanguageCode } from "../service/api";
 const HELLO_SERVICE_ENDPOINT = "hello-service-endpoint-name";
 
 export async function helloCallerWorkflow(name: string, language: LanguageCode): Promise<string> {
-  const nexusClient = wf.createNexusClient({
+  const nexusClient = wf.createNexusServiceClient({
     service: helloService,
     endpoint: HELLO_SERVICE_ENDPOINT,
   });
@@ -440,6 +444,36 @@ For **synchronous Nexus Operations** the following are reported in the caller's
 
 :::
 
+### OpenTelemetry
+
+The `@temporalio/interceptors-opentelemetry` package supports Nexus Operations, providing automatic trace context propagation across Nexus boundaries from the caller Workflow to the handler.
+
+The easiest way to enable it is with the `OpenTelemetryPlugin`, which auto-registers Nexus interceptors alongside Activity and Workflow interceptors:
+
+```ts
+import { OpenTelemetryPlugin } from '@temporalio/interceptors-opentelemetry';
+
+const plugin = new OpenTelemetryPlugin({
+  resource: myResource,
+  spanProcessor: mySpanProcessor,
+});
+
+const worker = await Worker.create({
+  // ...
+  plugins: [plugin],
+  nexusServices: [myServiceHandler],
+});
+```
+
+The plugin creates the following spans:
+
+- **Caller side:** `StartNexusOperation:service/operation` — created when the caller Workflow starts a Nexus Operation.
+- **Handler side:** `RunStartNexusOperation:service/operation` and `RunCancelNexusOperation:service/operation` — created when the handler processes the operation. These spans are children of the caller span, linked via trace context propagated in Nexus request headers.
+
+See the [interceptors-opentelemetry sample](https://github.com/temporalio/samples-typescript/tree/main/interceptors-opentelemetry) for a complete example.
+
+For custom interceptor logic beyond tracing (e.g., logging, authorization), see [Nexus interceptor registration](/develop/typescript/workers/interceptors#nexus-interceptor-registration).
+
 ## Learn more
 
 - Read the high-level description of the [Temporal Nexus feature](/evaluate/nexus) and watch the [Nexus keynote and demo](https://youtu.be/qqc2vsv1mrU?feature=shared&t=2082).

docs/develop/typescript/nexus/quickstart.mdx

@@ -166,7 +166,7 @@ The `nexusServices` parameter registers the handler so it can receive Nexus Oper
 <>
 
 <CodeSnippet language="typescript">
-{`import { proxyActivities, createNexusClient } from '@temporalio/workflow';
+{`import { proxyActivities, createNexusServiceClient } from '@temporalio/workflow';
 // Only import the activity types
 import type * as activities from './activities';
 import { sayHelloService } from './service';
@@ -183,7 +183,7 @@ export async function example(name: string): Promise<string> {
 const NEXUS_ENDPOINT = 'my-nexus-endpoint-name';
 
 export async function callerWorkflow(name: string): Promise<string> {
-    const nexusClient = createNexusClient({
+    const nexusClient = createNexusServiceClient({
       service: sayHelloService,
       endpoint: NEXUS_ENDPOINT,
     });
@@ -203,7 +203,7 @@ The caller Workflow demonstrates the consumer side of Nexus.
 Instead of importing handler code directly, the caller only depends on the Service contract.
 This keeps the caller and handler decoupled so they can live in separate Namespaces, repositories, or even teams.
 
-The `wf.createNexusClient()` method creates a client bound to your Nexus Service and Endpoint.
+The `wf.createNexusServiceClient()` method creates a client bound to your Nexus Service and Endpoint.
 `executeOperation` starts the operation and waits for the result.
 
 </SetupStep>

docs/develop/typescript/workers/interceptors.mdx

@@ -44,6 +44,10 @@ sample.
   Intercept workflow-related methods of [`Client`](https://typescript.temporal.io/api/classes/client.Client/) and
   [`WorkflowHandle`](https://typescript.temporal.io/api/interfaces/client.WorkflowHandle) like starting or signaling a
   Workflow.
+- [NexusInboundCallsInterceptor](https://typescript.temporal.io/api/interfaces/worker.NexusInboundCallsInterceptor):
+  Intercept inbound Nexus Operation calls like `startOperation` and `cancelOperation`.
+- [NexusOutboundCallsInterceptor](https://typescript.temporal.io/api/interfaces/worker.NexusOutboundCallsInterceptor):
+  Intercept outbound calls from Nexus Operations, such as enriching log attributes and metric tags.
 
 All interceptor methods are optional—it's up to the implementor to choose which methods to intercept.
 
@@ -74,6 +78,36 @@ export class ActivityLogInterceptor implements WorkflowOutboundCallsInterceptor
 }
 ```
 
+**Log Nexus Operations**
+
+```ts
+import type {
+  NexusInboundCallsInterceptor,
+  NexusStartOperationInput,
+  NexusStartOperationOutput,
+  Next,
+} from '@temporalio/worker';
+
+export class NexusOperationLogInterceptor implements NexusInboundCallsInterceptor {
+  async startOperation(
+    input: NexusStartOperationInput,
+    next: Next<NexusInboundCallsInterceptor, 'startOperation'>
+  ): Promise<NexusStartOperationOutput> {
+    console.log('Starting Nexus operation', {
+      service: input.ctx.service,
+      operation: input.ctx.operation,
+    });
+    const output = await next(input);
+    console.log('Nexus operation started', {
+      service: input.ctx.service,
+      operation: input.ctx.operation,
+      async: output.result.isAsync,
+    });
+    return output;
+  }
+}
+```
+
 ## Register an Interceptor {#register-interceptor}
 
 Registering an interceptor means providing it to the SDK so Temporal can invoke it when matching Client or Worker calls occur. Once registered, it runs in the call path and can observe or modify request and response data.
@@ -125,3 +159,29 @@ const worker = await Worker.create({
   },
 });
 ```
+
+### Nexus interceptor registration
+
+Nexus interceptors are registered on Worker creation via
+[WorkerOptions](https://typescript.temporal.io/api/interfaces/worker.WorkerOptions#interceptors).
+Pass an array of factory functions to `interceptors.nexus`.
+Each factory receives an [`OperationContext`](https://typescript.temporal.io/api/classes/nexus.OperationContext) and returns an object with optional `inbound` and `outbound` interceptors.
+
+`src/worker/index.ts`
+
+```ts
+import { NexusOperationLogInterceptor } from './nexus-interceptors';
+
+const worker = await Worker.create({
+  // ...
+  nexusServices: [/* your Nexus services */],
+  interceptors: {
+    nexus: [
+      (_ctx) => ({
+        inbound: new NexusOperationLogInterceptor(),
+      }),
+    ],
+  },
+});
+```
+