progress-observability 1.4.6__tar.gz → 1.5.1__tar.gz

{progress_observability-1.4.6 → progress_observability-1.5.1}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: progress-observability
-Version: 1.4.6
+Version: 1.5.1
 Summary: Progress Observability instrumentation for Python agents
 Project-URL: Homepage, https://github.com/telerik/agentclarity
 Project-URL: Repository, https://github.com/telerik/agentclarity
-Project-URL: Documentation, https://docs.telerik.com/agentclarity
+Project-URL: Documentation, https://www.telerik.com/ai-observability-platform/documentation/sdk/python
 Project-URL: Bug Reports, https://github.com/telerik/agentclarity/issues
 License: MIT
 License-File: LICENSE

{progress_observability-1.4.6 → progress_observability-1.5.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "progress-observability"
-version = "1.4.6"
+version = "1.5.1"
 description = "Progress Observability instrumentation for Python agents"
 readme = "README.md"
 license = { text = "MIT" }
@@ -17,7 +17,7 @@ dependencies = [
 [project.urls]
 Homepage = "https://github.com/telerik/agentclarity"
 Repository = "https://github.com/telerik/agentclarity"
-Documentation = "https://docs.telerik.com/agentclarity"
+Documentation = "https://www.telerik.com/ai-observability-platform/documentation/sdk/python"
 "Bug Reports" = "https://github.com/telerik/agentclarity/issues"
 
 [tool.uv]

progress_observability-1.5.1/src/progress/observability/genkit_span_processor.py

@@ -0,0 +1,187 @@
+"""Normalize native Genkit spans into AgentClarity attributes."""
+
+import json
+from typing import Any
+
+from .helpers import get_writable_attributes
+
+
+_PROVIDERS = {
+    "anthropic": "Anthropic",
+    "bedrock": "AWS",
+    "cohere": "Cohere",
+    "googleai": "Google",
+    "ollama": "Ollama",
+    "openai": "OpenAI",
+    "vertexai": "Google",
+}
+
+
+def _is_number(value: Any) -> bool:
+    return isinstance(value, (int, float)) and not isinstance(value, bool)
+
+
+def _parse_json(value: Any) -> dict[str, Any] | None:
+    if not isinstance(value, str):
+        return None
+    try:
+        parsed = json.loads(value)
+    except (TypeError, ValueError):
+        return None
+    return parsed if isinstance(parsed, dict) else None
+
+
+def _normalize_role(role: Any) -> str:
+    if role == "model":
+        return "assistant"
+    return role if isinstance(role, str) else "unknown"
+
+
+def _merge_consecutive_text_parts(parts: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    # Streaming responses (e.g. Genkit's generate_stream) record the final message content
+    # as a sequence of raw text deltas rather than one coalesced string. Merge adjacent
+    # text parts so consumers see the reassembled text instead of fragmented chunks.
+    merged: list[dict[str, Any]] = []
+    for part in parts:
+        previous = merged[-1] if merged else None
+        if part.get("type") == "text" and previous is not None and previous.get("type") == "text":
+            previous["content"] = f"{previous.get('content', '')}{part.get('content', '')}"
+            continue
+        merged.append(dict(part))
+    return merged
+
+
+def _normalize_parts(content: Any) -> list[dict[str, Any]]:
+    if not isinstance(content, list):
+        return [{"type": "text", "content": content}] if isinstance(content, str) else []
+
+    parts: list[dict[str, Any]] = []
+    for item in content:
+        if not isinstance(item, dict):
+            continue
+        if isinstance(item.get("text"), str):
+            parts.append({"type": "text", "content": item["text"]})
+        elif isinstance(item.get("toolRequest"), dict):
+            request = item["toolRequest"]
+            part: dict[str, Any] = {"type": "tool_call"}
+            if isinstance(request.get("name"), str):
+                part["name"] = request["name"]
+            if "input" in request:
+                part["arguments"] = request["input"]
+            parts.append(part)
+        elif isinstance(item.get("toolResponse"), dict):
+            response = item["toolResponse"]
+            part = {"type": "tool_call_response"}
+            if isinstance(response.get("name"), str):
+                part["name"] = response["name"]
+            if "output" in response:
+                part["response"] = response["output"]
+            parts.append(part)
+        else:
+            parts.append({"type": item.get("type", "unknown"), **item})
+    return _merge_consecutive_text_parts(parts)
+
+
+def _normalize_messages(value: Any) -> list[dict[str, Any]]:
+    if not isinstance(value, list):
+        return []
+    return [
+        {"role": _normalize_role(message.get("role")), "parts": _normalize_parts(message.get("content"))}
+        for message in value
+        if isinstance(message, dict)
+    ]
+
+
+class GenkitSpanProcessor:
+    """Post-process native Genkit action spans before export."""
+
+    def __init__(self, trace_content: bool = True) -> None:
+        self._trace_content = trace_content
+
+    def on_end(self, span: Any) -> None:
+        attributes = get_writable_attributes(span)
+        if not attributes or "genkit:type" not in attributes:
+            return
+
+        subtype = attributes.get("genkit:metadata:subtype")
+        if subtype == "flow":
+            attributes.setdefault("traceloop.span.kind", "workflow")
+            return
+        if subtype == "tool":
+            attributes.setdefault("traceloop.span.kind", "tool")
+            attributes.setdefault("gen_ai.operation.name", "execute_tool")
+            tool_name = attributes.get("genkit:name")
+            if isinstance(tool_name, str) and tool_name:
+                attributes.setdefault("gen_ai.tool.name", tool_name)
+            if self._trace_content:
+                tool_input = attributes.get("genkit:input")
+                if isinstance(tool_input, str):
+                    attributes.setdefault("gen_ai.tool.call.arguments", tool_input)
+                tool_output = attributes.get("genkit:output")
+                if isinstance(tool_output, str):
+                    attributes.setdefault("gen_ai.tool.call.result", tool_output)
+            return
+        if subtype != "model":
+            return
+
+        name = attributes.get("genkit:name")
+        if not isinstance(name, str) or not name:
+            return
+
+        separator = name.find("/")
+        if separator >= 0:
+            plugin = name[:separator].lower()
+            model = name[separator + 1 :]
+            if "gen_ai.provider.name" not in attributes and plugin:
+                attributes["gen_ai.provider.name"] = _PROVIDERS.get(plugin, plugin[:1].upper() + plugin[1:])
+        else:
+            model = name
+        attributes.setdefault("gen_ai.request.model", model)
+        attributes.setdefault("gen_ai.response.model", model)
+
+        if self._trace_content:
+            input_data = _parse_json(attributes.get("genkit:input"))
+            if input_data and "gen_ai.input.messages" not in attributes:
+                messages = _normalize_messages(input_data.get("messages"))
+                if messages:
+                    attributes["gen_ai.input.messages"] = json.dumps(messages)
+
+        output_data = _parse_json(attributes.get("genkit:output"))
+        if not output_data:
+            return
+        if self._trace_content:
+            output_message = output_data.get("message")
+            if output_message is None and isinstance(output_data.get("candidates"), list):
+                candidates = output_data["candidates"]
+                if candidates and isinstance(candidates[0], dict):
+                    output_message = candidates[0].get("message")
+            if isinstance(output_message, dict) and "gen_ai.output.messages" not in attributes:
+                messages = _normalize_messages([output_message])
+                if messages:
+                    attributes["gen_ai.output.messages"] = json.dumps(messages)
+
+        usage = output_data.get("usage")
+        if isinstance(usage, dict):
+            input_tokens = usage.get("inputTokens")
+            output_tokens = usage.get("outputTokens")
+            thoughts_tokens = usage.get("thoughtsTokens")
+            total_tokens = usage.get("totalTokens")
+            if _is_number(input_tokens) and "gen_ai.usage.input_tokens" not in attributes:
+                attributes["gen_ai.usage.input_tokens"] = int(input_tokens)
+            if (
+                _is_number(thoughts_tokens)
+                and "gen_ai.usage.reasoning.output_tokens" not in attributes
+            ):
+                attributes["gen_ai.usage.reasoning.output_tokens"] = int(thoughts_tokens)
+            if _is_number(output_tokens) and "gen_ai.usage.output_tokens" not in attributes:
+                # Genkit providers differ on whether outputTokens includes thoughtsTokens.
+                # totalTokens disambiguates the two representations when available.
+                thoughts_included = (
+                    _is_number(total_tokens)
+                    and _is_number(input_tokens)
+                    and int(total_tokens) == int(input_tokens) + int(output_tokens)
+                )
+                effective_output_tokens = int(output_tokens) + (
+                    0 if thoughts_included or not _is_number(thoughts_tokens) else int(thoughts_tokens)
+                )
+                attributes["gen_ai.usage.output_tokens"] = effective_output_tokens

{progress_observability-1.4.6 → progress_observability-1.5.1}/src/progress/observability/sdk.py

@@ -32,6 +32,7 @@ from .constants import DEFAULTS
 from .helpers import init_environment, setup_api_key_headers, patch_traceloop_modules, clear_sdk_env_vars
 from .model_fix_processor import ModelFixProcessor
 from .genai_message_processor import GenAIMessageProcessor
+from .genkit_span_processor import GenkitSpanProcessor
 from .exceptions import (
     EndpointValidationError,
     InvalidPortError,
@@ -279,16 +280,22 @@ class Observability:
                 handler.addFilter(lambda record: record.levelno == logging.DEBUG)
                 pkg_logger.addHandler(handler)
 
+        # Resolve the effective trace_content setting (init_environment() already
+        # applied env var precedence and may have set TRACELOOP_TRACE_CONTENT).
+        trace_content_enabled = os.getenv("TRACELOOP_TRACE_CONTENT", "true").lower() == "true"
+
         # Create processors with debug mode
         genai_message_processor = GenAIMessageProcessor(debug=debug_enabled)
+        genkit_span_processor = GenkitSpanProcessor(trace_content=trace_content_enabled)
         model_fix_processor = ModelFixProcessor(debug=debug_enabled)
         cls._model_fix_processor = model_fix_processor
 
-        # Chain processors: message normalization first, then model fixes
+        # Chain processors: Genkit normalization, message normalization, then model fixes.
         # Preserve any existing user-provided callback by chaining with it
         existing_callback = kwargs.get('span_postprocess_callback')
         
         def chained_callback(span):
+            genkit_span_processor.on_end(span)
             genai_message_processor.on_end(span)
             model_fix_processor.on_end(span)
             if existing_callback:

{progress_observability-1.4.6 → progress_observability-1.5.1}/uv.lock

@@ -1544,7 +1544,7 @@ wheels = [
 
 [[package]]
 name = "progress-observability"
-version = "1.4.6"
+version = "1.5.1"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },