copilotkit 0.1.0__tar.gz

copilotkit-0.1.0/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.1
+Name: copilotkit
+Version: 0.1.0
+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.12,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: fastapi (>=0.111.1,<0.112.0)
+Requires-Dist: httpx (>=0.27.0,<0.28.0)
+Requires-Dist: langchain (>=0.2.12,<0.3.0)
+Requires-Dist: langchain-openai (>=0.1.20,<0.2.0)
+Requires-Dist: langgraph (>=0.2.3,<0.3.0)
+Requires-Dist: partialjson (>=0.0.8,<0.0.9)
+Description-Content-Type: text/markdown
+
+# CopilotKit python SDK (alpha)
+
+Needs pre-release CopilotKit packages:
+
+```
+@copilotkit/react-core@1.1.1-feat-runtime-remote-actions.5
+@copilotkit/react-ui@1.1.1-feat-runtime-remote-actions.5
+@copilotkit/runtime@1.1.1-feat-runtime-remote-actions.5
+```
+

copilotkit-0.1.0/README.md

@@ -0,0 +1,9 @@
+# CopilotKit python SDK (alpha)
+
+Needs pre-release CopilotKit packages:
+
+```
+@copilotkit/react-core@1.1.1-feat-runtime-remote-actions.5
+@copilotkit/react-ui@1.1.1-feat-runtime-remote-actions.5
+@copilotkit/runtime@1.1.1-feat-runtime-remote-actions.5
+```

copilotkit-0.1.0/copilotkit/__init__.py

@@ -0,0 +1,9 @@
+"""CopilotKit SDK"""
+from .sdk import CopilotKitSDK
+from .action import Action
+from .agent import LangGraphAgent
+from .state import CopilotKitState
+
+__all__ = [
+    'CopilotKitSDK', 'Action', 'LangGraphAgent', 'CopilotKitState'
+]

copilotkit-0.1.0/copilotkit/action.py

@@ -0,0 +1,40 @@
+"""Actions"""
+
+from inspect import iscoroutinefunction
+from typing import Optional, List, Callable
+from .parameter import BaseParameter, normalize_parameters
+
+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[BaseParameter]] = None,
+        ):
+        self.name = name
+        self.description = description
+        self.parameters = parameters
+        self.handler = handler
+
+    async def execute(
+            self,
+            *,
+            arguments: dict
+        ) -> dict:
+        """Execute the action"""
+        result = self.handler(**arguments)
+
+        return {
+            "result": await result if iscoroutinefunction(self.handler) else result
+        }
+
+    def dict_repr(self):
+        """Dict representation of the action"""
+        return {
+            'name': self.name,
+            'description': self.description or '',
+            'parameters': normalize_parameters(self.parameters),
+        }

copilotkit-0.1.0/copilotkit/agent.py

@@ -0,0 +1,288 @@
+"""Agents"""
+
+from typing import Optional, List
+from abc import ABC, abstractmethod
+import uuid
+from langgraph.graph.graph import CompiledGraph
+from langchain.load.dump import dumps as langchain_dumps
+from langchain.load.load import load as langchain_load
+
+from langchain.schema import SystemMessage
+
+from partialjson.json_parser import JSONParser
+
+from .types import Message
+from .langchain import copilotkit_messages_to_langchain
+
+
+class Agent(ABC):
+    """Agent class for CopilotKit"""
+    def __init__(
+            self,
+            *,
+            name: str,
+            description: Optional[str] = None,
+            merge_state: Optional[callable] = None
+        ):
+        self.name = name
+        self.description = description
+        self.merge_state = merge_state
+
+    @abstractmethod
+    def execute(
+        self,
+        *,
+        state: dict,
+        messages: List[Message],
+        thread_id: Optional[str] = None,
+        node_name: Optional[str] = None,
+    ):
+        """Execute the agent"""
+
+    def dict_repr(self):
+        """Dict representation of the action"""
+        return {
+            'name': self.name,
+            'description': self.description or ''
+        }
+
+def langgraph_default_merge_state( # pylint: disable=unused-argument
+        *,
+        state: dict,
+        messages: List[Message],
+        actions: List[any]
+    ):
+    """Default merge state for LangGraph"""
+    if len(messages) > 0 and isinstance(messages[0], SystemMessage):
+        # remove system message
+        messages = messages[1:]
+
+    # merge with existing messages
+    merged_messages = list(map(langchain_load, state.get("messages", [])))
+    existing_message_ids = {message.id for message in merged_messages}
+
+    for message in messages:
+        if message.id not in existing_message_ids:
+            merged_messages.append(message)
+
+    return {
+        **state,
+        "messages": merged_messages,
+        "copilotkit": {
+            "actions": actions
+        }
+    }
+
+class LangGraphAgent(Agent):
+    """LangGraph agent class for CopilotKit"""
+    def __init__(
+            self,
+            *,
+            name: str,
+            agent: CompiledGraph,
+            description: Optional[str] = None,
+            merge_state: Optional[callable] = langgraph_default_merge_state
+        ):
+        super().__init__(
+            name=name,
+            description=description,
+            merge_state=merge_state
+        )
+        self.agent = agent
+
+    def _emit_state_sync_event(
+            self,
+            *,
+            thread_id: str,
+            run_id: str,
+            node_name: str,
+            state: dict,
+            running: bool,
+            active: bool
+        ):
+        return langchain_dumps({
+            "event": "on_copilotkit_state_sync",
+            "thread_id": thread_id,
+            "run_id": run_id,
+            "agent_name": self.name,
+            "node_name": node_name,
+            "active": active,
+            "state": state,
+            "running": running,
+            "role": "assistant"
+        })
+
+    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[any]] = None,
+    ):
+
+        langchain_messages = copilotkit_messages_to_langchain(messages)
+        state = self.merge_state(
+            state=state,
+            messages=langchain_messages,
+            actions=actions
+        )
+
+        mode = "continue" if thread_id and node_name != "__end__" else "start"
+        thread_id = thread_id or str(uuid.uuid4())
+
+        config = {"configurable": {"thread_id": thread_id}}
+        if mode == "continue":
+            self.agent.update_state(config, state, as_node=node_name)
+
+        return self._stream_events(
+            mode=mode,
+            thread_id=thread_id,
+            state=state,
+            node_name=node_name
+        )
+
+    async def _stream_events(
+            self,
+            *,
+            mode: str,
+            thread_id: str,
+            state: dict,
+            node_name: Optional[str] = None
+        ):
+
+        config = {"configurable": {"thread_id": thread_id}}
+        streaming_state_extractor = _StreamingStateExtractor({})
+        initial_state = state if mode == "start" else None
+        prev_node_name = None
+
+        async for event in self.agent.astream_events(initial_state, config, version="v1"):
+            current_node_name = event.get("name")
+            event_type = event.get("event")
+            run_id = event.get("run_id")
+
+            metadata = event.get("metadata")
+            emit_state = metadata.get("copilotkit:emit-state")
+
+            if emit_state and event_type == "on_chat_model_start":
+                # reset the streaming state extractor
+                streaming_state_extractor = _StreamingStateExtractor(emit_state)
+
+            # we only want to update the node name under certain conditions
+            # since we don't need any internal node names to be sent to the frontend
+            if current_node_name in self.agent.nodes.keys():
+                node_name = current_node_name
+
+            # we don't have a node name yet, so we can't update the state
+            if node_name is None:
+                continue
+
+            updated_state = self.agent.get_state(config).values
+
+            if emit_state and event_type == "on_chat_model_stream":
+                streaming_state_extractor.buffer_tool_calls(event)
+
+            updated_state = {
+                **updated_state,
+                **streaming_state_extractor.extract_state()
+            }
+
+            exiting_node = node_name == current_node_name and event_type == "on_chain_end"
+
+            # we send state sync events when:
+            #   a) the state has changed
+            #   b) the node has changed
+            #   c) the node is ending
+            if updated_state != state or prev_node_name != node_name or exiting_node:
+                state = updated_state
+                prev_node_name = node_name
+                yield self._emit_state_sync_event(
+                    thread_id=thread_id,
+                    run_id=run_id,
+                    node_name=node_name,
+                    state=state,
+                    running=True,
+                    active=not exiting_node
+                ) + "\n"
+
+            yield langchain_dumps(event) + "\n"
+
+        state = self.agent.get_state(config)
+        is_end_node = state.next == ()
+
+        node_name = list(state.metadata["writes"].keys())[0]
+        yield self._emit_state_sync_event(
+            thread_id=thread_id,
+            run_id=run_id,
+            node_name=node_name if not is_end_node else "__end__",
+            state=state.values,
+            # For now, we assume that the agent is always running
+            # In the future, we will have a special node that will
+            # indicate that the agent is done
+            running=True,
+
+            # at this point, the node is ending so we set active to false
+            active=False
+        ) + "\n"
+
+
+
+    def dict_repr(self):
+        super_repr = super().dict_repr()
+        return {
+            **super_repr,
+            'type': 'langgraph'
+        }
+
+class _StreamingStateExtractor:
+    def __init__(self, emit_state: dict):
+        self.emit_state = emit_state
+        self.tool_call_buffer = {}
+        self.current_tool_call = None
+
+    def buffer_tool_calls(self, event: dict):
+        """Buffer the tool calls"""
+        if len(event["data"]["chunk"].tool_call_chunks) > 0:
+            chunk = event["data"]["chunk"].tool_call_chunks[0]
+            if chunk["name"] is not None:
+                self.current_tool_call = chunk["name"]
+                self.tool_call_buffer[self.current_tool_call] = chunk["args"]
+            elif self.current_tool_call is not None:
+                self.tool_call_buffer[self.current_tool_call] = (
+                    self.tool_call_buffer[self.current_tool_call] + chunk["args"]
+                )
+
+    def get_emit_state_config(self, current_tool_name):
+        """Get the emit state config"""
+
+        for key, value in self.emit_state.items():
+            if current_tool_name == value.get("tool"):
+                return (value.get("argument"), key)
+
+        return (None, None)
+
+
+    def extract_state(self):
+        """Extract the streaming state"""
+        parser = JSONParser()
+
+        state = {}
+
+        for key, value in self.tool_call_buffer.items():
+            argument_name, state_key = self.get_emit_state_config(key)
+
+            if state_key is None:
+                continue
+
+            try:
+                parsed_value = parser.parse(value)
+            except Exception as _exc: # pylint: disable=broad-except
+                continue
+
+            if argument_name is None:
+                state[state_key] = parsed_value
+            else:
+                state[state_key] = parsed_value.get(argument_name)
+
+        return state

copilotkit-0.1.0/copilotkit/demo.py

@@ -0,0 +1,24 @@
+"""Demo"""
+
+from fastapi import FastAPI
+import uvicorn
+from .integrations.fastapi import add_fastapi_endpoint
+from . import CopilotKitSDK, LangGraphAgent
+from .demos.autotale_ai.agent import graph
+
+app = FastAPI()
+sdk = CopilotKitSDK(
+    agents=[
+        LangGraphAgent(
+            name="childrensBookAgent",
+            description="Write a children's book.",
+            agent=graph,
+        )
+    ],
+)
+
+add_fastapi_endpoint(app, sdk, "/copilotkit")
+
+def main():
+    """Run the uvicorn server."""
+    uvicorn.run("copilotkit.demo:app", host="127.0.0.1", port=8000, reload=True)

copilotkit-0.1.0/copilotkit/demos/autotale_ai/agent.py

@@ -0,0 +1,74 @@
+"""
+This is the main entry point for the autotale AI.
+It defines the workflow graph and the entry point for the agent.
+"""
+# pylint: disable=line-too-long, unused-import
+
+from langgraph.graph import StateGraph, END
+from langgraph.checkpoint.memory import MemorySaver
+
+from langchain_core.messages import ToolMessage
+
+from copilotkit.demos.autotale_ai.state import AgentState
+from copilotkit.demos.autotale_ai.chatbot import chatbot_node
+from copilotkit.demos.autotale_ai.story.outline import outline_node
+from copilotkit.demos.autotale_ai.story.characters import characters_node
+from copilotkit.demos.autotale_ai.story.story import story_node
+from copilotkit.demos.autotale_ai.story.style import style_node
+
+
+
+
+def route_story_writing(state):
+    """Route to story writing nodes."""
+    last_message = state["messages"][-1]
+
+    if isinstance(last_message, ToolMessage):
+        return last_message.name
+    return END
+
+# Define a new graph
+workflow = StateGraph(AgentState)
+workflow.add_node("chatbot_node", chatbot_node)
+workflow.add_node("outline_node", outline_node)
+workflow.add_node("characters_node", characters_node)
+workflow.add_node("style_node", style_node)
+workflow.add_node("story_node", story_node)
+
+# Chatbot
+workflow.set_entry_point("chatbot_node")
+
+workflow.add_conditional_edges(
+    "chatbot_node", 
+    route_story_writing,
+    {
+        "set_outline": "outline_node",
+        "set_characters": "characters_node",
+        "set_story": "story_node",
+        "set_style": "style_node",
+        END: END,
+    }
+)
+workflow.add_edge(
+    "outline_node",
+    "chatbot_node"
+)
+
+workflow.add_edge(
+    "characters_node",
+    "chatbot_node"
+)
+
+workflow.add_edge(
+    "story_node",
+    "chatbot_node"
+)
+
+workflow.add_edge(
+    "style_node",
+    "chatbot_node"
+)
+
+memory = MemorySaver()
+
+graph = workflow.compile(checkpointer=memory)

copilotkit-0.1.0/copilotkit/demos/autotale_ai/chatbot.py

@@ -0,0 +1,108 @@
+"""
+Main chatbot node.
+"""
+
+import json
+
+from langchain_openai import ChatOpenAI
+from langchain_core.messages import SystemMessage
+from langchain_core.runnables import RunnableConfig
+from langchain_core.messages import ToolMessage, AIMessage
+
+from copilotkit.demos.autotale_ai.state import AgentState
+from copilotkit.demos.autotale_ai.story.outline import set_outline
+from copilotkit.demos.autotale_ai.story.characters import set_characters
+from copilotkit.demos.autotale_ai.story.story import set_story
+from copilotkit.demos.autotale_ai.story.style import set_style
+from copilotkit.langchain import configure_copilotkit
+# pylint: disable=line-too-long
+
+async def chatbot_node(state: AgentState, config: RunnableConfig):
+    """
+    The chatbot is responsible for answering the user's questions and selecting
+    the next route.
+    """
+
+    config = configure_copilotkit(
+        config,
+        emit_messages=True,
+        emit_state={
+            "outline": {
+                "tool": "set_outline",
+                "argument": "outline"
+            },
+            "characters": {
+                "tool": "set_characters",
+                "argument": "characters"
+            },
+        }
+    )
+
+    tools = [set_outline, set_style]
+
+    if state.get("outline") is not None:
+        tools.append(set_characters)
+
+    if state.get("characters") is not None:
+        tools.append(set_story)
+
+    system_message = """
+You help the user write a children's story. Please assist the user by either having a conversation or by 
+taking the appropriate actions to advance the story writing process. Do not repeat the whole story again.
+
+Your state consists of the following concepts:
+
+- Outline: The outline of the story. Should be short, 2-3 sentences.
+- Characters: The characters that make up the story (depends on outline)
+- Story: The final story result. (depends on outline & characters)
+
+If the user asks you to make changes to any of these,
+you MUST take into account dependencies and make the changes accordingly.
+
+Example: If after coming up with the characters, the user requires changes in the outline, you must first 
+regenerate the outline.
+
+Dont bother the user too often, just call the tools.
+Especially, dont' repeat the story and so on, just call the tools.
+"""
+    if state.get("outline") is not None:
+        system_message += f"\n\nThe current outline is: {state['outline']}"
+
+    if state.get("characters") is not None:
+        system_message += f"\n\nThe current characters are: {json.dumps(state['characters'])}"
+
+    if state.get("story") is not None:
+        system_message += f"\n\nThe current story is: {json.dumps(state['story'])}"
+
+    last_message = state["messages"][-1] if state["messages"] else None
+
+    if last_message and isinstance(last_message, AIMessage):
+        system_message += """
+The user did not submit the last message. This means they probably changed the state of the story by
+in the UI. Figure out if you need to regenerate the outline, characters or story and call the appropriate
+tool. If not, just respond to the user.
+        """
+
+
+    response = await ChatOpenAI(model="gpt-4o").bind_tools(tools, parallel_tool_calls=False).ainvoke([
+        *state["messages"],
+        SystemMessage(
+            content=system_message
+        )
+    ], config)
+
+    if not response.tool_calls:
+        return {
+            "messages": response,
+        }
+
+    return {
+        "messages": [
+            response,
+            ToolMessage(
+                name=response.tool_calls[0]["name"],
+                content=json.dumps(response.tool_calls[0]["args"]),
+                tool_call_id=response.tool_calls[0]["id"]
+            )
+        ],
+    }

copilotkit-0.1.0/copilotkit/demos/autotale_ai/state.py

@@ -0,0 +1,33 @@
+"""
+This is the state definition for the autotale AI.
+It defines the state of the agent and the state of the conversation.
+"""
+
+from typing import List, TypedDict
+from langgraph.graph import MessagesState
+
+
+
+class Character(TypedDict):
+    """
+    Represents a character in the tale.
+    """
+    name: str
+    appearance: str
+    traits: List[str]
+
+
+class Page(TypedDict):
+    """
+    Represents a page in the children's story with an image url.
+    """
+    content: str
+
+class AgentState(MessagesState):
+    """
+    This is the state of the agent.
+    It is a subclass of the MessagesState class from langgraph.
+    """
+    outline: str
+    characters: List[Character]
+    story: List[Page]

copilotkit-0.1.0/copilotkit/demos/autotale_ai/story/characters.py

@@ -0,0 +1,30 @@
+"""
+Characters node.
+"""
+
+from typing import List
+import json
+from langchain_core.tools import tool
+
+from copilotkit.demos.autotale_ai.state import AgentState, Character
+
+
+
+@tool
+def set_characters(characters: List[Character]):
+    """
+    Extract the book's main characters from the conversation.
+    The traits should be short: 3-4 adjectives.
+    The appearance should be as detailed as possible. What they look like, their clothes, etc.
+    """
+    return characters
+
+
+def characters_node(state: AgentState):
+    """
+    The characters node is responsible for extracting the characters from the conversation.
+    """
+    last_message = state["messages"][-1]
+    return {
+        "characters": json.loads(last_message.content)["characters"]
+    }

copilotkit-0.1.0/copilotkit/demos/autotale_ai/story/outline.py

@@ -0,0 +1,22 @@
+"""
+Outline node.
+"""
+
+import json
+from langchain_core.tools import tool
+from copilotkit.demos.autotale_ai.state import AgentState
+
+@tool
+def set_outline(outline: str):
+    """Sets the outline of the story."""
+    return outline
+
+
+async def outline_node(state: AgentState):
+    """
+    The outline node is responsible for generating an outline for the story.
+    """
+    last_message = state["messages"][-1]
+    return {
+        "outline": json.loads(last_message.content)["outline"]
+    }

copilotkit-0.1.0/copilotkit/demos/autotale_ai/story/story.py

@@ -0,0 +1,107 @@
+"""
+Story node.
+"""
+
+from typing import List
+import json
+import asyncio
+
+from langchain_core.tools import tool
+from langchain_core.messages import SystemMessage
+from langchain_core.runnables import RunnableConfig
+from langchain_core.pydantic_v1 import BaseModel, Field
+from langchain_openai import ChatOpenAI
+
+from copilotkit.demos.autotale_ai.state import AgentState, Character
+
+
+class ImageDescription(BaseModel):
+    """
+    Represents the description of an image of a character in the story.
+    """
+    description: str
+
+async def _generate_page_image_description(
+        messages: list,
+        page_content: str,
+        characters: List[Character],
+        style: str,
+        config: RunnableConfig
+    ):
+    """
+    Generate a description of the image of a character.
+    """
+
+    system_message = SystemMessage(
+        content= f"""
+The user and the AI are having a conversation about writing a children's story.
+It's your job to generate a vivid description of a page in the story.
+Make the description as detailed as possible.
+
+These are the characters in the story:
+{characters}
+
+This is the page content:
+{page_content}
+
+This is the graphical style of the story:
+{style}
+
+Imagine an image of the page. Describe the looks of the page in great detail.
+Also describe the setting in which the image is taken.
+Make sure to include the name of the characters and full description of the characters in your output.
+Describe the style in detail, it's very important for image generation.
+        """
+    )
+    model = ChatOpenAI(model="gpt-4o").with_structured_output(ImageDescription)
+    response = await model.ainvoke([
+        *messages,
+        system_message
+    ], config)
+
+    return response.description
+
+class StoryPage(BaseModel):
+    """
+    Represents a page in the children's story. Keep it simple, 3-4 sentences per page.
+    """
+    content: str = Field(..., description="A single page in the story")
+
+@tool
+def set_story(pages: List[StoryPage]):
+    """
+    Considering the outline and characters, write a story.
+    Keep it simple, 3-4 sentences per page.
+    5 pages max.
+    (If the user mentions "chapters" in the conversation they mean pages, treat it as such)
+    """
+    return pages
+
+async def story_node(state: AgentState, config: RunnableConfig):
+    """
+    The story node is responsible for extracting the story from the conversation.
+    """
+    last_message = state["messages"][-1]
+    pages = json.loads(last_message.content)["pages"]
+    characters = state.get("characters", [])
+    style = state.get("style", "Pixar movies style 3D images")
+
+    async def generate_page(page):
+        description = await _generate_page_image_description(
+            state["messages"],
+            page["content"],
+            characters,
+            style,
+            config
+        )
+        return {
+            "content": page["content"],
+            "image_description": description
+        }
+
+    tasks = [generate_page(page) for page in pages]
+    story = await asyncio.gather(*tasks)
+
+    return {
+        "story": story
+    }

copilotkit-0.1.0/copilotkit/demos/autotale_ai/story/style.py

@@ -0,0 +1,22 @@
+"""
+Style node.
+"""
+
+import json
+from langchain_core.tools import tool
+from copilotkit.demos.autotale_ai.state import AgentState
+
+@tool
+def set_style(style: str):
+    """Sets the graphical style of the story."""
+    return style
+
+
+async def style_node(state: AgentState):
+    """
+    The style node is responsible for setting the graphical style of the story.
+    """
+    last_message = state["messages"][-1]
+    return {
+        "style": json.loads(last_message.content)["style"]
+    }

copilotkit-0.1.0/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.0/copilotkit/integrations/fastapi.py

@@ -0,0 +1,139 @@
+"""FastAPI integration"""
+
+from typing import List
+from fastapi import FastAPI, Request, HTTPException
+from fastapi.responses import JSONResponse, StreamingResponse
+from ..sdk import CopilotKitSDK, CopilotKitSDKContext
+from ..types import Message
+from ..exc import (
+    ActionNotFoundException,
+    ActionExecutionException,
+    AgentNotFoundException,
+    AgentExecutionException,
+)
+
+
+def add_fastapi_endpoint(fastapi_app: FastAPI, sdk: CopilotKitSDK, prefix: str):
+    """Add FastAPI endpoint"""
+    async def make_handler(request: Request):
+        return await handler(request, sdk)
+
+    # 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: CopilotKitSDK):
+    """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 = {"properties": body.get("properties", {})}
+
+    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 = 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,
+        )
+
+
+    raise HTTPException(status_code=404, detail="Not found")
+
+
+async def handle_info(*, sdk: CopilotKitSDK, context: CopilotKitSDKContext):
+    """Handle info request with FastAPI"""
+    result = sdk.info(context=context)
+    return JSONResponse(content=result)
+
+async def handle_execute_action(
+        *,
+        sdk: CopilotKitSDK,
+        context: CopilotKitSDKContext,
+        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:
+        return JSONResponse(content={"error": str(exc)}, status_code=404)
+    except ActionExecutionException as exc:
+        return JSONResponse(content={"error": str(exc)}, status_code=500)
+
+def handle_execute_agent( # pylint: disable=too-many-arguments
+        *,
+        sdk: CopilotKitSDK,
+        context: CopilotKitSDKContext,
+        thread_id: str,
+        node_name: str,
+        name: str,
+        state: dict,
+        messages: List[Message],
+        actions: List[any],
+    ):
+    """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:
+        return JSONResponse(content={"error": str(exc)}, status_code=404)
+    except AgentExecutionException as exc:
+        return JSONResponse(content={"error": str(exc)}, status_code=500)

copilotkit-0.1.0/copilotkit/langchain.py

@@ -0,0 +1,71 @@
+"""
+LangChain specific utilities for CopilotKit
+"""
+
+from typing import List, Optional
+from langchain_core.messages import (
+    HumanMessage,
+    SystemMessage,
+    BaseMessage,
+    AIMessage,
+    ToolMessage
+)
+from langchain_core.runnables import RunnableConfig
+from langchain_core.runnables.config import ensure_config
+
+from .types import Message
+def copilotkit_messages_to_langchain(messages: List[Message]) -> List[BaseMessage]:
+    """
+    Convert CopilotKit messages to LangChain messages
+    """
+    result = []
+    for message in messages:
+        if "content" in message:
+            if message["role"] == "user":
+                result.append(HumanMessage(content=message["content"], id=message["id"]))
+            elif message["role"] == "system":
+                result.append(SystemMessage(content=message["content"], id=message["id"]))
+            elif message["role"] == "assistant":
+                result.append(AIMessage(content=message["content"], id=message["id"]))
+        elif "arguments" in message:
+            tool_call = {
+                "name": message["name"],
+                "args": message["arguments"],
+                "id": message["id"],
+            }
+            result.append(AIMessage(id=message["id"], content="", tool_calls=[tool_call]))           
+        elif "actionExecutionId" in message:
+            result.append(ToolMessage(
+                id=message["id"],
+                content=message["result"],
+                name=message["actionName"],
+                tool_call_id=message["actionExecutionId"]
+            ))
+    return result
+
+def configure_copilotkit(
+        config: Optional[RunnableConfig] = None,
+        *,
+        emit_tool_calls: bool = False,
+        emit_messages: bool = False,
+        emit_all: bool = False,
+        emit_state: Optional[dict] = None
+    ):
+    """
+    Configure for LangChain for use in CopilotKit
+    """
+    tags = config.get("tags", []) if config else []
+    metadata = config.get("metadata", {}) if config else {}
+
+    if emit_tool_calls or emit_all:
+        tags.append("copilotkit:emit-tool-calls")
+    if emit_messages or emit_all:
+        tags.append("copilotkit:emit-messages")
+
+    if emit_state:
+        metadata["copilotkit:emit-state"] = emit_state
+
+    config = (config or {}).copy()
+    config["tags"] = tags
+    config["metadata"] = metadata
+    return ensure_config(config)

copilotkit-0.1.0/copilotkit/parameter.py

@@ -0,0 +1,64 @@
+"""Parameter classes for CopilotKit"""
+
+from typing import TypedDict, Optional, Literal, List
+
+class BaseParameter(TypedDict):
+    """Base parameter class"""
+    name: str
+    description: Optional[str]
+    required: Optional[bool]
+
+
+def normalize_parameters(parameters: Optional[List[BaseParameter]]) -> List[BaseParameter]:
+    """Normalize the parameters to ensure they have the correct type and format."""
+    if parameters is None:
+        return []
+    return [_normalize_parameter(parameter) for parameter in parameters]
+
+def _normalize_parameter(parameter: BaseParameter) -> BaseParameter:
+    """Normalize a parameter to ensure it has the correct type and format."""
+    if not hasattr(parameter, 'type'):
+        parameter['type'] = 'string'
+    if not hasattr(parameter, 'required'):
+        parameter['required'] = False
+    if not hasattr(parameter, 'description'):
+        parameter['description'] = ''
+    
+    if parameter['type'] == 'object' or parameter['type'] == 'object[]':
+        parameter['attributes'] = normalize_parameters(parameter.get('attributes'))
+    return parameter
+
+class StringParameter(BaseParameter):
+    """String parameter class"""
+    type: Literal["string"]
+    enum: Optional[list[str]]
+
+class NumberParameter(BaseParameter):
+    """Number parameter class"""
+    type: Literal["number"]
+
+class BooleanParameter(BaseParameter):
+    """Boolean parameter class"""
+    type: Literal["boolean"]
+
+class ObjectParameter(BaseParameter):
+    """Object parameter class"""
+    type: Literal["object"]
+    attributes: List[BaseParameter]
+
+class ObjectArrayParameter(BaseParameter):
+    """Object array parameter class"""
+    type: Literal["object[]"]
+    attributes: List[BaseParameter]
+
+class StringArrayParameter(BaseParameter):
+    """String array parameter class"""
+    type: Literal["string[]"]
+
+class NumberArrayParameter(BaseParameter):
+    """Number array parameter class"""
+    type: Literal["number[]"]
+
+class BooleanArrayParameter(BaseParameter):
+    """Boolean array parameter class"""
+    type: Literal["boolean[]"]

copilotkit-0.1.0/copilotkit/sdk.py

@@ -0,0 +1,102 @@
+"""CopilotKit SDK"""
+
+from typing import List, Callable, Union, Optional, TypedDict, Any
+from .agent import Agent
+from .action import Action
+from .types import Message
+from .exc import (
+    ActionNotFoundException,
+    AgentNotFoundException,
+    ActionExecutionException,
+    AgentExecutionException
+)
+
+
+class CopilotKitSDKContext(TypedDict):
+    """CopilotKit SDK Context"""
+    properties: Any
+
+class CopilotKitSDK:
+    """CopilotKit SDK"""
+
+    def __init__(
+        self,
+        *,
+        actions: Optional[Union[List[Action], Callable[[], List[Action]]]] = None,
+        agents: Optional[Union[List[Agent], Callable[[], List[Agent]]]] = None,
+    ):
+        self.agents = agents or []
+        self.actions = actions or []
+
+    def info(
+        self,
+        *,
+        context: CopilotKitSDKContext
+    ) -> List[Union[Action, Agent]]:
+        """Returns information about available actions and agents"""
+
+        actions = self.actions(context) if callable(self.actions) else self.actions
+        agents = self.agents(context) if callable(self.agents) else self.agents
+
+        result = {
+            "actions": [action.dict_repr() for action in actions],
+            "agents": [agent.dict_repr() for agent in agents]
+        }
+        return result
+    
+    def _get_action(
+        self,
+        *,
+        context: CopilotKitSDKContext,
+        name: str,
+    ) -> Action:
+        """Get an action by name"""
+        actions = self.actions(context) if callable(self.actions) else self.actions
+        action = next((action for action in actions if action.name == name), None)
+        if action is None:
+            raise ActionNotFoundException(name)
+        return action
+
+    def execute_action(
+            self,
+            *,
+            context: CopilotKitSDKContext,
+            name: str,
+            arguments: dict,
+    ) -> dict:
+        """Execute an action"""
+
+        action = self._get_action(context=context, name=name)
+
+        try:
+            return action.execute(arguments=arguments)
+        except Exception as error:
+            raise ActionExecutionException(name, error) from error
+
+    def execute_agent( # pylint: disable=too-many-arguments
+        self,
+        *,
+        context: CopilotKitSDKContext,
+        name: str,
+        thread_id: str,
+        node_name: str,
+        state: dict,
+        messages: List[Message],
+        actions: List[any],
+    ):
+        """Execute an agent"""
+        agents = self.agents(context) if callable(self.agents) else self.agents
+        agent = next((agent for agent in agents if agent.name == name), None)
+        if agent is None:
+            raise AgentNotFoundException(name)        
+
+        try:
+            return agent.execute(
+                thread_id=thread_id,
+                node_name=node_name,
+                state=state,
+                messages=messages,
+                actions=actions,
+            )
+        except Exception as error:
+            raise AgentExecutionException(name, error) from error

copilotkit-0.1.0/copilotkit/state.py

@@ -0,0 +1,7 @@
+"""CopilotKit state"""
+
+from typing import TypedDict, List, Any
+
+class CopilotKitState(TypedDict):
+    """CopilotKit state"""
+    actions: List[Any]

copilotkit-0.1.0/copilotkit/types.py

@@ -0,0 +1,32 @@
+"""State for CopilotKit"""
+
+from typing import TypedDict
+from enum import Enum
+
+class MessageRole(Enum):
+    """Message role"""
+    ASSISTANT = "assistant"
+    SYSTEM = "system"
+    USER = "user"
+
+class Message(TypedDict):
+    """Message"""
+    id: str
+    createdAt: str
+
+class TextMessage(Message):
+    """Text message"""
+    role: MessageRole
+    content: str
+
+class ActionExecutionMessage(Message):
+    """Action execution message"""
+    name: str
+    arguments: dict
+    scope: str
+
+class ResultMessage(Message):
+    """Result message"""
+    actionExecutionId: str
+    actionName: str
+    result: str

copilotkit-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[tool.poetry]
+name = "copilotkit"
+version = "0.1.0"
+description = "CopilotKit python SDK"
+authors = ["Markus Ecker <markus.ecker@gmail.com>"]
+license = "MIT"
+readme = "README.md"
+homepage = "https://copilotkit.ai"
+keywords = ["copilot", "copilotkit", "langgraph", "langchain", "ai", "langsmith", "langserve"]
+
+[tool.poetry.dependencies]
+python = "^3.12"
+langgraph = "^0.2.3"
+httpx = "^0.27.0"
+fastapi = "^0.111.1"
+langchain = "^0.2.12"
+langchain-openai = "^0.1.20"
+partialjson = "^0.0.8"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.scripts]
+demo = "copilotkit.demo:main"