add anthropic and open_response LLM format support

Signed-off-by: Jintao Zhang <zhangjintao9020@gmail.com>

README.md

@@ -124,7 +124,7 @@ Generate a starter config:
 amcp init
 ```
 
-Example:
+Example (OpenAI-compatible API):
 
 ```toml
 [servers.exa]
@@ -136,14 +136,35 @@ args = ["-y", "@some/mcp-server"]
 env.API_KEY = "your-key"
 
 [chat]
-base_url = "https://inference.baseten.co/v1"
-model = "DeepSeek-V3.1-Terminus"
+api_type = "openai"  # "openai" (default) or "anthropic"
+base_url = "https://api.openai.com/v1"
+model = "gpt-4o"
 api_key = "your-api-key"
 mcp_tools_enabled = true
 write_tool_enabled = true  # Enable/disable built-in write_file tool
 edit_tool_enabled = true   # Enable/disable built-in edit_file tool
 ```
 
+Example (OpenAI Responses API):
+
+```toml
+[chat]
+api_type = "openai_responses"
+model = "gpt-4o"
+api_key = "your-api-key"
+```
+
+Example (Anthropic Claude):
+
+```toml
+[chat]
+api_type = "anthropic"
+model = "claude-sonnet-4-20250514"
+api_key = "your-anthropic-api-key"  # or set ANTHROPIC_API_KEY env var
+```
+
+To use Anthropic, install with: `pip install amcp[anthropic]`
+
 ## Development
 
 ### Setup Development Environment

pyproject.toml

@@ -21,6 +21,17 @@ dependencies = [
   "agent-client-protocol>=0.7.0",
 ]
 
+[project.optional-dependencies]
+anthropic = ["anthropic>=0.40.0"]
+dev = [
+  "pytest>=8.0.0",
+  "pytest-cov>=4.1.0",
+  "pytest-asyncio>=0.23.0",
+  "ruff>=0.3.0",
+  "mypy>=1.8.0",
+  "anthropic>=0.40.0",
+]
+
 [project.scripts]
 amcp = "amcp.cli:app"
 amcp-acp = "amcp.acp_agent:main"
@@ -36,14 +47,6 @@ line-length = 120
 select = ["E", "F", "UP", "B", "SIM", "I"]
 ignore = ["E501"]
 
-[project.optional-dependencies]
-dev = [
-  "pytest>=8.0.0",
-  "pytest-cov>=4.1.0",
-  "ruff>=0.3.0",
-  "mypy>=1.8.0",
-]
-
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 addopts = "-v --cov=src/amcp --cov-report=term-missing"

src/amcp/agent.py

@@ -425,15 +425,18 @@ class Agent:
     ) -> str:
         """Run chat with tools and enhanced tracking."""
         cfg = load_config()
-        base = _resolve_base_url(self.agent_spec.base_url or None, cfg.chat)
-        model = self.agent_spec.model or (cfg.chat.model if cfg.chat else "") or "DeepSeek-V3.1-Terminus"
-        key = _resolve_api_key(None, cfg.chat)
-        client = _make_client(base, key)
+
+        # Use new LLM client abstraction
+        from .llm import create_llm_client
+        llm_client = create_llm_client(cfg.chat)
+
+        # Override model if specified in agent spec
+        if self.agent_spec.model:
+            llm_client.model = self.agent_spec.model
 
         # Override the chat function to add our tracking
         return await self._enhanced_chat_with_tools(
-            client=client,
-            model=model,
+            llm_client=llm_client,
             messages=messages,
             tools=tools,
             tool_registry=tool_registry,
@@ -443,8 +446,7 @@ class Agent:
 
     async def _enhanced_chat_with_tools(
         self,
-        client,
-        model: str,
+        llm_client,
         messages: list[dict[str, Any]],
         tools: list[dict[str, Any]],
         tool_registry: dict[str, Any],
@@ -463,25 +465,17 @@ class Agent:
             self.step_count = step + 1
             status.update(f"[bold]Agent {self.name}[/bold] - Step {self.step_count}/{max_steps}")
 
-            resp = client.chat.completions.create(
-                model=model,
-                messages=messages,
-                tools=tools,
-                tool_choice="auto",
-                stream=False,
-            )
-
-            msg = resp.choices[0].message
-            tool_calls = getattr(msg, "tool_calls", None)
+            resp = llm_client.chat(messages=messages, tools=tools)
 
-            if tool_calls:
+            if resp.tool_calls:
+                tool_calls = resp.tool_calls
                 used_tools = True
                 status.update(f"[bold]Agent {self.name}[/bold] - Executing {len(tool_calls)} tool(s)...")
 
                 # Check if any tool should be limited before processing
                 limited_tools = []
                 for tc in tool_calls:
-                    tool_name = tc.function.name
+                    tool_name = tc["name"]
                     if self._should_limit_tool_calls(tool_name):
                         limited_tools.append(tool_name)
 
@@ -499,12 +493,8 @@ class Agent:
                     )
                     # Get a final response from the LLM with the current messages
                     try:
-                        final_resp = client.chat.completions.create(
-                            model=model,
-                            messages=messages,
-                            stream=False,
-                        )
-                        final_text = final_resp.choices[0].message.content or ""
+                        final_resp = llm_client.chat(messages=messages)
+                        final_text = final_resp.content or ""
                         status.update(f"[bold]Agent {self.name}[/bold] - ✅ Complete")
                         return final_text
                     except Exception as e:
@@ -514,14 +504,15 @@ class Agent:
                 # Process tool calls with Live UI
                 with LiveUI() as live_ui:
                     for tc in tool_calls:
-                        tool_name = tc.function.name
-                        args = json.loads(tc.function.arguments or "{}")
+                        tool_name = tc["name"]
+                        tool_id = tc["id"]
+                        args = json.loads(tc["arguments"] or "{}")
 
                         # Record tool call
                         tool_call_record = {
                             "step": self.step_count,
                             "tool": tool_name,
-                            "args": tc.function.arguments,
+                            "args": tc["arguments"],
                             "timestamp": datetime.now().isoformat(),
                         }
                         self.tool_calls_history.append(tool_call_record)
@@ -577,12 +568,12 @@ class Agent:
                             messages.append(
                                 {
                                     "role": "assistant",
-                                    "content": msg.content or "",
+                                    "content": resp.content or "",
                                     "tool_calls": [
                                         {
-                                            "id": tc.id,
+                                            "id": tool_id,
                                             "type": "function",
-                                            "function": {"name": tool_name, "arguments": tc.function.arguments or "{}"},
+                                            "function": {"name": tool_name, "arguments": tc["arguments"] or "{}"},
                                         }
                                     ],
                                 }
@@ -590,7 +581,7 @@ class Agent:
                             messages.append(
                                 {
                                     "role": "tool",
-                                    "tool_call_id": tc.id,
+                                    "tool_call_id": tool_id,
                                     "name": tool_name,
                                     "content": truncated_result,
                                 }
@@ -602,7 +593,7 @@ class Agent:
                             messages.append(
                                 {
                                     "role": "tool",
-                                    "tool_call_id": tc.id,
+                                    "tool_call_id": tool_id,
                                     "name": tool_name,
                                     "content": error_msg,
                                 }
@@ -611,7 +602,7 @@ class Agent:
                 continue
             else:
                 # No tool calls, return the response
-                final_text = msg.content or ""
+                final_text = resp.content or ""
                 if stream and not used_tools:
                     # For streaming, we'll implement a simple version
                     pass

src/amcp/config.py

@@ -32,6 +32,7 @@ class ChatConfig:
     base_url: str | None = None
     model: str | None = None
     api_key: str | None = None
+    api_type: str | None = None  # "openai" (default) or "anthropic"
     # Tool calling settings
     tool_loop_limit: int | None = None
     default_max_lines: int | None = None
@@ -88,6 +89,7 @@ def _decode_chat(raw: Mapping[str, object] | None) -> ChatConfig | None:
     base_url = raw.get("base_url")
     model = raw.get("model")
     api_key = raw.get("api_key")
+    api_type = raw.get("api_type")
     tool_loop_limit = raw.get("tool_loop_limit")
     default_max_lines = raw.get("default_max_lines")
     read_roots = raw.get("read_roots")
@@ -99,6 +101,7 @@ def _decode_chat(raw: Mapping[str, object] | None) -> ChatConfig | None:
         base_url=str(base_url) if base_url is not None else None,
         model=str(model) if model is not None else None,
         api_key=str(api_key) if api_key is not None else None,
+        api_type=str(api_type) if api_type is not None else None,
         tool_loop_limit=int(tool_loop_limit) if tool_loop_limit is not None else None,
         default_max_lines=int(default_max_lines) if default_max_lines is not None else None,
         read_roots=[str(p) for p in (read_roots or [])] if read_roots is not None else None,
@@ -141,6 +144,8 @@ def _encode_chat(c: ChatConfig | None) -> dict | None:
         out["model"] = c.model
     if c.api_key:
         out["api_key"] = c.api_key
+    if c.api_type:
+        out["api_type"] = c.api_type
     if c.tool_loop_limit is not None:
         out["tool_loop_limit"] = int(c.tool_loop_limit)
     if c.default_max_lines is not None:

src/amcp/llm.py

@@ -0,0 +1,208 @@
+"""LLM client abstraction supporting OpenAI, OpenAI Responses, and Anthropic APIs."""
+
+from __future__ import annotations
+
+import json
+import os
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Any
+
+from .config import ChatConfig
+
+
+@dataclass
+class LLMResponse:
+    """Unified response from LLM."""
+    content: str | None
+    tool_calls: list[dict[str, Any]] | None = None
+    stop_reason: str | None = None
+
+
+class BaseLLMClient(ABC):
+    """Base class for LLM clients."""
+
+    @abstractmethod
+    def chat(self, messages: list[dict], tools: list[dict] | None = None, **kwargs) -> LLMResponse:
+        """Send chat request and return response."""
+        pass
+
+
+class OpenAIClient(BaseLLMClient):
+    """OpenAI Chat Completions API client."""
+
+    def __init__(self, base_url: str, api_key: str | None, model: str):
+        from openai import OpenAI
+        self.client = OpenAI(base_url=base_url, api_key=api_key or "")
+        self.model = model
+
+    def chat(self, messages: list[dict], tools: list[dict] | None = None, **kwargs) -> LLMResponse:
+        params = {"model": self.model, "messages": messages, "stream": False, **kwargs}
+        if tools:
+            params["tools"] = tools
+            params["tool_choice"] = "auto"
+
+        resp = self.client.chat.completions.create(**params)
+        msg = resp.choices[0].message
+
+        tool_calls = None
+        if hasattr(msg, "tool_calls") and msg.tool_calls:
+            tool_calls = [
+                {"id": tc.id, "name": tc.function.name, "arguments": tc.function.arguments}
+                for tc in msg.tool_calls
+            ]
+
+        return LLMResponse(content=msg.content, tool_calls=tool_calls, stop_reason=resp.choices[0].finish_reason)
+
+
+class OpenAIResponsesClient(BaseLLMClient):
+    """OpenAI Responses API client."""
+
+    def __init__(self, base_url: str, api_key: str | None, model: str):
+        from openai import OpenAI
+        self.client = OpenAI(base_url=base_url, api_key=api_key or "")
+        self.model = model
+
+    def chat(self, messages: list[dict], tools: list[dict] | None = None, **kwargs) -> LLMResponse:
+        # Convert tools to Responses API format
+        resp_tools = None
+        if tools:
+            resp_tools = [
+                {"type": "function", "name": t["function"]["name"], "description": t["function"].get("description", ""), "parameters": t["function"].get("parameters", {})}
+                for t in tools
+            ]
+
+        params = {"model": self.model, "input": messages}
+        if resp_tools:
+            params["tools"] = resp_tools
+
+        resp = self.client.responses.create(**params)
+
+        # Parse response
+        content_parts = []
+        tool_calls = []
+
+        for item in resp.output:
+            if item.type == "message":
+                for block in item.content:
+                    if block.type == "output_text":
+                        content_parts.append(block.text)
+            elif item.type == "function_call":
+                tool_calls.append({"id": item.call_id, "name": item.name, "arguments": item.arguments})
+
+        return LLMResponse(
+            content="\n".join(content_parts) if content_parts else None,
+            tool_calls=tool_calls if tool_calls else None,
+            stop_reason=resp.stop_reason,
+        )
+
+
+class AnthropicClient(BaseLLMClient):
+    """Anthropic Claude API client."""
+
+    def __init__(self, api_key: str | None, model: str, base_url: str | None = None):
+        try:
+            from anthropic import Anthropic
+        except ImportError:
+            raise ImportError("anthropic package not installed. Run: pip install anthropic")
+
+        kwargs = {"api_key": api_key or os.environ.get("ANTHROPIC_API_KEY", "")}
+        if base_url:
+            kwargs["base_url"] = base_url
+        self.client = Anthropic(**kwargs)
+        self.model = model
+
+    def chat(self, messages: list[dict], tools: list[dict] | None = None, **kwargs) -> LLMResponse:
+        # Convert OpenAI format to Anthropic format
+        system_prompt = None
+        anthropic_messages = []
+
+        for msg in messages:
+            role = msg["role"]
+            content = msg.get("content", "")
+
+            if role == "system":
+                system_prompt = content
+            elif role == "user":
+                anthropic_messages.append({"role": "user", "content": content})
+            elif role == "assistant":
+                if "tool_calls" in msg and msg["tool_calls"]:
+                    blocks = []
+                    if content:
+                        blocks.append({"type": "text", "text": content})
+                    for tc in msg["tool_calls"]:
+                        blocks.append({
+                            "type": "tool_use",
+                            "id": tc["id"],
+                            "name": tc["function"]["name"],
+                            "input": json.loads(tc["function"]["arguments"] or "{}"),
+                        })
+                    anthropic_messages.append({"role": "assistant", "content": blocks})
+                else:
+                    anthropic_messages.append({"role": "assistant", "content": content})
+            elif role == "tool":
+                anthropic_messages.append({
+                    "role": "user",
+                    "content": [{"type": "tool_result", "tool_use_id": msg.get("tool_call_id"), "content": content}],
+                })
+
+        # Convert tools to Anthropic format
+        anthropic_tools = None
+        if tools:
+            anthropic_tools = [
+                {"name": t["function"]["name"], "description": t["function"].get("description", ""), "input_schema": t["function"].get("parameters", {"type": "object", "properties": {}})}
+                for t in tools
+            ]
+
+        params = {"model": self.model, "messages": anthropic_messages, "max_tokens": kwargs.get("max_tokens", 4096)}
+        if system_prompt:
+            params["system"] = system_prompt
+        if anthropic_tools:
+            params["tools"] = anthropic_tools
+
+        resp = self.client.messages.create(**params)
+
+        content_parts = []
+        tool_calls = []
+
+        for block in resp.content:
+            if block.type == "text":
+                content_parts.append(block.text)
+            elif block.type == "tool_use":
+                tool_calls.append({"id": block.id, "name": block.name, "arguments": json.dumps(block.input)})
+
+        return LLMResponse(
+            content="\n".join(content_parts) if content_parts else None,
+            tool_calls=tool_calls if tool_calls else None,
+            stop_reason=resp.stop_reason,
+        )
+
+
+def create_llm_client(cfg: ChatConfig | None) -> BaseLLMClient:
+    """Create appropriate LLM client based on config.
+    
+    api_type options:
+    - "openai" (default): OpenAI Chat Completions API
+    - "openai_responses": OpenAI Responses API
+    - "anthropic": Anthropic Claude API
+    """
+    api_type = (cfg.api_type if cfg else None) or os.environ.get("AMCP_API_TYPE", "openai")
+    model = (cfg.model if cfg else None) or "gpt-4o"
+
+    if api_type == "anthropic":
+        api_key = (cfg.api_key if cfg else None) or os.environ.get("ANTHROPIC_API_KEY")
+        base_url = cfg.base_url if cfg else None
+        return AnthropicClient(api_key=api_key, model=model, base_url=base_url)
+    elif api_type == "openai_responses":
+        base_url = (cfg.base_url if cfg else None) or os.environ.get("AMCP_OPENAI_BASE", "https://api.openai.com/v1")
+        if not base_url.endswith("/v1"):
+            base_url = base_url.rstrip("/") + "/v1"
+        api_key = (cfg.api_key if cfg else None) or os.environ.get("OPENAI_API_KEY")
+        return OpenAIResponsesClient(base_url=base_url, api_key=api_key, model=model)
+    else:
+        # Default: OpenAI Chat Completions
+        base_url = (cfg.base_url if cfg else None) or os.environ.get("AMCP_OPENAI_BASE", "https://api.openai.com/v1")
+        if not base_url.endswith("/v1"):
+            base_url = base_url.rstrip("/") + "/v1"
+        api_key = (cfg.api_key if cfg else None) or os.environ.get("OPENAI_API_KEY")
+        return OpenAIClient(base_url=base_url, api_key=api_key, model=model)

tests/test_llm.py

@@ -0,0 +1,72 @@
+"""Tests for LLM client abstraction."""
+
+import pytest
+
+from amcp.config import ChatConfig
+from amcp.llm import LLMResponse, create_llm_client, OpenAIClient, OpenAIResponsesClient, AnthropicClient
+
+
+class TestLLMResponse:
+    """Tests for LLMResponse dataclass."""
+
+    def test_basic_response(self):
+        resp = LLMResponse(content="Hello, world!")
+        assert resp.content == "Hello, world!"
+        assert resp.tool_calls is None
+
+    def test_response_with_tool_calls(self):
+        tool_calls = [{"id": "1", "name": "test", "arguments": "{}"}]
+        resp = LLMResponse(content=None, tool_calls=tool_calls, stop_reason="tool_use")
+        assert resp.tool_calls == tool_calls
+
+
+class TestCreateLLMClient:
+    """Tests for create_llm_client factory."""
+
+    def test_default_creates_openai_client(self):
+        cfg = ChatConfig(model="gpt-4o", api_key="test-key")
+        client = create_llm_client(cfg)
+        assert isinstance(client, OpenAIClient)
+
+    def test_openai_type_creates_openai_client(self):
+        cfg = ChatConfig(api_type="openai", model="gpt-4o", api_key="test-key")
+        client = create_llm_client(cfg)
+        assert isinstance(client, OpenAIClient)
+
+    def test_openai_responses_type(self):
+        cfg = ChatConfig(api_type="openai_responses", model="gpt-4o", api_key="test-key")
+        client = create_llm_client(cfg)
+        assert isinstance(client, OpenAIResponsesClient)
+
+    def test_anthropic_type(self):
+        try:
+            cfg = ChatConfig(api_type="anthropic", model="claude-sonnet-4-20250514", api_key="test-key")
+            client = create_llm_client(cfg)
+            assert isinstance(client, AnthropicClient)
+        except ImportError:
+            pytest.skip("anthropic package not installed")
+
+    def test_none_config_uses_defaults(self):
+        client = create_llm_client(None)
+        assert isinstance(client, OpenAIClient)
+
+
+class TestOpenAIClient:
+    def test_client_creation(self):
+        client = OpenAIClient(base_url="https://api.openai.com/v1", api_key="test-key", model="gpt-4o")
+        assert client.model == "gpt-4o"
+
+
+class TestOpenAIResponsesClient:
+    def test_client_creation(self):
+        client = OpenAIResponsesClient(base_url="https://api.openai.com/v1", api_key="test-key", model="gpt-4o")
+        assert client.model == "gpt-4o"
+
+
+class TestAnthropicClient:
+    def test_client_creation(self):
+        try:
+            client = AnthropicClient(api_key="test-key", model="claude-sonnet-4-20250514")
+            assert client.model == "claude-sonnet-4-20250514"
+        except ImportError:
+            pytest.skip("anthropic package not installed")

uv.lock

@@ -30,9 +30,14 @@ dependencies = [
 ]
 
 [package.optional-dependencies]
+anthropic = [
+    { name = "anthropic" },
+]
 dev = [
+    { name = "anthropic" },
     { name = "mypy" },
     { name = "pytest" },
+    { name = "pytest-asyncio" },
     { name = "pytest-cov" },
     { name = "ruff" },
 ]
@@ -40,12 +45,15 @@ dev = [
 [package.metadata]
 requires-dist = [
     { name = "agent-client-protocol", specifier = ">=0.7.0" },
+    { name = "anthropic", marker = "extra == 'anthropic'", specifier = ">=0.40.0" },
+    { name = "anthropic", marker = "extra == 'dev'", specifier = ">=0.40.0" },
     { name = "mcp", extras = ["cli"] },
     { name = "mypy", marker = "extra == 'dev'", specifier = ">=1.8.0" },
     { name = "openai", specifier = ">=1.52.0" },
     { name = "prompt-toolkit", specifier = ">=3.0.0" },
     { name = "pydantic", specifier = ">=2.7" },
     { name = "pytest", marker = "extra == 'dev'", specifier = ">=8.0.0" },
+    { name = "pytest-asyncio", marker = "extra == 'dev'", specifier = ">=0.23.0" },
     { name = "pytest-cov", marker = "extra == 'dev'", specifier = ">=4.1.0" },
     { name = "pyyaml", specifier = ">=6.0" },
     { name = "rich", specifier = ">=13.7.0" },
@@ -64,6 +72,25 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643 },
 ]
 
+[[package]]
+name = "anthropic"
+version = "0.75.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "distro" },
+    { name = "docstring-parser" },
+    { name = "httpx" },
+    { name = "jiter" },
+    { name = "pydantic" },
+    { name = "sniffio" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/04/1f/08e95f4b7e2d35205ae5dcbb4ae97e7d477fc521c275c02609e2931ece2d/anthropic-0.75.0.tar.gz", hash = "sha256:e8607422f4ab616db2ea5baacc215dd5f028da99ce2f022e33c7c535b29f3dfb", size = 439565 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/60/1c/1cd02b7ae64302a6e06724bf80a96401d5313708651d277b1458504a1730/anthropic-0.75.0-py3-none-any.whl", hash = "sha256:ea8317271b6c15d80225a9f3c670152746e88805a7a61e14d4a374577164965b", size = 388164 },
+]
+
 [[package]]
 name = "anyio"
 version = "4.12.0"
@@ -349,6 +376,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", hash = "sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2", size = 20277 },
 ]
 
+[[package]]
+name = "docstring-parser"
+version = "0.17.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b2/9d/c3b43da9515bd270df0f80548d9944e389870713cc1fe2b8fb35fe2bcefd/docstring_parser-0.17.0.tar.gz", hash = "sha256:583de4a309722b3315439bb31d64ba3eebada841f2e2cee23b99df001434c912", size = 27442 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/55/e2/2537ebcff11c1ee1ff17d8d0b6f4db75873e3b0fb32c2d4a2ee31ecb310a/docstring_parser-0.17.0-py3-none-any.whl", hash = "sha256:cf2569abd23dce8099b300f9b4fa8191e9582dda731fd533daf54c4551658708", size = 36896 },
+]
+
 [[package]]
 name = "h11"
 version = "0.16.0"
@@ -904,6 +940,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801 },
 ]
 
+[[package]]
+name = "pytest-asyncio"
+version = "1.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/90/2c/8af215c0f776415f3590cac4f9086ccefd6fd463befeae41cd4d3f193e5a/pytest_asyncio-1.3.0.tar.gz", hash = "sha256:d7f52f36d231b80ee124cd216ffb19369aa168fc10095013c6b014a34d3ee9e5", size = 50087 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e5/35/f8b19922b6a25bc0880171a2f1a003eaeb93657475193ab516fd87cac9da/pytest_asyncio-1.3.0-py3-none-any.whl", hash = "sha256:611e26147c7f77640e6d0a92a38ed17c3e9848063698d5c93d5aa7aa11cebff5", size = 15075 },
+]
+
 [[package]]
 name = "pytest-cov"
 version = "7.0.0"