quraite 0.0.1__py3-none-any.whl

quraite/__init__.py

@@ -0,0 +1,3 @@
+"""Quraite Python SDK"""
+
+__version__ = "0.6.0"

quraite/adapters/__init__.py

@@ -0,0 +1,134 @@
+from typing import TYPE_CHECKING
+
+from quraite.adapters.base import BaseAdapter, DummyAdapter
+from quraite.adapters.http_adapter import HttpAdapter
+
+if TYPE_CHECKING:
+    from quraite.adapters.agno_adapter import AgnoAdapter
+    from quraite.adapters.bedrock_agents_adapter import BedrockAgentsAdapter
+    from quraite.adapters.flowise_adapter import FlowiseAdapter
+    from quraite.adapters.google_adk_adapter import GoogleADKAdapter
+    from quraite.adapters.langflow_adapter import LangflowAdapter
+    from quraite.adapters.langgraph_adapter import LanggraphAdapter
+    from quraite.adapters.langgraph_server_adapter import LanggraphServerAdapter
+    from quraite.adapters.n8n_adapter import N8nAdapter
+    from quraite.adapters.openai_agents_adapter import OpenaiAgentsAdapter
+    from quraite.adapters.pydantic_ai_adapter import PydanticAIAdapter
+    from quraite.adapters.smolagents_adapter import SmolagentsAdapter
+
+
+__all__ = [
+    "AgnoAdapter",
+    "BaseAdapter",
+    "BedrockAgentsAdapter",
+    "DummyAdapter",
+    "FlowiseAdapter",
+    "GoogleADKAdapter",
+    "LangflowAdapter",
+    "LanggraphAdapter",
+    "LanggraphServerAdapter",
+    "N8nAdapter",
+    "OpenaiAgentsAdapter",
+    "PydanticAIAdapter",
+    "HttpAdapter",
+    "SmolagentsAdapter",
+]
+
+
+def __getattr__(name: str):
+    if name == "AgnoAdapter":
+        try:
+            from quraite.adapters.agno_adapter import AgnoAdapter
+
+            return AgnoAdapter
+        except ImportError as e:
+            raise ImportError(
+                f"Failed to import {name}. Please install the 'agno' optional dependency: pip install 'quraite[agno]'"
+            ) from e
+
+    elif name == "BedrockAgentsAdapter":
+        try:
+            from quraite.adapters.bedrock_agents_adapter import BedrockAgentsAdapter
+
+            return BedrockAgentsAdapter
+        except ImportError as e:
+            raise ImportError(
+                f"Failed to import {name}. Please install the 'bedrock-agents' optional dependency: pip install 'quraite[bedrock-agents]'"
+            ) from e
+
+    elif name == "FlowiseAdapter":
+        from quraite.adapters.flowise_adapter import FlowiseAdapter
+
+        return FlowiseAdapter
+
+    elif name == "GoogleADKAdapter":
+        try:
+            from quraite.adapters.google_adk_adapter import GoogleADKAdapter
+
+            return GoogleADKAdapter
+        except ImportError as e:
+            raise ImportError(
+                f"Failed to import {name}. Please install the 'google-adk' optional dependency: pip install 'quraite[google-adk]'"
+            ) from e
+
+    elif name == "LangflowAdapter":
+        from quraite.adapters.langflow_adapter import LangflowAdapter
+
+        return LangflowAdapter
+
+    elif name == "LanggraphAdapter":
+        try:
+            from quraite.adapters.langgraph_adapter import LanggraphAdapter
+
+            return LanggraphAdapter
+        except ImportError as e:
+            raise ImportError(
+                f"Failed to import {name}. Please install the 'langgraph' optional dependency: pip install 'quraite[langgraph]'"
+            ) from e
+
+    elif name == "LanggraphServerAdapter":
+        try:
+            from quraite.adapters.langgraph_server_adapter import LanggraphServerAdapter
+
+            return LanggraphServerAdapter
+        except ImportError as e:
+            raise ImportError(
+                f"Failed to import {name}. Please install the 'langgraph' optional dependency: pip install 'quraite[langgraph]'"
+            ) from e
+
+    elif name == "N8nAdapter":
+        from quraite.adapters.n8n_adapter import N8nAdapter
+
+        return N8nAdapter
+
+    elif name == "OpenaiAgentsAdapter":
+        try:
+            from quraite.adapters.openai_agents_adapter import OpenaiAgentsAdapter
+
+            return OpenaiAgentsAdapter
+        except ImportError as e:
+            raise ImportError(
+                f"Failed to import {name}. Please install the 'openai-agents' optional dependency: pip install 'quraite[openai-agents]'"
+            ) from e
+
+    elif name == "PydanticAIAdapter":
+        try:
+            from quraite.adapters.pydantic_ai_adapter import PydanticAIAdapter
+
+            return PydanticAIAdapter
+        except ImportError as e:
+            raise ImportError(
+                f"Failed to import {name}. Please install the 'pydantic-ai' optional dependency: pip install 'quraite[pydantic-ai]'"
+            ) from e
+
+    elif name == "SmolagentsAdapter":
+        try:
+            from quraite.adapters.smolagents_adapter import SmolagentsAdapter
+
+            return SmolagentsAdapter
+        except ImportError as e:
+            raise ImportError(
+                f"Failed to import {name}. Please install the 'smolagents' optional dependency: pip install 'quraite[smolagents]'"
+            ) from e
+
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

quraite/adapters/agno_adapter.py

@@ -0,0 +1,159 @@
+import uuid
+from typing import List, Union
+
+from agno.agent import Agent
+from agno.team import Team
+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 AgnoAdapter(BaseAdapter):
+    """
+    Agno adapter wrapper that converts any Agno agent or team
+    to a standardized callable interface (invoke) and converts the output to List[AgentMessage].
+
+    This class wraps any Agno Agent or Team and provides:
+    - Asynchronous invocation via ainvoke()
+    - Automatic conversion to List[AgentMessage] format
+    - Access to message history and traces
+    - Support for both single agents and multi-agent teams
+    """
+
+    def __init__(
+        self,
+        agent: Union[Agent, Team],
+        agent_name: str = "Agno Agent",
+        tracer_provider: TracerProvider = None,
+    ):
+        """
+        Initialize with a pre-configured Agno agent or team
+
+        Args:
+            agent: An Agno Agent or Team instance
+            agent_name: Name of the agent for trajectory metadata
+            tracer_provider: TracerProvider for tracing (required)
+        """
+        logger.debug("Initializing AgnoAdapter with agent_name=%s", agent_name)
+        self._init_tracing(tracer_provider, required=True)
+
+        self.agent: Union[Agent, Team] = agent
+        self.agent_name = agent_name
+        logger.info(
+            "AgnoAdapter initialized successfully (tracing_enabled=%s)",
+            bool(tracer_provider),
+        )
+
+    def _prepare_input(self, input: List[AgentMessage]) -> str:
+        """
+        Prepare input for Agno agent from List[AgentMessage].
+
+        Args:
+            input: List[AgentMessage] containing user_message
+
+        Returns:
+            str: User message text
+        """
+        logger.debug("Preparing input from %d messages", len(input))
+        if not input or input[-1].role != "user":
+            logger.error("Invalid input: no user message found")
+            raise ValueError("No user message found in the input")
+
+        last_user_message = input[-1]
+        if not last_user_message.content:
+            logger.error("User message has no 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("No text content found in user message")
+            raise ValueError("No text content found in user message")
+
+        logger.debug("Prepared input with text_content 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 Agno agent/team 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(
+            "ainvoke called (session_id=%s, input_messages=%d)", session_id, len(input)
+        )
+        agent_input = self._prepare_input(input)
+        session_id = session_id or "default"
+
+        try:
+            logger.debug("Invoking Agno agent with tracing (session_id=%s)", session_id)
+            return await self._ainvoke_with_tracing(agent_input, session_id)
+
+        except ValueError:
+            logger.exception("Invalid input during ainvoke")
+            raise
+        except Exception as e:
+            logger.exception("Unexpected error invoking Agno agent")
+            raise RuntimeError(f"Error invoking Agno 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 traced invocation (trace_id=%s, session_id=%s)",
+            adapter_trace_id,
+            session_id,
+        )
+
+        with self.tracer.start_as_current_span(name=adapter_trace_id):
+            # Run the agent/team
+            await self.agent.arun(agent_input, session_id=session_id)
+
+        # Get trace spans
+        trace_readable_spans = self.quraite_span_exporter.get_trace_by_testcase(
+            adapter_trace_id
+        )
+
+        if trace_readable_spans:
+            logger.info(
+                "Retrieved %d spans for trace_id=%s",
+                len(trace_readable_spans),
+                adapter_trace_id,
+            )
+            agent_trace = AgentTrace(
+                spans=[
+                    AgentSpan.from_readable_oi_span(span)
+                    for span in trace_readable_spans
+                ],
+            )
+        else:
+            logger.warning("No spans found for trace_id=%s", adapter_trace_id)
+
+        return AgentInvocationResponse(
+            agent_trace=agent_trace,
+            agent_trajectory=agent_trace.to_agent_trajectory(framework=Framework.AGNO),
+        )

quraite/adapters/base.py

@@ -0,0 +1,123 @@
+from abc import ABC, abstractmethod
+from typing import Any, List, Optional, Union
+
+from opentelemetry.trace import TracerProvider
+
+from quraite.schema.message import AgentMessage, AssistantMessage, MessageContentText
+from quraite.schema.response import AgentInvocationResponse
+from quraite.tracing.constants import QURAITE_TRACER_NAME
+from quraite.tracing.span_exporter import QuraiteInMemorySpanExporter
+from quraite.tracing.span_processor import QuraiteSimpleSpanProcessor
+
+
+class BaseAdapter(ABC):
+    """
+    Abstract base class for all adapter providers.
+
+    Subclasses must implement the asynchronous adapter method,
+    which take List[Message] and return agent Message outputs.
+
+    Methods:
+        ainvoke: Asynchronously invoke an agent call for the provided input.
+    """
+
+    tracer_provider: Optional[TracerProvider] = None
+    tracer: Optional[Any] = None
+    quraite_span_exporter: Optional[QuraiteInMemorySpanExporter] = None
+
+    def _init_tracing(
+        self,
+        tracer_provider: Optional[TracerProvider],
+        required: bool = False,
+    ) -> None:
+        """
+        Initialize tracing components from a TracerProvider.
+
+        Args:
+            tracer_provider: TracerProvider for tracing
+            span_exporter: SpanExporter for exporting spans
+            required: If True, raises ValueError when tracer_provider is None
+        """
+        if tracer_provider is None:
+            if required:
+                raise ValueError(
+                    "tracer_provider is required. "
+                    "Please provide a TracerProvider instance."
+                )
+            return
+
+        self.tracer_provider = tracer_provider
+        self.tracer = tracer_provider.get_tracer(QURAITE_TRACER_NAME)
+
+        # Find Quraite span exporter
+        quraite_span_exporter = next(
+            (
+                processor.span_exporter
+                for processor in tracer_provider._active_span_processor._span_processors
+                if isinstance(processor, QuraiteSimpleSpanProcessor)
+            ),
+            None,
+        )
+
+        if quraite_span_exporter is None:
+            raise ValueError(
+                "Quraite span exporter not found. "
+                "Please ensure QuraiteSimpleSpanProcessor is used in the tracer provider."
+            )
+
+        self.quraite_span_exporter = quraite_span_exporter
+
+    @abstractmethod
+    async def ainvoke(
+        self,
+        input: List[AgentMessage],
+        session_id: Union[str, None],
+    ) -> AgentInvocationResponse:
+        """
+        Asynchronously invoke the agent with the given input.
+
+        Args:
+            input (List[AgentMessage]): List of AgentMessage objects.
+            session_id (str or None): ID for conversation thread/context.
+
+        Returns:
+            AgentInvocationResponse: Response containing agent trace, trajectory, and final response.
+
+        Raises:
+            NotImplementedError: If not implemented by subclass.
+        """
+        raise NotImplementedError("Not implemented")
+
+
+class DummyAdapter(BaseAdapter):
+    """
+    A dummy implementation of BaseAdapter, used mainly for testing and scaffolding.
+    Always returns a fixed dummy response.
+
+    Methods:
+        ainvoke: Returns a static assistant message asynchronously.
+    """
+
+    async def ainvoke(
+        self,
+        input: Any,
+        session_id: Union[str, None],
+    ) -> AgentInvocationResponse:
+        """
+        Asynchronously returns a dummy assistant response.
+
+        Args:
+            input: Ignored.
+            session_id: Ignored.
+
+        Returns:
+            AgentInvocationResponse: Response containing agent trace, trajectory, and final response.
+        """
+
+        return AgentInvocationResponse(
+            agent_trajectory=[
+                AssistantMessage(
+                    content=[MessageContentText(text="Dummy response")],
+                )
+            ]
+        )