conversimple-sdk 0.2.3__tar.gz → 0.2.4__tar.gz

{conversimple_sdk-0.2.3 → conversimple_sdk-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conversimple-sdk
-Version: 0.2.3
+Version: 0.2.4
 Summary: Python SDK for Conversimple Conversational AI Platform
 Home-page: https://github.com/conversimple/conversimple-sdk
 Author: Conversimple
@@ -16,14 +16,11 @@ Classifier: Topic :: Communications :: Chat
 Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-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-Python: >=3.8
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-License-File: LICENSE
 Requires-Dist: websockets>=12.0
 Requires-Dist: aiofiles>=23.0
 Requires-Dist: aiohttp>=3.8.0
@@ -45,7 +42,6 @@ Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: keywords
-Dynamic: license-file
 Dynamic: project-url
 Dynamic: provides-extra
 Dynamic: requires-dist
@@ -96,7 +92,7 @@ class MyAgent(ConversimpleAgent):
 Use the dispatcher to discover your agent modules and launch per-conversation instances automatically:
 
 ```bash
-python -m conversimple.dispatcher \
+conversimple-dispatcher \
   --api-key "$CONVERSIMPLE_API_KEY" \
   --platform-url "$CONVERSIMPLE_PLATFORM_URL" \
   --search-path ./agents
@@ -224,7 +220,7 @@ class BillingAgent(ConversimpleAgent):
 Point the dispatcher at a directory of agent modules (typically your project root):
 
 ```bash
-python -m conversimple.dispatcher --api-key "$CONVERSIMPLE_API_KEY" \
+conversimple-dispatcher --api-key "$CONVERSIMPLE_API_KEY" \
   --platform-url "$CONVERSIMPLE_PLATFORM_URL" \
   --search-path ./agents
 ```
@@ -251,6 +247,15 @@ class BusinessAgent(ConversimpleAgent):
         return {"sent": True, "message_id": result.id}
 ```
 
+The 0.2.4 source re-registers conversation tools after a WebSocket reconnect.
+Tool calls run independently of the receive loop, so one slow call does not
+block the next message. A repeated call ID returns its previous result without
+re-executing the function; the cache is bounded to 1,024 results per agent
+process. Tool execution has a default 30-second timeout, capped at five
+minutes. Synchronous functions run in a worker thread, so a timed-out function
+may finish its side effect after the timeout response; design externally
+mutating tools to be idempotent. Python 3.10 or newer is required.
+
 ### Event Callbacks
 
 Handle conversation lifecycle events:
@@ -353,7 +358,7 @@ Configuration is loaded in this order (first match wins):
 **Remote Platform Configuration:**
 ```bash
 export CONVERSIMPLE_API_ENDPOINT="https://api.conversimple.com"
-export CONVERSIMPLE_PLATFORM_URL="wss://api.conversimple.com/sdk/websocket"
+export CONVERSIMPLE_PLATFORM_URL="wss://app.conversimple.com/customer_sdk/websocket"
 export CONVERSIMPLE_API_KEY="prod-api-key"
 export CONVERSIMPLE_ENABLE_CIRCUIT_BREAKER="true"
 ```
@@ -467,7 +472,7 @@ agent = ConversimpleAgent(
 Example agents live in `examples/` and are discovered automatically when you point the dispatcher at that directory:
 
 ```bash
-python -m conversimple.dispatcher \
+conversimple-dispatcher \
   --api-key "$CONVERSIMPLE_API_KEY" \
   --platform-url "$CONVERSIMPLE_PLATFORM_URL" \
   --search-path ./examples

{conversimple_sdk-0.2.3 → conversimple_sdk-0.2.4}/README.md

@@ -42,7 +42,7 @@ class MyAgent(ConversimpleAgent):
 Use the dispatcher to discover your agent modules and launch per-conversation instances automatically:
 
 ```bash
-python -m conversimple.dispatcher \
+conversimple-dispatcher \
   --api-key "$CONVERSIMPLE_API_KEY" \
   --platform-url "$CONVERSIMPLE_PLATFORM_URL" \
   --search-path ./agents
@@ -170,7 +170,7 @@ class BillingAgent(ConversimpleAgent):
 Point the dispatcher at a directory of agent modules (typically your project root):
 
 ```bash
-python -m conversimple.dispatcher --api-key "$CONVERSIMPLE_API_KEY" \
+conversimple-dispatcher --api-key "$CONVERSIMPLE_API_KEY" \
   --platform-url "$CONVERSIMPLE_PLATFORM_URL" \
   --search-path ./agents
 ```
@@ -197,6 +197,15 @@ class BusinessAgent(ConversimpleAgent):
         return {"sent": True, "message_id": result.id}
 ```
 
+The 0.2.4 source re-registers conversation tools after a WebSocket reconnect.
+Tool calls run independently of the receive loop, so one slow call does not
+block the next message. A repeated call ID returns its previous result without
+re-executing the function; the cache is bounded to 1,024 results per agent
+process. Tool execution has a default 30-second timeout, capped at five
+minutes. Synchronous functions run in a worker thread, so a timed-out function
+may finish its side effect after the timeout response; design externally
+mutating tools to be idempotent. Python 3.10 or newer is required.
+
 ### Event Callbacks
 
 Handle conversation lifecycle events:
@@ -299,7 +308,7 @@ Configuration is loaded in this order (first match wins):
 **Remote Platform Configuration:**
 ```bash
 export CONVERSIMPLE_API_ENDPOINT="https://api.conversimple.com"
-export CONVERSIMPLE_PLATFORM_URL="wss://api.conversimple.com/sdk/websocket"
+export CONVERSIMPLE_PLATFORM_URL="wss://app.conversimple.com/customer_sdk/websocket"
 export CONVERSIMPLE_API_KEY="prod-api-key"
 export CONVERSIMPLE_ENABLE_CIRCUIT_BREAKER="true"
 ```
@@ -413,7 +422,7 @@ agent = ConversimpleAgent(
 Example agents live in `examples/` and are discovered automatically when you point the dispatcher at that directory:
 
 ```bash
-python -m conversimple.dispatcher \
+conversimple-dispatcher \
   --api-key "$CONVERSIMPLE_API_KEY" \
   --platform-url "$CONVERSIMPLE_PLATFORM_URL" \
   --search-path ./examples

{conversimple_sdk-0.2.3 → conversimple_sdk-0.2.4}/conversimple/agent.py

@@ -13,6 +13,7 @@ import json
 import logging
 import os
 import uuid
+from collections import OrderedDict
 from typing import Dict, List, Optional, Callable, Any, Union
 from datetime import datetime
 import datetime as dt
@@ -107,7 +108,11 @@ class ConversimpleAgent:
         self.conversation_id: Optional[str] = None
         self.connection_state = "disconnected"
         self.registered_tools: List[Dict] = []
+        self.registered_conversations = set()
+        self.ended_conversations = set()
         self.pending_tool_calls: Dict[str, ToolCall] = {}
+        self._tool_tasks: Dict[str, asyncio.Task] = {}
+        self._completed_tool_results = OrderedDict()
         
         # Event callbacks
         self.callbacks: Dict[str, Callable] = {}
@@ -139,14 +144,17 @@ class ConversimpleAgent:
         
         # Connect to platform
         await self.connection.connect()
+        if not self.connection.connected or not self.connection.channel_joined:
+            raise RuntimeError("SDK channel did not connect")
         self.connection_state = "connected"
         
         # Auto-register tools from decorated methods
         auto_register_tools(self)
         
-        # Store tools for later registration when real conversations start
-        # Don't register immediately since we don't have a real conversation ID yet
+        # A dispatcher already knows the real conversation ID at startup.
         await self._register_tools()
+        if conversation_id and self.registered_tools:
+            await self._register_conversation_tools(conversation_id, self.registered_tools)
         
         logger.info(f"Agent started successfully for conversation: {self.conversation_id}")
 
@@ -155,11 +163,16 @@ class ConversimpleAgent:
         logger.info(f"Stopping agent for conversation: {self.conversation_id}")
         
         self.connection_state = "disconnecting"
+        for task in self._tool_tasks.values():
+            task.cancel()
+        if self._tool_tasks:
+            await asyncio.gather(*self._tool_tasks.values(), return_exceptions=True)
+        self._tool_tasks.clear()
         await self.connection.disconnect()
         self.connection_state = "disconnected"
         
         # Trigger conversation ended callback
-        await self.callback_manager.trigger_conversation_ended(self.conversation_id)
+        await self._notify_conversation_ended(self.conversation_id)
 
     async def _register_tools(self) -> None:
         """Store discovered tools for registration when conversations start."""
@@ -174,12 +187,15 @@ class ConversimpleAgent:
 
     async def _register_conversation_tools(self, conversation_id: str, tools: list) -> None:
         """Register tools for a specific conversation."""
+        if conversation_id in self.registered_conversations:
+            return
         message = {
             "conversation_id": conversation_id,
             "tools": tools
         }
         
         await self.connection.send_message("register_conversation_tools", message)
+        self.registered_conversations.add(conversation_id)
         logger.info(f"Registered {len(tools)} tools for conversation {conversation_id}")
 
     async def _handle_platform_message(self, event: str, payload: Dict) -> None:
@@ -197,6 +213,19 @@ class ConversimpleAgent:
             "conversation_ready": self._handle_conversation_ready
         }
         
+        if event == "tool_call_request":
+            call_id = payload.get("call_id")
+            if call_id in self._tool_tasks:
+                logger.info("Ignoring duplicate in-flight tool call: %s", call_id)
+                return
+            task = asyncio.create_task(self._handle_tool_call_request(payload))
+            if call_id:
+                self._tool_tasks[call_id] = task
+                task.add_done_callback(
+                    lambda done, key=call_id: self._finish_tool_task(key, done)
+                )
+            return
+
         handler = handlers.get(event)
         if handler:
             try:
@@ -256,6 +285,17 @@ class ConversimpleAgent:
         if not call_id or not tool_name:
             await self._send_tool_error(call_id or "unknown", "Missing call_id or tool_name")
             return
+
+        if call_id in self._completed_tool_results:
+            event, response = self._completed_tool_results[call_id]
+            await self.connection.send_message(event, response)
+            return
+
+        timeout = payload.get("timeout_seconds", 30)
+        try:
+            timeout = max(0.1, min(float(timeout), 300.0))
+        except (TypeError, ValueError):
+            timeout = 30.0
             
         # Create tool call object
         tool_call = ToolCall(
@@ -263,7 +303,7 @@ class ConversimpleAgent:
             tool_name=tool_name,
             arguments=arguments,
             conversation_id=self.conversation_id,
-            timeout_seconds=payload.get("timeout_seconds", 30)
+            timeout_seconds=timeout
         )
         
         # Store as pending
@@ -274,21 +314,55 @@ class ConversimpleAgent:
         
         try:
             # Execute the tool
-            result = await self.tool_registry.execute_tool(tool_name, arguments)
+            result = await asyncio.wait_for(
+                self.tool_registry.execute_tool(tool_name, arguments), timeout=timeout
+            )
             
             # Send successful result
-            await self._send_tool_result(call_id, result)
+            response = {
+                "call_id": call_id,
+                "conversation_id": self.conversation_id,
+                "result": result,
+                "tool_name": tool_name,
+            }
+            self._remember_tool_result(call_id, "tool_call_response", response)
+            await self._send_tool_result(call_id, result, tool_name)
             
             # Trigger completion callback
             await self.callback_manager.trigger_tool_completed(call_id, result)
             
+        except asyncio.CancelledError:
+            raise
         except Exception as e:
             logger.error(f"Tool execution failed for {tool_name}: {e}")
-            await self._send_tool_error(call_id, str(e))
+            response = {
+                "call_id": call_id,
+                "conversation_id": self.conversation_id,
+                "error": {
+                    "message": "Tool execution timed out" if isinstance(e, TimeoutError) else str(e),
+                    "timestamp": datetime.now(dt.timezone.utc).isoformat(),
+                },
+                "tool_name": tool_name,
+            }
+            self._remember_tool_result(call_id, "tool_call_error", response)
+            await self._send_tool_error(call_id, response["error"]["message"], tool_name)
         finally:
             # Clean up pending call
             self.pending_tool_calls.pop(call_id, None)
 
+    def _remember_tool_result(self, call_id: str, event: str, payload: Dict) -> None:
+        self._completed_tool_results[call_id] = (event, payload)
+        self._completed_tool_results.move_to_end(call_id)
+        if len(self._completed_tool_results) > 1024:
+            self._completed_tool_results.popitem(last=False)
+
+    def _finish_tool_task(self, call_id: str, task: asyncio.Task) -> None:
+        self._tool_tasks.pop(call_id, None)
+        if not task.cancelled():
+            error = task.exception()
+            if error:
+                logger.error("Tool call %s could not deliver its result: %s", call_id, error)
+
     async def _handle_conversation_lifecycle(self, payload: Dict) -> None:
         """Handle conversation lifecycle events."""
         event = payload.get("event")
@@ -312,10 +386,15 @@ class ConversimpleAgent:
             await self.callback_manager.trigger_conversation_started(conversation_id, payload)
         elif event == "conversation_ended":
             logger.info(f"🏁 Conversation ended: {conversation_id}")
-            await self.callback_manager.trigger_conversation_ended(conversation_id, payload)
+            await self._notify_conversation_ended(conversation_id, payload)
         else:
             logger.warning(f"❓ Unknown lifecycle event: {event}")
 
+    async def _notify_conversation_ended(self, conversation_id: str, payload: Optional[Dict] = None) -> None:
+        if conversation_id and conversation_id not in self.ended_conversations:
+            self.ended_conversations.add(conversation_id)
+            await self.callback_manager.trigger_conversation_ended(conversation_id, payload)
+
     async def _handle_hook_event(self, payload: Dict) -> None:
         """Handle hook events from platform."""
         event_type = payload.get("event_type")
@@ -344,6 +423,12 @@ class ConversimpleAgent:
         if event == "connected":
             self.connection_state = "connected"
             logger.info("✅ Connection established successfully")
+            # A new channel process does not retain per-conversation tools.
+            # The first connect has no discovered tools yet; later connects do.
+            if self.registered_tools:
+                for conversation_id in list(self.registered_conversations):
+                    self.registered_conversations.discard(conversation_id)
+                    await self._register_conversation_tools(conversation_id, self.registered_tools)
 
         elif event == "disconnected":
             self.connection_state = "disconnected"
@@ -375,25 +460,31 @@ class ConversimpleAgent:
             logger.error(f"❌ Connection error (retrying): {data}")
             logger.info("🔄 Automatic reconnection will be attempted")
 
-    async def _send_tool_result(self, call_id: str, result: Any) -> None:
+    async def _send_tool_result(self, call_id: str, result: Any, tool_name: Optional[str] = None) -> None:
         """Send tool execution result to platform."""
         message = {
             "call_id": call_id,
+            "conversation_id": self.conversation_id,
             "result": result
         }
+        if tool_name:
+            message["tool_name"] = tool_name
         
         await self.connection.send_message("tool_call_response", message)
         logger.debug(f"Sent tool result for call: {call_id}")
 
-    async def _send_tool_error(self, call_id: str, error: str) -> None:
+    async def _send_tool_error(self, call_id: str, error: str, tool_name: Optional[str] = None) -> None:
         """Send tool execution error to platform."""
         message = {
             "call_id": call_id,
+            "conversation_id": self.conversation_id,
             "error": {
                 "message": error,
                 "timestamp": datetime.now(dt.timezone.utc).isoformat()
             }
         }
+        if tool_name:
+            message["tool_name"] = tool_name
         
         await self.connection.send_message("tool_call_error", message)
         logger.debug(f"Sent tool error for call: {call_id}")
@@ -426,4 +517,4 @@ class ConversimpleAgent:
 
     def on_config_update(self, callback: Callable[[Dict], None]) -> None:
         """Register callback for configuration updates."""
-        self.callback_manager.on_config_update = callback
+        self.callback_manager.on_config_update = callback

{conversimple_sdk-0.2.3 → conversimple_sdk-0.2.4}/conversimple/config.py

@@ -17,7 +17,7 @@ class Config:
     # Platform WebSocket Configuration
     PLATFORM_URL: str = os.getenv(
         "CONVERSIMPLE_PLATFORM_URL",
-        "wss://api.conversimple.com/sdk/websocket"
+        "wss://app.conversimple.com/customer_sdk/websocket"
     )
     """Platform WebSocket URL for agent communication."""
 

{conversimple_sdk-0.2.3 → conversimple_sdk-0.2.4}/conversimple/connection.py

@@ -111,7 +111,7 @@ class WebSocketConnection:
         """Set handler for connection events."""
         self.connection_handler = handler
 
-    async def connect(self) -> None:
+    async def connect(self, recover: bool = True) -> None:
         """Connect to the platform WebSocket."""
         connection_params = {
             "customer_id": self.customer_id,
@@ -146,7 +146,15 @@ class WebSocketConnection:
                 
         except Exception as e:
             logger.error(f"Failed to connect to platform: {e}")
-            await self._handle_connection_error(e)
+            self.connected = False
+            self.channel_joined = False
+            if self.websocket:
+                await self.websocket.close()
+                self.websocket = None
+            if recover:
+                await self._handle_connection_error(e)
+            else:
+                raise
 
     async def disconnect(self) -> None:
         """Disconnect from the platform."""
@@ -248,19 +256,24 @@ class WebSocketConnection:
 
     async def _stop_background_tasks(self) -> None:
         """Stop background tasks."""
+        current_task = asyncio.current_task()
         if self.heartbeat_task:
-            self.heartbeat_task.cancel()
-            try:
-                await self.heartbeat_task
-            except asyncio.CancelledError:
-                pass
-                
+            if self.heartbeat_task is not current_task:
+                self.heartbeat_task.cancel()
+                try:
+                    await self.heartbeat_task
+                except asyncio.CancelledError:
+                    pass
+            self.heartbeat_task = None
+
         if self.message_task:
-            self.message_task.cancel()
-            try:
-                await self.message_task
-            except asyncio.CancelledError:
-                pass
+            if self.message_task is not current_task:
+                self.message_task.cancel()
+                try:
+                    await self.message_task
+                except asyncio.CancelledError:
+                    pass
+            self.message_task = None
 
     async def _heartbeat_loop(self) -> None:
         """Send periodic heartbeat messages to platform."""
@@ -284,8 +297,10 @@ class WebSocketConnection:
                 message = await self.websocket.recv()
                 await self._handle_message(message)
                 
-            except (ConnectionClosedError, ConnectionClosedOK):
-                logger.info("WebSocket connection closed")
+            except (ConnectionClosedError, ConnectionClosedOK) as error:
+                logger.warning("WebSocket connection closed: %s", error)
+                if self.connected:
+                    await self._handle_connection_error(error)
                 break
             except asyncio.CancelledError:
                 break
@@ -415,7 +430,9 @@ class WebSocketConnection:
             return
 
         try:
-            await self.connect()
+            await self.connect(recover=False)
+            if not self.connected or not self.channel_joined:
+                raise TransientConnectionError("SDK channel did not reconnect")
             # Reset retry state on successful connection
             self.reconnect_attempts = 0
             self.first_retry_time = None
@@ -543,4 +560,4 @@ class WebSocketConnection:
         jitter = backoff * 0.2 * (random.random() * 2 - 1)
         backoff = backoff + jitter
 
-        return max(1.0, backoff)  # Ensure minimum 1 second
+        return max(1.0, backoff)  # Ensure minimum 1 second

{conversimple_sdk-0.2.3 → conversimple_sdk-0.2.4}/conversimple/dispatcher.py

@@ -9,10 +9,12 @@ inherit from `ConversimpleAgent` and expose an `agent_id` attribute.
 """
 
 import asyncio
+import argparse
 import contextlib
 import importlib.util
 import inspect
 import logging
+import os
 import sys
 from dataclasses import dataclass
 from pathlib import Path
@@ -320,3 +322,23 @@ async def run_dispatcher(api_key: str, platform_url: str, search_path: Optional[
         logger.info("Keyboard interrupt received, stopping dispatcher")
     finally:
         await dispatcher.stop()
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Run a Conversimple SDK dispatcher")
+    parser.add_argument("--api-key", default=os.getenv("CONVERSIMPLE_API_KEY"))
+    parser.add_argument("--platform-url", default=Config.PLATFORM_URL)
+    parser.add_argument("--search-path", type=Path, default=Path.cwd())
+    args = parser.parse_args()
+    if not args.api_key:
+        parser.error("provide --api-key or set CONVERSIMPLE_API_KEY")
+
+    logging.basicConfig(level=logging.INFO)
+    try:
+        asyncio.run(run_dispatcher(args.api_key, args.platform_url, args.search_path))
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == "__main__":
+    main()

{conversimple_sdk-0.2.3 → conversimple_sdk-0.2.4}/conversimple/tools.py

@@ -98,7 +98,7 @@ class ToolRegistry:
             
             try:
                 # Execute synchronous function
-                result = func(**arguments)
+                result = await asyncio.to_thread(func, **arguments)
                 logger.debug(f"Sync tool {tool_name} executed successfully")
                 return result
                 
@@ -310,4 +310,4 @@ def auto_register_tools(agent_instance: Any) -> None:
         else:
             logger.warning(f"Unknown tool type: {tool_type}")
 
-    logger.info(f"Auto-registered {len(discovered_tools)} tools")
+    logger.info(f"Auto-registered {len(discovered_tools)} tools")

{conversimple_sdk-0.2.3 → conversimple_sdk-0.2.4}/conversimple_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conversimple-sdk
-Version: 0.2.3
+Version: 0.2.4
 Summary: Python SDK for Conversimple Conversational AI Platform
 Home-page: https://github.com/conversimple/conversimple-sdk
 Author: Conversimple
@@ -16,14 +16,11 @@ Classifier: Topic :: Communications :: Chat
 Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-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-Python: >=3.8
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-License-File: LICENSE
 Requires-Dist: websockets>=12.0
 Requires-Dist: aiofiles>=23.0
 Requires-Dist: aiohttp>=3.8.0
@@ -45,7 +42,6 @@ Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: keywords
-Dynamic: license-file
 Dynamic: project-url
 Dynamic: provides-extra
 Dynamic: requires-dist
@@ -96,7 +92,7 @@ class MyAgent(ConversimpleAgent):
 Use the dispatcher to discover your agent modules and launch per-conversation instances automatically:
 
 ```bash
-python -m conversimple.dispatcher \
+conversimple-dispatcher \
   --api-key "$CONVERSIMPLE_API_KEY" \
   --platform-url "$CONVERSIMPLE_PLATFORM_URL" \
   --search-path ./agents
@@ -224,7 +220,7 @@ class BillingAgent(ConversimpleAgent):
 Point the dispatcher at a directory of agent modules (typically your project root):
 
 ```bash
-python -m conversimple.dispatcher --api-key "$CONVERSIMPLE_API_KEY" \
+conversimple-dispatcher --api-key "$CONVERSIMPLE_API_KEY" \
   --platform-url "$CONVERSIMPLE_PLATFORM_URL" \
   --search-path ./agents
 ```
@@ -251,6 +247,15 @@ class BusinessAgent(ConversimpleAgent):
         return {"sent": True, "message_id": result.id}
 ```
 
+The 0.2.4 source re-registers conversation tools after a WebSocket reconnect.
+Tool calls run independently of the receive loop, so one slow call does not
+block the next message. A repeated call ID returns its previous result without
+re-executing the function; the cache is bounded to 1,024 results per agent
+process. Tool execution has a default 30-second timeout, capped at five
+minutes. Synchronous functions run in a worker thread, so a timed-out function
+may finish its side effect after the timeout response; design externally
+mutating tools to be idempotent. Python 3.10 or newer is required.
+
 ### Event Callbacks
 
 Handle conversation lifecycle events:
@@ -353,7 +358,7 @@ Configuration is loaded in this order (first match wins):
 **Remote Platform Configuration:**
 ```bash
 export CONVERSIMPLE_API_ENDPOINT="https://api.conversimple.com"
-export CONVERSIMPLE_PLATFORM_URL="wss://api.conversimple.com/sdk/websocket"
+export CONVERSIMPLE_PLATFORM_URL="wss://app.conversimple.com/customer_sdk/websocket"
 export CONVERSIMPLE_API_KEY="prod-api-key"
 export CONVERSIMPLE_ENABLE_CIRCUIT_BREAKER="true"
 ```
@@ -467,7 +472,7 @@ agent = ConversimpleAgent(
 Example agents live in `examples/` and are discovered automatically when you point the dispatcher at that directory:
 
 ```bash
-python -m conversimple.dispatcher \
+conversimple-dispatcher \
   --api-key "$CONVERSIMPLE_API_KEY" \
   --platform-url "$CONVERSIMPLE_PLATFORM_URL" \
   --search-path ./examples

{conversimple_sdk-0.2.3 → conversimple_sdk-0.2.4}/conversimple_sdk.egg-info/SOURCES.txt

@@ -1,5 +1,5 @@
-LICENSE
 README.md
+setup.cfg
 setup.py
 conversimple/__init__.py
 conversimple/agent.py
@@ -24,4 +24,4 @@ conversimple_sdk.egg-info/entry_points.txt
 conversimple_sdk.egg-info/not-zip-safe
 conversimple_sdk.egg-info/requires.txt
 conversimple_sdk.egg-info/top_level.txt
-tests/test_platform_api_client.py
+tests/test_dispatcher_session.py

{conversimple_sdk-0.2.3 → conversimple_sdk-0.2.4}/conversimple_sdk.egg-info/entry_points.txt

@@ -1,2 +1,3 @@
 [console_scripts]
+conversimple-dispatcher = conversimple.dispatcher:main
 conversimple-example = examples.simple_agent:main

{conversimple_sdk-0.2.3 → conversimple_sdk-0.2.4}/setup.py

@@ -16,7 +16,7 @@ except FileNotFoundError:
 
 setup(
     name="conversimple-sdk",
-    version="0.2.3",  # Enhanced added API client
+    version="0.2.4",
     author="Conversimple",
     author_email="support@conversimple.com",
     description="Python SDK for Conversimple Conversational AI Platform",
@@ -36,14 +36,12 @@ setup(
         "Topic :: Internet :: WWW/HTTP :: Dynamic Content",
         "License :: OSI Approved :: MIT License",
         "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.8",
-        "Programming Language :: Python :: 3.9",
         "Programming Language :: Python :: 3.10",
         "Programming Language :: Python :: 3.11",
         "Programming Language :: Python :: 3.12",
     ],
     packages=find_packages(),
-    python_requires=">=3.8",
+    python_requires=">=3.10",
     install_requires=[
         "websockets>=12.0",
         "aiofiles>=23.0",
@@ -66,6 +64,7 @@ setup(
     },
     entry_points={
         "console_scripts": [
+            "conversimple-dispatcher=conversimple.dispatcher:main",
             "conversimple-example=examples.simple_agent:main",
         ],
     },

conversimple_sdk-0.2.4/tests/test_dispatcher_session.py

@@ -0,0 +1,120 @@
+import unittest
+import asyncio
+
+from conversimple import ConversimpleAgent, tool, tool_async
+
+
+class DemoAgent(ConversimpleAgent):
+    @tool("Return a sample answer")
+    def sample(self):
+        self.sample_calls = getattr(self, "sample_calls", 0) + 1
+        return {"answer": "ok"}
+
+    @tool_async("Wait longer than the tool deadline")
+    async def stall(self):
+        await asyncio.sleep(1)
+        return {"answer": "late"}
+
+
+class FakeConnection:
+    def __init__(self):
+        self.messages = []
+        self.connected = False
+        self.channel_joined = False
+
+    def set_message_handler(self, handler):
+        self.message_handler = handler
+
+    def set_connection_handler(self, handler):
+        self.connection_handler = handler
+
+    async def connect(self):
+        self.connected = True
+        self.channel_joined = True
+
+    async def send_message(self, event, payload):
+        self.messages.append((event, payload))
+
+    async def disconnect(self):
+        self.connected = False
+        self.channel_joined = False
+
+
+class DispatcherSessionTest(unittest.IsolatedAsyncioTestCase):
+    async def test_slow_tool_does_not_block_other_calls_and_duplicate_is_idempotent(self):
+        agent = DemoAgent(api_key="test-key")
+        agent.connection = FakeConnection()
+        await agent.start(conversation_id="conversation-123")
+
+        await agent._handle_platform_message(
+            "tool_call_request",
+            {"call_id": "slow", "tool_name": "stall", "arguments": {}, "timeout_seconds": 0.1},
+        )
+        await agent._handle_platform_message(
+            "tool_call_request",
+            {"call_id": "fast", "tool_name": "sample", "arguments": {}},
+        )
+
+        async def wait_for_messages(count):
+            while len([event for event, _ in agent.connection.messages if event.startswith("tool_call_")]) < count:
+                await asyncio.sleep(0.01)
+
+        await asyncio.wait_for(wait_for_messages(2), timeout=2)
+        calls = [(event, payload) for event, payload in agent.connection.messages if event.startswith("tool_call_")]
+        self.assertEqual(calls[0][0], "tool_call_response")
+        self.assertEqual(calls[0][1]["call_id"], "fast")
+        self.assertEqual(calls[1][0], "tool_call_error")
+        self.assertEqual(calls[1][1]["error"]["message"], "Tool execution timed out")
+
+        await agent._handle_platform_message(
+            "tool_call_request",
+            {"call_id": "fast", "tool_name": "sample", "arguments": {}},
+        )
+        await asyncio.wait_for(wait_for_messages(3), timeout=2)
+        self.assertEqual(agent.sample_calls, 1)
+        self.assertEqual(calls[0][1], agent.connection.messages[-1][1])
+        await agent.stop()
+
+    async def test_registers_tools_for_dispatcher_session_before_lifecycle_event(self):
+        agent = DemoAgent(api_key="test-key")
+        agent.connection = FakeConnection()
+
+        await agent.start(conversation_id="conversation-123")
+        await agent._handle_conversation_lifecycle(
+            {"event": "conversation_started", "conversation_id": "conversation-123"}
+        )
+
+        registrations = [
+            payload
+            for event, payload in agent.connection.messages
+            if event == "register_conversation_tools"
+        ]
+        self.assertEqual(len(registrations), 1)
+        self.assertEqual(registrations[0]["conversation_id"], "conversation-123")
+        self.assertEqual(registrations[0]["tools"][0]["name"], "sample")
+
+        await agent._send_tool_result("call-123", {"answer": "ok"})
+        self.assertEqual(
+            agent.connection.messages[-1],
+            (
+                "tool_call_response",
+                {
+                    "call_id": "call-123",
+                    "conversation_id": "conversation-123",
+                    "result": {"answer": "ok"},
+                },
+            ),
+        )
+
+        await agent._handle_tool_call_request(
+            {"call_id": "call-456", "tool_name": "sample", "arguments": {}}
+        )
+        self.assertEqual(agent.connection.messages[-1][1]["tool_name"], "sample")
+
+        ended = []
+        agent.on_conversation_ended(ended.append)
+        await agent._handle_conversation_lifecycle(
+            {"event": "conversation_ended", "conversation_id": "conversation-123"}
+        )
+        await agent.stop()
+        self.assertEqual(ended, ["conversation-123"])

conversimple_sdk-0.2.3/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2025-present, Syed Aqueel Haider and ConverSimple
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

conversimple_sdk-0.2.3/tests/test_platform_api_client.py

@@ -1,460 +0,0 @@
-"""Tests for Conversimple Platform API Client."""
-
-import json
-from datetime import datetime
-
-import pytest
-import responses
-
-from conversimple import (
-    PlatformClient,
-    Agent,
-    Deployment,
-    ApiKeyInfo,
-    ApiKeyUsage,
-    APIError,
-    ValidationError,
-    NotFoundError,
-    UnauthorizedError,
-    ForbiddenError,
-)
-from conversimple.config import Config
-
-# Use Config defaults for all test URLs
-BASE_URL = Config.API_ENDPOINT
-
-
-class TestPlatformClientInitialization:
-    """Test PlatformClient initialization."""
-
-    def test_init_with_defaults(self):
-        """Test initialization with default parameters."""
-        client = PlatformClient(api_key="test-key")
-        assert client._http_client.api_key == "test-key"
-        assert client._http_client.api_endpoint == Config.API_ENDPOINT
-        assert client._http_client.timeout == 30
-
-    def test_init_with_custom_endpoint(self):
-        """Test initialization with custom endpoint."""
-        client = PlatformClient(
-            api_key="test-key",
-            api_endpoint="https://api.dev.conversimple.com"
-        )
-        assert client._http_client.api_endpoint == "https://api.dev.conversimple.com"
-
-    def test_init_with_trailing_slash(self):
-        """Test that trailing slash is stripped from endpoint."""
-        client = PlatformClient(
-            api_key="test-key",
-            api_endpoint=f"{Config.API_ENDPOINT}/"
-        )
-        assert client._http_client.api_endpoint == Config.API_ENDPOINT
-
-    def test_endpoints_are_accessible(self):
-        """Test that all endpoints are accessible."""
-        client = PlatformClient(api_key="test-key")
-        assert hasattr(client, "agents")
-        assert hasattr(client, "deployments")
-        assert hasattr(client, "api_keys")
-
-
-class TestHTTPClientHeaders:
-    """Test HTTP client header management."""
-
-    def test_auth_header_format(self):
-        """Test that auth header is properly formatted."""
-        client = PlatformClient(api_key="my-secret-key")
-        headers = client._http_client._get_headers()
-        assert headers["Authorization"] == "Bearer my-secret-key"
-
-    def test_content_type_header(self):
-        """Test content type header is set."""
-        client = PlatformClient(api_key="test-key")
-        headers = client._http_client._get_headers()
-        assert headers["Content-Type"] == "application/json"
-
-    def test_user_agent_header(self):
-        """Test user agent header includes version."""
-        client = PlatformClient(api_key="test-key")
-        headers = client._http_client._get_headers()
-        assert "conversimple-sdk" in headers["User-Agent"]
-
-
-class TestExceptionHandling:
-    """Test exception handling for different HTTP status codes."""
-
-    @responses.activate
-    def test_422_validation_error(self):
-        """Test that 422 status raises ValidationError."""
-        responses.add(
-            responses.GET,
-            f"{BASE_URL}/api/v1/agents",
-            json={
-                "message": "Validation failed",
-                "errors": {"name": "Name is required"}
-            },
-            status=422,
-        )
-
-        client = PlatformClient(api_key="test-key")
-
-        with pytest.raises(ValidationError) as exc_info:
-            client._http_client.get("/api/v1/agents")
-
-        assert exc_info.value.status_code == 422
-        assert exc_info.value.errors == {"name": "Name is required"}
-
-    @responses.activate
-    def test_404_not_found_error(self):
-        """Test that 404 status raises NotFoundError."""
-        responses.add(
-            responses.GET,
-            f"{BASE_URL}/api/v1/agents/123",
-            json={"message": "Agent not found"},
-            status=404,
-        )
-
-        client = PlatformClient(api_key="test-key")
-
-        with pytest.raises(NotFoundError) as exc_info:
-            client._http_client.get("/api/v1/agents/123")
-
-        assert exc_info.value.status_code == 404
-
-    @responses.activate
-    def test_401_unauthorized_error(self):
-        """Test that 401 status raises UnauthorizedError."""
-        responses.add(
-            responses.GET,
-            f"{BASE_URL}/api/v1/agents",
-            json={"message": "Invalid API key"},
-            status=401,
-        )
-
-        client = PlatformClient(api_key="invalid-key")
-
-        with pytest.raises(UnauthorizedError):
-            client._http_client.get("/api/v1/agents")
-
-    @responses.activate
-    def test_403_forbidden_error(self):
-        """Test that 403 status raises ForbiddenError."""
-        responses.add(
-            responses.GET,
-            f"{BASE_URL}/api/v1/agents",
-            json={"message": "Forbidden"},
-            status=403,
-        )
-
-        client = PlatformClient(api_key="test-key")
-
-        with pytest.raises(ForbiddenError):
-            client._http_client.get("/api/v1/agents")
-
-
-class TestAgentEndpoint:
-    """Test Agent management endpoints."""
-
-    @responses.activate
-    def test_list_agents(self):
-        """Test listing agents."""
-        responses.add(
-            responses.GET,
-            f"{BASE_URL}/api/v1/agents",
-            json={
-                "success": True,
-                "data": [
-                    {
-                        "id": "agent-1",
-                        "name": "Support Bot",
-                        "description": "Support agent",
-                        "status": "published",
-                        "version": 1,
-                        "created_at": "2024-01-01T00:00:00Z",
-                        "updated_at": "2024-01-01T00:00:00Z",
-                    }
-                ],
-                "meta": {"page": 1, "per_page": 20, "total_count": 1}
-            },
-            status=200,
-        )
-
-        client = PlatformClient(api_key="test-key")
-        agents, meta = client.agents.list_agents(page=1, per_page=20)
-
-        assert len(agents) == 1
-        assert agents[0].name == "Support Bot"
-        assert meta["total_count"] == 1
-
-    @responses.activate
-    def test_create_agent(self):
-        """Test creating an agent."""
-        responses.add(
-            responses.POST,
-            f"{BASE_URL}/api/v1/agents",
-            json={
-                "success": True,
-                "data": {
-                    "id": "agent-new",
-                    "name": "New Agent",
-                    "description": "A new agent",
-                    "status": "draft",
-                    "version": 1,
-                    "created_at": "2024-01-01T00:00:00Z",
-                    "updated_at": "2024-01-01T00:00:00Z",
-                }
-            },
-            status=200,
-        )
-
-        client = PlatformClient(api_key="test-key")
-        agent = client.agents.create_agent(
-            name="New Agent",
-            description="A new agent"
-        )
-
-        assert agent.id == "agent-new"
-        assert agent.name == "New Agent"
-        assert agent.status == "draft"
-
-    @responses.activate
-    def test_get_agent(self):
-        """Test getting a single agent."""
-        responses.add(
-            responses.GET,
-            f"{BASE_URL}/api/v1/agents/agent-1",
-            json={
-                "success": True,
-                "data": {
-                    "id": "agent-1",
-                    "name": "Support Bot",
-                    "description": "Support agent",
-                    "status": "published",
-                    "version": 1,
-                    "created_at": "2024-01-01T00:00:00Z",
-                    "updated_at": "2024-01-01T00:00:00Z",
-                }
-            },
-            status=200,
-        )
-
-        client = PlatformClient(api_key="test-key")
-        agent = client.agents.get_agent("agent-1")
-
-        assert agent.id == "agent-1"
-        assert agent.name == "Support Bot"
-
-    @responses.activate
-    def test_update_agent(self):
-        """Test updating an agent."""
-        responses.add(
-            responses.PUT,
-            f"{BASE_URL}/api/v1/agents/agent-1",
-            json={
-                "success": True,
-                "data": {
-                    "id": "agent-1",
-                    "name": "Updated Bot",
-                    "description": "Support agent",
-                    "status": "draft",
-                    "version": 2,
-                    "created_at": "2024-01-01T00:00:00Z",
-                    "updated_at": "2024-01-02T00:00:00Z",
-                }
-            },
-            status=200,
-        )
-
-        client = PlatformClient(api_key="test-key")
-        agent = client.agents.update_agent("agent-1", name="Updated Bot")
-
-        assert agent.name == "Updated Bot"
-        assert agent.version == 2
-
-    @responses.activate
-    def test_delete_agent(self):
-        """Test deleting an agent."""
-        responses.add(
-            responses.DELETE,
-            f"{BASE_URL}/api/v1/agents/agent-1",
-            json={"success": True},
-            status=200,
-        )
-
-        client = PlatformClient(api_key="test-key")
-        client.agents.delete_agent("agent-1")
-
-        assert len(responses.calls) == 1
-
-    @responses.activate
-    def test_publish_agent(self):
-        """Test publishing an agent."""
-        responses.add(
-            responses.POST,
-            f"{BASE_URL}/api/v1/agents/agent-1/publish",
-            json={
-                "success": True,
-                "data": {
-                    "id": "agent-1",
-                    "name": "Support Bot",
-                    "description": "Support agent",
-                    "status": "published",
-                    "version": 2,
-                    "created_at": "2024-01-01T00:00:00Z",
-                    "updated_at": "2024-01-02T00:00:00Z",
-                }
-            },
-            status=200,
-        )
-
-        client = PlatformClient(api_key="test-key")
-        agent = client.agents.publish_agent("agent-1")
-
-        assert agent.status == "published"
-
-
-class TestDeploymentEndpoint:
-    """Test Deployment management endpoints."""
-
-    @responses.activate
-    def test_list_deployments(self):
-        """Test listing deployments."""
-        responses.add(
-            responses.GET,
-            f"{BASE_URL}/api/v1/deployments",
-            json={
-                "success": True,
-                "data": [
-                    {
-                        "id": "deploy-1",
-                        "name": "Support Widget",
-                        "agent_id": "agent-1",
-                        "channel": "widget",
-                        "status": "active",
-                        "environment": "widget",
-                        "created_at": "2024-01-01T00:00:00Z",
-                        "updated_at": "2024-01-01T00:00:00Z",
-                    }
-                ],
-                "meta": {"page": 1, "per_page": 20, "total_count": 1}
-            },
-            status=200,
-        )
-
-        client = PlatformClient(api_key="test-key")
-        deployments, meta = client.deployments.list_deployments()
-
-        assert len(deployments) == 1
-        assert deployments[0].name == "Support Widget"
-
-    @responses.activate
-    def test_create_deployment(self):
-        """Test creating a deployment."""
-        responses.add(
-            responses.POST,
-            f"{BASE_URL}/api/v1/deployments",
-            json={
-                "success": True,
-                "data": {
-                    "id": "deploy-new",
-                    "name": "Support Widget",
-                    "agent_id": "agent-1",
-                    "channel": "widget",
-                    "status": "pending",
-                    "environment": "widget",
-                    "created_at": "2024-01-01T00:00:00Z",
-                    "updated_at": "2024-01-01T00:00:00Z",
-                }
-            },
-            status=200,
-        )
-
-        client = PlatformClient(api_key="test-key")
-        deployment = client.deployments.create_deployment(
-            name="Support Widget",
-            agent_id="agent-1",
-            channel="widget"
-        )
-
-        assert deployment.id == "deploy-new"
-        assert deployment.channel == "widget"
-
-    @responses.activate
-    def test_activate_deployment(self):
-        """Test activating a deployment."""
-        responses.add(
-            responses.POST,
-            f"{BASE_URL}/api/v1/deployments/deploy-1/activate",
-            json={
-                "success": True,
-                "data": {
-                    "id": "deploy-1",
-                    "name": "Support Widget",
-                    "agent_id": "agent-1",
-                    "channel": "widget",
-                    "status": "active",
-                    "environment": "widget",
-                    "created_at": "2024-01-01T00:00:00Z",
-                    "updated_at": "2024-01-02T00:00:00Z",
-                }
-            },
-            status=200,
-        )
-
-        client = PlatformClient(api_key="test-key")
-        deployment = client.deployments.activate_deployment("deploy-1")
-
-        assert deployment.status == "active"
-
-
-class TestApiKeyEndpoint:
-    """Test API Key management endpoints."""
-
-    @responses.activate
-    def test_get_api_key_info(self):
-        """Test getting API key info."""
-        responses.add(
-            responses.GET,
-            f"{BASE_URL}/api/v1/settings/api-key",
-            json={
-                "success": True,
-                "data": {
-                    "status": "active",
-                    "last_4": "1234",
-                    "created_at": "2024-01-01T00:00:00Z",
-                    "last_used_at": "2024-01-02T00:00:00Z",
-                }
-            },
-            status=200,
-        )
-
-        client = PlatformClient(api_key="test-key")
-        key_info = client.api_keys.get_api_key_info()
-
-        assert key_info.status == "active"
-        assert key_info.last_4_chars == "1234"
-
-    @responses.activate
-    def test_get_api_key_usage(self):
-        """Test getting API key usage statistics."""
-        responses.add(
-            responses.GET,
-            f"{BASE_URL}/api/v1/settings/api-key/usage",
-            json={
-                "success": True,
-                "data": {
-                    "requests_24h": 100,
-                    "requests_month": 5000,
-                    "rate_limit": 10000,
-                    "rate_limit_remaining": 5000,
-                    "last_request_at": "2024-01-02T12:00:00Z",
-                }
-            },
-            status=200,
-        )
-
-        client = PlatformClient(api_key="test-key")
-        usage = client.api_keys.get_api_key_usage()
-
-        assert usage.requests_24h == 100
-        assert usage.rate_limit == 10000