quraite 0.0.1__py3-none-any.whl

quraite/adapters/google_adk_adapter.py

@@ -0,0 +1,209 @@
+import uuid
+from typing import List, Union
+
+from google.adk.agents import Agent
+from google.adk.apps.app import App
+from google.adk.errors.already_exists_error import AlreadyExistsError
+from google.adk.runners import Runner
+from google.adk.sessions import BaseSessionService, InMemorySessionService
+from google.genai import types
+from opentelemetry.trace import TracerProvider
+
+from quraite.adapters.base import BaseAdapter
+from quraite.logger import get_logger
+from quraite.schema.message import AgentMessage
+from quraite.schema.response import AgentInvocationResponse
+from quraite.tracing.constants import QURAITE_ADAPTER_TRACE_PREFIX, Framework
+from quraite.tracing.trace import AgentSpan, AgentTrace
+
+logger = get_logger(__name__)
+
+
+class GoogleADKAdapter(BaseAdapter):
+    """
+    Google ADK adapter wrapper that converts any Google ADK agent
+    to a standardized callable interface (ainvoke) with tracing support.
+
+    This class wraps any Google ADK Agent and provides:
+    - Asynchronous invocation via ainvoke()
+    - OpenTelemetry tracing integration
+    - Session management for multi-turn conversations
+    """
+
+    def __init__(
+        self,
+        agent: Agent,
+        agent_name: str = "Google ADK Agent",
+        tracer_provider: TracerProvider = None,
+        app_name: str = "google_adk_agent",
+        user_id: str = str(uuid.uuid4()),
+        session_service: BaseSessionService = InMemorySessionService(),
+    ):
+        """
+        Initialize with a pre-configured Google ADK agent
+
+        Args:
+            agent: A Google ADK Agent instance
+            app_name: Application name for ADK runner
+            agent_name: Name of the agent for trajectory metadata
+            tracer_provider: TracerProvider for tracing (required)
+        """
+        logger.debug(
+            "Initializing GoogleADKAdapter (agent_name=%s, app_name=%s)",
+            agent_name,
+            app_name,
+        )
+        self._init_tracing(tracer_provider, required=True)
+
+        self.agent: Agent = agent
+        self.app_name = app_name
+        self.agent_name = agent_name
+        self.session_service = session_service
+        self.user_id = user_id
+        self.app = App(
+            name=app_name,
+            root_agent=agent,
+        )
+        self.runner = Runner(
+            app=self.app,
+            session_service=session_service,
+        )
+        logger.info("GoogleADKAdapter initialized successfully")
+
+    def _prepare_input(self, input: List[AgentMessage]) -> str:
+        """
+        Prepare input for Google ADK agent from List[Message].
+
+        Args:
+            input: List[Message] containing user_message
+
+        Returns:
+            str: User message text
+        """
+        logger.debug("Preparing Google ADK input from %d messages", len(input))
+        if not input or input[-1].role != "user":
+            logger.error("Google ADK input missing user message")
+            raise ValueError("No user message found in the input")
+
+        last_user_message = input[-1]
+        # Check if content list is not empty and has text
+        if not last_user_message.content:
+            logger.error("Google ADK user message missing content")
+            raise ValueError("User message has no content")
+
+        # Find the first text content item
+        text_content = None
+        for content_item in last_user_message.content:
+            if content_item.type == "text" and content_item.text:
+                text_content = content_item.text
+                break
+
+        if not text_content:
+            logger.error("Google ADK user message missing text content")
+            raise ValueError("No text content found in user message")
+
+        logger.debug("Prepared Google ADK input (text_length=%d)", len(text_content))
+        return text_content
+
+    async def ainvoke(
+        self,
+        input: List[AgentMessage],
+        session_id: Union[str, None] = None,
+    ) -> AgentInvocationResponse:
+        """
+        Asynchronous invocation method - invokes the Google ADK agent with tracing
+
+        Args:
+            input: List[AgentMessage] containing user_message
+            session_id: Optional conversation ID for maintaining context
+
+        Returns:
+            AgentInvocationResponse - response containing agent trace, trajectory, and final response.
+        """
+        logger.info(
+            "Google ADK ainvoke called (session_id=%s, input_messages=%d)",
+            session_id,
+            len(input),
+        )
+        agent_input = self._prepare_input(input)
+        session_id = session_id or str(uuid.uuid4())
+
+        try:
+            return await self._ainvoke_with_tracing(agent_input, session_id)
+
+        except Exception as e:
+            logger.exception("Error invoking Google ADK agent")
+            raise RuntimeError(f"Error invoking Google ADK agent: {e}") from e
+
+    async def _ainvoke_with_tracing(
+        self,
+        agent_input: str,
+        session_id: str,
+    ) -> AgentInvocationResponse:
+        """Execute ainvoke with tracing enabled."""
+        adapter_trace_id = f"{QURAITE_ADAPTER_TRACE_PREFIX}-{uuid.uuid4()}"
+        logger.debug(
+            "Starting Google ADK traced invocation (trace_id=%s, session_id=%s)",
+            adapter_trace_id,
+            session_id,
+        )
+
+        with self.tracer.start_as_current_span(name=adapter_trace_id):
+            # Create session if it doesn't exist
+            try:
+                await self.session_service.create_session(
+                    app_name=self.app_name,
+                    user_id=self.user_id,
+                    session_id=session_id,
+                )
+            except AlreadyExistsError:
+                logger.info("Session already exists: %s", session_id)
+            except Exception as e:
+                logger.exception("Error creating Google ADK session")
+                raise RuntimeError(f"Error creating session: {e}") from e
+
+            # Create content for ADK
+            content = types.Content(
+                role="user",
+                parts=[types.Part(text=agent_input)],
+            )
+
+            # Run async and consume events
+            events = self.runner.run_async(
+                new_message=content,
+                user_id=self.user_id,
+                session_id=session_id,
+            )
+
+            # Consume all events (tracing captures everything)
+            async for event in events:
+                pass  # Just consume events, tracing handles capture
+
+        # Get trace spans
+        trace_readable_spans = self.quraite_span_exporter.get_trace_by_testcase(
+            adapter_trace_id
+        )
+
+        if trace_readable_spans:
+            agent_trace = AgentTrace(
+                spans=[
+                    AgentSpan.from_readable_oi_span(span)
+                    for span in trace_readable_spans
+                ],
+            )
+            logger.info(
+                "Google ADK trace collected %d spans for trace_id=%s",
+                len(trace_readable_spans),
+                adapter_trace_id,
+            )
+        else:
+            logger.warning(
+                "No spans exported for Google ADK trace_id=%s", adapter_trace_id
+            )
+
+        return AgentInvocationResponse(
+            agent_trace=agent_trace,
+            agent_trajectory=agent_trace.to_agent_trajectory(
+                framework=Framework.GOOGLE_ADK
+            ),
+        )

quraite/adapters/http_adapter.py

@@ -0,0 +1,239 @@
+"""
+HTTP Adapter - Connects to remote agent servers via HTTP.
+
+This module provides a BaseAdapter implementation that calls remote agent
+servers via HTTP endpoints, enabling distributed agent evaluation.
+"""
+
+from typing import Any, Dict, List, Optional, Union
+
+import httpx
+
+from quraite.adapters.base import BaseAdapter
+from quraite.logger import get_logger
+from quraite.schema.message import AgentMessage
+from quraite.schema.response import AgentInvocationResponse
+
+logger = get_logger(__name__)
+
+
+class HttpAdapter(BaseAdapter):
+    """
+    HTTP adapter client that communicates with agent servers via HTTP.
+
+    This class implements the BaseAdapter interface and forwards adapter
+    requests to a HTTP agent server, handling serialization, network errors,
+    and retries.
+
+    Args:
+        url: The full URL of the remote agent endpoint (e.g., "http://localhost:8000/v1/agents/completions")
+        headers: Optional dictionary of HTTP headers to include in requests
+        timeout: Request timeout in seconds (default: 60)
+        max_retries: Maximum number of retry attempts (default: 3)
+        retry_delay: Initial retry delay in seconds (default: 1)
+
+    Example:
+        ```python
+        remote_agent = HttpAdapter(
+            url="http://localhost:8000/v1/agents/completions",
+            headers={"Authorization": "Bearer secret_key"}
+        )
+
+        result = remote_agent.ainvoke(
+            input=[UserMessage(...)],
+            session_id="conv_123"
+        )
+        ```
+    """
+
+    def __init__(
+        self,
+        url: str,
+        headers: Optional[Dict[str, str]] = None,
+        timeout: float = 60.0,
+        max_retries: int = 3,
+        retry_delay: float = 1.0,
+    ):
+        """Initialize the HTTP adapter client."""
+        self.url = url.rstrip("/")
+        self.headers = headers or {}
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self.retry_delay = retry_delay
+
+        # Create HTTP client with user-provided headers
+        # Always include Content-Type if not provided
+        client_headers = {"Content-Type": "application/json"}
+        client_headers.update(self.headers)
+
+        self.async_client = httpx.AsyncClient(
+            headers=client_headers,
+            timeout=self.timeout,
+        )
+        logger.info(
+            "HttpAdapter initialized (url=%s, timeout=%s, max_retries=%s)",
+            self.url,
+            self.timeout,
+            self.max_retries,
+        )
+
+    def _serialize_request(
+        self,
+        input: List[AgentMessage],
+        session_id: Union[str, None],
+    ) -> Dict[str, Any]:
+        """
+        Serialize invocation request to JSON-compatible dict.
+
+        Args:
+            input: List[AgentMessage] containing user_message
+            session_id: Optional conversation ID for maintaining context
+
+        Returns:
+            Dictionary ready for JSON serialization
+        """
+        logger.debug(
+            "Serializing HTTP request (messages=%d, session_id=%s)",
+            len(input),
+            session_id,
+        )
+        return {
+            "input": [msg.model_dump(mode="json") for msg in input],
+            "session_id": session_id,
+        }
+
+    async def _make_request_with_retry_async(
+        self,
+        method: str,
+        url: str,
+        payload: Dict[str, Any],
+    ) -> Dict[str, Any]:
+        """
+        Make HTTP request with retry logic (asynchronous).
+
+        Args:
+            method: HTTP method (POST)
+            url: Full URL of the endpoint
+            payload: Request payload
+
+        Returns:
+            Response data as dictionary
+
+        Raises:
+            httpx.HTTPError: If all retries fail
+            ValueError: If response format is invalid
+        """
+        last_exception = None
+
+        for attempt in range(self.max_retries):
+            try:
+                response = await self.async_client.request(
+                    method=method,
+                    url=url,
+                    json=payload,
+                )
+                response.raise_for_status()
+                logger.info(
+                    "HTTP request succeeded (status=%s, attempt=%d)",
+                    response.status_code,
+                    attempt + 1,
+                )
+                return response.json()
+
+            except httpx.HTTPStatusError as e:
+                # Don't retry on 4xx errors (client errors)
+                if 400 <= e.response.status_code < 500:
+                    error_detail = e.response.text
+                    logger.error(
+                        "HTTP adapter received 4xx response (status=%s, detail=%s)",
+                        e.response.status_code,
+                        error_detail,
+                    )
+                    raise ValueError(
+                        f"Agent server error ({e.response.status_code}): {error_detail}"
+                    ) from e
+
+                # Retry on 5xx errors
+                last_exception = e
+                if attempt < self.max_retries - 1:
+                    delay = self.retry_delay * (2**attempt)
+                    logger.warning(
+                        "HTTP adapter retrying after server error (status=%s, retry_in=%.2fs)",
+                        e.response.status_code,
+                        delay,
+                    )
+                    await self._async_sleep(delay)
+
+            except (httpx.ConnectError, httpx.TimeoutException) as e:
+                # Retry on network errors
+                last_exception = e
+                if attempt < self.max_retries - 1:
+                    delay = self.retry_delay * (2**attempt)
+                    logger.warning(
+                        "HTTP adapter retrying after network error (retry_in=%.2fs)",
+                        delay,
+                    )
+                    await self._async_sleep(delay)
+
+        # All retries failed
+        logger.exception(
+            "HTTP adapter failed after %d attempts (url=%s)",
+            self.max_retries,
+            self.url,
+        )
+        raise RuntimeError(
+            f"Failed to connect to agent server at {self.url} after "
+            f"{self.max_retries} attempts. Last error: {last_exception}"
+        ) from last_exception
+
+    @staticmethod
+    async def _async_sleep(seconds: float):
+        """Helper for async sleep."""
+        import asyncio
+
+        await asyncio.sleep(seconds)
+
+    async def ainvoke(
+        self,
+        input: List[AgentMessage],
+        session_id: Union[str, None],
+    ) -> AgentInvocationResponse:
+        """
+        Asynchronously invoke the HTTP agent.
+
+        Args:
+            input: List[AgentMessage] containing user_message
+            session_id: Optional conversation ID for maintaining context
+
+        Returns:
+            AgentInvocationResponse: Response containing agent trace, trajectory, and final response.
+        """
+        logger.info(
+            "HTTP ainvoke called (session_id=%s, input_messages=%d)",
+            session_id,
+            len(input),
+        )
+        payload = self._serialize_request(input, session_id)
+        response_data = await self._make_request_with_retry_async(
+            method="POST", url=self.url, payload=payload
+        )
+        logger.debug(
+            "HTTP adapter received response keys: %s", list(response_data.keys())
+        )
+
+        return AgentInvocationResponse.model_validate(
+            response_data.get("agent_response", {})
+        )
+
+    async def aclose(self):
+        """Close async HTTP client."""
+        await self.async_client.aclose()
+        logger.debug("HTTP adapter client closed")
+
+    async def __aenter__(self):
+        """Async context manager entry."""
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit."""
+        await self.aclose()

quraite/adapters/langflow_adapter.py

@@ -0,0 +1,192 @@
+import asyncio
+import json
+import uuid
+from typing import Any, Dict, List, Union
+
+import aiohttp
+
+from quraite.adapters.base import BaseAdapter
+from quraite.logger import get_logger
+from quraite.schema.message import (
+    AgentMessage,
+    AssistantMessage,
+    MessageContentText,
+    ToolCall,
+    ToolMessage,
+)
+from quraite.schema.response import AgentInvocationResponse
+
+logger = get_logger(__name__)
+
+
+class LangflowAdapter(BaseAdapter):
+    def __init__(self, api_url: str, x_api_key: str, timeout: int = 60):
+        self.api_url = api_url
+        self.x_api_key = x_api_key
+        self.headers = {"Content-Type": "application/json", "x-api-key": self.x_api_key}
+        self.timeout = timeout
+        logger.info(
+            "LangflowAdapter initialized (api_url=%s, timeout=%s)",
+            self.api_url,
+            timeout,
+        )
+
+    def _convert_api_output_to_messages(
+        self,
+        response: Dict[str, Any],
+    ) -> List[AgentMessage]:
+        logger.debug(
+            "Converting Langflow response (root_keys=%s)",
+            list(response.keys()),
+        )
+        content_blocks = response["outputs"][0]["outputs"][0]["results"]["message"][
+            "content_blocks"
+        ]
+        contents = content_blocks[0]["contents"]
+
+        # Assume everything sequential.
+        ai_trajectory: List[AgentMessage] = []
+        for step in contents:
+            if step["type"] == "text":
+                if step["header"]["title"] == "Input":
+                    continue
+                else:
+                    ai_trajectory.append(
+                        AssistantMessage(
+                            content=[
+                                MessageContentText(type="text", text=step["text"])
+                            ],
+                        )
+                    )
+            elif step["type"] == "tool_use":
+                tool_id = str(uuid.uuid4())
+                tool_input = step.get("tool_input", {})
+                if not isinstance(tool_input, dict):
+                    tool_input = {"value": tool_input}
+
+                # Create AssistantMessage with tool call
+                ai_trajectory.append(
+                    AssistantMessage(
+                        tool_calls=[
+                            ToolCall(
+                                id=tool_id,
+                                name=step["name"],
+                                arguments=tool_input,
+                            )
+                        ],
+                    )
+                )
+                # Create ToolMessage with tool result
+                tool_output = step.get("output", "")
+                ai_trajectory.append(
+                    ToolMessage(
+                        tool_name=step["name"],
+                        tool_call_id=tool_id,
+                        content=[
+                            MessageContentText(type="text", text=str(tool_output))
+                        ],
+                    )
+                )
+
+        logger.info(
+            "Converted Langflow response into %d trajectory messages",
+            len(ai_trajectory),
+        )
+        return ai_trajectory
+
+    def _prepare_input(self, input: List[AgentMessage]) -> str:
+        logger.debug("Preparing Langflow input from %d messages", len(input))
+        if not input or input[-1].role != "user":
+            logger.error("Langflow input missing user message")
+            raise ValueError("No user message found in the input")
+
+        last_user_message = input[-1]
+        if not last_user_message.content:
+            logger.error("Langflow input user message missing content")
+            raise ValueError("User message has no content")
+
+        text_content = None
+        for content_item in last_user_message.content:
+            if content_item.type == "text" and content_item.text:
+                text_content = content_item.text
+                break
+
+        if not text_content:
+            logger.error("Langflow input missing text content")
+            raise ValueError("No text content found in user message")
+
+        logger.debug("Prepared Langflow input (text_length=%d)", len(text_content))
+        return text_content
+
+    async def _aapi_call(
+        self,
+        query: str,
+        sessionId: str,
+    ) -> Dict[str, Any]:
+        payload = {
+            "output_type": "chat",
+            "input_type": "chat",
+            "input_value": query,
+            "session_id": sessionId,
+        }
+
+        async with aiohttp.ClientSession() as session:
+            try:
+                async with session.post(
+                    self.api_url,
+                    headers=self.headers,
+                    json=payload,
+                    timeout=aiohttp.ClientTimeout(total=self.timeout),
+                ) as response:
+                    response.raise_for_status()
+                    logger.info(
+                        "Langflow API call succeeded (status=%s)", response.status
+                    )
+                    return await response.json()
+
+            except (aiohttp.ClientError, asyncio.TimeoutError) as e:
+                logger.exception("Langflow API request failed")
+                raise aiohttp.ClientError(f"Async API request failed: {str(e)}") from e
+
+            except json.JSONDecodeError as e:
+                logger.exception("Langflow API response decoding failed")
+                raise ValueError(f"Failed to decode JSON response: {e}") from e
+
+    async def ainvoke(
+        self,
+        input: List[AgentMessage],
+        session_id: Union[str, None],
+    ) -> AgentInvocationResponse:
+        """Asynchronous invocation method - invokes the Langflow agent and converts to List[AgentMessage]."""
+        logger.info(
+            "Langflow ainvoke called (session_id=%s, input_messages=%d)",
+            session_id,
+            len(input),
+        )
+        agent_input = self._prepare_input(input)
+
+        try:
+            agent_output = await self._aapi_call(
+                query=agent_input,
+                sessionId=session_id if session_id else uuid.uuid4(),
+            )
+            logger.debug(
+                "Langflow API returned payload with top-level keys: %s",
+                list(agent_output.keys()),
+            )
+        except Exception as e:
+            logger.exception("Error calling Langflow endpoint")
+            raise RuntimeError(f"Error calling langflow endpoint: {e}") from e
+
+        try:
+            agent_trajectory = self._convert_api_output_to_messages(agent_output)
+            logger.info(
+                "Langflow conversion produced %d trajectory messages",
+                len(agent_trajectory),
+            )
+            return AgentInvocationResponse(
+                agent_trajectory=agent_trajectory,
+            )
+        except Exception as e:
+            logger.exception("Error processing Langflow response")
+            raise RuntimeError(f"Error processing langflow response: {e}") from e