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

quraite/__init__.py

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

quraite/adapters/__init__.py

@@ -1,134 +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}")
+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.langchain_adapter import LangchainAdapter
+    from quraite.adapters.langchain_server_adapter import LangchainServerAdapter
+    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",
+    "LangchainAdapter",
+    "LangchainServerAdapter",
+    "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 == "LangchainAdapter":
+        try:
+            from quraite.adapters.langchain_adapter import LangchainAdapter
+
+            return LangchainAdapter
+        except ImportError as e:
+            raise ImportError(
+                f"Failed to import {name}. Please install the 'langchain' optional dependency: pip install 'quraite[langchain]'"
+            ) from e
+
+    elif name == "LangchainServerAdapter":
+        try:
+            from quraite.adapters.langchain_server_adapter import LangchainServerAdapter
+
+            return LangchainServerAdapter
+        except ImportError as e:
+            raise ImportError(
+                f"Failed to import {name}. Please install the 'langchain' optional dependency: pip install 'quraite[langchain]'"
+            ) 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

@@ -1,159 +1,157 @@
-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),
-        )
+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 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."""
+        with self.tracer.start_as_current_span("agno_invocation") as span:
+            trace_id = span.get_span_context().trace_id
+            logger.debug(
+                "Starting traced invocation (session_id=%s) with trace_id=%s",
+                session_id,
+                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_spans_by_trace_id(
+            trace_id
+        )
+
+        if trace_readable_spans:
+            logger.info(
+                "Retrieved %d spans for trace_id=%s",
+                len(trace_readable_spans),
+                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", trace_id)
+
+        return AgentInvocationResponse(
+            agent_trace=agent_trace,
+            agent_trajectory=agent_trace.to_agent_trajectory(framework=Framework.AGNO),
+        )