copilotkit 0.1.44__tar.gz → 0.2.0a0__tar.gz

copilotkit-0.2.0a0/PKG-INFO

@@ -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.2.0a0/README.md

@@ -0,0 +1,193 @@
+# 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 → copilotkit-0.2.0a0}/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-0.1.44 → copilotkit-0.2.0a0}/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-0.2.0a0/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)