hatchet-sdk 0.47.1__py3-none-any.whl → 1.0.0a1__py3-none-any.whl

hatchet_sdk/clients/admin.py

@@ -1,70 +1,56 @@
+import asyncio
 import json
 from datetime import datetime
-from typing import Any, Callable, Dict, List, Optional, TypedDict, TypeVar, Union
+from typing import Union, cast
 
 import grpc
 from google.protobuf import timestamp_pb2
+from pydantic import BaseModel, ConfigDict, Field, field_validator
 
-from hatchet_sdk.clients.rest.models.workflow_run import WorkflowRun
 from hatchet_sdk.clients.rest.tenacity_utils import tenacity_retry
-from hatchet_sdk.clients.run_event_listener import new_listener
+from hatchet_sdk.clients.run_event_listener import RunEventListenerClient
 from hatchet_sdk.clients.workflow_listener import PooledWorkflowRunListener
+from hatchet_sdk.config import ClientConfig
 from hatchet_sdk.connection import new_conn
-from hatchet_sdk.contracts.workflows_pb2 import (
-    BulkTriggerWorkflowRequest,
-    BulkTriggerWorkflowResponse,
-    CreateWorkflowVersionOpts,
-    PutRateLimitRequest,
-    PutWorkflowRequest,
-    RateLimitDuration,
-    ScheduleWorkflowRequest,
-    TriggerWorkflowRequest,
-    TriggerWorkflowResponse,
-    WorkflowVersion,
-)
+from hatchet_sdk.contracts import workflows_pb2 as v0_workflow_protos
+from hatchet_sdk.contracts.v1 import workflows_pb2 as workflow_protos
+from hatchet_sdk.contracts.v1.workflows_pb2_grpc import AdminServiceStub
 from hatchet_sdk.contracts.workflows_pb2_grpc import WorkflowServiceStub
-from hatchet_sdk.utils.serialization import flatten
-from hatchet_sdk.workflow_run import RunRef, WorkflowRunRef
-
-from ..loader import ClientConfig
-from ..metadata import get_metadata
-from ..workflow import WorkflowMeta
-
-
-def new_admin(config: ClientConfig):
-    return AdminClient(config)
-
-
-class ScheduleTriggerWorkflowOptions(TypedDict, total=False):
-    parent_id: Optional[str]
-    parent_step_run_id: Optional[str]
-    child_index: Optional[int]
-    child_key: Optional[str]
-    namespace: Optional[str]
-
-
-class ChildTriggerWorkflowOptions(TypedDict, total=False):
-    additional_metadata: Dict[str, str] | None = None
-    sticky: bool | None = None
+from hatchet_sdk.metadata import get_metadata
+from hatchet_sdk.rate_limit import RateLimitDuration
+from hatchet_sdk.runnables.contextvars import (
+    ctx_step_run_id,
+    ctx_worker_id,
+    ctx_workflow_run_id,
+    spawn_index_lock,
+    workflow_spawn_indices,
+)
+from hatchet_sdk.utils.proto_enums import convert_python_enum_to_proto
+from hatchet_sdk.utils.typing import JSONSerializableMapping
+from hatchet_sdk.workflow_run import WorkflowRunRef
 
 
-class ChildWorkflowRunDict(TypedDict, total=False):
-    workflow_name: str
-    input: Any
-    options: ChildTriggerWorkflowOptions
-    key: str | None = None
+class ScheduleTriggerWorkflowOptions(BaseModel):
+    parent_id: str | None = None
+    parent_step_run_id: str | None = None
+    child_index: int | None = None
+    child_key: str | None = None
+    namespace: str | None = None
 
 
-class TriggerWorkflowOptions(ScheduleTriggerWorkflowOptions, total=False):
-    additional_metadata: Dict[str, str] | None = None
+class TriggerWorkflowOptions(ScheduleTriggerWorkflowOptions):
+    additional_metadata: JSONSerializableMapping = Field(default_factory=dict)
     desired_worker_id: str | None = None
     namespace: str | None = None
+    sticky: bool = False
+    key: str | None = None
 
 
-class WorkflowRunDict(TypedDict, total=False):
+class WorkflowRunTriggerConfig(BaseModel):
     workflow_name: str
-    input: Any
-    options: TriggerWorkflowOptions | None
+    input: JSONSerializableMapping
+    options: TriggerWorkflowOptions
+    key: str | None = None
 
 
 class DedupeViolationErr(Exception):
@@ -73,259 +59,198 @@ class DedupeViolationErr(Exception):
     pass
 
 
-class AdminClientBase:
-    pooled_workflow_listener: PooledWorkflowRunListener | None = None
+class AdminClient:
+    def __init__(self, config: ClientConfig):
+        conn = new_conn(config, False)
+        self.config = config
+        self.client = AdminServiceStub(conn)  # type: ignore[no-untyped-call]
+        self.v0_client = WorkflowServiceStub(conn)  # type: ignore[no-untyped-call]
+        self.token = config.token
+        self.listener_client = RunEventListenerClient(config=config)
+        self.namespace = config.namespace
 
-    def _prepare_workflow_request(
-        self, workflow_name: str, input: any, options: TriggerWorkflowOptions = None
-    ):
-        try:
-            payload_data = json.dumps(input)
+        self.pooled_workflow_listener: PooledWorkflowRunListener | None = None
+
+    class TriggerWorkflowRequest(BaseModel):
+        model_config = ConfigDict(extra="ignore")
+
+        parent_id: str | None = None
+        parent_step_run_id: str | None = None
+        child_index: int | None = None
+        child_key: str | None = None
+        additional_metadata: str | None = None
+        desired_worker_id: str | None = None
+        priority: int | None = None
+
+        @field_validator("additional_metadata", mode="before")
+        @classmethod
+        def validate_additional_metadata(
+            cls, v: JSONSerializableMapping | None
+        ) -> bytes | None:
+            if not v:
+                return None
 
             try:
-                meta = (
-                    None
-                    if options is None or "additional_metadata" not in options
-                    else options["additional_metadata"]
-                )
-                if meta is not None:
-                    options = {
-                        **options,
-                        "additional_metadata": json.dumps(meta).encode("utf-8"),
-                    }
+                return json.dumps(v).encode("utf-8")
             except json.JSONDecodeError as e:
                 raise ValueError(f"Error encoding payload: {e}")
 
-            return TriggerWorkflowRequest(
-                name=workflow_name, input=payload_data, **(options or {})
-            )
+    def _prepare_workflow_request(
+        self,
+        workflow_name: str,
+        input: JSONSerializableMapping,
+        options: TriggerWorkflowOptions,
+    ) -> v0_workflow_protos.TriggerWorkflowRequest:
+        try:
+            payload_data = json.dumps(input)
         except json.JSONDecodeError as e:
             raise ValueError(f"Error encoding payload: {e}")
 
+        _options = self.TriggerWorkflowRequest.model_validate(
+            options.model_dump()
+        ).model_dump()
+
+        return v0_workflow_protos.TriggerWorkflowRequest(
+            name=workflow_name, input=payload_data, **_options
+        )
+
     def _prepare_put_workflow_request(
         self,
         name: str,
-        workflow: CreateWorkflowVersionOpts | WorkflowMeta,
-        overrides: CreateWorkflowVersionOpts | None = None,
-    ):
-        try:
-            opts: CreateWorkflowVersionOpts
-
-            if isinstance(workflow, CreateWorkflowVersionOpts):
-                opts = workflow
-            else:
-                opts = workflow.get_create_opts(self.client.config.namespace)
-
-            if overrides is not None:
-                opts.MergeFrom(overrides)
-
-            opts.name = name
-
-            return PutWorkflowRequest(
-                opts=opts,
+        workflow: workflow_protos.CreateWorkflowVersionRequest,
+        overrides: workflow_protos.CreateWorkflowVersionRequest | None = None,
+    ) -> workflow_protos.CreateWorkflowVersionRequest:
+        if overrides is not None:
+            workflow.MergeFrom(overrides)
+
+        workflow.name = name
+
+        return workflow
+
+    def _parse_schedule(
+        self, schedule: datetime | timestamp_pb2.Timestamp
+    ) -> timestamp_pb2.Timestamp:
+        if isinstance(schedule, datetime):
+            t = schedule.timestamp()
+            seconds = int(t)
+            nanos = int(t % 1 * 1e9)
+            return timestamp_pb2.Timestamp(seconds=seconds, nanos=nanos)
+        elif isinstance(schedule, timestamp_pb2.Timestamp):
+            return schedule
+        else:
+            raise ValueError(
+                "Invalid schedule type. Must be datetime or timestamp_pb2.Timestamp."
             )
-        except grpc.RpcError as e:
-            raise ValueError(f"Could not put workflow: {e}")
 
     def _prepare_schedule_workflow_request(
         self,
         name: str,
-        schedules: List[Union[datetime, timestamp_pb2.Timestamp]],
-        input={},
-        options: ScheduleTriggerWorkflowOptions = None,
-    ):
-        timestamp_schedules = []
-        for schedule in schedules:
-            if isinstance(schedule, datetime):
-                t = schedule.timestamp()
-                seconds = int(t)
-                nanos = int(t % 1 * 1e9)
-                timestamp = timestamp_pb2.Timestamp(seconds=seconds, nanos=nanos)
-                timestamp_schedules.append(timestamp)
-            elif isinstance(schedule, timestamp_pb2.Timestamp):
-                timestamp_schedules.append(schedule)
-            else:
-                raise ValueError(
-                    "Invalid schedule type. Must be datetime or timestamp_pb2.Timestamp."
-                )
-
-        return ScheduleWorkflowRequest(
+        schedules: list[Union[datetime, timestamp_pb2.Timestamp]],
+        input: JSONSerializableMapping = {},
+        options: ScheduleTriggerWorkflowOptions = ScheduleTriggerWorkflowOptions(),
+    ) -> v0_workflow_protos.ScheduleWorkflowRequest:
+        return v0_workflow_protos.ScheduleWorkflowRequest(
             name=name,
-            schedules=timestamp_schedules,
+            schedules=[self._parse_schedule(schedule) for schedule in schedules],
             input=json.dumps(input),
-            **(options or {}),
+            **options.model_dump(),
         )
 
-
-T = TypeVar("T")
-
-
-class AdminClientAioImpl(AdminClientBase):
-    def __init__(self, config: ClientConfig):
-        aio_conn = new_conn(config, True)
-        self.config = config
-        self.aio_client = WorkflowServiceStub(aio_conn)
-        self.token = config.token
-        self.listener_client = new_listener(config)
-        self.namespace = config.namespace
-
-    async def run(
+    @tenacity_retry
+    async def aio_put_workflow(
         self,
-        function: Union[str, Callable[[Any], T]],
-        input: any,
-        options: TriggerWorkflowOptions = None,
-    ) -> "RunRef[T]":
-        workflow_name = function
-
-        if not isinstance(function, str):
-            workflow_name = function.function_name
-
-        wrr = await self.run_workflow(workflow_name, input, options)
+        name: str,
+        workflow: workflow_protos.CreateWorkflowVersionRequest,
+        overrides: workflow_protos.CreateWorkflowVersionRequest | None = None,
+    ) -> workflow_protos.CreateWorkflowVersionResponse:
+        ## IMPORTANT: The `pooled_workflow_listener` must be created 1) lazily, and not at `init` time, and 2) on the
+        ## main thread. If 1) is not followed, you'll get an error about something being attached to the wrong event
+        ## loop. If 2) is not followed, you'll get an error about the event loop not being set up.
+        if not self.pooled_workflow_listener:
+            self.pooled_workflow_listener = PooledWorkflowRunListener(self.config)
 
-        return RunRef[T](
-            wrr.workflow_run_id, wrr.workflow_listener, wrr.workflow_run_event_listener
-        )
+        return await asyncio.to_thread(self.put_workflow, name, workflow, overrides)
 
-    ## IMPORTANT: Keep this method's signature in sync with the wrapper in the OTel instrumentor
     @tenacity_retry
-    async def run_workflow(
-        self, workflow_name: str, input: any, options: TriggerWorkflowOptions = None
-    ) -> WorkflowRunRef:
-        try:
-            if not self.pooled_workflow_listener:
-                self.pooled_workflow_listener = PooledWorkflowRunListener(self.config)
-
-            namespace = self.namespace
-
-            if (
-                options is not None
-                and "namespace" in options
-                and options["namespace"] is not None
-            ):
-                namespace = options.pop("namespace")
-
-            if namespace != "" and not workflow_name.startswith(self.namespace):
-                workflow_name = f"{namespace}{workflow_name}"
-
-            request = self._prepare_workflow_request(workflow_name, input, options)
-
-            resp: TriggerWorkflowResponse = await self.aio_client.TriggerWorkflow(
-                request,
-                metadata=get_metadata(self.token),
-            )
-
-            return WorkflowRunRef(
-                workflow_run_id=resp.workflow_run_id,
-                workflow_listener=self.pooled_workflow_listener,
-                workflow_run_event_listener=self.listener_client,
-            )
-        except (grpc.RpcError, grpc.aio.AioRpcError) as e:
-            if e.code() == grpc.StatusCode.ALREADY_EXISTS:
-                raise DedupeViolationErr(e.details())
+    async def aio_put_rate_limit(
+        self,
+        key: str,
+        limit: int,
+        duration: RateLimitDuration = RateLimitDuration.SECOND,
+    ) -> None:
+        ## IMPORTANT: The `pooled_workflow_listener` must be created 1) lazily, and not at `init` time, and 2) on the
+        ## main thread. If 1) is not followed, you'll get an error about something being attached to the wrong event
+        ## loop. If 2) is not followed, you'll get an error about the event loop not being set up.
+        if not self.pooled_workflow_listener:
+            self.pooled_workflow_listener = PooledWorkflowRunListener(self.config)
 
-            raise e
+        return await asyncio.to_thread(self.put_rate_limit, key, limit, duration)
 
-    ## IMPORTANT: Keep this method's signature in sync with the wrapper in the OTel instrumentor
     @tenacity_retry
-    async def run_workflows(
+    async def aio_schedule_workflow(
         self,
-        workflows: list[WorkflowRunDict],
-        options: TriggerWorkflowOptions | None = None,
-    ) -> List[WorkflowRunRef]:
-        if len(workflows) == 0:
-            raise ValueError("No workflows to run")
-
+        name: str,
+        schedules: list[Union[datetime, timestamp_pb2.Timestamp]],
+        input: JSONSerializableMapping = {},
+        options: ScheduleTriggerWorkflowOptions = ScheduleTriggerWorkflowOptions(),
+    ) -> v0_workflow_protos.WorkflowVersion:
+        ## IMPORTANT: The `pooled_workflow_listener` must be created 1) lazily, and not at `init` time, and 2) on the
+        ## main thread. If 1) is not followed, you'll get an error about something being attached to the wrong event
+        ## loop. If 2) is not followed, you'll get an error about the event loop not being set up.
         if not self.pooled_workflow_listener:
             self.pooled_workflow_listener = PooledWorkflowRunListener(self.config)
 
-        namespace = self.namespace
-
-        if (
-            options is not None
-            and "namespace" in options
-            and options["namespace"] is not None
-        ):
-            namespace = options["namespace"]
-            del options["namespace"]
-
-        workflow_run_requests: TriggerWorkflowRequest = []
-
-        for workflow in workflows:
-            workflow_name = workflow["workflow_name"]
-            input_data = workflow["input"]
-            options = workflow["options"]
-
-            if namespace != "" and not workflow_name.startswith(self.namespace):
-                workflow_name = f"{namespace}{workflow_name}"
-
-            # Prepare and trigger workflow for each workflow name and input
-            request = self._prepare_workflow_request(workflow_name, input_data, options)
-            workflow_run_requests.append(request)
-
-        request = BulkTriggerWorkflowRequest(workflows=workflow_run_requests)
-
-        resp: BulkTriggerWorkflowResponse = await self.aio_client.BulkTriggerWorkflow(
-            request,
-            metadata=get_metadata(self.token),
+        return await asyncio.to_thread(
+            self.schedule_workflow, name, schedules, input, options
         )
 
-        return [
-            WorkflowRunRef(
-                workflow_run_id=workflow_run_id,
-                workflow_listener=self.pooled_workflow_listener,
-                workflow_run_event_listener=self.listener_client,
-            )
-            for workflow_run_id in resp.workflow_run_ids
-        ]
-
     @tenacity_retry
-    async def put_workflow(
+    def put_workflow(
         self,
         name: str,
-        workflow: CreateWorkflowVersionOpts | WorkflowMeta,
-        overrides: CreateWorkflowVersionOpts | None = None,
-    ) -> WorkflowVersion:
+        workflow: workflow_protos.CreateWorkflowVersionRequest,
+        overrides: workflow_protos.CreateWorkflowVersionRequest | None = None,
+    ) -> workflow_protos.CreateWorkflowVersionResponse:
         opts = self._prepare_put_workflow_request(name, workflow, overrides)
 
-        return await self.aio_client.PutWorkflow(
-            opts,
-            metadata=get_metadata(self.token),
+        return cast(
+            workflow_protos.CreateWorkflowVersionResponse,
+            self.client.PutWorkflow(
+                opts,
+                metadata=get_metadata(self.token),
+            ),
         )
 
     @tenacity_retry
-    async def put_rate_limit(
+    def put_rate_limit(
         self,
         key: str,
         limit: int,
         duration: RateLimitDuration = RateLimitDuration.SECOND,
-    ):
-        await self.aio_client.PutRateLimit(
-            PutRateLimitRequest(
+    ) -> None:
+        duration_proto = convert_python_enum_to_proto(
+            duration, workflow_protos.RateLimitDuration
+        )
+
+        self.v0_client.PutRateLimit(
+            v0_workflow_protos.PutRateLimitRequest(
                 key=key,
                 limit=limit,
-                duration=duration,
+                duration=duration_proto,  # type: ignore[arg-type]
             ),
             metadata=get_metadata(self.token),
         )
 
     @tenacity_retry
-    async def schedule_workflow(
+    def schedule_workflow(
         self,
         name: str,
-        schedules: List[Union[datetime, timestamp_pb2.Timestamp]],
-        input={},
-        options: ScheduleTriggerWorkflowOptions = None,
-    ) -> WorkflowVersion:
+        schedules: list[Union[datetime, timestamp_pb2.Timestamp]],
+        input: JSONSerializableMapping = {},
+        options: ScheduleTriggerWorkflowOptions = ScheduleTriggerWorkflowOptions(),
+    ) -> v0_workflow_protos.WorkflowVersion:
         try:
-            namespace = self.namespace
-
-            if (
-                options is not None
-                and "namespace" in options
-                and options["namespace"] is not None
-            ):
-                namespace = options["namespace"]
-                del options["namespace"]
+            namespace = options.namespace or self.namespace
 
             if namespace != "" and not name.startswith(self.namespace):
                 name = f"{namespace}{name}"
@@ -334,128 +259,112 @@ class AdminClientAioImpl(AdminClientBase):
                 name, schedules, input, options
             )
 
-            return await self.aio_client.ScheduleWorkflow(
-                request,
-                metadata=get_metadata(self.token),
+            return cast(
+                v0_workflow_protos.WorkflowVersion,
+                self.v0_client.ScheduleWorkflow(
+                    request,
+                    metadata=get_metadata(self.token),
+                ),
             )
-        except (grpc.aio.AioRpcError, grpc.RpcError) as e:
+        except (grpc.RpcError, grpc.aio.AioRpcError) as e:
             if e.code() == grpc.StatusCode.ALREADY_EXISTS:
                 raise DedupeViolationErr(e.details())
 
             raise e
 
-
-class AdminClient(AdminClientBase):
-    def __init__(self, config: ClientConfig):
-        conn = new_conn(config)
-        self.config = config
-        self.client = WorkflowServiceStub(conn)
-        self.aio = AdminClientAioImpl(config)
-        self.token = config.token
-        self.listener_client = new_listener(config)
-        self.namespace = config.namespace
-
-    @tenacity_retry
-    def put_workflow(
+    def _create_workflow_run_request(
         self,
-        name: str,
-        workflow: CreateWorkflowVersionOpts | WorkflowMeta,
-        overrides: CreateWorkflowVersionOpts | None = None,
-    ) -> WorkflowVersion:
-        opts = self._prepare_put_workflow_request(name, workflow, overrides)
+        workflow_name: str,
+        input: JSONSerializableMapping,
+        options: TriggerWorkflowOptions,
+    ) -> v0_workflow_protos.TriggerWorkflowRequest:
+        workflow_run_id = ctx_workflow_run_id.get()
+        step_run_id = ctx_step_run_id.get()
+        worker_id = ctx_worker_id.get()
+        spawn_index = workflow_spawn_indices[workflow_run_id] if workflow_run_id else 0
+
+        ## Increment the spawn_index for the parent workflow
+        if workflow_run_id:
+            workflow_spawn_indices[workflow_run_id] += 1
+
+        desired_worker_id = (
+            (options.desired_worker_id or worker_id) if options.sticky else None
+        )
+        child_index = (
+            options.child_index if options.child_index is not None else spawn_index
+        )
 
-        resp: WorkflowVersion = self.client.PutWorkflow(
-            opts,
-            metadata=get_metadata(self.token),
+        trigger_options = TriggerWorkflowOptions(
+            parent_id=options.parent_id or workflow_run_id,
+            parent_step_run_id=options.parent_step_run_id or step_run_id,
+            child_key=options.child_key,
+            child_index=child_index,
+            additional_metadata=options.additional_metadata,
+            desired_worker_id=desired_worker_id,
         )
 
-        return resp
+        namespace = options.namespace or self.namespace
 
-    @tenacity_retry
-    def put_rate_limit(
-        self,
-        key: str,
-        limit: int,
-        duration: Union[RateLimitDuration.Value, str] = RateLimitDuration.SECOND,
-    ):
-        self.client.PutRateLimit(
-            PutRateLimitRequest(
-                key=key,
-                limit=limit,
-                duration=duration,
-            ),
-            metadata=get_metadata(self.token),
-        )
+        if namespace != "" and not workflow_name.startswith(self.namespace):
+            workflow_name = f"{namespace}{workflow_name}"
+
+        return self._prepare_workflow_request(workflow_name, input, trigger_options)
 
+    ## IMPORTANT: Keep this method's signature in sync with the wrapper in the OTel instrumentor
     @tenacity_retry
-    def schedule_workflow(
+    def run_workflow(
         self,
-        name: str,
-        schedules: List[Union[datetime, timestamp_pb2.Timestamp]],
-        input={},
-        options: ScheduleTriggerWorkflowOptions = None,
-    ) -> WorkflowVersion:
-        try:
-            namespace = self.namespace
-
-            if (
-                options is not None
-                and "namespace" in options
-                and options["namespace"] is not None
-            ):
-                namespace = options["namespace"]
-                del options["namespace"]
-
-            if namespace != "" and not name.startswith(self.namespace):
-                name = f"{namespace}{name}"
+        workflow_name: str,
+        input: JSONSerializableMapping,
+        options: TriggerWorkflowOptions = TriggerWorkflowOptions(),
+    ) -> WorkflowRunRef:
+        request = self._create_workflow_run_request(workflow_name, input, options)
 
-            request = self._prepare_schedule_workflow_request(
-                name, schedules, input, options
-            )
+        if not self.pooled_workflow_listener:
+            self.pooled_workflow_listener = PooledWorkflowRunListener(self.config)
 
-            return self.client.ScheduleWorkflow(
-                request,
-                metadata=get_metadata(self.token),
+        try:
+            resp = cast(
+                v0_workflow_protos.TriggerWorkflowResponse,
+                self.v0_client.TriggerWorkflow(
+                    request,
+                    metadata=get_metadata(self.token),
+                ),
             )
         except (grpc.RpcError, grpc.aio.AioRpcError) as e:
             if e.code() == grpc.StatusCode.ALREADY_EXISTS:
                 raise DedupeViolationErr(e.details())
 
-            raise e
+        return WorkflowRunRef(
+            workflow_run_id=resp.workflow_run_id,
+            workflow_listener=self.pooled_workflow_listener,
+            workflow_run_event_listener=self.listener_client,
+        )
 
     ## IMPORTANT: Keep this method's signature in sync with the wrapper in the OTel instrumentor
     @tenacity_retry
-    def run_workflow(
-        self, workflow_name: str, input: any, options: TriggerWorkflowOptions = None
+    async def aio_run_workflow(
+        self,
+        workflow_name: str,
+        input: JSONSerializableMapping,
+        options: TriggerWorkflowOptions = TriggerWorkflowOptions(),
     ) -> WorkflowRunRef:
-        try:
-            if not self.pooled_workflow_listener:
-                self.pooled_workflow_listener = PooledWorkflowRunListener(self.config)
-
-            namespace = self.namespace
-
-            ## TODO: Factor this out - it's repeated a lot of places
-            if (
-                options is not None
-                and "namespace" in options
-                and options["namespace"] is not None
-            ):
-                namespace = options.pop("namespace")
-
-            if namespace != "" and not workflow_name.startswith(self.namespace):
-                workflow_name = f"{namespace}{workflow_name}"
+        ## IMPORTANT: The `pooled_workflow_listener` must be created 1) lazily, and not at `init` time, and 2) on the
+        ## main thread. If 1) is not followed, you'll get an error about something being attached to the wrong event
+        ## loop. If 2) is not followed, you'll get an error about the event loop not being set up.
+        async with spawn_index_lock:
+            request = self._create_workflow_run_request(workflow_name, input, options)
 
-            request = self._prepare_workflow_request(workflow_name, input, options)
-
-            resp: TriggerWorkflowResponse = self.client.TriggerWorkflow(
-                request,
-                metadata=get_metadata(self.token),
-            )
+        if not self.pooled_workflow_listener:
+            self.pooled_workflow_listener = PooledWorkflowRunListener(self.config)
 
-            return WorkflowRunRef(
-                workflow_run_id=resp.workflow_run_id,
-                workflow_listener=self.pooled_workflow_listener,
-                workflow_run_event_listener=self.listener_client,
+        try:
+            resp = cast(
+                v0_workflow_protos.TriggerWorkflowResponse,
+                self.v0_client.TriggerWorkflow(
+                    request,
+                    metadata=get_metadata(self.token),
+                ),
             )
         except (grpc.RpcError, grpc.aio.AioRpcError) as e:
             if e.code() == grpc.StatusCode.ALREADY_EXISTS:
@@ -463,43 +372,36 @@ class AdminClient(AdminClientBase):
 
             raise e
 
+        return WorkflowRunRef(
+            workflow_run_id=resp.workflow_run_id,
+            workflow_listener=self.pooled_workflow_listener,
+            workflow_run_event_listener=self.listener_client,
+        )
+
     ## IMPORTANT: Keep this method's signature in sync with the wrapper in the OTel instrumentor
     @tenacity_retry
     def run_workflows(
-        self, workflows: List[WorkflowRunDict], options: TriggerWorkflowOptions = None
+        self,
+        workflows: list[WorkflowRunTriggerConfig],
     ) -> list[WorkflowRunRef]:
-        workflow_run_requests: TriggerWorkflowRequest = []
         if not self.pooled_workflow_listener:
             self.pooled_workflow_listener = PooledWorkflowRunListener(self.config)
 
-        for workflow in workflows:
-            workflow_name = workflow["workflow_name"]
-            input_data = workflow["input"]
-            options = workflow["options"]
-
-            namespace = self.namespace
-
-            if (
-                options is not None
-                and "namespace" in options
-                and options["namespace"] is not None
-            ):
-                namespace = options["namespace"]
-                del options["namespace"]
-
-            if namespace != "" and not workflow_name.startswith(self.namespace):
-                workflow_name = f"{namespace}{workflow_name}"
-
-            # Prepare and trigger workflow for each workflow name and input
-            request = self._prepare_workflow_request(workflow_name, input_data, options)
-
-            workflow_run_requests.append(request)
-
-            request = BulkTriggerWorkflowRequest(workflows=workflow_run_requests)
+        bulk_request = v0_workflow_protos.BulkTriggerWorkflowRequest(
+            workflows=[
+                self._create_workflow_run_request(
+                    workflow.workflow_name, workflow.input, workflow.options
+                )
+                for workflow in workflows
+            ]
+        )
 
-        resp: BulkTriggerWorkflowResponse = self.client.BulkTriggerWorkflow(
-            request,
-            metadata=get_metadata(self.token),
+        resp = cast(
+            v0_workflow_protos.BulkTriggerWorkflowResponse,
+            self.v0_client.BulkTriggerWorkflow(
+                bulk_request,
+                metadata=get_metadata(self.token),
+            ),
         )
 
         return [
@@ -511,32 +413,50 @@ class AdminClient(AdminClientBase):
             for workflow_run_id in resp.workflow_run_ids
         ]
 
-    def run(
+    @tenacity_retry
+    async def aio_run_workflows(
         self,
-        function: Union[str, Callable[[Any], T]],
-        input: any,
-        options: TriggerWorkflowOptions = None,
-    ) -> "RunRef[T]":
-        workflow_name = function
-
-        if not isinstance(function, str):
-            workflow_name = function.function_name
+        workflows: list[WorkflowRunTriggerConfig],
+    ) -> list[WorkflowRunRef]:
+        ## IMPORTANT: The `pooled_workflow_listener` must be created 1) lazily, and not at `init` time, and 2) on the
+        ## main thread. If 1) is not followed, you'll get an error about something being attached to the wrong event
+        ## loop. If 2) is not followed, you'll get an error about the event loop not being set up.
+        if not self.pooled_workflow_listener:
+            self.pooled_workflow_listener = PooledWorkflowRunListener(self.config)
 
-        wrr = self.run_workflow(workflow_name, input, options)
+        async with spawn_index_lock:
+            bulk_request = v0_workflow_protos.BulkTriggerWorkflowRequest(
+                workflows=[
+                    self._create_workflow_run_request(
+                        workflow.workflow_name, workflow.input, workflow.options
+                    )
+                    for workflow in workflows
+                ]
+            )
 
-        return RunRef[T](
-            wrr.workflow_run_id, wrr.workflow_listener, wrr.workflow_run_event_listener
+        resp = cast(
+            v0_workflow_protos.BulkTriggerWorkflowResponse,
+            self.v0_client.BulkTriggerWorkflow(
+                bulk_request,
+                metadata=get_metadata(self.token),
+            ),
         )
 
-    def get_workflow_run(self, workflow_run_id: str) -> WorkflowRunRef:
-        try:
-            if not self.pooled_workflow_listener:
-                self.pooled_workflow_listener = PooledWorkflowRunListener(self.config)
-
-            return WorkflowRunRef(
+        return [
+            WorkflowRunRef(
                 workflow_run_id=workflow_run_id,
                 workflow_listener=self.pooled_workflow_listener,
                 workflow_run_event_listener=self.listener_client,
             )
-        except grpc.RpcError as e:
-            raise ValueError(f"Could not get workflow run: {e}")
+            for workflow_run_id in resp.workflow_run_ids
+        ]
+
+    def get_workflow_run(self, workflow_run_id: str) -> WorkflowRunRef:
+        if not self.pooled_workflow_listener:
+            self.pooled_workflow_listener = PooledWorkflowRunListener(self.config)
+
+        return WorkflowRunRef(
+            workflow_run_id=workflow_run_id,
+            workflow_listener=self.pooled_workflow_listener,
+            workflow_run_event_listener=self.listener_client,
+        )