copilotkit 0.1.34a1__tar.gz

copilotkit-0.1.34a1/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.1
+Name: copilotkit
+Version: 0.1.34a1
+Summary: CopilotKit python SDK
+Home-page: https://copilotkit.ai
+License: MIT
+Keywords: copilot,copilotkit,langgraph,langchain,ai,langsmith,langserve
+Author: Markus Ecker
+Author-email: markus.ecker@gmail.com
+Requires-Python: >=3.9,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: fastapi (>=0.115.0,<0.116.0)
+Requires-Dist: httpx (>=0.27.2,<0.28.0)
+Requires-Dist: langchain (>=0.3.3,<0.4.0)
+Requires-Dist: langchain-anthropic (>=0.2.3,<0.4.0)
+Requires-Dist: langchain-openai (>=0.2.2,<0.3.0)
+Requires-Dist: langgraph (>=0.2.50)
+Requires-Dist: langgraph-sdk (>=0.1.32,<0.2.0)
+Requires-Dist: partialjson (>=0.0.8,<0.0.9)
+Requires-Dist: toml (>=0.10.2,<0.11.0)
+Project-URL: Repository, https://github.com/CopilotKit/sdk-python
+Description-Content-Type: text/markdown
+
+# CopilotKit python SDK
+

copilotkit-0.1.34a1/README.md

@@ -0,0 +1 @@
+# CopilotKit python SDK

copilotkit-0.1.34a1/copilotkit/__init__.py

@@ -0,0 +1,19 @@
+"""CopilotKit SDK"""
+from .sdk import CopilotKitRemoteEndpoint, CopilotKitContext, CopilotKitSDK, CopilotKitSDKContext
+from .action import Action
+from .langgraph_agent import LangGraphAgent
+from .state import CopilotKitState
+from .parameter import Parameter
+from .agent import Agent
+
+__all__ = [
+    'CopilotKitRemoteEndpoint', 
+    'CopilotKitSDK',
+    'Action', 
+    'LangGraphAgent', 
+    'CopilotKitState', 
+    'Parameter',
+    'Agent',
+    'CopilotKitContext',
+    'CopilotKitSDKContext'
+]

copilotkit-0.1.34a1/copilotkit/action.py

@@ -0,0 +1,51 @@
+"""Actions"""
+
+
+from inspect import iscoroutinefunction
+from typing import Optional, List, Callable, TypedDict, Any, cast
+from .parameter import Parameter, normalize_parameters
+
+class ActionDict(TypedDict):
+    """Dict representation of an action"""
+    name: str
+    description: str
+    parameters: List[Parameter]
+
+class ActionResultDict(TypedDict):
+    """Dict representation of an action result"""
+    result: Any
+
+class Action:  # pylint: disable=too-few-public-methods
+    """Action class for CopilotKit"""
+    def __init__(
+            self,
+            *,
+            name: str,
+            handler: Callable,
+            description: Optional[str] = None,
+            parameters: Optional[List[Parameter]] = None,
+        ):
+        self.name = name
+        self.description = description
+        self.parameters = parameters
+        self.handler = handler
+
+    async def execute(
+            self,
+            *,
+            arguments: dict
+        ) -> ActionResultDict:
+        """Execute the action"""
+        result = self.handler(**arguments)
+
+        return {
+            "result": await result if iscoroutinefunction(self.handler) else result
+        }
+
+    def dict_repr(self) -> ActionDict:
+        """Dict representation of the action"""
+        return {
+            'name': self.name,
+            'description': self.description or '',
+            'parameters': normalize_parameters(cast(Any, self.parameters)),
+        }

copilotkit-0.1.34a1/copilotkit/agent.py

@@ -0,0 +1,50 @@
+"""Agents"""
+
+from typing import Optional, List, TypedDict
+from abc import ABC, abstractmethod
+from .types import Message
+from .action import ActionDict
+
+class AgentDict(TypedDict):
+    """Agent dictionary"""
+    name: str
+    description: Optional[str]
+
+class Agent(ABC):
+    """Agent class for CopilotKit"""
+    def __init__(
+            self,
+            *,
+            name: str,
+            description: Optional[str] = None,
+        ):
+        self.name = name
+        self.description = description
+
+    @abstractmethod
+    def execute( # pylint: disable=too-many-arguments
+        self,
+        *,
+        state: dict,
+        messages: List[Message],
+        thread_id: Optional[str] = None,
+        node_name: Optional[str] = None,
+        actions: Optional[List[ActionDict]] = None,
+    ):
+        """Execute the agent"""
+
+    @abstractmethod
+    def get_state(
+        self,
+        *,
+        thread_id: str,
+    ):
+        """Get agent state"""
+
+
+    def dict_repr(self) -> AgentDict:
+        """Dict representation of the action"""
+        return {
+            'name': self.name,
+            'description': self.description or ''
+        }

copilotkit-0.1.34a1/copilotkit/exc.py

@@ -0,0 +1,31 @@
+"""Exceptions for CopilotKit."""
+
+class ActionNotFoundException(Exception):
+    """Exception raised when an action or agent is not found."""
+
+    def __init__(self, name: str):
+        self.name = name
+        super().__init__(f"Action '{name}' not found.")
+
+class AgentNotFoundException(Exception):
+    """Exception raised when an agent is not found."""
+
+    def __init__(self, name: str):
+        self.name = name
+        super().__init__(f"Agent '{name}' not found.")
+
+class ActionExecutionException(Exception):
+    """Exception raised when an action fails to execute."""
+
+    def __init__(self, name: str, error: Exception):
+        self.name = name
+        self.error = error
+        super().__init__(f"Action '{name}' failed to execute: {error}")
+
+class AgentExecutionException(Exception):
+    """Exception raised when an agent fails to execute."""
+
+    def __init__(self, name: str, error: Exception):
+        self.name = name
+        self.error = error
+        super().__init__(f"Agent '{name}' failed to execute: {error}")

copilotkit-0.1.34a1/copilotkit/integrations/fastapi.py

@@ -0,0 +1,210 @@
+"""FastAPI integration"""
+
+import logging
+import asyncio
+#
+from concurrent.futures import ThreadPoolExecutor
+from typing import List, Any, cast
+from fastapi import FastAPI, Request, HTTPException
+from fastapi.responses import JSONResponse, StreamingResponse
+from ..sdk import CopilotKitRemoteEndpoint, CopilotKitContext
+from ..types import Message
+from ..exc import (
+    ActionNotFoundException,
+    ActionExecutionException,
+    AgentNotFoundException,
+    AgentExecutionException,
+)
+from ..action import ActionDict
+
+logging.basicConfig(level=logging.ERROR)
+logger = logging.getLogger(__name__)
+
+def add_fastapi_endpoint(
+        fastapi_app: FastAPI,
+        sdk: CopilotKitRemoteEndpoint,
+        prefix: str,
+        *,
+        max_workers: int = 10,
+    ):
+    """Add FastAPI endpoint with configurable ThreadPoolExecutor size"""
+    executor = ThreadPoolExecutor(max_workers=max_workers)
+
+    def run_handler_in_thread(request: Request, sdk: CopilotKitRemoteEndpoint):
+        # Run the handler coroutine in the event loop        
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        return loop.run_until_complete(handler(request, sdk))
+
+    async def make_handler(request: Request):
+        loop = asyncio.get_event_loop()
+        future = loop.run_in_executor(executor, run_handler_in_thread, request, sdk)
+        return await future
+
+    # Ensure the prefix starts with a slash and remove trailing slashes
+    normalized_prefix = '/' + prefix.strip('/')
+
+    fastapi_app.add_api_route(
+        f"{normalized_prefix}/{{path:path}}",
+        make_handler,
+        methods=['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
+    )
+
+def body_get_or_raise(body: Any, key: str):
+    """Get value from body or raise an error"""
+    value = body.get(key)
+    if value is None:
+        raise HTTPException(status_code=400, detail=f"{key} is required")
+    return value
+
+
+async def handler(request: Request, sdk: CopilotKitRemoteEndpoint):
+    """Handle FastAPI request"""
+
+    try:
+        body = await request.json()
+    except Exception as exc:
+        raise HTTPException(status_code=400, detail="Request body is required") from exc
+
+    path = request.path_params.get('path')
+    method = request.method
+    context = cast(
+        CopilotKitContext, 
+        {
+            "properties": body.get("properties", {}),
+            "frontend_url": body.get("frontendUrl", None)
+        }
+    )
+
+    if method == 'POST' and path == 'info':
+        return await handle_info(sdk=sdk, context=context)
+
+    if method == 'POST' and path == 'actions/execute':
+        name = body_get_or_raise(body, "name")
+        arguments = body.get("arguments", {})
+
+        return await handle_execute_action(
+            sdk=sdk,
+            context=context,
+            name=name,
+            arguments=arguments,
+        )
+
+    if method == 'POST' and path == 'agents/execute':
+        thread_id = body.get("threadId")
+        node_name = body.get("nodeName")
+
+        name = body_get_or_raise(body, "name")
+        state = body_get_or_raise(body, "state")
+        messages = body_get_or_raise(body, "messages")
+        actions = cast(List[ActionDict], body.get("actions", []))
+
+        return handle_execute_agent(
+            sdk=sdk,
+            context=context,
+            thread_id=thread_id,
+            node_name=node_name,
+            name=name,
+            state=state,
+            messages=messages,
+            actions=actions,
+        )
+
+    if method == 'POST' and path == 'agents/state':
+        thread_id = body_get_or_raise(body, "threadId")
+        name = body_get_or_raise(body, "name")
+
+        return handle_get_agent_state(
+            sdk=sdk,
+            context=context,
+            thread_id=thread_id,
+            name=name,
+        )
+
+    raise HTTPException(status_code=404, detail="Not found")
+
+
+async def handle_info(*, sdk: CopilotKitRemoteEndpoint, context: CopilotKitContext):
+    """Handle info request with FastAPI"""
+    result = sdk.info(context=context)
+    return JSONResponse(content=result)
+
+async def handle_execute_action(
+        *,
+        sdk: CopilotKitRemoteEndpoint,
+        context: CopilotKitContext,
+        name: str,
+        arguments: dict,
+    ):
+    """Handle execute action request with FastAPI"""
+    try:
+        result = await sdk.execute_action(
+            context=context,
+            name=name,
+            arguments=arguments
+        )
+        return JSONResponse(content=result)
+    except ActionNotFoundException as exc:
+        logger.error("Action not found: %s", exc)
+        return JSONResponse(content={"error": str(exc)}, status_code=404)
+    except ActionExecutionException as exc:
+        logger.error("Action execution error: %s", exc)
+        return JSONResponse(content={"error": str(exc)}, status_code=500)
+    except Exception as exc: # pylint: disable=broad-except
+        logger.error("Action execution error: %s", exc)
+        return JSONResponse(content={"error": str(exc)}, status_code=500)
+
+def handle_execute_agent( # pylint: disable=too-many-arguments
+        *,
+        sdk: CopilotKitRemoteEndpoint,
+        context: CopilotKitContext,
+        thread_id: str,
+        node_name: str,
+        name: str,
+        state: dict,
+        messages: List[Message],
+        actions: List[ActionDict],
+    ):
+    """Handle continue agent execution request with FastAPI"""
+    try:
+        events = sdk.execute_agent(
+            context=context,
+            thread_id=thread_id,
+            name=name,
+            node_name=node_name,
+            state=state,
+            messages=messages,
+            actions=actions,
+        )
+        return StreamingResponse(events, media_type="application/json")
+    except AgentNotFoundException as exc:
+        logger.error("Agent not found: %s", exc, exc_info=True)
+        return JSONResponse(content={"error": str(exc)}, status_code=404)
+    except AgentExecutionException as exc:
+        logger.error("Agent execution error: %s", exc, exc_info=True)
+        return JSONResponse(content={"error": str(exc)}, status_code=500)
+    except Exception as exc: # pylint: disable=broad-except
+        logger.error("Agent execution error: %s", exc, exc_info=True)
+        return JSONResponse(content={"error": str(exc)}, status_code=500)
+
+def handle_get_agent_state(
+        *,
+        sdk: CopilotKitRemoteEndpoint,
+        context: CopilotKitContext,
+        thread_id: str,
+        name: str,
+    ):
+    """Handle get agent state request with FastAPI"""
+    try:
+        result = sdk.get_agent_state(
+            context=context,
+            thread_id=thread_id,
+            name=name,
+        )
+        return JSONResponse(content=result)
+    except AgentNotFoundException as exc:
+        logger.error("Agent not found: %s", exc, exc_info=True)
+        return JSONResponse(content={"error": str(exc)}, status_code=404)
+    except Exception as exc: # pylint: disable=broad-except
+        logger.error("Agent get state error: %s", exc, exc_info=True)
+        return JSONResponse(content={"error": str(exc)}, status_code=500)

copilotkit-0.1.34a1/copilotkit/langchain.py

@@ -0,0 +1,30 @@
+"""
+copilotkit.langchain is deprecated. Use copilotkit.langgraph instead.
+"""
+import warnings
+from copilotkit.langgraph import (
+  langchain_messages_to_copilotkit,
+  copilotkit_messages_to_langchain,
+  copilotkit_customize_config,
+  copilotkit_exit,
+  copilotkit_emit_state,
+  copilotkit_emit_message,
+  copilotkit_emit_tool_call,
+
+)
+
+warnings.warn(
+    "copilotkit.langchain is deprecated. Use copilotkit.langgraph instead.",
+    DeprecationWarning,
+    stacklevel=2
+)
+
+__all__ = [
+  "langchain_messages_to_copilotkit",
+  "copilotkit_messages_to_langchain",
+  "copilotkit_customize_config",
+  "copilotkit_exit",
+  "copilotkit_emit_state",
+  "copilotkit_emit_message",
+  "copilotkit_emit_tool_call",
+]