@openhands/extensions 0.28.0 → 0.30.0

package/tests/test_gitlab_issue_to_mr.py

@@ -35,6 +35,62 @@ def main(monkeypatch, tmp_path):
     return _load_module(monkeypatch, tmp_path / "workspace")
 
 
+CLOUD_URL = "https://app.example.test"
+GITLAB_MCP_URL = "https://gitlab.com/api/v4/mcp"
+CALL_TOOL_PATH = "/api/v1/mcp/servers/gitlab/call-tool"
+
+
+@pytest.fixture
+def cloud_main(monkeypatch, tmp_path):
+    """The script as a cloud run sees it: handed the OpenHands API, no agent server."""
+    monkeypatch.setenv("OPENHANDS_CLOUD_API_URL", CLOUD_URL)
+    monkeypatch.setenv("OPENHANDS_API_KEY", "openhands-key")
+    monkeypatch.setenv("SANDBOX_ID", "sandbox-1")
+    monkeypatch.setenv("SESSION_API_KEY", "session-key")
+    monkeypatch.delenv("AGENT_SERVER_URL", raising=False)
+    return _load_module(monkeypatch, tmp_path / "workspace")
+
+
+class CloudApi:
+    """Stand-in for the OpenHands API: records every call and answers from a table."""
+
+    def __init__(self, settings=None, tools=None):
+        self.calls = []
+        self.settings = settings or {
+            "agent_settings": {
+                "mcp_config": {
+                    "gitlab": {"url": GITLAB_MCP_URL, "transport": "http"},
+                    "rovo": {"url": "https://mcp.atlassian.com/v2/mcp"},
+                }
+            }
+        }
+        # Tool name -> result dict (what the tool's JSON text decodes to), or a
+        # callable taking the arguments.
+        self.tools = tools or {}
+
+    def __call__(self, method, path, body=None):
+        self.calls.append({"method": method, "path": path, "body": body})
+        if path == "/api/v1/settings":
+            return self.settings
+        if path == CALL_TOOL_PATH:
+            answer = self.tools[body["name"]]
+            if callable(answer):
+                answer = answer(body["arguments"])
+            if isinstance(answer, str):
+                return {"is_error": True, "text": answer}
+            return {"is_error": False, "text": json.dumps(answer)}
+        raise AssertionError(f"unexpected call {method} {path}")
+
+    def tool_calls(self, name):
+        return [c["body"]["arguments"] for c in self.calls if c["path"] == CALL_TOOL_PATH and c["body"]["name"] == name]
+
+
+def _wire(cloud_main, monkeypatch, api):
+    monkeypatch.setattr(cloud_main, "_cloud_request", api)
+    monkeypatch.setattr(cloud_main, "GITLAB_MCP_SERVER", "gitlab")
+    return api
+
+
 def _http_error(code: int, body: bytes = b"{}") -> urllib.error.HTTPError:
     return urllib.error.HTTPError("https://gitlab.com/api/v4", code, "err", {}, None)
 
@@ -397,6 +453,234 @@ def test_the_conversation_carries_the_mcp_config_when_there_is_one(main, monkeyp
     assert sent["body"]["mcp_config"] == config
 
 
+# ── GitLab through a connected MCP server (cloud runs) ────────────────────────
+
+
+def test_a_cloud_run_uses_the_connected_gitlab_mcp_server_and_reads_no_token(cloud_main, monkeypatch):
+    """The MCP connection replaces the token: no secret is read, no token verified."""
+    api = CloudApi()
+    monkeypatch.setattr(cloud_main, "_cloud_request", api)
+    read = []
+    monkeypatch.setattr(cloud_main, "get_secret", lambda name: read.append(name) or "token")
+
+    assert cloud_main._find_gitlab_mcp_server() == "gitlab"
+    assert read == []
+
+
+def test_a_configured_server_name_is_used_without_looking_at_settings(cloud_main, monkeypatch):
+    api = CloudApi()
+    monkeypatch.setattr(cloud_main, "_cloud_request", api)
+    monkeypatch.setattr(cloud_main, "GITLAB_MCP_SERVER_NAME", "my-gitlab")
+
+    assert cloud_main._find_gitlab_mcp_server() == "my-gitlab"
+    assert api.calls == []
+
+
+def test_a_cloud_run_without_a_gitlab_mcp_server_still_resolves_the_token(cloud_main, monkeypatch):
+    """The fallback is unchanged: GITLAB_TOKEN first, then the connected integration's token."""
+    api = CloudApi(settings={"agent_settings": {"mcp_config": {
+        "rovo": {"url": "https://mcp.atlassian.com/v2/mcp"},
+        "other": {"url": "https://gitlab.example.com/api/v4/mcp"},
+    }}})
+    monkeypatch.setattr(cloud_main, "_cloud_request", api)
+
+    def get_secret(name):
+        if name == "gitlab_token":
+            return "integration-token"
+        raise RuntimeError("no such secret")
+
+    monkeypatch.setattr(cloud_main, "get_secret", get_secret)
+
+    assert cloud_main._find_gitlab_mcp_server() is None
+    assert cloud_main._resolve_gitlab_token() == "integration-token"
+
+
+def test_the_cloud_error_for_no_gitlab_access_names_every_option(cloud_main, monkeypatch):
+    def get_secret(name):
+        raise RuntimeError("no such secret")
+
+    monkeypatch.setattr(cloud_main, "get_secret", get_secret)
+
+    with pytest.raises(RuntimeError) as excinfo:
+        cloud_main._resolve_gitlab_token()
+
+    message = str(excinfo.value)
+    assert "GitLab MCP server" in message
+    assert "GitLab integration" in message
+    assert "GITLAB_TOKEN" in message
+
+
+def test_a_gitlab_token_secret_wins_over_a_connected_gitlab_mcp_server(cloud_main, monkeypatch):
+    """The MCP tools need GitLab 19.4 or later, while a token works with any GitLab."""
+    api = CloudApi()
+    monkeypatch.setattr(cloud_main, "_cloud_request", api)
+    monkeypatch.setattr(
+        cloud_main, "get_secret", lambda name: "secret-token" if name == "GITLAB_TOKEN" else ""
+    )
+    verified = []
+    monkeypatch.setattr(cloud_main, "_verify_token", verified.append)
+
+    assert cloud_main._choose_gitlab_access() == "secret-token"
+    assert cloud_main.GITLAB_MCP_SERVER is None
+    assert verified == ["secret-token"]
+    assert api.calls == []
+
+
+def test_the_gitlab_sign_in_token_wins_over_a_connected_gitlab_mcp_server(cloud_main, monkeypatch):
+    """A user who signed in with GitLab is not asked for a GITLAB_TOKEN secret on top."""
+    api = CloudApi()
+    monkeypatch.setattr(cloud_main, "_cloud_request", api)
+
+    def get_secret(name):
+        if name == "gitlab_token":
+            return "sign-in-token"
+        raise RuntimeError("no such secret")
+
+    monkeypatch.setattr(cloud_main, "get_secret", get_secret)
+    verified = []
+    monkeypatch.setattr(cloud_main, "_verify_token", verified.append)
+
+    assert cloud_main._choose_gitlab_access() == "sign-in-token"
+    assert cloud_main.GITLAB_MCP_SERVER is None
+    assert verified == ["sign-in-token"]
+    assert api.calls == []
+
+
+def _no_secrets(name):
+    raise RuntimeError("no such secret")
+
+
+def test_without_any_gitlab_token_the_connected_gitlab_mcp_server_is_used(cloud_main, monkeypatch):
+    monkeypatch.setattr(cloud_main, "_cloud_request", CloudApi())
+    monkeypatch.setattr(cloud_main, "get_secret", _no_secrets)
+    verified = []
+    monkeypatch.setattr(cloud_main, "_verify_token", verified.append)
+
+    assert cloud_main._choose_gitlab_access() == ""
+    assert cloud_main.GITLAB_MCP_SERVER == "gitlab"
+    assert verified == []
+
+
+def test_without_a_token_or_a_gitlab_mcp_server_the_run_says_how_to_connect(cloud_main, monkeypatch):
+    monkeypatch.setattr(
+        cloud_main, "_cloud_request", CloudApi(settings={"agent_settings": {"mcp_config": {}}})
+    )
+    monkeypatch.setattr(cloud_main, "get_secret", _no_secrets)
+
+    with pytest.raises(RuntimeError) as excinfo:
+        cloud_main._choose_gitlab_access()
+
+    message = str(excinfo.value)
+    assert "GitLab integration" in message and "GITLAB_TOKEN" in message
+
+
+def test_labelled_issues_are_listed_through_the_mcp_server(cloud_main, monkeypatch):
+    pages = {
+        None: {"nodes": [
+            {"iid": "42", "title": "Retry uploads", "webUrl": "https://gitlab.com/group/project/-/issues/42",
+             "state": "OPEN", "labels": {"nodes": [{"title": "openhands"}]}},
+        ], "pageInfo": {"hasNextPage": True, "endCursor": "c2"}},
+        "c2": {"nodes": [
+            {"iid": "7", "title": "Old one", "webUrl": "https://gitlab.com/group/project/-/issues/7",
+             "state": "OPEN", "labels": ["openhands", "bug"]},
+        ], "pageInfo": {"hasNextPage": False}},
+    }
+    api = _wire(cloud_main, monkeypatch, CloudApi(tools={
+        "list_work_items": lambda args: pages[args.get("after")],
+    }))
+
+    issues = cloud_main._list_labeled_issues("", "group/project")
+
+    assert [issue["iid"] for issue in issues] == [42, 7]
+    assert issues[0]["web_url"] == "https://gitlab.com/group/project/-/issues/42"
+    assert cloud_main._has_trigger_label(issues[0]) and cloud_main._has_trigger_label(issues[1])
+    first, second = api.tool_calls("list_work_items")
+    assert first["project_id"] == "group/project"
+    assert first["state"] == "opened"
+    assert first["label_name"] == ["openhands"]
+    assert second["after"] == "c2"
+
+
+def test_the_label_event_is_the_newest_system_note_that_added_the_label(cloud_main, monkeypatch):
+    api = _wire(cloud_main, monkeypatch, CloudApi(tools={
+        "search_labels": {"nodes": [{"id": "gid://gitlab/ProjectLabel/99", "title": "openhands"}]},
+        "get_work_item": {"iid": "42", "notes": {"nodes": [
+            {"id": "gid://gitlab/Note/1", "system": True, "body": "added ~99 label", "createdAt": "2026-01-01T00:00:00Z"},
+            {"id": "gid://gitlab/Note/2", "system": False, "body": "added ~99 label", "createdAt": "2026-01-02T00:00:00Z"},
+            {"id": "gid://gitlab/Note/3", "system": True, "body": "added ~\"openhands\" label", "createdAt": "2026-01-03T00:00:00Z"},
+            {"id": "gid://gitlab/Note/4", "system": True, "body": "removed ~\"openhands\" label", "createdAt": "2026-01-04T00:00:00Z"},
+        ], "pageInfo": {"hasNextPage": False}}},
+    }))
+
+    event = cloud_main._latest_trigger_label_event("", "group/project", 42)
+
+    assert event == {"id": "gid://gitlab/Note/3", "created_at": "2026-01-03T00:00:00Z"}
+    [call] = api.tool_calls("get_work_item")
+    assert call["work_item_iid"] == 42 and "notes" in call["include"]
+
+
+def test_an_issue_without_a_label_note_is_keyed_once(cloud_main, monkeypatch):
+    _wire(cloud_main, monkeypatch, CloudApi(tools={
+        "search_labels": {"nodes": []},
+        "get_work_item": {"iid": "42", "createdAt": "2026-01-01T00:00:00Z", "notes": {"nodes": []}},
+    }))
+
+    event = cloud_main._latest_trigger_label_event("", "group/project", 42)
+
+    assert event == {"id": "first", "created_at": "2026-01-01T00:00:00Z"}
+
+
+def test_branches_are_probed_and_merge_requests_found_through_the_mcp_server(cloud_main, monkeypatch):
+    api = _wire(cloud_main, monkeypatch, CloudApi(tools={
+        "list_branches": lambda args: [{"name": "openhands/issue-42"}, {"name": "openhands/issue-42-x"}]
+        if args["search"] == "openhands/issue-42" else [],
+        "get_work_item": {"iid": "42", "relatedMergeRequests": {"nodes": [
+            {"iid": "5", "sourceBranch": "other", "webUrl": "https://gitlab.com/group/project/-/merge_requests/5"},
+            {"iid": "6", "sourceBranch": "openhands/issue-42-2", "webUrl": "https://gitlab.com/group/project/-/merge_requests/6"},
+        ]}},
+    }))
+
+    assert cloud_main._branch_name("", "group/project", 42) == "openhands/issue-42-2"
+    assert api.tool_calls("list_branches")[0] == {"id": "group/project", "search": "openhands/issue-42", "per_page": 100}
+
+    found = cloud_main._existing_merge_request("", "group/project", "openhands/issue-42-2", iid=42)
+
+    assert found["web_url"] == "https://gitlab.com/group/project/-/merge_requests/6"
+    assert found["iid"] == 6
+    assert cloud_main._existing_merge_request("", "group/project", "openhands/issue-42", iid=42) is None
+
+
+def test_comments_go_through_the_mcp_server(cloud_main, monkeypatch):
+    api = _wire(cloud_main, monkeypatch, CloudApi(tools={"save_note": {"id": "gid://gitlab/Note/9"}}))
+
+    cloud_main._post_gitlab_comment("", "group/project", 42, "hello")
+
+    assert api.tool_calls("save_note") == [{"project_id": "group/project", "work_item_iid": 42, "body": "hello"}]
+
+
+def test_the_cloud_prompt_in_mcp_mode_delivers_through_the_tools(cloud_main, monkeypatch):
+    monkeypatch.setattr(cloud_main, "GITLAB_MCP_SERVER", "gitlab")
+    prompt = _prompt(cloud_main)
+
+    for tool in ("get_work_item", "add_branch", "add_commit", "save_merge_request", "get_repository_file"):
+        assert f"`{tool}`" in prompt
+    assert "private" in prompt
+    assert "GITLAB_TOKEN" not in prompt
+    assert "git push" not in prompt
+    assert "Closes #42" in prompt and "GITLAB_MR_OPENED" in prompt
+    assert '"Draft: [#42] Retry uploads"' in prompt
+    assert "untrusted input" in prompt
+
+
+def test_the_cloud_prompt_in_token_mode_is_unchanged(cloud_main, monkeypatch):
+    monkeypatch.setattr(cloud_main, "GITLAB_MCP_SERVER", None)
+    prompt = _prompt(cloud_main)
+
+    assert "git push" in prompt and "$GITLAB_TOKEN" in prompt
+    assert "Authorization: Bearer $GITLAB_TOKEN" in prompt
+    assert "`add_commit`" not in prompt
+
+
 # ── Issue discovery ───────────────────────────────────────────────────────────
 
 

package/tests/test_jira_issue_to_pr.py

@@ -30,6 +30,33 @@ ISSUE = {
 }
 # A baseline from before the issue was updated, so the issue counts as new.
 STATE = {"processed_keys": [], "first_run_at": "2020-01-01T00:00:00+00:00"}
+# A deployment that reaches Jira through the user's connected MCP server.
+MCP_CONFIG = {"jira_mcp_server": "atlassian-rovo", "jira_cloud_id": "cloud-1"}
+MCP_TOOL_PATH = "/api/v1/mcp/servers/atlassian-rovo/call-tool"
+# What the conversation for ISSUE is asked when no git provider is configured. The
+# Jira to GitHub PR template relies on this text staying as it is.
+GITHUB_PROMPT = """Create a GitHub Pull Request for the following Jira issue.
+
+Jira Issue : ENG-1
+Summary    : Add a README
+Description: No description provided.
+
+Steps:
+1. Find the target GitHub repository in the Description above. Look for a reference in
+   "owner/repo" format (e.g. "acme-org/backend") or a full GitHub URL
+   (e.g. "https://github.com/acme-org/backend"). Use that repository.
+   If no repository is mentioned, create a file `jira/ENG-1/notes.md` with the issue
+   details and print a message explaining that no GitHub repo was found in the ticket.
+2. Clone the repository (e.g. https://github.com/<owner>/<repo>).
+3. Create branch `jira/eng-1` from the default branch.
+4. Implement the changes described in the issue.
+   If the description is vague or missing, create `jira/ENG-1/notes.md`
+   with the issue key, summary, and description as a placeholder.
+5. Commit, push the branch, and open a Pull Request:
+   - Title : [ENG-1] Add a README
+   - Body  : Reference the Jira issue key and describe the changes made.
+6. Print the PR URL when done.
+"""
 
 
 class StubServer:
@@ -41,19 +68,24 @@ class StubServer:
         # reports for the conversations it was asked to start.
         self.state = dict(STATE)
         self.start_tasks = []
+        # Set to make the connected MCP server report a failed tool call.
+        self.mcp_error = None
+        # The name the connected MCP server offers its comment tool under.
+        self.mcp_comment_tool = "addOrEditJiraIssueComment"
         stub = self
 
         class Handler(BaseHTTPRequestHandler):
             def _handle(self):
                 length = int(self.headers.get("Content-Length") or 0)
                 body = self.rfile.read(length) if length else b""
-                stub.requests.append({
+                request = {
                     "method": self.command,
                     "path": self.path,
                     "headers": {k.lower(): v for k, v in self.headers.items()},
                     "body": json.loads(body) if body else None,
-                })
-                status, payload = stub.respond(self.path)
+                }
+                stub.requests.append(request)
+                status, payload = stub.respond(self.path, request["body"])
                 data = payload.encode() if isinstance(payload, str) else json.dumps(payload).encode()
                 self.send_response(status)
                 self.send_header("Content-Length", str(len(data)))
@@ -69,7 +101,14 @@ class StubServer:
         self.url = f"http://127.0.0.1:{self.httpd.server_port}"
         threading.Thread(target=self.httpd.serve_forever, daemon=True).start()
 
-    def respond(self, path):
+    def respond(self, path, body):
+        if path == MCP_TOOL_PATH:
+            if self.mcp_error:
+                return 200, {"is_error": True, "text": self.mcp_error}
+            if body["name"] not in ("searchJiraIssuesUsingJql", self.mcp_comment_tool):
+                return 200, {"is_error": True, "text": f"Tool {body['name']!r} not advertised by server"}
+            found = {"issues": [ISSUE]} if body["name"] == "searchJiraIssuesUsingJql" else {}
+            return 200, {"is_error": False, "text": json.dumps(found)}
         if path == "/rest/api/3/search/jql":
             return 200, {"issues": [ISSUE]}
         if path.startswith("/rest/api/3/issue/"):
@@ -93,6 +132,9 @@ class StubServer:
     def find(self, method, path):
         return [r for r in self.requests if r["method"] == method and r["path"] == path]
 
+    def mcp_calls(self, tool):
+        return [r for r in self.find("POST", MCP_TOOL_PATH) if r["body"]["name"] == tool]
+
 
 @pytest.fixture
 def stub():
@@ -103,11 +145,11 @@ def stub():
 
 @pytest.fixture
 def run_script(stub, tmp_path):
-    def run(env):
+    def run(env, config=None):
         workdir = tmp_path / "run"
         workdir.mkdir()
         shutil.copy(SCRIPT_PATH, workdir / "main.py")
-        (workdir / "config.json").write_text(json.dumps({
+        (workdir / "config.json").write_text(json.dumps(config or {
             "jira_base_url": stub.url,
             "jira_email": "alice@example.test",
             "jira_token_secret": "JIRA_CLOUD_KEY",
@@ -154,6 +196,10 @@ def comment_text(comment):
     return comment["body"]["body"]["content"][0]["content"][0]["text"]
 
 
+def prompt_text(conversation):
+    return conversation["body"]["initial_message"]["content"][0]["text"]
+
+
 def test_a_cloud_run_reads_the_jira_token_from_its_sandbox_secrets(stub, run_script):
     # Arrange
     env = cloud_env(stub)
@@ -283,6 +329,154 @@ def test_a_cloud_run_without_the_kv_store_fails_before_dispatching(stub, run_scr
     assert callback["body"]["status"] == "FAILED"
 
 
+def test_a_cloud_run_finds_issues_through_the_connected_mcp_server(stub, run_script):
+    # Arrange
+    env = cloud_env(stub)
+
+    # Act
+    result = run_script(env, MCP_CONFIG)
+
+    # Assert
+    assert result.returncode == 0, result.stderr
+    [search] = stub.mcp_calls("searchJiraIssuesUsingJql")
+    assert search["headers"]["authorization"] == "Bearer openhands-key"
+    assert search["body"]["arguments"]["cloudId"] == "cloud-1"
+    assert 'labels = "create-pr"' in search["body"]["arguments"]["jql"]
+    [conversation] = stub.find("POST", "/api/v1/app-conversations")
+    assert conversation["body"]["title"] == "[ENG-1] Add a README"
+    assert [r for r in stub.requests if "/settings/secrets/" in r["path"]] == []
+
+
+def test_a_cloud_run_links_the_jira_issue_through_the_connected_mcp_server(stub, run_script):
+    # Arrange
+    env = cloud_env(stub)
+
+    # Act
+    result = run_script(env, MCP_CONFIG)
+
+    # Assert
+    assert result.returncode == 0, result.stderr
+    [conversation] = stub.find("POST", "/api/v1/app-conversations")
+    [comment] = stub.mcp_calls("addOrEditJiraIssueComment")
+    conversation_id = conversation["body"]["conversation_id"]
+    assert comment["body"]["arguments"] == {
+        "cloudId": "cloud-1",
+        "issueIdOrKey": "ENG-1",
+        "commentBody": f"I'm on it: {stub.url}/canvas/conversations/{conversation_id}",
+    }
+
+
+def test_a_cloud_run_links_the_jira_issue_when_the_mcp_server_still_has_the_older_comment_tool(stub, run_script):
+    # Arrange
+    stub.mcp_comment_tool = "addCommentToJiraIssue"
+
+    # Act
+    result = run_script(cloud_env(stub), MCP_CONFIG)
+
+    # Assert
+    assert result.returncode == 0, result.stderr
+    [comment] = stub.mcp_calls("addCommentToJiraIssue")
+    assert comment["body"]["arguments"]["issueIdOrKey"] == "ENG-1"
+    assert comment["body"]["arguments"]["commentBody"].startswith("I'm on it: ")
+
+
+def test_a_cloud_run_fails_when_the_connected_mcp_server_reports_an_error(stub, run_script):
+    # Arrange
+    stub.mcp_error = "The MCP server must be authorized again"
+
+    # Act
+    result = run_script(cloud_env(stub), MCP_CONFIG)
+
+    # Assert
+    assert result.returncode == 1
+    assert stub.find("POST", "/api/v1/app-conversations") == []
+    [callback] = stub.find("POST", "/callback")
+    assert callback["body"]["status"] == "FAILED"
+    assert "must be authorized again" in callback["body"]["error"]
+
+
+def test_a_cloud_run_asks_for_a_github_pull_request_when_no_provider_is_configured(stub, run_script):
+    # Act
+    result = run_script(cloud_env(stub), MCP_CONFIG)
+
+    # Assert
+    assert result.returncode == 0, result.stderr
+    [conversation] = stub.find("POST", "/api/v1/app-conversations")
+    assert prompt_text(conversation) == GITHUB_PROMPT
+
+
+def test_a_cloud_run_asks_for_a_gitlab_merge_request_when_the_provider_is_gitlab(stub, run_script):
+    # Act
+    result = run_script(cloud_env(stub), {**MCP_CONFIG, "git_provider": "gitlab"})
+
+    # Assert
+    assert result.returncode == 0, result.stderr
+    [conversation] = stub.find("POST", "/api/v1/app-conversations")
+    prompt = prompt_text(conversation)
+    assert prompt.startswith("Create a GitLab Merge Request for the following Jira issue.")
+    assert '"group/project" format' in prompt
+    assert "self-managed" in prompt
+    assert "https://gitlab.com/<group>/<project>" in prompt
+    assert "Print the MR URL" in prompt
+    assert "github.com" not in prompt
+    # Without a git credential the conversation delivers through the GitLab MCP tools.
+    for tool in ("add_branch", "add_commit", "save_merge_request", "get_repository_file"):
+        assert f"`{tool}`" in prompt
+    assert "Create branch `jira/eng-1`" in prompt
+    assert conversation["body"]["title"] == "[ENG-1] Add a README"
+
+
+def test_a_cloud_run_asks_for_a_bitbucket_pull_request_when_the_provider_is_bitbucket(stub, run_script):
+    # Act
+    result = run_script(cloud_env(stub), {**MCP_CONFIG, "git_provider": "bitbucket"})
+
+    # Assert
+    assert result.returncode == 0, result.stderr
+    [conversation] = stub.find("POST", "/api/v1/app-conversations")
+    prompt = prompt_text(conversation)
+    assert prompt.startswith("Create a Bitbucket Pull Request for the following Jira issue.")
+    assert '"workspace/repo" format' in prompt
+    assert "https://bitbucket.org/<workspace>/<repo>" in prompt
+    assert "Print the PR URL" in prompt
+    assert "Merge Request" not in prompt
+    # Without a git credential the conversation delivers through Rovo's Bitbucket tools.
+    for tool in (
+        "createBitbucketRepoBranch",
+        "createBitbucketRepoCommit",
+        "createBitbucketRepoPullRequest",
+        "getBitbucketRepoFileContent",
+    ):
+        assert f"`{tool}`" in prompt
+
+
+def test_a_run_with_an_unknown_git_provider_fails_before_dispatching(stub, run_script):
+    # Act
+    result = run_script(cloud_env(stub), {**MCP_CONFIG, "git_provider": "gitea"})
+
+    # Assert
+    assert result.returncode == 1
+    assert stub.find("POST", "/api/v1/app-conversations") == []
+    [callback] = stub.find("POST", "/callback")
+    assert callback["body"]["status"] == "FAILED"
+    assert "git_provider" in callback["body"]["error"]
+    assert "gitea" in callback["body"]["error"]
+
+
+def test_a_local_run_cannot_reach_jira_through_a_connected_mcp_server(stub, run_script):
+    # Arrange
+    env = local_env(stub)
+
+    # Act
+    result = run_script(env, MCP_CONFIG)
+
+    # Assert
+    assert result.returncode == 1
+    assert stub.find("POST", "/api/conversations") == []
+    [callback] = stub.find("POST", "/callback")
+    assert callback["body"]["status"] == "FAILED"
+    assert "OpenHands Cloud or Enterprise" in callback["body"]["error"]
+
+
 def test_a_local_run_still_starts_conversations_on_the_agent_server(stub, run_script):
     # Arrange
     env = local_env(stub)