agentstack-sdk 0.5.2rc2__py3-none-any.whl

agentstack_sdk/server/server.py

@@ -0,0 +1,376 @@
+# Copyright 2025 © BeeAI a Series of LF Projects, LLC
+# SPDX-License-Identifier: Apache-2.0
+
+import asyncio
+import functools
+import os
+import re
+import urllib.parse
+from collections.abc import AsyncGenerator, Awaitable, Callable
+from configparser import RawConfigParser
+from contextlib import asynccontextmanager, nullcontext, suppress
+from datetime import timedelta
+from ssl import CERT_NONE
+from typing import IO, Any, Literal
+
+import uvicorn
+import uvicorn.config as uvicorn_config
+from a2a.server.agent_execution import RequestContextBuilder
+from a2a.server.events import QueueManager
+from a2a.server.tasks import PushNotificationConfigStore, PushNotificationSender, TaskStore
+from a2a.types import AgentExtension
+from fastapi import FastAPI
+from fastapi.applications import AppType
+from fastapi.responses import PlainTextResponse
+from httpx import HTTPError, HTTPStatusError
+from pydantic import AnyUrl
+from starlette.authentication import AuthenticationBackend, AuthenticationError
+from starlette.middleware.authentication import AuthenticationMiddleware
+from starlette.requests import HTTPConnection
+from starlette.types import Lifespan
+from tenacity import AsyncRetrying, retry_if_exception_type, stop_after_attempt, wait_exponential
+
+from agentstack_sdk.platform import get_platform_client
+from agentstack_sdk.platform.client import PlatformClient
+from agentstack_sdk.platform.provider import Provider
+from agentstack_sdk.server.agent import Agent, AgentFactory
+from agentstack_sdk.server.agent import agent as agent_decorator
+from agentstack_sdk.server.store.context_store import ContextStore
+from agentstack_sdk.server.store.memory_context_store import InMemoryContextStore
+from agentstack_sdk.server.telemetry import configure_telemetry as configure_telemetry_func
+from agentstack_sdk.server.utils import cancel_task
+from agentstack_sdk.util.logging import configure_logger as configure_logger_func
+from agentstack_sdk.util.logging import logger
+
+
+class Server:
+    def __init__(self) -> None:
+        self._agent_factory: AgentFactory | None = None
+        self._agent: Agent | None = None
+        self.server: uvicorn.Server | None = None
+        self._context_store: ContextStore | None = None
+        self._self_registration_client: PlatformClient | None = None
+        self._self_registration_id: str | None = None
+        self._provider_id: str | None = None
+        self._all_configured_variables: set[str] = set()
+
+    @functools.wraps(agent_decorator)
+    def agent(*args, **kwargs) -> Callable:
+        self, other_args = args[0], args[1:]  # Must hide self due to pyright issues
+        if self._agent_factory:
+            raise ValueError("Server can have only one agent.")
+
+        def decorator(fn: Callable) -> Callable:
+            self._agent_factory = agent_decorator(*other_args, **kwargs)(fn)  # pyright: ignore [reportArgumentType]
+            return fn
+
+        return decorator
+
+    async def serve(
+        self,
+        *,
+        configure_logger: bool = True,
+        configure_telemetry: bool = False,
+        self_registration: bool = True,
+        self_registration_id: str | None = None,
+        task_store: TaskStore | None = None,
+        context_store: ContextStore | None = None,
+        queue_manager: QueueManager | None = None,
+        task_timeout: timedelta = timedelta(minutes=10),
+        push_config_store: PushNotificationConfigStore | None = None,
+        push_sender: PushNotificationSender | None = None,
+        request_context_builder: RequestContextBuilder | None = None,
+        host: str = "127.0.0.1",
+        port: int = 10000,
+        url: str | None = None,
+        uds: str | None = None,
+        fd: int | None = None,
+        loop: Literal["none", "auto", "asyncio", "uvloop"] = "auto",
+        http: type[asyncio.Protocol] | uvicorn_config.HTTPProtocolType = "auto",
+        ws: type[asyncio.Protocol] | uvicorn_config.WSProtocolType = "auto",
+        ws_max_size: int = 16 * 1024 * 1024,
+        ws_max_queue: int = 32,
+        ws_ping_interval: float | None = 20.0,
+        ws_ping_timeout: float | None = 20.0,
+        ws_per_message_deflate: bool = True,
+        lifespan: uvicorn_config.LifespanType = "auto",
+        lifespan_fn: Lifespan[AppType] | None = None,
+        env_file: str | os.PathLike[str] | None = None,
+        log_config: dict[str, Any] | str | RawConfigParser | IO[Any] | None = uvicorn_config.LOGGING_CONFIG,
+        log_level: str | int | None = None,
+        access_log: bool = True,
+        use_colors: bool | None = None,
+        interface: uvicorn_config.InterfaceType = "auto",
+        reload: bool = False,
+        reload_dirs: list[str] | str | None = None,
+        reload_delay: float = 0.25,
+        reload_includes: list[str] | str | None = None,
+        reload_excludes: list[str] | str | None = None,
+        workers: int | None = None,
+        proxy_headers: bool = True,
+        server_header: bool = True,
+        date_header: bool = True,
+        forwarded_allow_ips: list[str] | str | None = None,
+        root_path: str = "",
+        limit_concurrency: int | None = None,
+        limit_max_requests: int | None = None,
+        backlog: int = 2048,
+        timeout_keep_alive: int = 5,
+        timeout_notify: int = 30,
+        timeout_worker_healthcheck: int = 5,
+        timeout_graceful_shutdown: int | None = None,
+        callback_notify: Callable[..., Awaitable[None]] | None = None,
+        ssl_keyfile: str | os.PathLike[str] | None = None,
+        ssl_certfile: str | os.PathLike[str] | None = None,
+        ssl_keyfile_password: str | None = None,
+        ssl_version: int = uvicorn_config.SSL_PROTOCOL_VERSION,
+        ssl_cert_reqs: int = CERT_NONE,
+        ssl_ca_certs: str | None = None,
+        ssl_ciphers: str = "TLSv1",
+        headers: list[tuple[str, str]] | None = None,
+        factory: bool = False,
+        h11_max_incomplete_event_size: int | None = None,
+        self_registration_client_factory: Callable[[], PlatformClient] | None = None,
+        auth_backend: AuthenticationBackend | None = None,
+    ) -> None:
+        if self.server:
+            raise RuntimeError("The server is already running")
+        if not self._agent_factory:
+            raise ValueError("Agent is not registered")
+
+        context_store = context_store or InMemoryContextStore()
+        self._agent = self._agent_factory(context_store.modify_dependencies)
+        card_url = url and url.strip()
+        self._agent.card.url = card_url.rstrip("/") if card_url else f"http://{host}:{port}"
+
+        self._self_registration_client = (
+            self_registration_client_factory() if self_registration_client_factory else None
+        )
+        self._self_registration_id = urllib.parse.quote(self_registration_id or self._agent.card.name)
+
+        if headers is None:
+            headers = [("server", "a2a")]
+        elif not any(k.lower() == "server" for k, _ in headers):
+            headers.append(("server", "a2a"))
+
+        import uvicorn
+
+        from agentstack_sdk.server.app import create_app
+
+        @asynccontextmanager
+        async def _lifespan_fn(app: FastAPI) -> AsyncGenerator[None, None]:
+            async with self._self_registration_client or nullcontext():
+                register_task = asyncio.create_task(self._register_agent()) if self_registration else None
+                reload_task = asyncio.create_task(self._reload_variables_periodically()) if self_registration else None
+
+                try:
+                    async with lifespan_fn(app) if lifespan_fn else nullcontext():  # pyright: ignore [reportArgumentType]
+                        yield
+                finally:
+                    if register_task:
+                        with suppress(Exception):
+                            await cancel_task(register_task)
+                    if reload_task:
+                        with suppress(Exception):
+                            await cancel_task(reload_task)
+
+        card_url = AnyUrl(self._agent.card.url)
+        if card_url.host == "invalid":
+            self._agent.card.url = f"http://{host}:{port}"
+
+        if self_registration:
+            from agentstack_sdk.a2a.extensions.services.platform import (
+                _PlatformSelfRegistrationExtensionParams,
+                _PlatformSelfRegistrationExtensionSpec,
+            )
+
+            self._agent.card.capabilities.extensions = [
+                *(self._agent.card.capabilities.extensions or []),
+                *_PlatformSelfRegistrationExtensionSpec(
+                    _PlatformSelfRegistrationExtensionParams(self_registration_id=self._self_registration_id)
+                ).to_agent_card_extensions(),
+            ]
+
+        app = create_app(
+            self._agent,
+            lifespan=_lifespan_fn,
+            task_store=task_store,
+            context_store=context_store,
+            queue_manager=queue_manager,
+            push_config_store=push_config_store,
+            push_sender=push_sender,
+            task_timeout=task_timeout,
+            request_context_builder=request_context_builder,
+        )
+
+        if auth_backend:
+
+            def on_error(connection: HTTPConnection, error: AuthenticationError) -> PlainTextResponse:
+                return PlainTextResponse("Unauthorized", status_code=401)
+
+            app.add_middleware(AuthenticationMiddleware, backend=auth_backend, on_error=on_error)
+
+        if configure_logger:
+            configure_logger_func(log_level)
+
+        if configure_telemetry:
+            configure_telemetry_func(app)
+
+        config = uvicorn.Config(
+            app,
+            host,
+            port,
+            uds,
+            fd,
+            loop,
+            http,
+            ws,
+            ws_max_size,
+            ws_max_queue,
+            ws_ping_interval,
+            ws_ping_timeout,
+            ws_per_message_deflate,
+            lifespan,
+            env_file,
+            log_config if not configure_logger else None,
+            log_level,
+            access_log,
+            use_colors,
+            interface,
+            reload,
+            reload_dirs,
+            reload_delay,
+            reload_includes,
+            reload_excludes,
+            workers,
+            proxy_headers,
+            server_header,
+            date_header,
+            forwarded_allow_ips,
+            root_path,
+            limit_concurrency,
+            limit_max_requests,
+            backlog,
+            timeout_keep_alive,
+            timeout_notify,
+            timeout_graceful_shutdown,
+            timeout_worker_healthcheck,
+            callback_notify,
+            ssl_keyfile,
+            ssl_certfile,
+            ssl_keyfile_password,
+            ssl_version,
+            ssl_cert_reqs,
+            ssl_ca_certs,
+            ssl_ciphers,
+            headers,
+            factory,
+            h11_max_incomplete_event_size,
+        )
+        self.server = uvicorn.Server(config)
+        await self.server.serve()
+
+    @functools.wraps(serve)
+    def run(*args, **kwargs) -> None:
+        self = args[0]  # Must hide self due to pyright issues
+        asyncio.run(self.serve(**kwargs))
+
+    @property
+    def should_exit(self) -> bool:
+        return self.server.should_exit if self.server else False
+
+    @should_exit.setter
+    def should_exit(self, value: bool) -> None:
+        if self.server:
+            self.server.should_exit = value
+
+    @property
+    def _platform_url(self) -> str:
+        return os.getenv("PLATFORM_URL", "http://127.0.0.1:8333")
+
+    @property
+    def _production_mode(self) -> bool:
+        return os.getenv("PRODUCTION_MODE", "").lower() in ["true", "1"]
+
+    async def _reload_variables_periodically(self):
+        while True:
+            await asyncio.sleep(5)
+            await self._load_variables()
+
+    async def _load_variables(self, first_run: bool = False) -> None:
+        from agentstack_sdk.a2a.extensions import AgentDetail, AgentDetailExtensionSpec
+
+        assert self.server and self._agent
+        if not self._provider_id:
+            return
+
+        variables = await Provider.list_variables(self._provider_id, client=self._self_registration_client)
+        old_variables = self._all_configured_variables.copy()
+
+        for variable in list(self._all_configured_variables - variables.keys()):  # reset removed variables
+            os.environ.pop(variable, None)
+            self._all_configured_variables.remove(variable)
+
+        os.environ.update(variables)
+        self._all_configured_variables.update(variables.keys())
+
+        if dirty := old_variables != self._all_configured_variables:
+            logger.info(f"Environment variables reloaded dynamically: {self._all_configured_variables}")
+
+        if first_run or dirty:
+            for extension in self._agent.card.capabilities.extensions or []:
+                match extension:
+                    case AgentExtension(uri=AgentDetailExtensionSpec.URI, params=params):
+                        variables = AgentDetail.model_validate(params).variables or []
+                        if missing_keys := [env for env in variables if env.required and os.getenv(env.name) is None]:
+                            logger.warning(
+                                f"Missing required env variables: {missing_keys}, "
+                                f"add them using `agentstack env add <agent> key=value`"
+                            )
+
+    async def _register_agent(self) -> None:
+        """If not in PRODUCTION mode, register agent to the agentstack platform and provide missing env variables"""
+        assert self.server and self._agent
+        if self._production_mode:
+            logger.debug("Agent is not automatically registered in the production mode.")
+            return
+
+        host = re.sub(r"localhost|127\.0\.0\.1", "host.docker.internal", self.server.config.host)
+        provider_location = f"http://{host}:{self.server.config.port}#{self._self_registration_id}"
+        logger.info("Registering agent to the agentstack platform")
+        try:
+            async for attempt in AsyncRetrying(
+                stop=stop_after_attempt(10),
+                wait=wait_exponential(max=10),
+                retry=retry_if_exception_type(HTTPError),
+                reraise=True,
+            ):
+                with attempt:
+                    try:
+                        provider = await Provider.get_by_location(
+                            location=provider_location, client=self._self_registration_client
+                        )
+                        await provider.patch(agent_card=self._agent.card, client=self._self_registration_client)
+                    except HTTPStatusError as error:
+                        if error.response.status_code != 404:
+                            raise
+                        provider = await Provider.create(
+                            location=provider_location,
+                            client=self._self_registration_client,
+                            agent_card=self._agent.card,
+                        )
+                    self._provider_id = provider.id
+                    logger.debug("Agent registered to the agentstack server.")
+                    await self._load_variables()
+                    logger.debug("Environment variables loaded dynamically.")
+            logger.info("Agent registered successfully")
+        except HTTPStatusError as e:
+            with suppress(Exception):
+                if error_message := e.response.json().get("detail"):
+                    logger.info(f"Agent can not be registered to agentstack server: {error_message}")
+                    return
+            logger.info(f"Agent can not be registered to agentstack server: {e}")
+        except HTTPError as e:
+            logger.info(f"Can not reach server, check if running on {get_platform_client().base_url} : {e}")
+        except Exception as e:
+            logger.info(f"Agent can not be registered to agentstack server: {e}")

agentstack_sdk/server/store/__init__.py

@@ -0,0 +1,3 @@
+# Copyright 2025 © BeeAI a Series of LF Projects, LLC
+# SPDX-License-Identifier: Apache-2.0
+

agentstack_sdk/server/store/context_store.py

@@ -0,0 +1,35 @@
+# Copyright 2025 © BeeAI a Series of LF Projects, LLC
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import abc
+from collections.abc import AsyncIterator
+from typing import TYPE_CHECKING, Protocol
+from uuid import UUID
+
+from a2a.types import Artifact, Message
+
+from agentstack_sdk.platform.context import ContextHistoryItem
+
+if TYPE_CHECKING:
+    from agentstack_sdk.server.dependencies import Dependency, Depends
+
+
+class ContextStoreInstance(Protocol):
+    async def load_history(
+        self, load_history_items: bool = False
+    ) -> AsyncIterator[ContextHistoryItem | Message | Artifact]:
+        yield ...  # type: ignore
+
+    async def store(self, data: Message | Artifact) -> None: ...
+
+    async def delete_history_from_id(self, from_id: UUID) -> None: ...
+
+
+class ContextStore(abc.ABC):
+    def modify_dependencies(self, dependencies: dict[str, Depends]) -> None:
+        return
+
+    @abc.abstractmethod
+    async def create(self, context_id: str, initialized_dependencies: list[Dependency]) -> ContextStoreInstance: ...

agentstack_sdk/server/store/memory_context_store.py

@@ -0,0 +1,59 @@
+# Copyright 2025 © BeeAI a Series of LF Projects, LLC
+# SPDX-License-Identifier: Apache-2.0
+
+from collections.abc import AsyncIterator
+from datetime import timedelta
+from uuid import UUID
+
+from a2a.types import Artifact, Message
+from cachetools import TTLCache
+
+from agentstack_sdk.platform.context import ContextHistoryItem
+from agentstack_sdk.server.dependencies import Dependency
+from agentstack_sdk.server.store.context_store import ContextStore, ContextStoreInstance
+
+
+class MemoryContextStoreInstance(ContextStoreInstance):
+    def __init__(self, context_id: str):
+        self.context_id = context_id
+        self._history: list[ContextHistoryItem] = []
+
+    async def load_history(
+        self, load_history_items: bool = False
+    ) -> AsyncIterator[ContextHistoryItem | Message | Artifact]:
+        for item in self._history.copy():
+            if load_history_items:
+                yield item.model_copy(deep=True)
+            else:
+                yield item.data.model_copy(deep=True)
+
+    async def store(self, data: Message | Artifact) -> None:
+        self._history.append(ContextHistoryItem(data=data.model_copy(deep=True), context_id=self.context_id))
+
+    async def delete_history_from_id(self, from_id: UUID) -> None:
+        # Does not allow to delete from an artifact onwards
+        index = next(
+            (i for i, item in enumerate(self._history) if item.id == from_id),
+            None,
+        )
+        if index is not None:
+            self._history = self._history[:index]
+
+
+class InMemoryContextStore(ContextStore):
+    def __init__(self, max_contexts: int = 1000, context_ttl: timedelta = timedelta(hours=1)):
+        """
+        Initialize in-memory context store with TTL cache.
+
+        Args:
+            max_contexts: Maximum number of contexts to keep in memory
+            ttl_seconds: Time-to-live for context instances in seconds (default: 1 hour)
+        """
+        self._instances: TTLCache[str, MemoryContextStoreInstance] = TTLCache(
+            maxsize=max_contexts, ttl=context_ttl.total_seconds()
+        )
+
+    async def create(self, context_id: str, initialized_dependencies: list[Dependency]) -> ContextStoreInstance:
+        if context_id not in self._instances:
+            self._instances[context_id] = MemoryContextStoreInstance(context_id)
+        return self._instances[context_id]

agentstack_sdk/server/store/platform_context_store.py

@@ -0,0 +1,58 @@
+# Copyright 2025 © BeeAI a Series of LF Projects, LLC
+# SPDX-License-Identifier: Apache-2.0
+
+from collections.abc import AsyncIterator
+from uuid import UUID
+
+from a2a.types import Artifact, Message
+
+from agentstack_sdk.a2a.extensions.services.platform import (
+    PlatformApiExtensionServer,
+    PlatformApiExtensionSpec,
+)
+from agentstack_sdk.platform.context import Context, ContextHistoryItem
+from agentstack_sdk.server.constants import _IMPLICIT_DEPENDENCY_PREFIX
+from agentstack_sdk.server.dependencies import Dependency, Depends
+from agentstack_sdk.server.store.context_store import ContextStore, ContextStoreInstance
+
+
+class PlatformContextStore(ContextStore):
+    def modify_dependencies(self, dependencies: dict[str, Depends]) -> None:
+        for dependency in dependencies.values():
+            if dependency.extension is None:
+                continue
+            if dependency.extension.spec.URI == PlatformApiExtensionSpec.URI:
+                dependency.extension.spec.required = True
+                break
+        else:
+            dependencies[f"{_IMPLICIT_DEPENDENCY_PREFIX}_{PlatformApiExtensionSpec.URI}"] = Depends(
+                PlatformApiExtensionServer(PlatformApiExtensionSpec())
+            )
+
+    async def create(self, context_id: str, initialized_dependencies: list[Dependency]) -> ContextStoreInstance:
+        [platform_ext] = [d for d in initialized_dependencies if isinstance(d, PlatformApiExtensionServer)]
+        return PlatformContextStoreInstance(context_id=context_id, platform_extension=platform_ext)
+
+
+class PlatformContextStoreInstance(ContextStoreInstance):
+    def __init__(self, context_id: str, platform_extension: PlatformApiExtensionServer):
+        self._context_id = context_id
+        self._platform_extension = platform_extension
+
+    async def load_history(
+        self, load_history_items: bool = False
+    ) -> AsyncIterator[ContextHistoryItem | Message | Artifact]:
+        async with self._platform_extension.use_client():
+            async for history_item in Context.list_all_history(self._context_id):
+                if load_history_items:
+                    yield history_item
+                else:
+                    yield history_item.data
+
+    async def store(self, data: Message | Artifact) -> None:
+        async with self._platform_extension.use_client():
+            await Context.add_history_item(self._context_id, data=data)
+
+    async def delete_history_from_id(self, from_id: UUID) -> None:
+        async with self._platform_extension.use_client():
+            await Context.delete_history_from_id(self._context_id, from_id=from_id)

agentstack_sdk/server/telemetry.py

@@ -0,0 +1,53 @@
+# Copyright 2025 © BeeAI a Series of LF Projects, LLC
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+
+from fastapi import FastAPI
+from opentelemetry import metrics, trace
+from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter
+from opentelemetry.exporter.otlp.proto.http.metric_exporter import OTLPMetricExporter
+from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
+from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
+from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
+from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
+from opentelemetry.sdk.metrics import MeterProvider
+from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
+from opentelemetry.sdk.resources import (
+    SERVICE_NAME,
+    SERVICE_VERSION,
+    Resource,
+)
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor
+
+from agentstack_sdk import __version__
+
+root_logger = logging.getLogger()
+
+
+def configure_telemetry(app: FastAPI) -> None:
+    """Utility that configures opentelemetry with OTLP exporter and FastAPI instrumentation"""
+
+    FastAPIInstrumentor.instrument_app(app)
+
+    resource = Resource(attributes={SERVICE_NAME: "agentstack-sdk-a2a-server", SERVICE_VERSION: __version__})
+
+    # Traces
+    provider = TracerProvider(resource=resource)
+    processor = BatchSpanProcessor(OTLPSpanExporter())
+    provider.add_span_processor(processor)
+    trace.set_tracer_provider(provider)
+
+    # Metrics
+    meter_provider = MeterProvider(
+        resource=resource,
+        metric_readers=[PeriodicExportingMetricReader(OTLPMetricExporter())],
+    )
+    metrics.set_meter_provider(meter_provider)
+
+    # Logs
+    logger_provider = LoggerProvider(resource=resource)
+    processor = BatchLogRecordProcessor(OTLPLogExporter())
+    logger_provider.add_log_record_processor(processor)
+    root_logger.addHandler(LoggingHandler(logger_provider=logger_provider))

agentstack_sdk/server/utils.py

@@ -0,0 +1,26 @@
+# Copyright 2025 © BeeAI a Series of LF Projects, LLC
+# SPDX-License-Identifier: Apache-2.0
+
+import asyncio
+from asyncio import CancelledError
+from contextlib import suppress
+
+from a2a.server.events import QueueManager
+
+
+async def cancel_task(task: asyncio.Task):
+    task.cancel()
+    with suppress(CancelledError):
+        await task
+
+
+async def close_queue(queue_manager: QueueManager, queue_name: str, immediate: bool = False):
+    """Closes a queue without blocking the QueueManager
+
+    By default, QueueManager.close() will block all QueueManager operations (creating new queues, etc)
+    until all queue events are processed. This can have unexpected side effects, we avoid this by closing queue
+    independently and then removing it from queue_manager
+    """
+    if queue := await queue_manager.get(queue_name):
+        await queue.close(immediate=immediate)
+        await queue_manager.close(queue_name)

agentstack_sdk/types.py

@@ -0,0 +1,15 @@
+# Copyright 2025 © BeeAI a Series of LF Projects, LLC
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    JsonValue: TypeAlias = list["JsonValue"] | dict[str, "JsonValue"] | str | bool | int | float | None
+    JsonDict: TypeAlias = dict[str, JsonValue]
+else:
+    from typing import Union
+
+    from typing_extensions import TypeAliasType
+
+    JsonValue = TypeAliasType("JsonValue", "Union[dict[str, JsonValue], list[JsonValue], str, int, float, bool, None]")  # noqa: UP007
+    JsonDict = TypeAliasType("JsonDict", "dict[str, JsonValue]")

agentstack_sdk/util/__init__.py

@@ -0,0 +1,4 @@
+# Copyright 2025 © BeeAI a Series of LF Projects, LLC
+# SPDX-License-Identifier: Apache-2.0
+
+from .resource_context import *