ioa-observe-sdk 1.0.12__py3-none-any.whl → 1.0.14__py3-none-any.whl

ioa_observe/sdk/decorators/__init__.py

@@ -21,6 +21,7 @@ def task(
     name: Optional[str] = None,
     description: Optional[str] = None,
     version: Optional[int] = None,
+    protocol: Optional[str] = None,
     method_name: Optional[str] = None,
     tlp_span_kind: Optional[ObserveSpanKindValues] = ObserveSpanKindValues.TASK,
 ) -> Callable[[F], F]:
@@ -29,6 +30,7 @@ def task(
             name=name,
             description=description,
             version=version,
+            protocol=protocol,
             tlp_span_kind=tlp_span_kind,
         )
     else:
@@ -36,6 +38,7 @@ def task(
             name=name,
             description=description,
             version=version,
+            protocol=protocol,
             method_name=method_name,
             tlp_span_kind=tlp_span_kind,
         )
@@ -45,6 +48,7 @@ def workflow(
     name: Optional[str] = None,
     description: Optional[str] = None,
     version: Optional[int] = None,
+    protocol: Optional[str] = None,
     method_name: Optional[str] = None,
     tlp_span_kind: Optional[
         Union[ObserveSpanKindValues, str]
@@ -57,6 +61,7 @@ def workflow(
                 name=name,
                 description=description,
                 version=version,
+                protocol=protocol,
                 method_name=method_name,
                 tlp_span_kind=tlp_span_kind,
             )(target)
@@ -66,6 +71,7 @@ def workflow(
                 name=name,
                 description=description,
                 version=version,
+                protocol=protocol,
                 tlp_span_kind=tlp_span_kind,
             )(target)
 
@@ -77,14 +83,18 @@ def graph(
     description: Optional[str] = None,
     version: Optional[int] = None,
     method_name: Optional[str] = None,
+    protocol: Optional[str] = None,
 ) -> Callable[[F], F]:
     if method_name is None:
-        return entity_method(name=name, version=version, tlp_span_kind="graph")
+        return entity_method(
+            name=name, version=version, protocol=protocol, tlp_span_kind="graph"
+        )
     else:
         return entity_class(
             name=name,
             version=version,
             method_name=method_name,
+            protocol=protocol,
             tlp_span_kind="graph",
         )
 
@@ -93,12 +103,14 @@ def agent(
     name: Optional[str] = None,
     description: Optional[str] = None,
     version: Optional[int] = None,
+    protocol: Optional[str] = None,
     method_name: Optional[str] = None,
 ) -> Callable[[F], F]:
     return workflow(
         name=name,
         description=description,
         version=version,
+        protocol=protocol,
         method_name=method_name,
         tlp_span_kind=ObserveSpanKindValues.AGENT,
     )

ioa_observe/sdk/decorators/base.py

@@ -7,16 +7,23 @@ import traceback
 from functools import wraps
 import os
 import types
-from typing import Optional, TypeVar, Callable, Awaitable, Any, cast, Union
+from typing import Optional, TypeVar, Callable, Awaitable, Any, Union
 import inspect
 
+from ioa_observe.sdk.decorators.helpers import (
+    _is_async_method,
+    _get_original_function_name,
+    _is_async_generator,
+)
+
+
 from langgraph.graph.state import CompiledStateGraph
 from opentelemetry import trace
 from opentelemetry import context as context_api
 from pydantic_core import PydanticSerializationError
 from typing_extensions import ParamSpec
 
-from ioa_observe.sdk.decorators.util import determine_workflow_type
+from ioa_observe.sdk.decorators.util import determine_workflow_type, _serialize_object
 from ioa_observe.sdk.metrics.agents.availability import agent_availability
 from ioa_observe.sdk.metrics.agents.recovery_tracker import agent_recovery_tracker
 from ioa_observe.sdk.metrics.agents.tool_call_tracker import tool_call_tracker
@@ -79,14 +86,6 @@ def _should_send_prompts():
     ).lower() == "true" or context_api.get_value("override_enable_content_tracing")
 
 
-# Unified Decorators : handles both sync and async operations
-
-
-def _is_async_method(fn):
-    # check if co-routine function or async generator( example : using async & yield)
-    return inspect.iscoroutinefunction(fn) or inspect.isasyncgenfunction(fn)
-
-
 def _setup_span(
     entity_name,
     tlp_span_kind: Optional[ObserveSpanKindValues] = None,
@@ -164,24 +163,24 @@ def _handle_span_input(span, args, kwargs, cls=None):
             # Safely convert args
             for arg in args:
                 try:
-                    # Test if the object can be JSON serialized
+                    # Check if the object can be JSON serialized directly
                     json.dumps(arg)
                     safe_args.append(arg)
                 except (TypeError, ValueError, PydanticSerializationError):
-                    # If it can't be serialized, use string representation
-                    safe_args.append(str(arg))
+                    # Use intelligent serialization
+                    safe_args.append(_serialize_object(arg))
 
             # Safely convert kwargs
             for key, value in kwargs.items():
                 try:
-                    # Test if the object can be JSON serialized
+                    # Test if the object can be JSON serialized directly
                     json.dumps(value)
                     safe_kwargs[key] = value
                 except (TypeError, ValueError, PydanticSerializationError):
-                    # If it can't be serialized, use string representation
-                    safe_kwargs[key] = str(value)
+                    # Use intelligent serialization
+                    safe_kwargs[key] = _serialize_object(value)
 
-            # Create the JSON without custom encoder to avoid recursion
+            # Create the JSON
             json_input = json.dumps({"args": safe_args, "kwargs": safe_kwargs})
 
             if _is_json_size_valid(json_input):
@@ -212,62 +211,55 @@ def _handle_span_output(span, tlp_span_kind, res, cls=None):
                     # end_span.end()  # end the span immediately
                     set_agent_id_event("")  # reset the agent id event
                 # Add agent interpretation scoring
-            if (
-                tlp_span_kind == ObserveSpanKindValues.AGENT
-                or tlp_span_kind == ObserveSpanKindValues.WORKFLOW
-            ):
-                current_agent = span.attributes.get("agent_id", "unknown")
-
-                # Determine next agent from response (if Command object with goto)
-                next_agent = None
-                if isinstance(res, dict) and "goto" in res:
-                    next_agent = res["goto"]
-                    # Check if there's an error flag in the response
-                    success = not (
-                        res.get("error", False) or res.get("goto") == "__end__"
+        if (
+            tlp_span_kind == ObserveSpanKindValues.AGENT
+            or tlp_span_kind == ObserveSpanKindValues.WORKFLOW
+        ):
+            current_agent = span.attributes.get("agent_id", "unknown")
+
+            # Determine next agent from response (if Command object with goto)
+            next_agent = None
+            if isinstance(res, dict) and "goto" in res:
+                next_agent = res["goto"]
+                # Check if there's an error flag in the response
+                success = not (res.get("error", False) or res.get("goto") == "__end__")
+
+                # If we have a chain of communication, compute interpretation score
+                if next_agent and next_agent != "__end__":
+                    score = compute_agent_interpretation_score(
+                        sender_agent=current_agent,
+                        receiver_agent=next_agent,
+                        data=res,
+                    )
+                    span.set_attribute("gen_ai.ioa.agent.interpretation_score", score)
+                    reliability = connection_tracker.record_connection(
+                        sender=current_agent, receiver=next_agent, success=success
+                    )
+                    span.set_attribute(
+                        "gen_ai.ioa.agent.connection_reliability", reliability
                     )
 
-                    # If we have a chain of communication, compute interpretation score
-                    if next_agent and next_agent != "__end__":
-                        score = compute_agent_interpretation_score(
-                            sender_agent=current_agent,
-                            receiver_agent=next_agent,
-                            data=res,
-                        )
-                        span.set_attribute(
-                            "gen_ai.ioa.agent.interpretation_score", score
-                        )
-                        reliability = connection_tracker.record_connection(
-                            sender=current_agent, receiver=next_agent, success=success
-                        )
-                        span.set_attribute(
-                            "gen_ai.ioa.agent.connection_reliability", reliability
-                        )
-
-            if _should_send_prompts():
+        if _should_send_prompts():
+            try:
+                # Try direct JSON serialization first
+                json_output = json.dumps(res)
+            except (TypeError, PydanticSerializationError, ValueError):
+                # Use intelligent serialization for complex objects
                 try:
-                    # Try direct JSON serialization first (without custom encoder)
-                    json_output = json.dumps(res)
-                except (TypeError, PydanticSerializationError, ValueError):
-                    # Fallback for objects that can't be directly serialized
-                    try:
-                        # Try to serialize a string representation
-                        safe_output = str(res)
-                        json_output = json.dumps(
-                            {"__str_representation__": safe_output}
-                        )
-                    except Exception:
-                        # If all serialization fails, skip output attribute
-                        json_output = None
+                    serialized_res = _serialize_object(res)
+                    json_output = json.dumps(serialized_res)
+                except Exception:
+                    # If all serialization fails, skip output attribute
+                    json_output = None
 
-                if json_output and _is_json_size_valid(json_output):
-                    span.set_attribute(
-                        OBSERVE_ENTITY_OUTPUT,
-                        json_output,
-                    )
-                    TracerWrapper().span_processor_on_ending(
-                        span
-                    )  # record the response latency
+            if json_output and _is_json_size_valid(json_output):
+                span.set_attribute(
+                    OBSERVE_ENTITY_OUTPUT,
+                    json_output,
+                )
+                TracerWrapper().span_processor_on_ending(
+                    span
+                )  # record the response latency
     except Exception as e:
         print(f"Warning: Failed to serialize output for span: {e}")
         Telemetry().log_exception(e)
@@ -293,17 +285,27 @@ def _cleanup_span(span, ctx_token):
     context_api.detach(ctx_token)
 
 
+def _unwrap_structured_tool(fn):
+    # Unwraps StructuredTool or similar wrappers to get the underlying function
+    if hasattr(fn, "func") and callable(fn.func):
+        return fn.func
+    return fn
+
+
 def entity_method(
     name: Optional[str] = None,
     description: Optional[str] = None,
     version: Optional[int] = None,
+    protocol: Optional[str] = None,
     tlp_span_kind: Optional[ObserveSpanKindValues] = ObserveSpanKindValues.TASK,
 ) -> Callable[[F], F]:
     def decorate(fn: F) -> F:
+        # Unwrap StructuredTool if present
+        fn = _unwrap_structured_tool(fn)
         is_async = _is_async_method(fn)
-        entity_name = name or fn.__qualname__
+        entity_name = name or _get_original_function_name(fn)
         if is_async:
-            if inspect.isasyncgenfunction(fn):
+            if _is_async_generator(fn):
 
                 @wraps(fn)
                 async def async_gen_wrap(*args: Any, **kwargs: Any) -> Any:
@@ -375,7 +377,7 @@ def entity_method(
                                     agent_recovery_tracker.record_agent_recovery(
                                         entity_name
                                     )
-                        _handle_graph_response(span, res, tlp_span_kind)
+                        _handle_graph_response(span, res, protocol, tlp_span_kind)
                         # span will be ended in the generator
                         if isinstance(res, types.GeneratorType):
                             return _handle_generator(span, res)
@@ -421,7 +423,7 @@ def entity_method(
                         _cleanup_span(span, ctx_token)
                     return res
 
-                return cast(F, async_wrap)
+            decorated = async_wrap
         else:
 
             @wraps(fn)
@@ -485,7 +487,7 @@ def entity_method(
                                 agent_recovery_tracker.record_agent_recovery(
                                     entity_name
                                 )
-                    _handle_graph_response(span, res, tlp_span_kind)
+                    _handle_graph_response(span, res, protocol, tlp_span_kind)
 
                     # span will be ended in the generator
                     if isinstance(res, types.GeneratorType):
@@ -532,7 +534,12 @@ def entity_method(
                     _cleanup_span(span, ctx_token)
                 return res
 
-            return cast(F, sync_wrap)
+            decorated = sync_wrap
+        # # If the original fn was a StructuredTool, re-wrap
+        if hasattr(fn, "func") and callable(fn.func):
+            fn.func = decorated
+            return fn
+        return decorated
 
     return decorate
 
@@ -541,6 +548,7 @@ def entity_class(
     name: Optional[str],
     description: Optional[str],
     version: Optional[int],
+    protocol: Optional[str],
     method_name: Optional[str],
     tlp_span_kind: Optional[ObserveSpanKindValues] = ObserveSpanKindValues.TASK,
 ):
@@ -585,16 +593,18 @@ def entity_class(
             if hasattr(cls, method_to_wrap):
                 original_method = getattr(cls, method_to_wrap)
                 # Only wrap actual functions defined in this class
-                if inspect.isfunction(original_method):
+                unwrapped_method = _unwrap_structured_tool(original_method)
+                if inspect.isfunction(unwrapped_method):
                     try:
                         # Verify the method has a proper signature
-                        sig = inspect.signature(original_method)
+                        sig = inspect.signature(unwrapped_method)
                         wrapped_method = entity_method(
                             name=f"{task_name}.{method_to_wrap}",
                             description=description,
                             version=version,
+                            protocol=protocol,
                             tlp_span_kind=tlp_span_kind,
-                        )(original_method)
+                        )(unwrapped_method)
                         # Set the wrapped method on the class
                         setattr(cls, method_to_wrap, wrapped_method)
                     except Exception:
@@ -654,15 +664,17 @@ def _handle_execution_result(span, success):
     return
 
 
-def _handle_graph_response(span, res, tlp_span_kind):
+def _handle_graph_response(span, res, protocol, tlp_span_kind):
     if tlp_span_kind == "graph":
+        if protocol:
+            protocol = protocol.upper()
+            span.set_attribute("gen_ai.ioa.graph.protocol", protocol)
         # Check if the response is a Llama Index Workflow object
         graph = determine_workflow_type(res)
         if graph is not None:
             # Convert the graph to JSON string
             graph_json = json.dumps(graph, indent=2)
             span.set_attribute("gen_ai.ioa.graph", graph_json)
-
             # get graph dynamism
             dynamism = topology_dynamism(graph)
             span.set_attribute("gen_ai.ioa.graph_dynamism", dynamism)

ioa_observe/sdk/decorators/helpers.py

@@ -0,0 +1,66 @@
+# Copyright AGNTCY Contributors (https://github.com/agntcy)
+# SPDX-License-Identifier: Apache-2.0
+
+import inspect
+
+
+def _is_async_method(fn):
+    # check if co-routine function or async generator( example : using async & yield)
+    if inspect.iscoroutinefunction(fn) or inspect.isasyncgenfunction(fn):
+        return True
+
+    # Check if this is a wrapped function that might hide the original async nature
+    # Look for common wrapper attributes that might contain the original function
+    for attr_name in ["__wrapped__", "func", "_func", "function"]:
+        if hasattr(fn, attr_name):
+            wrapped_fn = getattr(fn, attr_name)
+            if wrapped_fn and callable(wrapped_fn):
+                if inspect.iscoroutinefunction(
+                    wrapped_fn
+                ) or inspect.isasyncgenfunction(wrapped_fn):
+                    return True
+                # Recursively check in case of multiple levels of wrapping
+                if _is_async_method(wrapped_fn):
+                    return True
+
+    return False
+
+
+def _is_async_generator(fn):
+    """Check if function is an async generator, looking through wrapped functions"""
+    if inspect.isasyncgenfunction(fn):
+        return True
+
+    # Check if this is a wrapped function that might hide the original async generator nature
+    for attr_name in ["__wrapped__", "func", "_func", "function"]:
+        if hasattr(fn, attr_name):
+            wrapped_fn = getattr(fn, attr_name)
+            if wrapped_fn and callable(wrapped_fn):
+                if inspect.isasyncgenfunction(wrapped_fn):
+                    return True
+                # Recursively check in case of multiple levels of wrapping
+                if _is_async_generator(wrapped_fn):
+                    return True
+
+    return False
+
+
+def _get_original_function_name(fn):
+    """Extract the original function name from potentially wrapped functions"""
+    if hasattr(fn, "__qualname__") and fn.__qualname__:
+        return fn.__qualname__
+
+    # Look for the original function in common wrapper attributes
+    for attr_name in ["__wrapped__", "func", "_func", "function"]:
+        if hasattr(fn, attr_name):
+            wrapped_fn = getattr(fn, attr_name)
+            if wrapped_fn and callable(wrapped_fn):
+                if hasattr(wrapped_fn, "__qualname__") and wrapped_fn.__qualname__:
+                    return wrapped_fn.__qualname__
+                # Recursively check in case of multiple levels of wrapping
+                result = _get_original_function_name(wrapped_fn)
+                if result:
+                    return result
+
+    # Fallback to function name if qualname is not available
+    return getattr(fn, "__name__", "unknown_function")

ioa_observe/sdk/decorators/util.py

@@ -13,6 +13,129 @@ from llama_index.core.workflow.utils import (
 )
 
 
+def _serialize_object(obj, max_depth=3, current_depth=0):
+    """
+    Intelligently serialize an object to a more meaningful representation
+    """
+    if current_depth > max_depth:
+        return f"<{type(obj).__name__}:max_depth_reached>"
+
+    # Handle basic JSON-serializable types
+    if obj is None or isinstance(obj, (bool, int, float, str)):
+        return obj
+
+    # Handle lists and tuples
+    if isinstance(obj, (list, tuple)):
+        try:
+            return [
+                _serialize_object(item, max_depth, current_depth + 1)
+                for item in obj[:10]
+            ]  # Limit to first 10 items
+        except Exception:
+            return f"<{type(obj).__name__}:length={len(obj)}>"
+
+    # Handle dictionaries
+    if isinstance(obj, dict):
+        try:
+            serialized = {}
+            for key, value in list(obj.items())[:10]:  # Limit to first 10 items
+                serialized[str(key)] = _serialize_object(
+                    value, max_depth, current_depth + 1
+                )
+            return serialized
+        except Exception:
+            return f"<dict:keys={len(obj)}>"
+
+    # Handle common object types with meaningful attributes
+    try:
+        # Check class attributes first
+        class_attrs = {}
+        for attr_name in dir(type(obj)):
+            if (
+                not attr_name.startswith("_")
+                and not callable(getattr(type(obj), attr_name, None))
+                and hasattr(obj, attr_name)
+            ):
+                try:
+                    attr_value = getattr(obj, attr_name)
+                    if not callable(attr_value):
+                        class_attrs[attr_name] = _serialize_object(
+                            attr_value, max_depth, current_depth + 1
+                        )
+                        if len(class_attrs) >= 5:  # Limit attributes
+                            break
+                except Exception:
+                    continue
+
+        # Check if object has a __dict__ with interesting attributes
+        instance_attrs = {}
+        if hasattr(obj, "__dict__"):
+            obj_dict = obj.__dict__
+            if obj_dict:
+                # Extract meaningful attributes (skip private ones and callables)
+                for key, value in obj_dict.items():
+                    if not key.startswith("_") and not callable(value):
+                        try:
+                            instance_attrs[key] = _serialize_object(
+                                value, max_depth, current_depth + 1
+                            )
+                            if len(instance_attrs) >= 5:  # Limit attributes
+                                break
+                        except Exception:
+                            continue
+
+        # Combine class and instance attributes
+        all_attrs = {**class_attrs, **instance_attrs}
+
+        if all_attrs:
+            return {
+                "__class__": type(obj).__name__,
+                "__module__": getattr(type(obj), "__module__", "unknown"),
+                "attributes": all_attrs,
+            }
+
+        # Special handling for specific types
+        if hasattr(obj, "message") and hasattr(obj.message, "parts"):
+            # Handle RequestContext-like objects
+            try:
+                parts_content = []
+                for part in obj.message.parts:
+                    if hasattr(part, "root") and hasattr(part.root, "text"):
+                        parts_content.append(part.root.text)
+                return {
+                    "__class__": type(obj).__name__,
+                    "message_content": parts_content,
+                }
+            except Exception:
+                pass
+
+        # Check for common readable attributes
+        for attr in ["name", "id", "type", "value", "content", "text", "data"]:
+            if hasattr(obj, attr):
+                try:
+                    attr_value = getattr(obj, attr)
+                    if not callable(attr_value):
+                        return {
+                            "__class__": type(obj).__name__,
+                            attr: _serialize_object(
+                                attr_value, max_depth, current_depth + 1
+                            ),
+                        }
+                except Exception:
+                    continue
+
+        # Fallback to class information
+        return {
+            "__class__": type(obj).__name__,
+            "__module__": getattr(type(obj), "__module__", "unknown"),
+            "__repr__": str(obj)[:100] + ("..." if len(str(obj)) > 100 else ""),
+        }
+
+    except Exception:
+        # Final fallback
+        return f"<{type(obj).__name__}:serialization_failed>"
+
+
 def determine_workflow_type(workflow_obj: Any) -> Union[None, dict]:
     """Determines the workflow type and generates appropriate topology."""
     # Check if it's a dict mapping agent roles to agent names

{ioa_observe_sdk-1.0.12.dist-info → ioa_observe_sdk-1.0.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ioa-observe-sdk
-Version: 1.0.12
+Version: 1.0.14
 Summary: IOA Observability SDK
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -15,17 +15,17 @@ Requires-Dist: opentelemetry-exporter-otlp-proto-grpc==1.33.1
 Requires-Dist: opentelemetry-exporter-otlp-proto-http==1.33.1
 Requires-Dist: opentelemetry-instrumentation
 Requires-Dist: opentelemetry-instrumentation-logging==0.54b1
-Requires-Dist: opentelemetry-instrumentation-openai==0.40.8
-Requires-Dist: opentelemetry-instrumentation-llamaindex==0.40.8
-Requires-Dist: opentelemetry-instrumentation-ollama==0.40.8
-Requires-Dist: opentelemetry-instrumentation-anthropic==0.40.8
-Requires-Dist: opentelemetry-instrumentation-langchain==0.40.8
+Requires-Dist: opentelemetry-instrumentation-openai==0.43.1
+Requires-Dist: opentelemetry-instrumentation-llamaindex==0.43.1
+Requires-Dist: opentelemetry-instrumentation-ollama==0.43.1
+Requires-Dist: opentelemetry-instrumentation-anthropic==0.43.1
+Requires-Dist: opentelemetry-instrumentation-langchain==0.43.1
 Requires-Dist: opentelemetry-instrumentation-threading==00.54b1
 Requires-Dist: opentelemetry-instrumentation-urllib3==0.54b1
 Requires-Dist: opentelemetry-proto==1.33.1
 Requires-Dist: opentelemetry-sdk==1.33.1
 Requires-Dist: opentelemetry-semantic-conventions==0.54b1
-Requires-Dist: opentelemetry-semantic-conventions-ai==0.4.9
+Requires-Dist: opentelemetry-semantic-conventions-ai>=0.4.11
 Requires-Dist: opentelemetry-util-http==0.54b1
 Requires-Dist: langgraph>=0.3.2
 Requires-Dist: langchain>=0.3.19

{ioa_observe_sdk-1.0.12.dist-info → ioa_observe_sdk-1.0.14.dist-info}/RECORD

@@ -9,9 +9,10 @@ ioa_observe/sdk/client/http.py,sha256=LdLYSQPFIhKN5BTB-N78jLO7ITl7jGjA0-qpewEIvO
 ioa_observe/sdk/config/__init__.py,sha256=8aVNaw0yRNLFPxlf97iOZLlJVcV81ivSDnudH2m1OIo,572
 ioa_observe/sdk/connectors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ioa_observe/sdk/connectors/slim.py,sha256=NwbKEV7d5NIOqmG8zKqtgGigSJl7kf3QJ65z2gxpsY8,8498
-ioa_observe/sdk/decorators/__init__.py,sha256=Lv5EbouBazvWaYB0N82v26pqKtj2FAqlwfLKEh5e8Q0,3251
-ioa_observe/sdk/decorators/base.py,sha256=kR_0KWMMbOdJ_t9m5EZ9ZUj3pmKWEgkj0-E1F3c-nIE,29969
-ioa_observe/sdk/decorators/util.py,sha256=WMkzmwD7Js0g1BbId9_qR4pwhnaIJdW588zVc5dpqdQ,25399
+ioa_observe/sdk/decorators/__init__.py,sha256=c8gzCG-CASNI61RiTpNiTvMfguWvn4zc25fhBBgbHFA,3626
+ioa_observe/sdk/decorators/base.py,sha256=KbSxFUTP_qpZA0gzt_xe4pFTu9SLpAo1MbHskQ3BQ9A,30208
+ioa_observe/sdk/decorators/helpers.py,sha256=I9HXMBivkZpGDtPe9Ad_UU35p_m_wEPate4r_fU0oOA,2705
+ioa_observe/sdk/decorators/util.py,sha256=IebvH9gwZN1en3LblYJUh4bAV2STl6xmp8WpZzBDH2g,30068
 ioa_observe/sdk/instrumentations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ioa_observe/sdk/instrumentations/a2a.py,sha256=ov_9ckkymf_qFXG0iXVWfxlW-3kFcP-knrM_t-Cf72w,4414
 ioa_observe/sdk/instrumentations/slim.py,sha256=J5e6XeshH55xXaUiT9_j4R_n6VQELzBjgRAU-AgZGOg,11435
@@ -38,8 +39,8 @@ ioa_observe/sdk/utils/const.py,sha256=GwbHakKPjBL4wLqAVkDrSoKB-8p18EUrbaqPuRuV_x
 ioa_observe/sdk/utils/in_memory_span_exporter.py,sha256=H_4TRaThMO1H6vUQ0OpQvzJk_fZH0OOsRAM1iZQXsR8,2112
 ioa_observe/sdk/utils/json_encoder.py,sha256=g4NQ0tTqgWssY6I1D7r4zo0G6PiUo61jhofTAw5-jno,639
 ioa_observe/sdk/utils/package_check.py,sha256=1d1MjxhwoEZIx9dumirT2pRsEWgn-m-SI4npDeEalew,576
-ioa_observe_sdk-1.0.12.dist-info/licenses/LICENSE.md,sha256=55VjUfgjWOS4vv3Cf55gfq-RxjPgRIO2vlgYPUuC5lA,11362
-ioa_observe_sdk-1.0.12.dist-info/METADATA,sha256=3owAgvI_xgARwMohc3ticBRqKwju2w-poBOu1SILHC4,6109
-ioa_observe_sdk-1.0.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ioa_observe_sdk-1.0.12.dist-info/top_level.txt,sha256=Yt-6Y1olZEDqCs2REeqI30WjYx0pLGQSVqzYmDd67N8,12
-ioa_observe_sdk-1.0.12.dist-info/RECORD,,
+ioa_observe_sdk-1.0.14.dist-info/licenses/LICENSE.md,sha256=55VjUfgjWOS4vv3Cf55gfq-RxjPgRIO2vlgYPUuC5lA,11362
+ioa_observe_sdk-1.0.14.dist-info/METADATA,sha256=SaSIS2l9wA9A4KRRazaD33ZmMPzLsjNKvqeFl50ko0Y,6110
+ioa_observe_sdk-1.0.14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ioa_observe_sdk-1.0.14.dist-info/top_level.txt,sha256=Yt-6Y1olZEDqCs2REeqI30WjYx0pLGQSVqzYmDd67N8,12
+ioa_observe_sdk-1.0.14.dist-info/RECORD,,