hatchet-sdk 1.16.4__py3-none-any.whl → 1.17.0__py3-none-any.whl

hatchet_sdk/hatchet.py

@@ -3,7 +3,7 @@ import logging
 from collections.abc import Callable
 from datetime import timedelta
 from functools import cached_property
-from typing import Any, cast, overload
+from typing import Any, Concatenate, ParamSpec, cast, overload
 
 from hatchet_sdk import Context, DurableContext
 from hatchet_sdk.client import Client
@@ -40,6 +40,8 @@ from hatchet_sdk.utils.timedelta_to_expression import Duration
 from hatchet_sdk.utils.typing import CoroutineLike
 from hatchet_sdk.worker.worker import LifespanFn, Worker
 
+P = ParamSpec("P")
+
 
 class Hatchet:
     """
@@ -346,7 +348,7 @@ class Hatchet:
         backoff_max_seconds: int | None = None,
         default_filters: list[DefaultFilter] | None = None,
     ) -> Callable[
-        [Callable[[EmptyModel, Context], R | CoroutineLike[R]]],
+        [Callable[Concatenate[EmptyModel, Context, P], R | CoroutineLike[R]]],
         Standalone[EmptyModel, R],
     ]: ...
 
@@ -372,7 +374,7 @@ class Hatchet:
         backoff_max_seconds: int | None = None,
         default_filters: list[DefaultFilter] | None = None,
     ) -> Callable[
-        [Callable[[TWorkflowInput, Context], R | CoroutineLike[R]]],
+        [Callable[Concatenate[TWorkflowInput, Context, P], R | CoroutineLike[R]]],
         Standalone[TWorkflowInput, R],
     ]: ...
 
@@ -398,11 +400,11 @@ class Hatchet:
         default_filters: list[DefaultFilter] | None = None,
     ) -> (
         Callable[
-            [Callable[[EmptyModel, Context], R | CoroutineLike[R]]],
+            [Callable[Concatenate[EmptyModel, Context, P], R | CoroutineLike[R]]],
             Standalone[EmptyModel, R],
         ]
         | Callable[
-            [Callable[[TWorkflowInput, Context], R | CoroutineLike[R]]],
+            [Callable[Concatenate[TWorkflowInput, Context, P], R | CoroutineLike[R]]],
             Standalone[TWorkflowInput, R],
         ]
     ):
@@ -447,7 +449,9 @@ class Hatchet:
         """
 
         def inner(
-            func: Callable[[TWorkflowInput, Context], R | CoroutineLike[R]],
+            func: Callable[
+                Concatenate[TWorkflowInput, Context, P], R | CoroutineLike[R]
+            ],
         ) -> Standalone[TWorkflowInput, R]:
             inferred_name = name or func.__name__
 
@@ -518,7 +522,7 @@ class Hatchet:
         backoff_max_seconds: int | None = None,
         default_filters: list[DefaultFilter] | None = None,
     ) -> Callable[
-        [Callable[[EmptyModel, DurableContext], R | CoroutineLike[R]]],
+        [Callable[Concatenate[EmptyModel, DurableContext, P], R | CoroutineLike[R]]],
         Standalone[EmptyModel, R],
     ]: ...
 
@@ -544,7 +548,11 @@ class Hatchet:
         backoff_max_seconds: int | None = None,
         default_filters: list[DefaultFilter] | None = None,
     ) -> Callable[
-        [Callable[[TWorkflowInput, DurableContext], R | CoroutineLike[R]]],
+        [
+            Callable[
+                Concatenate[TWorkflowInput, DurableContext, P], R | CoroutineLike[R]
+            ]
+        ],
         Standalone[TWorkflowInput, R],
     ]: ...
 
@@ -570,11 +578,19 @@ class Hatchet:
         default_filters: list[DefaultFilter] | None = None,
     ) -> (
         Callable[
-            [Callable[[EmptyModel, DurableContext], R | CoroutineLike[R]]],
+            [
+                Callable[
+                    Concatenate[EmptyModel, DurableContext, P], R | CoroutineLike[R]
+                ]
+            ],
             Standalone[EmptyModel, R],
         ]
         | Callable[
-            [Callable[[TWorkflowInput, DurableContext], R | CoroutineLike[R]]],
+            [
+                Callable[
+                    Concatenate[TWorkflowInput, DurableContext, P], R | CoroutineLike[R]
+                ]
+            ],
             Standalone[TWorkflowInput, R],
         ]
     ):
@@ -619,7 +635,9 @@ class Hatchet:
         """
 
         def inner(
-            func: Callable[[TWorkflowInput, DurableContext], R | CoroutineLike[R]],
+            func: Callable[
+                Concatenate[TWorkflowInput, DurableContext, P], R | CoroutineLike[R]
+            ],
         ) -> Standalone[TWorkflowInput, R]:
             inferred_name = name or func.__name__
             workflow = Workflow[TWorkflowInput](

hatchet_sdk/rate_limit.py

@@ -1,20 +1,10 @@
 from enum import Enum
 
-from celpy import CELEvalError, Environment  # type: ignore
 from pydantic import BaseModel, model_validator
 
 from hatchet_sdk.contracts.v1.workflows_pb2 import CreateTaskRateLimit
 
 
-def validate_cel_expression(expr: str) -> bool:
-    env = Environment()
-    try:
-        env.compile(expr)
-        return True
-    except CELEvalError:
-        return False
-
-
 class RateLimitDuration(str, Enum):
     SECOND = "SECOND"
     MINUTE = "MINUTE"
@@ -72,17 +62,7 @@ class RateLimit(BaseModel):
         if self.dynamic_key and self.static_key:
             raise ValueError("Cannot have both static key and dynamic key set")
 
-        if self.dynamic_key and not validate_cel_expression(self.dynamic_key):
-            raise ValueError(f"Invalid CEL expression: {self.dynamic_key}")
-
-        if not isinstance(self.units, int) and not validate_cel_expression(self.units):
-            raise ValueError(f"Invalid CEL expression: {self.units}")
-
-        if (
-            self.limit
-            and not isinstance(self.limit, int)
-            and not validate_cel_expression(self.limit)
-        ):
+        if self.limit and not isinstance(self.limit, int):
             raise ValueError(f"Invalid CEL expression: {self.limit}")
 
         if self.dynamic_key and not self.limit:

hatchet_sdk/runnables/task.py

@@ -1,5 +1,21 @@
+import asyncio
 from collections.abc import Callable
-from typing import TYPE_CHECKING, Any, Generic, cast, get_type_hints
+from inspect import Parameter, iscoroutinefunction, signature
+from typing import (
+    TYPE_CHECKING,
+    Annotated,
+    Any,
+    Concatenate,
+    Generic,
+    ParamSpec,
+    TypeVar,
+    cast,
+    get_args,
+    get_origin,
+    get_type_hints,
+)
+
+from pydantic import BaseModel, ConfigDict
 
 from hatchet_sdk.conditions import (
     Action,
@@ -18,6 +34,7 @@ from hatchet_sdk.contracts.v1.workflows_pb2 import (
     CreateTaskRateLimit,
     DesiredWorkerLabels,
 )
+from hatchet_sdk.exceptions import InvalidDependencyError
 from hatchet_sdk.runnables.types import (
     ConcurrencyExpression,
     EmptyModel,
@@ -25,7 +42,6 @@ from hatchet_sdk.runnables.types import (
     StepType,
     TWorkflowInput,
     is_async_fn,
-    is_durable_sync_fn,
     is_sync_fn,
 )
 from hatchet_sdk.utils.timedelta_to_expression import Duration, timedelta_to_expr
@@ -41,16 +57,45 @@ from hatchet_sdk.worker.runner.utils.capture_logs import AsyncLogSender
 if TYPE_CHECKING:
     from hatchet_sdk.runnables.workflow import Workflow
 
+T = TypeVar("T")
+P = ParamSpec("P")
+
+
+class Depends(Generic[T, TWorkflowInput]):
+    def __init__(
+        self, fn: Callable[[TWorkflowInput, Context], T | CoroutineLike[T]]
+    ) -> None:
+        sig = signature(fn)
+        params = list(sig.parameters.values())
+
+        if len(params) != 2:
+            raise InvalidDependencyError(
+                f"Dependency function {fn.__name__} must have exactly two parameters: input and ctx."
+            )
+
+        self.fn = fn
+
+
+class DependencyToInject(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    name: str
+    value: Any
+
 
 class Task(Generic[TWorkflowInput, R]):
     def __init__(
         self,
         _fn: (
-            Callable[[TWorkflowInput, Context], R | CoroutineLike[R]]
-            | Callable[[TWorkflowInput, Context], AwaitableLike[R]]
+            Callable[Concatenate[TWorkflowInput, Context, P], R | CoroutineLike[R]]
+            | Callable[Concatenate[TWorkflowInput, Context, P], AwaitableLike[R]]
             | (
-                Callable[[TWorkflowInput, DurableContext], R | CoroutineLike[R]]
-                | Callable[[TWorkflowInput, DurableContext], AwaitableLike[R]]
+                Callable[
+                    Concatenate[TWorkflowInput, DurableContext, P], R | CoroutineLike[R]
+                ]
+                | Callable[
+                    Concatenate[TWorkflowInput, DurableContext, P], AwaitableLike[R]
+                ]
             )
         ),
         is_durable: bool,
@@ -100,33 +145,74 @@ class Task(Generic[TWorkflowInput, R]):
             step_output=return_type if is_basemodel_subclass(return_type) else None,
         )
 
-    def call(self, ctx: Context | DurableContext) -> R:
+    async def _parse_parameter(
+        self,
+        name: str,
+        param: Parameter,
+        input: TWorkflowInput,
+        ctx: Context | DurableContext,
+    ) -> DependencyToInject | None:
+        annotation = param.annotation
+
+        if get_origin(annotation) is Annotated:
+            args = get_args(annotation)
+
+            if len(args) < 2:
+                return None
+
+            metadata = args[1:]
+
+            for item in metadata:
+                if isinstance(item, Depends):
+                    if iscoroutinefunction(item.fn):
+                        return DependencyToInject(
+                            name=name, value=await item.fn(input, ctx)
+                        )
+
+                    return DependencyToInject(
+                        name=name, value=await asyncio.to_thread(item.fn, input, ctx)
+                    )
+
+        return None
+
+    async def _unpack_dependencies(
+        self, ctx: Context | DurableContext
+    ) -> dict[str, Any]:
+        sig = signature(self.fn)
+        input = self.workflow._get_workflow_input(ctx)
+        return {
+            parsed.name: parsed.value
+            for n, p in sig.parameters.items()
+            if (parsed := await self._parse_parameter(n, p, input, ctx)) is not None
+        }
+
+    def call(
+        self, ctx: Context | DurableContext, dependencies: dict[str, Any] | None = None
+    ) -> R:
         if self.is_async_function:
             raise TypeError(f"{self.name} is not a sync function. Use `acall` instead.")
 
         workflow_input = self.workflow._get_workflow_input(ctx)
+        dependencies = dependencies or {}
 
-        if self.is_durable:
-            fn = cast(Callable[[TWorkflowInput, DurableContext], R], self.fn)
-            if is_durable_sync_fn(fn):
-                return fn(workflow_input, cast(DurableContext, ctx))
-        else:
-            fn = cast(Callable[[TWorkflowInput, Context], R], self.fn)
-            if is_sync_fn(fn):
-                return fn(workflow_input, ctx)
+        if is_sync_fn(self.fn):  # type: ignore
+            return self.fn(workflow_input, cast(Context, ctx), **dependencies)  # type: ignore
 
         raise TypeError(f"{self.name} is not a sync function. Use `acall` instead.")
 
-    async def aio_call(self, ctx: Context | DurableContext) -> R:
+    async def aio_call(
+        self, ctx: Context | DurableContext, dependencies: dict[str, Any] | None = None
+    ) -> R:
         if not self.is_async_function:
             raise TypeError(
                 f"{self.name} is not an async function. Use `call` instead."
             )
 
         workflow_input = self.workflow._get_workflow_input(ctx)
+        dependencies = dependencies or {}
 
         if is_async_fn(self.fn):  # type: ignore
-            return await self.fn(workflow_input, cast(Context, ctx))  # type: ignore
+            return await self.fn(workflow_input, cast(Context, ctx), **dependencies)  # type: ignore
 
         raise TypeError(f"{self.name} is not an async function. Use `call` instead.")
 
@@ -255,6 +341,7 @@ class Task(Generic[TWorkflowInput, R]):
         parent_outputs: dict[str, JSONSerializableMapping] | None = None,
         retry_count: int = 0,
         lifespan: Any = None,
+        dependencies: dict[str, Any] | None = None,
     ) -> R:
         """
         Mimic the execution of a task. This method is intended to be used to unit test
@@ -266,6 +353,7 @@ class Task(Generic[TWorkflowInput, R]):
         :param parent_outputs: Outputs from parent tasks, if any. This is useful for mimicking DAG functionality. For instance, if you have a task `step_2` that has a `parent` which is `step_1`, you can pass `parent_outputs={"step_1": {"result": "Hello, world!"}}` to `step_2.mock_run()` to be able to access `ctx.task_output(step_1)` in `step_2`.
         :param retry_count: The number of times the task has been retried.
         :param lifespan: The lifespan to be used in the task, which is useful if one was set on the worker. This will allow you to access `ctx.lifespan` inside of your task.
+        :param dependencies: Dependencies to be injected into the task. This is useful for tasks that have dependencies defined using `Depends`. **IMPORTANT**: You must pass the dependencies _directly_, **not** the `Depends` objects themselves. For example, if you have a task that has a dependency `config: Annotated[str, Depends(get_config)]`, you should pass `dependencies={"config": "config_value"}` to `aio_mock_run`.
 
         :return: The output of the task.
         :raises TypeError: If the task is an async function and `mock_run` is called, or if the task is a sync function and `aio_mock_run` is called.
@@ -280,7 +368,7 @@ class Task(Generic[TWorkflowInput, R]):
             input, additional_metadata, parent_outputs, retry_count, lifespan
         )
 
-        return self.call(ctx)
+        return self.call(ctx, dependencies)
 
     async def aio_mock_run(
         self,
@@ -289,6 +377,7 @@ class Task(Generic[TWorkflowInput, R]):
         parent_outputs: dict[str, JSONSerializableMapping] | None = None,
         retry_count: int = 0,
         lifespan: Any = None,
+        dependencies: dict[str, Any] | None = None,
     ) -> R:
         """
         Mimic the execution of a task. This method is intended to be used to unit test
@@ -300,6 +389,7 @@ class Task(Generic[TWorkflowInput, R]):
         :param parent_outputs: Outputs from parent tasks, if any. This is useful for mimicking DAG functionality. For instance, if you have a task `step_2` that has a `parent` which is `step_1`, you can pass `parent_outputs={"step_1": {"result": "Hello, world!"}}` to `step_2.mock_run()` to be able to access `ctx.task_output(step_1)` in `step_2`.
         :param retry_count: The number of times the task has been retried.
         :param lifespan: The lifespan to be used in the task, which is useful if one was set on the worker. This will allow you to access `ctx.lifespan` inside of your task.
+        :param dependencies: Dependencies to be injected into the task. This is useful for tasks that have dependencies defined using `Depends`. **IMPORTANT**: You must pass the dependencies _directly_, **not** the `Depends` objects themselves. For example, if you have a task that has a dependency `config: Annotated[str, Depends(get_config)]`, you should pass `dependencies={"config": "config_value"}` to `aio_mock_run`.
 
         :return: The output of the task.
         :raises TypeError: If the task is an async function and `mock_run` is called, or if the task is a sync function and `aio_mock_run` is called.
@@ -318,4 +408,4 @@ class Task(Generic[TWorkflowInput, R]):
             lifespan,
         )
 
-        return await self.aio_call(ctx)
+        return await self.aio_call(ctx, dependencies)

hatchet_sdk/runnables/workflow.py

@@ -5,8 +5,10 @@ from functools import cached_property
 from typing import (
     TYPE_CHECKING,
     Any,
+    Concatenate,
     Generic,
     Literal,
+    ParamSpec,
     TypeVar,
     cast,
     get_type_hints,
@@ -60,6 +62,7 @@ if TYPE_CHECKING:
 
 
 T = TypeVar("T")
+P = ParamSpec("P")
 
 
 def fall_back_to_default(value: T, param_default: T, fallback_value: T | None) -> T:
@@ -800,7 +803,7 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         skip_if: list[Condition | OrGroup] | None = None,
         cancel_if: list[Condition | OrGroup] | None = None,
     ) -> Callable[
-        [Callable[[TWorkflowInput, Context], R | CoroutineLike[R]]],
+        [Callable[Concatenate[TWorkflowInput, Context, P], R | CoroutineLike[R]]],
         Task[TWorkflowInput, R],
     ]:
         """
@@ -845,7 +848,9 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         )
 
         def inner(
-            func: Callable[[TWorkflowInput, Context], R | CoroutineLike[R]],
+            func: Callable[
+                Concatenate[TWorkflowInput, Context, P], R | CoroutineLike[R]
+            ],
         ) -> Task[TWorkflowInput, R]:
             task = Task(
                 _fn=func,
@@ -892,7 +897,11 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         skip_if: list[Condition | OrGroup] | None = None,
         cancel_if: list[Condition | OrGroup] | None = None,
     ) -> Callable[
-        [Callable[[TWorkflowInput, DurableContext], R | CoroutineLike[R]]],
+        [
+            Callable[
+                Concatenate[TWorkflowInput, DurableContext, P], R | CoroutineLike[R]
+            ]
+        ],
         Task[TWorkflowInput, R],
     ]:
         """
@@ -941,7 +950,9 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         )
 
         def inner(
-            func: Callable[[TWorkflowInput, DurableContext], R | CoroutineLike[R]],
+            func: Callable[
+                Concatenate[TWorkflowInput, DurableContext, P], R | CoroutineLike[R]
+            ],
         ) -> Task[TWorkflowInput, R]:
             task = Task(
                 _fn=func,
@@ -983,7 +994,7 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         backoff_max_seconds: int | None = None,
         concurrency: list[ConcurrencyExpression] | None = None,
     ) -> Callable[
-        [Callable[[TWorkflowInput, Context], R | CoroutineLike[R]]],
+        [Callable[Concatenate[TWorkflowInput, Context, P], R | CoroutineLike[R]]],
         Task[TWorkflowInput, R],
     ]:
         """
@@ -1009,7 +1020,9 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         """
 
         def inner(
-            func: Callable[[TWorkflowInput, Context], R | CoroutineLike[R]],
+            func: Callable[
+                Concatenate[TWorkflowInput, Context, P], R | CoroutineLike[R]
+            ],
         ) -> Task[TWorkflowInput, R]:
             task = Task(
                 is_durable=False,
@@ -1051,7 +1064,7 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         backoff_max_seconds: int | None = None,
         concurrency: list[ConcurrencyExpression] | None = None,
     ) -> Callable[
-        [Callable[[TWorkflowInput, Context], R | CoroutineLike[R]]],
+        [Callable[Concatenate[TWorkflowInput, Context, P], R | CoroutineLike[R]]],
         Task[TWorkflowInput, R],
     ]:
         """
@@ -1077,7 +1090,9 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         """
 
         def inner(
-            func: Callable[[TWorkflowInput, Context], R | CoroutineLike[R]],
+            func: Callable[
+                Concatenate[TWorkflowInput, Context, P], R | CoroutineLike[R]
+            ],
         ) -> Task[TWorkflowInput, R]:
             task = Task(
                 is_durable=False,

hatchet_sdk/utils/typing.py

@@ -1,5 +1,6 @@
 import sys
 from collections.abc import Awaitable, Coroutine, Generator
+from enum import Enum
 from typing import Any, Literal, TypeAlias, TypeGuard, TypeVar
 
 from pydantic import BaseModel
@@ -31,3 +32,29 @@ else:
 
 STOP_LOOP_TYPE = Literal["STOP_LOOP"]
 STOP_LOOP: STOP_LOOP_TYPE = "STOP_LOOP"  # Sentinel object to stop the loop
+
+
+class LogLevel(str, Enum):
+    DEBUG = "DEBUG"
+    INFO = "INFO"
+    WARN = "WARN"
+    ERROR = "ERROR"
+
+    @classmethod
+    def from_levelname(cls, levelname: str) -> "LogLevel":
+        levelname = levelname.upper()
+
+        if levelname == "DEBUG":
+            return cls.DEBUG
+
+        if levelname == "INFO":
+            return cls.INFO
+
+        if levelname in ["WARNING", "WARN"]:
+            return cls.WARN
+
+        if levelname == "ERROR":
+            return cls.ERROR
+
+        # fall back to INFO
+        return cls.INFO

hatchet_sdk/worker/runner/runner.py

@@ -166,22 +166,22 @@ class Runner:
             except Exception as e:
                 should_not_retry = isinstance(e, NonRetryableException)
 
-                exc = TaskRunError.from_exception(e)
+                exc = TaskRunError.from_exception(e, action.step_run_id)
 
                 # This except is coming from the application itself, so we want to send that to the Hatchet instance
                 self.event_queue.put(
                     ActionEvent(
                         action=action,
                         type=STEP_EVENT_TYPE_FAILED,
-                        payload=exc.serialize(),
+                        payload=exc.serialize(include_metadata=True),
                         should_not_retry=should_not_retry,
                     )
                 )
 
-                log_with_level = logger.info if should_not_retry else logger.error
+                log_with_level = logger.info if should_not_retry else logger.exception
 
                 log_with_level(
-                    f"failed step run: {action.action_id}/{action.step_run_id}\n{exc.serialize()}"
+                    f"failed step run: {action.action_id}/{action.step_run_id}\n{exc.serialize(include_metadata=False)}"
                 )
 
                 return
@@ -198,18 +198,18 @@ class Runner:
                     )
                 )
             except IllegalTaskOutputError as e:
-                exc = TaskRunError.from_exception(e)
+                exc = TaskRunError.from_exception(e, action.step_run_id)
                 self.event_queue.put(
                     ActionEvent(
                         action=action,
                         type=STEP_EVENT_TYPE_FAILED,
-                        payload=exc.serialize(),
+                        payload=exc.serialize(include_metadata=True),
                         should_not_retry=False,
                     )
                 )
 
-                logger.error(
-                    f"failed step run: {action.action_id}/{action.step_run_id}\n{exc.serialize()}"
+                logger.exception(
+                    f"failed step run: {action.action_id}/{action.step_run_id}\n{exc.serialize(include_metadata=False)}"
                 )
 
                 return
@@ -230,19 +230,19 @@ class Runner:
             try:
                 output = task.result()
             except Exception as e:
-                exc = TaskRunError.from_exception(e)
+                exc = TaskRunError.from_exception(e, action.step_run_id)
 
                 self.event_queue.put(
                     ActionEvent(
                         action=action,
                         type=GROUP_KEY_EVENT_TYPE_FAILED,
-                        payload=exc.serialize(),
+                        payload=exc.serialize(include_metadata=True),
                         should_not_retry=False,
                     )
                 )
 
-                logger.error(
-                    f"failed step run: {action.action_id}/{action.step_run_id}\n{exc.serialize()}"
+                logger.exception(
+                    f"failed step run: {action.action_id}/{action.step_run_id}\n{exc.serialize(include_metadata=False)}"
                 )
 
                 return
@@ -259,18 +259,18 @@ class Runner:
                     )
                 )
             except IllegalTaskOutputError as e:
-                exc = TaskRunError.from_exception(e)
+                exc = TaskRunError.from_exception(e, action.step_run_id)
                 self.event_queue.put(
                     ActionEvent(
                         action=action,
                         type=STEP_EVENT_TYPE_FAILED,
-                        payload=exc.serialize(),
+                        payload=exc.serialize(include_metadata=True),
                         should_not_retry=False,
                     )
                 )
 
-                logger.error(
-                    f"failed step run: {action.action_id}/{action.step_run_id}\n{exc.serialize()}"
+                logger.exception(
+                    f"failed step run: {action.action_id}/{action.step_run_id}\n{exc.serialize(include_metadata=False)}"
                 )
 
                 return
@@ -280,12 +280,16 @@ class Runner:
         return inner_callback
 
     def thread_action_func(
-        self, ctx: Context, task: Task[TWorkflowInput, R], action: Action
+        self,
+        ctx: Context,
+        task: Task[TWorkflowInput, R],
+        action: Action,
+        dependencies: dict[str, Any],
     ) -> R:
         if action.step_run_id or action.get_group_key_run_id:
             self.threads[action.key] = current_thread()
 
-        return task.call(ctx)
+        return task.call(ctx, dependencies)
 
     # We wrap all actions in an async func
     async def async_wrapped_action_func(
@@ -300,9 +304,12 @@ class Runner:
         ctx_action_key.set(action.key)
         ctx_additional_metadata.set(action.additional_metadata)
 
+        dependencies = await task._unpack_dependencies(ctx)
+
         try:
             if task.is_async_function:
-                return await task.aio_call(ctx)
+                return await task.aio_call(ctx, dependencies)
+
             pfunc = functools.partial(
                 # we must copy the context vars to the new thread, as only asyncio natively supports
                 # contextvars
@@ -343,6 +350,7 @@ class Runner:
                 ctx,
                 task,
                 action,
+                dependencies,
             )
 
             loop = asyncio.get_event_loop()