python-ddd-framework 0.4.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

python_ddd_framework/application_services/invocation.py

@@ -1,500 +1,14 @@
-"""Application-local admission、调用身份、REQUEST 入场与现有 ACTION/UoW owner。"""
+"""应用服务 Contract 的 REQUEST 代理入口；准入与 scope 清理由 Invocation 拥有。"""
 
-from __future__ import annotations
-
-import asyncio
-import logging
-from collections.abc import AsyncIterator, Awaitable, Callable, Iterator
-from contextlib import asynccontextmanager, contextmanager
-from contextvars import ContextVar, Token
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, cast
-from uuid import UUID, uuid4
+from collections.abc import Awaitable, Callable
+from typing import cast
 
 from dishka import AsyncContainer, Scope
 
 from ..authorization import CurrentUser
-from ..invocation import ApplicationInvocationContext
-from ..invocation.contracts import _is_safe_correlation_id
-from ..lifecycle import ApplicationState, RuntimeParticipant, ShutdownReason
-from ..unit_of_work import UnitOfWork, UnitOfWorkManager
-from ..unit_of_work.options import _DEFAULT_CONNECTION_NAME, UnitOfWorkDeclaration
-from .catalog import (
-    ApplicationServiceCatalog,
-)
-from .errors import (
-    ApplicationInvocationCleanupError,
-    ApplicationInvocationRejectedError,
-    CrossTaskInvocationError,
-    NestedConnectionError,
-)
-
-_LOGGER = logging.getLogger(__name__)
-
-if TYPE_CHECKING:
-    from opentelemetry.trace import Tracer
-
-
-@dataclass(slots=True)
-class _InvocationState:
-    context: ApplicationInvocationContext
-    owner_task: asyncio.Task[object]
-    action_container: AsyncContainer
-
-
-@dataclass(frozen=True, slots=True)
-class _CallerContext:
-    current_user: CurrentUser
-    correlation_id: str
-    owner_task: asyncio.Task[object]
-    transferable: bool = False
-
-
-@dataclass(frozen=True, slots=True)
-class _OuterInvocationLease:
-    owner_task: asyncio.Task[object]
-    allows_invocation: bool
-
-
-@dataclass(frozen=True, slots=True)
-class _CallScope:
-    container: AsyncContainer
-    owner_task: asyncio.Task[object]
-
-
-@dataclass(eq=False, slots=True)
-class _InvocationReservation:
-    """只携带准入事实，不携带 caller、DI scope 或事务；由接受工作的 owner 收口。"""
-
-    runtime: _InvocationRuntime
-    executing: bool = False
-
-
-class _InvocationRuntime:
-    """每个 Application 独占 admission 与 ContextVar，禁止进程级 current app。"""
-
-    __slots__ = (
-        "_active",
-        "_ambient",
-        "_application_id",
-        "_authenticating",
-        "_call_scope",
-        "_caller",
-        "_condition",
-        "_http_method",
-        "_is_accepting",
-        "_lease",
-        "_reservations",
-        "_state_getter",
-        "tracer",
-    )
-
-    def __init__(
-        self,
-        *,
-        application_id: UUID,
-        state_getter: Callable[[], ApplicationState],
-    ) -> None:
-        self._application_id = application_id
-        self._authenticating: ContextVar[bool] = ContextVar(
-            f"python_ddd_framework_authenticating_{application_id}", default=False
-        )
-        self._http_method: ContextVar[str | None] = ContextVar(
-            f"python_ddd_framework_http_method_{application_id}", default=None
-        )
-        self.tracer: Tracer | None = None
-        self._state_getter = state_getter
-        self._ambient: ContextVar[_InvocationState | None] = ContextVar(
-            f"python_ddd_framework_invocation_{application_id}",
-            default=None,
-        )
-        self._caller: ContextVar[_CallerContext | None] = ContextVar(
-            f"python_ddd_framework_caller_{application_id}",
-            default=None,
-        )
-        self._lease: ContextVar[_OuterInvocationLease | None] = ContextVar(
-            f"python_ddd_framework_invocation_lease_{application_id}",
-            default=None,
-        )
-        self._condition = asyncio.Condition()
-        self._is_accepting = False
-        self._active = 0
-        self._reservations: set[_InvocationReservation] = set()
-        self._call_scope: ContextVar[_CallScope | None] = ContextVar(
-            f"python_ddd_framework_call_scope_{application_id}",
-            default=None,
-        )
-
-    @contextmanager
-    def call_scope(self, container: AsyncContainer) -> Iterator[None]:
-        token = self._call_scope.set(_CallScope(container, _current_task()))
-        try:
-            yield
-        finally:
-            self._call_scope.reset(token)
-
-    def current_call_scope(self) -> AsyncContainer | None:
-        scope = self._call_scope.get()
-        if scope is None:
-            return None
-        if scope.owner_task is not _current_task():
-            raise CrossTaskInvocationError
-        return scope.container
-
-    def http_method(self) -> str | None:
-        return self._http_method.get()
-
-    @contextmanager
-    def http_scope(self, method: str) -> Iterator[None]:
-        token = self._http_method.set(method)
-        try:
-            yield
-        finally:
-            self._http_method.reset(token)
-
-    @contextmanager
-    def detached_execution(self, container: AsyncContainer) -> Iterator[None]:
-        token = self._ambient.set(None)
-        try:
-            with self.call_scope(container):
-                yield
-        finally:
-            self._ambient.reset(token)
-
-    @property
-    def application_id(self) -> UUID:
-        return self._application_id
-
-    def start_accepting(self) -> None:
-        self._is_accepting = True
-
-    def runtime_participant(self) -> RuntimeParticipant:
-        async def start() -> None:
-            self.start_accepting()
-
-        async def stop(reason: ShutdownReason) -> tuple[BaseException, ...]:
-            self._is_accepting = False
-            return ()
-
-        # 未 start 的 COMPOSED HTTP 也可持有许可；所有消费者停止后、容器关闭前统一排空。
-        return RuntimeParticipant(start=start, stop=stop, drain=self.stop_accepting_and_wait)
-
-    async def stop_accepting_and_wait(self) -> None:
-        async with self._condition:
-            self._is_accepting = False
-            await self._condition.wait_for(lambda: self._active == 0)
-
-    def reserve(self) -> _InvocationReservation:
-        # 与 loop 上的接受/关闭无 await 地线性化；等待执行不打开 REQUEST/ACTION。
-        self.require_accepting_work()
-        reservation = _InvocationReservation(self)
-        self._reservations.add(reservation)
-        self._active += 1
-        return reservation
-
-    def require_accepting_work(self) -> None:
-        _current_task()
-        if not self._is_accepting or self._state_getter() not in (
-            ApplicationState.STARTING,
-            ApplicationState.RUNNING,
-        ):
-            raise ApplicationInvocationRejectedError(reason="Application is not accepting work")
-
-    async def discard(self, reservation: _InvocationReservation) -> None:
-        if reservation.runtime is not self or reservation not in self._reservations:
-            raise ApplicationInvocationRejectedError(reason="Invalid or released reservation")
-        async with self._condition:
-            self._reservations.remove(reservation)
-            self._active -= 1
-            if self._active == 0:
-                self._condition.notify_all()
-
-    @asynccontextmanager
-    async def reserved_lease(self, reservation: _InvocationReservation) -> AsyncIterator[None]:
-        if (
-            reservation.runtime is not self
-            or reservation not in self._reservations
-            or reservation.executing
-            or self._lease.get() is not None
-            or self.current() is not None
-            or self.current_call_scope() is not None
-        ):
-            raise ApplicationInvocationRejectedError(reason="Invalid reservation execution owner")
-        reservation.executing = True
-        token = self._lease.set(_OuterInvocationLease(_current_task(), True))
-        try:
-            yield
-        finally:
-            self._lease.reset(token)
-            await self.discard(reservation)
-
-    @asynccontextmanager
-    async def outer_lease(self, *, allow_composed_request: bool = False) -> AsyncIterator[None]:
-        owner_task = _current_task()
-        inherited = self._lease.get()
-        if inherited is not None:
-            if inherited.owner_task is not owner_task:
-                # asyncio.create_task 会复制 ContextVar；child task 不得继承 parent admission。
-                raise CrossTaskInvocationError
-            if not inherited.allows_invocation and not allow_composed_request:
-                raise ApplicationInvocationRejectedError(
-                    reason=(
-                        "Application must be running and accepting invocations, got "
-                        f"{self._state_getter().value}"
-                    )
-                )
-            yield
-            return
-
-        async with self._condition:
-            state = self._state_getter()
-            # HostedService.start 可调用业务入口，但全部后台启动成功前 readiness 仍为 false。
-            allows_invocation = self._is_accepting and state in (
-                ApplicationState.STARTING,
-                ApplicationState.RUNNING,
-            )
-            allows_composed_request = allow_composed_request and state is ApplicationState.COMPOSED
-            if not allows_invocation and not allows_composed_request:
-                raise ApplicationInvocationRejectedError(
-                    reason=(
-                        f"Application must be running and accepting invocations, got {state.value}"
-                    )
-                )
-            self._active += 1
-        token = self._lease.set(_OuterInvocationLease(owner_task, allows_invocation))
-        try:
-            yield
-        finally:
-            self._lease.reset(token)
-            async with self._condition:
-                assert self._active > 0
-                self._active -= 1
-                if self._active == 0:
-                    self._condition.notify_all()
-
-    def current(self) -> _InvocationState | None:
-        return self._ambient.get()
-
-    def bind(self, state: _InvocationState) -> Token[_InvocationState | None]:
-        return self._ambient.set(state)
-
-    def reset(self, token: Token[_InvocationState | None]) -> None:
-        self._ambient.reset(token)
-
-    def current_user(self) -> CurrentUser:
-        if self._authenticating.get():
-            raise ApplicationInvocationRejectedError(
-                reason="authentication cannot depend on the final CurrentUser"
-            )
-        caller = self._caller.get()
-        if caller is None:
-            return CurrentUser.anonymous()
-        if not caller.transferable and caller.owner_task is not _current_task():
-            raise CrossTaskInvocationError
-        return caller.current_user
-
-    def correlation_id(self) -> str | None:
-        caller = self._caller.get()
-        if caller is None:
-            return None
-        if not caller.transferable and caller.owner_task is not _current_task():
-            raise CrossTaskInvocationError
-        return caller.correlation_id
-
-    def diagnostic_correlation_id(self) -> str | None:
-        # 日志允许只读关联复制到线程的上下文；这不授予 child task/线程调用业务的 lease。
-        caller = self._caller.get()
-        return None if caller is None else caller.correlation_id
-
-    def bind_caller(
-        self,
-        current_user: CurrentUser,
-        correlation_id: str,
-    ) -> Token[_CallerContext | None]:
-        if not isinstance(current_user, CurrentUser):
-            raise TypeError("current_user must be CurrentUser")
-        if not _is_safe_correlation_id(correlation_id):
-            raise ValueError("correlation_id must be a safe non-empty identifier")
-        return self._caller.set(
-            _CallerContext(
-                current_user=current_user,
-                correlation_id=correlation_id,
-                owner_task=_current_task(),
-            )
-        )
-
-    def reset_caller(self, token: Token[_CallerContext | None]) -> None:
-        self._caller.reset(token)
-
-    @contextmanager
-    def authenticating(self) -> Iterator[None]:
-        token = self._authenticating.set(True)
-        try:
-            yield
-        finally:
-            self._authenticating.reset(token)
-
-    @contextmanager
-    def trusted_http_task(
-        self, container: AsyncContainer, user: CurrentUser, correlation_id: str, method: str
-    ) -> Iterator[None]:
-        # 只有 adapter 的受监督入口可交接许可；普通 create_task 仍受原有 task guard 约束。
-        lease = self._lease.get()
-        if lease is None or self.current() is not None:
-            raise CrossTaskInvocationError
-        task = _current_task()
-        lease_token = self._lease.set(_OuterInvocationLease(task, lease.allows_invocation))
-        caller_token = self._caller.set(_CallerContext(user, correlation_id, task, True))
-        try:
-            with self.call_scope(container), self.http_scope(method):
-                yield
-        finally:
-            self._caller.reset(caller_token)
-            self._lease.reset(lease_token)
-
-    def context_for_action(self, container: AsyncContainer) -> ApplicationInvocationContext:
-        """由原生 ACTION factory 缓存上下文，DI 与调用管线共享同一身份。"""
-        # Dishka 1.10 的公开 context 属性已弃用；这里只读取原生 scope 的输入，
-        # 不写 context/cache，也不复制容器的解析或缓存。第三方字段访问集中于此。
-        native_context = container._context
-        if native_context is None or ApplicationInvocationContext not in native_context:
-            return self._new_context(_DEFAULT_CONNECTION_NAME)
-        supplied: object = native_context[ApplicationInvocationContext]
-        if not isinstance(supplied, ApplicationInvocationContext):
-            raise ApplicationInvocationRejectedError(reason="invalid ACTION invocation context")
-        if supplied.application_id != self.application_id:
-            raise ApplicationInvocationRejectedError(
-                reason="ACTION invocation context belongs to another Application"
-            )
-        return supplied
-
-    def _new_context(self, connection_name: str) -> ApplicationInvocationContext:
-        return ApplicationInvocationContext(
-            application_id=self.application_id,
-            invocation_id=uuid4(),
-            parent_invocation_id=None,
-            connection_name=connection_name,
-        )
-
-    async def run_action(
-        self,
-        container: AsyncContainer,
-        *,
-        connection_name: str,
-        callback: Callable[[AsyncContainer], Awaitable[object]],
-        declaration: UnitOfWorkDeclaration,
-        method_name: str = "execute",
-        unit_of_work_enabled: bool = True,
-    ) -> object:
-        """执行 scope 独立于数据库 UoW；自动边界只完成自己创建或加入的工作。"""
-        context = (
-            await container.get(ApplicationInvocationContext)
-            if container.scope is Scope.ACTION
-            else self._new_context(connection_name)
-        )
-        if context.connection_name != connection_name:
-            raise NestedConnectionError(outer=context.connection_name, requested=connection_name)
-        work: UnitOfWork | None = None
-        async with _managed_action(
-            container, context, committed=lambda: work is not None and work.committed
-        ) as action:
-            state = _InvocationState(context, _current_task(), action)
-            token = self.bind(state)
-            try:
-                if not unit_of_work_enabled:
-                    return await callback(action)
-                manager = await action.get(UnitOfWorkManager)
-                if declaration.disabled:
-                    manager._check_current(connection_name)
-                    return await callback(action)
-                options = manager._resolve_options(connection_name, declaration, method_name)
-                async with manager._begin(options) as work:
-                    result = await callback(action)
-                    await work.complete()
-                    return result
-            finally:
-                self.reset(token)
-
-
-@asynccontextmanager
-async def _managed_request(parent: AsyncContainer) -> AsyncIterator[AsyncContainer]:
-    """排空入口自己创建的 REQUEST；不推断业务事务是否已经提交。"""
-    request = parent(scope=Scope.REQUEST)
-    primary: BaseException | None = None
-    try:
-        yield request
-    except BaseException as error:
-        primary = error
-    primary, failures = await _close_action(request, primary)
-    if failures:
-        # REQUEST 无事务 owner；保留业务原异常及已有 cause，不伪造 committed=False。
-        inherited = (primary.__cause__,) if primary is not None and primary.__cause__ else ()
-        cleanup = BaseExceptionGroup("REQUEST cleanup failed", (*inherited, *failures))
-        if primary is not None:
-            raise primary from cleanup
-        raise cleanup
-    if primary is not None:
-        raise primary
-
-
-@asynccontextmanager
-async def _managed_action(
-    parent: AsyncContainer,
-    context: ApplicationInvocationContext,
-    *,
-    committed: Callable[[], bool],
-) -> AsyncIterator[AsyncContainer]:
-    if parent.scope is Scope.ACTION:
-        # 普通服务可能已经由调用方的 ACTION 解析；资源仍由该 scope 的 owner 关闭。
-        yield parent
-        return
-    action = parent(context={ApplicationInvocationContext: context}, scope=Scope.ACTION)
-    primary: BaseException | None = None
-    try:
-        yield action
-    except BaseException as error:
-        primary = error
-    primary, failures = await _close_action(action, primary)
-    _raise_scope_failure(primary, failures, committed())
-
-
-async def _close_action(
-    action: AsyncContainer, primary: BaseException | None
-) -> tuple[BaseException | None, tuple[BaseException, ...]]:
-    # Dishka generator 可能拥有 ContextVar token，进入与退出必须保持同一 task。
-    # 具体 provider 负责保护自己的原生 I/O（SQL UoW 已在 scope 关闭前回收）；
-    # finalizer 的 BaseException 仍需继续原生 close，穷尽其余资源。
-    failures: list[BaseException] = []
-    while True:
-        try:
-            await action.close(primary)
-            return primary, tuple(failures)
-        except asyncio.CancelledError as cancellation:
-            if primary is None:
-                primary = cancellation
-            else:
-                failures.append(cancellation)
-        except BaseException as error:
-            failures.append(error)
-
-
-def _raise_scope_failure(
-    primary: BaseException | None, failures: tuple[BaseException, ...], committed: bool
-) -> None:
-    if failures:
-        inherited = primary.__cause__ if isinstance(primary, asyncio.CancelledError) else primary
-        if isinstance(inherited, ApplicationInvocationCleanupError):
-            failures = (*inherited.cleanup_failures, *failures)
-            if not isinstance(primary, asyncio.CancelledError):
-                primary = inherited.primary
-        failure = ApplicationInvocationCleanupError(
-            primary=primary, cleanup_failures=failures, committed=committed
-        )
-        if isinstance(primary, asyncio.CancelledError):
-            raise primary from failure
-        raise failure from (primary or failures[0])
-    if primary is not None:
-        raise primary
+from ..invocation.runtime import _InvocationRuntime
+from ..invocation.scopes import _managed_request
+from .catalog import ApplicationServiceCatalog
 
 
 class _ScopedApplicationServiceInvoker:
@@ -526,7 +40,7 @@ class _ScopedApplicationServiceInvoker:
         async with self._runtime.outer_lease():
             caller_token = self._runtime.bind_caller(current_user, correlation_id)
             try:
-                async with parent(scope=Scope.REQUEST) as request_container:
+                async with _managed_request(parent) as request_container:
                     proxy = await request_container.get(service.registration.contract)
                     call = cast(
                         Callable[..., Awaitable[object]],
@@ -541,10 +55,3 @@ class _ScopedApplicationServiceInvoker:
             return
         if parent.scope is not Scope.SESSION or parent.parent_container is not self._root_container:
             raise RuntimeError("scoped invocation parent is not owned by this Application")
-
-
-def _current_task() -> asyncio.Task[object]:
-    task = asyncio.current_task()
-    if task is None:
-        raise RuntimeError("Application Service invocation requires an asyncio Task")
-    return cast(asyncio.Task[object], task)

python_ddd_framework/application_services/module.py

@@ -25,15 +25,16 @@ from ..services.convention_contracts import (
     ConventionDiscoveryKind,
     _ServiceDefinition,
 )
+from ..services.relocation import _BindingRelocation
 from ..settings.module import SettingsModule
 from ..unit_of_work.module import UnitOfWorkModule
 from .bindings import (
     _bind_application_services,
-    _runtime_providers,
     _validate_application_service_bindings,
     _validate_application_service_dependencies,
 )
 from .catalog import (
+    _APPLICATION_SERVICE_COMPONENT,
     ApplicationServiceCatalog,
     _build_application_service_catalog,
     _DiscoveredApplicationService,
@@ -130,10 +131,20 @@ class ApplicationServicesModule(AppModule):
             context.modules.instance(InvocationModule).rules,
             context.modules.instance(ExtensionsModule).catalog,
         )
-        # 只重定位仲裁后的原生绑定，保留其他能力已经生成的目录 Provider。
-        for provider in context.arbitration.providers:
-            context._providers.remove(provider)
-        context._providers[0:0] = _runtime_providers(context.arbitration, bound)
+        # 能力只决定私有实现 key；来源、工厂搬迁和贡献指纹仍由 services 管理。
+        context._relocate_bindings(
+            tuple(
+                _BindingRelocation(
+                    item.winner,
+                    DependencyKey(
+                        item.binding.discovery.definition.contract
+                        or item.binding.discovery.service_type,
+                        _APPLICATION_SERVICE_COMPONENT,
+                    ),
+                )
+                for item in bound
+            )
+        )
         provider = Provider()
         provider.provide(lambda: self.catalog, provides=ApplicationServiceCatalog, scope=Scope.APP)
         provider.provide(_ApplicationServiceDispatcher, scope=Scope.REQUEST)

python_ddd_framework/authorization/module.py

@@ -2,8 +2,8 @@
 
 from dishka import Provider, Scope
 
-from ..application_services.invocation import _InvocationRuntime
 from ..invocation.module import InvocationModule
+from ..invocation.runtime import _InvocationRuntime
 from ..lifecycle import ConfigureContext
 from ..modularity import AppModule
 from ..services.composition import (

python_ddd_framework/background_execution/local.py

@@ -30,12 +30,19 @@ class _LocalTask:
         self.operation: asyncio.Task[None] | None = None
         self._failed = failed
         self._monitor: asyncio.Task[None] | None = None
+        self._quiescing = False
+        self._claiming_stopped = False
 
     async def start(self) -> None:
+        self._claiming_stopped = False
         self.state = BackgroundTaskState.STARTING
         if self.execution is None:
             raise RuntimeError("Task execution provider is unavailable")
         await self.execution.start()
+        if self._quiescing:
+            # start 可能与关闭重叠；完成后再次请求停止，不能重新打开领取。
+            self._claiming_stopped = False
+            self._stop_claiming()
         self.state = BackgroundTaskState.RUNNING
         if self.execution.wait_for_failure is not None:
             self._monitor = asyncio.create_task(
@@ -82,6 +89,9 @@ class _LocalTask:
     async def _operate(self, start: bool) -> None:
         try:
             if start:
+                if self._quiescing:
+                    self.state = BackgroundTaskState.STOPPED
+                    return
                 await self.start()
             else:
                 await self._drain()
@@ -91,6 +101,15 @@ class _LocalTask:
             self.state = BackgroundTaskState.FAILED
             # 失败转为 Application-owned 状态供查询；task 不留下未观察异常。
 
+    def quiesce(self) -> None:
+        self._quiescing = True
+        self._stop_claiming()
+
+    def _stop_claiming(self) -> None:
+        if self.execution is not None and not self._claiming_stopped:
+            self._claiming_stopped = True
+            self.execution.stop_claiming()
+
     async def shutdown(self) -> None:
         if self.operation is not None:
             await self.operation
@@ -112,7 +131,7 @@ class _LocalTask:
         execution = self.execution
         if execution is None:
             return
-        execution.stop_claiming()
+        self._stop_claiming()
         draining = asyncio.ensure_future(execution.wait())
         _, pending = await asyncio.wait((draining,), timeout=self.deadline)
         if pending:

python_ddd_framework/background_execution/processes.py

@@ -60,6 +60,7 @@ class _ProcessSlot:
         self._exited = asyncio.Event()
         self._exited.set()
         self._stopping = False
+        self._shutdown_request: asyncio.Task[None] | None = None
         self._restart_count = 0
         self._wanted: set[str] = set()
         self._serial = 0
@@ -307,14 +308,23 @@ class _ProcessSlot:
                 if not self._stopping and self._wanted and self._process is None:
                     self._spawn()
 
-    async def shutdown(self) -> None:
+    def quiesce(self) -> None:
         self._stopping = True
         self._set_enabled_state(BackgroundTaskState.STOPPING)
+        if self._shutdown_request is None:
+            self._shutdown_request = asyncio.create_task(self._request_shutdown())
+
+    async def _request_shutdown(self) -> None:
         if self._process is not None and self._process.is_alive():
             try:
                 await self._send((_Message.SHUTDOWN,))
             except (EOFError, OSError):
                 pass
+
+    async def shutdown(self) -> None:
+        self.quiesce()
+        assert self._shutdown_request is not None
+        await self._shutdown_request
         if self._monitor is not None:
             await self._monitor
         if self._operations:

python_ddd_framework/background_jobs/execution.py

@@ -12,9 +12,9 @@ from uuid import uuid4
 from dishka import AsyncContainer, Scope
 from pydantic import BaseModel, ValidationError
 
-from ..application_services.invocation import _InvocationRuntime
 from ..authorization import CurrentUser
 from ..invocation import BackgroundSystemCaller
+from ..invocation.runtime import _InvocationRuntime
 from ..observability.context import invocation_span
 from .catalog import BackgroundJobCatalog
 from .contracts import BackgroundJobContext, BackgroundJobDefinition

python_ddd_framework/background_jobs/pgqueuer/enqueue.py

@@ -8,7 +8,7 @@ from typing import Any, TypeVar
 import asyncpg  # type: ignore[import-untyped]
 from pydantic import BaseModel
 
-from ...application_services.invocation import _InvocationRuntime
+from ...invocation.runtime import _InvocationRuntime
 from ...observability.context import capture_trace_context
 from ...options import Options
 from ...sqlalchemy import SqlAlchemySessionProvider