copilotkit 0.1.44__py3-none-any.whl → 0.2.0a0__py3-none-any.whl

copilotkit/crewai/__init__.py

@@ -12,6 +12,11 @@ from .crewai_sdk import (
     copilotkit_exit,
     copilotkit_predict_state,
 )
+from .utils import (
+    create_copilotkit_tool_handlers, 
+    check_for_intercepted_actions,
+    COPILOTKIT_ACTION_INTERCEPTED_MARKER
+)
 __all__ = [
     "CrewAIAgent",
     "CopilotKitProperties",
@@ -22,4 +27,7 @@ __all__ = [
     "copilotkit_stream",
     "copilotkit_exit",
     "copilotkit_predict_state",
+    "create_copilotkit_tool_handlers",
+    "check_for_intercepted_actions",
+    "COPILOTKIT_ACTION_INTERCEPTED_MARKER",
 ]

copilotkit/crewai/crewai_agent.py

@@ -5,9 +5,9 @@ CrewAI Agent
 import uuid
 import json
 from copy import deepcopy
-from pydantic import BaseModel
 from typing import Optional, List, Callable
 from typing_extensions import TypedDict, NotRequired, Any, Dict, cast
+from pydantic import BaseModel
 from crewai import Crew, Flow
 from crewai.flow import start
 from crewai.cli.crew_chat import (
@@ -25,7 +25,7 @@ from copilotkit.protocol import (
   emit_runtime_events,
   agent_state_message,
 )
-from .crewai_sdk import (
+from copilotkit.crewai.crewai_sdk import (
   copilotkit_messages_to_crewai_flow,
   crewai_flow_messages_to_copilotkit,
   crewai_flow_async_runner,

copilotkit/crewai/crewai_event_listener.py

@@ -0,0 +1,242 @@
+"""
+CrewAI Event Listener
+"""
+import asyncio
+import uuid
+import contextvars
+import inspect
+import json
+import logging
+import threading
+import types
+from typing import Any, Dict, List, Optional, Tuple, Union, cast, TypedDict
+
+# Import from our centralized imports module
+from copilotkit.crewai.imports import (
+    BaseEventListener,
+    FlowStartedEvent,
+    MethodExecutionStartedEvent,
+    MethodExecutionFinishedEvent,
+    FlowFinishedEvent,
+    LLMCallStartedEvent,
+    LLMCallCompletedEvent,
+    LLMCallFailedEvent,
+    LLMStreamChunkEvent,
+    ToolUsageStartedEvent,
+    ToolUsageFinishedEvent,
+    ToolUsageErrorEvent,
+)
+from copilotkit.runloop import queue_put
+from copilotkit.protocol import (
+    RuntimeEventTypes,
+    RunStarted,
+    RunFinished,
+    NodeStarted,
+    NodeFinished,
+    TextMessageStart,
+    TextMessageContent,
+)
+
+class LocalExecutionContext(TypedDict):
+    """
+    Local execution context
+    """
+    current_message_id: Optional[str]
+    current_tool_call_id: Optional[str]
+
+
+_id_to_execution_context = {}
+
+class CopilotKitCrewAIEventListener(BaseEventListener):
+    """
+    CopilotKit CrewAI Event Listener
+    """
+
+    def _get_execution_context(self, flow_id: int) -> LocalExecutionContext:
+        """
+        Get the execution context for a given ID
+        """
+        return _id_to_execution_context[flow_id]
+
+    def _set_execution_context(self, flow_id: int, execution_context: LocalExecutionContext):
+        """
+        Set the execution context for a given ID
+        """
+        _id_to_execution_context[flow_id] = execution_context
+
+    def _delete_execution_context(self, flow_id: int):
+        """
+        Delete the execution context for a given ID
+        """
+        del _id_to_execution_context[flow_id]
+
+    # Flow lifecycle events
+
+    async def aon_flow_started(self, source, event): # pylint: disable=unused-argument
+        """
+        Handle a flow started event
+        """
+        self._set_execution_context(id(source), LocalExecutionContext(
+            current_message_id=None,
+            current_tool_call_id=None
+        ))
+        await queue_put(RunStarted(
+                type=RuntimeEventTypes.RUN_STARTED,
+                state=source.state
+            ), priority=True)
+
+    async def aon_method_execution_started(self, source, event):
+        """
+        Handle a method execution started event
+        """
+        await queue_put(NodeStarted(
+                type=RuntimeEventTypes.NODE_STARTED,
+                node_name=event.method_name,
+                state=source.state
+            ), priority=True)
+
+    async def aon_method_execution_finished(self, source, event):
+        """
+        Handle a method execution finished event
+        """
+        await queue_put(NodeFinished(
+                type=RuntimeEventTypes.NODE_FINISHED,
+                node_name=event.method_name,
+                state=source.state
+            ), priority=True)
+
+    async def aon_flow_finished(self, source, event): # pylint: disable=unused-argument
+        """
+        Handle a flow finished event
+        """
+        self._delete_execution_context(id(source))
+        await queue_put(RunFinished(
+                type=RuntimeEventTypes.RUN_FINISHED,
+                state=source.state
+            ), priority=True)
+
+    # LLM call events
+
+    async def aon_llm_call_started(self, source, event): # pylint: disable=unused-argument
+        """
+        Handle an LLM call started event
+        """
+        message_id = str(uuid.uuid4())
+        self._set_execution_context(id(source), LocalExecutionContext(
+            current_message_id=message_id,
+            current_tool_call_id=None
+        ))
+
+    async def aon_llm_call_completed(self, source, event): # pylint: disable=unused-argument
+        """
+        Handle an LLM call completed event
+        """
+        self._set_execution_context(id(source), LocalExecutionContext(
+            current_message_id=None,
+            current_tool_call_id=None
+        ))
+
+    async def aon_llm_call_failed(self, source, event): # pylint: disable=unused-argument
+        """
+        Handle an LLM call failed event
+        """
+        self._set_execution_context(id(source), LocalExecutionContext(
+            current_message_id=None,
+            current_tool_call_id=None
+        ))
+
+    async def aon_llm_stream_chunk(self, source, event):
+        """
+        Handle an LLM stream chunk event
+        """
+        execution_context = self._get_execution_context(id(source))
+        if execution_context["current_message_id"] is None:
+            return
+        print(TextMessageContent(
+            type=RuntimeEventTypes.TEXT_MESSAGE_CONTENT,
+            messageId=execution_context["current_message_id"],
+            content=event.chunk
+        ), flush=True)
+
+    def setup_listeners(self, crewai_event_bus):
+        """
+        Setup listeners for CrewAI events
+        """
+        @crewai_event_bus.on(FlowStartedEvent)
+        def on_flow_started(source, event):
+            asyncio.get_running_loop().create_task(self.aon_flow_started(source, event))
+
+        @crewai_event_bus.on(MethodExecutionStartedEvent)
+        def on_method_execution_started(source, event):
+            asyncio.get_running_loop().create_task(self.aon_method_execution_started(source, event))
+
+        @crewai_event_bus.on(MethodExecutionFinishedEvent)
+        def on_method_execution_finished(source, event):
+            asyncio.get_running_loop().create_task(
+                self.aon_method_execution_finished(source, event)
+            )
+
+        @crewai_event_bus.on(FlowFinishedEvent)
+        def on_flow_finished(source, event):
+            asyncio.get_running_loop().create_task(self.aon_flow_finished(source, event))
+
+        @crewai_event_bus.on(LLMCallStartedEvent)
+        def on_llm_call_started(source, event):
+            asyncio.get_running_loop().create_task(self.aon_llm_call_started(source, event))
+
+        @crewai_event_bus.on(LLMCallCompletedEvent)
+        def on_llm_call_completed(source, event):
+            asyncio.get_running_loop().create_task(self.aon_llm_call_completed(source, event))
+
+        @crewai_event_bus.on(LLMCallFailedEvent)
+        def on_llm_call_failed(source, event):
+            asyncio.get_running_loop().create_task(self.aon_llm_call_failed(source, event))
+
+        @crewai_event_bus.on(LLMStreamChunkEvent)
+        def on_llm_stream_chunk(source, event):
+            asyncio.get_running_loop().create_task(self.aon_llm_stream_chunk(source, event))
+
+        @crewai_event_bus.on(ToolUsageStartedEvent)
+        def on_tool_usage_started(source, event: ToolUsageStartedEvent):
+            asyncio.get_running_loop().create_task(self.on_tool_usage_started(event))
+
+        @crewai_event_bus.on(ToolUsageFinishedEvent)
+        def on_tool_usage_finished(source, event: ToolUsageFinishedEvent):
+            asyncio.get_running_loop().create_task(self.on_tool_usage_finished(event))
+
+        @crewai_event_bus.on(ToolUsageErrorEvent)
+        def on_tool_usage_error(source, event: ToolUsageErrorEvent):
+            asyncio.get_running_loop().create_task(self.on_tool_usage_error(event))
+
+    async def on_tool_usage_started(self, event: ToolUsageStartedEvent):
+        """CrewAI's on_tool_usage_started event."""
+        # Create a proper LocalExecutionContext
+        execution_context = LocalExecutionContext(
+            current_message_id=None,  # Not using message ID for tools
+            current_tool_call_id=str(uuid.uuid4()) if hasattr(event, "run_id") else None
+        )
+        
+        # Store the event in the execution context
+        self._set_execution_context(event.source_id, execution_context)
+
+    async def on_tool_usage_finished(self, event: ToolUsageFinishedEvent):
+        """CrewAI's on_tool_usage_finished event."""
+        # Create a proper LocalExecutionContext
+        execution_context = LocalExecutionContext(
+            current_message_id=None,  # Not using message ID for tools
+            current_tool_call_id=None  # Tool call is finished
+        )
+        
+        # Store the event in the execution context
+        self._set_execution_context(event.source_id, execution_context)
+
+    async def on_tool_usage_error(self, event: ToolUsageErrorEvent):
+        """CrewAI's on_tool_usage_error event."""
+        # Create a proper LocalExecutionContext
+        execution_context = LocalExecutionContext(
+            current_message_id=None,  # Not using message ID for tools
+            current_tool_call_id=None  # Tool call has errored
+        )
+        
+        # Store the event in the execution context
+        self._set_execution_context(event.source_id, execution_context)

copilotkit/crewai/crewai_sdk.py

@@ -2,10 +2,13 @@
 CrewAI integration for CopilotKit
 """
 
+# new event listener docs
+# https://github.com/crewAIInc/crewAI/blob/main/docs/concepts/event-listener.mdx
+
+# 
 import uuid
 import json
-import asyncio
-from typing_extensions import Any, Dict, List, Literal
+from typing_extensions import Any, Dict, List, Literal, Optional
 from pydantic import BaseModel, Field
 from litellm.types.utils import (
   ModelResponse,
@@ -16,23 +19,12 @@ from litellm.types.utils import (
 )
 from litellm.litellm_core_utils.streaming_handler import CustomStreamWrapper
 from crewai.flow.flow import FlowState, Flow
-from crewai.flow.flow_events import (
-  Event as CrewAIFlowEvent,
-  FlowStartedEvent,
-  MethodExecutionStartedEvent,
-  MethodExecutionFinishedEvent,
-  FlowFinishedEvent,
-)
 from copilotkit.types import Message
 from copilotkit.logging import get_logger
 from copilotkit.runloop import queue_put, get_context_execution
 from copilotkit.protocol import (
     RuntimeEventTypes,
-    RunStarted,
-    RunFinished,
     RunError,
-    NodeStarted,
-    NodeFinished,
     agent_state_message,
     text_message_start,
     text_message_content,
@@ -44,12 +36,40 @@ from copilotkit.protocol import (
     RuntimeMetaEventName,
     PredictStateConfig
 )
+from copilotkit.crewai.crewai_event_listener import CopilotKitCrewAIEventListener
 
 logger = get_logger(__name__)
 
+copilotkit_crewai_event_listener =  CopilotKitCrewAIEventListener()
+
+
 class CopilotKitProperties(BaseModel):
-    """CopilotKit properties"""
-    actions: List[Any] = Field(default_factory=list)
+    """
+    CopilotKit properties for the state
+    """
+    actions: List[Dict[str, Any]] = []
+
+    # Properties for tool call interception
+    _intercepted_action: bool = False
+    _last_intercepted_action_name: Optional[str] = None
+    _last_intercepted_action_args: Optional[Dict[str, Any]] = None
+    
+    # Allow arbitrary properties
+    model_config = {
+        "extra": "allow",
+        "arbitrary_types_allowed": True
+    }
+    
+    def __setattr__(self, name, value):
+        """
+        Custom __setattr__ to handle dynamic properties even in strict Pydantic mode
+        """
+        try:
+            # Try standard setattr first
+            super().__setattr__(name, value)
+        except Exception:
+            # If that fails, store it in __dict__ directly
+            object.__setattr__(self, name, value)
 
 class CopilotKitState(FlowState):
     """CopilotKit state"""
@@ -62,47 +82,48 @@ async def crewai_flow_async_runner(flow: Flow, inputs: Dict[str, Any]):
     asyncio.run().
     """
 
-    async def crewai_flow_event_subscriber(flow: Any, event: CrewAIFlowEvent):
-        if isinstance(event, FlowStartedEvent):
-            await queue_put(RunStarted(
-                type=RuntimeEventTypes.RUN_STARTED,
-                state=flow.state
-            ), priority=True)
-        elif isinstance(event, MethodExecutionStartedEvent):
-            await queue_put(NodeStarted(
-                type=RuntimeEventTypes.NODE_STARTED,
-                node_name=event.method_name,
-                state=flow.state
-            ), priority=True)
-        elif isinstance(event, MethodExecutionFinishedEvent):
-            await queue_put(NodeFinished(
-                type=RuntimeEventTypes.NODE_FINISHED,
-                node_name=event.method_name,
-                state=flow.state
-            ), priority=True)
-        elif isinstance(event, FlowFinishedEvent):
-            await queue_put(RunFinished(
-                type=RuntimeEventTypes.RUN_FINISHED,
-                state=flow.state
-            ), priority=True)
-
-    def crewai_flow_event_subscriber_sync(flow: Any, event: CrewAIFlowEvent):
-        loop = asyncio.get_running_loop()
-        loop.call_soon(lambda: asyncio.create_task(crewai_flow_event_subscriber(flow, event)))
-
-    flow.event_emitter.connect(crewai_flow_event_subscriber_sync)
+    # Note: In CrewAI 0.114.0+, these events are in utilities.events
+    # async def crewai_flow_event_subscriber(flow: Any, event: CrewAIFlowEvent):
+    #     if isinstance(event, FlowStartedEvent):
+    #         await queue_put(RunStarted(
+    #             type=RuntimeEventTypes.RUN_STARTED,
+    #             state=flow.state
+    #         ), priority=True)
+    #     elif isinstance(event, MethodExecutionStartedEvent):
+    #         await queue_put(NodeStarted(
+    #             type=RuntimeEventTypes.NODE_STARTED,
+    #             node_name=event.method_name,
+    #             state=flow.state
+    #         ), priority=True)
+    #     elif isinstance(event, MethodExecutionFinishedEvent):
+    #         await queue_put(NodeFinished(
+    #             type=RuntimeEventTypes.NODE_FINISHED,
+    #             node_name=event.method_name,
+    #             state=flow.state
+    #         ), priority=True)
+    #     elif isinstance(event, FlowFinishedEvent):
+    #         await queue_put(RunFinished(
+    #             type=RuntimeEventTypes.RUN_FINISHED,
+    #             state=flow.state
+    #         ), priority=True)
+
+    # def crewai_flow_event_subscriber_sync(flow: Any, event: CrewAIFlowEvent):
+    #     loop = asyncio.get_running_loop()
+    #     loop.call_soon(lambda: asyncio.create_task(crewai_flow_event_subscriber(flow, event)))
+
+    # flow.event_emitter.connect(crewai_flow_event_subscriber_sync)
 
     try:
-        flow.event_emitter.send(
-            flow,
-            event=FlowStartedEvent(
-                type="flow_started",
-                flow_name=flow.__class__.__name__,
-            ),
-        )
-
-        flow._initialize_state(inputs) # pylint: disable=protected-access
-        await flow.kickoff_async()
+        # flow.event_emitter.send(
+        #     flow,
+        #     event=FlowStartedEvent(
+        #         type="flow_started",
+        #         flow_name=flow.__class__.__name__,
+        #     ),
+        # )
+
+        # flow._initialize_state(inputs) # pylint: disable=protected-access
+        await flow.kickoff_async(inputs=inputs)
     except Exception as e: # pylint: disable=broad-except
         await queue_put(RunError(
             type=RuntimeEventTypes.RUN_ERROR,

copilotkit/crewai/imports.py

@@ -0,0 +1,130 @@
+"""
+Centralized imports for CrewAI integration.
+
+This module handles importing from different versions of CrewAI to maintain backward compatibility.
+"""
+from typing import Any, Dict, Optional, Union
+import importlib.util
+
+# First check if the tool_usage_events module exists
+tool_usage_events_spec = importlib.util.find_spec("crewai.tools.tool_usage_events")
+has_tool_usage_events = tool_usage_events_spec is not None
+
+# Try to import from the new locations first (crewai 0.114.0+)
+try:
+    # Check if the new events module exists
+    from crewai.events import (
+        BaseEventListener,
+        FlowStartedEvent,
+        MethodExecutionStartedEvent,
+        MethodExecutionFinishedEvent,
+        FlowFinishedEvent,
+        LLMCallStartedEvent,
+        LLMCallCompletedEvent,
+        LLMCallFailedEvent,
+        LLMStreamChunkEvent,
+    )
+    
+    # Import tool events from appropriate location
+    if has_tool_usage_events:
+        from crewai.tools.tool_usage_events import (
+            ToolUsageStartedEvent,
+            ToolUsageFinishedEvent,
+            ToolUsageErrorEvent,
+        )
+    else:
+        # Try to get them from the same module
+        from crewai.events import (
+            ToolUsageStartedEvent,
+            ToolUsageFinishedEvent,
+            ToolUsageErrorEvent,
+        )
+# Fall back to older import locations (pre-0.114.0)
+except ImportError:
+    try:
+        from crewai.utilities.events import (
+            BaseEventListener,
+            FlowStartedEvent,
+            MethodExecutionStartedEvent,
+            MethodExecutionFinishedEvent,
+            FlowFinishedEvent,
+            LLMCallStartedEvent,
+            LLMCallCompletedEvent,
+            LLMCallFailedEvent,
+            LLMStreamChunkEvent,
+        )
+        
+        # Also try to get tool events from the same module
+        from crewai.utilities.events import (
+            ToolUsageStartedEvent,
+            ToolUsageFinishedEvent, 
+            ToolUsageErrorEvent,
+        )
+    except ImportError:
+        # Define stub classes for environments without CrewAI
+        class BaseEventStub:
+            pass
+            
+        class BaseEventListener(BaseEventStub):
+            async def aon_flow_started(self, event):
+                pass
+            
+            async def aon_method_execution_started(self, event):
+                pass
+                
+            async def aon_method_execution_finished(self, event):
+                pass
+                
+            async def aon_flow_finished(self, event):
+                pass
+                
+            async def aon_llm_call_started(self, event):
+                pass
+                
+            async def aon_llm_call_completed(self, event):
+                pass
+                
+            async def aon_llm_call_failed(self, event):
+                pass
+                
+            async def aon_llm_stream_chunk(self, event):
+                pass
+        
+        # Define stub event classes
+        class EventStub(BaseEventStub):
+            def __init__(self, **kwargs):
+                for key, value in kwargs.items():
+                    setattr(self, key, value)
+        
+        class FlowStartedEvent(EventStub):
+            pass
+            
+        class MethodExecutionStartedEvent(EventStub):
+            pass
+            
+        class MethodExecutionFinishedEvent(EventStub):
+            pass
+            
+        class FlowFinishedEvent(EventStub):
+            pass
+            
+        class LLMCallStartedEvent(EventStub):
+            pass
+            
+        class LLMCallCompletedEvent(EventStub):
+            pass
+            
+        class LLMCallFailedEvent(EventStub):
+            pass
+            
+        class LLMStreamChunkEvent(EventStub):
+            pass
+            
+        class ToolUsageStartedEvent(EventStub):
+            pass
+            
+        class ToolUsageFinishedEvent(EventStub):
+            pass
+            
+        class ToolUsageErrorEvent(EventStub):
+            pass 

copilotkit/crewai/utils.py

@@ -0,0 +1,166 @@
+"""
+Utilities for integrating CopilotKit with CrewAI
+"""
+from typing import Dict, List, Any, Callable
+import uuid
+import json
+import logging
+
+# Setup logger
+logger = logging.getLogger("copilotkit.crewai.utils")
+
+# Global variable to track interception when state modification fails
+_COPILOTKIT_INTERCEPTED_ACTION = None
+
+# Constants
+COPILOTKIT_ACTION_INTERCEPTED_MARKER = "[[COPILOTKIT_ACTION_INTERCEPTED]]"
+
+
+def create_copilotkit_tool_handlers(
+    original_handlers: Dict[str, Callable], 
+    copilotkit_actions: List[Dict[str, Any]], 
+    state: Any
+) -> Dict[str, Callable]:
+    """
+    Creates a wrapper around tool handlers that intercepts CopilotKit actions.
+    
+    Args:
+        original_handlers: Dict of original tool handler functions
+        copilotkit_actions: List of CopilotKit action definitions
+        state: The flow state object where flagging will occur
+        
+    Returns:
+        Dict of wrapped tool handler functions
+    """
+    # Extract action names from CopilotKit actions
+    copilotkit_action_names = [
+        action["function"]["name"] 
+        for action in copilotkit_actions
+    ]
+    
+    # Store action definitions by name for parameter validation
+    action_definitions = {}
+    for action in copilotkit_actions:
+        action_name = action["function"]["name"]
+        action_definitions[action_name] = action
+    
+    logger.debug(f"Setting up interceptors for actions: {copilotkit_action_names}")
+    
+    def interceptor(name):
+        def handle_tool_call(**args):
+            global _COPILOTKIT_INTERCEPTED_ACTION
+            
+            if name in copilotkit_action_names:
+                logger.debug(f"Intercepting call to action: {name}")
+                
+                # Check for required parameters
+                if name in action_definitions:
+                    action_def = action_definitions[name]
+                    missing_required_params = []
+                    
+                    # Extract required parameters from action definition
+                    if "parameters" in action_def["function"]:
+                        parameters = action_def["function"]["parameters"]
+                        if "properties" in parameters:
+                            for param_name, param_props in parameters["properties"].items():
+                                # Check if parameter is required
+                                is_required = False
+                                if "required" in parameters and param_name in parameters["required"]:
+                                    is_required = True
+                                
+                                # Check if required parameter is missing
+                                if is_required and (param_name not in args or args[param_name] is None):
+                                    missing_required_params.append(param_name)
+                    
+                    # If required parameters are missing, return a message asking for them
+                    if missing_required_params:
+                        logger.debug(f"Missing required parameters: {missing_required_params}")
+                        missing_params_str = ", ".join(missing_required_params)
+                        return f"I need the following information before I can proceed: {missing_params_str}. Can you please provide these details?"
+                
+                # 1. Always set the global variable first for maximum reliability
+                _COPILOTKIT_INTERCEPTED_ACTION = {
+                    "intercepted": True,
+                    "name": name,
+                    "args": args
+                }
+                
+                # 2. Try to store it in the state as well for redundancy
+                try:
+                    # Try to store it directly in the copilotkit namespace
+                    if hasattr(state.copilotkit, "__dict__"):
+                        state.copilotkit.__dict__["_intercepted_action"] = True
+                        state.copilotkit.__dict__["_last_intercepted_action_name"] = name
+                        state.copilotkit.__dict__["_last_intercepted_action_args"] = args
+                except Exception as e:
+                    logger.debug(f"Failed to store intercepted state in copilotkit: {e}")
+                
+                # 3. Create a proper tool_call object and add it to the next message
+                try:
+                    # Generate a unique ID for the tool call
+                    tool_call_id = str(uuid.uuid4())
+                    
+                    # Create a properly formatted tool call object
+                    tool_call = {
+                        "id": tool_call_id,
+                        "type": "function",
+                        "function": {
+                            "name": name,
+                            "arguments": json.dumps(args)
+                        }
+                    }
+                    
+                    # Store this tool call in state for the next message
+                    if hasattr(state, "_next_message_tool_calls"):
+                        state._next_message_tool_calls.append(tool_call)
+                    else:
+                        setattr(state, "_next_message_tool_calls", [tool_call])
+                except Exception as e:
+                    logger.debug(f"Failed to create tool call: {e}")
+                
+                # Return a special marker string that LLM response handling can detect
+                # This should be a valid non-empty string so the LLM response processor doesn't break
+                # but it should be replaced in the final message to the user
+                return COPILOTKIT_ACTION_INTERCEPTED_MARKER
+            
+            # Otherwise, call the original handler
+            if name in original_handlers:
+                return original_handlers[name](**args)
+            
+            # Fallback if handler not found
+            return f"No handler found for tool '{name}'"
+        
+        return handle_tool_call
+    
+    # Create a wrapped handler for each original handler
+    return {name: interceptor(name) for name in set(list(original_handlers.keys()) + copilotkit_action_names)}
+
+
+def check_for_intercepted_actions(state: Any) -> bool:
+    """
+    Checks if a CopilotKit action was intercepted during the last LLM call.
+    If so, clears the flag and returns True.
+    
+    Args:
+        state: The flow state object
+        
+    Returns:
+        bool: True if a CopilotKit action was intercepted
+    """
+    global _COPILOTKIT_INTERCEPTED_ACTION
+    
+    # First try the copilotkit namespace approach
+    try:
+        if hasattr(state.copilotkit, "_intercepted_action") and state.copilotkit._intercepted_action:
+            # Clear the flag but keep the action details
+            state.copilotkit._intercepted_action = False
+            return True
+    except Exception:
+        pass
+        
+    # Then try the global variable approach
+    if _COPILOTKIT_INTERCEPTED_ACTION and _COPILOTKIT_INTERCEPTED_ACTION.get("intercepted", False):
+        _COPILOTKIT_INTERCEPTED_ACTION["intercepted"] = False
+        return True
+        
+    return False 

copilotkit-0.2.0a0.dist-info/METADATA

@@ -0,0 +1,219 @@
+Metadata-Version: 2.3
+Name: copilotkit
+Version: 0.2.0a0
+Summary: CopilotKit python SDK
+License: MIT
+Keywords: copilot,copilotkit,langgraph,langchain,ai,langsmith,langserve
+Author: Markus Ecker
+Author-email: markus.ecker@gmail.com
+Requires-Python: >=3.10,<3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Provides-Extra: crewai
+Requires-Dist: crewai (==0.114.0) ; extra == "crewai"
+Requires-Dist: fastapi (>=0.115.0,<0.116.0)
+Requires-Dist: langchain (>=0.3.3,<0.4.0)
+Requires-Dist: langgraph (>=0.2.50)
+Requires-Dist: partialjson (>=0.0.8,<0.0.9)
+Requires-Dist: toml (>=0.10.2,<0.11.0)
+Project-URL: Homepage, https://copilotkit.ai
+Project-URL: Repository, https://github.com/CopilotKit/CopilotKit/tree/main/sdk-python
+Description-Content-Type: text/markdown
+
+# CopilotKit Python SDK
+
+[![PyPI version](https://badge.fury.io/py/copilotkit.svg)](https://badge.fury.io/py/copilotkit)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+The official Python SDK for CopilotKit - build AI copilots and agents into your applications.
+
+## Features
+
+- 🚀 Integration with LangGraph and LangChain
+- 🔄 Support for stateful conversations
+- 🔌 FastAPI integration for serving endpoints
+- 🤝 Optional CrewAI integration (requires CrewAI 0.114.0+)
+
+## Version 0.2.0 Breaking Changes
+
+⚠️ As of version 0.2.0, CopilotKit Python SDK now requires CrewAI 0.114.0 or higher.
+If you're using CrewAI with CopilotKit, you must update your CrewAI version.
+
+## Installation
+
+```bash
+pip install copilotkit
+```
+
+With CrewAI support:
+
+```bash
+pip install "copilotkit[crewai]"
+```
+
+## Quick Start
+
+```python
+from copilotkit import CopilotKitRemoteEndpoint, Action
+from copilotkit.integrations.fastapi import add_fastapi_endpoint
+from fastapi import FastAPI
+
+# Define an action handler function
+def greet_user_handler(name: str):
+    return f"Hello, {name}!"
+
+# Initialize the SDK endpoint
+endpoint = CopilotKitRemoteEndpoint(
+    actions=[
+        Action(
+            name="greet_user",
+            handler=greet_user_handler,
+            description="Greet the user",
+            parameters=[
+                {
+                    "name": "name",
+                    "type": "string",
+                    "description": "The name of the user"
+                }
+            ]
+        )
+    ]
+)
+
+# Create FastAPI app and add CopilotKit endpoint
+app = FastAPI()
+add_fastapi_endpoint(app, endpoint, "/copilotkit")
+```
+
+## LangGraph Integration
+
+CopilotKit provides seamless integration with LangGraph for building sophisticated agent workflows.
+
+### Using LangGraphAgent
+
+```python
+from copilotkit import CopilotKitRemoteEndpoint, LangGraphAgent
+from langgraph.graph import StateGraph, MessagesState
+
+# Create your LangGraph
+def create_graph():
+    workflow = StateGraph(MessagesState)
+    # ... define your graph nodes and edges
+    return workflow.compile()
+
+# Initialize the SDK with a LangGraph agent
+endpoint = CopilotKitRemoteEndpoint(
+    agents=[
+        LangGraphAgent(
+            name="email_agent",
+            description="This agent sends emails",
+            graph=create_graph(),
+        )
+    ]
+)
+```
+
+### Customizing LangGraph Behavior
+
+CopilotKit provides utilities to customize how your LangGraph agents work:
+
+```python
+from copilotkit.langgraph import copilotkit_customize_config, copilotkit_emit_state
+
+# Customize configuration
+config = copilotkit_customize_config(
+    base_config=None,  # or your existing config
+    emit_messages=True,
+    emit_tool_calls=True,
+    emit_intermediate_state=[
+        {
+            "state_key": "progress",
+            "tool": "ProgressTool",
+            "tool_argument": "steps"
+        },
+    ]
+)
+
+# Emit intermediate state
+async def long_running_node(state):
+    for i in range(10):
+        await some_operation(i)
+        await copilotkit_emit_state(config, {"progress": i})
+    return state
+```
+
+## CrewAI Integration
+
+CopilotKit provides integration with CrewAI for building multi-agent systems.
+
+### Intercepting CopilotKit Actions in CrewAI Flows
+
+When building flows that use CopilotKit actions, you need to properly intercept any tool calls that should be handled by the frontend:
+
+```python
+from copilotkit.crewai import create_copilotkit_tool_handlers, check_for_intercepted_actions
+
+@router(start_flow)
+async def chat(self):
+    # Your existing code...
+
+    # 1. Create wrapped tool handlers
+    wrapped_handlers = create_copilotkit_tool_handlers(
+        original_handlers=tool_handlers,  # Your original tool handlers
+        copilotkit_actions=self.state.copilotkit.actions,  # From CopilotKitState
+        state=self.state  # Flow state for flagging
+    )
+
+    # 2. Use wrapped handlers with LLM call
+    response = llm.call(
+        messages=[...],
+        tools=[
+            *self.state.copilotkit.actions,  # Include CopilotKit actions
+            YOUR_OTHER_TOOLS...
+        ],
+        available_functions=wrapped_handlers  # Use wrapped handlers
+    )
+
+    # 3. Create response message as usual
+    message = {"role": "assistant", "content": response}
+    self.state.messages.append(message)
+
+    # 4. Check if a CopilotKit action was intercepted
+    if check_for_intercepted_actions(self.state):
+        # Return to frontend to handle the action
+        return "route_end"
+
+    # Continue with normal flow...
+```
+
+This pattern ensures that:
+
+1. CopilotKit actions are properly identified
+2. The frontend gets control when needed
+3. Other tools continue to work normally
+
+## Documentation
+
+For detailed documentation and examples, visit [copilotkit.ai](https://copilotkit.ai)
+
+## Contributing
+
+We welcome contributions! Please see our [Contributing Guidelines](https://github.com/CopilotKit/CopilotKit/blob/main/CONTRIBUTING.md) for details.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](https://github.com/CopilotKit/CopilotKit/blob/main/LICENSE) file for details.
+
+## Support
+
+- 📚 [Documentation](https://docs.copilotkit.ai)
+- 💬 [Discord Community](https://discord.gg/6dffbvGU)
+- 🐛 [Issue Tracker](https://github.com/CopilotKit/CopilotKit/issues)
+
+---
+
+Built with ❤️ by the CopilotKit team
+

{copilotkit-0.1.44.dist-info → copilotkit-0.2.0a0.dist-info}/RECORD

@@ -1,9 +1,12 @@
 copilotkit/__init__.py,sha256=cmSvgm_jfy8hDu7VMN3DOzRIsEuICMhsJahplqJ-xwE,694
 copilotkit/action.py,sha256=bg_bPusEfN8TMQV1B3lVyMLbHyLn1E7yVYAvfE2_PXA,1691
 copilotkit/agent.py,sha256=HXDh4-PtdSFpLjp3g9nhO4VLPT9N4A1IdNTH6l4zh9w,1669
-copilotkit/crewai/__init__.py,sha256=GeD_lnvUkCMJC2Z3DKgd-50kXh0pUux7UyZ2M7OKaHI,546
-copilotkit/crewai/crewai_agent.py,sha256=Qjbee_G7IZAzC1kFhdBn8fiQ_9dOec4y4pXYpw-b2ik,15306
-copilotkit/crewai/crewai_sdk.py,sha256=MkldyEYU6eqqc4HdzoTN4oaZT9-rNJp9Ssx3j_6c7rU,18169
+copilotkit/crewai/__init__.py,sha256=XRTpm5cj7GG-W6B39m2_w69fmCwc_dfTvI_dDQkuXNY,803
+copilotkit/crewai/crewai_agent.py,sha256=maoMnl0WIHUnFAK5ALUKD9z0GvjtfNGi31zi37LyyaE,15323
+copilotkit/crewai/crewai_event_listener.py,sha256=GiHQQmP7xLX3Yj4O-ocwVgbxJab-L__KNIlOvrf5SVQ,8643
+copilotkit/crewai/crewai_sdk.py,sha256=goBwTnu2cOFwTWboZESBFsaX3eEBALPgJK4mOcxoCAo,19074
+copilotkit/crewai/imports.py,sha256=dD3thCatrH63nYaGQf7cBwYoRnqGxQwcp5VoL_XBXsI,3991
+copilotkit/crewai/utils.py,sha256=yEerz8DvcobD4SgVIDsIhObhDYnyrLxT0VYFB3n1i2w,7134
 copilotkit/exc.py,sha256=xsYVU7RIO50eWQsYtBsreCB5ilyBuDUC4Xepki0uCQs,1032
 copilotkit/html.py,sha256=IHnY4cx89LuYuPPf8Tady2DXfr3MyRWilMHpZ7d8bFk,4357
 copilotkit/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -18,6 +21,6 @@ copilotkit/runloop.py,sha256=9pBqWeu4QCRPOizz00se1d0_BvCX3ZIABzNeiXhdyNM,10641
 copilotkit/sdk.py,sha256=l4Sk-wUwTpgvSHP3O63FdM_df2xioy2SEwshbXdu__0,11525
 copilotkit/types.py,sha256=_YQluiHpJGGXYB4eWLk0EocDZp5C8rs3ZsMNFhmXEYU,972
 copilotkit/utils.py,sha256=rOAaaFBXgb3iv_cLH9S2steyGwHmnTjaxQTA53qdtQo,203
-copilotkit-0.1.44.dist-info/METADATA,sha256=QOQ2WlDD5c5iKHKMM45ILtaqZzTxtkdfBDkzF6nCdoI,2553
-copilotkit-0.1.44.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-copilotkit-0.1.44.dist-info/RECORD,,
+copilotkit-0.2.0a0.dist-info/METADATA,sha256=hkqHvJk2m6X3WpaIhwzkpLb_sm9UBpzrFN8dr2NT-lg,6367
+copilotkit-0.2.0a0.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+copilotkit-0.2.0a0.dist-info/RECORD,,

{copilotkit-0.1.44.dist-info → copilotkit-0.2.0a0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.1
+Generator: poetry-core 2.0.1
 Root-Is-Purelib: true
 Tag: py3-none-any

copilotkit-0.1.44.dist-info/METADATA

@@ -1,89 +0,0 @@
-Metadata-Version: 2.3
-Name: copilotkit
-Version: 0.1.44
-Summary: CopilotKit python SDK
-License: MIT
-Keywords: copilot,copilotkit,langgraph,langchain,ai,langsmith,langserve
-Author: Markus Ecker
-Author-email: markus.ecker@gmail.com
-Requires-Python: >=3.10,<3.13
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Provides-Extra: crewai
-Requires-Dist: crewai (==0.102.0) ; extra == "crewai"
-Requires-Dist: fastapi (>=0.115.0,<0.116.0)
-Requires-Dist: langchain (>=0.3.3,<0.4.0)
-Requires-Dist: langgraph (>=0.2.50)
-Requires-Dist: partialjson (>=0.0.8,<0.0.9)
-Requires-Dist: toml (>=0.10.2,<0.11.0)
-Project-URL: Homepage, https://copilotkit.ai
-Project-URL: Repository, https://github.com/CopilotKit/CopilotKit/tree/main/sdk-python
-Description-Content-Type: text/markdown
-
-# CopilotKit Python SDK
-
-[![PyPI version](https://badge.fury.io/py/copilotkit.svg)](https://badge.fury.io/py/copilotkit)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-
-The official Python SDK for CopilotKit - build AI copilots and agents into your applications.
-
-## Features
-
-- 🚀 Easy integration with LangGraph and LangChain
-- 🔄 Built-in support for stateful conversations
-- 🛠 Extensible agent framework
-- 🔌 FastAPI-ready endpoints
-- 🤝 Optional CrewAI integration
-
-## Installation
-
-```bash
-pip install copilotkit
-```
-
-With CrewAI support:
-
-```bash
-pip install "copilotkit[crewai]"
-```
-
-## Quick Start
-
-```python
-from copilotkit import Copilot
-
-# Initialize a copilot
-copilot = Copilot()
-
-# Add your tools and configure the copilot
-copilot.add_tool(my_custom_tool)
-
-# Run the copilot
-response = copilot.run("Your task description here")
-```
-
-## Documentation
-
-For detailed documentation and examples, visit [copilotkit.ai](https://copilotkit.ai)
-
-## Contributing
-
-We welcome contributions! Please see our [Contributing Guidelines](https://github.com/CopilotKit/CopilotKit/blob/main/CONTRIBUTING.md) for details.
-
-## License
-
-This project is licensed under the MIT License - see the [LICENSE](https://github.com/CopilotKit/CopilotKit/blob/main/LICENSE) file for details.
-
-## Support
-
-- 📚 [Documentation](https://docs.copilotkit.ai)
-- 💬 [Discord Community](https://discord.gg/6dffbvGU)
-- 🐛 [Issue Tracker](https://github.com/CopilotKit/CopilotKit/issues)
-
----
-
-Built with ❤️ by the CopilotKit team
-