PyPI - letta-nightly - Versions diffs - 0.1.7.dev20240924104148__py3-none-any.whl - Mend

letta-nightly 0.1.7.dev20240924104148__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of letta-nightly might be problematic. Click here for more details.

Files changed (189) hide show

letta/__init__.py +24 -0
letta/__main__.py +3 -0
letta/agent.py +1427 -0
letta/agent_store/chroma.py +295 -0
letta/agent_store/db.py +546 -0
letta/agent_store/lancedb.py +177 -0
letta/agent_store/milvus.py +198 -0
letta/agent_store/qdrant.py +201 -0
letta/agent_store/storage.py +188 -0
letta/benchmark/benchmark.py +96 -0
letta/benchmark/constants.py +14 -0
letta/cli/cli.py +689 -0
letta/cli/cli_config.py +1282 -0
letta/cli/cli_load.py +166 -0
letta/client/__init__.py +0 -0
letta/client/admin.py +171 -0
letta/client/client.py +2360 -0
letta/client/streaming.py +90 -0
letta/client/utils.py +61 -0
letta/config.py +484 -0
letta/configs/anthropic.json +13 -0
letta/configs/letta_hosted.json +11 -0
letta/configs/openai.json +12 -0
letta/constants.py +134 -0
letta/credentials.py +140 -0
letta/data_sources/connectors.py +247 -0
letta/embeddings.py +218 -0
letta/errors.py +26 -0
letta/functions/__init__.py +0 -0
letta/functions/function_sets/base.py +174 -0
letta/functions/function_sets/extras.py +132 -0
letta/functions/functions.py +105 -0
letta/functions/schema_generator.py +205 -0
letta/humans/__init__.py +0 -0
letta/humans/examples/basic.txt +1 -0
letta/humans/examples/cs_phd.txt +9 -0
letta/interface.py +314 -0
letta/llm_api/__init__.py +0 -0
letta/llm_api/anthropic.py +383 -0
letta/llm_api/azure_openai.py +155 -0
letta/llm_api/cohere.py +396 -0
letta/llm_api/google_ai.py +468 -0
letta/llm_api/llm_api_tools.py +485 -0
letta/llm_api/openai.py +470 -0
letta/local_llm/README.md +3 -0
letta/local_llm/__init__.py +0 -0
letta/local_llm/chat_completion_proxy.py +279 -0
letta/local_llm/constants.py +31 -0
letta/local_llm/function_parser.py +68 -0
letta/local_llm/grammars/__init__.py +0 -0
letta/local_llm/grammars/gbnf_grammar_generator.py +1324 -0
letta/local_llm/grammars/json.gbnf +26 -0
letta/local_llm/grammars/json_func_calls_with_inner_thoughts.gbnf +32 -0
letta/local_llm/groq/api.py +97 -0
letta/local_llm/json_parser.py +202 -0
letta/local_llm/koboldcpp/api.py +62 -0
letta/local_llm/koboldcpp/settings.py +23 -0
letta/local_llm/llamacpp/api.py +58 -0
letta/local_llm/llamacpp/settings.py +22 -0
letta/local_llm/llm_chat_completion_wrappers/__init__.py +0 -0
letta/local_llm/llm_chat_completion_wrappers/airoboros.py +452 -0
letta/local_llm/llm_chat_completion_wrappers/chatml.py +470 -0
letta/local_llm/llm_chat_completion_wrappers/configurable_wrapper.py +387 -0
letta/local_llm/llm_chat_completion_wrappers/dolphin.py +246 -0
letta/local_llm/llm_chat_completion_wrappers/llama3.py +345 -0
letta/local_llm/llm_chat_completion_wrappers/simple_summary_wrapper.py +156 -0
letta/local_llm/llm_chat_completion_wrappers/wrapper_base.py +11 -0
letta/local_llm/llm_chat_completion_wrappers/zephyr.py +345 -0
letta/local_llm/lmstudio/api.py +100 -0
letta/local_llm/lmstudio/settings.py +29 -0
letta/local_llm/ollama/api.py +88 -0
letta/local_llm/ollama/settings.py +32 -0
letta/local_llm/settings/__init__.py +0 -0
letta/local_llm/settings/deterministic_mirostat.py +45 -0
letta/local_llm/settings/settings.py +72 -0
letta/local_llm/settings/simple.py +28 -0
letta/local_llm/utils.py +265 -0
letta/local_llm/vllm/api.py +63 -0
letta/local_llm/webui/api.py +60 -0
letta/local_llm/webui/legacy_api.py +58 -0
letta/local_llm/webui/legacy_settings.py +23 -0
letta/local_llm/webui/settings.py +24 -0
letta/log.py +76 -0
letta/main.py +437 -0
letta/memory.py +440 -0
letta/metadata.py +884 -0
letta/openai_backcompat/__init__.py +0 -0
letta/openai_backcompat/openai_object.py +437 -0
letta/persistence_manager.py +148 -0
letta/personas/__init__.py +0 -0
letta/personas/examples/anna_pa.txt +13 -0
letta/personas/examples/google_search_persona.txt +15 -0
letta/personas/examples/memgpt_doc.txt +6 -0
letta/personas/examples/memgpt_starter.txt +4 -0
letta/personas/examples/sam.txt +14 -0
letta/personas/examples/sam_pov.txt +14 -0
letta/personas/examples/sam_simple_pov_gpt35.txt +13 -0
letta/personas/examples/sqldb/test.db +0 -0
letta/prompts/__init__.py +0 -0
letta/prompts/gpt_summarize.py +14 -0
letta/prompts/gpt_system.py +26 -0
letta/prompts/system/memgpt_base.txt +49 -0
letta/prompts/system/memgpt_chat.txt +58 -0
letta/prompts/system/memgpt_chat_compressed.txt +13 -0
letta/prompts/system/memgpt_chat_fstring.txt +51 -0
letta/prompts/system/memgpt_doc.txt +50 -0
letta/prompts/system/memgpt_gpt35_extralong.txt +53 -0
letta/prompts/system/memgpt_intuitive_knowledge.txt +31 -0
letta/prompts/system/memgpt_modified_chat.txt +23 -0
letta/pytest.ini +0 -0
letta/schemas/agent.py +117 -0
letta/schemas/api_key.py +21 -0
letta/schemas/block.py +135 -0
letta/schemas/document.py +21 -0
letta/schemas/embedding_config.py +54 -0
letta/schemas/enums.py +35 -0
letta/schemas/job.py +38 -0
letta/schemas/letta_base.py +80 -0
letta/schemas/letta_message.py +175 -0
letta/schemas/letta_request.py +23 -0
letta/schemas/letta_response.py +28 -0
letta/schemas/llm_config.py +54 -0
letta/schemas/memory.py +224 -0
letta/schemas/message.py +727 -0
letta/schemas/openai/chat_completion_request.py +123 -0
letta/schemas/openai/chat_completion_response.py +136 -0
letta/schemas/openai/chat_completions.py +123 -0
letta/schemas/openai/embedding_response.py +11 -0
letta/schemas/openai/openai.py +157 -0
letta/schemas/organization.py +20 -0
letta/schemas/passage.py +80 -0
letta/schemas/source.py +62 -0
letta/schemas/tool.py +143 -0
letta/schemas/usage.py +18 -0
letta/schemas/user.py +33 -0
letta/server/__init__.py +0 -0
letta/server/constants.py +6 -0
letta/server/rest_api/__init__.py +0 -0
letta/server/rest_api/admin/__init__.py +0 -0
letta/server/rest_api/admin/agents.py +21 -0
letta/server/rest_api/admin/tools.py +83 -0
letta/server/rest_api/admin/users.py +98 -0
letta/server/rest_api/app.py +193 -0
letta/server/rest_api/auth/__init__.py +0 -0
letta/server/rest_api/auth/index.py +43 -0
letta/server/rest_api/auth_token.py +22 -0
letta/server/rest_api/interface.py +726 -0
letta/server/rest_api/routers/__init__.py +0 -0
letta/server/rest_api/routers/openai/__init__.py +0 -0
letta/server/rest_api/routers/openai/assistants/__init__.py +0 -0
letta/server/rest_api/routers/openai/assistants/assistants.py +115 -0
letta/server/rest_api/routers/openai/assistants/schemas.py +121 -0
letta/server/rest_api/routers/openai/assistants/threads.py +336 -0
letta/server/rest_api/routers/openai/chat_completions/__init__.py +0 -0
letta/server/rest_api/routers/openai/chat_completions/chat_completions.py +131 -0
letta/server/rest_api/routers/v1/__init__.py +15 -0
letta/server/rest_api/routers/v1/agents.py +543 -0
letta/server/rest_api/routers/v1/blocks.py +73 -0
letta/server/rest_api/routers/v1/jobs.py +46 -0
letta/server/rest_api/routers/v1/llms.py +28 -0
letta/server/rest_api/routers/v1/organizations.py +61 -0
letta/server/rest_api/routers/v1/sources.py +199 -0
letta/server/rest_api/routers/v1/tools.py +103 -0
letta/server/rest_api/routers/v1/users.py +109 -0
letta/server/rest_api/static_files.py +74 -0
letta/server/rest_api/utils.py +69 -0
letta/server/server.py +1995 -0
letta/server/startup.sh +8 -0
letta/server/static_files/assets/index-0cbf7ad5.js +274 -0
letta/server/static_files/assets/index-156816da.css +1 -0
letta/server/static_files/assets/index-486e3228.js +274 -0
letta/server/static_files/favicon.ico +0 -0
letta/server/static_files/index.html +39 -0
letta/server/static_files/memgpt_logo_transparent.png +0 -0
letta/server/utils.py +46 -0
letta/server/ws_api/__init__.py +0 -0
letta/server/ws_api/example_client.py +104 -0
letta/server/ws_api/interface.py +108 -0
letta/server/ws_api/protocol.py +100 -0
letta/server/ws_api/server.py +145 -0
letta/settings.py +165 -0
letta/streaming_interface.py +396 -0
letta/system.py +207 -0
letta/utils.py +1065 -0
letta_nightly-0.1.7.dev20240924104148.dist-info/LICENSE +190 -0
letta_nightly-0.1.7.dev20240924104148.dist-info/METADATA +98 -0
letta_nightly-0.1.7.dev20240924104148.dist-info/RECORD +189 -0
letta_nightly-0.1.7.dev20240924104148.dist-info/WHEEL +4 -0
letta_nightly-0.1.7.dev20240924104148.dist-info/entry_points.txt +3 -0

letta/server/static_files/favicon.ico ADDED Viewed

Binary file

letta/server/static_files/index.html ADDED Viewed

@@ -0,0 +1,39 @@
+<!doctype html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<title>Letta</title>
+		<base href="/" />
+		<meta name="viewport" content="width=device-width, initial-scale=1" />
+		<link rel="icon" type="image/x-icon" href="/favicon.ico" />
+		<script>
+			if (localStorage.theme === 'dark') {
+				if (document && document.documentElement) {
+					document.documentElement.classList.add('dark');
+				}
+			} else if (localStorage.theme === 'light') {
+				if (document && document.documentElement) {
+					document.documentElement.classList.remove('dark');
+					localStorage.setItem('theme', 'light');
+				}
+			} else if (window.matchMedia('(prefers-color-scheme: dark)').matches) {
+				localStorage.setItem('theme', 'system');
+				if (document && document.documentElement) {
+					document.documentElement.classList.add('dark');
+				}
+			} else {
+				if (document && document.documentElement) {
+					document.documentElement.classList.remove('dark');
+				}
+			}
+		</script>
+		<script type="module" crossorigin src="/assets/index-486e3228.js"></script>
+		<link rel="stylesheet" href="/assets/index-156816da.css">
+	</head>
+	<body>
+		<div class="h-full w-full" id="root"></div>
+	</body>
+</html>

letta/server/static_files/memgpt_logo_transparent.png ADDED Viewed

Binary file

letta/server/utils.py ADDED Viewed

@@ -0,0 +1,46 @@
+def condition_to_stop_receiving(response):
+    """Determines when to stop listening to the server"""
+    if response.get("type") in ["agent_response_end", "agent_response_error", "command_response", "server_error"]:
+        return True
+    else:
+        return False
+def print_server_response(response):
+    """Turn response json into a nice print"""
+    if response["type"] == "agent_response_start":
+        print("[agent.step start]")
+    elif response["type"] == "agent_response_end":
+        print("[agent.step end]")
+    elif response["type"] == "agent_response":
+        msg = response["message"]
+        if response["message_type"] == "internal_monologue":
+            print(f"[inner thoughts] {msg}")
+        elif response["message_type"] == "assistant_message":
+            print(f"{msg}")
+        elif response["message_type"] == "function_message":
+            pass
+        else:
+            print(response)
+    else:
+        print(response)
+def shorten_key_middle(key_string, chars_each_side=3):
+    """
+    Shortens a key string by showing a specified number of characters on each side and adding an ellipsis in the middle.
+    Args:
+    key_string (str): The key string to be shortened.
+    chars_each_side (int): The number of characters to show on each side of the ellipsis.
+    Returns:
+    str: The shortened key string with an ellipsis in the middle.
+    """
+    if not key_string:
+        return key_string
+    key_length = len(key_string)
+    if key_length <= 2 * chars_each_side:
+        return "..."  # Return ellipsis if the key is too short
+    else:
+        return key_string[:chars_each_side] + "..." + key_string[-chars_each_side:]

letta/server/ws_api/__init__.py ADDED Viewed

File without changes

letta/server/ws_api/example_client.py ADDED Viewed

@@ -0,0 +1,104 @@
+import asyncio
+import websockets
+import letta.server.ws_api.protocol as protocol
+from letta.server.constants import WS_CLIENT_TIMEOUT, WS_DEFAULT_PORT
+from letta.server.utils import condition_to_stop_receiving, print_server_response
+# CLEAN_RESPONSES = False  # print the raw server responses (JSON)
+CLEAN_RESPONSES = True  # make the server responses cleaner
+# LOAD_AGENT = None  # create a brand new agent
+AGENT_NAME = "agent_26"  # load an existing agent
+NEW_AGENT = False
+RECONNECT_DELAY = 1
+RECONNECT_MAX_TRIES = 5
+async def send_message_and_print_replies(websocket, user_message, agent_id):
+    """Send a message over websocket protocol and wait for the reply stream to end"""
+    # Send a message to the agent
+    await websocket.send(protocol.client_user_message(msg=str(user_message), agent_id=agent_id))
+    # Wait for messages in a loop, since the server may send a few
+    while True:
+        response = await asyncio.wait_for(websocket.recv(), WS_CLIENT_TIMEOUT)
+        response = json_loads(response)
+        if CLEAN_RESPONSES:
+            print_server_response(response)
+        else:
+            print(f"Server response:\n{json_dumps(response, indent=2)}")
+        # Check for a specific condition to break the loop
+        if condition_to_stop_receiving(response):
+            break
+async def basic_cli_client():
+    """Basic example of a Letta CLI client that connects to a Letta server.py process via WebSockets
+    Meant to illustrate how to use the server.py process, so limited in features (only supports sending user messages)
+    """
+    uri = f"ws://localhost:{WS_DEFAULT_PORT}"
+    closed_on_message = False
+    retry_attempts = 0
+    while True:  # Outer loop for reconnection attempts
+        try:
+            async with websockets.connect(uri) as websocket:
+                if NEW_AGENT:
+                    # Initialize new agent
+                    print("Sending config to server...")
+                    example_config = {
+                        "persona": "sam_pov",
+                        "human": "cs_phd",
+                        "model": "gpt-4-1106-preview",  # gpt-4-turbo
+                    }
+                    await websocket.send(protocol.client_command_create(example_config))
+                    # Wait for the response
+                    response = await websocket.recv()
+                    response = json_loads(response)
+                    print(f"Server response:\n{json_dumps(response, indent=2)}")
+                    await asyncio.sleep(1)
+                while True:
+                    if closed_on_message:
+                        # If we're on a retry after a disconnect, don't ask for input again
+                        closed_on_message = False
+                    else:
+                        user_input = input("\nEnter your message: ")
+                        print("\n")
+                    # Send a message to the agent
+                    try:
+                        await send_message_and_print_replies(websocket=websocket, user_message=user_input, agent_id=AGENT_NAME)
+                        retry_attempts = 0
+                    except websockets.exceptions.ConnectionClosedError:
+                        print("Connection to server was lost. Attempting to reconnect...")
+                        closed_on_message = True
+                        raise
+        except websockets.exceptions.ConnectionClosedError:
+            # Decide whether or not to retry the connection
+            if retry_attempts < RECONNECT_MAX_TRIES:
+                retry_attempts += 1
+                await asyncio.sleep(RECONNECT_DELAY)  # Wait for N seconds before reconnecting
+                continue
+            else:
+                print(f"Max attempts exceeded ({retry_attempts} > {RECONNECT_MAX_TRIES})")
+                break
+        except asyncio.TimeoutError:
+            print("Timeout waiting for the server response.")
+            continue
+        except Exception as e:
+            print(f"An error occurred: {e}")
+            continue
+asyncio.run(basic_cli_client())

letta/server/ws_api/interface.py ADDED Viewed

@@ -0,0 +1,108 @@
+import asyncio
+import threading
+import letta.server.ws_api.protocol as protocol
+from letta.interface import AgentInterface
+class BaseWebSocketInterface(AgentInterface):
+    """Interface for interacting with a Letta agent over a WebSocket"""
+    def __init__(self):
+        self.clients = set()
+    def register_client(self, websocket):
+        """Register a new client connection"""
+        self.clients.add(websocket)
+    def unregister_client(self, websocket):
+        """Unregister a client connection"""
+        self.clients.remove(websocket)
+    def step_yield(self):
+        pass
+class AsyncWebSocketInterface(BaseWebSocketInterface):
+    """WebSocket calls are async"""
+    async def user_message(self, msg):
+        """Handle reception of a user message"""
+        # Logic to process the user message and possibly trigger agent's response
+    async def internal_monologue(self, msg):
+        """Handle the agent's internal monologue"""
+        print(msg)
+        # Send the internal monologue to all clients
+        if self.clients:  # Check if there are any clients connected
+            await asyncio.gather(*[client.send_text(protocol.server_agent_internal_monologue(msg)) for client in self.clients])
+    async def assistant_message(self, msg):
+        """Handle the agent sending a message"""
+        print(msg)
+        # Send the assistant's message to all clients
+        if self.clients:
+            await asyncio.gather(*[client.send_text(protocol.server_agent_assistant_message(msg)) for client in self.clients])
+    async def function_message(self, msg):
+        """Handle the agent calling a function"""
+        print(msg)
+        # Send the function call message to all clients
+        if self.clients:
+            await asyncio.gather(*[client.send_text(protocol.server_agent_function_message(msg)) for client in self.clients])
+class SyncWebSocketInterface(BaseWebSocketInterface):
+    def __init__(self):
+        super().__init__()
+        self.clients = set()
+        self.loop = asyncio.new_event_loop()  # Create a new event loop
+        self.thread = threading.Thread(target=self._run_event_loop, daemon=True)
+        self.thread.start()
+    def _run_event_loop(self):
+        """Run the dedicated event loop and handle its closure."""
+        asyncio.set_event_loop(self.loop)
+        try:
+            self.loop.run_forever()
+        finally:
+            # Run the cleanup tasks in the event loop
+            self.loop.run_until_complete(self.loop.shutdown_asyncgens())
+            self.loop.close()
+    def _run_async(self, coroutine):
+        """Schedule coroutine to be run in the dedicated event loop."""
+        if not self.loop.is_closed():
+            asyncio.run_coroutine_threadsafe(coroutine, self.loop)
+    async def _send_to_all_clients(self, clients, msg):
+        """Asynchronously sends a message to all clients."""
+        if clients:
+            await asyncio.gather(*(client.send_text(msg) for client in clients))
+    def user_message(self, msg):
+        """Handle reception of a user message"""
+        # Logic to process the user message and possibly trigger agent's response
+    def internal_monologue(self, msg):
+        """Handle the agent's internal monologue"""
+        print(msg)
+        if self.clients:
+            self._run_async(self._send_to_all_clients(self.clients, protocol.server_agent_internal_monologue(msg)))
+    def assistant_message(self, msg):
+        """Handle the agent sending a message"""
+        print(msg)
+        if self.clients:
+            self._run_async(self._send_to_all_clients(self.clients, protocol.server_agent_assistant_message(msg)))
+    def function_message(self, msg):
+        """Handle the agent calling a function"""
+        print(msg)
+        if self.clients:
+            self._run_async(self._send_to_all_clients(self.clients, protocol.server_agent_function_message(msg)))
+    def close(self):
+        """Shut down the WebSocket interface and its event loop."""
+        self.loop.call_soon_threadsafe(self.loop.stop)  # Signal the loop to stop
+        self.thread.join()  # Wait for the thread to finish

letta/server/ws_api/protocol.py ADDED Viewed

@@ -0,0 +1,100 @@
+from letta.utils import json_dumps
+# Server -> client
+def server_error(msg):
+    """General server error"""
+    return json_dumps(
+        {
+            "type": "server_error",
+            "message": msg,
+        }
+    )
+def server_command_response(status):
+    return json_dumps(
+        {
+            "type": "command_response",
+            "status": status,
+        }
+    )
+def server_agent_response_error(msg):
+    return json_dumps(
+        {
+            "type": "agent_response_error",
+            "message": msg,
+        }
+    )
+def server_agent_response_start():
+    return json_dumps(
+        {
+            "type": "agent_response_start",
+        }
+    )
+def server_agent_response_end():
+    return json_dumps(
+        {
+            "type": "agent_response_end",
+        }
+    )
+def server_agent_internal_monologue(msg):
+    return json_dumps(
+        {
+            "type": "agent_response",
+            "message_type": "internal_monologue",
+            "message": msg,
+        }
+    )
+def server_agent_assistant_message(msg):
+    return json_dumps(
+        {
+            "type": "agent_response",
+            "message_type": "assistant_message",
+            "message": msg,
+        }
+    )
+def server_agent_function_message(msg):
+    return json_dumps(
+        {
+            "type": "agent_response",
+            "message_type": "function_message",
+            "message": msg,
+        }
+    )
+# Client -> server
+def client_user_message(msg, agent_id=None):
+    return json_dumps(
+        {
+            "type": "user_message",
+            "message": msg,
+            "agent_id": agent_id,
+        }
+    )
+def client_command_create(config):
+    return json_dumps(
+        {
+            "type": "command",
+            "command": "create_agent",
+            "config": config,
+        }
+    )

letta/server/ws_api/server.py ADDED Viewed

@@ -0,0 +1,145 @@
+import asyncio
+import signal
+import sys
+import traceback
+import websockets
+import letta.server.ws_api.protocol as protocol
+from letta.server.constants import WS_DEFAULT_PORT
+from letta.server.server import SyncServer
+from letta.server.ws_api.interface import SyncWebSocketInterface
+class WebSocketServer:
+    def __init__(self, host="localhost", port=WS_DEFAULT_PORT):
+        self.host = host
+        self.port = port
+        self.interface = SyncWebSocketInterface()
+        self.server = SyncServer(default_interface=self.interface)
+    def shutdown_server(self):
+        try:
+            self.server.save_agents()
+            print(f"Saved agents")
+        except Exception as e:
+            print(f"Saving agents failed with: {e}")
+        try:
+            self.interface.close()
+            print(f"Closed the WS interface")
+        except Exception as e:
+            print(f"Closing the WS interface failed with: {e}")
+    def initialize_server(self):
+        print("Server is initializing...")
+        print(f"Listening on {self.host}:{self.port}...")
+    async def start_server(self):
+        self.initialize_server()
+        # Can play with ping_interval and ping_timeout
+        # See: https://websockets.readthedocs.io/en/stable/topics/timeouts.html
+        # and https://github.com/cpacker/Letta/issues/471
+        async with websockets.serve(self.handle_client, self.host, self.port):
+            await asyncio.Future()  # Run forever
+    def run(self):
+        return self.start_server()  # Return the coroutine
+    async def handle_client(self, websocket, path):
+        self.interface.register_client(websocket)
+        try:
+            # async for message in websocket:
+            while True:
+                message = await websocket.recv()
+                # Assuming the message is a JSON string
+                try:
+                    data = json_loads(message)
+                except:
+                    print(f"[server] bad data from client:\n{data}")
+                    await websocket.send(protocol.server_command_response(f"Error: bad data from client - {str(data)}"))
+                    continue
+                if "type" not in data:
+                    print(f"[server] bad data from client (JSON but no type):\n{data}")
+                    await websocket.send(protocol.server_command_response(f"Error: bad data from client - {str(data)}"))
+                elif data["type"] == "command":
+                    # Create a new agent
+                    if data["command"] == "create_agent":
+                        try:
+                            # self.agent = self.create_new_agent(data["config"])
+                            self.server.create_agent(user_id="NULL", agent_config=data["config"])
+                            await websocket.send(protocol.server_command_response("OK: Agent initialized"))
+                        except Exception as e:
+                            self.agent = None
+                            print(f"[server] self.create_new_agent failed with:\n{e}")
+                            print(f"{traceback.format_exc()}")
+                            await websocket.send(protocol.server_command_response(f"Error: Failed to init agent - {str(e)}"))
+                    else:
+                        print(f"[server] unrecognized client command type: {data}")
+                        await websocket.send(protocol.server_error(f"unrecognized client command type: {data}"))
+                elif data["type"] == "user_message":
+                    user_message = data["message"]
+                    if "agent_id" not in data or data["agent_id"] is None:
+                        await websocket.send(protocol.server_agent_response_error("agent_name was not specified in the request"))
+                        continue
+                    await websocket.send(protocol.server_agent_response_start())
+                    try:
+                        # self.run_step(user_message)
+                        self.server.user_message(user_id="NULL", agent_id=data["agent_id"], message=user_message)
+                    except Exception as e:
+                        print(f"[server] self.server.user_message failed with:\n{e}")
+                        print(f"{traceback.format_exc()}")
+                        await websocket.send(protocol.server_agent_response_error(f"server.user_message failed with: {e}"))
+                    await asyncio.sleep(1)  # pause before sending the terminating message, w/o this messages may be missed
+                    await websocket.send(protocol.server_agent_response_end())
+                # ... handle other message types as needed ...
+                else:
+                    print(f"[server] unrecognized client package data type: {data}")
+                    await websocket.send(protocol.server_error(f"unrecognized client package data type: {data}"))
+        except websockets.exceptions.ConnectionClosed:
+            print(f"[server] connection with client was closed")
+        finally:
+            self.interface.unregister_client(websocket)
+def start_server():
+    # Check if a port argument is provided
+    port = WS_DEFAULT_PORT
+    if len(sys.argv) > 1:
+        try:
+            port = int(sys.argv[1])
+        except ValueError:
+            print(f"Invalid port number. Using default port {port}.")
+    server = WebSocketServer(port=port)
+    def handle_sigterm(*args):
+        # Perform necessary cleanup
+        print("SIGTERM received, shutting down...")
+        # Note: This should be quick and not involve asynchronous calls
+        print("Shutting down the server...")
+        server.shutdown_server()
+        print("Server has been shut down.")
+        sys.exit(0)
+    signal.signal(signal.SIGTERM, handle_sigterm)
+    try:
+        asyncio.run(server.run())
+    except KeyboardInterrupt:
+        print("Shutting down the server...")
+    finally:
+        server.shutdown_server()
+        print("Server has been shut down.")
+if __name__ == "__main__":
+    start_server()