Ak Dev New Tracing Provider

ak-py/src/agentkernel/trace/<provider>/
├── __init__.py
├── <provider>.py        # Main trace class
├── openai.py            # Traced OpenAI runner
├── langgraph.py         # Traced LangGraph runner
├── crewai.py            # Traced CrewAI runner
├── adk.py               # Traced Google ADK runner
├── smolagents.py        # Traced Smolagents runner
└── pydanticai.py        # Traced Pydantic AI runner

# ak-py/src/agentkernel/trace/<provider>/<provider>.py
import logging
from agentkernel.core.base import Runner
from agentkernel.trace.base import BaseTrace

logger = logging.getLogger("ak.trace.<provider>")


class <Provider>(BaseTrace):
    """<Provider> tracing implementation for Agent Kernel."""

    def __init__(self):
        logger.info("Initializing <Provider> tracing")
        # Initialize the tracing client/SDK
        # e.g., self._client = ProviderClient()

    def init(self):
        """Initialize the tracing backend. Called once at startup."""
        # Set up any global instrumentation
        # e.g., self._client.configure(api_key=os.getenv("PROVIDER_API_KEY"))
        pass

    def openai(self) -> Runner | None:
        """Return a traced runner for OpenAI framework, or None if not supported."""
        try:
            from .openai import <Provider>OpenAIRunner
            return <Provider>OpenAIRunner(self._client)
        except ImportError:
            logger.warning("OpenAI tracing dependencies not available")
            return None

    def langgraph(self) -> Runner | None:
        try:
            from .langgraph import <Provider>LangGraphRunner
            return <Provider>LangGraphRunner(self._client)
        except ImportError:
            return None

    def crewai(self) -> Runner | None:
        try:
            from .crewai import <Provider>CrewAIRunner
            return <Provider>CrewAIRunner(self._client)
        except ImportError:
            return None

    def adk(self) -> Runner | None:
        try:
            from .adk import <Provider>ADKRunner
            return <Provider>ADKRunner(self._client)
        except ImportError:
            return None

    def smolagents(self) -> Runner:
        from .smolagents import <Provider>SmolagentsRunner

        return <Provider>SmolagentsRunner(self._client)

# ak-py/src/agentkernel/trace/<provider>/openai.py
from agentkernel.framework.openai.openai import OpenAIRunner
from agentkernel.core.base import Session
from agentkernel.core.model import AgentReply, AgentRequest


class <Provider>OpenAIRunner(OpenAIRunner):
    def __init__(self, client):
        super().__init__()
        self._trace_client = client

    async def run(self, agent, session: Session, requests: list[AgentRequest]) -> AgentReply:
        # Wrap the base runner's execution with a trace span
        with self._trace_client.start_span(
            name=f"agent.{agent.name}",
            attributes={
                "framework": "openai",
                "session_id": session.id,
                "agent_name": agent.name,
            }
        ) as span:
            try:
                result = await super().run(agent, session, requests)
                span.set_attribute("output_length", len(result.response) if hasattr(result, 'response') else 0)
                span.set_status("OK")
                return result
            except Exception as e:
                span.set_status("ERROR")
                span.record_exception(e)
                raise

# ak-py/src/agentkernel/trace/<provider>/langgraph.py
from agentkernel.framework.langgraph.langgraph import LangGraphRunner


class <Provider>LangGraphRunner(LangGraphRunner):
    def __init__(self, client):
        super().__init__()
        self._trace_client = client

    async def run(self, agent, session, requests):
        with self._trace_client.start_span(
            name=f"agent.{agent.name}",
            attributes={"framework": "langgraph", "session_id": session.id}
        ):
            return await super().run(agent, session, requests)

# ak-py/src/agentkernel/trace/<provider>/__init__.py
from .<provider> import <Provider>

_BUILTIN_TRACERS = ["langfuse", "openllmetry", "logfire", "cloudwatch"]

class Trace(BaseTrace):
    @classmethod
    def get(cls) -> "Trace":
        config = AKConfig.get()
        instance = cls._build(config.trace.type) if config.trace.enabled else None
        trace = cls(instance)
        trace.init()
        return trace

    @staticmethod
    def _build(trace_type: str) -> BaseTrace:
        if trace_type == "langfuse":
            with require_extra("langfuse", "trace.type: langfuse"):
                from .langfuse.langfuse import LangFuse
            return LangFuse()
        if trace_type == "openllmetry":
            with require_extra("openllmetry", "trace.type: openllmetry"):
                from .openllmetry.openllmetry import OpenLLMetry
            return OpenLLMetry()
        if trace_type == "logfire":
            with require_extra("logfire", "trace.type: logfire"):
                from .logfire.logfire import Logfire
            return Logfire()
        if trace_type == "cloudwatch":
            with require_extra("cloudwatch", "trace.type: cloudwatch"):
                from .cloudwatch.cloudwatch import CloudWatch
            return CloudWatch()
        if trace_type == "<provider>":                                    # ADD THIS
            with require_extra("<provider>", "trace.type: <provider>"):
                from .<provider>.<provider> import <Provider>
            return <Provider>()
        if "." not in trace_type:
            raise AKConfigError(
                f"unknown trace type '{trace_type}'; expected one of {_BUILTIN_TRACERS} or a dotted path to a BaseTrace subclass"
            )
        return resolve_dotted(trace_type, base=BaseTrace)()  # bring-your-own

# config.yaml
trace:
  enabled: true
  type: <provider>