cortexhub 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

cortexhub/adapters/claude_agents.py

@@ -19,11 +19,13 @@ Architectural rules:
 - No governance logic in adapter
 """
 
+import json
 import os
 from functools import wraps
 from typing import TYPE_CHECKING, Any, Callable, Awaitable
 
 import structlog
+from opentelemetry.trace import SpanKind, Status, StatusCode
 
 from cortexhub.adapters.base import ToolAdapter
 from cortexhub.pipeline import govern_execution
@@ -36,6 +38,10 @@ logger = structlog.get_logger(__name__)
 # Attribute names for storing originals
 _ORIGINAL_TOOL_ATTR = "__cortexhub_original_tool__"
 _PATCHED_ATTR = "__cortexhub_patched__"
+_ORIGINAL_QUERY_ATTR = "__cortexhub_original_query__"
+_ORIGINAL_RECEIVE_RESPONSE_ATTR = "__cortexhub_original_receive_response__"
+_ORIGINAL_CLIENT_QUERY_ATTR = "__cortexhub_original_client_query__"
+_PATCHED_RUN_ATTR = "__cortexhub_run_patched__"
 
 
 class ClaudeAgentsAdapter(ToolAdapter):
@@ -64,6 +70,10 @@ class ClaudeAgentsAdapter(ToolAdapter):
     def framework_name(self) -> str:
         return "claude_agents"
 
+    def __init__(self, cortex_hub: Any):
+        super().__init__(cortex_hub)
+        self._hook_spans: dict[str, Any] = {}
+
     def _get_framework_modules(self) -> list[str]:
         return ["claude_agent_sdk"]
 
@@ -145,6 +155,8 @@ class ClaudeAgentsAdapter(ToolAdapter):
             setattr(claude_agent_sdk, _PATCHED_ATTR, True)
             
             logger.info("Claude Agent SDK @tool decorator patched successfully")
+
+            self._patch_run_completion(cortex_hub)
             
         except ImportError:
             logger.debug("Claude Agent SDK not installed, skipping adapter")
@@ -161,6 +173,23 @@ class ClaudeAgentsAdapter(ToolAdapter):
                 claude_agent_sdk.tool = original
                 setattr(claude_agent_sdk, _PATCHED_ATTR, False)
                 logger.info("Claude Agent SDK adapter unpatched")
+            
+            try:
+                from claude_agent_sdk import ClaudeSDKClient
+
+                if hasattr(claude_agent_sdk, _ORIGINAL_QUERY_ATTR):
+                    claude_agent_sdk.query = getattr(claude_agent_sdk, _ORIGINAL_QUERY_ATTR)
+                if hasattr(ClaudeSDKClient, _ORIGINAL_CLIENT_QUERY_ATTR):
+                    ClaudeSDKClient.query = getattr(
+                        ClaudeSDKClient, _ORIGINAL_CLIENT_QUERY_ATTR
+                    )
+                if hasattr(ClaudeSDKClient, _ORIGINAL_RECEIVE_RESPONSE_ATTR):
+                    ClaudeSDKClient.receive_response = getattr(
+                        ClaudeSDKClient, _ORIGINAL_RECEIVE_RESPONSE_ATTR
+                    )
+                setattr(claude_agent_sdk, _PATCHED_RUN_ATTR, False)
+            except ImportError:
+                pass
         except ImportError:
             pass
 
@@ -171,6 +200,88 @@ class ClaudeAgentsAdapter(ToolAdapter):
     def _discover_tools(self) -> list[dict[str, Any]]:
         """Discover tools from Claude Agent SDK (best-effort)."""
         return []
+
+    def _patch_run_completion(self, cortex_hub) -> None:
+        """Patch Claude Agent SDK runs to emit run completion."""
+        try:
+            import claude_agent_sdk
+            from claude_agent_sdk import ClaudeSDKClient, ResultMessage
+
+            if getattr(claude_agent_sdk, _PATCHED_RUN_ATTR, False):
+                return
+
+            if not hasattr(claude_agent_sdk, _ORIGINAL_QUERY_ATTR):
+                setattr(claude_agent_sdk, _ORIGINAL_QUERY_ATTR, claude_agent_sdk.query)
+            original_query = getattr(claude_agent_sdk, _ORIGINAL_QUERY_ATTR)
+
+            async def patched_query(*args, **kwargs):
+                status = None
+                failed = False
+                cortex_hub.start_run(framework="claude_agents")
+                try:
+                    async for message in original_query(*args, **kwargs):
+                        if isinstance(message, ResultMessage):
+                            status = "failed" if message.is_error else "completed"
+                        yield message
+                except Exception:
+                    failed = True
+                    raise
+                finally:
+                    if status is None and failed:
+                        status = "failed"
+                    if status:
+                        cortex_hub.finish_run(framework="claude_agents", status=status)
+
+            claude_agent_sdk.query = patched_query
+
+            if not hasattr(ClaudeSDKClient, _ORIGINAL_RECEIVE_RESPONSE_ATTR):
+                setattr(
+                    ClaudeSDKClient,
+                    _ORIGINAL_RECEIVE_RESPONSE_ATTR,
+                    ClaudeSDKClient.receive_response,
+                )
+            original_receive_response = getattr(ClaudeSDKClient, _ORIGINAL_RECEIVE_RESPONSE_ATTR)
+            if not hasattr(ClaudeSDKClient, _ORIGINAL_CLIENT_QUERY_ATTR):
+                setattr(
+                    ClaudeSDKClient,
+                    _ORIGINAL_CLIENT_QUERY_ATTR,
+                    ClaudeSDKClient.query,
+                )
+            original_client_query = getattr(ClaudeSDKClient, _ORIGINAL_CLIENT_QUERY_ATTR)
+
+            async def patched_client_query(self, *args, **kwargs):
+                cortex_hub.start_run(framework="claude_agents")
+                try:
+                    return await original_client_query(self, *args, **kwargs)
+                except Exception:
+                    cortex_hub.finish_run(framework="claude_agents", status="failed")
+                    raise
+
+            async def patched_receive_response(self, *args, **kwargs):
+                status = None
+                failed = False
+                try:
+                    async for message in original_receive_response(self, *args, **kwargs):
+                        if isinstance(message, ResultMessage):
+                            status = "failed" if message.is_error else "completed"
+                        yield message
+                except Exception:
+                    failed = True
+                    raise
+                finally:
+                    if status is None and failed:
+                        status = "failed"
+                    if status:
+                        cortex_hub.finish_run(framework="claude_agents", status=status)
+
+            ClaudeSDKClient.query = patched_client_query
+            ClaudeSDKClient.receive_response = patched_receive_response
+            setattr(claude_agent_sdk, _PATCHED_RUN_ATTR, True)
+            logger.info("Claude Agent SDK run completion patched successfully")
+        except ImportError:
+            logger.debug("Claude Agent SDK run completion patch skipped")
+        except Exception as e:
+            logger.debug("Claude Agent SDK run completion patch failed", reason=str(e))
     
     def create_governance_hooks(self) -> dict[str, list]:
         """Create CortexHub governance hooks for Claude Agent SDK.
@@ -191,6 +302,61 @@ class ClaudeAgentsAdapter(ToolAdapter):
             )
         """
         cortex_hub = self.cortex_hub
+        span_store = self._hook_spans
+
+        def _start_tool_span(
+            *,
+            tool_name: str,
+            tool_description: str,
+            policy_args: dict[str, Any],
+            raw_args: dict[str, Any],
+            tool_use_id: str | None,
+        ):
+            span = cortex_hub._tracer.start_span(
+                name="tool.invoke",
+                kind=SpanKind.INTERNAL,
+            )
+            span.set_attribute("cortexhub.session.id", cortex_hub.session_id)
+            span.set_attribute("cortexhub.agent.id", cortex_hub.agent_id)
+            span.set_attribute("cortexhub.tool.name", tool_name)
+            span.set_attribute("cortexhub.tool.framework", "claude_agents")
+            span.set_attribute("cortexhub.tool.description", tool_description)
+
+            if tool_use_id:
+                span.set_attribute("cortexhub.tool.use_id", tool_use_id)
+
+            if policy_args:
+                arg_names = list(policy_args.keys())
+                if arg_names:
+                    span.set_attribute("cortexhub.tool.arg_names", arg_names)
+                arg_schema = cortex_hub._infer_arg_schema(policy_args)
+                if arg_schema:
+                    span.set_attribute(
+                        "cortexhub.tool.arg_schema",
+                        json.dumps(arg_schema),
+                    )
+
+            if not cortex_hub.privacy and raw_args:
+                span.set_attribute("cortexhub.raw.args", json.dumps(raw_args, default=str))
+
+            return span
+
+        def _finish_tool_span(
+            span,
+            *,
+            success: bool,
+            error_message: str | None = None,
+            result: Any | None = None,
+        ) -> None:
+            span.set_attribute("cortexhub.result.success", success)
+            if error_message:
+                span.set_attribute("cortexhub.error.message", error_message)
+                span.set_status(Status(StatusCode.ERROR, error_message))
+            else:
+                span.set_status(Status(StatusCode.OK))
+            if result is not None and not cortex_hub.privacy:
+                span.set_attribute("cortexhub.raw.result", json.dumps(result, default=str))
+            span.end()
         
         async def pre_tool_governance(
             input_data: dict[str, Any],
@@ -204,12 +370,18 @@ class ClaudeAgentsAdapter(ToolAdapter):
             """
             tool_name = input_data.get("tool_name", "unknown")
             tool_input = input_data.get("tool_input", {})
+            if not isinstance(tool_input, dict):
+                tool_input = {"_raw": tool_input}
+            policy_args = cortex_hub._sanitize_policy_args(tool_input)
             
-            tool_metadata = {
-                "name": tool_name,
-                "description": f"Claude Agent SDK built-in tool: {tool_name}",
-                "framework": "claude_agents",
-            }
+            tool_description = f"Claude Agent SDK built-in tool: {tool_name}"
+            span = _start_tool_span(
+                tool_name=tool_name,
+                tool_description=tool_description,
+                policy_args=policy_args,
+                raw_args=tool_input,
+                tool_use_id=tool_use_id,
+            )
             
             # Build authorization request and evaluate
             from cortexhub.policy.models import (
@@ -222,7 +394,7 @@ class ClaudeAgentsAdapter(ToolAdapter):
                 principal=Principal(type="Agent", id=cortex_hub.agent_id),
                 action=Action(type="tool.invoke", name=tool_name),
                 resource=PolicyResource(type="Tool", id=tool_name),
-                args=tool_input,
+                args=policy_args,
                 framework="claude_agents",
             )
             
@@ -230,8 +402,23 @@ class ClaudeAgentsAdapter(ToolAdapter):
             if cortex_hub.enforce and cortex_hub.evaluator:
                 from cortexhub.policy.effects import Effect
                 decision = cortex_hub.evaluator.evaluate(request)
+
+                span.add_event(
+                    "policy.decision",
+                    attributes={
+                        "decision.effect": decision.effect.value,
+                        "decision.policy_id": decision.policy_id or "",
+                        "decision.reasoning": decision.reasoning,
+                        "decision.policy_name": decision.policy_name or "",
+                    },
+                )
                 
                 if decision.effect == Effect.DENY:
+                    _finish_tool_span(
+                        span,
+                        success=False,
+                        error_message=decision.reasoning,
+                    )
                     return {
                         "hookSpecificOutput": {
                             "hookEventName": "PreToolUse",
@@ -242,7 +429,7 @@ class ClaudeAgentsAdapter(ToolAdapter):
                 
                 if decision.effect == Effect.ESCALATE:
                     try:
-                        context_hash = cortex_hub._compute_context_hash(tool_name, tool_input)
+                        context_hash = cortex_hub._compute_context_hash(tool_name, policy_args)
                         approval_response = cortex_hub.backend.create_approval(
                             run_id=cortex_hub.session_id,
                             trace_id=cortex_hub._get_current_trace_id(),
@@ -260,6 +447,11 @@ class ClaudeAgentsAdapter(ToolAdapter):
                         approval_id = approval_response.get("approval_id", "unknown")
                     except Exception as e:
                         logger.error("Failed to create approval", error=str(e))
+                        _finish_tool_span(
+                            span,
+                            success=False,
+                            error_message=str(e),
+                        )
                         return {
                             "hookSpecificOutput": {
                                 "hookEventName": "PreToolUse",
@@ -270,6 +462,20 @@ class ClaudeAgentsAdapter(ToolAdapter):
                             }
                         }
 
+                    span.add_event(
+                        "approval.created",
+                        attributes={
+                            "approval_id": approval_id,
+                            "tool_name": tool_name,
+                            "policy_id": decision.policy_id or "",
+                            "expires_at": approval_response.get("expires_at", ""),
+                        },
+                    )
+                    _finish_tool_span(
+                        span,
+                        success=False,
+                        error_message="Approval required",
+                    )
                     return {
                         "hookSpecificOutput": {
                             "hookEventName": "PreToolUse",
@@ -281,6 +487,10 @@ class ClaudeAgentsAdapter(ToolAdapter):
                     }
             
             # Allow execution
+            if tool_use_id:
+                span_store[tool_use_id] = span
+            else:
+                span.end()
             return {}
         
         async def post_tool_governance(
@@ -294,6 +504,21 @@ class ClaudeAgentsAdapter(ToolAdapter):
             """
             tool_name = input_data.get("tool_name", "unknown")
             tool_response = input_data.get("tool_response", {})
+            tool_input = input_data.get("tool_input", {})
+            if not isinstance(tool_input, dict):
+                tool_input = {"_raw": tool_input}
+            policy_args = cortex_hub._sanitize_policy_args(tool_input)
+
+            span = span_store.pop(tool_use_id, None) if tool_use_id else None
+            if span is None:
+                tool_description = f"Claude Agent SDK built-in tool: {tool_name}"
+                span = _start_tool_span(
+                    tool_name=tool_name,
+                    tool_description=tool_description,
+                    policy_args=policy_args,
+                    raw_args=tool_input,
+                    tool_use_id=tool_use_id,
+                )
             
             # Log the tool execution
             logger.debug(
@@ -301,6 +526,8 @@ class ClaudeAgentsAdapter(ToolAdapter):
                 tool=tool_name,
                 framework="claude_agents",
             )
+
+            _finish_tool_span(span, success=True, result=tool_response)
             
             return {}
         

cortexhub/adapters/crewai.py

@@ -28,11 +28,21 @@ logger = structlog.get_logger(__name__)
 # Attribute names for storing originals on class
 _ORIGINAL_INVOKE_ATTR = "__cortexhub_original_invoke__"
 _ORIGINAL_RUN_ATTR = "__cortexhub_original_run__"
+_ORIGINAL_RUN_METHOD_ATTR = "__cortexhub_original_run_method__"
 _PATCHED_ATTR = "__cortexhub_patched__"
 _PATCHED_TOOL_ATTR = "__cortexhub_tool_patched__"
+_PATCHED_RUN_METHOD_ATTR = "__cortexhub_run_method_patched__"
+_ORIGINAL_TOOL_RUN_ATTR = "__cortexhub_original_tool_run__"
+_PATCHED_TOOL_RUN_ATTR = "__cortexhub_tool_run_patched__"
 _PATCHED_LLM_ATTR = "__cortexhub_llm_patched__"
 _ORIGINAL_COMPLETION_ATTR = "__cortexhub_original_completion__"
 _ORIGINAL_ACOMPLETION_ATTR = "__cortexhub_original_acompletion__"
+_ORIGINAL_KICKOFF_ATTR = "__cortexhub_original_kickoff__"
+_ORIGINAL_KICKOFF_ASYNC_ATTR = "__cortexhub_original_kickoff_async__"
+_PATCHED_RUN_ATTR = "__cortexhub_run_patched__"
+_ORIGINAL_LLM_CALL_ATTR = "__cortexhub_original_llm_call__"
+_ORIGINAL_LLM_ACALL_ATTR = "__cortexhub_original_llm_acall__"
+_PATCHED_LLM_CALL_ATTR = "__cortexhub_llm_call_patched__"
 
 
 class CrewAIAdapter(ToolAdapter):
@@ -105,7 +115,7 @@ class CrewAIAdapter(ToolAdapter):
 
             # Also patch BaseTool._run for direct tool.run() calls
             try:
-                from crewai.tools.base_tool import BaseTool
+                from crewai.tools.base_tool import BaseTool, Tool
                 
                 if not getattr(BaseTool, _PATCHED_TOOL_ATTR, False):
                     if not hasattr(BaseTool, _ORIGINAL_RUN_ATTR):
@@ -142,6 +152,76 @@ class CrewAIAdapter(ToolAdapter):
                     BaseTool._run = patched_run
                     setattr(BaseTool, _PATCHED_TOOL_ATTR, True)
                     logger.info("CrewAI BaseTool._run patched")
+
+                if not getattr(BaseTool, _PATCHED_RUN_METHOD_ATTR, False):
+                    if not hasattr(BaseTool, _ORIGINAL_RUN_METHOD_ATTR):
+                        setattr(BaseTool, _ORIGINAL_RUN_METHOD_ATTR, BaseTool.run)
+
+                    original_run_method = getattr(BaseTool, _ORIGINAL_RUN_METHOD_ATTR)
+
+                    def patched_run_method(self, *args, **kwargs):
+                        """Governed BaseTool.run execution."""
+                        tool_name = getattr(self, "name", "unknown_tool")
+                        tool_description = getattr(self, "description", None)
+
+                        tool_metadata = {
+                            "name": tool_name,
+                            "description": tool_description,
+                            "framework": "crewai",
+                        }
+
+                        governed_fn = govern_execution(
+                            tool_fn=lambda **_kw: original_run_method(self, *args, **kwargs),
+                            tool_metadata=tool_metadata,
+                            cortex_hub=cortex_hub,
+                        )
+
+                        if kwargs:
+                            return governed_fn(**kwargs)
+                        if len(args) == 1 and isinstance(args[0], dict):
+                            return governed_fn(**args[0])
+                        if args:
+                            return governed_fn(_raw=args[0])
+                        return governed_fn()
+
+                    BaseTool.run = patched_run_method
+                    setattr(BaseTool, _PATCHED_RUN_METHOD_ATTR, True)
+                    logger.info("CrewAI BaseTool.run patched")
+
+                if not getattr(Tool, _PATCHED_TOOL_RUN_ATTR, False):
+                    if not hasattr(Tool, _ORIGINAL_TOOL_RUN_ATTR):
+                        setattr(Tool, _ORIGINAL_TOOL_RUN_ATTR, Tool.run)
+
+                    original_tool_run = getattr(Tool, _ORIGINAL_TOOL_RUN_ATTR)
+
+                    def patched_tool_run(self, *args, **kwargs):
+                        """Governed Tool.run execution (bypasses BaseTool.run)."""
+                        tool_name = getattr(self, "name", "unknown_tool")
+                        tool_description = getattr(self, "description", None)
+
+                        tool_metadata = {
+                            "name": tool_name,
+                            "description": tool_description,
+                            "framework": "crewai",
+                        }
+
+                        governed_fn = govern_execution(
+                            tool_fn=lambda **_kw: original_tool_run(self, *args, **kwargs),
+                            tool_metadata=tool_metadata,
+                            cortex_hub=cortex_hub,
+                        )
+
+                        if kwargs:
+                            return governed_fn(**kwargs)
+                        if len(args) == 1 and isinstance(args[0], dict):
+                            return governed_fn(**args[0])
+                        if args:
+                            return governed_fn(_raw=args[0])
+                        return governed_fn()
+
+                    Tool.run = patched_tool_run
+                    setattr(Tool, _PATCHED_TOOL_RUN_ATTR, True)
+                    logger.info("CrewAI Tool.run patched")
                     
             except ImportError:
                 logger.debug("CrewAI BaseTool not available")
@@ -150,6 +230,8 @@ class CrewAIAdapter(ToolAdapter):
             
             # Patch LiteLLM for LLM call governance (guardrails, PII)
             self._patch_litellm(cortex_hub)
+            self._patch_llm_call(cortex_hub)
+            self._patch_run_completion(cortex_hub)
 
         except ImportError:
             logger.debug("CrewAI not available, skipping adapter")
@@ -251,6 +333,183 @@ class CrewAIAdapter(ToolAdapter):
         except Exception as e:
             logger.debug("CrewAI LiteLLM interception skipped", reason=str(e))
 
+    def _patch_llm_call(self, cortex_hub) -> None:
+        """Patch CrewAI LLM provider call methods for llm.call spans."""
+        try:
+            from crewai.llms.base_llm import BaseLLM
+            provider_modules = [
+                "crewai.llms.providers.openai.completion",
+                "crewai.llms.providers.anthropic.completion",
+                "crewai.llms.providers.azure.completion",
+                "crewai.llms.providers.gemini.completion",
+                "crewai.llms.providers.bedrock.completion",
+            ]
+            for module_path in provider_modules:
+                try:
+                    __import__(module_path)
+                except Exception:
+                    continue
+
+            def _all_subclasses(base):
+                seen = set()
+                stack = list(base.__subclasses__())
+                while stack:
+                    cls = stack.pop()
+                    if cls in seen:
+                        continue
+                    seen.add(cls)
+                    stack.extend(cls.__subclasses__())
+                    yield cls
+
+            patched_any = False
+            for llm_cls in _all_subclasses(BaseLLM):
+                if getattr(llm_cls, _PATCHED_LLM_CALL_ATTR, False):
+                    continue
+
+                if hasattr(llm_cls, "call"):
+                    if not hasattr(llm_cls, _ORIGINAL_LLM_CALL_ATTR):
+                        setattr(llm_cls, _ORIGINAL_LLM_CALL_ATTR, llm_cls.call)
+                    original_call = getattr(llm_cls, _ORIGINAL_LLM_CALL_ATTR)
+
+                    def _make_patched_call(call_impl):
+                        def patched_call(self, messages, *args, **kwargs):
+                            if getattr(self, "is_litellm", False):
+                                return call_impl(self, messages, *args, **kwargs)
+
+                            model = getattr(self, "model", "unknown")
+                            prompt = messages
+
+                            def call_original(prompt_override):
+                                new_messages = (
+                                    prompt_override if prompt_override is not None else messages
+                                )
+                                return call_impl(self, new_messages, *args, **kwargs)
+
+                            llm_metadata = {
+                                "kind": "llm",
+                                "framework": "crewai",
+                                "model": model,
+                                "prompt": prompt,
+                                "call_original": call_original,
+                            }
+
+                            governed = govern_execution(
+                                tool_fn=lambda *a, **kw: call_impl(
+                                    self, messages, *args, **kwargs
+                                ),
+                                tool_metadata=llm_metadata,
+                                cortex_hub=cortex_hub,
+                            )
+                            return governed()
+
+                        return patched_call
+
+                    llm_cls.call = _make_patched_call(original_call)
+                    patched_any = True
+
+                if hasattr(llm_cls, "acall"):
+                    if not hasattr(llm_cls, _ORIGINAL_LLM_ACALL_ATTR):
+                        setattr(llm_cls, _ORIGINAL_LLM_ACALL_ATTR, llm_cls.acall)
+                    original_acall = getattr(llm_cls, _ORIGINAL_LLM_ACALL_ATTR)
+
+                    def _make_patched_acall(call_impl):
+                        async def patched_acall(self, messages, *args, **kwargs):
+                            if getattr(self, "is_litellm", False):
+                                return await call_impl(self, messages, *args, **kwargs)
+
+                            model = getattr(self, "model", "unknown")
+                            prompt = messages
+
+                            async def call_original(prompt_override):
+                                new_messages = (
+                                    prompt_override if prompt_override is not None else messages
+                                )
+                                return await call_impl(self, new_messages, *args, **kwargs)
+
+                            llm_metadata = {
+                                "kind": "llm",
+                                "framework": "crewai",
+                                "model": model,
+                                "prompt": prompt,
+                                "call_original": call_original,
+                            }
+
+                            governed = govern_execution(
+                                tool_fn=lambda *a, **kw: call_impl(
+                                    self, messages, *args, **kwargs
+                                ),
+                                tool_metadata=llm_metadata,
+                                cortex_hub=cortex_hub,
+                            )
+                            return await governed()
+
+                        return patched_acall
+
+                    llm_cls.acall = _make_patched_acall(original_acall)
+                    patched_any = True
+
+                setattr(llm_cls, _PATCHED_LLM_CALL_ATTR, True)
+
+            if patched_any:
+                logger.info("CrewAI LLM provider calls patched successfully")
+        except ImportError:
+            logger.debug("CrewAI LLM base not available, skipping LLM call patch")
+        except Exception as e:
+            logger.debug("CrewAI LLM call patch skipped", reason=str(e))
+
+    def _patch_run_completion(self, cortex_hub) -> None:
+        """Patch CrewAI crew kickoff methods to emit run completion."""
+        try:
+            import crewai
+            Crew = getattr(crewai, "Crew", None)
+            if Crew is None:
+                from crewai.crew import Crew
+
+            if getattr(Crew, _PATCHED_RUN_ATTR, False):
+                return
+
+            if not hasattr(Crew, _ORIGINAL_KICKOFF_ATTR):
+                setattr(Crew, _ORIGINAL_KICKOFF_ATTR, Crew.kickoff)
+            original_kickoff = getattr(Crew, _ORIGINAL_KICKOFF_ATTR)
+
+            def patched_kickoff(self, *args, **kwargs):
+                status = "completed"
+                cortex_hub.start_run(framework="crewai")
+                try:
+                    return original_kickoff(self, *args, **kwargs)
+                except Exception:
+                    status = "failed"
+                    raise
+                finally:
+                    cortex_hub.finish_run(framework="crewai", status=status)
+
+            Crew.kickoff = patched_kickoff
+
+            if hasattr(Crew, "kickoff_async"):
+                if not hasattr(Crew, _ORIGINAL_KICKOFF_ASYNC_ATTR):
+                    setattr(Crew, _ORIGINAL_KICKOFF_ASYNC_ATTR, Crew.kickoff_async)
+                original_kickoff_async = getattr(Crew, _ORIGINAL_KICKOFF_ASYNC_ATTR)
+
+                async def patched_kickoff_async(self, *args, **kwargs):
+                    status = "completed"
+                    cortex_hub.start_run(framework="crewai")
+                    try:
+                        return await original_kickoff_async(self, *args, **kwargs)
+                    except Exception:
+                        status = "failed"
+                        raise
+                    finally:
+                        cortex_hub.finish_run(framework="crewai", status=status)
+
+                Crew.kickoff_async = patched_kickoff_async
+
+            setattr(Crew, _PATCHED_RUN_ATTR, True)
+            logger.info("CrewAI run completion patched successfully")
+        except ImportError:
+            logger.debug("CrewAI run completion patch skipped")
+        except Exception as e:
+            logger.debug("CrewAI run completion patch failed", reason=str(e))
+
     def unpatch(self) -> None:
         """Restore original CrewAI methods."""
         try:
@@ -284,6 +543,21 @@ class CrewAIAdapter(ToolAdapter):
                 logger.info("CrewAI LiteLLM unpatched")
             except ImportError:
                 pass
+
+            # Restore run completion patches
+            try:
+                import crewai
+                Crew = getattr(crewai, "Crew", None)
+                if Crew is None:
+                    from crewai.crew import Crew
+
+                if hasattr(Crew, _ORIGINAL_KICKOFF_ATTR):
+                    Crew.kickoff = getattr(Crew, _ORIGINAL_KICKOFF_ATTR)
+                if hasattr(Crew, _ORIGINAL_KICKOFF_ASYNC_ATTR):
+                    Crew.kickoff_async = getattr(Crew, _ORIGINAL_KICKOFF_ASYNC_ATTR)
+                setattr(Crew, _PATCHED_RUN_ATTR, False)
+            except ImportError:
+                pass
                 
         except ImportError:
             pass