sythra 0.1.0__tar.gz

sythra-0.1.0/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: sythra
+Version: 0.1.0
+Summary: Runtime intelligence for AI agents: find the first point where a run went wrong, what it cost, and how to fix it.
+Author-email: Sythra <sythra.hq@gmail.com>
+Project-URL: Homepage, https://sythra.vercel.app
+Project-URL: Repository, https://github.com/sythrahq/sythra
+Keywords: ai,agents,observability,llm,debugging
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.24
+
+# Sythra
+
+Runtime intelligence for AI agents. When a run goes wrong, Sythra finds the first point where it diverged, shows what it cascaded into, what it cost, and what to do about it.
+
+## Install
+
+```
+pip install sythra
+```
+
+## Quick start
+
+Create an agent in your dashboard at https://sythra.vercel.app to get an API key, then wrap your agent function:
+
+```python
+from sythra import Sythra
+
+sythra = Sythra(api_key="YOUR_API_KEY", agent_name="my-agent")
+
+@sythra.observe
+def run_agent(question):
+    ...  # your agent code
+```
+
+Each call is recorded with its outcome, duration and steps. Works with LangChain, LangGraph, CrewAI and the OpenAI Agents SDK.
+
+## Privacy
+
+Sythra records what your agent did (tools, models, cost, outcome), not what it said. Prompt and response content is never captured unless you turn it on.
+
+## Links
+
+- Dashboard: https://sythra.vercel.app
+- Source: https://github.com/sythrahq/sythra
+- Support: sythra.hq@gmail.com

sythra-0.1.0/README.md

@@ -0,0 +1,35 @@
+# Sythra
+
+Runtime intelligence for AI agents. When a run goes wrong, Sythra finds the first point where it diverged, shows what it cascaded into, what it cost, and what to do about it.
+
+## Install
+
+```
+pip install sythra
+```
+
+## Quick start
+
+Create an agent in your dashboard at https://sythra.vercel.app to get an API key, then wrap your agent function:
+
+```python
+from sythra import Sythra
+
+sythra = Sythra(api_key="YOUR_API_KEY", agent_name="my-agent")
+
+@sythra.observe
+def run_agent(question):
+    ...  # your agent code
+```
+
+Each call is recorded with its outcome, duration and steps. Works with LangChain, LangGraph, CrewAI and the OpenAI Agents SDK.
+
+## Privacy
+
+Sythra records what your agent did (tools, models, cost, outcome), not what it said. Prompt and response content is never captured unless you turn it on.
+
+## Links
+
+- Dashboard: https://sythra.vercel.app
+- Source: https://github.com/sythrahq/sythra
+- Support: sythra.hq@gmail.com

sythra-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sythra"
+version = "0.1.0"
+description = "Runtime intelligence for AI agents: find the first point where a run went wrong, what it cost, and how to fix it."
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = ["httpx>=0.24"]
+authors = [{ name = "Sythra", email = "sythra.hq@gmail.com" }]
+keywords = ["ai", "agents", "observability", "llm", "debugging"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://sythra.vercel.app"
+Repository = "https://github.com/sythrahq/sythra"
+
+[tool.setuptools]
+packages = ["sythra"]

sythra-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sythra-0.1.0/sythra/__init__.py

@@ -0,0 +1,5 @@
+from .client import Sythra
+
+__version__ = "0.1.0"
+
+__all__ = ["Sythra"]

sythra-0.1.0/sythra/client.py

@@ -0,0 +1,154 @@
+import os
+import time
+import functools
+import asyncio
+import threading
+import atexit
+import httpx
+from typing import Callable
+
+
+class Sythra:
+    """
+    The main SDK client. A developer creates one instance of this,
+    then uses @sythra.observe to wrap their agent function.
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        agent_name: str,
+        capture_content: bool = False,
+        flush_interval: float = 0.5,
+        framework: str | None = None,
+        base_url: str | None = None,
+    ):
+        self.api_key = api_key
+        self.agent_name = agent_name
+        self.capture_content = capture_content
+        self.framework = framework
+
+        # Where to send data. Order of priority: the base_url argument, then
+        # the SYTHRA_BASE_URL environment variable, then the live site.
+        # For local testing, set SYTHRA_BASE_URL=http://localhost:3000
+        resolved_base = base_url or os.environ.get("SYTHRA_BASE_URL") or "https://sythra.vercel.app"
+        self._ingest_url = resolved_base.rstrip("/") + "/api/ingest"
+
+        self._current_steps = []
+
+        self._flush_interval = flush_interval
+        self._event_queue = []
+        self._queue_lock = threading.Lock()
+        self._stop_flag = threading.Event()
+
+        self._flush_thread = threading.Thread(target=self._flush_loop, daemon=True)
+        self._flush_thread.start()
+
+        atexit.register(self.flush)
+
+    def log_step(
+        self,
+        step_type: str,
+        step_name: str,
+        status: str = "success",
+        latency_ms: int = 0,
+        cost_usd: float = 0.0,
+        error_type: str | None = None,
+        error_message: str | None = None,
+        prompt_tokens: int | None = None,
+        completion_tokens: int | None = None,
+        model_name: str | None = None,
+    ):
+        self._current_steps.append({
+            "step_type": step_type,
+            "step_name": step_name,
+            "status": status,
+            "latency_ms": latency_ms,
+            "cost_usd": cost_usd,
+            "error_type": error_type,
+            "error_message": error_message,
+            "prompt_tokens": prompt_tokens,
+            "completion_tokens": completion_tokens,
+            "model_name": model_name,
+        })
+
+    def observe(self, func: Callable) -> Callable:
+        if asyncio.iscoroutinefunction(func):
+            @functools.wraps(func)
+            async def async_wrapper(*args, **kwargs):
+                start_time = time.time()
+                outcome = "success"
+                error_type = None
+                error_message = None
+
+                try:
+                    result = await func(*args, **kwargs)
+                    return result
+                except Exception as e:
+                    outcome = "failure"
+                    error_type = type(e).__name__
+                    error_message = str(e)[:300]
+                    raise
+                finally:
+                    duration_ms = int((time.time() - start_time) * 1000)
+                    self._queue_event(outcome, duration_ms, error_type, error_message=error_message)
+
+            return async_wrapper
+        else:
+            @functools.wraps(func)
+            def sync_wrapper(*args, **kwargs):
+                start_time = time.time()
+                outcome = "success"
+                error_type = None
+                error_message = None
+
+                try:
+                    result = func(*args, **kwargs)
+                    return result
+                except Exception as e:
+                    outcome = "failure"
+                    error_type = type(e).__name__
+                    error_message = str(e)[:300]
+                    raise
+                finally:
+                    duration_ms = int((time.time() - start_time) * 1000)
+                    self._queue_event(outcome, duration_ms, error_type, error_message=error_message)
+
+            return sync_wrapper
+
+    def _queue_event(self, outcome: str, duration_ms: int, error_type: str | None, framework: str | None = None, error_message: str | None = None):
+        event = {
+            "agent_name": self.agent_name,
+            "outcome": outcome,
+            "duration_ms": duration_ms,
+            "error_type": error_type,
+            "error_message": error_message,
+            "steps": self._current_steps,
+            "framework": framework or self.framework,
+        }
+        with self._queue_lock:
+            self._event_queue.append(event)
+        self._current_steps = []
+
+    def _flush_loop(self):
+        while not self._stop_flag.wait(self._flush_interval):
+            self.flush()
+
+    def flush(self):
+        with self._queue_lock:
+            if not self._event_queue:
+                return
+            events_to_send = self._event_queue
+            self._event_queue = []
+
+        try:
+            response = httpx.post(
+                self._ingest_url,
+                json={"events": events_to_send},
+                headers={"Authorization": f"Bearer {self.api_key}"},
+                timeout=5.0,
+            )
+            if response.status_code != 200:
+                print(f"[sythra] warning: ingest returned {response.status_code}")
+        except Exception as e:
+            print(f"[sythra] warning: could not reach Sythra ({type(e).__name__}) — events not sent")

sythra-0.1.0/sythra/crewai_listener.py

@@ -0,0 +1,136 @@
+import time
+from typing import Optional
+
+from sythra.errors import extract_error_message
+
+try:
+    from crewai.events import (
+        BaseEventListener,
+        CrewKickoffStartedEvent,
+        CrewKickoffCompletedEvent,
+        CrewKickoffFailedEvent,
+        LLMCallStartedEvent,
+        LLMCallCompletedEvent,
+        LLMCallFailedEvent,
+        ToolUsageStartedEvent,
+        ToolUsageFinishedEvent,
+        ToolUsageErrorEvent,
+    )
+except ImportError:
+    raise ImportError(
+        "CrewAI auto-instrumentation requires crewai. "
+        "Install it with: pip install crewai"
+    )
+
+
+class SythraCrewListener(BaseEventListener):
+    """
+    Register this once and Sythra captures every LLM call, tool call, and
+    crew run automatically — no manual @sythra.observe or log_step()
+    calls needed.
+
+    Usage:
+        from sythra.crewai_listener import SythraCrewListener
+        SythraCrewListener(sythra)  # keep a reference so it isn't garbage collected
+        crew.kickoff()
+    """
+
+    def __init__(self, sythra_client):
+        super().__init__()
+        self.sythra = sythra_client
+        self._crew_start_time: Optional[float] = None
+        # CrewAI's events don't carry a per-call ID like LangChain's
+        # run_id, so we track "what's currently running" as a stack —
+        # correct for CrewAI's normal sequential execution.
+        self._llm_call_stack = []
+        self._tool_call_stack = []
+
+    def setup_listeners(self, crewai_event_bus):
+        @crewai_event_bus.on(CrewKickoffStartedEvent)
+        def on_crew_start(source, event):
+            self._crew_start_time = time.time()
+
+        @crewai_event_bus.on(CrewKickoffCompletedEvent)
+        def on_crew_complete(source, event):
+            if self._crew_start_time is not None:
+                duration_ms = int((time.time() - self._crew_start_time) * 1000)
+                self.sythra._queue_event("success", duration_ms, None, framework="crewai")
+                self._crew_start_time = None
+
+        @crewai_event_bus.on(CrewKickoffFailedEvent)
+        def on_crew_failed(source, event):
+            if self._crew_start_time is not None:
+                duration_ms = int((time.time() - self._crew_start_time) * 1000)
+                error = getattr(event, "error", None)
+                error_type = type(error).__name__ if isinstance(error, BaseException) else "CrewFailed"
+                error_message = extract_error_message(error) if error else None
+                self.sythra._queue_event("failure", duration_ms, error_type, framework="crewai", error_message=error_message)
+                self._crew_start_time = None
+
+        @crewai_event_bus.on(LLMCallStartedEvent)
+        def on_llm_start(source, event):
+            self._llm_call_stack.append(time.time())
+
+        @crewai_event_bus.on(LLMCallCompletedEvent)
+        def on_llm_complete(source, event):
+            start = self._llm_call_stack.pop() if self._llm_call_stack else None
+            latency_ms = int((time.time() - start) * 1000) if start else 0
+
+            prompt_tokens = None
+            completion_tokens = None
+            model_name = getattr(event, "model", None)
+            usage = getattr(event, "usage_metrics", None) or getattr(event, "usage", None)
+            if usage:
+                prompt_tokens = getattr(usage, "prompt_tokens", None)
+                completion_tokens = getattr(usage, "completion_tokens", None)
+
+            self.sythra.log_step(
+                "llm_call",
+                "LLM call",
+                latency_ms=latency_ms,
+                prompt_tokens=prompt_tokens,
+                completion_tokens=completion_tokens,
+                model_name=model_name,
+            )
+
+            # If there's no crew run currently tracked, this LLM call is
+            # standalone (no Crew wrapping it) — same edge case we fixed
+            # for LangChain. Treat it as the whole execution.
+            if self._crew_start_time is None:
+                self.sythra._queue_event("success", latency_ms, None, framework="crewai")
+
+        @crewai_event_bus.on(LLMCallFailedEvent)
+        def on_llm_failed(source, event):
+            start = self._llm_call_stack.pop() if self._llm_call_stack else None
+            latency_ms = int((time.time() - start) * 1000) if start else 0
+            error = getattr(event, "error", "LLMCallFailed")
+            error_type = type(error).__name__ if isinstance(error, BaseException) else "LLMCallFailed"
+            error_message = extract_error_message(error)
+            self.sythra.log_step(
+                "llm_call", "LLM call", status="error", latency_ms=latency_ms,
+                error_type=error_type, error_message=error_message,
+            )
+
+        @crewai_event_bus.on(ToolUsageStartedEvent)
+        def on_tool_start(source, event):
+            self._tool_call_stack.append(time.time())
+
+        @crewai_event_bus.on(ToolUsageFinishedEvent)
+        def on_tool_finish(source, event):
+            start = self._tool_call_stack.pop() if self._tool_call_stack else None
+            latency_ms = int((time.time() - start) * 1000) if start else 0
+            tool_name = getattr(event, "tool_name", "tool")
+            self.sythra.log_step("tool_call", tool_name, latency_ms=latency_ms)
+
+        @crewai_event_bus.on(ToolUsageErrorEvent)
+        def on_tool_error(source, event):
+            start = self._tool_call_stack.pop() if self._tool_call_stack else None
+            latency_ms = int((time.time() - start) * 1000) if start else 0
+            tool_name = getattr(event, "tool_name", "tool")
+            error = getattr(event, "error", "ToolUsageError")
+            error_type = type(error).__name__ if isinstance(error, BaseException) else "ToolUsageError"
+            error_message = extract_error_message(error)
+            self.sythra.log_step(
+                "tool_call", tool_name, status="error", latency_ms=latency_ms,
+                error_type=error_type, error_message=error_message,
+            )

sythra-0.1.0/sythra/errors.py

@@ -0,0 +1,37 @@
+import json
+import re
+
+
+def extract_error_message(error: BaseException) -> str:
+    """
+    Turn a raw exception into a short, human-readable message.
+
+    Many LLM provider errors (Groq, OpenAI, etc.) raise an exception whose
+    str() is a long message wrapping embedded JSON, e.g.:
+        GroqException - {"error":{"message":"The model 'x' does not
+        exist...","type":"invalid_request_error"}}
+
+    That's unreadable on a dashboard. This pulls the real message out of
+    the embedded JSON when there is one, and falls back to a trimmed
+    version of the raw string when there isn't.
+    """
+    raw = str(error)
+
+    # Look for the first {...} block in the string and try to parse it.
+    match = re.search(r"\{.*\}", raw, re.DOTALL)
+    if match:
+        try:
+            parsed = json.loads(match.group(0))
+            # Common shapes: {"error": {"message": "..."}} or {"message": "..."}
+            if isinstance(parsed, dict):
+                err_obj = parsed.get("error", parsed)
+                if isinstance(err_obj, dict) and "message" in err_obj:
+                    return str(err_obj["message"])
+        except (json.JSONDecodeError, AttributeError, TypeError):
+            pass
+
+    # No embedded JSON, or it didn't parse — fall back to the raw string,
+    # trimmed so it never becomes its own wall of text.
+    if len(raw) > 300:
+        return raw[:300] + "..."
+    return raw

sythra-0.1.0/sythra/langchain_handler.py

@@ -0,0 +1,117 @@
+import time
+from typing import Any, Dict, List, Optional
+from uuid import UUID
+
+from sythra.errors import extract_error_message
+
+try:
+    from langchain_core.callbacks.base import BaseCallbackHandler
+except ImportError:
+    raise ImportError(
+        "LangChain auto-instrumentation requires langchain-core. "
+        "Install it with: pip install langchain-core"
+    )
+
+
+class SythraCallbackHandler(BaseCallbackHandler):
+    """
+    Drop this into any LangChain chain/agent's callbacks list and Sythra
+    captures every LLM call and tool call automatically — no manual
+    @sythra.observe or log_step() calls needed.
+
+    Usage:
+        handler = SythraCallbackHandler(sythra)
+        result = my_chain.invoke(input, config={"callbacks": [handler]})
+    """
+
+    def __init__(self, sythra_client):
+        self.sythra = sythra_client
+        self._start_times: Dict[UUID, float] = {}
+        self._chain_start_time: Optional[float] = None
+
+    def on_chain_start(
+        self, serialized: Dict[str, Any], inputs: Dict[str, Any], *, run_id: UUID, parent_run_id: Optional[UUID] = None, **kwargs: Any
+    ) -> None:
+        if parent_run_id is None:
+            self._chain_start_time = time.time()
+
+    def on_chain_end(
+        self, outputs: Dict[str, Any], *, run_id: UUID, parent_run_id: Optional[UUID] = None, **kwargs: Any
+    ) -> None:
+        if parent_run_id is None and self._chain_start_time is not None:
+            duration_ms = int((time.time() - self._chain_start_time) * 1000)
+            self.sythra._queue_event("success", duration_ms, None)
+            self._chain_start_time = None
+
+    def on_chain_error(
+        self, error: BaseException, *, run_id: UUID, parent_run_id: Optional[UUID] = None, **kwargs: Any
+    ) -> None:
+        if parent_run_id is None and self._chain_start_time is not None:
+            duration_ms = int((time.time() - self._chain_start_time) * 1000)
+            self.sythra._queue_event(
+                "failure", duration_ms, type(error).__name__,
+                error_message=extract_error_message(error),
+            )
+            self._chain_start_time = None
+
+    def on_llm_start(
+        self, serialized: Dict[str, Any], prompts: List[str], *, run_id: UUID, **kwargs: Any
+    ) -> None:
+        self._start_times[run_id] = time.time()
+
+    def on_llm_end(self, response: Any, *, run_id: UUID, parent_run_id: Optional[UUID] = None, **kwargs: Any) -> None:
+        start = self._start_times.pop(run_id, None)
+        latency_ms = int((time.time() - start) * 1000) if start else 0
+
+        prompt_tokens = None
+        completion_tokens = None
+        model_name = None
+        try:
+            usage = response.llm_output.get("token_usage", {}) if response.llm_output else {}
+            model_name = response.llm_output.get("model_name") if response.llm_output else None
+            prompt_tokens = usage.get("prompt_tokens")
+            completion_tokens = usage.get("completion_tokens")
+        except Exception:
+            pass
+
+        self.sythra.log_step(
+            "llm_call",
+            "LLM call",
+            latency_ms=latency_ms,
+            prompt_tokens=prompt_tokens,
+            completion_tokens=completion_tokens,
+            model_name=model_name,
+        )
+
+        if parent_run_id is None:
+            self.sythra._queue_event("success", latency_ms, None)
+
+    def on_llm_error(self, error: BaseException, *, run_id: UUID, **kwargs: Any) -> None:
+        start = self._start_times.pop(run_id, None)
+        latency_ms = int((time.time() - start) * 1000) if start else 0
+        self.sythra.log_step(
+            "llm_call", "LLM call", status="error", latency_ms=latency_ms,
+            error_type=type(error).__name__,
+            error_message=extract_error_message(error),
+        )
+
+    def on_tool_start(
+        self, serialized: Dict[str, Any], input_str: str, *, run_id: UUID, **kwargs: Any
+    ) -> None:
+        self._start_times[run_id] = time.time()
+
+    def on_tool_end(self, output: Any, *, run_id: UUID, **kwargs: Any) -> None:
+        start = self._start_times.pop(run_id, None)
+        latency_ms = int((time.time() - start) * 1000) if start else 0
+        tool_name = kwargs.get("name", "tool")
+        self.sythra.log_step("tool_call", tool_name, latency_ms=latency_ms)
+
+    def on_tool_error(self, error: BaseException, *, run_id: UUID, **kwargs: Any) -> None:
+        start = self._start_times.pop(run_id, None)
+        latency_ms = int((time.time() - start) * 1000) if start else 0
+        tool_name = kwargs.get("name", "tool")
+        self.sythra.log_step(
+            "tool_call", tool_name, status="error", latency_ms=latency_ms,
+            error_type=type(error).__name__,
+            error_message=extract_error_message(error),
+        )

sythra-0.1.0/sythra/openai_agents_listener.py

@@ -0,0 +1,63 @@
+import os
+import time
+import asyncio
+from dotenv import load_dotenv
+from openai import AsyncOpenAI
+from agents import Agent, Runner
+from agents.models.openai_chatcompletions import OpenAIChatCompletionsModel
+
+from sythra.client import Sythra
+from sythra.openai_agents_listener import SythraAgentsHooks
+from sythra.errors import extract_error_message
+
+load_dotenv()
+os.environ.setdefault("OPENAI_AGENTS_DISABLE_TRACING", "1")
+
+sythra = Sythra(
+    api_key="sk-sythra-6fb7ec0d9ecf410ece3d88ad6d80a1b53f900f26f85a2c8d",
+    agent_name="main agent",
+    framework="openai-agents",
+)
+
+hooks = SythraAgentsHooks(sythra)
+
+groq_client = AsyncOpenAI(
+    api_key=os.getenv("GROQ_API_KEY"),
+    base_url="https://api.groq.com/openai/v1",
+)
+
+groq_model = OpenAIChatCompletionsModel(
+    model="openai/gpt-oss-20b",
+    openai_client=groq_client,
+)
+
+agent = Agent(
+    name="Assistant",
+    instructions="You are a helpful, concise assistant.",
+    model=groq_model,
+)
+
+
+async def main():
+    start_time = time.time()
+    try:
+        result = await Runner.run(agent, "In one short sentence, what is the capital of Italy?", hooks=hooks)
+        duration_ms = int((time.time() - start_time) * 1000)
+        sythra._queue_event("success", duration_ms, None, framework="openai-agents")
+        print("\nResult:", result.final_output)
+    except Exception as e:
+        duration_ms = int((time.time() - start_time) * 1000)
+        sythra._queue_event(
+            "failure", duration_ms, type(e).__name__,
+            framework="openai-agents",
+            error_message=extract_error_message(e),
+        )
+        raise
+    finally:
+        sythra.flush()
+        time.sleep(1)
+        print("Done — check the Executions page for a new 'main agent' entry.")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

sythra-0.1.0/sythra/pricing.py

@@ -0,0 +1,49 @@
+"""
+Per-model token pricing, in dollars per token (not per million — converted
+here so cost calculations elsewhere stay simple multiplication).
+
+IMPORTANT — this table WILL go stale. LLM pricing changes often (OpenAI
+raised its top-tier pricing 350% in a single move in April 2026; Anthropic
+cut Opus pricing 67% at the 4.6 launch). This is a best-effort snapshot,
+not a live feed. Review and update these numbers periodically — a wrong
+cost is worse than a missing one, which is why unknown models return
+None rather than a guessed price (see cost_for_model below).
+
+Prices verified from public provider pricing pages, ~Sep 2026.
+"""
+
+from typing import Optional
+
+# (input_price_per_token, output_price_per_token)
+_PRICING = {
+    # OpenAI
+    "gpt-4o": (2.50 / 1_000_000, 10.00 / 1_000_000),
+    "gpt-4o-mini": (0.15 / 1_000_000, 0.60 / 1_000_000),
+    "gpt-4.1": (2.00 / 1_000_000, 8.00 / 1_000_000),
+    "o3-mini": (1.10 / 1_000_000, 4.40 / 1_000_000),
+
+    # Anthropic
+    "claude-opus-4.8": (5.00 / 1_000_000, 25.00 / 1_000_000),
+    "claude-sonnet-4.6": (3.00 / 1_000_000, 15.00 / 1_000_000),
+    "claude-haiku-4.5": (1.00 / 1_000_000, 5.00 / 1_000_000),
+}
+
+
+def cost_for_model(model_name: str, prompt_tokens: int, completion_tokens: int) -> Optional[float]:
+    """
+    Returns the dollar cost for this many tokens on this model, or None
+    if the model isn't in our table. Callers should treat None as "cost
+    unknown" (log_step already defaults cost_usd to 0.0 for that case)
+    rather than falling back to a guessed number.
+    """
+    if not model_name:
+        return None
+
+    # Match loosely — providers often return versioned names
+    # ("gpt-4o-2024-05-13") that won't exactly match our table keys.
+    normalized = model_name.lower()
+    for key, (in_price, out_price) in _PRICING.items():
+        if key in normalized:
+            return (prompt_tokens * in_price) + (completion_tokens * out_price)
+
+    return None

sythra-0.1.0/sythra.egg-info/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: sythra
+Version: 0.1.0
+Summary: Runtime intelligence for AI agents: find the first point where a run went wrong, what it cost, and how to fix it.
+Author-email: Sythra <sythra.hq@gmail.com>
+Project-URL: Homepage, https://sythra.vercel.app
+Project-URL: Repository, https://github.com/sythrahq/sythra
+Keywords: ai,agents,observability,llm,debugging
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.24
+
+# Sythra
+
+Runtime intelligence for AI agents. When a run goes wrong, Sythra finds the first point where it diverged, shows what it cascaded into, what it cost, and what to do about it.
+
+## Install
+
+```
+pip install sythra
+```
+
+## Quick start
+
+Create an agent in your dashboard at https://sythra.vercel.app to get an API key, then wrap your agent function:
+
+```python
+from sythra import Sythra
+
+sythra = Sythra(api_key="YOUR_API_KEY", agent_name="my-agent")
+
+@sythra.observe
+def run_agent(question):
+    ...  # your agent code
+```
+
+Each call is recorded with its outcome, duration and steps. Works with LangChain, LangGraph, CrewAI and the OpenAI Agents SDK.
+
+## Privacy
+
+Sythra records what your agent did (tools, models, cost, outcome), not what it said. Prompt and response content is never captured unless you turn it on.
+
+## Links
+
+- Dashboard: https://sythra.vercel.app
+- Source: https://github.com/sythrahq/sythra
+- Support: sythra.hq@gmail.com

sythra-0.1.0/sythra.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+sythra/__init__.py
+sythra/client.py
+sythra/crewai_listener.py
+sythra/errors.py
+sythra/langchain_handler.py
+sythra/openai_agents_listener.py
+sythra/pricing.py
+sythra.egg-info/PKG-INFO
+sythra.egg-info/SOURCES.txt
+sythra.egg-info/dependency_links.txt
+sythra.egg-info/requires.txt
+sythra.egg-info/top_level.txt

sythra-0.1.0/sythra.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sythra-0.1.0/sythra.egg-info/requires.txt

@@ -0,0 +1 @@
+httpx>=0.24

sythra-0.1.0/sythra.egg-info/top_level.txt

@@ -0,0 +1 @@
+sythra