Added server image test, server stop, added server acknowledgement docs

Author: KillianLucas

docs/server/usage.mdx

@@ -232,6 +232,79 @@ docker run -p 8000:8000 open-interpreter
 
 This will expose the server on port 8000 of your host machine.
 
+## Acknowledgment Feature
+
+When the `INTERPRETER_REQUIRE_ACKNOWLEDGE` environment variable is set to `"True"`, the server requires clients to acknowledge each message received. This feature ensures reliable message delivery in environments where network stability might be a concern.
+
+### How it works
+
+1. When this feature is enabled, each message sent by the server will include an `id` field.
+2. The client must send an acknowledgment message back to the server for each received message.
+3. The server will wait for this acknowledgment before sending the next message.
+
+### Client Implementation
+
+To implement this on the client side:
+
+1. Check if each received message contains an `id` field.
+2. If an `id` is present, send an acknowledgment message back to the server.
+
+Here's an example of how to handle this in your WebSocket client:
+
+```python
+import json
+import websockets
+
+async def handle_messages(websocket):
+    async for message in websocket:
+        data = json.loads(message)
+        
+        # Process the message as usual
+        print(f"Received: {data}")
+
+        # Check if the message has an ID that needs to be acknowledged
+        if "id" in data:
+            ack_message = {
+                "ack": data["id"]
+            }
+            await websocket.send(json.dumps(ack_message))
+            print(f"Sent acknowledgment for message {data['id']}")
+
+async def main():
+    uri = "ws://localhost:8000"
+    async with websockets.connect(uri) as websocket:
+        await handle_messages(websocket)
+
+# Run the async function
+import asyncio
+asyncio.run(main())
+```
+
+### Server Behavior
+
+- If the server doesn't receive an acknowledgment within a certain timeframe, it will attempt to resend the message.
+- The server will make multiple attempts to send a message before considering it failed.
+
+### Enabling the Feature
+
+To enable this feature, set the `INTERPRETER_REQUIRE_ACKNOWLEDGE` environment variable to `"True"` before starting the server:
+
+```bash
+export INTERPRETER_REQUIRE_ACKNOWLEDGE="True"
+interpreter --server
+```
+
+Or in Python:
+
+```python
+import os
+os.environ["INTERPRETER_REQUIRE_ACKNOWLEDGE"] = "True"
+
+from interpreter import AsyncInterpreter
+async_interpreter = AsyncInterpreter()
+async_interpreter.server.run()
+```
+
 ## Advanced Usage: Accessing the FastAPI App Directly
 
 The FastAPI app is exposed at `async_interpreter.server.app`. This allows you to add custom routes or host the app using Uvicorn directly.

tests/test_interpreter.py

@@ -341,6 +341,83 @@ async def test_fastapi_server():
             )
             assert response.strip(" \n.").lower() == "no"
 
+            #### TEST IMAGES ####
+
+            # Send another POST request
+            post_url = "http://localhost:8000/settings"
+            settings = {"messages": [], "auto_run": True}
+            response = requests.post(post_url, json=settings)
+            print("POST request sent, response:", response.json())
+
+            base64png = "iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAIAAADTED8xAAADMElEQVR4nOzVwQnAIBQFQYXff81RUkQCOyDj1YOPnbXWPmeTRef+/3O/OyBjzh3CD95BfqICMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMO0TAAD//2Anhf4QtqobAAAAAElFTkSuQmCC"
+
+            # Sending messages via WebSocket
+            await websocket.send(json.dumps({"role": "user", "start": True}))
+            await websocket.send(
+                json.dumps(
+                    {
+                        "role": "user",
+                        "type": "message",
+                        "content": "describe these images",
+                    }
+                )
+            )
+            await websocket.send(
+                json.dumps(
+                    {
+                        "role": "user",
+                        "type": "image",
+                        "format": "base64.png",
+                        "content": base64png,
+                    }
+                )
+            )
+            # await websocket.send(
+            #     json.dumps(
+            #         {
+            #             "role": "user",
+            #             "type": "image",
+            #             "format": "path",
+            #             "content": "/Users/killianlucas/Documents/GitHub/open-interpreter/screen.png",
+            #         }
+            #     )
+            # )
+
+            await websocket.send(json.dumps({"role": "user", "end": True}))
+            print("WebSocket chunks sent")
+
+            # Wait for response
+            accumulated_content = ""
+            while True:
+                message = await websocket.recv()
+                message_data = json.loads(message)
+                if "error" in message_data:
+                    raise Exception(message_data["content"])
+                print("Received from WebSocket:", message_data)
+                if type(message_data.get("content")) == str:
+                    accumulated_content += message_data.get("content")
+                if message_data == {
+                    "role": "server",
+                    "type": "status",
+                    "content": "complete",
+                }:
+                    print("Received expected message from server")
+                    break
+
+            # Get messages
+            get_url = "http://localhost:8000/settings/messages"
+            response_json = requests.get(get_url).json()
+            print("GET request sent, response:", response_json)
+            if isinstance(response_json, str):
+                response_json = json.loads(response_json)
+            messages = response_json["messages"]
+
+            response = async_interpreter.computer.ai.chat(
+                str(messages)
+                + "\n\nIn the conversation above, does the assistant appear to be able to describe the images? Yes or no? Only reply with one word— 'yes' or 'no'."
+            )
+            assert response.strip(" \n.").lower() == "yes"
+
             # Sending POST request to /run endpoint with code to kill a thread in Python
             # actually wait i dont think this will work..? will just kill the python interpreter
             post_url = "http://localhost:8000/run"