package python sdk for PyPI

apps/python-sdk/src/rowboat/__init__.py

@@ -0,0 +1,28 @@
+from .client import Client, StatefulChat
+from .schema import (
+    ApiMessage,
+    UserMessage,
+    SystemMessage,
+    AssistantMessage,
+    AssistantMessageWithToolCalls,
+    ToolMessage,
+    ApiRequest,
+    ApiResponse
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Client",
+    "StatefulChat",
+    # Message types
+    "ApiMessage",
+    "UserMessage",
+    "SystemMessage",
+    "AssistantMessage",
+    "AssistantMessageWithToolCalls",
+    "ToolMessage",
+    # Request/Response types
+    "ApiRequest",
+    "ApiResponse",
+] 

apps/python-sdk/src/rowboat/client.py

@@ -0,0 +1,180 @@
+from typing import Dict, List, Optional, Any, Callable, Union, Tuple
+import requests
+import json
+from .schema import (
+    ApiRequest, 
+    ApiResponse, 
+    ApiMessage, 
+    ToolMessage, 
+    UserMessage, 
+    SystemMessage, 
+    AssistantMessage, 
+    AssistantMessageWithToolCalls
+)
+
+
+class Client:
+    def __init__(self, host: str, project_id: str, project_secret: str) -> None:
+        self.base_url: str = f'{host}/api/v1/{project_id}/chat'
+        self.headers: Dict[str, str] = {
+            'Content-Type': 'application/json',
+            'Authorization': f'Bearer {project_secret}'
+        }
+
+    def _call_api(
+        self, 
+        messages: List[ApiMessage],
+        state: Optional[Dict[str, Any]] = None,
+    ) -> ApiResponse:
+        request = ApiRequest(
+            messages=messages,
+            state=state
+        )
+        # print request json
+        print(request.model_dump_json())
+        response = requests.post(self.base_url, headers=self.headers, data=request.model_dump_json())
+
+        if not response.status_code == 200:
+            raise ValueError(f"Error: {response.status_code} - {response.text}")
+    
+        response_data = ApiResponse.model_validate(response.json())
+        
+        if not response_data.messages:
+            raise ValueError("No response")
+            
+        last_message = response_data.messages[-1]
+        if not isinstance(last_message, (AssistantMessage, AssistantMessageWithToolCalls)):
+            raise ValueError("Last message was not an assistant message")
+
+        return response_data
+
+    def _process_tool_calls(
+        self,
+        tool_calls: List[Any],
+        tools: Dict[str, Callable[..., str]]
+    ) -> List[ToolMessage]:
+        """Process tool calls and return a list of tool response messages"""
+        tool_messages = []
+        for tool_call in tool_calls:
+            tool_name = tool_call.function.name
+            tool_arguments = json.loads(tool_call.function.arguments)
+
+            if tool_name not in tools:
+                raise ValueError(f'Missing tool: {tool_name}')
+                
+            tool_response = tools[tool_name](**tool_arguments)
+            tool_msg = ToolMessage(
+                role='tool',
+                content=tool_response,
+                tool_call_id=tool_call.id,
+                tool_name=tool_name
+            )
+            tool_messages.append(tool_msg)
+        return tool_messages
+
+    def chat(
+        self,
+        messages: List[ApiMessage],
+        tools: Optional[Dict[str, Callable[..., str]]] = None,
+        state: Optional[Dict[str, Any]] = None,
+        max_turns: int = 3
+    ) -> Tuple[List[ApiMessage], Optional[Dict[str, Any]]]:
+        """Stateless chat method that handles a single conversation turn with multiple tool call rounds"""
+        
+        current_messages = messages
+        current_state = state
+        turns = 0
+
+        response_messages = []
+        response_state = None
+        has_tool_calls = False
+        
+        while turns < max_turns:
+            # call api
+            response_data = self._call_api(
+                messages=current_messages,
+                state=current_state
+            )
+
+            current_messages.extend(response_data.messages)
+            current_state = response_data.state
+            response_messages = response_data.messages
+            response_state = response_data.state
+
+            # Process tool calls if present and tools are provided
+            last_message = response_data.messages[-1]
+            has_tool_calls = hasattr(last_message, 'tool_calls') and last_message.tool_calls
+            if has_tool_calls:
+                tool_messages = self._process_tool_calls(last_message.tool_calls, tools)
+                current_messages.extend(tool_messages)
+            
+            # If no tool calls were made, we're done
+            if not has_tool_calls:
+                break
+                
+            turns += 1
+        
+        if turns == max_turns and has_tool_calls:
+            raise ValueError("Max turns reached")
+
+        if not last_message.agenticResponseType == 'external':
+            raise ValueError("Last message was not an external message")
+
+        return response_messages, response_state
+
+class StatefulChat:
+    """Maintains conversation state across multiple turns"""
+    
+    def __init__(
+        self,
+        client: Client,
+        tools: Optional[Dict[str, Callable[..., str]]] = None,
+        system_prompt: Optional[str] = None,
+    ) -> None:
+        self.client = client
+        self.tools = tools
+        self.messages: List[ApiMessage] = []
+        self.state: Optional[Dict[str, Any]] = None
+        
+        if system_prompt:
+            self.messages.append(SystemMessage(role='system', content=system_prompt))
+
+    def run(self, message: Union[str]) -> str:
+        """Handle a single user turn in the conversation"""
+        
+        # Process the message
+        user_msg = UserMessage(role='user', content=message)
+        self.messages.append(user_msg)
+
+        # Get response using the client's chat method
+        new_messages, new_state = self.client.chat(
+            messages=self.messages,
+            tools=self.tools,
+            state=self.state
+        )
+        
+        # Update internal state
+        self.messages = new_messages
+        self.state = new_state
+        
+        # Return only the final message content
+        last_message = new_messages[-1]
+        return last_message.content
+
+
+def weather_lookup_tool(city_name: str) -> str:
+    return f"The weather in {city_name} is 22°C."
+
+
+if __name__ == "__main__":
+    host: str = "<HOST>"
+    project_id: str = "<PROJECT_ID>"
+    project_secret: str = "<PROJECT_SECRET>"
+    client = Client(host, project_id, project_secret)
+
+    tools: Dict[str, Callable[..., str]] = {
+        'weather_lookup': weather_lookup_tool
+    }
+    chat_session = StatefulChat(client, tools)
+    resp = chat_session.run("whats the weather in london?")
+    print(resp)

apps/python-sdk/src/rowboat/schema.py

@@ -0,0 +1,54 @@
+from typing import List, Optional, Union, Any, Literal
+from pydantic import BaseModel
+
+class SystemMessage(BaseModel):
+    role: Literal['system']
+    content: str
+
+class UserMessage(BaseModel):
+    role: Literal['user']
+    content: str
+
+class AssistantMessage(BaseModel):
+    role: Literal['assistant']
+    content: str
+    agenticSender: Optional[str] = None
+    agenticResponseType: Literal['internal', 'external']
+
+class FunctionCall(BaseModel):
+    name: str
+    arguments: str
+
+class ToolCall(BaseModel):
+    id: str
+    type: Literal['function']
+    function: FunctionCall
+
+class AssistantMessageWithToolCalls(BaseModel):
+    role: Literal['assistant']
+    content: Optional[str] = None
+    tool_calls: List[ToolCall]
+    agenticSender: Optional[str] = None
+    agenticResponseType: Literal['internal', 'external']
+
+class ToolMessage(BaseModel):
+    role: Literal['tool']
+    content: str
+    tool_call_id: str
+    tool_name: str
+
+ApiMessage = Union[
+    SystemMessage,
+    UserMessage,
+    AssistantMessage,
+    AssistantMessageWithToolCalls,
+    ToolMessage
+]
+
+class ApiRequest(BaseModel):
+    messages: List[ApiMessage]
+    state: Any
+
+class ApiResponse(BaseModel):
+    messages: List[ApiMessage]
+    state: Any