Edit code blocks with e after it asks for confirmation

KillianLucas · KillianLucas · commit b27befdb0919 · 2024-07-09T15:17:24.000-07:00
diff --git a/Dockerfile b/Dockerfile
@@ -8,16 +8,20 @@ FROM python:3.11.8
 # Set environment variables
 # ENV OPENAI_API_KEY ...
 
+ENV HOST 0.0.0.0 
+# ^ Sets the server host to 0.0.0.0, Required for the server to be accessible outside the container
+
 # Copy required files into container
-RUN mkdir -p interpreter
+RUN mkdir -p interpreter scripts
 COPY interpreter/ interpreter/
+COPY scripts/ scripts/
 COPY poetry.lock pyproject.toml README.md ./
 
 # Expose port 8000
 EXPOSE 8000
 
 # Install server dependencies
-RUN pip install -e ".[server]"
+RUN pip install ".[server]"
 
 # Start the server
 ENTRYPOINT ["interpreter", "--server"]
diff --git a/benchmarks/run.py b/benchmarks/run.py
diff --git a/docs/server/usage.mdx b/docs/server/usage.mdx
@@ -107,7 +107,7 @@ Example:
 import requests
 
 settings = {
-    "model": "gpt-4",
+    "llm": {"model": "gpt-4"},
     "custom_instructions": "You only write Python code.",
     "auto_run": True,
 }
@@ -120,9 +120,9 @@ To get current settings, send a GET request to `http://localhost:8000/settings/{
 
 Example:
 ```python
-response = requests.get("http://localhost:8000/settings/model")
+response = requests.get("http://localhost:8000/settings/custom_instructions")
 print(response.json())
-# Output: {"model": "gpt-4"}
+# Output: {"custom_instructions": "You only write react."}
 ```
 
 ## Advanced Usage: Accessing the FastAPI App Directly
diff --git a/interpreter/core/async_core.py b/interpreter/core/async_core.py
@@ -75,34 +75,42 @@ async def output(self):
         return await self.output_queue.async_q.get()
 
     def respond(self, run_code=None):
-        if run_code == None:
-            run_code = self.auto_run
+        try:
+            if run_code == None:
+                run_code = self.auto_run
 
-        for chunk in self._respond_and_store():
-            if chunk["type"] == "confirmation":
-                if run_code:
-                    continue  # We don't need to send out confirmation chunks on the server. I don't even like them.
-                else:
-                    break
+            for chunk in self._respond_and_store():
+                if chunk["type"] == "confirmation":
+                    if run_code:
+                        continue  # We don't need to send out confirmation chunks on the server. I don't even like them.
+                    else:
+                        break
 
-            if self.stop_event.is_set():
-                return
+                if self.stop_event.is_set():
+                    return
 
-            if self.print:
-                if "start" in chunk:
-                    print("\n")
-                if chunk["type"] in ["code", "console"] and "format" in chunk:
+                if self.print:
                     if "start" in chunk:
-                        print("\n------------\n\n```" + chunk["format"], flush=True)
-                    if "end" in chunk:
-                        print("\n```\n\n------------\n\n", flush=True)
-                print(chunk.get("content", ""), end="", flush=True)
-
-            self.output_queue.sync_q.put(chunk)
-
-        self.output_queue.sync_q.put(
-            {"role": "server", "type": "status", "content": "complete"}
-        )
+                        print("\n")
+                    if chunk["type"] in ["code", "console"] and "format" in chunk:
+                        if "start" in chunk:
+                            print("\n------------\n\n```" + chunk["format"], flush=True)
+                        if "end" in chunk:
+                            print("\n```\n\n------------\n\n", flush=True)
+                    print(chunk.get("content", ""), end="", flush=True)
+
+                self.output_queue.sync_q.put(chunk)
+
+            self.output_queue.sync_q.put(
+                {"role": "server", "type": "status", "content": "complete"}
+            )
+        except Exception as e:
+            error_message = {
+                "role": "server",
+                "type": "error",
+                "content": traceback.format_exc() + "\n" + str(e),
+            }
+            self.output_queue.sync_q.put(error_message)
 
     def accumulate(self, chunk):
         """
@@ -202,13 +210,29 @@ async def send_output():
         finally:
             await websocket.close()
 
+    # TODO
+    @router.post("/")
+    async def post_input(payload: Dict[str, Any]):
+        # This doesn't work, but something like this should exist
+        query = payload.get("query")
+        if not query:
+            return {"error": "Query is required."}, 400
+        try:
+            async_interpreter.input.put(query)
+            return {"status": "success"}
+        except Exception as e:
+            return {"error": str(e)}, 500
+
     @router.post("/run")
     async def run_code(payload: Dict[str, Any]):
         language, code = payload.get("language"), payload.get("code")
         if not (language and code):
             return {"error": "Both 'language' and 'code' are required."}, 400
         try:
-            return {"output": async_interpreter.computer.run(language, code)}
+            print(f"Running {language}:", code)
+            output = async_interpreter.computer.run(language, code)
+            print("Output:", output)
+            return {"output": output}
         except Exception as e:
             return {"error": str(e)}, 500
 
@@ -217,10 +241,20 @@ async def set_settings(payload: Dict[str, Any]):
         for key, value in payload.items():
             print(f"Updating settings: {key} = {value}")
             if key in ["llm", "computer"] and isinstance(value, dict):
-                for sub_key, sub_value in value.items():
-                    setattr(getattr(async_interpreter, key), sub_key, sub_value)
-            else:
+                if hasattr(async_interpreter, key):
+                    for sub_key, sub_value in value.items():
+                        if hasattr(getattr(async_interpreter, key), sub_key):
+                            setattr(getattr(async_interpreter, key), sub_key, sub_value)
+                        else:
+                            return {
+                                "error": f"Sub-setting {sub_key} not found in {key}"
+                            }, 404
+                else:
+                    return {"error": f"Setting {key} not found"}, 404
+            elif hasattr(async_interpreter, key):
                 setattr(async_interpreter, key, value)
+            else:
+                return {"error": f"Setting {key} not found"}, 404
 
         return {"status": "success"}
 
@@ -238,8 +272,14 @@ async def get_setting(setting: str):
     return router
 
 
+host = os.getenv(
+    "HOST", "127.0.0.1"
+)  # IP address for localhost, used for local testing
+port = int(os.getenv("PORT", 8000))  # Default port is 8000
+
+
 class Server:
-    def __init__(self, async_interpreter, host="0.0.0.0", port=8000):
+    def __init__(self, async_interpreter, host=host, port=port):
         self.app = FastAPI()
         router = create_router(async_interpreter)
         self.app.include_router(router)
diff --git a/interpreter/core/llm/llm.py b/interpreter/core/llm/llm.py
@@ -378,25 +378,29 @@ def fixed_litellm_completions(**params):
         litellm.drop_params = True
 
     # Run completion
+    attempts = 4
     first_error = None
-    try:
-        yield from litellm.completion(**params)
-    except Exception as e:
-        # Store the first error
-        first_error = e
-        # LiteLLM can fail if there's no API key,
-        # even though some models (like local ones) don't require it.
-
-        if "api key" in str(first_error).lower() and "api_key" not in params:
-            print(
-                "LiteLLM requires an API key. Please set a dummy API key to prevent this message. (e.g `interpreter --api_key x` or `self.api_key = 'x'`)"
-            )
-
-        # So, let's try one more time with a dummy API key:
-        params["api_key"] = "x"
 
+    for attempt in range(attempts):
         try:
             yield from litellm.completion(**params)
-        except:
-            # If the second attempt also fails, raise the first error
-            raise first_error
+            return  # If the completion is successful, exit the function
+        except Exception as e:
+            if attempt == 0:
+                # Store the first error
+                first_error = e
+            if (
+                isinstance(e, litellm.exceptions.AuthenticationError)
+                and "api_key" not in params
+            ):
+                print(
+                    "LiteLLM requires an API key. Trying again with a dummy API key. In the future, please set a dummy API key to prevent this message. (e.g `interpreter --api_key x` or `self.api_key = 'x'`)"
+                )
+                # So, let's try one more time with a dummy API key:
+                params["api_key"] = "x"
+            if attempt == 1:
+                # Try turning up the temperature?
+                params["temperature"] = params.get("temperature", 0.0) + 0.1
+
+    if first_error is not None:
+        raise first_error  # If all attempts fail, raise the first error
diff --git a/interpreter/core/respond.py b/interpreter/core/respond.py
@@ -219,6 +219,9 @@ def respond(interpreter):
                     # We need to tell python what we (the generator) should do if they exit
                     break
 
+                # They may have edited the code! Grab it again
+                code = interpreter.messages[-1]["content"]
+
                 # don't let it import computer — we handle that!
                 if interpreter.computer.import_computer_api and language == "python":
                     code = code.replace("import computer\n", "pass\n")
diff --git a/interpreter/terminal_interface/terminal_interface.py b/interpreter/terminal_interface/terminal_interface.py
@@ -13,6 +13,7 @@
 import random
 import re
 import subprocess
+import tempfile
 import time
 
 from ..core.utils.scan_code import scan_code
@@ -286,6 +287,31 @@ def terminal_interface(interpreter, message):
                             active_block.margin_top = False  # <- Aesthetic choice
                             active_block.language = language
                             active_block.code = code
+                        elif response.strip().lower() == "e":
+                            # Edit
+
+                            # Create a temporary file
+                            with tempfile.NamedTemporaryFile(
+                                suffix=".tmp", delete=False
+                            ) as tf:
+                                tf.write(code.encode())
+                                tf.flush()
+
+                            # Open the temporary file with the default editor
+                            subprocess.call([os.environ.get("EDITOR", "vim"), tf.name])
+
+                            # Read the modified code
+                            with open(tf.name, "r") as tf:
+                                code = tf.read()
+
+                            interpreter.messages[-1]["content"] = code  # Give it code
+
+                            # Delete the temporary file
+                            os.unlink(tf.name)
+                            active_block = CodeBlock()
+                            active_block.margin_top = False  # <- Aesthetic choice
+                            active_block.language = language
+                            active_block.code = code
                         else:
                             # User declined to run code.
                             interpreter.messages.append(
diff --git a/poetry.lock b/poetry.lock
diff --git a/pyproject.toml b/pyproject.toml
