hatchet-sdk 1.0.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

hatchet_sdk/features/cron.py

@@ -1,8 +1,11 @@
-from typing import List, Union
-
 from pydantic import BaseModel, Field, field_validator
 
-from hatchet_sdk.client import Client
+from hatchet_sdk.clients.rest.api.workflow_api import WorkflowApi
+from hatchet_sdk.clients.rest.api.workflow_run_api import WorkflowRunApi
+from hatchet_sdk.clients.rest.api_client import ApiClient
+from hatchet_sdk.clients.rest.models.create_cron_workflow_trigger_request import (
+    CreateCronWorkflowTriggerRequest,
+)
 from hatchet_sdk.clients.rest.models.cron_workflows import CronWorkflows
 from hatchet_sdk.clients.rest.models.cron_workflows_list import CronWorkflowsList
 from hatchet_sdk.clients.rest.models.cron_workflows_order_by_field import (
@@ -11,10 +14,14 @@ from hatchet_sdk.clients.rest.models.cron_workflows_order_by_field import (
 from hatchet_sdk.clients.rest.models.workflow_run_order_by_direction import (
     WorkflowRunOrderByDirection,
 )
+from hatchet_sdk.clients.v1.api_client import (
+    BaseRestClient,
+    maybe_additional_metadata_to_kv,
+)
 from hatchet_sdk.utils.typing import JSONSerializableMapping
 
 
-class CreateCronTriggerJSONSerializableMapping(BaseModel):
+class CreateCronTriggerConfig(BaseModel):
     """
     Schema for creating a workflow run triggered by a cron.
 
@@ -62,27 +69,14 @@ class CreateCronTriggerJSONSerializableMapping(BaseModel):
         return v
 
 
-class CronClient:
-    """
-    Client for managing workflow cron triggers synchronously.
-
-    Attributes:
-        _client (Client): The underlying client used to interact with the REST API.
-        aio (CronClientAsync): Asynchronous counterpart of CronClient.
-    """
-
-    _client: Client
-
-    def __init__(self, _client: Client):
-        """
-        Initializes the CronClient with a given Client instance.
+class CronClient(BaseRestClient):
+    def _wra(self, client: ApiClient) -> WorkflowRunApi:
+        return WorkflowRunApi(client)
 
-        Args:
-            _client (Client): The client instance to be used for REST interactions.
-        """
-        self._client = _client
+    def _wa(self, client: ApiClient) -> WorkflowApi:
+        return WorkflowApi(client)
 
-    def create(
+    async def aio_create(
         self,
         workflow_name: str,
         cron_name: str,
@@ -91,7 +85,7 @@ class CronClient:
         additional_metadata: JSONSerializableMapping,
     ) -> CronWorkflows:
         """
-        Creates a new workflow cron trigger.
+        Asynchronously creates a new workflow cron trigger.
 
         Args:
             workflow_name (str): The name of the workflow to trigger.
@@ -103,42 +97,65 @@ class CronClient:
         Returns:
             CronWorkflows: The created cron workflow instance.
         """
-        validated_input = CreateCronTriggerJSONSerializableMapping(
+        validated_input = CreateCronTriggerConfig(
             expression=expression, input=input, additional_metadata=additional_metadata
         )
 
-        return self._client.rest.cron_create(
+        async with self.client() as client:
+            return await self._wra(client).cron_workflow_trigger_create(
+                tenant=self.client_config.tenant_id,
+                workflow=workflow_name,
+                create_cron_workflow_trigger_request=CreateCronWorkflowTriggerRequest(
+                    cronName=cron_name,
+                    cronExpression=validated_input.expression,
+                    input=dict(validated_input.input),
+                    additionalMetadata=dict(validated_input.additional_metadata),
+                ),
+            )
+
+    def create(
+        self,
+        workflow_name: str,
+        cron_name: str,
+        expression: str,
+        input: JSONSerializableMapping,
+        additional_metadata: JSONSerializableMapping,
+    ) -> CronWorkflows:
+        return self._run_async_from_sync(
+            self.aio_create,
             workflow_name,
             cron_name,
-            validated_input.expression,
-            validated_input.input,
-            validated_input.additional_metadata,
+            expression,
+            input,
+            additional_metadata,
         )
 
-    def delete(self, cron_trigger: Union[str, CronWorkflows]) -> None:
+    async def aio_delete(self, cron_id: str) -> None:
         """
-        Deletes a workflow cron trigger.
+        Asynchronously deletes a workflow cron trigger.
 
         Args:
-            cron_trigger (Union[str, CronWorkflows]): The cron trigger ID or CronWorkflows instance to delete.
+            cron_id (str): The cron trigger ID or CronWorkflows instance to delete.
         """
-        self._client.rest.cron_delete(
-            cron_trigger.metadata.id
-            if isinstance(cron_trigger, CronWorkflows)
-            else cron_trigger
-        )
+        async with self.client() as client:
+            await self._wa(client).workflow_cron_delete(
+                tenant=self.client_config.tenant_id, cron_workflow=str(cron_id)
+            )
 
-    def list(
+    def delete(self, cron_id: str) -> None:
+        return self._run_async_from_sync(self.aio_delete, cron_id)
+
+    async def aio_list(
         self,
         offset: int | None = None,
         limit: int | None = None,
         workflow_id: str | None = None,
-        additional_metadata: list[str] | None = None,
+        additional_metadata: JSONSerializableMapping | None = None,
         order_by_field: CronWorkflowsOrderByField | None = None,
         order_by_direction: WorkflowRunOrderByDirection | None = None,
     ) -> CronWorkflowsList:
         """
-        Retrieves a list of all workflow cron triggers matching the criteria.
+        Asynchronously retrieves a list of all workflow cron triggers matching the criteria.
 
         Args:
             offset (int | None): The offset to start the list from.
@@ -151,88 +168,30 @@ class CronClient:
         Returns:
             CronWorkflowsList: A list of cron workflows.
         """
-        return self._client.rest.cron_list(
-            offset=offset,
-            limit=limit,
-            workflow_id=workflow_id,
-            additional_metadata=additional_metadata,
-            order_by_field=order_by_field,
-            order_by_direction=order_by_direction,
-        )
-
-    def get(self, cron_trigger: Union[str, CronWorkflows]) -> CronWorkflows:
-        """
-        Retrieves a specific workflow cron trigger by ID.
-
-        Args:
-            cron_trigger (Union[str, CronWorkflows]): The cron trigger ID or CronWorkflows instance to retrieve.
-
-        Returns:
-            CronWorkflows: The requested cron workflow instance.
-        """
-        return self._client.rest.cron_get(
-            cron_trigger.metadata.id
-            if isinstance(cron_trigger, CronWorkflows)
-            else cron_trigger
-        )
-
-    async def aio_create(
-        self,
-        workflow_name: str,
-        cron_name: str,
-        expression: str,
-        input: JSONSerializableMapping,
-        additional_metadata: JSONSerializableMapping,
-    ) -> CronWorkflows:
-        """
-        Asynchronously creates a new workflow cron trigger.
-
-        Args:
-            workflow_name (str): The name of the workflow to trigger.
-            cron_name (str): The name of the cron trigger.
-            expression (str): The cron expression defining the schedule.
-            input (dict): The input data for the cron workflow.
-            additional_metadata (dict[str, str]): Additional metadata associated with the cron trigger (e.g. {"key1": "value1", "key2": "value2"}).
-
-        Returns:
-            CronWorkflows: The created cron workflow instance.
-        """
-        validated_input = CreateCronTriggerJSONSerializableMapping(
-            expression=expression, input=input, additional_metadata=additional_metadata
-        )
-
-        return await self._client.rest.aio_create_cron(
-            workflow_name=workflow_name,
-            cron_name=cron_name,
-            expression=validated_input.expression,
-            input=validated_input.input,
-            additional_metadata=validated_input.additional_metadata,
-        )
-
-    async def aio_delete(self, cron_trigger: Union[str, CronWorkflows]) -> None:
-        """
-        Asynchronously deletes a workflow cron trigger.
-
-        Args:
-            cron_trigger (Union[str, CronWorkflows]): The cron trigger ID or CronWorkflows instance to delete.
-        """
-        await self._client.rest.aio_delete_cron(
-            cron_trigger.metadata.id
-            if isinstance(cron_trigger, CronWorkflows)
-            else cron_trigger
-        )
+        async with self.client() as client:
+            return await self._wa(client).cron_workflow_list(
+                tenant=self.client_config.tenant_id,
+                offset=offset,
+                limit=limit,
+                workflow_id=workflow_id,
+                additional_metadata=maybe_additional_metadata_to_kv(
+                    additional_metadata
+                ),
+                order_by_field=order_by_field,
+                order_by_direction=order_by_direction,
+            )
 
-    async def aio_list(
+    def list(
         self,
         offset: int | None = None,
         limit: int | None = None,
         workflow_id: str | None = None,
-        additional_metadata: List[str] | None = None,
+        additional_metadata: JSONSerializableMapping | None = None,
         order_by_field: CronWorkflowsOrderByField | None = None,
         order_by_direction: WorkflowRunOrderByDirection | None = None,
     ) -> CronWorkflowsList:
         """
-        Asynchronously retrieves a list of all workflow cron triggers matching the criteria.
+        Synchronously retrieves a list of all workflow cron triggers matching the criteria.
 
         Args:
             offset (int | None): The offset to start the list from.
@@ -245,7 +204,8 @@ class CronClient:
         Returns:
             CronWorkflowsList: A list of cron workflows.
         """
-        return await self._client.rest.aio_list_crons(
+        return self._run_async_from_sync(
+            self.aio_list,
             offset=offset,
             limit=limit,
             workflow_id=workflow_id,
@@ -254,19 +214,29 @@ class CronClient:
             order_by_direction=order_by_direction,
         )
 
-    async def aio_get(self, cron_trigger: Union[str, CronWorkflows]) -> CronWorkflows:
+    async def aio_get(self, cron_id: str) -> CronWorkflows:
         """
         Asynchronously retrieves a specific workflow cron trigger by ID.
 
         Args:
-            cron_trigger (Union[str, CronWorkflows]): The cron trigger ID or CronWorkflows instance to retrieve.
+            cron_id (str): The cron trigger ID or CronWorkflows instance to retrieve.
 
         Returns:
             CronWorkflows: The requested cron workflow instance.
         """
+        async with self.client() as client:
+            return await self._wa(client).workflow_cron_get(
+                tenant=self.client_config.tenant_id, cron_workflow=str(cron_id)
+            )
+
+    def get(self, cron_id: str) -> CronWorkflows:
+        """
+        Synchronously retrieves a specific workflow cron trigger by ID.
 
-        return await self._client.rest.aio_get_cron(
-            cron_trigger.metadata.id
-            if isinstance(cron_trigger, CronWorkflows)
-            else cron_trigger
-        )
+        Args:
+            cron_id (str): The cron trigger ID or CronWorkflows instance to retrieve.
+
+        Returns:
+            CronWorkflows: The requested cron workflow instance.
+        """
+        return self._run_async_from_sync(self.aio_get, cron_id)

hatchet_sdk/features/logs.py

@@ -0,0 +1,16 @@
+from hatchet_sdk.clients.rest.api.log_api import LogApi
+from hatchet_sdk.clients.rest.api_client import ApiClient
+from hatchet_sdk.clients.rest.models.v1_log_line_list import V1LogLineList
+from hatchet_sdk.clients.v1.api_client import BaseRestClient
+
+
+class LogsClient(BaseRestClient):
+    def _la(self, client: ApiClient) -> LogApi:
+        return LogApi(client)
+
+    async def aio_list(self, task_run_id: str) -> V1LogLineList:
+        async with self.client() as client:
+            return await self._la(client).v1_log_line_list(task=task_run_id)
+
+    def list(self, task_run_id: str) -> V1LogLineList:
+        return self._run_async_from_sync(self.aio_list, task_run_id)

hatchet_sdk/features/metrics.py

@@ -0,0 +1,75 @@
+from hatchet_sdk.clients.rest.api.tenant_api import TenantApi
+from hatchet_sdk.clients.rest.api.workflow_api import WorkflowApi
+from hatchet_sdk.clients.rest.api_client import ApiClient
+from hatchet_sdk.clients.rest.models.tenant_queue_metrics import TenantQueueMetrics
+from hatchet_sdk.clients.rest.models.tenant_step_run_queue_metrics import (
+    TenantStepRunQueueMetrics,
+)
+from hatchet_sdk.clients.rest.models.workflow_metrics import WorkflowMetrics
+from hatchet_sdk.clients.rest.models.workflow_run_status import WorkflowRunStatus
+from hatchet_sdk.clients.v1.api_client import (
+    BaseRestClient,
+    maybe_additional_metadata_to_kv,
+)
+from hatchet_sdk.utils.typing import JSONSerializableMapping
+
+
+class MetricsClient(BaseRestClient):
+    def _wa(self, client: ApiClient) -> WorkflowApi:
+        return WorkflowApi(client)
+
+    def _ta(self, client: ApiClient) -> TenantApi:
+        return TenantApi(client)
+
+    async def aio_get_workflow_metrics(
+        self,
+        workflow_id: str,
+        status: WorkflowRunStatus | None = None,
+        group_key: str | None = None,
+    ) -> WorkflowMetrics:
+        async with self.client() as client:
+            return await self._wa(client).workflow_get_metrics(
+                workflow=workflow_id, status=status, group_key=group_key
+            )
+
+    def get_workflow_metrics(
+        self,
+        workflow_id: str,
+        status: WorkflowRunStatus | None = None,
+        group_key: str | None = None,
+    ) -> WorkflowMetrics:
+        return self._run_async_from_sync(
+            self.aio_get_workflow_metrics, workflow_id, status, group_key
+        )
+
+    async def aio_get_queue_metrics(
+        self,
+        workflow_ids: list[str] | None = None,
+        additional_metadata: JSONSerializableMapping | None = None,
+    ) -> TenantQueueMetrics:
+        async with self.client() as client:
+            return await self._wa(client).tenant_get_queue_metrics(
+                tenant=self.client_config.tenant_id,
+                workflows=workflow_ids,
+                additional_metadata=maybe_additional_metadata_to_kv(
+                    additional_metadata
+                ),
+            )
+
+    def get_queue_metrics(
+        self,
+        workflow_ids: list[str] | None = None,
+        additional_metadata: JSONSerializableMapping | None = None,
+    ) -> TenantQueueMetrics:
+        return self._run_async_from_sync(
+            self.aio_get_queue_metrics, workflow_ids, additional_metadata
+        )
+
+    async def aio_get_task_metrics(self) -> TenantStepRunQueueMetrics:
+        async with self.client() as client:
+            return await self._ta(client).tenant_get_step_run_queue_metrics(
+                tenant=self.client_config.tenant_id
+            )
+
+    def get_task_metrics(self) -> TenantStepRunQueueMetrics:
+        return self._run_async_from_sync(self.aio_get_task_metrics)

hatchet_sdk/features/rate_limits.py

@@ -0,0 +1,45 @@
+import asyncio
+
+from hatchet_sdk.clients.rest.tenacity_utils import tenacity_retry
+from hatchet_sdk.clients.v1.api_client import BaseRestClient
+from hatchet_sdk.connection import new_conn
+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.workflows_pb2_grpc import WorkflowServiceStub
+from hatchet_sdk.metadata import get_metadata
+from hatchet_sdk.rate_limit import RateLimitDuration
+from hatchet_sdk.utils.proto_enums import convert_python_enum_to_proto
+
+
+class RateLimitsClient(BaseRestClient):
+    @tenacity_retry
+    def put(
+        self,
+        key: str,
+        limit: int,
+        duration: RateLimitDuration = RateLimitDuration.SECOND,
+    ) -> None:
+        duration_proto = convert_python_enum_to_proto(
+            duration, workflow_protos.RateLimitDuration
+        )
+
+        conn = new_conn(self.client_config, False)
+        client = WorkflowServiceStub(conn)  # type: ignore[no-untyped-call]
+
+        client.PutRateLimit(
+            v0_workflow_protos.PutRateLimitRequest(
+                key=key,
+                limit=limit,
+                duration=duration_proto,  # type: ignore[arg-type]
+            ),
+            metadata=get_metadata(self.client_config.token),
+        )
+
+    @tenacity_retry
+    async def aio_put(
+        self,
+        key: str,
+        limit: int,
+        duration: RateLimitDuration = RateLimitDuration.SECOND,
+    ) -> None:
+        await asyncio.to_thread(self.put, key, limit, duration)

hatchet_sdk/features/runs.py

@@ -0,0 +1,221 @@
+from datetime import datetime, timedelta
+from typing import Literal, overload
+
+from pydantic import BaseModel, model_validator
+
+from hatchet_sdk.clients.rest.api.task_api import TaskApi
+from hatchet_sdk.clients.rest.api.workflow_runs_api import WorkflowRunsApi
+from hatchet_sdk.clients.rest.api_client import ApiClient
+from hatchet_sdk.clients.rest.models.v1_cancel_task_request import V1CancelTaskRequest
+from hatchet_sdk.clients.rest.models.v1_replay_task_request import V1ReplayTaskRequest
+from hatchet_sdk.clients.rest.models.v1_task_filter import V1TaskFilter
+from hatchet_sdk.clients.rest.models.v1_task_status import V1TaskStatus
+from hatchet_sdk.clients.rest.models.v1_task_summary_list import V1TaskSummaryList
+from hatchet_sdk.clients.rest.models.v1_trigger_workflow_run_request import (
+    V1TriggerWorkflowRunRequest,
+)
+from hatchet_sdk.clients.rest.models.v1_workflow_run_details import V1WorkflowRunDetails
+from hatchet_sdk.clients.v1.api_client import (
+    BaseRestClient,
+    maybe_additional_metadata_to_kv,
+)
+from hatchet_sdk.utils.typing import JSONSerializableMapping
+
+
+class RunFilter(BaseModel):
+    since: datetime
+    until: datetime | None = None
+    statuses: list[V1TaskStatus] | None = None
+    workflow_ids: list[str] | None = None
+    additional_metadata: dict[str, str] | None = None
+
+
+class BulkCancelReplayOpts(BaseModel):
+    ids: list[str] | None = None
+    filters: RunFilter | None = None
+
+    @model_validator(mode="after")
+    def validate_model(self) -> "BulkCancelReplayOpts":
+        if not self.ids and not self.filters:
+            raise ValueError("ids or filters must be set")
+
+        if self.ids and self.filters:
+            raise ValueError("ids and filters cannot both be set")
+
+        return self
+
+    @property
+    def v1_task_filter(self) -> V1TaskFilter | None:
+        if not self.filters:
+            return None
+
+        return V1TaskFilter(
+            since=self.filters.since,
+            until=self.filters.until,
+            statuses=self.filters.statuses,
+            workflowIds=self.filters.workflow_ids,
+            additionalMetadata=maybe_additional_metadata_to_kv(
+                self.filters.additional_metadata
+            ),
+        )
+
+    @overload
+    def to_request(self, request_type: Literal["replay"]) -> V1ReplayTaskRequest: ...
+
+    @overload
+    def to_request(self, request_type: Literal["cancel"]) -> V1CancelTaskRequest: ...
+
+    def to_request(
+        self, request_type: Literal["replay", "cancel"]
+    ) -> V1ReplayTaskRequest | V1CancelTaskRequest:
+        if request_type == "replay":
+            return V1ReplayTaskRequest(
+                externalIds=self.ids,
+                filter=self.v1_task_filter,
+            )
+
+        if request_type == "cancel":
+            return V1CancelTaskRequest(
+                externalIds=self.ids,
+                filter=self.v1_task_filter,
+            )
+
+
+class RunsClient(BaseRestClient):
+    def _wra(self, client: ApiClient) -> WorkflowRunsApi:
+        return WorkflowRunsApi(client)
+
+    def _ta(self, client: ApiClient) -> TaskApi:
+        return TaskApi(client)
+
+    async def aio_get(self, workflow_run_id: str) -> V1WorkflowRunDetails:
+        async with self.client() as client:
+            return await self._wra(client).v1_workflow_run_get(str(workflow_run_id))
+
+    def get(self, workflow_run_id: str) -> V1WorkflowRunDetails:
+        return self._run_async_from_sync(self.aio_get, workflow_run_id)
+
+    async def aio_list(
+        self,
+        since: datetime = datetime.now() - timedelta(hours=1),
+        only_tasks: bool = False,
+        offset: int | None = None,
+        limit: int | None = None,
+        statuses: list[V1TaskStatus] | None = None,
+        until: datetime | None = None,
+        additional_metadata: dict[str, str] | None = None,
+        workflow_ids: list[str] | None = None,
+        worker_id: str | None = None,
+        parent_task_external_id: str | None = None,
+    ) -> V1TaskSummaryList:
+        async with self.client() as client:
+            return await self._wra(client).v1_workflow_run_list(
+                tenant=self.client_config.tenant_id,
+                since=since,
+                only_tasks=only_tasks,
+                offset=offset,
+                limit=limit,
+                statuses=statuses,
+                until=until,
+                additional_metadata=maybe_additional_metadata_to_kv(
+                    additional_metadata
+                ),
+                workflow_ids=workflow_ids,
+                worker_id=worker_id,
+                parent_task_external_id=parent_task_external_id,
+            )
+
+    def list(
+        self,
+        since: datetime = datetime.now() - timedelta(hours=1),
+        only_tasks: bool = False,
+        offset: int | None = None,
+        limit: int | None = None,
+        statuses: list[V1TaskStatus] | None = None,
+        until: datetime | None = None,
+        additional_metadata: dict[str, str] | None = None,
+        workflow_ids: list[str] | None = None,
+        worker_id: str | None = None,
+        parent_task_external_id: str | None = None,
+    ) -> V1TaskSummaryList:
+        return self._run_async_from_sync(
+            self.aio_list,
+            since=since,
+            only_tasks=only_tasks,
+            offset=offset,
+            limit=limit,
+            statuses=statuses,
+            until=until,
+            additional_metadata=additional_metadata,
+            workflow_ids=workflow_ids,
+            worker_id=worker_id,
+            parent_task_external_id=parent_task_external_id,
+        )
+
+    async def aio_create(
+        self,
+        workflow_name: str,
+        input: JSONSerializableMapping,
+        additional_metadata: JSONSerializableMapping = {},
+    ) -> V1WorkflowRunDetails:
+        async with self.client() as client:
+            return await self._wra(client).v1_workflow_run_create(
+                tenant=self.client_config.tenant_id,
+                v1_trigger_workflow_run_request=V1TriggerWorkflowRunRequest(
+                    workflowName=workflow_name,
+                    input=dict(input),
+                    additionalMetadata=dict(additional_metadata),
+                ),
+            )
+
+    def create(
+        self,
+        workflow_name: str,
+        input: JSONSerializableMapping,
+        additional_metadata: JSONSerializableMapping = {},
+    ) -> V1WorkflowRunDetails:
+        return self._run_async_from_sync(
+            self.aio_create, workflow_name, input, additional_metadata
+        )
+
+    async def aio_replay(self, run_id: str) -> None:
+        await self.aio_bulk_replay(opts=BulkCancelReplayOpts(ids=[run_id]))
+
+    def replay(self, run_id: str) -> None:
+        return self._run_async_from_sync(self.aio_replay, run_id)
+
+    async def aio_bulk_replay(self, opts: BulkCancelReplayOpts) -> None:
+        async with self.client() as client:
+            await self._ta(client).v1_task_replay(
+                tenant=self.client_config.tenant_id,
+                v1_replay_task_request=opts.to_request("replay"),
+            )
+
+    def bulk_replay(self, opts: BulkCancelReplayOpts) -> None:
+        return self._run_async_from_sync(self.aio_bulk_replay, opts)
+
+    async def aio_cancel(self, run_id: str) -> None:
+        await self.aio_bulk_cancel(opts=BulkCancelReplayOpts(ids=[run_id]))
+
+    def cancel(self, run_id: str) -> None:
+        return self._run_async_from_sync(self.aio_cancel, run_id)
+
+    async def aio_bulk_cancel(self, opts: BulkCancelReplayOpts) -> None:
+        async with self.client() as client:
+            await self._ta(client).v1_task_cancel(
+                tenant=self.client_config.tenant_id,
+                v1_cancel_task_request=opts.to_request("cancel"),
+            )
+
+    def bulk_cancel(self, opts: BulkCancelReplayOpts) -> None:
+        return self._run_async_from_sync(self.aio_bulk_cancel, opts)
+
+    async def aio_get_result(self, run_id: str) -> JSONSerializableMapping:
+        details = await self.aio_get(run_id)
+
+        return details.run.output
+
+    def get_result(self, run_id: str) -> JSONSerializableMapping:
+        details = self.get(run_id)
+
+        return details.run.output