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

quraite/adapters/http_adapter.py

@@ -118,10 +118,6 @@ class HttpAdapter(BaseAdapter):
 
         Returns:
             Response data as dictionary
-
-        Raises:
-            httpx.HTTPError: If all retries fail
-            ValueError: If response format is invalid
         """
         last_exception = None
 
@@ -141,28 +137,15 @@ class HttpAdapter(BaseAdapter):
                 return response.json()
 
             except httpx.HTTPStatusError as e:
-                # Don't retry on 4xx errors (client errors)
-                if 400 <= e.response.status_code < 500:
-                    error_detail = e.response.text
-                    logger.error(
-                        "HTTP adapter received 4xx response (status=%s, detail=%s)",
-                        e.response.status_code,
-                        error_detail,
-                    )
-                    raise ValueError(
-                        f"Agent server error ({e.response.status_code}): {error_detail}"
-                    ) from e
+                error_detail = e.response.text
+                logger.error(
+                    "Failed while invoking the url '%s' with status code '%s' and detail '%s'",
+                    url,
+                    e.response.status_code,
+                    error_detail,
+                )
 
-                # Retry on 5xx errors
-                last_exception = e
-                if attempt < self.max_retries - 1:
-                    delay = self.retry_delay * (2**attempt)
-                    logger.warning(
-                        "HTTP adapter retrying after server error (status=%s, retry_in=%.2fs)",
-                        e.response.status_code,
-                        delay,
-                    )
-                    await self._async_sleep(delay)
+                raise e
 
             except (httpx.ConnectError, httpx.TimeoutException) as e:
                 # Retry on network errors
@@ -170,21 +153,27 @@ class HttpAdapter(BaseAdapter):
                 if attempt < self.max_retries - 1:
                     delay = self.retry_delay * (2**attempt)
                     logger.warning(
-                        "HTTP adapter retrying after network error (retry_in=%.2fs)",
+                        "HTTP adapter retrying after network/connection error (retry_in=%.2fs)",
                         delay,
                     )
                     await self._async_sleep(delay)
+                else:
+                    logger.error(
+                        "Failed while connecting to the url %s after %d attempts. Last error: %s",
+                        url,
+                        self.max_retries,
+                        last_exception,
+                    )
+                    raise last_exception
 
-        # All retries failed
-        logger.exception(
-            "HTTP adapter failed after %d attempts (url=%s)",
+        logger.error(
+            "HTTP adapter failed while invoking the url %s after %d attempts. Last error: %s",
+            url,
             self.max_retries,
-            self.url,
+            last_exception,
         )
-        raise RuntimeError(
-            f"Failed to connect to agent server at {self.url} after "
-            f"{self.max_retries} attempts. Last error: {last_exception}"
-        ) from last_exception
+
+        raise last_exception
 
     @staticmethod
     async def _async_sleep(seconds: float):
@@ -237,3 +226,26 @@ class HttpAdapter(BaseAdapter):
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         """Async context manager exit."""
         await self.aclose()
+
+
+if __name__ == "__main__":
+    import asyncio
+    import json
+
+    from quraite.schema.message import MessageContentText, UserMessage
+
+    async def test_http_adapter():
+        adapter = HttpAdapter(url="http://localhost:8080/v1/agents/completions")
+
+        try:
+            response = await adapter.ainvoke(
+                input=[UserMessage(content=[MessageContentText(text="What is 1 + 1")])],
+                session_id="test",
+            )
+            print(response)
+        except httpx.HTTPStatusError as e:
+            print(json.loads(e.response.text)["detail"])
+        except Exception as e:
+            print(e)
+
+    asyncio.run(test_http_adapter())

quraite/logger.py

@@ -54,11 +54,8 @@ def get_logger(name: str | None = None) -> logging.Logger:
 
 
 # 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")
+_env_level = os.getenv("LOG_LEVEL") or "INFO"
+try:
+    set_log_level(_env_level)
+except ValueError:
+    pass

quraite/schema/message.py

@@ -1,6 +1,6 @@
 from typing import Any, List, Literal, Optional, TypeAlias, Union
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 
 class MessageContentText(BaseModel):
@@ -35,11 +35,47 @@ class ToolCall(BaseModel):
     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):
@@ -47,6 +83,7 @@ class ToolMessage(BaseModel):
     tool_name: Optional[str] = None
     tool_call_id: Optional[str] = None
     content: List[MessageContentText]
+    metadata: ToolMessageMetadata = Field(default_factory=ToolMessageMetadata)
 
 
 AgentMessage: TypeAlias = Union[

quraite/serve/local_agent.py

@@ -48,7 +48,7 @@ class LocalAgentServer:
     Usage:
         ```python
         from quraite.serve.local_agent_server import LocalAgentServer
-        from quraite.adapters.langgraph_adapter import LangGraphAdapter
+        from quraite.adapters import LangGraphAdapter
 
         sdk = LocalAgentServer(wrapped_agent=LangGraphAdapter(agent_graph=agent_graph))
         sdk.start(host="0.0.0.0", port=8000, reload=False)
@@ -331,12 +331,12 @@ class LocalAgentServer:
 
             try:
                 # Invoke agent (asynchronously)
-                messages: List[AgentMessage] = await self._agent.ainvoke(
+                response: AgentInvocationResponse = await self._agent.ainvoke(
                     input=request.input,
                     session_id=request.session_id,
                 )
 
-                return InvokeResponse(agent_response=messages)
+                return InvokeResponse(agent_response=response)
 
             except HTTPException:
                 raise

quraite/tracing/trace.py

@@ -11,13 +11,14 @@ from opentelemetry.sdk.trace import Span as OTelSpan
 from pydantic import BaseModel, ConfigDict, Field
 
 from quraite.logger import get_logger
-from quraite.schema.message import (
-    AssistantMessage,
-    MessageContentText,
-    SystemMessage,
-    ToolCall,
-    ToolMessage,
-)
+from quraite.schema.message import AssistantMessage, AssistantMessageMetadata
+from quraite.schema.message import CostInfo as MessageCostInfo
+from quraite.schema.message import LatencyInfo as MessageLatencyInfo
+from quraite.schema.message import MessageContentText
+from quraite.schema.message import ModelInfo as MessageModelInfo
+from quraite.schema.message import SystemMessage
+from quraite.schema.message import TokenInfo as MessageTokenInfo
+from quraite.schema.message import ToolCall, ToolMessage, ToolMessageMetadata
 from quraite.tracing.constants import Framework
 from quraite.tracing.types import Event, Link, Resource, SpanContext, SpanKind, Status
 from quraite.tracing.utils import unflatten_messages
@@ -254,8 +255,15 @@ class AgentTrace(BaseModel):
         self.spans.extend(spans)
         self._invalidate_tokens_and_cost_cache()
 
-    def _convert_llm_message(self, msg: dict[str, Any]) -> AssistantMessage | None:
-        """Convert an LLM output message dict to an AssistantMessage."""
+    def _convert_llm_message(
+        self, msg: dict[str, Any], metadata: AssistantMessageMetadata
+    ) -> AssistantMessage | None:
+        """Convert an LLM output message dict to an AssistantMessage.
+
+        Args:
+            msg: Raw LLM message dict from OpenInference attributes.
+            metadata: Per-span metadata (tokens, cost, latency) to attach.
+        """
 
         role = msg.get("role")
         tool_calls = msg.get("tool_calls")
@@ -322,6 +330,7 @@ class AgentTrace(BaseModel):
             return AssistantMessage(
                 content=text_content if text_content else None,
                 tool_calls=tool_calls_list if tool_calls_list else None,
+                metadata=metadata,
             )
 
         return None
@@ -336,6 +345,64 @@ class AgentTrace(BaseModel):
             content=[MessageContentText(type="text", text=str(content))],
         )
 
+    def _extract_assistant_metadata(self, span: AgentSpan) -> AssistantMessageMetadata:
+        """Extract assistant message metadata from a span.
+
+        Args:
+            span: The span to extract metadata from.
+
+        Returns:
+            AssistantMessageMetadata with tokens, cost, latency, and model info.
+        """
+        # Per-span token and cost metrics for assistant messages
+        span_input_tokens = span.attributes.get(
+            SpanAttributes.LLM_TOKEN_COUNT_PROMPT, 0
+        )
+        span_output_tokens = span.attributes.get(
+            SpanAttributes.LLM_TOKEN_COUNT_COMPLETION, 0
+        )
+        span_input_cost = span.attributes.get(SpanAttributes.LLM_COST_PROMPT, 0.0)
+        span_output_cost = span.attributes.get(SpanAttributes.LLM_COST_COMPLETION, 0.0)
+
+        # Per-span latency (nanoseconds as float)
+        span_start_time = float(span.start_time) if span.start_time is not None else 0.0
+        span_end_time = float(span.end_time) if span.end_time is not None else 0.0
+
+        # Per-span model info
+        span_model_name = span.attributes.get(SpanAttributes.LLM_MODEL_NAME, "")
+        span_model_provider = span.attributes.get(SpanAttributes.LLM_PROVIDER, "")
+
+        return AssistantMessageMetadata(
+            tokens=MessageTokenInfo(
+                input_tokens=span_input_tokens,
+                output_tokens=span_output_tokens,
+            ),
+            cost=MessageCostInfo(
+                input_cost=span_input_cost,
+                output_cost=span_output_cost,
+            ),
+            latency=MessageLatencyInfo(
+                start_time=span_start_time,
+                end_time=span_end_time,
+            ),
+            model_info=MessageModelInfo(
+                model_name=span_model_name,
+                model_provider=span_model_provider,
+            ),
+        )
+
+    def _extract_tool_metadata(self, span: AgentSpan) -> ToolMessageMetadata:
+        """Extract tool message metadata from a span."""
+        span_start_time = float(span.start_time) if span.start_time is not None else 0.0
+        span_end_time = float(span.end_time) if span.end_time is not None else 0.0
+
+        return ToolMessageMetadata(
+            latency=MessageLatencyInfo(
+                start_time=span_start_time,
+                end_time=span_end_time,
+            ),
+        )
+
     def to_agent_trajectory(
         self,
         framework: Framework = Framework.LANGGRAPH,
@@ -411,8 +478,10 @@ class AgentTrace(BaseModel):
                 if only_leaf_llms and span_id and has_llm_children(span_id):
                     continue
 
+                metadata = self._extract_assistant_metadata(span)
+
                 for llm_msg in span.to_llm_messages():
-                    converted = self._convert_llm_message(llm_msg)
+                    converted = self._convert_llm_message(llm_msg, metadata=metadata)
                     if converted:
                         messages.append(converted)
 
@@ -422,6 +491,7 @@ class AgentTrace(BaseModel):
                 if tool_msg:
                     converted = self._convert_tool_message(tool_msg)
                     if converted:
+                        converted.metadata = self._extract_tool_metadata(span)
                         messages.append(converted)
 
         return messages

quraite-0.1.1.dist-info/METADATA

@@ -0,0 +1,377 @@
+Metadata-Version: 2.3
+Name: quraite
+Version: 0.1.1
+Summary: This project provides adaptors and methods to integrate with the Quraite platform
+Author: Shiv Mohith
+Author-email: Shiv Mohith <shivmohith8@gmail.com>
+Requires-Dist: aiohttp>=3.13.2
+Requires-Dist: fastapi>=0.121.1
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: openinference-semantic-conventions>=0.1.25
+Requires-Dist: opentelemetry-api>=1.37.0
+Requires-Dist: opentelemetry-sdk>=1.37.0
+Requires-Dist: pydantic>=2.12.4
+Requires-Dist: python-dotenv>=1.2.1
+Requires-Dist: uvicorn>=0.38.0
+Requires-Dist: agno>=2.3.4 ; extra == 'agno'
+Requires-Dist: boto3>=1.40.70 ; extra == 'bedrock'
+Requires-Dist: google-adk>=1.18.0 ; extra == 'google-adk'
+Requires-Dist: langchain>=1.0.5 ; extra == 'langgraph'
+Requires-Dist: langgraph>=1.0.3 ; extra == 'langgraph'
+Requires-Dist: openai-agents>=0.5.0 ; extra == 'openai-agents'
+Requires-Dist: pydantic-ai>=1.25.0 ; extra == 'pydantic-ai'
+Requires-Dist: pyngrok>=7.5.0 ; extra == 'pyngrok'
+Requires-Dist: smolagents>=1.23.0 ; extra == 'smolagents'
+Requires-Python: >=3.10
+Provides-Extra: agno
+Provides-Extra: bedrock
+Provides-Extra: google-adk
+Provides-Extra: langgraph
+Provides-Extra: openai-agents
+Provides-Extra: pydantic-ai
+Provides-Extra: pyngrok
+Provides-Extra: smolagents
+Description-Content-Type: text/markdown
+
+# Quraite Python SDK
+
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+The **Quraite Python SDK** provides adapters and methods to integrate AI agent frameworks with the [Quraite platform](https://quraite.ai). It offers a unified interface for different agent frameworks, automatic tracing and observability, and easy local server setup with tunneling capabilities.
+
+## Features
+
+- 🔌 **Framework Adapters**: Support for multiple AI agent frameworks (LangGraph, Pydantic AI, Agno, Google ADK, OpenAI Agents, Smolagents, AWS Bedrock, Flowise, Langflow, N8n, and more)
+- 📊 **Automatic Tracing**: Built-in OpenTelemetry-based tracing for agent execution, tool calls, and performance metrics
+- 🚀 **Local Server**: Easy-to-use local server with optional tunneling (Cloudflare/ngrok) for public access
+- 📦 **Standardized Schema**: Unified message and response formats across all frameworks
+- 🔍 **Observability**: Track token usage, costs, latency, and model information for each agent invocation
+
+## Installation
+
+### Basic Installation
+
+```bash
+pip install quraite
+```
+
+### Framework-Specific Installation
+
+Install with optional dependencies for specific frameworks:
+
+```bash
+# LangGraph
+pip install 'quraite[langgraph]'
+
+# Pydantic AI
+pip install 'quraite[pydantic-ai]'
+
+# Agno
+pip install 'quraite[agno]'
+
+# Google ADK
+pip install 'quraite[google-adk]'
+
+# OpenAI Agents
+pip install 'quraite[openai-agents]'
+
+# Smolagents
+pip install 'quraite[smolagents]'
+
+# AWS Bedrock
+pip install 'quraite[bedrock]'
+
+# Multiple frameworks
+pip install 'quraite[langgraph,pydantic-ai,agno]'
+```
+
+## Quick Start
+
+### Example: LangGraph Agent with Local Server
+
+Pass your compiled LangGraph agent to the adapter and expose it as an HTTP API:
+
+```python
+import uvicorn
+from dotenv import load_dotenv
+from openinference.instrumentation import TracerProvider
+from openinference.instrumentation.langchain import LangChainInstrumentor
+
+from quraite.adapters import LanggraphAdapter
+from quraite.serve.local_agent import LocalAgentServer
+from quraite.tracing.span_exporter import QuraiteInMemorySpanExporter
+from quraite.tracing.span_processor import QuraiteSimpleSpanProcessor
+
+load_dotenv()
+
+# Set up tracing (optional)
+tracer_provider = TracerProvider()
+quraite_span_exporter = QuraiteInMemorySpanExporter()
+quraite_span_processor = QuraiteSimpleSpanProcessor(quraite_span_exporter)
+tracer_provider.add_span_processor(quraite_span_processor)
+LangChainInstrumentor().instrument(tracer_provider=tracer_provider)
+
+# Your compiled LangGraph agent (created elsewhere)
+# agent = create_agent(...)
+
+# Wrap with Quraite adapter
+adapter = LanggraphAdapter(
+    agent_graph=agent,  # Pass your compiled LangGraph agent here
+    tracer_provider=tracer_provider,  # Optional: for tracing
+)
+
+# Create and start server with Cloudflare tunnel
+server = LocalAgentServer(
+    wrapped_agent=adapter,
+    agent_id="your-agent-id",  # Optional: for Quraite platform integration
+)
+
+app = server.create_app(
+    port=8080,
+    host="0.0.0.0",
+    tunnel="cloudflare",  # Options: "cloudflare", "ngrok", or "none"
+)
+
+if __name__ == "__main__":
+    uvicorn.run("local_server:app", host="0.0.0.0", port=8080)
+```
+
+The server exposes:
+
+- `GET /` - Health check endpoint
+- `POST /v1/agents/completions` - Agent invocation endpoint
+
+When using `tunnel="cloudflare"` or `tunnel="ngrok"`, your agent will be publicly accessible via the generated URL.
+
+## Supported Frameworks
+
+| Framework            | Adapter                  | Installation                           |
+| -------------------- | ------------------------ | -------------------------------------- |
+| **LangGraph**        | `LanggraphAdapter`       | `pip install 'quraite[langgraph]'`     |
+| **Pydantic AI**      | `PydanticAIAdapter`      | `pip install 'quraite[pydantic-ai]'`   |
+| **Agno**             | `AgnoAdapter`            | `pip install 'quraite[agno]'`          |
+| **Google ADK**       | `GoogleADKAdapter`       | `pip install 'quraite[google-adk]'`    |
+| **OpenAI Agents**    | `OpenaiAgentsAdapter`    | `pip install 'quraite[openai-agents]'` |
+| **Smolagents**       | `SmolagentsAdapter`      | `pip install 'quraite[smolagents]'`    |
+| **AWS Bedrock**      | `BedrockAgentsAdapter`   | `pip install 'quraite[bedrock]'`       |
+| **Flowise**          | `FlowiseAdapter`         | Included in base package               |
+| **Langflow**         | `LangflowAdapter`        | Included in base package               |
+| **N8n**              | `N8nAdapter`             | Included in base package               |
+| **HTTP**             | `HttpAdapter`            | Included in base package               |
+| **LangGraph Server** | `LanggraphServerAdapter` | `pip install 'quraite[langgraph]'`     |
+
+## Core Concepts
+
+### Adapters
+
+Adapters provide a unified interface (`BaseAdapter`) for different agent frameworks. Each adapter:
+
+- Converts framework-specific agents to a standard interface
+- Handles message format conversion
+- Supports optional tracing integration
+- Provides async invocation via `ainvoke()`
+
+### Tracing
+
+The SDK includes built-in OpenTelemetry-based tracing that captures:
+
+- **Agent Trajectory**: Complete conversation flow with all messages
+- **Tool Calls**: Tool invocations with inputs and outputs
+- **Performance Metrics**: Token usage, costs, latency
+- **Model Information**: Model name and provider details
+
+To enable tracing:
+
+```python
+from openinference.instrumentation import TracerProvider
+from quraite.tracing.span_exporter import QuraiteInMemorySpanExporter
+from quraite.tracing.span_processor import QuraiteSimpleSpanProcessor
+
+tracer_provider = TracerProvider()
+quraite_span_exporter = QuraiteInMemorySpanExporter()
+quraite_span_processor = QuraiteSimpleSpanProcessor(quraite_span_exporter)
+tracer_provider.add_span_processor(quraite_span_processor)
+
+# Instrument your framework (example for LangChain)
+from openinference.instrumentation.langchain import LangChainInstrumentor
+LangChainInstrumentor().instrument(tracer_provider=tracer_provider)
+```
+
+### Message Schema
+
+The SDK uses a standardized message format:
+
+```python
+from quraite.schema.message import (
+    UserMessage,
+    AssistantMessage,
+    ToolMessage,
+    SystemMessage,
+    MessageContentText,
+    ToolCall,
+)
+
+# User message
+user_msg = UserMessage(
+    content=[MessageContentText(text="Hello, world!")]
+)
+
+# Assistant message with tool calls
+assistant_msg = AssistantMessage(
+    content=[MessageContentText(text="I'll calculate that for you.")],
+    tool_calls=[
+        ToolCall(
+            id="call_123",
+            name="add",
+            arguments={"a": 10, "b": 5}
+        )
+    ]
+)
+
+# Tool message
+tool_msg = ToolMessage(
+    tool_call_id="call_123",
+    content=[MessageContentText(text="15")]
+)
+```
+
+### Response Format
+
+Agent invocations return an `AgentInvocationResponse`:
+
+```python
+from quraite.schema.response import AgentInvocationResponse
+
+response: AgentInvocationResponse = await adapter.ainvoke(
+    input=[user_msg],
+    session_id="session-123"
+)
+
+# Access trajectory (list of messages)
+trajectory = response.agent_trajectory
+
+# Access trace (if tracing enabled)
+trace = response.agent_trace
+
+# Access final response text
+final_response = response.agent_final_response
+```
+
+## Examples
+
+The repository includes comprehensive examples for each supported framework:
+
+- [`langgraph_calculator_agent`](examples/langgraph_calculator_agent/) - LangGraph calculator agent
+- [`pydantic_calculator_agent`](examples/pydantic_calculator_agent/) - Pydantic AI calculator agent
+- [`agno_calculator_agent`](examples/agno_calculator_agent/) - Agno calculator agent
+- [`google_adk_weather_agent`](examples/google_adk_weather_agent/) - Google ADK weather agent
+- [`openai_flight_booking_agent`](examples/openai_flight_booking_agent/) - OpenAI Agents flight booking
+- [`smolagents_sql_agent`](examples/smolagents_sql_agent/) - Smolagents SQL agent
+- [`bedrock_restaurant_support_agent`](examples/bedrock_restaurant_support_agent/) - AWS Bedrock agent
+- And more...
+
+Each example includes:
+
+- Agent implementation
+- Adapter setup
+- Local server configuration
+- Environment variable examples
+
+## API Reference
+
+### BaseAdapter
+
+All adapters inherit from `BaseAdapter`:
+
+```python
+from quraite.adapters.base import BaseAdapter
+
+class MyAdapter(BaseAdapter):
+    async def ainvoke(
+        self,
+        input: List[AgentMessage],
+        session_id: str | None,
+    ) -> AgentInvocationResponse:
+        # Implementation
+        pass
+```
+
+### LocalAgentServer
+
+Create a local HTTP server for your agent:
+
+```python
+from quraite.serve.local_agent import LocalAgentServer
+
+server = LocalAgentServer(
+    wrapped_agent=adapter,
+    agent_id="optional-agent-id",
+)
+
+app = server.create_app(
+    port=8080,
+    host="0.0.0.0",
+    tunnel="cloudflare",  # or "ngrok" or "none"
+)
+```
+
+## Development
+
+### Setup
+
+```bash
+# Clone the repository
+git clone https://github.com/innowhyte/quraite-python.git
+cd quraite-python
+
+# Install dependencies
+pip install -e ".[dev,test]"
+```
+
+### Running Tests
+
+```bash
+pytest
+```
+
+### Building
+
+```bash
+make build
+```
+
+### Publishing
+
+```bash
+# Update version
+make update-version v=0.4.0
+
+# Build
+make build
+
+# Publish to Test PyPI
+make publish
+# Enter username as "__token__" and then enter your API key
+```
+
+## Requirements
+
+- Python 3.10+
+- See `pyproject.toml` for full dependency list
+
+## License
+
+See [LICENSE](LICENSE) file for details.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## Support
+
+For issues, questions, or contributions, please visit the [Quraite platform](https://quraite.ai) or open an issue on GitHub.
+
+## Changelog
+
+See the repository's commit history for detailed changes.

{quraite-0.0.2.dist-info → quraite-0.1.1.dist-info}/RECORD

@@ -5,7 +5,7 @@ quraite/adapters/base.py,sha256=sgzXuCRt81LyH7kjP3UsccbgDbgVQeHKOfqcXah1mHo,3917
 quraite/adapters/bedrock_agents_adapter.py,sha256=2G-zUXqhNSzpyxut2UQgqTfe01MWcdjt1ajZIb43CUM,14136
 quraite/adapters/flowise_adapter.py,sha256=yLJ0tjDWMtTzm0bRYbhjfRm6wd5A6DqbHhqemy_FW48,10349
 quraite/adapters/google_adk_adapter.py,sha256=Ci7L54gA6pEH3-qcZ0PW1qODV6flJsVVbL9sN78FT_Y,7390
-quraite/adapters/http_adapter.py,sha256=rI800-94fpkoQH4vST311KEi7gwnl3XZh13emDcB8JE,7842
+quraite/adapters/http_adapter.py,sha256=y5ft65fF6SfvJXkhDkoglvq6dv6_VlCWDTZSCLEgssE,7883
 quraite/adapters/langflow_adapter.py,sha256=zGbDSd7Q_AZZ0ICByedsBIl5yNJ0hN6tQZgpUyN41-E,6946
 quraite/adapters/langgraph_adapter.py,sha256=WqmbP6Zw1lwfSCBf_O7oKNoGEb_1-zw_PMS1v71i3-w,11603
 quraite/adapters/langgraph_server_adapter.py,sha256=OhMx370Uzrvbp4yMOtgKkjQFI5u1xboKq0ybQRsBD90,9694
@@ -13,13 +13,13 @@ quraite/adapters/n8n_adapter.py,sha256=CCIOcZNxQw-69xdf9BVX9Jyt8i666AlsE2DJHsY8l
 quraite/adapters/openai_agents_adapter.py,sha256=iCFOWrZ-HnLoWOB-xsyJZf37Nh5QW5j8sHNSkjSWdGc,9665
 quraite/adapters/pydantic_ai_adapter.py,sha256=gps_90Zp8NcAiDX26-py4MKN2B5_jPEvgroRi8kjfQU,10811
 quraite/adapters/smolagents_adapter.py,sha256=QhEyMDlFkkXPSc5PiQTxMA9i2fRitzNcMdEsZwe9QVY,5448
-quraite/logger.py,sha256=u-0syR9efyCfxQSiPRWYYPSny-Z5DTNC-udxYATdLhU,1654
+quraite/logger.py,sha256=Py5GRQfD_s5FVb2Ziz5JxJk9AT4ve6w_iePbOSQkwH4,1601
 quraite/schema/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-quraite/schema/message.py,sha256=Rn77vBOuHTScDDC08deejat2-8IEphMT-k63tOSVpr8,1297
+quraite/schema/message.py,sha256=D6HWaZJOcoKObzDD-vo4Qg-chJDyOSwC-9XiNv_0xFc,2416
 quraite/schema/response.py,sha256=HUD_TyU6nibfXgRzdpD9LGoRtptD663oq7INy1sqaS4,412
 quraite/serve/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 quraite/serve/cloudflared.py,sha256=7XR1tPl0E3Feawo-6VCM8SXfCAie4cw9T1mx-ZNVJKw,6482
-quraite/serve/local_agent.py,sha256=UKg2vyO0U1wrFpzGAxDyIBTvisz8ynHfbCWBnr8FY70,12858
+quraite/serve/local_agent.py,sha256=8-a_4AeHeK3nTsgoDJVcTx7s4YvPoUhd6Zu3KVWEVAQ,12845
 quraite/traces/traces_adk_openinference.json,sha256=QjXAxMUEdSBcA5pCMOPiDU2_0NDsctEP6IFB6BIps9U,35957
 quraite/traces/traces_agno_multi_agent.json,sha256=FEW_zkSCKYizKG40KNvfXuouXsmOTdsPC7nnXWaKLfE,65098
 quraite/traces/traces_agno_openinference.json,sha256=p_tyBAp9KaT23PqGBU1cSMli7By0vss9Vpm3tL4pTMM,36871
@@ -39,11 +39,11 @@ quraite/tracing/constants.py,sha256=KhBIHkHRXAGW6xqa9vFa1LnA94C-EUTrWh5zNsx_z4Y,
 quraite/tracing/span_exporter.py,sha256=0S3qyPgtPfZtb-IhEoQKm0ciFZoHvlaFUcqbNtDh7kM,4676
 quraite/tracing/span_processor.py,sha256=mp5AR5RbRz1ddgJEK07CbXRL8NfaFj2DXP1bs9xcf4w,1603
 quraite/tracing/tool_extractors.py,sha256=BXTr0lT570jSlQtwLvFGarEvBSkvAs07YSo6Ah9Qkkw,9232
-quraite/tracing/trace.py,sha256=Ft4WdXoofW7G5NCyTMFjEe0rg1UmvadiVn1ToAJ0EyE,18506
+quraite/tracing/trace.py,sha256=bLIXyk8XXRC6LcPImDnwowW20eg2WI6qUW6-SFrTLpQ,21646
 quraite/tracing/types.py,sha256=sWyp-7Qc8zsWN6ltem8OSTRIgKWbqnQSfsTKX6RrrB8,4948
 quraite/tracing/utils.py,sha256=Vm5q_iN_K1f_nEMpkQzv6jiUPpS2Yzo_VP5ZVmJZdBQ,5673
 quraite/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 quraite/utils/json_utils.py,sha256=RewoObREfHnLBVI6MBCIEov6CaIxs8d67jbKEH79mQ0,18686
-quraite-0.0.2.dist-info/WHEEL,sha256=5w2T7AS2mz1-rW9CNagNYWRCaB0iQqBMYLwKdlgiR4Q,78
-quraite-0.0.2.dist-info/METADATA,sha256=6tNvIA4ylYwUHXdFoFoj2hhA5je8t8h9-Z9lY-BzaW4,1492
-quraite-0.0.2.dist-info/RECORD,,
+quraite-0.1.1.dist-info/WHEEL,sha256=5w2T7AS2mz1-rW9CNagNYWRCaB0iQqBMYLwKdlgiR4Q,78
+quraite-0.1.1.dist-info/METADATA,sha256=av4RLcrkIZpgsYRyY3IZ1G8opLtP_6QBOBM-ft-p64M,11163
+quraite-0.1.1.dist-info/RECORD,,

quraite-0.0.2.dist-info/METADATA

@@ -1,44 +0,0 @@
-Metadata-Version: 2.3
-Name: quraite
-Version: 0.0.2
-Summary: This project provides adaptors and methods to integrate with the Quraite platform
-Author: Shiv Mohith
-Author-email: Shiv Mohith <shivmohith8@gmail.com>
-Requires-Dist: aiohttp>=3.13.2
-Requires-Dist: fastapi>=0.121.1
-Requires-Dist: httpx>=0.28.1
-Requires-Dist: openinference-semantic-conventions>=0.1.25
-Requires-Dist: opentelemetry-api>=1.37.0
-Requires-Dist: opentelemetry-sdk>=1.37.0
-Requires-Dist: pydantic>=2.12.4
-Requires-Dist: python-dotenv>=1.2.1
-Requires-Dist: uvicorn>=0.38.0
-Requires-Dist: agno>=2.3.4 ; extra == 'agno'
-Requires-Dist: boto3>=1.40.70 ; extra == 'bedrock'
-Requires-Dist: google-adk>=1.18.0 ; extra == 'google-adk'
-Requires-Dist: langchain>=1.0.5 ; extra == 'langgraph'
-Requires-Dist: langgraph>=1.0.3 ; extra == 'langgraph'
-Requires-Dist: openai-agents>=0.5.0 ; extra == 'openai-agents'
-Requires-Dist: pydantic-ai>=1.25.0 ; extra == 'pydantic-ai'
-Requires-Dist: pyngrok>=7.5.0 ; extra == 'pyngrok'
-Requires-Dist: smolagents>=1.23.0 ; extra == 'smolagents'
-Requires-Python: >=3.10
-Provides-Extra: agno
-Provides-Extra: bedrock
-Provides-Extra: google-adk
-Provides-Extra: langgraph
-Provides-Extra: openai-agents
-Provides-Extra: pydantic-ai
-Provides-Extra: pyngrok
-Provides-Extra: smolagents
-Description-Content-Type: text/markdown
-
-## Quraite Python SDK
-
-### Publishing to Test PyPI
-
-```bash
-make update-version v=0.4.0
-make build
-make publish-test-pypi # enter user name as "__token__" and then enter the key
-```