Respond to upstream: tctc.start_workflow -> WorkflowOperationToken

Author: dandavison

hello_nexus/basic/handler/service_handler.py

@@ -24,8 +24,8 @@
     sync_operation_handler,
 )
 from temporalio.nexus.handler import (
-    NexusStartWorkflowRequest,
     TemporalNexusOperationContext,
+    WorkflowOperationToken,
 )
 
 from hello_nexus.basic.handler.db_client import MyDBClient
@@ -45,24 +45,25 @@ def __init__(self, connected_db_client: MyDBClient):
         self.connected_db_client = connected_db_client
 
     # This is a nexus operation that is backed by a Temporal workflow. The start method
-    # starts a workflow, and returns a nexus operation token that the handler can use to
-    # obtain a workflow handle (for example if a cancel request is subsequently sent by
-    # the caller). The Temporal server takes care of delivering the workflow result to the
-    # calling workflow. The task queue defaults to the task queue being used by the Nexus
-    # worker.
+    # starts a workflow, and returns a nexus operation token synchronously. Meanwhile,
+    # the workflow executes in the background, and the Temporal server takes care of
+    # delivering the eventual workflow result (success or failure) to the calling
+    # workflow.
+    #
+    # The token will be used by the caller if it subsequently wants to cancel the Nexus
+    # operation.
     @temporalio.nexus.handler.workflow_run_operation_handler
     async def my_workflow_run_operation(
         self, ctx: StartOperationContext, input: MyInput
-    ) -> NexusStartWorkflowRequest[MyOutput]:
+    ) -> WorkflowOperationToken[MyOutput]:
         # You could use self.connected_db_client here.
         tctx = TemporalNexusOperationContext.current()
-        return NexusStartWorkflowRequest(
-            tctx.client.start_workflow(
-                WorkflowStartedByNexusOperation.run,
-                input,
-                id=str(uuid.uuid4()),
-                task_queue=tctx.task_queue,
-            )
+        return await tctx.start_workflow(
+            WorkflowStartedByNexusOperation.run,
+            input,
+            id=str(uuid.uuid4()),
+            client=tctx.client,
+            task_queue=tctx.task_queue,
         )
 
     # This is a sync operation. That means that unlike the workflow run operation above,

hello_nexus/basic/handler/service_handler_with_operation_handler_classes.py

@@ -36,7 +36,6 @@ class directly.
 )
 from temporalio.nexus.handler import (
     TemporalNexusOperationContext,
-    WorkflowOperationToken,
 )
 
 from hello_nexus.basic.handler.db_client import MyDBClient
@@ -133,18 +132,14 @@ async def start(
         self, ctx: StartOperationContext, input: MyInput
     ) -> StartOperationResultAsync:
         tctx = TemporalNexusOperationContext.current()
-        wf_handle = await tctx.client.start_workflow(
+        token = await tctx.start_workflow(
             WorkflowStartedByNexusOperation.run,
             input,
             id=str(uuid.uuid4()),
+            client=tctx.client,
             task_queue=tctx.task_queue,
         )
-        # TODO(prerelease) It must be possible to start "normal" workflows in here, and
-        # then finish up with a "nexusified" workflow. It should not be possible to
-        # construct a Nexus token for a non-nexusified workflow.
-
-        token = WorkflowOperationToken.from_workflow_handle(wf_handle).encode()
-        return StartOperationResultAsync(token)
+        return StartOperationResultAsync(token.encode())
 
     async def cancel(self, ctx: CancelOperationContext, token: str) -> None:
         return await temporalio.nexus.handler.cancel_workflow(ctx, token)

hello_nexus/without_service_definition/app.py

@@ -13,8 +13,8 @@
 from temporalio import workflow
 from temporalio.client import Client
 from temporalio.nexus.handler import (
-    NexusStartWorkflowRequest,
     TemporalNexusOperationContext,
+    WorkflowOperationToken,
     workflow_run_operation_handler,
 )
 from temporalio.worker import UnsandboxedWorkflowRunner, Worker
@@ -47,15 +47,14 @@ class MyNexusServiceHandler:
     @workflow_run_operation_handler
     async def my_workflow_run_operation(
         self, ctx: StartOperationContext, name: str
-    ) -> NexusStartWorkflowRequest[str]:
+    ) -> WorkflowOperationToken[str]:
         tctx = TemporalNexusOperationContext.current()
-        return NexusStartWorkflowRequest(
-            tctx.client.start_workflow(
-                HandlerWorkflow.run,
-                name,
-                id=str(uuid.uuid4()),
-                task_queue=tctx.task_queue,
-            )
+        return await tctx.start_workflow(
+            HandlerWorkflow.run,
+            name,
+            id=str(uuid.uuid4()),
+            client=tctx.client,
+            task_queue=tctx.task_queue,
         )