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

quraite/adapters/smolagents_adapter.py

@@ -1,152 +1,152 @@
-import asyncio
-import uuid
-from typing import List, Optional
-
-from opentelemetry.trace import TracerProvider
-from smolagents import CodeAgent
-
-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 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)
-    """
-
-    def __init__(
-        self,
-        agent: CodeAgent,
-        agent_name: str = "Smolagents Agent",
-        tracer_provider: Optional[TracerProvider] = None,
-    ):
-        """
-        Initialize with a pre-configured Smolagents CodeAgent
-
-        Args:
-            agent: A Smolagents CodeAgent instance
-            agent_name: Name of the agent for trajectory metadata
-            tracer_provider: TracerProvider for tracing (required)
-        """
-        logger.debug(
-            "Initializing SmolagentsAdapter with agent_name=%s (tracing_required=True)",
-            agent_name,
-        )
-        self._init_tracing(tracer_provider, required=True)
-
-        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")
-
-        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)
-
-        try:
-            return await self._ainvoke_with_tracing(agent_input)
-        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:
-        """Execute ainvoke with tracing enabled."""
-        adapter_trace_id = f"{QURAITE_ADAPTER_TRACE_PREFIX}-{uuid.uuid4()}"
-        logger.debug(
-            "Starting Smolagents traced invocation (trace_id=%s)", adapter_trace_id
-        )
-
-        with self.tracer.start_as_current_span(name=adapter_trace_id):
-            # Run the agent synchronously inside a thread to avoid blocking
-            await asyncio.to_thread(self.agent.run, agent_input)
-
-        trace_readable_spans = self.quraite_span_exporter.get_trace_by_testcase(
-            adapter_trace_id
-        )
-
-        if trace_readable_spans:
-            logger.info(
-                "Smolagents trace collected %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 captured for Smolagents trace_id=%s", adapter_trace_id
-            )
-
-        return AgentInvocationResponse(
-            agent_trace=agent_trace,
-            agent_trajectory=agent_trace.to_agent_trajectory(
-                framework=Framework.SMOLAGENTS
-            ),
-        )
+import asyncio
+import uuid
+from typing import List, Optional
+
+from opentelemetry.trace import TracerProvider
+from smolagents import CodeAgent
+
+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 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)
+    """
+
+    def __init__(
+        self,
+        agent: CodeAgent,
+        agent_name: str = "Smolagents Agent",
+        tracer_provider: Optional[TracerProvider] = None,
+    ):
+        """
+        Initialize with a pre-configured Smolagents CodeAgent
+
+        Args:
+            agent: A Smolagents CodeAgent instance
+            agent_name: Name of the agent for trajectory metadata
+            tracer_provider: TracerProvider for tracing (required)
+        """
+        logger.debug(
+            "Initializing SmolagentsAdapter with agent_name=%s (tracing_required=True)",
+            agent_name,
+        )
+        self._init_tracing(tracer_provider, required=True)
+
+        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")
+
+        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)
+
+        try:
+            return await self._ainvoke_with_tracing(agent_input)
+        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:
+        """Execute ainvoke with tracing enabled."""
+        adapter_trace_id = f"{QURAITE_ADAPTER_TRACE_PREFIX}-{uuid.uuid4()}"
+        logger.debug(
+            "Starting Smolagents traced invocation (trace_id=%s)", adapter_trace_id
+        )
+
+        with self.tracer.start_as_current_span(name=adapter_trace_id):
+            # Run the agent synchronously inside a thread to avoid blocking
+            await asyncio.to_thread(self.agent.run, agent_input)
+
+        trace_readable_spans = self.quraite_span_exporter.get_trace_by_testcase(
+            adapter_trace_id
+        )
+
+        if trace_readable_spans:
+            logger.info(
+                "Smolagents trace collected %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 captured for Smolagents trace_id=%s", adapter_trace_id
+            )
+
+        return AgentInvocationResponse(
+            agent_trace=agent_trace,
+            agent_trajectory=agent_trace.to_agent_trajectory(
+                framework=Framework.SMOLAGENTS
+            ),
+        )

quraite/logger.py

@@ -1,64 +1,61 @@
-import logging
-import os
-
-_logger = logging.getLogger("quraite")
-_logger.addHandler(logging.NullHandler())
-
-
-def set_log_level(level: int | str) -> None:
-    """
-    Configure the root quraite logger programmatically.
-
-    Args:
-        level: Either a logging level integer or its string name (e.g. "INFO").
-    """
-    resolved_level: int
-    if isinstance(level, str):
-        try:
-            resolved_level = getattr(logging, level.upper())
-        except AttributeError as exc:
-            raise ValueError(f"Invalid log level: {level}") from exc
-    else:
-        resolved_level = level
-
-    _logger.setLevel(resolved_level)
-
-    # Ensure a stream handler is attached so logs are emitted somewhere useful.
-    if not any(
-        isinstance(handler, logging.StreamHandler) for handler in _logger.handlers
-    ):
-        handler = logging.StreamHandler()
-        handler.setFormatter(
-            logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
-        )
-        _logger.addHandler(handler)
-
-
-def get_logger(name: str | None = None) -> logging.Logger:
-    """
-    Get a logger for quraite submodules.
-
-    Args:
-        name: Module name (typically __name__)
-
-    Returns:
-        A logging.Logger instance for the quraite package.
-    """
-    if name is None:
-        return _logger
-
-    if name.startswith("quraite"):
-        return logging.getLogger(name)
-
-    return logging.getLogger(f"quraite.{name}")
-
-
-# Set level from environment variable if provided
-_env_level = os.getenv("LOG_LEVEL")
-if _env_level:
-    try:
-        set_log_level(_env_level)
-    except ValueError:
-        pass
-else:
-    set_log_level("INFO")
+import logging
+import os
+
+_logger = logging.getLogger("quraite")
+_logger.addHandler(logging.NullHandler())
+
+
+def set_log_level(level: int | str) -> None:
+    """
+    Configure the root quraite logger programmatically.
+
+    Args:
+        level: Either a logging level integer or its string name (e.g. "INFO").
+    """
+    resolved_level: int
+    if isinstance(level, str):
+        try:
+            resolved_level = getattr(logging, level.upper())
+        except AttributeError as exc:
+            raise ValueError(f"Invalid log level: {level}") from exc
+    else:
+        resolved_level = level
+
+    _logger.setLevel(resolved_level)
+
+    # Ensure a stream handler is attached so logs are emitted somewhere useful.
+    if not any(
+        isinstance(handler, logging.StreamHandler) for handler in _logger.handlers
+    ):
+        handler = logging.StreamHandler()
+        handler.setFormatter(
+            logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+        )
+        _logger.addHandler(handler)
+
+
+def get_logger(name: str | None = None) -> logging.Logger:
+    """
+    Get a logger for quraite submodules.
+
+    Args:
+        name: Module name (typically __name__)
+
+    Returns:
+        A logging.Logger instance for the quraite package.
+    """
+    if name is None:
+        return _logger
+
+    if name.startswith("quraite"):
+        return logging.getLogger(name)
+
+    return logging.getLogger(f"quraite.{name}")
+
+
+# Set level from environment variable if provided
+_env_level = os.getenv("LOG_LEVEL") or "INFO"
+try:
+    set_log_level(_env_level)
+except ValueError:
+    pass

quraite/schema/message.py

@@ -1,54 +1,91 @@
-from typing import Any, List, Literal, Optional, TypeAlias, Union
-
-from pydantic import BaseModel
-
-
-class MessageContentText(BaseModel):
-    type: Literal["text"] = "text"
-    text: str
-
-
-class MessageContentReasoning(BaseModel):
-    type: Literal["reasoning"] = "reasoning"
-    reasoning: str
-
-
-class UserMessage(BaseModel):
-    role: Literal["user"] = "user"
-    name: Optional[str] = None
-    content: List[MessageContentText]
-
-
-class DeveloperMessage(BaseModel):
-    role: Literal["developer"] = "developer"
-    content: List[MessageContentText]
-
-
-class SystemMessage(BaseModel):
-    role: Literal["system"] = "system"
-    content: List[MessageContentText]
-
-
-class ToolCall(BaseModel):
-    id: str
-    name: str
-    arguments: dict[str, Any]
-
-
-class AssistantMessage(BaseModel):
-    role: Literal["assistant"] = "assistant"
-    agent_name: Optional[str] = None
-    content: Optional[List[Union[MessageContentText, MessageContentReasoning]]] = None
-    tool_calls: Optional[List[ToolCall]] = None
-
-
-class ToolMessage(BaseModel):
-    role: Literal["tool"] = "tool"
-    tool_name: Optional[str] = None
-    tool_call_id: Optional[str] = None
-    content: List[MessageContentText]
-
-
-AgentMessage: TypeAlias = Union[
-    UserMessage, DeveloperMessage, SystemMessage, AssistantMessage, ToolMessage
-]
+from typing import Any, List, Literal, Optional, TypeAlias, Union
+
+from pydantic import BaseModel, Field
+
+
+class MessageContentText(BaseModel):
+    type: Literal["text"] = "text"
+    text: str
+
+
+class MessageContentReasoning(BaseModel):
+    type: Literal["reasoning"] = "reasoning"
+    reasoning: str
+
+
+class UserMessage(BaseModel):
+    role: Literal["user"] = "user"
+    name: Optional[str] = None
+    content: List[MessageContentText]
+
+
+class DeveloperMessage(BaseModel):
+    role: Literal["developer"] = "developer"
+    content: List[MessageContentText]
+
+
+class SystemMessage(BaseModel):
+    role: Literal["system"] = "system"
+    content: List[MessageContentText]
+
+
+class ToolCall(BaseModel):
+    id: str
+    name: str
+    arguments: dict[str, Any]
+
+
+class ModelInfo(BaseModel):
+    model_name: str = Field(default="")
+    model_provider: str = Field(default="")
+
+
+class CostInfo(BaseModel):
+    input_cost: float = Field(default=0.0)
+    output_cost: float = Field(default=0.0)
+
+
+class TokenInfo(BaseModel):
+    input_tokens: int = Field(default=0)
+    output_tokens: int = Field(default=0)
+
+
+class LatencyInfo(BaseModel):
+    start_time: float = Field(default=0.0)
+    end_time: float = Field(default=0.0)
+
+
+class AssistantMessageMetadata(BaseModel):
+    """Structured metadata for assistant messages."""
+
+    tokens: TokenInfo = Field(default_factory=TokenInfo)
+    cost: CostInfo = Field(default_factory=CostInfo)
+    latency: LatencyInfo = Field(default_factory=LatencyInfo)
+    model_info: ModelInfo = Field(default_factory=ModelInfo)
+
+
+class ToolMessageMetadata(BaseModel):
+    """Structured metadata for tool messages."""
+
+    latency: LatencyInfo = Field(default_factory=LatencyInfo)
+
+
+class AssistantMessage(BaseModel):
+    role: Literal["assistant"] = "assistant"
+    agent_name: Optional[str] = None
+    content: Optional[List[Union[MessageContentText, MessageContentReasoning]]] = None
+    tool_calls: Optional[List[ToolCall]] = None
+    metadata: AssistantMessageMetadata = Field(default_factory=AssistantMessageMetadata)
+
+
+class ToolMessage(BaseModel):
+    role: Literal["tool"] = "tool"
+    tool_name: Optional[str] = None
+    tool_call_id: Optional[str] = None
+    content: List[MessageContentText]
+    metadata: ToolMessageMetadata = Field(default_factory=ToolMessageMetadata)
+
+
+AgentMessage: TypeAlias = Union[
+    UserMessage, DeveloperMessage, SystemMessage, AssistantMessage, ToolMessage
+]

quraite/schema/response.py

@@ -1,16 +1,16 @@
-from typing import List, Optional
-
-from pydantic import BaseModel
-
-from quraite.schema.message import AgentMessage
-from quraite.tracing.trace import AgentTrace
-
-
-class AgentInvocationResponse(BaseModel):
-    """
-    Response model for agent invocation.
-    """
-
-    agent_trace: Optional[AgentTrace] = None
-    agent_trajectory: Optional[List[AgentMessage]] = None
-    agent_final_response: Optional[str] = None
+from typing import List, Optional
+
+from pydantic import BaseModel
+
+from quraite.schema.message import AgentMessage
+from quraite.tracing.trace import AgentTrace
+
+
+class AgentInvocationResponse(BaseModel):
+    """
+    Response model for agent invocation.
+    """
+
+    agent_trace: Optional[AgentTrace] = None
+    agent_trajectory: Optional[List[AgentMessage]] = None
+    agent_final_response: Optional[str] = None

quraite/serve/__init__.py

@@ -1 +1 @@
-
+