[release] v0.96.7

api/ee/src/apis/fastapi/billing/router.py

@@ -576,7 +576,7 @@ async def create_checkout(
                 },
             },
             #
-            ui_mode="hosted",
+            ui_mode="hosted_page",
             success_url=success_url,
         )
 

api/oss/src/core/annotations/service.py

@@ -195,7 +195,7 @@ async def create(
             project_id=project_id,
             user_id=user_id,
             #
-            name=simple_evaluator.name if simple_evaluator else None,
+            name=simple_evaluator.slug if simple_evaluator else None,
             #
             flags=annotation_flags,
             tags=annotation_create.tags,

api/oss/src/core/evaluations/service.py

@@ -156,6 +156,32 @@ def _first_reference_id(
     return None
 
 
+def _is_invocation_query(data: Any) -> bool:
+    """Live evaluations require the query filter to target invocation traces.
+
+    Returns True only when the query's filtering contains a top-level
+    condition with field="trace_type", operator="is", value="invocation".
+    """
+    filtering = getattr(data, "filtering", None)
+    if filtering is None:
+        return False
+
+    for condition in filtering.conditions or []:
+        field = getattr(condition, "field", None)
+        if field != "trace_type":
+            continue
+
+        operator = getattr(condition, "operator", None)
+        if operator != "is":
+            continue
+
+        value = getattr(condition, "value", None)
+        if value == "invocation":
+            return True
+
+    return False
+
+
 class EvaluationsService:
     def __init__(
         self,
@@ -209,6 +235,22 @@ async def refresh_runs(
             user_id = run.created_by_id
 
             try:
+                if not await self._is_live_run_valid(
+                    project_id=project_id,
+                    run=run,
+                ):
+                    log.warning(
+                        "[LIVE] Closing invalid live run (null data or non-invocation trace_type).",
+                        project_id=project_id,
+                        run_id=run.id,
+                    )
+                    await self._close_live_run(
+                        project_id=project_id,
+                        user_id=user_id,
+                        run=run,
+                    )
+                    continue
+
                 log.info(
                     "[LIVE] Dispatching...",
                     project_id=project_id,
@@ -239,6 +281,71 @@ async def refresh_runs(
 
         return True
 
+    async def _is_live_run_valid(
+        self,
+        *,
+        project_id: UUID,
+        run: EvaluationRun,
+    ) -> bool:
+        """Every query step must reference a revision with data targeting invocation traces."""
+        if not run.data or not run.data.steps:
+            return False
+
+        query_revision_ids: List[UUID] = []
+        for step in run.data.steps:
+            query_ref = (step.references or {}).get("query_revision")
+            if isinstance(query_ref, Reference) and query_ref.id:
+                query_revision_ids.append(query_ref.id)
+
+        if not query_revision_ids:
+            return False
+
+        for query_revision_id in query_revision_ids:
+            query_revision = await self.queries_service.fetch_query_revision(
+                project_id=project_id,
+                #
+                query_revision_ref=Reference(id=query_revision_id),
+            )
+
+            if not query_revision or not query_revision.data:
+                return False
+
+            if not _is_invocation_query(query_revision.data):
+                return False
+
+        return True
+
+    async def _close_live_run(
+        self,
+        *,
+        project_id: UUID,
+        user_id: UUID,
+        run: EvaluationRun,
+    ) -> None:
+        flags = run.flags.model_copy() if run.flags else EvaluationRunFlags()
+        flags.is_active = False
+        flags.is_closed = True
+
+        await self.edit_run(
+            project_id=project_id,
+            user_id=user_id,
+            #
+            run=EvaluationRunEdit(
+                id=run.id,
+                #
+                name=run.name,
+                description=run.description,
+                #
+                flags=flags,
+                tags=run.tags,
+                meta=run.meta,
+                #
+                status=run.status,
+                #
+                data=run.data,
+            ),
+        )
+
     async def fetch_live_runs(
         self,
         *,
@@ -1706,6 +1813,8 @@ async def create(
                 evaluator_steps=evaluation.data.evaluator_steps,
                 #
                 repeats=evaluation.data.repeats,
+                #
+                is_live=evaluation.flags.is_live,
             )
 
             if not run_data:
@@ -1882,6 +1991,8 @@ async def edit(
                 evaluator_steps=evaluation.data.evaluator_steps,
                 #
                 repeats=_evaluation.data.repeats,
+                #
+                is_live=(_evaluation.flags.is_live if _evaluation.flags else None),
             )
 
             run_edit = EvaluationRunEdit(
@@ -2351,6 +2462,8 @@ async def _make_evaluation_run_data(
         evaluator_steps: Optional[Target] = None,
         #
         repeats: Optional[int] = None,
+        #
+        is_live: Optional[bool] = None,
     ) -> Optional[EvaluationRunData]:
         # IMPLICIT FLAG: is_multivariate=False
         # IMPLICIT FLAG: all_inputs=True
@@ -2385,6 +2498,20 @@ async def _make_evaluation_run_data(
                     )
                     return None
 
+                if is_live and not query_revision.data:
+                    log.warning(
+                        "[EVAL] [run] [make] [failure] live evaluation requires query with data",
+                        id=query_revision_ref.id,
+                    )
+                    return None
+
+                if is_live and not _is_invocation_query(query_revision.data):
+                    log.warning(
+                        "[EVAL] [run] [make] [failure] live evaluation requires trace_type=invocation",
+                        id=query_revision_ref.id,
+                    )
+                    return None
+
                 query_variant_ref = Reference(id=query_revision.variant_id)
 
                 query_variant = await self.queries_service.fetch_query_variant(

api/oss/src/core/queries/service.py

@@ -983,7 +983,36 @@ async def create(
             return None
 
         # ----------------------------------------------------------------------
-        # Query revision
+        # Query revision (placeholder v0 — first revision has its fields nulled)
+        # ----------------------------------------------------------------------
+        placeholder_revision_slug = uuid4().hex[-12:]
+
+        _query_revision_create = QueryRevisionCreate(
+            slug=placeholder_revision_slug,
+            #
+            name=simple_query_create.name,
+            description=simple_query_create.description,
+            #
+            flags=simple_query_create.flags,
+            tags=simple_query_create.tags,
+            meta=simple_query_create.meta,
+            #
+            query_id=query.id,
+            query_variant_id=query_variant.id,
+        )
+
+        placeholder_revision = await self.queries_service.create_query_revision(
+            project_id=project_id,
+            user_id=user_id,
+            #
+            query_revision_create=_query_revision_create,
+        )
+
+        if placeholder_revision is None:
+            return None
+
+        # ----------------------------------------------------------------------
+        # Query revision (v1 — carries the actual data)
         # ----------------------------------------------------------------------
         query_revision_slug = uuid4().hex[-12:]
 

api/oss/src/core/tracing/service.py

@@ -1007,17 +1007,17 @@ async def _resolve_evaluator_references(
 
         references.evaluator = Reference(
             id=evaluator_revision.evaluator_id,
-            slug=(references.evaluator.slug if references.evaluator else None)
-            or (evaluator.slug if evaluator else None),
+            slug=(evaluator.slug if evaluator else None)
+            or (references.evaluator.slug if references.evaluator else None),
         )
         references.evaluator_variant = Reference(
             id=evaluator_revision.evaluator_variant_id,
-            slug=(
+            slug=(evaluator_variant.slug if evaluator_variant else None)
+            or (
                 references.evaluator_variant.slug
                 if references.evaluator_variant
                 else None
-            )
-            or (evaluator_variant.slug if evaluator_variant else None),
+            ),
         )
         references.evaluator_revision = Reference(
             id=evaluator_revision.id,
@@ -1061,6 +1061,12 @@ async def create(
             references=_references,
         )
 
+        span_name = (
+            references.evaluator.slug
+            if references.evaluator and references.evaluator.slug
+            else "annotation"
+        )
+
         otel_links = await self.tracing_service.create_trace(
             organization_id=organization_id,
             project_id=project_id,
@@ -1070,6 +1076,7 @@ async def create(
                     trace_id=trace_id,
                     span_id=span_id,
                     span_type=SpanType.TASK,
+                    span_name=span_name,
                     attributes=_attributes,
                     links=_links,
                 )

api/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "api"
-version = "0.96.6"
+version = "0.96.7"
 description = "Agenta API"
 authors = [
     { name = "Mahmoud Mabrouk", email = "mahmoud@agenta.ai" },

sdk/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "agenta"
-version = "0.96.6"
+version = "0.96.7"
 description = "The SDK for agenta is an open-source LLMOps platform."
 readme = "README.md"
 authors = [

services/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "services"
-version = "0.96.6"
+version = "0.96.7"
 description = "Agenta Services (Chat & Completion)"
 authors = [
     "Mahmoud Mabrouk <mahmoud@agenta.ai>",

web/ee/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@agenta/ee",
-    "version": "0.96.6",
+    "version": "0.96.7",
     "private": true,
     "engines": {
         "node": ">=18"

web/oss/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@agenta/oss",
-    "version": "0.96.6",
+    "version": "0.96.7",
     "private": true,
     "engines": {
         "node": ">=18"