mle-kit-mcp 0.0.9__tar.gz → 0.1.1__tar.gz

{mle_kit_mcp-0.0.9 → mle_kit_mcp-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mle-kit-mcp
-Version: 0.0.9
+Version: 0.1.1
 Summary: MCP server that provides different tools for MLE
 Author-email: Ilya Gusev <phoenixilya@gmail.com>
 Project-URL: Homepage, https://github.com/IlyaGusev/mle_kit_mcp

mle_kit_mcp-0.1.1/mle_kit_mcp/llm_proxy_source.py

@@ -0,0 +1,51 @@
+import os
+
+import fire  # type: ignore
+import uvicorn
+from openai import AsyncOpenAI
+from fastapi import FastAPI, Request, HTTPException
+from fastapi.responses import JSONResponse
+
+ACCESS_TOKEN = os.getenv("ACCESS_TOKEN", "")
+OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY", "")
+OPENROUTER_BASE_URL = os.getenv("OPENROUTER_BASE_URL", "https://openrouter.ai/api/v1")
+
+app = FastAPI()
+client = AsyncOpenAI(base_url=OPENROUTER_BASE_URL, api_key=OPENROUTER_API_KEY)
+
+
+def _check_auth(request: Request) -> None:
+    auth = request.headers.get("authorization", "")
+    if not ACCESS_TOKEN or auth != f"Bearer {ACCESS_TOKEN}":
+        raise HTTPException(status_code=401, detail="Unauthorized")
+    if not OPENROUTER_API_KEY:
+        raise HTTPException(status_code=500, detail="OpenRouter key not configured")
+
+
+@app.post("/v1/chat/completions")
+async def chat_completions(request: Request) -> JSONResponse:
+    _check_auth(request)
+    payload = await request.json()
+    if isinstance(payload, dict) and payload.get("stream"):
+        payload.pop("stream", None)
+
+    try:
+        resp = await client.chat.completions.create(**payload)
+    except Exception as e:
+        raise HTTPException(status_code=502, detail=str(e))
+    return JSONResponse(resp.model_dump())
+
+
+@app.get("/health")
+async def health() -> JSONResponse:
+    if not OPENROUTER_API_KEY:
+        return JSONResponse({"error": "missing OPENROUTER_API_KEY"}, 500)
+    return JSONResponse({"result": "ok"})
+
+
+def main(host: str = "127.0.0.1", port: int = 8001) -> None:
+    uvicorn.run("llm_proxy:app", host=host, port=port)
+
+
+if __name__ == "__main__":
+    fire.Fire(main)

{mle_kit_mcp-0.0.9 → mle_kit_mcp-0.1.1}/mle_kit_mcp/server.py

@@ -1,3 +1,4 @@
+import os
 from pathlib import Path
 from typing import Optional
 
@@ -12,6 +13,10 @@ from .tools.remote_gpu import (
     create_remote_text_editor,
     remote_download,
 )
+from .tools.llm_proxy import (
+    llm_proxy_local,
+    llm_proxy_remote,
+)
 from .files import get_workspace_dir, WorkspaceDirectory
 
 
@@ -30,6 +35,9 @@ def run(host: str = "0.0.0.0", port: int = 5050, workspace: Optional[str] = None
     server.add_tool(remote_bash)
     server.add_tool(remote_text_editor)
     server.add_tool(remote_download)
+    if os.getenv("OPENROUTER_API_KEY"):
+        server.add_tool(llm_proxy_local)
+        server.add_tool(llm_proxy_remote)
 
     http_app = server.streamable_http_app()
 

{mle_kit_mcp-0.0.9 → mle_kit_mcp-0.1.1}/mle_kit_mcp/tools/__init__.py

@@ -4,6 +4,10 @@ from .remote_gpu import (
     remote_bash,
     remote_download,
 )
+from .llm_proxy import (
+    llm_proxy_local,
+    llm_proxy_remote,
+)
 
 
 __all__ = [
@@ -11,4 +15,6 @@ __all__ = [
     "text_editor",
     "remote_bash",
     "remote_download",
+    "llm_proxy_local",
+    "llm_proxy_remote",
 ]

{mle_kit_mcp-0.0.9 → mle_kit_mcp-0.1.1}/mle_kit_mcp/tools/bash.py

@@ -1,8 +1,11 @@
-import docker  # type: ignore
 import atexit
 import signal
 from typing import Optional, Any
 
+from docker import from_env as docker_from_env  # type: ignore
+from docker import DockerClient
+from docker.models.containers import Container  # type: ignore
+
 from mle_kit_mcp.files import get_workspace_dir
 
 
@@ -13,6 +16,40 @@ BASE_IMAGE = "python:3.12-slim"
 DOCKER_WORKSPACE_DIR_PATH = "/workdir"
 
 
+def get_docker_client() -> DockerClient:
+    global _client
+    if not _client:
+        _client = docker_from_env()
+    return _client
+
+
+def create_container() -> Container:
+    client = get_docker_client()
+    container = client.containers.run(
+        BASE_IMAGE,
+        "tail -f /dev/null",
+        detach=True,
+        remove=True,
+        tty=True,
+        stdin_open=True,
+        volumes={
+            get_workspace_dir(): {
+                "bind": DOCKER_WORKSPACE_DIR_PATH,
+                "mode": "rw",
+            }
+        },
+        working_dir=DOCKER_WORKSPACE_DIR_PATH,
+    )
+    return container
+
+
+def get_container() -> Container:
+    global _container
+    if not _container:
+        _container = create_container()
+    return _container
+
+
 def cleanup_container(signum: Optional[Any] = None, frame: Optional[Any] = None) -> None:
     global _container
     if _container:
@@ -30,7 +67,7 @@ signal.signal(signal.SIGINT, cleanup_container)
 signal.signal(signal.SIGTERM, cleanup_container)
 
 
-def bash(command: str) -> str:
+def bash(command: str, cwd: Optional[str] = None) -> str:
     """
     Run commands in a bash shell.
     When invoking this tool, the contents of the "command" parameter does NOT need to be XML-escaped.
@@ -43,37 +80,16 @@ def bash(command: str) -> str:
 
     Args:
         command: The bash command to run.
+        cwd: The working directory to run the command in. Relative to the workspace directory.
     """
 
-    global _container, _client
-
-    if not _client:
-        _client = docker.from_env()
-
-    if not _container:
-        try:
-            _container = _client.containers.get("bash_runner")
-        except docker.errors.NotFound:
-            _container = _client.containers.run(
-                BASE_IMAGE,
-                "tail -f /dev/null",
-                detach=True,
-                remove=True,
-                name="bash_runner",
-                tty=True,
-                stdin_open=True,
-                volumes={
-                    get_workspace_dir(): {
-                        "bind": DOCKER_WORKSPACE_DIR_PATH,
-                        "mode": "rw",
-                    }
-                },
-                working_dir=DOCKER_WORKSPACE_DIR_PATH,
-            )
-
-    result = _container.exec_run(
+    container = get_container()
+    workdir = DOCKER_WORKSPACE_DIR_PATH
+    if cwd:
+        workdir = DOCKER_WORKSPACE_DIR_PATH + "/" + cwd
+    result = container.exec_run(
         ["bash", "-c", command],
-        workdir=DOCKER_WORKSPACE_DIR_PATH,
+        workdir=workdir,
         stdout=True,
         stderr=True,
     )

mle_kit_mcp-0.1.1/mle_kit_mcp/tools/llm_proxy.py

@@ -0,0 +1,148 @@
+import os
+import json
+import time
+import random
+import secrets
+from pathlib import Path
+from typing import Optional
+
+from dotenv import load_dotenv
+
+from mle_kit_mcp.tools.bash import get_container
+from mle_kit_mcp.files import get_workspace_dir
+from mle_kit_mcp.utils import find_free_port
+
+from mle_kit_mcp.tools.remote_gpu import (
+    get_instance as _remote_get_instance,
+    run_command as _remote_run_command,
+    send_rsync as _remote_send_rsync,
+)
+
+INPUT_SCRIPT_FILE_NAME = "llm_proxy_source.py"
+OUTPUT_SCRIPT_FILE_NAME = "llm_proxy.py"
+DEPENDENCIES = "fastapi uvicorn httpx openai fire"
+START_TIMEOUT = 30
+
+
+def _write_proxy_script(script_path: Path) -> None:
+    source_script_path = Path(__file__).parent.parent / INPUT_SCRIPT_FILE_NAME
+    script = source_script_path.read_text()
+    script_path.write_text(script)
+
+
+def llm_proxy_local(port: Optional[int] = None) -> str:
+    """
+    Start a lightweight OpenRouter proxy inside the same Docker container used by the "bash" tool.
+
+    Returns a JSON string with fields: url, token, scope.
+    The url is reachable from inside the "bash" container as localhost.
+    Use the token in the Authorization header: "Bearer <token>" when calling the proxy.
+    It runs a standard OpenAI compatible server, so you can use it with any OpenAI compatible client.
+    You can use all models available on OpenRouter, for instance:
+    - openai/gpt-5-mini
+    - google/gemini-2.5-pro
+    - anthropic/claude-sonnet-4
+
+    Args:
+        port: Optional fixed port to bind inside the container. Random if omitted.
+    """
+
+    load_dotenv()
+    api_key = os.getenv("OPENROUTER_API_KEY")
+    assert api_key, "Set OPENROUTER_API_KEY in the environment before starting the proxy."
+
+    _write_proxy_script(get_workspace_dir() / OUTPUT_SCRIPT_FILE_NAME)
+
+    container = get_container()
+    dependencies_cmd = f"python -m pip install --quiet --no-input {DEPENDENCIES}"
+    container.exec_run(["bash", "-lc", dependencies_cmd])
+
+    chosen_port = port or find_free_port()
+    token = secrets.token_urlsafe(24)
+    launch_cmd = (
+        f"OPENROUTER_API_KEY='{api_key}' ACCESS_TOKEN='{token}' "
+        f"nohup python {OUTPUT_SCRIPT_FILE_NAME} "
+        f"--host 127.0.0.1 --port {chosen_port} "
+        f"> llm_proxy.log 2>&1 "
+        f"& echo $! > llm_proxy.pid"
+    )
+    container.exec_run(["bash", "-lc", launch_cmd])
+
+    health_cmd = f'import httpx; print(httpx.get("http://127.0.0.1:{chosen_port}/health").json())'
+    start_time = time.time()
+    while time.time() - start_time < START_TIMEOUT:
+        result = container.exec_run(["python", "-c", health_cmd])
+        if result.exit_code == 0 and "ok" in result.output.decode("utf-8").strip():
+            break
+        time.sleep(1)
+    else:
+        raise Exception("Failed to start the proxy")
+
+    return json.dumps(
+        {
+            "url": f"http://127.0.0.1:{chosen_port}/v1/chat/completions",
+            "token": token,
+            "scope": "bash-container",
+        }
+    )
+
+
+def llm_proxy_remote(port: Optional[int] = None) -> str:
+    """
+    Start a lightweight OpenRouter proxy on the remote GPU machine.
+
+    Returns a JSON string with fields: url, token, scope.
+    The url is reachable from inside the remote machine as localhost.
+    Use the token in the Authorization header: "Bearer <token>" when calling the proxy.
+    It runs a standard OpenAI compatible server, so you can use it with any OpenAI compatible client.
+    You can use all models available on OpenRouter, for instance:
+    - openai/gpt-5-mini
+    - google/gemini-2.5-pro
+    - anthropic/claude-sonnet-4
+
+    Args:
+        port: Optional fixed port to bind on the remote. Random if omitted.
+    """
+
+    load_dotenv()
+    api_key = os.getenv("OPENROUTER_API_KEY")
+    assert api_key, "Set OPENROUTER_API_KEY in the environment before starting the proxy."
+
+    instance = _remote_get_instance()
+    script_path = get_workspace_dir() / OUTPUT_SCRIPT_FILE_NAME
+    _write_proxy_script(script_path)
+    _remote_send_rsync(instance, f"{script_path}", "/root")
+
+    chosen_port = port or random.randint(5000, 6000)
+    token = secrets.token_urlsafe(24)
+    dependencies_cmd = f"python3 -m pip install -q --no-input {DEPENDENCIES}"
+    _remote_run_command(instance, dependencies_cmd, timeout=300, raise_exc=True)
+
+    launch_cmd = (
+        f"OPENROUTER_API_KEY='{api_key}' ACCESS_TOKEN='{token}' "
+        f"nohup python {OUTPUT_SCRIPT_FILE_NAME} "
+        f"--host 127.0.0.1 --port {chosen_port} "
+        f"> openrouter_proxy.log 2>&1 "
+        f"& echo $! > openrouter_proxy.pid"
+    )
+    _remote_run_command(instance, launch_cmd, timeout=60, raise_exc=True)
+
+    health_cmd = f'import httpx; print(httpx.get("http://127.0.0.1:{chosen_port}/health").json())'
+    start_time = time.time()
+    while time.time() - start_time < START_TIMEOUT:
+        result = _remote_run_command(
+            instance, f"python -c '{health_cmd}'", timeout=10, raise_exc=False
+        )
+        if result.returncode == 0 and "ok" in result.stdout.strip():
+            break
+        time.sleep(1)
+    else:
+        raise Exception("Failed to start the proxy")
+
+    return json.dumps(
+        {
+            "url": f"http://127.0.0.1:{chosen_port}/v1/chat/completions",
+            "token": token,
+            "scope": "remote-gpu",
+        }
+    )

{mle_kit_mcp-0.0.9 → mle_kit_mcp-0.1.1}/mle_kit_mcp/tools/remote_gpu.py

@@ -36,7 +36,28 @@ _sdk: Optional[VastAI] = None
 _instance_info: Optional[InstanceInfo] = None
 
 
-def cleanup_machine(signum: Optional[Any] = None, frame: Optional[Any] = None) -> None:
+def get_sdk() -> VastAI:
+    global _sdk
+    if not _sdk:
+        _sdk = VastAI(api_key=os.getenv("VAST_AI_KEY"))
+    return _sdk
+
+
+def get_instance() -> InstanceInfo:
+    load_dotenv()
+    signal.alarm(GLOBAL_TIMEOUT)
+    global _instance_info
+    if not _instance_info:
+        _instance_info = launch_instance(get_sdk(), DEFAULT_GPU_TYPE)
+
+    if _instance_info:
+        send_scripts()
+
+    assert _instance_info, "Failed to connect to a remote instance! Try again"
+    return _instance_info
+
+
+def cleanup_instance(signum: Optional[Any] = None, frame: Optional[Any] = None) -> None:
     global _instance_info
     signal.alarm(0)
     if _instance_info and _sdk:
@@ -50,10 +71,10 @@ def cleanup_machine(signum: Optional[Any] = None, frame: Optional[Any] = None) -
         raise KeyboardInterrupt()
 
 
-atexit.register(cleanup_machine)
-signal.signal(signal.SIGINT, cleanup_machine)
-signal.signal(signal.SIGTERM, cleanup_machine)
-signal.signal(signal.SIGALRM, cleanup_machine)
+atexit.register(cleanup_instance)
+signal.signal(signal.SIGINT, cleanup_instance)
+signal.signal(signal.SIGTERM, cleanup_instance)
+signal.signal(signal.SIGALRM, cleanup_instance)
 
 
 def wait_for_instance(vast_sdk: VastAI, instance_id: str, max_wait_time: int = 300) -> bool:
@@ -264,25 +285,6 @@ def send_scripts() -> None:
             send_rsync(_instance_info, f"{get_workspace_dir()}/{name}", "/root")
 
 
-def init_all() -> None:
-    global _sdk, _instance_info
-
-    load_dotenv()
-
-    if not _sdk:
-        _sdk = VastAI(api_key=os.getenv("VAST_AI_KEY"))
-    assert _sdk
-
-    signal.alarm(GLOBAL_TIMEOUT)
-    if not _instance_info:
-        _instance_info = launch_instance(_sdk, DEFAULT_GPU_TYPE)
-
-    if _instance_info:
-        send_scripts()
-
-    assert _instance_info, "Failed to connect to a remote instance! Try again"
-
-
 def remote_bash(command: str, timeout: int = 60) -> str:
     """
     Run commands in a bash shell on a remote machine with GPU cards.
@@ -300,10 +302,10 @@ def remote_bash(command: str, timeout: int = 60) -> str:
         timeout: Timeout for the command execution. 60 seconds by default. Set a higher value for heavy jobs.
     """
 
-    init_all()
-    assert _instance_info
+    instance = get_instance()
+    assert instance
     assert timeout
-    result = run_command(_instance_info, command, timeout=timeout, raise_exc=False)
+    result = run_command(instance, command, timeout=timeout, raise_exc=False)
     output = ("STDOUT: " + result.stdout + "\n") if result.stdout else ""
     output += ("STDERR: " + result.stderr) if result.stderr else ""
     return output.replace(VAST_AI_GREETING, "")
@@ -316,9 +318,9 @@ def remote_download(file_path: str) -> str:
     Args:
         file_path: Path to the file on a remote machine.
     """
-    init_all()
-    assert _instance_info
-    recieve_rsync(_instance_info, f"/root/{file_path}", f"{get_workspace_dir()}")
+    instance = get_instance()
+    assert instance
+    recieve_rsync(instance, f"/root/{file_path}", f"{get_workspace_dir()}")
     return f"File '{file_path}' downloaded!"
 
 
@@ -327,8 +329,7 @@ def create_remote_text_editor(
 ) -> Callable[..., str]:
     @functools.wraps(text_editor_func)
     def wrapper(*args: Any, **kwargs: Any) -> str:
-        init_all()
-        assert _instance_info
+        instance = get_instance()
 
         args_dict = {k: v for k, v in kwargs.items()}
         if args:
@@ -337,12 +338,12 @@ def create_remote_text_editor(
         command = args_dict["command"]
 
         if command != "write":
-            recieve_rsync(_instance_info, f"/root/{path}", f"{get_workspace_dir()}")
+            recieve_rsync(instance, f"/root/{path}", f"{get_workspace_dir()}")
 
         result: str = text_editor_func(*args, **kwargs)
 
         if command != "view":
-            send_rsync(_instance_info, f"{get_workspace_dir()}/{path}", "/root")
+            send_rsync(instance, f"{get_workspace_dir()}/{path}", "/root")
 
         return result
 

{mle_kit_mcp-0.0.9 → mle_kit_mcp-0.1.1}/mle_kit_mcp/tools/text_editor.py

@@ -50,17 +50,23 @@ def _insert(path: Path, insert_line: int, new_str: str) -> str:
     return truncate_content(new_content, WRITE_MAX_OUTPUT_LENGTH, target_line=insert_line)
 
 
-def _str_replace(path: Path, old_str: str, new_str: str) -> str:
+def _str_replace(path: Path, old_str: str, new_str: str, dry_run: bool = False) -> str:
     assert path.is_file(), f"File not found: {path}"
     content = path.open().read()
     count = content.count(old_str)
     assert count != 0, "old_str not found in file"
     assert count == 1, "old_str is not unique in file"
     target_line = content[: content.find(old_str) + len(old_str)].count("\n")
-    _save_file_state(path, content.splitlines(True))
     new_content = content.replace(old_str, new_str)
-    path.write_text(new_content)
-    return truncate_content(new_content, WRITE_MAX_OUTPUT_LENGTH, target_line=target_line)
+    if not dry_run:
+        _save_file_state(path, content.splitlines(True))
+        path.write_text(new_content)
+    display_content = truncate_content(
+        new_content, WRITE_MAX_OUTPUT_LENGTH, target_line=target_line
+    )
+    if dry_run:
+        display_content = f"Dry run:\n{display_content}"
+    return display_content
 
 
 def _undo_edit(path: Path) -> str:
@@ -129,6 +135,7 @@ def text_editor(
     view_start_line: Optional[int] = None,
     view_end_line: Optional[int] = None,
     show_lines: Optional[bool] = False,
+    dry_run: Optional[bool] = False,
 ) -> str:
     """
     Custom editing tool for viewing, creating and editing files.
@@ -167,6 +174,7 @@ def text_editor(
         new_str: Required for `str_replace`, `insert` and `append`.
         old_str: Required for `str_replace` containing the string in `path` to replace.
         show_lines: Optional for view command. If True, the command will also output line numbers.
+        dry_run: Optional for `str_replace` command. If True, the command won't modify the file but will display the result.
     """
     assert not path.startswith(
         "/"
@@ -191,7 +199,8 @@ def text_editor(
     if command == "str_replace":
         assert old_str is not None, "'old_str' is required for 'str_replace' command"
         assert new_str is not None, "'new_str' is required for 'str_replace' command"
-        return _str_replace(path_obj, old_str, new_str)
+        assert dry_run is not None
+        return _str_replace(path_obj, old_str, new_str, dry_run=dry_run)
     if command == "undo_edit":
         return _undo_edit(path_obj)
     assert False, f"Not a valid command! List of commands: {valid_commands}"

{mle_kit_mcp-0.0.9 → mle_kit_mcp-0.1.1}/mle_kit_mcp/utils.py

@@ -1,3 +1,5 @@
+import random
+import socket
 from typing import Optional
 
 
@@ -48,3 +50,16 @@ def truncate_content(
     prefix = content[:half_length]
     suffix = content[-half_length:]
     return prefix + disclaimer + suffix
+
+
+def find_free_port() -> Optional[int]:
+    ports = list(range(5000, 6001))
+    random.shuffle(ports)
+    for port in ports:
+        try:
+            with socket.socket() as s:
+                s.bind(("", port))
+                return port
+        except OSError:
+            continue
+    return None

{mle_kit_mcp-0.0.9 → mle_kit_mcp-0.1.1}/mle_kit_mcp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mle-kit-mcp
-Version: 0.0.9
+Version: 0.1.1
 Summary: MCP server that provides different tools for MLE
 Author-email: Ilya Gusev <phoenixilya@gmail.com>
 Project-URL: Homepage, https://github.com/IlyaGusev/mle_kit_mcp

{mle_kit_mcp-0.0.9 → mle_kit_mcp-0.1.1}/mle_kit_mcp.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ pyproject.toml
 mle_kit_mcp/__init__.py
 mle_kit_mcp/__main__.py
 mle_kit_mcp/files.py
+mle_kit_mcp/llm_proxy_source.py
 mle_kit_mcp/py.typed
 mle_kit_mcp/server.py
 mle_kit_mcp/utils.py
@@ -15,8 +16,10 @@ mle_kit_mcp.egg-info/requires.txt
 mle_kit_mcp.egg-info/top_level.txt
 mle_kit_mcp/tools/__init__.py
 mle_kit_mcp/tools/bash.py
+mle_kit_mcp/tools/llm_proxy.py
 mle_kit_mcp/tools/remote_gpu.py
 mle_kit_mcp/tools/text_editor.py
 tests/test_bash.py
+tests/test_llm_proxy.py
 tests/test_text_editor.py
 tests/test_truncate_context.py

{mle_kit_mcp-0.0.9 → mle_kit_mcp-0.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mle-kit-mcp"
-version = "0.0.9"
+version = "0.1.1"
 description = "MCP server that provides different tools for MLE"
 readme = "README.md"
 authors = [

{mle_kit_mcp-0.0.9 → mle_kit_mcp-0.1.1}/tests/test_bash.py

@@ -16,3 +16,9 @@ def test_bash() -> None:
 
     result = bash("fddafad")
     assert "fddafad: command not found" in result
+
+
+def test_bash_cwd() -> None:
+    bash("mkdir -p dummy_dir")
+    bash("touch dummy", cwd="dummy_dir")
+    assert os.path.exists(get_workspace_dir() / "dummy_dir" / "dummy")

mle_kit_mcp-0.1.1/tests/test_llm_proxy.py

@@ -0,0 +1,24 @@
+import json
+from mle_kit_mcp.tools import llm_proxy_local, bash
+
+
+QUERY_SNIPPET = """
+import httpx
+headers = {{'Authorization': 'Bearer {token}'}}
+json_payload = {{'model': 'gpt-4o', 'messages': [{{'role': 'user', 'content': 'Hello, how are you?'}}]}}
+response = httpx.post("{url}", headers=headers, json=json_payload)
+print(response.json())
+"""
+
+
+def test_llm_proxy_local():
+    result = json.loads(llm_proxy_local(port=8001))
+    token = result["token"]
+    url = result["url"]
+    assert url
+    assert token
+
+    snippet = QUERY_SNIPPET.format(url=url, token=token)
+    result = bash(f'cat > test_query.py << "EOF"\n{snippet}\nEOF')
+    result = bash("python test_query.py")
+    assert "content" in result

{mle_kit_mcp-0.0.9 → mle_kit_mcp-0.1.1}/tests/test_text_editor.py

@@ -87,6 +87,18 @@ def test_text_editor_str_replace() -> None:
         assert "41.9" in new_content and "41.8" not in new_content
 
 
+def test_text_editor_str_replace_dry_run() -> None:
+    with tempfile.NamedTemporaryFile(dir=get_workspace_dir(), mode="w+") as f:
+        name = os.path.basename(f.name)
+        test_file = get_workspace_dir() / name
+        test_file.write_text(DOCUMENT1)
+
+        result = text_editor("str_replace", name, old_str="41.8", new_str="41.9", dry_run=True)
+        new_content = test_file.open().read()
+        assert "41.9" not in new_content and "41.8" in new_content
+        assert "Dry run" in result
+
+
 def test_text_editor_undo_edit() -> None:
     with tempfile.NamedTemporaryFile(dir=get_workspace_dir(), mode="w+") as f:
         name = os.path.basename(f.name)