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

ioa_observe/sdk/__init__.py

@@ -89,7 +89,7 @@ class Observe:
 
         if (
             observe_sync_enabled
-            and api_endpoint.find("observe.com") != -1
+            and api_endpoint.find("agntcy-observe.com") != -1
             and api_key
             and (exporter is None)
             and (processor is None)
@@ -112,13 +112,13 @@ class Observe:
         if (
             not exporter
             and not processor
-            and api_endpoint == "https://api.observe.com"
+            and api_endpoint == "https://api.agntcy-observe.com"
             and not api_key
         ):
             print(
                 Fore.RED
                 + "Error: Missing observe API key,"
-                + " go to https://app.observe.com/settings/api-keys to create one"
+                + " go to https://app.agntcy-observe.com/settings/api-keys to create one"
             )
             print("Set the OBSERVE_API_KEY environment variable to the key")
             print(Fore.RESET)

ioa_observe/sdk/client/client.py

@@ -27,7 +27,7 @@ class Client:
         self,
         api_key: str,
         app_name: str = sys.argv[0],
-        api_endpoint: str = "https://api.observe.com",
+        api_endpoint: str = "https://api.agntcy-observe.com",
     ):
         """
         Initialize a new observe client.
@@ -35,13 +35,13 @@ class Client:
         Args:
             api_key (str): Your observe API key
             app_name (Optional[str], optional): The name of your application. Defaults to sys.argv[0].
-            api_endpoint (Optional[str], optional): Custom API endpoint. Defaults to https://api.observe.com.
+            api_endpoint (Optional[str], optional): Custom API endpoint. Defaults to https://api.agntcy-observe.com.
         """
         if not api_key or not api_key.strip():
             raise ValueError("API key is required")
 
         self.app_name = app_name
-        self.api_endpoint = api_endpoint or "https://api.observe.com"
+        self.api_endpoint = api_endpoint or "https://api.agntcy-observe.com"
         self.api_key = api_key
         self._http = HTTPClient(
             base_url=self.api_endpoint, api_key=self.api_key, version=__version__

ioa_observe/sdk/decorators/__init__.py

@@ -1,7 +1,7 @@
 # Copyright AGNTCY Contributors (https://github.com/agntcy)
 # SPDX-License-Identifier: Apache-2.0
 import inspect
-from typing import Optional, Union, TypeVar, Callable, Awaitable
+from typing import Optional, Union, TypeVar, Callable, Any
 
 from typing_extensions import ParamSpec
 
@@ -14,7 +14,7 @@ from ioa_observe.sdk.utils.const import ObserveSpanKindValues
 
 P = ParamSpec("P")
 R = TypeVar("R")
-F = TypeVar("F", bound=Callable[P, Union[R, Awaitable[R]]])
+F = TypeVar("F", bound=Callable[..., Any])
 
 
 def task(

ioa_observe/sdk/decorators/base.py

@@ -7,7 +7,7 @@ import traceback
 from functools import wraps
 import os
 import types
-from typing import Optional, TypeVar, Callable, Awaitable, Any, Union
+from typing import Optional, TypeVar, Callable, Any
 import inspect
 
 from ioa_observe.sdk.decorators.helpers import (
@@ -53,7 +53,7 @@ from ioa_observe.sdk.metrics.agent import topology_dynamism, determinism_score
 P = ParamSpec("P")
 
 R = TypeVar("R")
-F = TypeVar("F", bound=Callable[P, Union[R, Awaitable[R]]])
+F = TypeVar("F", bound=Callable[..., Any])
 
 
 def _is_json_size_valid(json_str: str) -> bool:

ioa_observe/sdk/instrumentations/a2a.py

@@ -14,7 +14,7 @@ from ioa_observe.sdk import TracerWrapper
 from ioa_observe.sdk.client import kv_store
 from ioa_observe.sdk.tracing import set_session_id, get_current_traceparent
 
-_instruments = ("a2a-sdk >= 0.2.5",)
+_instruments = ("a2a-sdk >= 0.3.0",)
 _global_tracer = None
 _kv_lock = threading.RLock()  # Add thread-safety for kv_store operations
 
@@ -34,15 +34,14 @@ class A2AInstrumentor(BaseInstrumentor):
         if importlib.util.find_spec("a2a") is None:
             raise ImportError("No module named 'a2a-sdk'. Please install it first.")
 
-        # Instrument `publish`
+        # Instrument client send_message
         from a2a.client import A2AClient
 
         original_send_message = A2AClient.send_message
 
         @functools.wraps(original_send_message)
-        async def instrumented_send_message(
-            self, request, *, http_kwargs=None, context=None
-        ):
+        async def instrumented_send_message(self, request, *args, **kwargs):
+            # Put context into A2A message metadata instead of HTTP headers
             with _global_tracer.start_as_current_span("a2a.send_message"):
                 traceparent = get_current_traceparent()
                 session_id = None
@@ -50,47 +49,101 @@ class A2AInstrumentor(BaseInstrumentor):
                     session_id = kv_store.get(f"execution.{traceparent}")
                     if session_id:
                         kv_store.set(f"execution.{traceparent}", session_id)
-                # Inject headers into http_kwargs
-                if http_kwargs is None:
-                    http_kwargs = {}
-                headers = http_kwargs.get("headers", {})
-                headers["traceparent"] = traceparent
+
+                # Ensure metadata dict exists
+                try:
+                    md = getattr(request.params, "metadata", None)
+                except AttributeError:
+                    md = None
+                metadata = md if isinstance(md, dict) else {}
+
+                observe_meta = dict(metadata.get("observe", {}))
+
+                # Inject W3C trace context + baggage into observe_meta
+                TraceContextTextMapPropagator().inject(carrier=observe_meta)
+                W3CBaggagePropagator().inject(carrier=observe_meta)
+
+                if traceparent:
+                    observe_meta["traceparent"] = traceparent
                 if session_id:
-                    headers["session_id"] = session_id
+                    observe_meta["session_id"] = session_id
                     baggage.set_baggage(f"execution.{traceparent}", session_id)
-                http_kwargs["headers"] = headers
-            return await original_send_message(self, request, http_kwargs=http_kwargs)
 
-        from a2a.client import A2AClient
+                metadata["observe"] = observe_meta
+
+                # Write back metadata (pydantic models are mutable by default in v2)
+                try:
+                    request.params.metadata = metadata
+                except Exception:
+                    # Fallback
+                    request = request.model_copy(
+                        update={
+                            "params": request.params.model_copy(
+                                update={"metadata": metadata}
+                            )
+                        }
+                    )
+
+            # Call through without transport-specific kwargs
+            return await original_send_message(self, request, *args, **kwargs)
 
         A2AClient.send_message = instrumented_send_message
 
+        # Instrument server handler
         from a2a.server.request_handlers import DefaultRequestHandler
 
         original_server_on_message_send = DefaultRequestHandler.on_message_send
 
         @functools.wraps(original_server_on_message_send)
-        async def instrumented_execute(self, params, context):
-            # Extract headers from context (assume context.request.headers)
-
-            traceparent = context.state.get("headers", {}).get("traceparent")
-            session_id = context.state.get("headers", {}).get("session_id")
-            carrier = {
-                k.lower(): v
-                for k, v in context.state.get("headers", {}).items()
-                if k.lower() in ["traceparent", "baggage"]
-            }
-            if carrier and traceparent:
+        async def instrumented_on_message_send(self, params, context):
+            # Read context from A2A message metadata (transport-agnostic)
+            try:
+                metadata = getattr(params, "metadata", {}) or {}
+            except Exception:
+                metadata = {}
+
+            carrier = {}
+            observe_meta = metadata.get("observe", {}) or {}
+            # Accept keys we inject
+            for k in ("traceparent", "baggage", "session_id"):
+                if k in observe_meta:
+                    carrier[k] = observe_meta[k]
+
+            token = None
+            if carrier.get("traceparent"):
+                # Extract and attach parent context
                 ctx = TraceContextTextMapPropagator().extract(carrier=carrier)
                 ctx = W3CBaggagePropagator().extract(carrier=carrier, context=ctx)
+                try:
+                    from opentelemetry import context as otel_ctx
+
+                    token = otel_ctx.attach(ctx)
+                except Exception:
+                    token = None
+
+                session_id = observe_meta.get("session_id")
                 if session_id and session_id != "None":
-                    set_session_id(session_id, traceparent=traceparent)
-                    kv_store.set(f"execution.{traceparent}", session_id)
-            return await original_server_on_message_send(self, params, context)
+                    set_session_id(session_id, traceparent=carrier.get("traceparent"))
+                    kv_store.set(f"execution.{carrier.get('traceparent')}", session_id)
 
-        from a2a.server.request_handlers import DefaultRequestHandler
+            try:
+                return await original_server_on_message_send(self, params, context)
+            finally:
+                if token is not None:
+                    try:
+                        otel_ctx.detach(token)
+                    except Exception:
+                        pass
+
+        DefaultRequestHandler.on_message_send = instrumented_on_message_send
+
+        # from a2a.client import A2AClient
+
+        # A2AClient.send_message = instrumented_send_message
+
+        # from a2a.server.request_handlers import DefaultRequestHandler
 
-        DefaultRequestHandler.on_message_send = instrumented_execute
+        # original_server_on_message_send = DefaultRequestHandler.on_message_send
 
     def _uninstrument(self, **kwargs):
         import importlib
@@ -103,7 +156,7 @@ class A2AInstrumentor(BaseInstrumentor):
 
         A2AClient.send_message = A2AClient.send_message.__wrapped__
 
-        # Uninstrument `execute`
+        # Uninstrument server handler
         from a2a.server.request_handlers import DefaultRequestHandler
 
         DefaultRequestHandler.on_message_send = (