agenta 0.27.7a1__py3-none-any.whl → 0.27.8a2__py3-none-any.whl

agenta/sdk/decorators/routing.py

@@ -143,9 +143,7 @@ class entrypoint:
                 _MIDDLEWARES = False
 
         except:  # pylint: disable=bare-except
-            log.error("------------------------------------")
-            log.error("Agenta SDK - failed to secure route: %s", route_path)
-            log.error("------------------------------------")
+            log.warning("Agenta SDK - failed to secure route: %s", route_path)
         ### --- Update Middleware --- #
 
         DEFAULT_PATH = "generate"
@@ -357,9 +355,7 @@ class entrypoint:
         *args,
         **func_params,
     ):
-        log.info("---------------------------")
-        log.info(f"Agenta SDK - running route: {repr(self.route_path or '/')}")
-        log.info("---------------------------")
+        log.info("Agenta SDK - handling route: %s", repr(self.route_path or "/"))
 
         tracing_context.set(routing_context.get())
 
@@ -377,7 +373,7 @@ class entrypoint:
 
     async def handle_success(self, result: Any, inline_trace: bool):
         data = None
-        trace = dict()
+        trace = None
 
         with suppress():
             data = self.patch_result(result)
@@ -389,24 +385,20 @@ class entrypoint:
         log.info(f"Agenta SDK - exiting with success: 200")
         log.info(f"----------------------------------")
 
-        return BaseResponse(data=data, trace=trace)
+        return BaseResponse(data=data, tree=trace)
 
     def handle_failure(self, error: Exception):
-        log.error("--------------------------------------------------")
-        log.error("Agenta SDK - handling application exception below:")
-        log.error("--------------------------------------------------")
-        log.error(format_exc().strip("\n"))
-        log.error("--------------------------------------------------")
+        log.warning("--------------------------------------------------")
+        log.warning("Agenta SDK - handling application exception below:")
+        log.warning("--------------------------------------------------")
+        log.warning(format_exc().strip("\n"))
+        log.warning("--------------------------------------------------")
 
         status_code = error.status_code if hasattr(error, "status_code") else 500
         message = str(error)
         stacktrace = format_exception(error, value=error, tb=error.__traceback__)  # type: ignore
         detail = {"message": message, "stacktrace": stacktrace}
 
-        log.error(f"----------------------------------")
-        log.error(f"Agenta SDK - exiting with failure: {status_code}")
-        log.error(f"----------------------------------")
-
         raise HTTPException(status_code=status_code, detail=detail)
 
     def patch_result(self, result: Any):
@@ -683,10 +675,7 @@ class entrypoint:
 
         loop = get_event_loop()
 
-        with routing_context_manager(
-            config=args_config_params,
-            environment="terminal",
-        ):
+        with routing_context_manager(config=args_config_params):
             result = loop.run_until_complete(
                 self.execute_function(
                     func,
@@ -695,30 +684,23 @@ class entrypoint:
                 )
             )
 
-        SHOW_DETAILS = True
-        SHOW_DATA = False
-        SHOW_TRACE = False
-
         if result.trace:
             log.info("\n========= Result =========\n")
 
             log.info(f"trace_id: {result.trace['trace_id']}")
-            if SHOW_DETAILS:
-                log.info(f"latency:  {result.trace.get('latency')}")
-                log.info(f"cost:     {result.trace.get('cost')}")
-                log.info(f"usage:   {list(result.trace.get('usage', {}).values())}")
-
-            if SHOW_DATA:
-                log.info(" ")
-                log.info(f"data:")
-                log.info(dumps(result.data, indent=2))
-
-            if SHOW_TRACE:
-                log.info(" ")
-                log.info(f"trace:")
-                log.info(f"----------------")
-                log.info(dumps(result.trace.get("spans", []), indent=2))
-                log.info(f"----------------")
+            log.info(f"latency:  {result.trace.get('latency')}")
+            log.info(f"cost:     {result.trace.get('cost')}")
+            log.info(f"usage:   {list(result.trace.get('usage', {}).values())}")
+
+            log.info(" ")
+            log.info("data:")
+            log.info(dumps(result.data, indent=2))
+
+            log.info(" ")
+            log.info("trace:")
+            log.info("----------------")
+            log.info(dumps(result.trace.get("spans", []), indent=2))
+            log.info("----------------")
 
             log.info("\n==========================\n")
 

agenta/sdk/litellm/litellm.py

@@ -60,7 +60,11 @@ def litellm_handler():
             )
 
             if not self.span:
-                log.error("LiteLLM callback error: span not found.")
+                log.warning("Agenta SDK - litellm tracing failed")
+                return
+
+            if not self.span.is_recording():
+                log.error("Agenta SDK - litellm span not recording.")
                 return
 
             self.span.set_attributes(
@@ -86,43 +90,11 @@ def litellm_handler():
             end_time,
         ):
             if not self.span:
-                log.error("LiteLLM callback error: span not found.")
+                log.warning("Agenta SDK - litellm tracing failed")
                 return
 
-            try:
-                result = []
-                for choice in response_obj.choices:
-                    message = choice.message.__dict__
-                    result.append(message)
-
-                outputs = {"completion": result}
-                self.span.set_attributes(
-                    attributes={"outputs": outputs},
-                    namespace="data",
-                )
-
-            except Exception as e:
-                pass
-
-            self.span.set_attributes(
-                attributes={"total": kwargs.get("response_cost")},
-                namespace="metrics.unit.costs",
-            )
-
-            self.span.set_attributes(
-                attributes=(
-                    {
-                        "prompt": response_obj.usage.prompt_tokens,
-                        "completion": response_obj.usage.completion_tokens,
-                        "total": response_obj.usage.total_tokens,
-                    }
-                ),
-                namespace="metrics.unit.tokens",
-            )
-
-            self.span.set_status(status="OK")
-
-            self.span.end()
+            if not self.span.is_recording():
+                return
 
         def log_success_event(
             self,
@@ -131,8 +103,14 @@ def litellm_handler():
             start_time,
             end_time,
         ):
+            if kwargs.get("stream"):
+                return
+
             if not self.span:
-                log.error("LiteLLM callback error: span not found.")
+                log.warning("Agenta SDK - litellm tracing failed")
+                return
+
+            if not self.span.is_recording():
                 return
 
             try:
@@ -178,7 +156,10 @@ def litellm_handler():
             end_time,
         ):
             if not self.span:
-                log.error("LiteLLM callback error: span not found.")
+                log.warning("Agenta SDK - litellm tracing failed")
+                return
+
+            if not self.span.is_recording():
                 return
 
             self.span.record_exception(kwargs["exception"])
@@ -195,43 +176,11 @@ def litellm_handler():
             end_time,
         ):
             if not self.span:
-                log.error("LiteLLM callback error: span not found.")
+                log.warning("Agenta SDK - litellm tracing failed")
                 return
 
-            try:
-                result = []
-                for choice in response_obj.choices:
-                    message = choice.message.__dict__
-                    result.append(message)
-
-                outputs = {"completion": result}
-                self.span.set_attributes(
-                    attributes={"outputs": outputs},
-                    namespace="data",
-                )
-
-            except Exception as e:
-                pass
-
-            self.span.set_attributes(
-                attributes={"total": kwargs.get("response_cost")},
-                namespace="metrics.unit.costs",
-            )
-
-            self.span.set_attributes(
-                attributes=(
-                    {
-                        "prompt": response_obj.usage.prompt_tokens,
-                        "completion": response_obj.usage.completion_tokens,
-                        "total": response_obj.usage.total_tokens,
-                    }
-                ),
-                namespace="metrics.unit.tokens",
-            )
-
-            self.span.set_status(status="OK")
-
-            self.span.end()
+            if not self.span.is_recording():
+                return
 
         async def async_log_success_event(
             self,
@@ -241,7 +190,10 @@ def litellm_handler():
             end_time,
         ):
             if not self.span:
-                log.error("LiteLLM callback error: span not found.")
+                log.warning("Agenta SDK - litellm tracing failed")
+                return
+
+            if not self.span.is_recording():
                 return
 
             try:
@@ -287,7 +239,10 @@ def litellm_handler():
             end_time,
         ):
             if not self.span:
-                log.error("LiteLLM callback error: span not found.")
+                log.warning("Agenta SDK - litellm tracing failed")
+                return
+
+            if not self.span.is_recording():
                 return
 
             self.span.record_exception(kwargs["exception"])

agenta/sdk/middleware/auth.py

@@ -133,10 +133,10 @@ class AuthorizationMiddleware(BaseHTTPMiddleware):
             return await call_next(request)
 
         except:  # pylint: disable=bare-except
-            log.error("------------------------------------------------------")
-            log.error("Agenta SDK - handling auth middleware exception below:")
-            log.error("------------------------------------------------------")
-            log.error(format_exc().strip("\n"))
-            log.error("------------------------------------------------------")
+            log.warning("------------------------------------------------------")
+            log.warning("Agenta SDK - handling auth middleware exception below:")
+            log.warning("------------------------------------------------------")
+            log.warning(format_exc().strip("\n"))
+            log.warning("------------------------------------------------------")
 
             return Deny()

agenta/sdk/tracing/context.py

@@ -14,11 +14,11 @@ def tracing_context_manager():
     token = tracing_context.set(_tracing_context)
     try:
         yield
-    except Exception as e:
-        log.error("----------------------------------------------")
-        log.error("Agenta SDK - handling tracing exception below:")
-        log.error("----------------------------------------------")
-        log.error(format_exc().strip("\n"))
-        log.error("----------------------------------------------")
+    except:  # pylint: disable=bare-except
+        log.warning("----------------------------------------------")
+        log.warning("Agenta SDK - handling tracing exception below:")
+        log.warning("----------------------------------------------")
+        log.warning(format_exc().strip("\n"))
+        log.warning("----------------------------------------------")
     finally:
         tracing_context.reset(token)

agenta/sdk/tracing/inline.py

@@ -903,9 +903,9 @@ def parse_to_agenta_span_dto(
     if span_dto.data:
         span_dto.data = _unmarshal_attributes(span_dto.data)
 
-        # if "outputs" in span_dto.data:
-        #     if "__default__" in span_dto.data["outputs"]:
-        #         span_dto.data["outputs"] = span_dto.data["outputs"]["__default__"]
+        if "outputs" in span_dto.data:
+            if "__default__" in span_dto.data["outputs"]:
+                span_dto.data["outputs"] = span_dto.data["outputs"]["__default__"]
 
     # METRICS
     if span_dto.metrics:
@@ -934,6 +934,17 @@ def parse_to_agenta_span_dto(
             else:
                 parse_to_agenta_span_dto(v)
 
+    # MASK LINKS FOR NOW
+    span_dto.links = None
+    # ------------------
+
+    # MASK LIFECYCLE FOR NOW
+    # span_dto.lifecycle = None
+    if span_dto.lifecycle:
+        span_dto.lifecycle.updated_at = None
+        span_dto.lifecycle.updated_by_id = None
+    # ----------------------
+
     return span_dto
 
 
@@ -945,6 +956,8 @@ def parse_to_agenta_span_dto(
 from litellm import cost_calculator
 from opentelemetry.sdk.trace import ReadableSpan
 
+from agenta.sdk.types import AgentaNodeDto, AgentaNodesResponse
+
 
 def parse_inline_trace(
     spans: Dict[str, ReadableSpan],
@@ -992,51 +1005,19 @@ def parse_inline_trace(
     ### services.observability.service.query() ###
     ##############################################
 
-    LEGACY = True
-    inline_trace = None
-
-    if LEGACY:
-        legacy_spans = [
-            _parse_to_legacy_span(span_dto) for span_dto in span_idx.values()
-        ]
-
-        root_span = agenta_span_dtos[0]
-
-        trace_id = root_span.root.id.hex
-        latency = root_span.time.span / 1_000_000
-        cost = root_span.metrics.get("acc", {}).get("costs", {}).get("total", 0.0)
-        tokens = {
-            "prompt_tokens": root_span.metrics.get("acc", {})
-            .get("tokens", {})
-            .get("prompt", 0),
-            "completion_tokens": root_span.metrics.get("acc", {})
-            .get("tokens", {})
-            .get("completion", 0),
-            "total_tokens": root_span.metrics.get("acc", {})
-            .get("tokens", {})
-            .get("total", 0),
-        }
-
-        spans = [
-            loads(span.model_dump_json(exclude_none=True)) for span in legacy_spans
-        ]
-
-        inline_trace = {
-            "trace_id": trace_id,
-            "latency": latency,
-            "cost": cost,
-            "usage": tokens,
-            "spans": spans,
-        }
-
-    else:
-        spans = [
-            loads(span_dto.model_dump_json(exclude_none=True))
-            for span_dto in agenta_span_dtos
-        ]
-
-        inline_trace = spans  # turn into Agenta Model ?
-
+    spans = [
+        loads(
+            span_dto.model_dump_json(
+                exclude_none=True,
+                exclude_defaults=True,
+            )
+        )
+        for span_dto in agenta_span_dtos
+    ]
+    inline_trace = AgentaNodesResponse(
+        version="1.0.0",
+        nodes=[AgentaNodeDto(**span) for span in spans],
+    ).model_dump(exclude_none=True, exclude_unset=True)
     return inline_trace
 
 
@@ -1120,98 +1101,6 @@ class LlmTokens(BaseModel):
     total_tokens: Optional[int] = 0
 
 
-class CreateSpan(BaseModel):
-    id: str
-    app_id: str
-    variant_id: Optional[str] = None
-    variant_name: Optional[str] = None
-    inputs: Optional[Dict[str, Optional[Any]]] = None
-    internals: Optional[Dict[str, Optional[Any]]] = None
-    outputs: Optional[Union[str, Dict[str, Optional[Any]], List[Any]]] = None
-    config: Optional[Dict[str, Optional[Any]]] = None
-    environment: Optional[str] = None
-    tags: Optional[List[str]] = None
-    token_consumption: Optional[int] = None
-    name: str
-    parent_span_id: Optional[str] = None
-    attributes: Optional[Dict[str, Optional[Any]]] = None
-    spankind: str
-    status: str
-    user: Optional[str] = None
-    start_time: datetime
-    end_time: datetime
-    tokens: Optional[LlmTokens] = None
-    cost: Optional[float] = None
-
-
-def _parse_to_legacy_span(span: SpanDTO) -> CreateSpan:
-    attributes = None
-    if span.otel:
-        attributes = span.otel.attributes or {}
-
-        if span.otel.events:
-            for event in span.otel.events:
-                if event.name == "exception":
-                    attributes.update(**event.attributes)
-
-    legacy_span = CreateSpan(
-        id=span.node.id.hex[:24],
-        spankind=span.node.type,
-        name=span.node.name,
-        #
-        status=span.status.code.name,
-        #
-        start_time=span.time.start,
-        end_time=span.time.end,
-        #
-        parent_span_id=span.parent.id.hex[:24] if span.parent else None,
-        #
-        inputs=span.data.get("inputs") if span.data else {},
-        internals=span.data.get("internals") if span.data else {},
-        outputs=span.data.get("outputs") if span.data else {},
-        #
-        environment=span.meta.get("environment") if span.meta else None,
-        config=span.meta.get("configuration") if span.meta else None,
-        #
-        tokens=(
-            LlmTokens(
-                prompt_tokens=span.metrics.get("acc", {})
-                .get("tokens", {})
-                .get("prompt", 0.0),
-                completion_tokens=span.metrics.get("acc", {})
-                .get("tokens", {})
-                .get("completion", 0.0),
-                total_tokens=span.metrics.get("acc", {})
-                .get("tokens", {})
-                .get("total", 0.0),
-            )
-            if span.metrics
-            else None
-        ),
-        cost=(
-            span.metrics.get("acc", {}).get("costs", {}).get("total", 0.0)
-            if span.metrics
-            else None
-        ),
-        #
-        app_id=(
-            span.refs.get("application", {}).get("id", "missing-app-id")
-            if span.refs
-            else "missing-app-id"
-        ),
-        #
-        attributes=attributes,
-        #
-        variant_id=None,
-        variant_name=None,
-        tags=None,
-        token_consumption=None,
-        user=None,
-    )
-
-    return legacy_span
-
-
 TYPES_WITH_COSTS = [
     "embedding",
     "query",
@@ -1229,13 +1118,15 @@ def calculate_costs(span_idx: Dict[str, SpanDTO]):
             and span.meta
             and span.metrics
         ):
+            model = span.meta.get("response.model")
+            prompt_tokens = span.metrics.get("unit.tokens.prompt", 0.0)
+            completion_tokens = span.metrics.get("unit.tokens.completion", 0.0)
+
             try:
                 costs = cost_calculator.cost_per_token(
-                    model=span.meta.get("response.model"),
-                    prompt_tokens=span.metrics.get("unit.tokens.prompt", 0.0),
-                    completion_tokens=span.metrics.get("unit.tokens.completion", 0.0),
-                    call_type=span.node.type.name.lower(),
-                    response_time_ms=span.time.span // 1_000,
+                    model=model,
+                    prompt_tokens=prompt_tokens,
+                    completion_tokens=completion_tokens,
                 )
 
                 if not costs:
@@ -1248,5 +1139,8 @@ def calculate_costs(span_idx: Dict[str, SpanDTO]):
                 span.metrics["unit.costs.completion"] = completion_cost
                 span.metrics["unit.costs.total"] = total_cost
 
-            except:
-                pass
+            except:  # pylint: disable=bare-except
+                print("Failed to calculate costs:")
+                print(
+                    f"model={model}, prompt_tokens={prompt_tokens}, completion_tokens={completion_tokens}"
+                )

agenta/sdk/tracing/processors.py

@@ -91,9 +91,7 @@ class TraceProcessor(BatchSpanProcessor):
         ret = super().force_flush(timeout_millis)
 
         if not ret:
-            log.error("--------------------------------------------")
-            log.error("Agenta SDK - skipping export due to timeout.")
-            log.error("--------------------------------------------")
+            log.warning("Agenta SDK - skipping export due to timeout.")
 
     def is_ready(
         self,

agenta/sdk/tracing/tracing.py

@@ -90,7 +90,6 @@ class Tracing(metaclass=Singleton):
                 self.otlp_url,
             )
             log.info("--------------------------------------------")
-
             check(
                 self.otlp_url,
                 headers=self.headers,
@@ -106,13 +105,10 @@ class Tracing(metaclass=Singleton):
             )
 
             self.tracer_provider.add_span_processor(_otlp)
-
             log.info("Success: traces will be exported.")
             log.info("--------------------------------------------")
-
         except:  # pylint: disable=bare-except
-            log.warning("Failure: traces will not be exported.")
-            log.warning("--------------------------------------------")
+            log.warning("Agenta SDK - traces will not be exported.")
 
         # GLOBAL TRACER PROVIDER -- INSTRUMENTATION LIBRARIES
         set_tracer_provider(self.tracer_provider)

agenta/sdk/types.py

@@ -4,6 +4,9 @@ from typing import Dict, List, Optional, Any, Union
 
 from pydantic import ConfigDict, BaseModel, HttpUrl
 
+from agenta.client.backend.types.agenta_node_dto import AgentaNodeDto
+from agenta.client.backend.types.agenta_nodes_response import AgentaNodesResponse
+
 
 @dataclass
 class MultipleChoice:
@@ -23,9 +26,9 @@ class LLMTokenUsage(BaseModel):
 
 
 class BaseResponse(BaseModel):
-    version: Optional[str] = "2.0"
+    version: Optional[str] = "3.0"
     data: Optional[Union[str, Dict[str, Any]]] = None
-    trace: Optional[Dict[str, Any]] = None
+    tree: Optional[AgentaNodesResponse] = None
 
 
 class DictInput(dict):

agenta/sdk/utils/exceptions.py

@@ -17,11 +17,11 @@ class suppress(AbstractContextManager):  # pylint: disable=invalid-name
         if exc_type is None:
             return True
         else:
-            log.error("-------------------------------------------------")
-            log.error("Agenta SDK - suppressing tracing exception below:")
-            log.error("-------------------------------------------------")
-            log.error(format_exc().strip("\n"))
-            log.error("-------------------------------------------------")
+            log.warning("-------------------------------------------------")
+            log.warning("Agenta SDK - suppressing tracing exception below:")
+            log.warning("-------------------------------------------------")
+            log.warning(format_exc().strip("\n"))
+            log.warning("-------------------------------------------------")
             return True
 
 
@@ -34,8 +34,11 @@ def handle_exceptions():
             try:
                 return await func(*args, **kwargs)
             except Exception as e:
-                log.error("--- HANDLING EXCEPTION ---")
-                log.error("--------------------------")
+                log.warning("------------------------------------------")
+                log.warning("Agenta SDK - intercepting exception below:")
+                log.warning("------------------------------------------")
+                log.warning(format_exc().strip("\n"))
+                log.warning("------------------------------------------")
                 raise e
 
         @wraps(func)
@@ -43,8 +46,11 @@ def handle_exceptions():
             try:
                 return func(*args, **kwargs)
             except Exception as e:
-                log.error("--- HANDLING EXCEPTION ---")
-                log.error("--------------------------")
+                log.warning("------------------------------------------")
+                log.warning("Agenta SDK - intercepting exception below:")
+                log.warning("------------------------------------------")
+                log.warning(format_exc().strip("\n"))
+                log.warning("------------------------------------------")
                 raise e
 
         return async_wrapper if is_coroutine_function else sync_wrapper

agenta/sdk/utils/logging.py

@@ -1,8 +1,12 @@
 import logging
+from os import getenv
 
 
 class Logger:
-    def __init__(self, name="agenta.logger", level=logging.DEBUG):
+    def __init__(self, name="agenta.logger", level=logging.WARNING):
+        if getenv("AGENTA_DEBUG"):
+            level = logging.DEBUG
+
         self.logger = logging.getLogger(name)
         self.logger.setLevel(level)
 

{agenta-0.27.7a1.dist-info → agenta-0.27.8a2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: agenta
-Version: 0.27.7a1
+Version: 0.27.8a2
 Summary: The SDK for agenta is an open-source LLMOps platform.
 Home-page: https://agenta.ai
 Keywords: LLMOps,LLM,evaluation,prompt engineering