quraite 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

quraite/adapters/flowise_adapter.py

@@ -1,11 +1,12 @@
 import asyncio
 import json
-from typing import Any, Dict, List, Optional, Union
+from typing import Any
 
 import aiohttp
 
 from quraite.adapters.base import BaseAdapter
 from quraite.logger import get_logger
+from quraite.schema.invoke import InvokeInput, InvokeOutput
 from quraite.schema.message import (
     AgentMessage,
     AssistantMessage,
@@ -13,14 +14,13 @@ from quraite.schema.message import (
     ToolCall,
     ToolMessage,
 )
-from quraite.schema.response import AgentInvocationResponse
 
 logger = get_logger(__name__)
 
 
 class FlowiseAdapter(BaseAdapter):
     def __init__(
-        self, api_url: str, headers: Optional[Dict[str, str]] = None, timeout: int = 60
+        self, api_url: str, headers: dict[str, str] | None = None, timeout: int = 60
     ):
         self.api_url = api_url
         self.headers = headers or {}
@@ -28,8 +28,6 @@ class FlowiseAdapter(BaseAdapter):
 
         if "Content-Type" not in self.headers:
             self.headers["Content-Type"] = "application/json"
-
-        self.headers["Content-Type"] = "application/json"
         logger.info(
             "FlowiseAdapter initialized (api_url=%s, timeout=%s)", self.api_url, timeout
         )
@@ -38,15 +36,15 @@ class FlowiseAdapter(BaseAdapter):
 
     def _convert_api_output_to_messages(
         self,
-        response: Dict[str, Any],
-        request_messages: Optional[List[AgentMessage]] = None,
-    ) -> List[AgentMessage]:
+        response: dict[str, Any],
+        request_messages: list[AgentMessage] | None = None,
+    ) -> list[AgentMessage]:
         logger.debug(
             "Converting Flowise response to messages (has_agent_node=%s)",
             bool(response.get("agentFlowExecutedData")),
         )
 
-        def _append_text(content_obj: Any, bucket: List[MessageContentText]) -> None:
+        def _append_text(content_obj: Any, bucket: list[MessageContentText]) -> None:
             if isinstance(content_obj, str):
                 if content_obj:
                     bucket.append(MessageContentText(type="text", text=content_obj))
@@ -60,7 +58,7 @@ class FlowiseAdapter(BaseAdapter):
 
         agent_node = self._find_agentflow_node(response)
         if agent_node:
-            converted: List[AgentMessage] = []
+            converted: list[AgentMessage] = []
             messages_section = agent_node.get("input")
             raw_messages = []
             if isinstance(messages_section, dict):
@@ -68,7 +66,7 @@ class FlowiseAdapter(BaseAdapter):
                 if isinstance(potential_messages, list):
                     raw_messages = potential_messages
 
-            latest_turn: List[Dict[str, Any]] = []
+            latest_turn: list[dict[str, Any]] = []
             for raw in reversed(raw_messages):
                 if not isinstance(raw, dict):
                     continue
@@ -83,9 +81,9 @@ class FlowiseAdapter(BaseAdapter):
                     continue
 
                 if role == "assistant":
-                    text_content: List[MessageContentText] = []
+                    text_content: list[MessageContentText] = []
                     _append_text(raw.get("content"), text_content)
-                    tool_calls_list: List[ToolCall] = []
+                    tool_calls_list: list[ToolCall] = []
                     tool_calls = raw.get("tool_calls")
                     if isinstance(tool_calls, list):
                         for call in tool_calls:
@@ -128,7 +126,7 @@ class FlowiseAdapter(BaseAdapter):
 
             output_section = agent_node.get("output")
             if isinstance(output_section, dict):
-                final_segments: List[MessageContentText] = []
+                final_segments: list[MessageContentText] = []
                 _append_text(output_section.get("content"), final_segments)
 
                 if final_segments:
@@ -144,8 +142,8 @@ class FlowiseAdapter(BaseAdapter):
         return []
 
     def _find_agentflow_node(
-        self, response: Dict[str, Any]
-    ) -> Optional[Dict[str, Any]]:
+        self, response: dict[str, Any]
+    ) -> dict[str, Any] | None:
         executed_data = response.get("agentFlowExecutedData")
         if not isinstance(executed_data, list):
             return None
@@ -160,39 +158,15 @@ class FlowiseAdapter(BaseAdapter):
 
         return None
 
-    def _prepare_input(self, input: List[AgentMessage]) -> str:
-        logger.debug("Preparing Flowise input from %d messages", len(input))
-        if not input or input[-1].role != "user":
-            logger.error("Flowise 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("Flowise 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("Flowise input missing text content")
-            raise ValueError("No text content found in user message")
-
-        logger.debug("Prepared Flowise input (text_length=%d)", len(text_content))
-        return text_content
-
     async def _aapi_call(
         self,
         question: str,
-        history: Optional[List[Dict[str, Any]]] = None,
-        override_config: Optional[Dict[str, Any]] = None,
-        form: Optional[Dict[str, Any]] = None,
-        human_input: Optional[str] = None,
+        history: list[dict[str, Any]] | None = None,
+        override_config: dict[str, Any] | None = None,
+        form: dict[str, Any] | None = None,
+        human_input: str | None = None,
         **kwargs,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         logger.debug(
             "Calling Flowise API (history=%s, form=%s, human_input=%s)",
             bool(history),
@@ -236,40 +210,25 @@ class FlowiseAdapter(BaseAdapter):
                 logger.exception("Flowise 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 Flowise agent and converts to List[AgentMessage]."""
-        logger.info(
-            "Flowise ainvoke called (session_id=%s, input_messages=%d)",
-            session_id,
-            len(input),
-        )
-        agent_input = self._prepare_input(input)
+    async def ainvoke(self, input: InvokeInput) -> InvokeOutput:
+        """Invoke Flowise agent and return response."""
+        logger.info("Flowise ainvoke called (session_id=%s)", input.session_id)
 
         try:
             agent_output = await self._aapi_call(
-                question=agent_input,
-                override_config={"sessionId": session_id} if session_id else None,
+                question=input.user_message_str(),
+                override_config=(
+                    {"sessionId": input.session_id} if input.session_id else None
+                ),
             )
-            logger.debug(
-                "Flowise API returned payload with keys: %s", list(agent_output.keys())
+            agent_trajectory = self._convert_api_output_to_messages(
+                agent_output, [input.user_message]
             )
-        except Exception as e:
-            logger.exception("Flowise ainvoke failed during API call")
-            raise RuntimeError(f"Error calling Flowise endpoint: {e}") from e
-
-        try:
-            agent_trajectory = self._convert_api_output_to_messages(agent_output, input)
             logger.info(
                 "Flowise conversion produced %d trajectory messages",
                 len(agent_trajectory),
             )
-            return AgentInvocationResponse(
-                agent_trajectory=agent_trajectory,
-            )
+            return InvokeOutput(agent_trajectory=agent_trajectory)
         except Exception as e:
-            logger.exception("Flowise ainvoke failed while processing response")
-            raise RuntimeError(f"Error processing Flowise response: {e}") from e
+            logger.exception("Error calling Flowise endpoint")
+            raise RuntimeError(f"Error calling Flowise endpoint: {e}") from e

quraite/adapters/google_adk_adapter.py

@@ -1,5 +1,4 @@
 import uuid
-from typing import List, Union
 
 from google.adk.agents import Agent
 from google.adk.apps.app import App
@@ -10,127 +9,62 @@ from google.genai import types
 from opentelemetry.trace import TracerProvider
 
 from quraite.adapters.base import BaseAdapter
+from quraite.constants.framework import Framework
 from quraite.logger import get_logger
-from quraite.schema.message import AgentMessage
-from quraite.schema.response import AgentInvocationResponse
-from quraite.tracing.constants import Framework
+from quraite.schema.invoke import InvokeInput, InvokeOutput
 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
-    """
+    """Google ADK adapter for Agent (requires tracing)."""
 
     def __init__(
         self,
         agent: Agent,
+        *,
+        tracer_provider: TracerProvider | None = None,
         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
+        Initialize Google ADK adapter.
 
         Args:
-            agent: A Google ADK Agent instance
+            agent: Google ADK Agent instance
+            tracer_provider: TracerProvider from setup_tracing() (required)
+            agent_name: Agent name for metadata
             app_name: Application name for ADK runner
-            agent_name: Name of the agent for trajectory metadata
-            tracer_provider: TracerProvider for tracing (required)
+            user_id: User ID for session management
+            session_service: Session service for multi-turn conversations
         """
-        logger.debug(
-            "Initializing GoogleADKAdapter (agent_name=%s, app_name=%s)",
-            agent_name,
-            app_name,
-        )
-        self._init_tracing(tracer_provider, required=True)
+        if tracer_provider is None:
+            raise ValueError(
+                "Google ADK adapter requires tracing. Use setup_tracing([Framework.GOOGLE_ADK]) first."
+            )
 
         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")
+        self.app = App(name=app_name, root_agent=agent)
+        self.runner = Runner(app=self.app, session_service=session_service)
+        self._init_tracer(tracer_provider)
+        logger.info("GoogleADKAdapter initialized")
 
-    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())
+    async def ainvoke(self, input: InvokeInput) -> InvokeOutput:
+        """Invoke Google ADK agent and return response with trace."""
+        logger.info("Google ADK ainvoke called (session_id=%s)", input.session_id)
+        session_id = input.session_id or str(uuid.uuid4())
 
         try:
-            return await self._ainvoke_with_tracing(agent_input, session_id)
-
+            return await self._ainvoke_with_tracing(
+                input.user_message_str(), session_id
+            )
         except Exception as e:
             logger.exception("Error invoking Google ADK agent")
             raise RuntimeError(f"Error invoking Google ADK agent: {e}") from e
@@ -139,7 +73,7 @@ class GoogleADKAdapter(BaseAdapter):
         self,
         agent_input: str,
         session_id: str,
-    ) -> AgentInvocationResponse:
+    ) -> InvokeOutput:
         """Execute ainvoke with tracing enabled."""
         logger.debug(
             "Starting Google ADK traced invocation (session_id=%s)",
@@ -203,7 +137,7 @@ class GoogleADKAdapter(BaseAdapter):
         else:
             logger.warning("No spans exported for Google ADK trace_id=%s", trace_id)
 
-        return AgentInvocationResponse(
+        return InvokeOutput(
             agent_trace=agent_trace,
             agent_trajectory=agent_trace.to_agent_trajectory(
                 framework=Framework.GOOGLE_ADK

quraite/adapters/http_adapter.py

@@ -5,14 +5,13 @@ 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
+from typing import Any
 
 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
+from quraite.schema.invoke import InvokeInput, InvokeOutput
 
 logger = get_logger(__name__)
 
@@ -49,7 +48,7 @@ class HttpAdapter(BaseAdapter):
     def __init__(
         self,
         url: str,
-        headers: Optional[Dict[str, str]] = None,
+        headers: dict[str, str] | None = None,
         timeout: float = 60.0,
         max_retries: int = 3,
         retry_delay: float = 1.0,
@@ -79,35 +78,29 @@ class HttpAdapter(BaseAdapter):
 
     def _serialize_request(
         self,
-        input: List[AgentMessage],
-        session_id: Union[str, None],
-    ) -> Dict[str, Any]:
+        input: InvokeInput,
+    ) -> 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
+            input: InvokeInput containing user_message and session_id
 
         Returns:
             Dictionary ready for JSON serialization
         """
         logger.debug(
-            "Serializing HTTP request (messages=%d, session_id=%s)",
-            len(input),
-            session_id,
+            "Serializing HTTP request (session_id=%s)",
+            input.session_id,
         )
-        return {
-            "input": [msg.model_dump(mode="json") for msg in input],
-            "session_id": session_id,
-        }
+        return input.model_dump(mode="json")
 
     async def _make_request_with_retry_async(
         self,
         method: str,
         url: str,
-        payload: Dict[str, Any],
-    ) -> Dict[str, Any]:
+        payload: dict[str, Any],
+    ) -> dict[str, Any]:
         """
         Make HTTP request with retry logic (asynchronous).
 
@@ -151,12 +144,14 @@ class HttpAdapter(BaseAdapter):
                 # Retry on network errors
                 last_exception = e
                 if attempt < self.max_retries - 1:
+                    import asyncio
+
                     delay = self.retry_delay * (2**attempt)
                     logger.warning(
                         "HTTP adapter retrying after network/connection error (retry_in=%.2fs)",
                         delay,
                     )
-                    await self._async_sleep(delay)
+                    await asyncio.sleep(delay)
                 else:
                     logger.error(
                         "Failed while connecting to the url %s after %d attempts. Last error: %s",
@@ -175,34 +170,24 @@ class HttpAdapter(BaseAdapter):
 
         raise 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:
+        input: InvokeInput,
+    ) -> InvokeOutput:
         """
         Asynchronously invoke the HTTP agent.
 
         Args:
-            input: List[AgentMessage] containing user_message
-            session_id: Optional conversation ID for maintaining context
+            input: InvokeInput containing user_message and session_id
 
         Returns:
-            AgentInvocationResponse: Response containing agent trace, trajectory, and final response.
+            InvokeOutput: Response containing agent trace and trajectory
         """
         logger.info(
-            "HTTP ainvoke called (session_id=%s, input_messages=%d)",
-            session_id,
-            len(input),
+            "HTTP ainvoke called (session_id=%s)",
+            input.session_id,
         )
-        payload = self._serialize_request(input, session_id)
+        payload = self._serialize_request(input)
         response_data = await self._make_request_with_retry_async(
             method="POST", url=self.url, payload=payload
         )
@@ -210,9 +195,7 @@ class HttpAdapter(BaseAdapter):
             "HTTP adapter received response keys: %s", list(response_data.keys())
         )
 
-        return AgentInvocationResponse.model_validate(
-            response_data.get("agent_response", {})
-        )
+        return InvokeOutput.model_validate(response_data)
 
     async def aclose(self):
         """Close async HTTP client."""
@@ -232,6 +215,7 @@ if __name__ == "__main__":
     import asyncio
     import json
 
+    from quraite.schema.invoke import InvokeInput
     from quraite.schema.message import MessageContentText, UserMessage
 
     async def test_http_adapter():
@@ -239,12 +223,12 @@ if __name__ == "__main__":
 
         try:
             response = await adapter.ainvoke(
-                input=[
-                    UserMessage(
+                input=InvokeInput(
+                    user_message=UserMessage(
                         content=[MessageContentText(text="What is 34354 - 54?")]
-                    )
-                ],
-                session_id="test",
+                    ),
+                    session_id="test",
+                )
             )
             print(response.agent_trajectory)
         except httpx.HTTPStatusError as e: