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

quraite/adapters/n8n_adapter.py

@@ -1,12 +1,13 @@
 import asyncio
 import json
 import uuid
-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,
@@ -14,14 +15,13 @@ from quraite.schema.message import (
     ToolCall,
     ToolMessage,
 )
-from quraite.schema.response import AgentInvocationResponse
 
 logger = get_logger(__name__)
 
 
 class N8nAdapter(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 {}
@@ -35,13 +35,13 @@ class N8nAdapter(BaseAdapter):
 
     def _convert_api_output_to_messages(
         self,
-        response: Dict[str, Any],
-    ) -> List[AgentMessage]:
+        response: dict[str, Any],
+    ) -> list[AgentMessage]:
         logger.debug(
             "Converting n8n response (steps=%d)",
             len(response[0].get("intermediateSteps", [])),
         )
-        messages: List[AgentMessage] = []
+        messages: list[AgentMessage] = []
         output = response[0]["output"]
         intermediateSteps = response[0]["intermediateSteps"]
 
@@ -52,10 +52,10 @@ class N8nAdapter(BaseAdapter):
                 )
             ]
 
-        def flush_messages(tool_calls_dict: Dict[str, Any]):
+        def flush_messages(tool_calls_dict: dict[str, Any]):
             nonlocal messages
-            tool_calls_list: List[ToolCall] = []
-            tool_results: List[ToolMessage] = []
+            tool_calls_list: list[ToolCall] = []
+            tool_results: list[ToolMessage] = []
 
             for tool_call_id, tool_call_dict in tool_calls_dict.items():
                 tool_name = tool_call_dict.get("name", "")
@@ -87,7 +87,7 @@ class N8nAdapter(BaseAdapter):
 
             messages.extend(tool_results)
 
-        current_step_tool_calls_dict: Dict[str, Any] = {}
+        current_step_tool_calls_dict: dict[str, Any] = {}
         for step in intermediateSteps:
             message_log = step.get("action", {}).get("messageLog", {})
             if message_log:
@@ -127,35 +127,11 @@ class N8nAdapter(BaseAdapter):
         )
         return messages
 
-    def _prepare_input(self, input: List[AgentMessage]) -> str:
-        logger.debug("Preparing n8n input from %d messages", len(input))
-        if not input or input[-1].role != "user":
-            logger.error("n8n 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("n8n 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("n8n user message missing text content")
-            raise ValueError("No text content found in user message")
-
-        logger.debug("Prepared n8n input (text_length=%d)", len(text_content))
-        return text_content
-
     async def _aapi_call(
         self,
         query: str,
         sessionId: str,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         payload = {
             "query": query,
             "sessionId": sessionId,
@@ -183,38 +159,18 @@ class N8nAdapter(BaseAdapter):
                 logger.exception("n8n 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:
-        logger.info(
-            "n8n 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 n8n agent and return response."""
+        logger.info("n8n ainvoke called (session_id=%s)", input.session_id)
 
         try:
             agent_output = await self._aapi_call(
-                query=agent_input,
-                sessionId=session_id if session_id else uuid.uuid4(),
-            )
-            logger.debug(
-                "n8n API returned payload keys: %s", list(agent_output[0].keys())
+                query=input.user_message_str(),
+                sessionId=input.session_id if input.session_id else str(uuid.uuid4()),
             )
+            agent_trajectory = self._convert_api_output_to_messages(agent_output)
+            logger.info("n8n produced %d trajectory messages", len(agent_trajectory))
+            return InvokeOutput(agent_trajectory=agent_trajectory)
         except Exception as e:
             logger.exception("Error calling n8n endpoint")
             raise RuntimeError(f"Error calling n8n endpoint: {e}") from e
-
-        try:
-            agent_trajectory = self._convert_api_output_to_messages(agent_output)
-            logger.info(
-                "n8n conversion produced %d trajectory messages", len(agent_trajectory)
-            )
-            return AgentInvocationResponse(
-                agent_trajectory=agent_trajectory,
-            )
-        except Exception as e:
-            logger.exception("Error processing n8n response")
-            raise RuntimeError(f"Error processing n8n response: {e}") from e

quraite/adapters/openai_agents_adapter.py

@@ -1,5 +1,4 @@
 import json
-from typing import Dict, List, Optional, Union
 
 from agents import (
     Agent,
@@ -16,7 +15,9 @@ from agents.memory import Session
 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.invoke import InvokeInput, InvokeOutput
 from quraite.schema.message import (
     AgentMessage,
     AssistantMessage,
@@ -25,38 +26,46 @@ from quraite.schema.message import (
     ToolCall,
     ToolMessage,
 )
-from quraite.schema.response import AgentInvocationResponse
-from quraite.tracing.constants import Framework
 from quraite.tracing.trace import AgentSpan, AgentTrace
 
 logger = get_logger(__name__)
 
 
 class OpenaiAgentsAdapter(BaseAdapter):
+    """OpenAI Agents adapter for Agent."""
+
     def __init__(
         self,
         agent: Agent,
+        *,
+        tracer_provider: TracerProvider | None = None,
         agent_name: str = "OpenAI Agents",
-        tracer_provider: Optional[TracerProvider] = None,
     ):
+        """
+        Initialize OpenAI Agents adapter.
+
+        Args:
+            agent: OpenAI Agent instance
+            tracer_provider: Optional TracerProvider from setup_tracing()
+            agent_name: Agent name for metadata
+        """
         self.agent = agent
-        self.sessions: Dict[str, Session] = {}
-        self._init_tracing(tracer_provider, required=False)
+        self.sessions: dict[str, Session] = {}
         self.agent_name = agent_name
+        self._init_tracer(tracer_provider)
         logger.info(
-            "OpenaiAgentsAdapter initialized (agent_name=%s, tracing_enabled=%s)",
-            agent_name,
-            bool(tracer_provider),
+            "OpenaiAgentsAdapter initialized (tracing=%s)", bool(tracer_provider)
         )
 
     def _convert_run_items_to_messages(
-        self, run_items: List[RunItem]
-    ) -> List[AgentMessage]:
+        self, run_items: list[RunItem]
+    ) -> list[AgentMessage]:
+        """Convert OpenAI run items to Quraite messages."""
         logger.debug("Converting %d OpenAI run items to messages", len(run_items))
-        messages: List[AgentMessage] = []
-        text_content: List[MessageContentText] = []
-        reasoning_content: List[MessageContentReasoning] = []
-        tool_calls: List[ToolCall] = []
+        messages: list[AgentMessage] = []
+        text_content: list[MessageContentText] = []
+        reasoning_content: list[MessageContentReasoning] = []
+        tool_calls: list[ToolCall] = []
 
         def flush_assistant_message():
             nonlocal text_content, reasoning_content, tool_calls
@@ -141,46 +150,13 @@ class OpenaiAgentsAdapter(BaseAdapter):
         logger.info("Converted OpenAI agent run into %d messages", len(messages))
         return messages
 
-    def _prepare_input(self, input: List[AgentMessage]) -> str:
-        logger.debug("Preparing OpenAI input from %d messages", len(input))
-        if not input or input[-1].role != "user":
-            logger.error("OpenAI 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("OpenAI 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("OpenAI user message missing text content")
-            raise ValueError("No text content found in user message")
-
-        logger.debug("Prepared OpenAI 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 OpenAI Agents agent and converts to List[AgentMessage]."""
+    async def ainvoke(self, input: InvokeInput) -> InvokeOutput:
+        """Invoke OpenAI Agents agent and return response."""
         try:
-            logger.info(
-                "OpenAI ainvoke called (session_id=%s, input_messages=%d)",
-                session_id,
-                len(input),
-            )
-            agent_input: Union[str, List[TResponseInputItem]] = self._prepare_input(
-                input
-            )
+            logger.info("OpenAI ainvoke called (session_id=%s)", input.session_id)
+            agent_input: str | list[TResponseInputItem] = input.user_message_str()
 
+            session_id = input.session_id or "default"
             if session_id not in self.sessions:
                 self.sessions[session_id] = SQLiteSession(session_id=session_id)
             session = self.sessions[session_id]
@@ -195,9 +171,9 @@ class OpenaiAgentsAdapter(BaseAdapter):
 
     async def _ainvoke_with_tracing(
         self,
-        agent_input: Union[str, List[TResponseInputItem]],
+        agent_input: str | list[TResponseInputItem],
         session: Session,
-    ) -> AgentInvocationResponse:
+    ) -> InvokeOutput:
         """Execute ainvoke with tracing enabled."""
         with self.tracer.start_as_current_span("openai_invocation") as span:
             trace_id = span.get_span_context().trace_id
@@ -234,7 +210,7 @@ class OpenaiAgentsAdapter(BaseAdapter):
                 trace_id,
             )
 
-        return AgentInvocationResponse(
+        return InvokeOutput(
             agent_trace=agent_trace,
             agent_trajectory=agent_trace.to_agent_trajectory(
                 framework=Framework.OPENAI_AGENTS
@@ -243,9 +219,9 @@ class OpenaiAgentsAdapter(BaseAdapter):
 
     async def _ainvoke_without_tracing(
         self,
-        agent_input: Union[str, List[TResponseInputItem]],
+        agent_input: str | list[TResponseInputItem],
         session: Session,
-    ) -> AgentInvocationResponse:
+    ) -> InvokeOutput:
         """Execute ainvoke without tracing."""
         result = await Runner.run(
             self.agent,
@@ -259,7 +235,7 @@ class OpenaiAgentsAdapter(BaseAdapter):
                 "OpenAI agent produced %d trajectory messages (no tracing)",
                 len(agent_trajectory),
             )
-            return AgentInvocationResponse(
+            return InvokeOutput(
                 agent_trajectory=agent_trajectory,
             )
         except Exception as exc:

quraite/adapters/pydantic_ai_adapter.py

@@ -1,4 +1,4 @@
-from typing import Any, List, Union
+from typing import Any
 
 from opentelemetry.trace import TracerProvider
 from pydantic_ai import Agent
@@ -12,7 +12,9 @@ from pydantic_ai.messages import (
 )
 
 from quraite.adapters.base import BaseAdapter
+from quraite.constants.framework import Framework
 from quraite.logger import get_logger
+from quraite.schema.invoke import InvokeInput, InvokeOutput
 from quraite.schema.message import (
     AgentMessage,
     AssistantMessage,
@@ -20,69 +22,47 @@ from quraite.schema.message import (
     ToolCall,
     ToolMessage,
 )
-from quraite.schema.response import AgentInvocationResponse
-from quraite.tracing.constants import Framework
 from quraite.tracing.trace import AgentSpan, AgentTrace
 
 logger = get_logger(__name__)
 
 
 class PydanticAIAdapter(BaseAdapter):
-    """
-    Pydantic AI adapter wrapper that converts any Pydantic AI agent
-    to a standardized callable interface (invoke) and converts the output to List[AgentMessage].
-
-    This class wraps any Pydantic AI Agent and provides:
-    - Synchronous invocation via invoke()
-    - Asynchronous invocation via ainvoke()
-    - Automatic conversion to List[AgentMessage] format
-    - Access to message history and traces
-    """
+    """Pydantic AI adapter for Agent."""
 
     def __init__(
         self,
         agent: Agent,
-        agent_name: str = "Pydantic AI Agent",
+        *,
         tracer_provider: TracerProvider | None = None,
+        agent_name: str = "Pydantic AI Agent",
     ):
         """
-        Initialize with a pre-configured Pydantic AI agent
+        Initialize Pydantic AI adapter.
 
         Args:
-            agent: A Pydantic AI Agent instance
-            agent_name: Name of the agent for trajectory metadata
+            agent: Pydantic AI Agent instance
+            tracer_provider: Optional TracerProvider from setup_tracing()
+            agent_name: Agent name for metadata
         """
         self.agent = agent
         self.agent_name = agent_name
-        # Store session state for conversation context
         self._sessions: dict[str, Any] = {}
-        self._init_tracing(tracer_provider, required=False)
-        logger.info(
-            "PydanticAIAdapter initialized (agent_name=%s, tracing_enabled=%s)",
-            agent_name,
-            bool(tracer_provider),
-        )
+        self._init_tracer(tracer_provider)
+        logger.info("PydanticAIAdapter initialized (tracing=%s)", bool(tracer_provider))
 
     def _convert_pydantic_ai_messages_to_messages(
-        self, messages: List[Any]
-    ) -> List[AgentMessage]:
-        """
-        Convert Pydantic AI ModelMessage objects (with parts) to SDK Message format.
-
-        Args:
-            messages: List of Pydantic AI ModelMessage objects
-
-        Returns:
-            List[AgentMessage]: Converted messages in SDK format
-        """
-        converted_messages: List[AgentMessage] = []
+        self, messages: list[Any]
+    ) -> list[AgentMessage]:
+        """Convert Pydantic AI messages to Quraite format."""
+        converted_messages: list[AgentMessage] = []
 
         for msg in messages:
             if not hasattr(msg, "parts"):
                 continue
 
-            content: List[MessageContentText] = []
-            tool_calls_list: List[ToolCall] = []
+            content: list[MessageContentText] = []
+            tool_calls_list: list[ToolCall] = []
 
             for part in msg.parts:
                 if isinstance(part, SystemPromptPart) or isinstance(
@@ -147,61 +127,11 @@ class PydanticAIAdapter(BaseAdapter):
         )
         return converted_messages
 
-    def _prepare_input(self, input: List[AgentMessage]) -> str:
-        """
-        Prepare input for Pydantic AI agent from List[AgentMessage].
-
-        Args:
-            input: List[AgentMessage] containing user_message
-
-        Returns:
-            str: User message text
-        """
-        logger.debug("Preparing Pydantic AI input from %d messages", len(input))
-        if not input or input[-1].role != "user":
-            logger.error("Pydantic AI 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("Pydantic AI 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("Pydantic AI user message missing text content")
-            raise ValueError("No text content found in user message")
-
-        logger.debug("Prepared Pydantic AI input (text_length=%d)", len(text_content))
-        return text_content
-
-    async def ainvoke(
-        self,
-        input: List[AgentMessage],
-        session_id: Union[str, None],
-    ) -> AgentInvocationResponse:
-        """
-        Asynchronous invocation method - invokes the Pydantic AI agent and converts the output to List[AgentMessage]
-
-        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(
-            "Pydantic AI ainvoke called (session_id=%s, input_messages=%d)",
-            session_id,
-            len(input),
-        )
-        agent_input = self._prepare_input(input)
-        session_id = session_id or "default"
+    async def ainvoke(self, input: InvokeInput) -> InvokeOutput:
+        """Invoke Pydantic AI agent and return response."""
+        logger.info("Pydantic AI ainvoke called (session_id=%s)", input.session_id)
+        agent_input = input.user_message_str()
+        session_id = input.session_id or "default"
 
         try:
             # Get message history for this session (for multi-turn conversations)
@@ -226,7 +156,7 @@ class PydanticAIAdapter(BaseAdapter):
         agent_input: str,
         session_id: str,
         message_history: Any | None,
-    ) -> AgentInvocationResponse:
+    ) -> InvokeOutput:
         """Execute ainvoke with tracing enabled."""
         with self.tracer.start_as_current_span("pydantic_invocation") as span:
             trace_id = span.get_span_context().trace_id
@@ -266,7 +196,7 @@ class PydanticAIAdapter(BaseAdapter):
         else:
             logger.warning("No spans exported for Pydantic AI trace_id=%s", trace_id)
 
-        return AgentInvocationResponse(
+        return InvokeOutput(
             agent_trace=agent_trace,
             agent_trajectory=agent_trace.to_agent_trajectory(
                 framework=Framework.PYDANTIC_AI
@@ -278,7 +208,7 @@ class PydanticAIAdapter(BaseAdapter):
         agent_input: str,
         session_id: str,
         message_history: Any | None,
-    ) -> AgentInvocationResponse:
+    ) -> InvokeOutput:
         """Execute ainvoke without tracing."""
         # Run the agent asynchronously with message history for context
         if message_history:
@@ -302,6 +232,6 @@ class PydanticAIAdapter(BaseAdapter):
             len(agent_trajectory),
         )
 
-        return AgentInvocationResponse(
+        return InvokeOutput(
             agent_trajectory=agent_trajectory,
         )

quraite/adapters/smolagents_adapter.py

@@ -1,117 +1,56 @@
 import asyncio
-from typing import List, Optional
 
 from opentelemetry.trace import TracerProvider
 from smolagents import CodeAgent
 
 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 SmolagentsAdapter(BaseAdapter):
-    """
-    Smolagents adapter wrapper that converts any Smolagents CodeAgent
-    to a standardized callable interface (ainvoke) with tracing support.
-
-    This class wraps any CodeAgent and provides:
-    - Asynchronous invocation via ainvoke()
-    - OpenTelemetry tracing integration
-    - Required tracing (returns AgentTrace containing spans)
-    """
+    """Smolagents adapter for CodeAgent (requires tracing)."""
 
     def __init__(
         self,
         agent: CodeAgent,
+        *,
+        tracer_provider: TracerProvider | None = None,
         agent_name: str = "Smolagents Agent",
-        tracer_provider: Optional[TracerProvider] = None,
     ):
         """
-        Initialize with a pre-configured Smolagents CodeAgent
+        Initialize Smolagents adapter.
 
         Args:
-            agent: A Smolagents CodeAgent instance
-            agent_name: Name of the agent for trajectory metadata
-            tracer_provider: TracerProvider for tracing (required)
+            agent: Smolagents CodeAgent instance
+            tracer_provider: TracerProvider from setup_tracing() (required)
+            agent_name: Agent name for metadata
         """
-        logger.debug(
-            "Initializing SmolagentsAdapter with agent_name=%s (tracing_required=True)",
-            agent_name,
-        )
-        self._init_tracing(tracer_provider, required=True)
+        if tracer_provider is None:
+            raise ValueError(
+                "Smolagents adapter requires tracing. Use setup_tracing([Framework.SMOLAGENTS]) first."
+            )
 
         self.agent = agent
         self.agent_name = agent_name
-        logger.info("SmolagentsAdapter initialized successfully")
-
-    def _prepare_input(self, input: List[AgentMessage]) -> str:
-        """
-        Prepare input for Smolagents CodeAgent from List[AgentMessage].
-
-        Args:
-            input: List[AgentMessage] containing user_message
-
-        Returns:
-            str: User message text
-        """
-        logger.debug("Preparing Smolagents input from %d messages", len(input))
-        if not input or input[-1].role != "user":
-            logger.error("Smolagents 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("Smolagents user message missing content")
-            raise ValueError("User message has no content")
+        self._init_tracer(tracer_provider)
+        logger.info("SmolagentsAdapter initialized")
 
-        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("Smolagents user message missing text content")
-            raise ValueError("No text content found in user message")
-
-        logger.debug("Prepared Smolagents input (text_length=%d)", len(text_content))
-        return text_content
-
-    async def ainvoke(
-        self,
-        input: List[AgentMessage],
-        session_id: Optional[str] = None,
-    ) -> AgentInvocationResponse:
-        """
-        Asynchronous invocation method - invokes the Smolagents CodeAgent with tracing
-
-        Args:
-            input: List[AgentMessage] containing user_message
-            session_id: Optional conversation ID (for parity with other adapters)
-
-        Returns:
-            AgentTrace - trace with spans captured during invocation
-        """
-        _ = session_id  # Currently unused but kept for interface compatibility
-        logger.info(
-            "Smolagents 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 Smolagents agent and return response with trace."""
+        logger.info("Smolagents ainvoke called (session_id=%s)", input.session_id)
 
         try:
-            return await self._ainvoke_with_tracing(agent_input)
+            return await self._ainvoke_with_tracing(input.user_message_str())
         except Exception as exc:
             logger.exception("Error invoking Smolagents agent")
             raise RuntimeError(f"Error invoking Smolagents agent: {exc}") from exc
 
-    async def _ainvoke_with_tracing(self, agent_input: str) -> AgentInvocationResponse:
+    async def _ainvoke_with_tracing(self, agent_input: str) -> InvokeOutput:
         """Execute ainvoke with tracing enabled."""
         with self.tracer.start_as_current_span("smolagents_invocation") as span:
             trace_id = span.get_span_context().trace_id
@@ -140,7 +79,7 @@ class SmolagentsAdapter(BaseAdapter):
         else:
             logger.warning("No spans captured for Smolagents trace_id=%s", trace_id)
 
-        return AgentInvocationResponse(
+        return InvokeOutput(
             agent_trace=agent_trace,
             agent_trajectory=agent_trace.to_agent_trajectory(
                 framework=Framework.SMOLAGENTS

quraite/constants/framework.py

@@ -0,0 +1,14 @@
+from enum import Enum
+
+
+class Framework(str, Enum):
+    """Supported agent frameworks."""
+
+    DEFAULT = "default"
+    PYDANTIC_AI = "pydantic_ai"
+    LANGCHAIN = "langchain"
+    GOOGLE_ADK = "google_adk"
+    OPENAI_AGENTS = "openai_agents"
+    AGNO = "agno"
+    SMOLAGENTS = "smolagents"
+    OPENAI = "openai"