csp-bot 2.0.0__tar.gz → 2.0.2__tar.gz

{csp_bot-2.0.0 → csp_bot-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: csp-bot
-Version: 2.0.0
+Version: 2.0.2
 Summary: Reactive chat bot framework
 Project-URL: Repository, https://github.com/Point72/csp-bot
 Project-URL: Homepage, https://github.com/Point72/csp-bot
@@ -12,19 +12,18 @@ Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Requires-Dist: beautifulsoup4
 Requires-Dist: ccflow>=0.5.2
 Requires-Dist: chatom>=0.2.0
 Requires-Dist: croniter
-Requires-Dist: csp-gateway<2.7,>=2.5
+Requires-Dist: csp-gateway<4,>=2.5
 Requires-Dist: csp<1,>=0.9
 Requires-Dist: dateparser
 Requires-Dist: hydra-core
@@ -32,11 +31,17 @@ Requires-Dist: pandas
 Requires-Dist: pydantic>=2
 Provides-Extra: agent
 Requires-Dist: chatom[agent]>=0.2.0; extra == 'agent'
+Requires-Dist: pydantic-ai>=2.42; extra == 'agent'
+Provides-Extra: claude-agent
+Requires-Dist: chatom[agent]>=0.2.0; extra == 'claude-agent'
+Requires-Dist: claude-agent-sdk>=0.2.152; extra == 'claude-agent'
+Requires-Dist: pydantic-ai>=2.42; extra == 'claude-agent'
 Provides-Extra: develop
 Requires-Dist: build; extra == 'develop'
 Requires-Dist: bump-my-version; extra == 'develop'
 Requires-Dist: chatom[agent]>=0.2.0; extra == 'develop'
 Requires-Dist: check-dist; extra == 'develop'
+Requires-Dist: claude-agent-sdk>=0.2.152; extra == 'develop'
 Requires-Dist: codespell; extra == 'develop'
 Requires-Dist: csp-adapter-discord<0.3,>=0.2; extra == 'develop'
 Requires-Dist: csp-adapter-slack<0.5,>=0.4; extra == 'develop'

{csp_bot-2.0.0 → csp_bot-2.0.2}/csp_bot/__init__.py

@@ -11,7 +11,7 @@ Key features:
 - Support for Slack, Symphony, and Discord
 """
 
-__version__ = "2.0.0"
+__version__ = "2.0.2"
 
 # Re-export chatom types for convenience
 from chatom import Channel, Message, User

{csp_bot-2.0.0 → csp_bot-2.0.2}/csp_bot/bot.py

@@ -435,7 +435,7 @@ class Bot(GatewayModule):
         active_backends = self._active_backends()
         for model in command_models:
             try:
-                command = model.command()
+                command = model.create_command()
             except TypeError:
                 log.critical(f"Incomplete command type - implement all abstract methods: {model.command}")
                 raise
@@ -1053,7 +1053,13 @@ class Bot(GatewayModule):
             return None
 
         # Look up session by the bot response ID
-        session = AgentCommand._sessions.get_by_response_id(ref_id)
+        source_id = msg.author.id if msg.author else msg.author_id or ""
+        session = AgentCommand._sessions.get_by_response_id(
+            ref_id,
+            user_id=source_id,
+            channel_id=channel_id,
+            backend=backend,
+        )
         if session is None:
             return None
 

{csp_bot-2.0.0 → csp_bot-2.0.2}/csp_bot/commands/__init__.py

@@ -32,13 +32,7 @@ from .legacy import LegacyCommandAdapter
 from .schedule import ScheduleCommand, ScheduleCommandModel
 from .status import StatusCommand, StatusCommandModel
 
-try:
-    from .agent import AgentCommand
-except ImportError:
-    pass
-
 __all__ = (
-    "AgentCommand",
     "BaseCommand",
     "BaseCommandModel",
     "BotInfo",
@@ -66,3 +60,11 @@ __all__ = (
     "get_registered_commands",
     "mention_user",
 )
+
+try:
+    from .agent import AgentCommand, AgentCommandModel
+    from .claude_agent import ClaudeAgentCommand
+
+    __all__ += ("AgentCommand", "AgentCommandModel", "ClaudeAgentCommand")
+except ImportError:
+    pass

{csp_bot-2.0.0 → csp_bot-2.0.2}/csp_bot/commands/agent.py

@@ -21,34 +21,33 @@ from abc import abstractmethod
 from collections.abc import Sequence
 from concurrent.futures import Future, ThreadPoolExecutor
 from dataclasses import dataclass, field
-from datetime import datetime, timedelta, timezone
+from datetime import UTC, datetime, timedelta
 from typing import Any, ClassVar
 
 from chatom import Channel, Message
 from chatom.backend import BackendBase
 from chatom.format import Format, convert_format
 
-from csp_bot.commands.base import BaseCommand, ReplyCommand
+from csp_bot.commands.base import BaseCommand, BaseCommandModel, ReplyCommand
 from csp_bot.persistence import InMemoryStateStore, StateStore
 from csp_bot.structs import BotCommand
 
 try:
     from chatom.agent import BackendToolset
     from chatom.agent.toolset import AccessPolicy
-    from pydantic_ai import Agent
-    from pydantic_ai.messages import ModelMessage, ModelMessagesTypeAdapter
+    from pydantic_ai.messages import ModelMessagesTypeAdapter
 except ImportError as e:
     raise ImportError("AgentCommand requires the 'agent' extra. Install with: pip install csp-bot[agent]") from e
 
 log = logging.getLogger(__name__)
 
-__all__ = ("AgentCommand",)
+__all__ = ("AgentCommand", "AgentCommandModel")
 
 _executor = ThreadPoolExecutor(max_workers=4, thread_name_prefix="agent-cmd")
 
 
 def _utc_now() -> datetime:
-    return datetime.now(timezone.utc)
+    return datetime.now(UTC)
 
 
 @dataclass
@@ -56,19 +55,20 @@ class AgentSession:
     """Tracks a multi-turn conversation between a user and an agent command."""
 
     #: Bumped whenever the serialized layout in :meth:`to_dict` changes.
-    SCHEMA_VERSION: ClassVar[int] = 1
+    SCHEMA_VERSION: ClassVar[int] = 2
 
     user_id: str
     channel_id: str
+    backend: str
     command_name: str
-    message_history: list[ModelMessage] = field(default_factory=list)
+    message_history: list[Any] = field(default_factory=list)
     last_active: datetime = field(default_factory=_utc_now)
     bot_response_id: str | None = None  # ID of last bot message (for reply matching)
 
     @property
     def store_key(self) -> str:
-        """Deterministic key for this session: command:user:channel."""
-        return f"{self.command_name}:{self.user_id}:{self.channel_id}"
+        """Deterministic key for this session: command:backend:user:channel."""
+        return f"{self.command_name}:{self.backend}:{self.user_id}:{self.channel_id}"
 
     def touch(self) -> None:
         self.last_active = _utc_now()
@@ -82,12 +82,17 @@ class AgentSession:
         The pydantic-ai conversation history is serialized via
         :data:`ModelMessagesTypeAdapter` so it round-trips across processes.
         """
+        opaque_history = all(isinstance(item, dict) and item.get("type") == "claude-session" for item in self.message_history)
+        history_format = "opaque" if self.message_history and opaque_history else "pydantic-ai"
+        history = self.message_history if history_format == "opaque" else ModelMessagesTypeAdapter.dump_python(self.message_history, mode="json")
         return {
             "schema_version": self.SCHEMA_VERSION,
             "user_id": self.user_id,
             "channel_id": self.channel_id,
+            "backend": self.backend,
             "command_name": self.command_name,
-            "message_history": ModelMessagesTypeAdapter.dump_python(self.message_history, mode="json"),
+            "history_format": history_format,
+            "message_history": history,
             "last_active": self.last_active.isoformat(),
             "bot_response_id": self.bot_response_id,
         }
@@ -96,14 +101,23 @@ class AgentSession:
     def from_dict(cls, data: dict[str, Any]) -> AgentSession:
         """Reconstruct a session from :meth:`to_dict` output."""
         version = data.get("schema_version")
-        if version != cls.SCHEMA_VERSION:
-            raise ValueError(f"Unsupported AgentSession schema version: {version!r} (expected {cls.SCHEMA_VERSION})")
+        if version not in (1, cls.SCHEMA_VERSION):
+            raise ValueError(f"Unsupported AgentSession schema version: {version!r} (expected 1 or {cls.SCHEMA_VERSION})")
         last_active = data.get("last_active")
+        history_format = data.get("history_format", "pydantic-ai")
+        raw_history = data.get("message_history") or []
+        if history_format == "opaque":
+            message_history = list(raw_history)
+        elif history_format == "pydantic-ai":
+            message_history = list(ModelMessagesTypeAdapter.validate_python(raw_history))
+        else:
+            raise ValueError(f"Unsupported agent history format: {history_format!r}")
         return cls(
             user_id=data["user_id"],
             channel_id=data["channel_id"],
+            backend=data.get("backend", ""),
             command_name=data["command_name"],
-            message_history=list(ModelMessagesTypeAdapter.validate_python(data.get("message_history") or [])),
+            message_history=message_history,
             last_active=datetime.fromisoformat(last_active) if last_active else _utc_now(),
             bot_response_id=data.get("bot_response_id"),
         )
@@ -138,7 +152,14 @@ class SessionStore:
                 return None
             return session
 
-    def get_by_response_id(self, response_id: str) -> AgentSession | None:
+    def get_by_response_id(
+        self,
+        response_id: str,
+        *,
+        user_id: str,
+        channel_id: str,
+        backend: str,
+    ) -> AgentSession | None:
         """Look up a session by the bot's response message ID (for replies)."""
         with self._lock:
             key = self.store.get(self.response_namespace, response_id)
@@ -148,6 +169,8 @@ class SessionStore:
             if session and session.is_expired(self._ttl):
                 self._remove_session(key, session)
                 return None
+            if session and (session.user_id != user_id or session.channel_id != channel_id or session.backend != backend):
+                return None
             return session
 
     def put(self, key: str, session: AgentSession) -> None:
@@ -198,10 +221,10 @@ class SessionStore:
 
 
 def _run_agent(
-    agent: Agent,
+    agent: Any,
     prompt: str | Sequence[Any],
     loop: asyncio.AbstractEventLoop | None = None,
-    message_history: Sequence[ModelMessage] | None = None,
+    message_history: Sequence[Any] | None = None,
 ) -> Any:
     """Run an agent on an event loop (for use in thread pool).
 
@@ -243,6 +266,8 @@ class AgentCommand(ReplyCommand):
     Example::
 
         class AskCommand(AgentCommand):
+            model_name = "github-copilot:claude-haiku-4.5"
+
             def command(self): return "ask"
             def name(self): return "Ask"
             def help(self): return "/ask <question> — Ask the AI (reply to continue)"
@@ -250,7 +275,7 @@ class AgentCommand(ReplyCommand):
             def build_agent(self, command):
                 toolset = self.build_toolset(command)
                 return Agent(
-                    "anthropic:claude-sonnet-4-6",
+                    self.get_model(),
                     toolsets=[toolset] if toolset else [],
                     instructions="You are a helpful assistant.",
                 )
@@ -264,6 +289,7 @@ class AgentCommand(ReplyCommand):
     _futures: ClassVar[dict[str, Future]] = {}
     _sessions: ClassVar[SessionStore] = SessionStore(ttl_seconds=900.0)
 
+    model_name: str = "claude-sonnet-4-6"
     # Configurable delay between polling checks (seconds)
     poll_interval: int = 2
     # Maximum time to wait for agent completion (seconds)
@@ -301,7 +327,9 @@ class AgentCommand(ReplyCommand):
     ]
 
     def __init__(self, *args, **kwargs):
-        pass
+        model_name = kwargs.pop("model_name", None)
+        if model_name is not None:
+            self.model_name = model_name
 
     @classmethod
     def set_backends(
@@ -329,8 +357,8 @@ class AgentCommand(ReplyCommand):
         cls._sessions = SessionStore(ttl_seconds=ttl, store=store)
 
     @abstractmethod
-    def build_agent(self, command: BotCommand) -> Agent:
-        """Return the pydantic-ai Agent to run for this command."""
+    def build_agent(self, command: BotCommand) -> Any:
+        """Return the agent or runner to use for this command."""
         ...
 
     @abstractmethod
@@ -392,12 +420,20 @@ class AgentCommand(ReplyCommand):
             block_dm_reads=True,
         )
 
-    def get_model(self, model_name: str = "claude-sonnet-4-6") -> Any:
+    def get_model(self, model_name: str | None = None) -> Any:
         """Return a model instance configured from environment variables.
 
-        Checks ANTHROPIC_AUTH_TOKEN / ANTHROPIC_API_KEY and ANTHROPIC_BASE_URL
-        to construct a properly-configured provider.
+        Fully qualified model names are resolved by PydanticAI. Bare model names
+        retain the Anthropic gateway configuration used by existing commands.
         """
+        if model_name is None:
+            model_name = self.model_name
+
+        if ":" in model_name:
+            from pydantic_ai.models import infer_model
+
+            return infer_model(model_name)
+
         from pydantic_ai.models.anthropic import AnthropicModel
         from pydantic_ai.providers.anthropic import AnthropicProvider
 
@@ -416,8 +452,8 @@ class AgentCommand(ReplyCommand):
         return messageml
 
     def _session_key(self, command: BotCommand) -> str:
-        """Key for session lookup: command:user:channel."""
-        return f"{self.command()}:{command.source.id}:{command.channel_id}"
+        """Key for session lookup: command:backend:user:channel."""
+        return f"{self.command()}:{command.backend}:{command.source.id}:{command.channel_id}"
 
     def _get_session(self, command: BotCommand) -> AgentSession | None:
         """Find an existing session — by reply reference or by user+channel."""
@@ -425,7 +461,12 @@ class AgentCommand(ReplyCommand):
         msg = command.message
         reply_to_id = getattr(msg, "reply_to_id", None) or (msg.reference.message_id if getattr(msg, "reference", None) else None)
         if reply_to_id:
-            session = self._sessions.get_by_response_id(reply_to_id)
+            session = self._sessions.get_by_response_id(
+                reply_to_id,
+                user_id=command.source.id,
+                channel_id=command.channel_id,
+                backend=command.backend,
+            )
             if session:
                 session.touch()
                 self._sessions.put(session.store_key, session)
@@ -446,6 +487,7 @@ class AgentCommand(ReplyCommand):
             user_id=command.source.id,
             channel_id=command.channel_id,
             command_name=self.command(),
+            backend=command.backend,
         )
         self._sessions.put(self._session_key(command), session)
         return session
@@ -736,3 +778,14 @@ class AgentCommand(ReplyCommand):
         future replies to that message can be routed back to this session.
         """
         self._sessions.update_response_id(session_key, response_message_id)
+
+
+class AgentCommandModel(BaseCommandModel):
+    """Model for registering an agent command with model configuration."""
+
+    command: type[AgentCommand]
+    model_name: str = "claude-sonnet-4-6"
+
+    def create_command(self) -> AgentCommand:
+        """Create the configured agent command."""
+        return self.command(model_name=self.model_name)

{csp_bot-2.0.0 → csp_bot-2.0.2}/csp_bot/commands/base.py

@@ -136,3 +136,7 @@ class BaseCommandModel(BaseModel):
     """Model for registering commands via configuration."""
 
     command: type[BaseCommand]
+
+    def create_command(self) -> BaseCommand:
+        """Create the configured command."""
+        return self.command()

csp_bot-2.0.2/csp_bot/commands/claude_agent.py

@@ -0,0 +1,206 @@
+import base64
+import json
+from collections.abc import Sequence
+from dataclasses import dataclass
+from typing import Any, cast
+
+from chatom.agent import BackendToolset
+
+from csp_bot.commands.agent import AgentCommand
+
+
+@dataclass(frozen=True)
+class ClaudeRunResult:
+    output: str
+    session_id: str
+
+    def all_messages(self) -> list[dict[str, str]]:
+        """Return session state in the form persisted by AgentCommand."""
+        return [{"type": "claude-session", "session_id": self.session_id}]
+
+
+class ClaudeAgentRunner:
+    """Run Claude with Chatom tools and resumable sessions."""
+
+    def __init__(
+        self,
+        toolset: BackendToolset,
+        *,
+        model: str | None = None,
+        query_fn: Any = None,
+    ) -> None:
+        if query_fn is None:
+            from claude_agent_sdk import query
+
+            query_fn = query
+        self._toolset = toolset
+        self._model = model
+        self._query = query_fn
+
+    async def run(
+        self,
+        prompt: str | Sequence[Any],
+        *,
+        session_id: str | None = None,
+        message_history: Sequence[Any] | None = None,
+    ) -> ClaudeRunResult:
+        """Run one turn and return its output and resumable session ID."""
+        from claude_agent_sdk import ResultError, ResultMessage
+
+        if session_id is None and message_history:
+            state = message_history[-1]
+            if isinstance(state, dict) and state.get("type") == "claude-session":
+                session_id = state.get("session_id")
+
+        final_result = None
+        options = await build_claude_options(
+            self._toolset,
+            model=self._model,
+            resume=session_id,
+        )
+        claude_prompt = _claude_prompt(prompt)
+        try:
+            async for message in self._query(prompt=claude_prompt, options=options):
+                if isinstance(message, ResultMessage):
+                    final_result = message
+        except ResultError as error:
+            if final_result is None:
+                raise RuntimeError("; ".join(error.errors) or str(error)) from error
+
+        if final_result is None:
+            raise RuntimeError("Claude query completed without a result")
+        if final_result.is_error or final_result.subtype != "success":
+            errors = final_result.errors or ([final_result.result] if final_result.result else [])
+            raise RuntimeError("; ".join(errors) or f"Claude query failed: {final_result.subtype}")
+
+        return ClaudeRunResult(
+            output=final_result.result or "",
+            session_id=final_result.session_id,
+        )
+
+
+class ClaudeAgentCommand(AgentCommand):
+    """Agent command backed by the Claude Agent SDK."""
+
+    def build_agent(self, command: Any) -> ClaudeAgentRunner:
+        toolset = self.build_toolset(command)
+        if toolset is None:
+            raise RuntimeError("Claude agent command requires a connected backend")
+        return ClaudeAgentRunner(toolset, model=self.model_name)
+
+
+def _claude_prompt(prompt: str | Sequence[Any]) -> Any:
+    if isinstance(prompt, str):
+        return prompt
+
+    from pydantic_ai import BinaryContent
+
+    content = []
+    for part in prompt:
+        if isinstance(part, str):
+            content.append({"type": "text", "text": part})
+        elif isinstance(part, BinaryContent) and part.media_type.startswith("image/"):
+            content.append(
+                {
+                    "type": "image",
+                    "source": {
+                        "type": "base64",
+                        "media_type": part.media_type,
+                        "data": base64.b64encode(part.data).decode("ascii"),
+                    },
+                }
+            )
+        else:
+            raise TypeError(f"Unsupported Claude prompt content: {type(part).__name__}")
+
+    async def message_stream():
+        yield {
+            "type": "user",
+            "message": {
+                "role": "user",
+                "content": content,
+            },
+        }
+
+    return message_stream()
+
+
+def _handler(toolset: BackendToolset, name: str, toolset_tool: Any = None):
+    async def call(tool_args: dict[str, Any]) -> dict[str, Any]:
+        call_tool = getattr(toolset, "call", None)
+        if call_tool is not None:
+            result = await call_tool(name, tool_args)
+        else:
+            validated_args = toolset_tool.args_validator.validate_python(tool_args)
+            result = await toolset.call_tool(name, validated_args, cast(Any, None), toolset_tool)
+        return {
+            "content": [
+                {
+                    "type": "text",
+                    "text": json.dumps(result),
+                }
+            ]
+        }
+
+    return call
+
+
+async def build_claude_tools(toolset: BackendToolset) -> list[Any]:
+    """Convert a Chatom backend toolset to Claude SDK MCP tools."""
+    from claude_agent_sdk import tool
+
+    tool_definitions = getattr(toolset, "tool_definitions", None)
+    if tool_definitions is not None:
+        definitions = [(definition, None) for definition in tool_definitions().values()]
+    else:
+        toolset_tools = await toolset.get_tools(cast(Any, None))
+        definitions = [(toolset_tool.tool_def, toolset_tool) for toolset_tool in toolset_tools.values()]
+
+    tools = []
+    for definition, toolset_tool in definitions:
+        tools.append(
+            tool(
+                definition.name,
+                definition.description or definition.name,
+                definition.parameters_json_schema,
+            )(_handler(toolset, definition.name, toolset_tool))
+        )
+    return tools
+
+
+async def build_claude_mcp_server(toolset: BackendToolset) -> Any:
+    """Build an in-process Claude SDK MCP server for a Chatom backend."""
+    from claude_agent_sdk import create_sdk_mcp_server
+
+    return create_sdk_mcp_server(
+        name=toolset.id or "chatom",
+        tools=await build_claude_tools(toolset),
+    )
+
+
+async def build_claude_options(
+    toolset: BackendToolset,
+    *,
+    model: str | None = None,
+    resume: str | None = None,
+) -> Any:
+    """Configure Claude to use only the supplied Chatom tools."""
+    from claude_agent_sdk import ClaudeAgentOptions, create_sdk_mcp_server
+
+    server_name = toolset.id or "chatom"
+    tools = await build_claude_tools(toolset)
+    allowed_tools = [f"mcp__{server_name}__{tool.name}" for tool in tools]
+    return ClaudeAgentOptions(
+        tools=[],
+        allowed_tools=allowed_tools,
+        mcp_servers={
+            server_name: create_sdk_mcp_server(
+                name=server_name,
+                tools=tools,
+            )
+        },
+        strict_mcp_config=True,
+        setting_sources=[],
+        model=model,
+        resume=resume,
+    )

{csp_bot-2.0.0 → csp_bot-2.0.2}/csp_bot/commands/executor.py

@@ -200,7 +200,7 @@ def _run_async_function(
         future = asyncio.run_coroutine_threadsafe(fn(ctx), loop)
         result = future.result(timeout=timeout)
         return [_coerce_response(result, backend)]
-    except asyncio.TimeoutError:
+    except TimeoutError:
         log.error(f"Async command timed out after {timeout}s")
         raise
     except Exception:
@@ -258,7 +258,7 @@ def _run_async_generator(
             loop,
         )
         return future.result(timeout=timeout)
-    except asyncio.TimeoutError:
+    except TimeoutError:
         log.error(f"Async generator command timed out after {timeout}s")
         raise
     except Exception:

{csp_bot-2.0.0 → csp_bot-2.0.2}/csp_bot/commands/framework.py

@@ -158,3 +158,7 @@ class CommandModel(BaseModel):
     """
 
     command: type[Command] = Command
+
+    def create_command(self) -> Command:
+        """Create the configured command."""
+        return self.command()

{csp_bot-2.0.0 → csp_bot-2.0.2}/csp_bot/commands/status.py

@@ -3,7 +3,7 @@
 Displays system and bot status information using FormattedMessage.
 """
 
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from getpass import getuser
 from logging import getLogger
 from socket import gethostname
@@ -52,7 +52,7 @@ class StatusCommand(ReplyCommand):
         proc = psutil.Process()
 
         rows = [
-            {"Metric": "Now", "Value": str(datetime.now(timezone.utc))},
+            {"Metric": "Now", "Value": str(datetime.now(UTC))},
             {"Metric": "Backends", "Value": ", ".join(self._adapters)},
             {"Metric": "CPU", "Value": f"{psutil.cpu_percent()}%"},
             {"Metric": "Memory", "Value": f"{mem.percent}%"},

{csp_bot-2.0.0 → csp_bot-2.0.2}/csp_bot/persistence.py

@@ -10,7 +10,7 @@ import threading
 import uuid
 from collections.abc import Iterable
 from dataclasses import dataclass
-from datetime import datetime, timedelta, timezone
+from datetime import UTC, datetime, timedelta
 from pickle import HIGHEST_PROTOCOL, dumps, loads
 from typing import Any, Protocol
 from urllib.parse import quote, unquote
@@ -28,19 +28,19 @@ __all__ = (
 
 
 def _utc_now() -> datetime:
-    return datetime.now(timezone.utc)
+    return datetime.now(UTC)
 
 
 def _to_utc(value: datetime | None) -> datetime | None:
     if value is None:
         return None
     if value.tzinfo is None:
-        return value.replace(tzinfo=timezone.utc)
-    return value.astimezone(timezone.utc)
+        return value.replace(tzinfo=UTC)
+    return value.astimezone(UTC)
 
 
 def _sort_datetime(value: datetime | None) -> datetime:
-    return _to_utc(value) or datetime.max.replace(tzinfo=timezone.utc)
+    return _to_utc(value) or datetime.max.replace(tzinfo=UTC)
 
 
 @dataclass(frozen=True)