synathic 0.1.0__tar.gz

synathic-0.1.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: synathic
+Version: 0.1.0
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.24.0
+Dynamic: requires-dist
+Dynamic: requires-python

synathic-0.1.0/setup.cfg

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

synathic-0.1.0/setup.py

@@ -0,0 +1,9 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="synathic",
+    version="0.1.0",
+    packages=find_packages(),
+    install_requires=["httpx>=0.24.0"],
+    python_requires=">=3.9",
+)

synathic-0.1.0/synathic/__init__.py

@@ -0,0 +1,4 @@
+from .monitor import monitor
+from .decorators import expect
+
+__all__ = ["monitor", "expect"]

synathic-0.1.0/synathic/decorators.py

@@ -0,0 +1,110 @@
+import functools
+import asyncio
+import uuid
+from datetime import datetime
+from .monitor import monitor
+
+def expect(
+    postcondition: str,
+    table: str = None,
+    match_field: str = None,
+    expected_field: str = None,
+    expected_value: str = None,
+    sync: bool = False,
+    timestamp_column: str | None = "updated_at",
+):
+    """Decorador para verificar una postcondicion tras ejecutar una herramienta.
+
+    Tipos soportados por el backend:
+      - "row_exists":     pass si existe una fila en `table` donde
+                          `match_field = <valor de match_field en la llamada>`.
+      - "row_not_exists": pass si NO existe tal fila.
+      - "field_equals":   pass si ademas el valor real de `expected_field`
+                          en esa fila es exactamente igual a `expected_value`.
+    """
+    def decorator(func):
+        @functools.wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            execution_id = str(uuid.uuid4())
+            execution_start = datetime.utcnow()
+
+            # Para flujos síncronos evitamos enviar el `tool_call`.
+            if not sync:
+                # Fire-and-forget the tool_call to avoid adding network/DB latency
+                try:
+                    import asyncio as _asyncio
+                    _asyncio.create_task(monitor.send_event(
+                        execution_id=execution_id,
+                        agent_name=func.__name__,
+                        event_type="tool_call",
+                        payload={"args": str(args), "kwargs": str(kwargs)}
+                    ))
+                except Exception:
+                    # best-effort: if task creation fails, fall back to awaiting
+                    await monitor.send_event(
+                        execution_id=execution_id,
+                        agent_name=func.__name__,
+                        event_type="tool_call",
+                        payload={"args": str(args), "kwargs": str(kwargs)}
+                    )
+
+            result = await func(*args, **kwargs)
+
+            # Valor usado para localizar la fila: normalmente el argumento
+            # cuyo nombre coincide con match_field.
+            value = kwargs.get(match_field) or (args[0] if args else None)
+
+            postcondition_payload = {
+                "type": postcondition,
+                "table": table,
+                "field": match_field,
+                "value": value,
+                "execution_start": execution_start.isoformat(),
+                "timestamp_column": timestamp_column,
+            }
+
+            # Para field_equals, incluir el campo y el valor esperado extra.
+            if postcondition == "field_equals":
+                postcondition_payload["expected_field"] = expected_field or match_field
+                postcondition_payload["expected_value"] = expected_value
+
+            # Si sync=True, usar el método que espera la verificación síncrona
+            if sync:
+                verification = await monitor.send_event_and_wait_verification(
+                    execution_id=execution_id,
+                    agent_name=func.__name__,
+                    event_type="tool_result",
+                    payload={
+                        "result": str(result),
+                        "postcondition": postcondition_payload,
+                    }
+                )
+
+                # Devolver el resultado junto con la verificación para que el
+                # código llamante pueda tomar decisiones bloqueantes.
+                if isinstance(result, dict):
+                    result["verification"] = verification
+                    return result
+                return {"result": result, "verification": verification}
+            else:
+                await monitor.send_event(
+                    execution_id=execution_id,
+                    agent_name=func.__name__,
+                    event_type="tool_result",
+                    payload={
+                        "result": str(result),
+                        "postcondition": postcondition_payload,
+                    }
+                )
+
+                return result
+
+        @functools.wraps(func)
+        def sync_wrapper(*args, **kwargs):
+            return func(*args, **kwargs)
+
+        if asyncio.iscoroutinefunction(func):
+            return async_wrapper
+        return sync_wrapper
+
+    return decorator

synathic-0.1.0/synathic/monitor.py

@@ -0,0 +1,110 @@
+import httpx
+import time
+from time import perf_counter
+from typing import Optional
+
+class SynathicMonitor:
+    def __init__(self):
+        self.api_key = None
+        self.endpoint = "http://localhost:8000/api/events"
+        self._client = None
+
+    def start(self, api_key: Optional[str] = None, endpoint: Optional[str] = None):
+        self.api_key = api_key
+        if endpoint:
+            self.endpoint = endpoint
+        # Crear el client asíncrono que se reutiliza en llamadas posteriores
+        self._client = httpx.AsyncClient(timeout=5.0)
+
+        # Warmup no bloqueante: lanzar ping a /health en background (no espera)
+        try:
+            import threading
+            def _bg_ping(url: str):
+                try:
+                    with httpx.Client(timeout=1.0) as c:
+                        c.get(url)
+                except Exception:
+                    pass
+
+            warm_url = self.endpoint.replace('/events', '/health')
+            t = threading.Thread(target=_bg_ping, args=(warm_url,), daemon=True)
+            t.start()
+        except Exception:
+            pass
+
+        print("Synathic monitor started")
+
+    async def send_event(self, execution_id: str, agent_name: str, event_type: str, payload: dict):
+        if not self._client:
+            return
+
+        try:
+            t0 = time.time()
+            print(f"[monitor] send_event start {t0} endpoint={self.endpoint} event_type={event_type}")
+            resp = await self._client.post(
+                self.endpoint,
+                json={
+                    "execution_id": execution_id,
+                    "agent_name": agent_name,
+                    "event_type": event_type,
+                    "payload": payload,
+                    "timestamp": time.time()
+                }
+            )
+            t1 = time.time()
+            print(f"[monitor] send_event done elapsed_ms={(t1-t0)*1000:.1f} event_type={event_type}")
+        except Exception:
+            # Fire-and-forget: si el backend está caído, el agente sigue corriendo
+            pass
+
+    async def send_event_and_wait_verification(self, execution_id: str, agent_name: str, event_type: str, payload: dict):
+        """Enviar el evento y, si contiene una postcondition, pedir verificación síncrona al backend.
+        Devuelve el JSON de la respuesta del endpoint /api/events-verify cuando aplique.
+        """
+        # Enviar un único request que inserta el evento y ejecuta la verificación
+        if not self._client:
+            return None
+
+        try:
+            timings = {}
+            t_wrapper_start = perf_counter()
+
+            client_created = False
+            if getattr(self, "_client", None) is None:
+                t_client_create_start = perf_counter()
+                self._client = httpx.AsyncClient(timeout=5.0)
+                t_client_create_end = perf_counter()
+                timings["client_create_ms"] = (t_client_create_end - t_client_create_start) * 1000
+                client_created = True
+
+            # Preparar payload y endpoint nuevo `/events-verify`
+            verify_url = self.endpoint.replace('/events', '/events-verify')
+            req_body = {
+                "execution_id": execution_id,
+                "agent_name": agent_name,
+                "event_type": event_type,
+                "payload": payload,
+                "timestamp": time.time()
+            }
+
+            # Momento justo antes de iniciar la llamada HTTP
+            t_request_start = perf_counter()
+            resp = await self._client.post(verify_url, json=req_body)
+            t_response_received = perf_counter()
+
+            timings["func_to_request_start_ms"] = (t_request_start - t_wrapper_start) * 1000
+            timings["request_roundtrip_ms"] = (t_response_received - t_request_start) * 1000
+
+            # Intentar parsear la respuesta que incluye timings del servidor
+            try:
+                j = resp.json()
+            except Exception:
+                j = None
+
+            # Incluir measurementes del lado servidor si están presentes
+            result = {"client_timings": timings, "server_response": j}
+            return result
+        except Exception:
+            return None
+
+monitor = SynathicMonitor()

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

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: synathic
+Version: 0.1.0
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.24.0
+Dynamic: requires-dist
+Dynamic: requires-python

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

@@ -0,0 +1,10 @@
+README.md
+setup.py
+synathic/__init__.py
+synathic/decorators.py
+synathic/monitor.py
+synathic.egg-info/PKG-INFO
+synathic.egg-info/SOURCES.txt
+synathic.egg-info/dependency_links.txt
+synathic.egg-info/requires.txt
+synathic.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

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

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

@@ -0,0 +1 @@
+synathic