feat: CrewAI integration and LangGraph node-level tracing (#153)

- integrations/crewai.py: new integration patching Crew.kickoff,
  Agent.execute_task, and Task.execute_sync to emit session_start,
  llm_request/response, and tool_call/result events
- integrations/langchain.py: add LangGraph StateGraph.compile patch
  that wraps each compiled node with decision + tool_result events;
  uninstrument_langchain now properly restores all three patches
- integrations/__init__.py: register crewai and langgraph aliases,
  add instrument_crewai() export, add to _DETECTABLE/_FRAMEWORK_PROBE
- pyproject.toml: add crewai optional extra and include in all-integrations

Closes #131

Co-authored-by: Ona <no-reply@ona.com>

Author: Siddhant-K-code

pyproject.toml

@@ -33,13 +33,15 @@ litellm = ["litellm>=1.0.0"]
 anthropic = ["anthropic>=0.20.0"]
 openai = ["openai>=1.0.0"]
 strands = ["strands-agents>=0.1.0"]
+crewai = ["crewai>=0.28.0"]
 all-integrations = [
     "openai-agents>=0.0.1",
     "langchain-core>=0.1.0",
     "litellm>=1.0.0",
     "anthropic>=0.20.0",
     "openai>=1.0.0",
     "strands-agents>=0.1.0",
+    "crewai>=0.28.0",
 ]
 
 [project.scripts]

src/agent_trace/__init__.py

@@ -1,3 +1,3 @@
 """agent-trace: strace for AI agents."""
 
-__version__ = "0.55.0"
+__version__ = "0.56.0"

src/agent_trace/integrations/__init__.py

@@ -32,10 +32,12 @@
     "openai-agents": ("agent_trace.integrations.openai_agents", "instrument_openai_agents"),
     "openai_agents": ("agent_trace.integrations.openai_agents", "instrument_openai_agents"),
     "langchain": ("agent_trace.integrations.langchain", "instrument_langchain"),
+    "langgraph": ("agent_trace.integrations.langchain", "instrument_langchain"),
     "litellm": ("agent_trace.integrations.litellm", "instrument_litellm"),
     "anthropic": ("agent_trace.integrations.anthropic", "instrument_anthropic"),
     "openai": ("agent_trace.integrations.openai", "instrument_openai"),
     "strands": ("agent_trace.integrations.strands", "instrument_strands"),
+    "crewai": ("agent_trace.integrations.crewai", "instrument_crewai"),
 }
 
 # Frameworks that can be auto-detected by checking importability
@@ -46,6 +48,7 @@
     "anthropic",
     "openai",
     "strands",
+    "crewai",
 ]
 
 _FRAMEWORK_PROBE: dict[str, str] = {
@@ -55,6 +58,7 @@
     "anthropic": "anthropic",
     "openai": "openai",
     "strands": "strands",
+    "crewai": "crewai",
 }
 
 
@@ -102,6 +106,11 @@ def instrument_strands(**kwargs):
     return _import_integration("strands")(**kwargs)
 
 
+def instrument_crewai(**kwargs):
+    """Instrument CrewAI."""
+    return _import_integration("crewai")(**kwargs)
+
+
 def detect_and_instrument() -> list[str]:
     """Auto-detect installed frameworks and instrument all of them.
 

src/agent_trace/integrations/crewai.py

@@ -0,0 +1,156 @@
+"""Auto-instrumentation for CrewAI.
+
+Patches:
+  - crewai.Crew.kickoff          → session_start / session_end
+  - crewai.Agent.execute_task    → llm_request / llm_response
+  - crewai.Task.execute_sync     → tool_call / tool_result
+
+Install:
+    pip install agent-strace[crewai]
+    # or: pip install crewai
+"""
+
+from __future__ import annotations
+
+import time
+
+_PATCHED = False
+_orig_kickoff = None
+_orig_execute_task = None
+_orig_task_execute = None
+
+
+def instrument_crewai(agent_name: str = "crewai") -> None:
+    """Patch CrewAI to emit agent-trace events. Idempotent."""
+    global _PATCHED, _orig_kickoff, _orig_execute_task, _orig_task_execute
+    if _PATCHED:
+        return
+
+    try:
+        import crewai  # noqa: F401
+    except ImportError as exc:
+        raise ImportError(
+            "CrewAI is not installed. "
+            "Install it with: pip install crewai"
+        ) from exc
+
+    from ._base import _get_store, _get_or_create_session, emit
+    from ..models import EventType
+
+    store = _get_store()
+
+    # --- Patch Crew.kickoff ---
+    try:
+        from crewai import Crew
+
+        _orig_kickoff = Crew.kickoff
+
+        def _patched_kickoff(self, *args, **kwargs):
+            sid = _get_or_create_session(store, agent_name)
+            crew_name = getattr(self, "name", None) or agent_name
+            emit(EventType.SESSION_START, sid, store,
+                 agent_name=crew_name,
+                 agent_count=len(getattr(self, "agents", [])),
+                 task_count=len(getattr(self, "tasks", [])))
+            t0 = time.time()
+            try:
+                result = _orig_kickoff(self, *args, **kwargs)
+                emit(EventType.SESSION_END, sid, store,
+                     duration_ms=(time.time() - t0) * 1000)
+                return result
+            except Exception as exc:
+                emit(EventType.ERROR, sid, store,
+                     error=str(exc), error_type=type(exc).__name__)
+                raise
+
+        Crew.kickoff = _patched_kickoff
+    except (ImportError, AttributeError):
+        pass
+
+    # --- Patch Agent.execute_task ---
+    try:
+        from crewai import Agent
+
+        _orig_execute_task = Agent.execute_task
+
+        def _patched_execute_task(self, task, *args, **kwargs):
+            sid = _get_or_create_session(store, agent_name)
+            agent_role = getattr(self, "role", str(self))
+            task_desc = getattr(task, "description", str(task))[:200]
+            t0 = time.time()
+            emit(EventType.LLM_REQUEST, sid, store,
+                 agent_role=agent_role,
+                 task=task_desc)
+            try:
+                result = _orig_execute_task(self, task, *args, **kwargs)
+                emit(EventType.LLM_RESPONSE, sid, store,
+                     agent_role=agent_role,
+                     duration_ms=(time.time() - t0) * 1000,
+                     result_preview=str(result)[:300])
+                return result
+            except Exception as exc:
+                emit(EventType.ERROR, sid, store,
+                     agent_role=agent_role, error=str(exc))
+                raise
+
+        Agent.execute_task = _patched_execute_task
+    except (ImportError, AttributeError):
+        pass
+
+    # --- Patch Task.execute_sync (tool calls within a task) ---
+    try:
+        from crewai import Task
+
+        _orig_task_execute = Task.execute_sync
+
+        def _patched_task_execute(self, *args, **kwargs):
+            sid = _get_or_create_session(store, agent_name)
+            task_desc = getattr(self, "description", str(self))[:200]
+            t0 = time.time()
+            emit(EventType.TOOL_CALL, sid, store,
+                 tool_name="crewai.task",
+                 task=task_desc)
+            try:
+                result = _orig_task_execute(self, *args, **kwargs)
+                emit(EventType.TOOL_RESULT, sid, store,
+                     tool_name="crewai.task",
+                     duration_ms=(time.time() - t0) * 1000,
+                     result_preview=str(result)[:300])
+                return result
+            except Exception as exc:
+                emit(EventType.ERROR, sid, store,
+                     tool_name="crewai.task", error=str(exc))
+                raise
+
+        Task.execute_sync = _patched_task_execute
+    except (ImportError, AttributeError):
+        pass
+
+    _PATCHED = True
+
+
+def uninstrument_crewai() -> None:
+    """Remove patches (for testing)."""
+    global _PATCHED, _orig_kickoff, _orig_execute_task, _orig_task_execute
+    if _orig_kickoff is not None:
+        try:
+            from crewai import Crew
+            Crew.kickoff = _orig_kickoff
+        except ImportError:
+            pass
+    if _orig_execute_task is not None:
+        try:
+            from crewai import Agent
+            Agent.execute_task = _orig_execute_task
+        except ImportError:
+            pass
+    if _orig_task_execute is not None:
+        try:
+            from crewai import Task
+            Task.execute_sync = _orig_task_execute
+        except ImportError:
+            pass
+    _PATCHED = False
+    _orig_kickoff = None
+    _orig_execute_task = None
+    _orig_task_execute = None

src/agent_trace/integrations/langchain.py

@@ -1,25 +1,30 @@
 """Auto-instrumentation for LangChain / LangGraph.
 
 Patches:
-  - langchain_core.runnables.base.Runnable.invoke  → chain invocations
   - langchain_core.tools.BaseTool._run             → tool_call / tool_result
   - langchain_core.language_models.BaseChatModel._generate → llm_request / llm_response
+  - langgraph.graph.StateGraph.compile             → wraps each node with
+                                                     decision / tool_call events
 
 Install:
     pip install agent-strace[langchain]
     # or: pip install langchain-core
+    # LangGraph node tracing also requires: pip install langgraph
 """
 
 from __future__ import annotations
 
 import time
 
 _PATCHED = False
+_orig_tool_run = None
+_orig_generate = None
+_orig_compile = None
 
 
 def instrument_langchain(agent_name: str = "langchain") -> None:
-    """Patch LangChain to emit agent-trace events. Idempotent."""
-    global _PATCHED
+    """Patch LangChain (and LangGraph if installed) to emit agent-trace events. Idempotent."""
+    global _PATCHED, _orig_tool_run, _orig_generate, _orig_compile
     if _PATCHED:
         return
 
@@ -40,7 +45,7 @@ def instrument_langchain(agent_name: str = "langchain") -> None:
     try:
         from langchain_core.tools import BaseTool
 
-        _orig_run = BaseTool._run
+        _orig_tool_run = BaseTool._run
 
         def _patched_run(self, *args, **kwargs):
             sid = _get_or_create_session(store, agent_name)
@@ -49,7 +54,7 @@ def _patched_run(self, *args, **kwargs):
             emit(EventType.TOOL_CALL, sid, store,
                  tool_name=tool_name, arguments={"args": str(args)[:200], **kwargs})
             try:
-                result = _orig_run(self, *args, **kwargs)
+                result = _orig_tool_run(self, *args, **kwargs)
                 emit(EventType.TOOL_RESULT, sid, store,
                      tool_name=tool_name,
                      result=str(result)[:500],
@@ -91,10 +96,82 @@ def _patched_generate(self, messages, *args, **kwargs):
     except (ImportError, AttributeError):
         pass
 
+    # --- Patch LangGraph StateGraph.compile (optional, best-effort) ---
+    try:
+        from langgraph.graph import StateGraph
+
+        _orig_compile = StateGraph.compile
+
+        def _patched_compile(self, *args, **kwargs):
+            compiled = _orig_compile(self, *args, **kwargs)
+            _wrap_langgraph_nodes(compiled, store, agent_name)
+            return compiled
+
+        StateGraph.compile = _patched_compile
+    except (ImportError, AttributeError):
+        pass  # LangGraph not installed — skip silently
+
     _PATCHED = True
 
 
+def _wrap_langgraph_nodes(compiled_graph, store, agent_name: str) -> None:
+    """Wrap each node in a compiled LangGraph graph to emit decision events."""
+    from ._base import _get_or_create_session, emit
+    from ..models import EventType
+
+    nodes = getattr(compiled_graph, "nodes", None)
+    if not isinstance(nodes, dict):
+        return
+
+    for node_name, node_fn in list(nodes.items()):
+        if node_name in ("__start__", "__end__"):
+            continue
+
+        def _make_wrapper(name, fn):
+            def _wrapped(state, *args, **kwargs):
+                sid = _get_or_create_session(store, agent_name)
+                t0 = time.time()
+                emit(EventType.DECISION, sid, store,
+                     choice=name,
+                     reason=f"LangGraph node: {name}")
+                try:
+                    result = fn(state, *args, **kwargs)
+                    emit(EventType.TOOL_RESULT, sid, store,
+                         tool_name=f"langgraph.node.{name}",
+                         duration_ms=(time.time() - t0) * 1000)
+                    return result
+                except Exception as exc:
+                    emit(EventType.ERROR, sid, store,
+                         tool_name=f"langgraph.node.{name}",
+                         error=str(exc))
+                    raise
+            return _wrapped
+
+        nodes[node_name] = _make_wrapper(node_name, node_fn)
+
+
 def uninstrument_langchain() -> None:
     """Remove patches (for testing)."""
-    global _PATCHED
+    global _PATCHED, _orig_tool_run, _orig_generate, _orig_compile
+    if _orig_tool_run is not None:
+        try:
+            from langchain_core.tools import BaseTool
+            BaseTool._run = _orig_tool_run
+        except ImportError:
+            pass
+    if _orig_generate is not None:
+        try:
+            from langchain_core.language_models import BaseChatModel
+            BaseChatModel._generate = _orig_generate
+        except ImportError:
+            pass
+    if _orig_compile is not None:
+        try:
+            from langgraph.graph import StateGraph
+            StateGraph.compile = _orig_compile
+        except ImportError:
+            pass
     _PATCHED = False
+    _orig_tool_run = None
+    _orig_generate = None
+    _orig_compile = None