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

quraite/tracing/span_processor.py

@@ -1,4 +1,3 @@
-import typing
 
 from opentelemetry.context import (
     _SUPPRESS_INSTRUMENTATION_KEY,
@@ -7,24 +6,24 @@ from opentelemetry.context import (
     detach,
     set_value,
 )
-from opentelemetry.sdk.trace.export import ReadableSpan, SpanExporter, SpanProcessor
+from opentelemetry.sdk.trace.export import ReadableSpan, SpanProcessor
 from opentelemetry.trace import Span, logger
 
-from quraite.tracing.span_exporter import QuraiteInMemorySpanExporter
+from quraite.tracing.span_exporter import QuraiteSpanExporter
 
 
-class QuraiteSimpleSpanProcessor(SpanProcessor):
+class QuraiteSpanProcessor(SpanProcessor):
     """Simple SpanProcessor implementation.
 
     SimpleSpanProcessor is an implementation of `SpanProcessor` that
     passes ended spans directly to the configured `SpanExporter`.
     """
 
-    def __init__(self, span_exporter: SpanExporter):
-        self.span_exporter: QuraiteInMemorySpanExporter = span_exporter
+    def __init__(self, span_exporter: QuraiteSpanExporter):
+        self.span_exporter: QuraiteSpanExporter = span_exporter
 
     def on_start(
-        self, span: Span, parent_context: typing.Optional[Context] = None
+        self, span: Span, parent_context: Context | None = None
     ) -> None:
         pass
 

quraite/tracing/tool_extractors.py

@@ -10,7 +10,7 @@ from typing import Any, Protocol
 
 from openinference.semconv.trace import SpanAttributes
 
-from quraite.tracing.constants import Framework
+from quraite.constants.framework import Framework
 
 
 class ToolCallInfo:

quraite/tracing/trace.py

@@ -3,23 +3,28 @@ from __future__ import annotations
 
 import json
 from functools import cached_property
-from typing import Any, List, Optional
+from typing import Any
 
 from openinference.semconv.trace import OpenInferenceSpanKindValues, SpanAttributes
 from opentelemetry.sdk.trace import ReadableSpan
 from opentelemetry.sdk.trace import Span as OTelSpan
 from pydantic import BaseModel, ConfigDict, Field
 
+from quraite.constants.framework import Framework
 from quraite.logger import get_logger
-from quraite.schema.message import AssistantMessage, AssistantMessageMetadata
+from quraite.schema.message import (
+    AssistantMessage,
+    AssistantMessageMetadata,
+    MessageContentText,
+    SystemMessage,
+    ToolCall,
+    ToolMessage,
+    ToolMessageMetadata,
+)
 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
 
@@ -153,7 +158,7 @@ class AgentSpan(BaseModel):
             )
         )
 
-    def to_llm_messages(self) -> List[dict[str, Any]]:
+    def to_llm_messages(self) -> list[dict[str, Any]]:
         """
         Convert LLM span to output messages.
 
@@ -309,15 +314,21 @@ class AgentTrace(BaseModel):
                     arguments_str = function.get("arguments", "")
 
                     # Parse arguments - could be JSON string or already a dict
-                    arguments = {}
-                    if arguments_str:
-                        if isinstance(arguments_str, str):
+                    arguments = arguments_str if isinstance(arguments_str, dict) else {}
+                    if isinstance(arguments_str, str):
+                        result: str | dict = arguments_str
+                        for _ in range(3):
                             try:
-                                arguments = json.loads(arguments_str)
+                                result = json.loads(result)
+                                if not isinstance(result, str):
+                                    break
                             except (json.JSONDecodeError, TypeError):
-                                arguments = {}
-                        elif isinstance(arguments_str, dict):
-                            arguments = arguments_str
+                                logger.exception(
+                                    "Error loading JSON from arguments_str"
+                                )
+                                result = {}
+                                break
+                        arguments = result if isinstance(result, dict) else {}
 
                     tool_calls_list.append(
                         ToolCall(
@@ -405,9 +416,9 @@ class AgentTrace(BaseModel):
 
     def to_agent_trajectory(
         self,
-        framework: Optional[Framework] = Framework.DEFAULT,
-        only_leaf_llms: Optional[bool] = True,
-    ) -> List[AssistantMessage | ToolMessage]:
+        framework: Framework | None = Framework.DEFAULT,
+        only_leaf_llms: bool | None = True,
+    ) -> list[AssistantMessage | ToolMessage]:
         """
         Convert trace spans to agent trajectory.
 
@@ -468,7 +479,7 @@ class AgentTrace(BaseModel):
             return any(child_id in llm_span_ids for child_id in children)
 
         # Collect messages from spans
-        messages: List[AssistantMessage | ToolMessage] = []
+        messages: list[AssistantMessage | ToolMessage] = []
 
         for span in sorted_spans:
             span_id = str(span.context.span_id) if span.context.span_id else None
@@ -489,15 +500,16 @@ class AgentTrace(BaseModel):
                 # Use span method to extract tool message
                 tool_msg = span.to_tool_message(framework=framework)
                 if tool_msg:
-                    converted = self._convert_tool_message(tool_msg)
-                    if converted:
-                        converted.metadata = self._extract_tool_metadata(span)
-                        messages.append(converted)
+                    converted_tool = self._convert_tool_message(tool_msg)
+                    if converted_tool:
+                        tool_metadata = self._extract_tool_metadata(span)
+                        converted_tool.metadata = tool_metadata
+                        messages.append(converted_tool)
 
         return messages
 
     @cached_property
-    def system_messages(self) -> List[SystemMessage]:
+    def system_messages(self) -> list[SystemMessage]:
         """
         Extract unique system messages from all LLM spans in the trace.
 
@@ -505,7 +517,7 @@ class AgentTrace(BaseModel):
             List of unique system messages from LLM input messages (deduplicated)
         """
         seen_messages = set()
-        system_messages: List[SystemMessage] = []
+        system_messages: list[SystemMessage] = []
 
         for span in self.spans:
             if span.is_llm_call():

quraite/utils/json_utils.py

@@ -58,7 +58,7 @@ def parse_malformed_object(obj_str: str) -> dict[str, Any]:
     """
     Manually parse a malformed object string with key=value pairs.
     """
-    result = {}
+    result: dict[str, Any] = {}
 
     # Remove outer braces
     content = obj_str.strip()[1:-1]
@@ -173,7 +173,7 @@ def parse_content_object(content_str: str) -> dict[str, Any]:
         return {"raw": content_str}
 
     content = content_str[start:end]
-    result = {}
+    result: dict[str, Any] = {}
 
     # Split by commas, handling nested structures
     parts = []

{quraite-0.1.3.dist-info → quraite-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: quraite
-Version: 0.1.3
+Version: 0.1.4
 Summary: This project provides adaptors and methods to integrate with the Quraite platform
 Author: Shiv Mohith
 Author-email: Shiv Mohith <shivmohith8@gmail.com>
@@ -92,55 +92,43 @@ pip install 'quraite[langchain,pydantic-ai,agno]'
 Pass your compiled LangChain agent to the adapter and expose it as an HTTP API:
 
 ```python
-import asyncio
-import uvicorn
 from dotenv import load_dotenv
-from openinference.instrumentation import TracerProvider
-from openinference.instrumentation.langchain import LangChainInstrumentor
 
-from quraite.adapters import LangChainAdapter
-from quraite.serve.local_agent import LocalAgentServer
-from quraite.tracing.span_exporter import QuraiteInMemorySpanExporter
-from quraite.tracing.span_processor import QuraiteSimpleSpanProcessor
+from quraite import run_agent
+from quraite.adapters import LangchainAdapter
+from quraite.tracing import Framework, setup_tracing
 
 load_dotenv()
 
-# Set up tracing
-# Use Quraite's in-memory span exporter to capture the agent trajectory
-# and use it for evaluation.
-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 LangChain agent (created elsewhere)
 # agent = create_agent(...)
 
-# Wrap with Quraite adapter
-adapter = LangChainAdapter(
+# Setup tracing once
+tracer_provider = setup_tracing([Framework.LANGCHAIN])
+
+# Create adapter with tracer provider
+adapter = LangchainAdapter(
     agent_graph=agent,  # Pass your compiled LangChain agent here
     tracer_provider=tracer_provider,
 )
 
-# Create and start server with Cloudflare tunnel
-server = LocalAgentServer(
-    wrapped_agent=adapter,
+# Option 1: Use run_agent to start the server (simplest)
+run_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"
 )
 
-# Option 1: Use the start method to start the server
-asyncio.run(server.start(host="0.0.0.0", port=8080))
+# Option 2: Use create_app for more control (e.g., with uvicorn reload)
+from quraite import create_app
+import uvicorn
+
+app = create_app(adapter, agent_id="your-agent-id")
 
-# Option 2: Use uvicorn to start the server for auto-reload
-# if __name__ == "__main__":
-#     uvicorn.run("local_server:app", host="0.0.0.0", port=8080, reload=True)
+if __name__ == "__main__":
+    uvicorn.run("local_server:app", host="0.0.0.0", port=8080, reload=True)
 ```
 
 The server exposes:
@@ -191,20 +179,14 @@ Most agent frameworks return agent steps, but lack critical observability data.
 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()
+from quraite.tracing import Framework, setup_tracing
 
-# Add Quraite span exporter and processor to the tracer provider
-quraite_span_exporter = QuraiteInMemorySpanExporter()
-quraite_span_processor = QuraiteSimpleSpanProcessor(quraite_span_exporter)
-tracer_provider.add_span_processor(quraite_span_processor)
+# Setup tracing once at app startup
+tracer_provider = setup_tracing([Framework.LANGCHAIN])
 
-# Instrument your framework with OpenInference
-from openinference.instrumentation.langchain import LangChainInstrumentor
-LangChainInstrumentor().instrument(tracer_provider=tracer_provider)
+# Pass to adapter
+from quraite.adapters import LangchainAdapter
+adapter = LangchainAdapter(agent_graph=agent, tracer_provider=tracer_provider)
 ```
 
 ### Message Schema
@@ -245,16 +227,18 @@ tool_msg = ToolMessage(
 )
 ```
 
-### Response Format
+### Invoke Input and Output
 
-Agent invocations return an `AgentInvocationResponse`:
+Agent invocations use structured `InvokeInput` and return `InvokeOutput`:
 
 ```python
-from quraite.schema.response import AgentInvocationResponse
+from quraite.schema.invoke import InvokeInput, InvokeOutput
 
-response: AgentInvocationResponse = await adapter.ainvoke(
-    input=[user_msg],
-    session_id="session-123"
+response: InvokeOutput = await adapter.ainvoke(
+    input=InvokeInput(
+        user_message=user_msg,
+        session_id="session-123"
+    )
 )
 
 # Access trajectory (list of messages)
@@ -292,37 +276,45 @@ All adapters inherit from `BaseAdapter`:
 
 ```python
 from quraite.adapters.base import BaseAdapter
+from quraite.schema.invoke import InvokeInput, InvokeOutput
 
 class MyAdapter(BaseAdapter):
     async def ainvoke(
         self,
-        input: List[AgentMessage],
-        session_id: str | None,
-    ) -> AgentInvocationResponse:
+        input: InvokeInput,
+    ) -> InvokeOutput:
         # Implementation
+        # Access user_message: input.user_message
+        # Access session_id: input.session_id
         pass
 ```
 
-### LocalAgentServer
+### Running Your Agent
 
-Create a local HTTP server for your agent:
+Use `run_agent` or `create_app` to start a local HTTP server for your agent:
 
 ```python
-import asyncio
-from quraite.serve.local_agent import LocalAgentServer
+from quraite import run_agent, create_app
 
-server = LocalAgentServer(
-    wrapped_agent=adapter,
+# Simple approach: run_agent handles everything
+run_agent(
+    adapter,
     agent_id="optional-agent-id",
-)
-
-app = server.create_app(
     port=8080,
     host="0.0.0.0",
     tunnel="cloudflare",  # or "ngrok" or "none"
 )
 
-asyncio.run(server.start(host="0.0.0.0", port=8080))
+# Advanced approach: create_app for more control (e.g., uvicorn reload)
+import uvicorn
+
+app = create_app(
+    adapter,
+    agent_id="optional-agent-id",
+)
+
+if __name__ == "__main__":
+    uvicorn.run("local_server:app", host="0.0.0.0", port=8080, reload=True)
 ```
 
 ## Development

quraite-0.1.4.dist-info/RECORD

@@ -0,0 +1,37 @@
+quraite/__init__.py,sha256=7jS37UVvrYYGKwjhChMCHiSFN4zaAFquZL9weIQMJPE,166
+quraite/adapters/__init__.py,sha256=-2FPY_cUHtIKVlB7O3SUkgrEp1iybJ1z3VM52SjYk3I,4842
+quraite/adapters/agno_adapter.py,sha256=pVq5C3mOBAYb62lpjsjmS-2KtDJtnai0mAk4dxvEhyM,4184
+quraite/adapters/base.py,sha256=PIeWZTMzp9SEXtkYyd-Qc2uNhMjie2mRT6U3xTJHSdo,2358
+quraite/adapters/bedrock_agents_adapter.py,sha256=knwz6RA1-aibMIMWCrsf-L81XBAehVWjCWs8s-MI2Zw,12024
+quraite/adapters/flowise_adapter.py,sha256=2uyCbC7mUpZljrJZRnFzdMw3piECZVViQ6jR75FlppA,8682
+quraite/adapters/google_adk_adapter.py,sha256=jxawemzLxQOf0FaCz39Se_0nAWR1h0UHYeUK-9vFSI8,5264
+quraite/adapters/http_adapter.py,sha256=qf0nS8LzC10fbolCQ62HItGoAYoNN0o-qv_Yooqyn-8,7370
+quraite/adapters/langchain_adapter.py,sha256=FCt9K3MCqG-lj71QapKhSELwCjY_Fc3DHhL_-YoQrns,8993
+quraite/adapters/langchain_server_adapter.py,sha256=KbakUla41-mMFhNdb4Q1Ie8rRCmLU-fzMx-lGRolSLI,7504
+quraite/adapters/langflow_adapter.py,sha256=D1dh7L9UrhONPwVGtcfj8G4LguRTpzOyskQJ_mb7TTg,5249
+quraite/adapters/n8n_adapter.py,sha256=TJdDLA2IEd_wCKQRCs9qzs-9iLoPoENefExUGi7H1XY,6417
+quraite/adapters/openai_agents_adapter.py,sha256=lcc2v1Q89E1j9A12IY8UfMoxM39HlJuIrhxZXax0SzI,8537
+quraite/adapters/pydantic_ai_adapter.py,sha256=MzdA-qPZxkMEVYafXcwDG-_7P3JRP1D1__BXAh6GNnA,8171
+quraite/adapters/smolagents_adapter.py,sha256=aJyLf5-6dMh1bQQ91KoaeVBGVyIRz7fbqXFIMO9DsF8,3106
+quraite/constants/framework.py,sha256=ZPTXUP6HtkzGUUQgDBr6rV6AXHC-Uf3RJ-XArmjqsbI,311
+quraite/logger.py,sha256=Py5GRQfD_s5FVb2Ziz5JxJk9AT4ve6w_iePbOSQkwH4,1601
+quraite/schema/__init__.py,sha256=-oZxv5ufJWyzZo8YDrP5USYr-UPtl7qPCzIvV2PvtbI,165
+quraite/schema/invoke.py,sha256=vHgQGro8uGC8sw-JzgQUJ8CrzVRWlC5A14OhIvuyZYM,1317
+quraite/schema/message.py,sha256=84dCcV-Dm4vkM1DGxNerYPd-ybz_hvPBRUky_dcHX20,2226
+quraite/serve/__init__.py,sha256=GCRJSZKCXJXMjvg1e8HhXLTdCbFoR7abcNB7rYS2Gcs,158
+quraite/serve/cloudflared.py,sha256=YIQkUq0pIwJDLkZoVhcO77O3yMyI1rAhN0ywzN4fsws,6518
+quraite/serve/server.py,sha256=Hw7yDdzAfQi-8FtwEpn-mKuJlEUJi-hlZJR5VSlgys8,9756
+quraite/tracing/__init__.py,sha256=eemwel7P00Outi6v0OAP5KnUWPlWzoRrQW-aiRAAEds,843
+quraite/tracing/constants.py,sha256=y43slSQiyoGWoHmos30w20Bts9r-YsrlZYjYxzLmSLw,48
+quraite/tracing/setup.py,sha256=YUEcsJse653uc-TXwczC34MaFc2q952umUROjGKjSgk,4717
+quraite/tracing/span_exporter.py,sha256=3ZM1RwZ53PU7CM_5KZjix0Oi46q7nk4ThNj0eTa53Vo,3880
+quraite/tracing/span_processor.py,sha256=uXnTJKqs89-qGidBE33I5J0e6vZ25GXzfdeKcfnUd58,1383
+quraite/tracing/tool_extractors.py,sha256=3ai2iavPUunf_lZArll6k3qZWHWTLsJDrlnDjLMTUTg,9802
+quraite/tracing/trace.py,sha256=siXt246DACghHmr--I5oazmWG_wRzpr0gaku_lUi-ts,22030
+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=7obT8t92z6dK8nerGgfjVL_v5y96e8wX8eglGAHI50Y,18718
+quraite-0.1.4.dist-info/WHEEL,sha256=5w2T7AS2mz1-rW9CNagNYWRCaB0iQqBMYLwKdlgiR4Q,78
+quraite-0.1.4.dist-info/METADATA,sha256=xv9GN6JbHYMvrzEJ2wcxF9IVyo20gBQjghH6jykZBgM,11398
+quraite-0.1.4.dist-info/RECORD,,

quraite/schema/response.py

@@ -1,16 +0,0 @@
-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